def __attach_disks(self, entity):
disks_service = self._connection.system_service().disks_service()
for disk in self.param('disks'):
# If disk ID is not specified, find disk by name:
disk_id = disk.get('id')
if disk_id is None:
disk_id = getattr(
search_by_name(service=disks_service,
name=disk.get('name')), 'id', None)
# Attach disk to VM:
disk_attachments_service = self._service.service(
entity.id).disk_attachments_service()
if get_entity(disk_attachments_service.attachment_service(
disk_id)) is None:
if not self._module.check_mode:
disk_attachments_service.add(
otypes.DiskAttachment(
disk=otypes.Disk(id=disk_id, ),
active=disk.get('activate', True),
interface=otypes.DiskInterface(
disk.get('interface', 'virtio')),
bootable=disk.get('bootable', False),
))
self.changed = True
def restore_snapshot(module, vm_service, snapshots_service):
changed = False
snapshot_service = snapshots_service.snapshot_service(
module.params['snapshot_id'])
snapshot = get_entity(snapshot_service)
if snapshot is None:
raise Exception("Snapshot with id '%s' doesn't exist" %
module.params['snapshot_id'])
if snapshot.snapshot_status != otypes.SnapshotStatus.IN_PREVIEW:
if not module.check_mode:
snapshot_service.restore(
restore_memory=module.params.get('use_memory'), )
changed = True
else:
if not module.check_mode:
vm_service.commit_snapshot()
changed = True
if changed:
wait(
service=snapshot_service,
condition=lambda snap: snap.snapshot_status == otypes.
SnapshotStatus.OK,
wait=module.params['wait'],
timeout=module.params['timeout'],
)
return {
'changed': changed,
'id': snapshot.id if snapshot else None,
'snapshot': get_dict_of_struct(snapshot),
}
def remove_snapshot(module, vm_service, snapshots_service, snapshot_id=None):
changed = False
if not snapshot_id:
snapshot_id = module.params['snapshot_id']
snapshot = get_entity(
snapshots_service.snapshot_service(snapshot_id)
)
if snapshot:
snapshot_service = snapshots_service.snapshot_service(snapshot.id)
if not module.check_mode:
snapshot_service.remove()
changed = True
wait(
service=snapshot_service,
condition=lambda snapshot: snapshot is None,
wait=module.params['wait'],
timeout=module.params['timeout'],
)
return {
'changed': changed,
'id': snapshot.id if snapshot else None,
'snapshot': get_dict_of_struct(snapshot),
}
def create_snapshot(module, vm_service, snapshots_service):
changed = False
snapshot = get_entity(
snapshots_service.snapshot_service(module.params['snapshot_id'])
)
if snapshot is None:
if not module.check_mode:
snapshot = snapshots_service.add(
otypes.Snapshot(
description=module.params.get('description'),
persist_memorystate=module.params.get('use_memory'),
)
)
changed = True
wait(
service=snapshots_service.snapshot_service(snapshot.id),
condition=lambda snap: snap.snapshot_status == otypes.SnapshotStatus.OK,
wait=module.params['wait'],
timeout=module.params['timeout'],
)
return {
'changed': changed,
'id': snapshot.id,
'snapshot': get_dict_of_struct(snapshot),
}
def create_snapshot(module, vm_service, snapshots_service, connection):
changed = False
snapshot = get_entity(
snapshots_service.snapshot_service(module.params['snapshot_id']))
if snapshot is None:
if not module.check_mode:
disk_attachments_id = set(
get_disk_attachment(
disk,
vm_service.disk_attachments_service().list(),
connection).id for disk in module.params.get(
'disks')) if module.params.get('disks') else None
snapshot = snapshots_service.add(
otypes.Snapshot(
description=module.params.get('description'),
persist_memorystate=module.params.get('use_memory'),
disk_attachments=[
otypes.DiskAttachment(id=da_id)
for da_id in disk_attachments_id
] if disk_attachments_id else None))
changed = True
wait(
service=snapshots_service.snapshot_service(snapshot.id),
condition=lambda snap: snap.snapshot_status == otypes.
SnapshotStatus.OK,
wait=module.params['wait'],
timeout=module.params['timeout'],
)
return {
'changed': changed,
'id': snapshot.id,
'snapshot': get_dict_of_struct(snapshot),
}
def __init__(self, network_id, cluster_network, *args, **kwargs):
super(ClusterNetworksModule, self).__init__(*args, **kwargs)
self._network_id = network_id
self._cluster_network = cluster_network
self._old_usages = []
self._cluster_network_entity = get_entity(self._service.network_service(network_id))
if self._cluster_network_entity is not None:
self._old_usages = self._cluster_network_entity.usages
def _attached_sds_service(self, dc_name):
# Get data center object of the storage domain:
dcs_service = self._connection.system_service().data_centers_service()
# Search the data_center name, if it does not exist, try to search by guid.
dc = search_by_name(dcs_service, dc_name)
if dc is None:
dc = get_entity(dcs_service.service(dc_name))
if dc is None:
return None
dc_service = dcs_service.data_center_service(dc.id)
return dc_service.storage_domains_service()
def _attached_sds_service(self, dc_name):
# Get data center object of the storage domain:
dcs_service = self._connection.system_service().data_centers_service()
# Search the data_center name, if it does not exist, try to search by guid.
dc = search_by_name(dcs_service, dc_name)
if dc is None:
dc = get_entity(dcs_service.service(dc_name))
if dc is None:
return None
dc_service = dcs_service.data_center_service(dc.id)
return dc_service.storage_domains_service()
def has_update(self, nic_service):
update = False
bond = self._module.params['bond']
networks = self._module.params['networks']
labels = self._module.params['labels']
nic = get_entity(nic_service)
if nic is None:
return update
# Check if bond configuration should be updated:
if bond:
update = self.__compare_options(
get_bond_options(bond.get('mode'), bond.get('options')),
getattr(nic.bonding, 'options', []))
update = update or not equal(
sorted(bond.get('interfaces'))
if bond.get('interfaces') else None,
sorted(
get_link_name(self._connection, s)
for s in nic.bonding.slaves))
# Check if labels need to be updated on interface/bond:
if labels:
net_labels = nic_service.network_labels_service().list()
# If any lables which user passed aren't assigned, relabel the interface:
if sorted(labels) != sorted([lbl.id for lbl in net_labels]):
return True
if not networks:
return update
# Check if networks attachments configuration should be updated:
attachments_service = nic_service.network_attachments_service()
network_names = [network.get('name') for network in networks]
attachments = {}
for attachment in attachments_service.list():
name = get_link_name(self._connection, attachment.network)
if name in network_names:
attachments[name] = attachment
for network in networks:
attachment = attachments.get(network.get('name'))
# If attachment don't exists, we need to create it:
if attachment is None:
return True
self.update_address(attachments_service, attachment, network)
return update
def _maintenance(self, storage_domain):
attached_sd_service = self._attached_sd_service(storage_domain)
attached_sd = get_entity(attached_sd_service)
if attached_sd and attached_sd.status != sdstate.MAINTENANCE:
if not self._module.check_mode:
attached_sd_service.deactivate()
self.changed = True
wait(
service=attached_sd_service,
condition=lambda sd: sd.status == sdstate.MAINTENANCE,
wait=self.param('wait'),
timeout=self.param('timeout'),
)
def _maintenance(self, storage_domain):
attached_sd_service = self._attached_sd_service(storage_domain)
attached_sd = get_entity(attached_sd_service)
if attached_sd and attached_sd.status != sdstate.MAINTENANCE:
if not self._module.check_mode:
attached_sd_service.deactivate()
self.changed = True
wait(
service=attached_sd_service,
condition=lambda sd: sd.status == sdstate.MAINTENANCE,
wait=self.param('wait'),
timeout=self.param('timeout'),
)
def has_update(self, nic_service):
update = False
bond = self._module.params['bond']
networks = self._module.params['networks']
labels = self._module.params['labels']
nic = get_entity(nic_service)
if nic is None:
return update
# Check if bond configuration should be updated:
if bond:
update = not (equal(str(bond.get('mode')),
nic.bonding.options[0].value) and equal(
sorted(bond.get('interfaces'))
if bond.get('interfaces') else None,
sorted(
get_link_name(self._connection, s)
for s in nic.bonding.slaves)))
# Check if labels need to be updated on interface/bond:
if labels:
net_labels = nic_service.network_labels_service().list()
if sorted(labels) != sorted([lbl.id for lbl in net_labels]):
return True
if not networks:
return update
# Check if networks attachments configuration should be updated:
attachments_service = nic_service.network_attachments_service()
network_names = [network.get('name') for network in networks]
attachments = {}
for attachment in attachments_service.list():
name = get_link_name(self._connection, attachment.network)
if name in network_names:
attachments[name] = attachment
for network in networks:
attachment = attachments.get(network.get('name'))
# If attachment don't exsits, we need to create it:
if attachment is None:
return True
self.update_address(attachments_service, attachment, network)
return update
def post_create_check(self, sd_id):
storage_domain = self._service.service(sd_id).get()
self._service = self._attached_sds_service()
# If storage domain isn't attached, attach it:
attached_sd_service = self._service.service(storage_domain.id)
if get_entity(attached_sd_service) is None:
self._service.add(otypes.StorageDomain(id=storage_domain.id, ), )
self.changed = True
# Wait until storage domain is in maintenance:
wait(
service=attached_sd_service,
condition=lambda sd: sd.status == sdstate.ACTIVE,
wait=self._module.params['wait'],
timeout=self._module.params['timeout'],
)
def _unattach(self, storage_domain):
attached_sd_service = self._attached_sd_service(storage_domain)
attached_sd = get_entity(attached_sd_service)
if attached_sd and attached_sd.status == sdstate.MAINTENANCE:
if not self._module.check_mode:
# Detach the storage domain:
attached_sd_service.remove()
self.changed = True
# Wait until storage domain is detached:
wait(
service=attached_sd_service,
condition=lambda sd: sd is None,
wait=self.param('wait'),
timeout=self.param('timeout'),
)
def _unattach(self, storage_domain):
attached_sd_service = self._attached_sd_service(storage_domain)
attached_sd = get_entity(attached_sd_service)
if attached_sd and attached_sd.status == sdstate.MAINTENANCE:
if not self._module.check_mode:
# Detach the storage domain:
attached_sd_service.remove()
self.changed = True
# Wait until storage domain is detached:
wait(
service=attached_sd_service,
condition=lambda sd: sd is None,
wait=self.param('wait'),
timeout=self.param('timeout'),
)
def has_update(self, nic_service):
update = False
bond = self._module.params['bond']
networks = self._module.params['networks']
labels = self._module.params['labels']
nic = get_entity(nic_service)
if nic is None:
return update
# Check if bond configuration should be updated:
if bond:
update = self.__compare_options(get_bond_options(bond.get('mode'), bond.get('options')), getattr(nic.bonding, 'options', []))
update = update or not equal(
sorted(bond.get('interfaces')) if bond.get('interfaces') else None,
sorted(get_link_name(self._connection, s) for s in nic.bonding.slaves)
)
# Check if labels need to be updated on interface/bond:
if labels:
net_labels = nic_service.network_labels_service().list()
# If any lables which user passed aren't assigned, relabel the interface:
if sorted(labels) != sorted([lbl.id for lbl in net_labels]):
return True
if not networks:
return update
# Check if networks attachments configuration should be updated:
attachments_service = nic_service.network_attachments_service()
network_names = [network.get('name') for network in networks]
attachments = {}
for attachment in attachments_service.list():
name = get_link_name(self._connection, attachment.network)
if name in network_names:
attachments[name] = attachment
for network in networks:
attachment = attachments.get(network.get('name'))
# If attachment don't exists, we need to create it:
if attachment is None:
return True
self.update_address(attachments_service, attachment, network)
return update
def post_create_check(self, sd_id):
storage_domain = self._service.service(sd_id).get()
dc_name = self.param('data_center')
if not dc_name:
# Find the DC, where the storage resides:
dc_name = self._find_attached_datacenter_name(storage_domain.name)
self._service = self._attached_sds_service(dc_name)
# If storage domain isn't attached, attach it:
attached_sd_service = self._service.service(storage_domain.id)
if get_entity(attached_sd_service) is None:
self._service.add(otypes.StorageDomain(id=storage_domain.id, ), )
self.changed = True
# Wait until storage domain is in maintenance:
wait(
service=attached_sd_service,
condition=lambda sd: sd.status == sdstate.ACTIVE,
wait=self.param('wait'),
timeout=self.param('timeout'),
)
def has_update(self, nic_service):
update = False
bond = self._module.params['bond']
networks = self._module.params['networks']
nic = get_entity(nic_service)
if nic is None:
return update
# Check if bond configuration should be updated:
if bond:
update = not (
equal(str(bond.get('mode')), nic.bonding.options[0].value) and
equal(
sorted(bond.get('interfaces')) if bond.get('interfaces') else None,
sorted(get_link_name(self._connection, s) for s in nic.bonding.slaves)
)
)
if not networks:
return update
# Check if networks attachments configuration should be updated:
attachments_service = nic_service.network_attachments_service()
network_names = [network.get('name') for network in networks]
attachments = {}
for attachment in attachments_service.list():
name = get_link_name(self._connection, attachment.network)
if name in network_names:
attachments[name] = attachment
for network in networks:
attachment = attachments.get(network.get('name'))
# If attachment don't exsits, we need to create it:
if attachment is None:
return True
self.update_address(attachments_service, attachment, network)
return update
def control_state(sd_module):
sd = sd_module.search_entity()
if sd is None:
return
sd_service = sd_module._service.service(sd.id)
# In the case of no status returned, it's an attached storage domain.
# Redetermine the corresponding serivce and entity:
if sd.status is None:
sd_service = sd_module._attached_sd_service(sd)
sd = get_entity(sd_service)
if sd.status == sdstate.LOCKED:
wait(
service=sd_service,
condition=lambda sd: sd.status != sdstate.LOCKED,
fail_condition=failed_state,
)
if failed_state(sd):
raise Exception("Not possible to manage storage domain '%s'." %
sd.name)
elif sd.status == sdstate.ACTIVATING:
wait(
service=sd_service,
condition=lambda sd: sd.status == sdstate.ACTIVE,
fail_condition=failed_state,
)
elif sd.status == sdstate.DETACHING:
wait(
service=sd_service,
condition=lambda sd: sd.status == sdstate.UNATTACHED,
fail_condition=failed_state,
)
elif sd.status == sdstate.PREPARING_FOR_MAINTENANCE:
wait(
service=sd_service,
condition=lambda sd: sd.status == sdstate.MAINTENANCE,
fail_condition=failed_state,
)
def post_create_check(self, sd_id):
storage_domain = self._service.service(sd_id).get()
dc_name = self.param('data_center')
if not dc_name:
# Find the DC, where the storage resides:
dc_name = self._find_attached_datacenter_name(storage_domain.name)
self._service = self._attached_sds_service(dc_name)
# If storage domain isn't attached, attach it:
attached_sd_service = self._service.service(storage_domain.id)
if get_entity(attached_sd_service) is None:
self._service.add(
otypes.StorageDomain(
id=storage_domain.id,
),
)
self.changed = True
# Wait until storage domain is in maintenance:
wait(
service=attached_sd_service,
condition=lambda sd: sd.status == sdstate.ACTIVE,
wait=self.param('wait'),
timeout=self.param('timeout'),
)
