def __delete_snapshot(self, resource):
if 'snapshotParameters' not in self.data:
raise OneViewModuleResourceNotFound(self.MSG_NO_OPTIONS_PROVIDED)
snapshot = self.__get_snapshot_by_name(resource, self.data)
if not snapshot:
raise OneViewModuleResourceNotFound(self.MSG_SNAPSHOT_NOT_FOUND)
else:
self.resource_client.delete_snapshot(snapshot)
return dict(changed=True, msg=self.MSG_SNAPSHOT_DELETED)
def __delete_snapshot(self):
if 'snapshotParameters' not in self.data:
raise OneViewModuleResourceNotFound(self.MSG_NO_OPTIONS_PROVIDED)
snapshot_parameters = self.data['snapshotParameters']
snapshot = self.current_resource.get_snapshot_by_name(
snapshot_parameters['name'])
if not snapshot:
raise OneViewModuleResourceNotFound(self.MSG_SNAPSHOT_NOT_FOUND)
else:
snapshot.delete()
return dict(changed=True, msg=self.MSG_SNAPSHOT_DELETED)
def __update_resource_assignments(self, resource):
if not resource:
raise OneViewModuleResourceNotFound(self.MSG_RESOURCE_NOT_FOUND)
if self.oneview_client.api_version < 500:
scope = self.resource_client.update_resource_assignments(
resource['uri'], self.data.get('resourceAssignments'))
else:
add_resources = self.data.get('resourceAssignments').get(
'addedResourceUris') is not None
remove_resources = self.data.get('resourceAssignments').get(
'removedResourceUris') is not None
if add_resources:
scope = self.resource_client.patch(
resource['uri'], 'replace', '/addedResourceUris',
self.data.get('resourceAssignments').get(
'addedResourceUris'))
if remove_resources:
scope = self.resource_client.patch(
resource['uri'], 'replace', '/removedResourceUris',
self.data.get('resourceAssignments').get(
'removedResourceUris'))
if not add_resources and not remove_resources:
return dict(changed=False,
msg=self.MSG_RESOURCE_ASSIGNMENTS_NOT_UPDATED,
ansible_facts=dict(scope=resource))
return dict(changed=True,
msg=self.MSG_RESOURCE_ASSIGNMENTS_UPDATED,
ansible_facts=dict(scope=scope))
def __get_appliance_by_name(self, name):
appliance = self.oneview_client.os_deployment_servers.get_appliance_by_name(name)
if not appliance:
raise OneViewModuleResourceNotFound(self.MSG_APPLIANCE_NOT_FOUND.format(name))
return appliance['uri']
def execute_module(self):
resource = self.__get_by_name(self.data)
if self.state == 'present':
changed, msg, resource = self.__present(resource, self.data)
elif self.state == 'absent':
return self.resource_absent(resource, 'remove')
else:
if not resource:
raise OneViewModuleResourceNotFound(self.MSG_ENCLOSURE_NOT_FOUND)
if self.state == 'reconfigured':
changed, msg, resource = self.__reconfigure(resource)
elif self.state == 'refreshed':
changed, msg, resource = self.__refresh(resource, self.data)
elif self.state == 'support_data_collection_set':
changed, msg, resource = self.__support_data_collection_set(resource, self.data)
else:
changed, msg, resource = self.__patch(resource, self.data)
return dict(changed=changed,
msg=msg,
ansible_facts=dict(enclosure=resource))
def execute_module(self):
if self.state == 'present':
changed, msg, resource = self.__present()
elif self.state == 'absent':
return self.resource_absent('remove')
else:
if not self.current_resource:
raise OneViewModuleResourceNotFound(
self.MSG_ENCLOSURE_NOT_FOUND)
if self.state == 'reconfigured':
changed, msg, resource = self.__reconfigure()
elif self.state == 'refreshed':
changed, msg, resource = self.__refresh()
elif self.state == 'support_data_collection_set':
changed, msg, resource = self.__support_data_collection_set()
elif self.state == 'create_certificate_request':
changed, msg, resource = self.__create_certificate_request()
elif self.state == 'get_certificate_request':
changed, msg, resource = self.__get_certificate_request()
elif self.state == 'import_certificate_request':
changed, msg, resource = self.__import_certificate_request()
else:
changed, msg, resource = self.__patch()
return dict(changed=changed,
msg=msg,
ansible_facts=dict(enclosure=resource))
def __get_by_name(self, name):
sas_interconnects = self.resource_client.get_by('name', name)
if not sas_interconnects:
raise OneViewModuleResourceNotFound(self.MSG_NOT_FOUND)
return sas_interconnects[0]
def __get_build_plan_by_name(self, name):
build_plan = self.i3s_client.build_plans.get_by('name', name)
if build_plan:
return build_plan[0]
else:
raise OneViewModuleResourceNotFound(
self.MSG_BUILD_PLAN_WAS_NOT_FOUND)
def __create_snapshot(self, resource):
if 'snapshotParameters' not in self.data:
raise OneViewModuleResourceNotFound(self.MSG_NO_OPTIONS_PROVIDED)
self.resource_client.create_snapshot(resource['uri'],
self.data['snapshotParameters'])
return dict(changed=True, msg=self.MSG_SNAPSHOT_CREATED)
def __get_current_property_value(self, state_name, state):
property_name = state['path'].split('/')[1]
sub_property_name = state['path'].split('/')[-1]
if sub_property_name == property_name:
sub_property_name = None
if state_name == 'appliance_bays_powered_on':
sub_property_name = 'poweredOn'
filter_ = set(self.data.keys()) - set(["name"])
if filter_:
filter_ = filter_.pop()
property_current_value = None
if filter_:
sub_resource = None
if self.current_resource.data.get(property_name):
sub_resource = next(
(item for item in self.current_resource.data[property_name]
if str(item[filter_]) == str(self.data[filter_])), None)
if not sub_resource:
# Resource doesn't have that property or subproperty
raise OneViewModuleResourceNotFound(self.MSG_BAY_NOT_FOUND)
property_current_value = sub_resource.get(sub_property_name)
state['path'] = state['path'].format(**self.data)
else:
property_current_value = self.current_resource.data[property_name]
return property_current_value
def __get_interconnect_type_by_name(self, name):
i_type = self.oneview_client.interconnect_types.get_by('name', name)
if i_type:
return i_type[0]
else:
raise OneViewModuleResourceNotFound(
self.MSG_INTERCONNECT_TYPE_NOT_FOUND)
def __get_by_options(self, name):
if not self.current_resource:
raise OneViewModuleResourceNotFound(self.MSG_NOT_FOUND)
facts = dict(logical_interconnects=self.current_resource.data)
options = self.module.params["options"]
if options:
self.options = dict(
qos_aggregated_configuration=self.current_resource.
get_qos_aggregated_configuration,
snmp_configuration=self.current_resource.
get_snmp_configuration,
port_monitor=self.current_resource.get_port_monitor,
internal_vlans=self.current_resource.get_internal_vlans,
forwarding_information_base=self.current_resource.
get_forwarding_information_base,
firmware=self.current_resource.get_firmware,
unassigned_uplink_ports=self.current_resource.
get_unassigned_uplink_ports,
unassigned_ports=self.current_resource.get_unassigned_ports,
telemetry_configuration=self.current_resource.
get_telemetry_configuration,
ethernet_settings=self.current_resource.get_ethernet_settings,
)
options_facts = self.__get_options(options)
facts.update(options_facts)
return facts
def execute_module(self):
if self.state == 'present':
return self.__present()
elif self.state == 'multiple_servers_added':
changed, msg, ansible_facts = self.__add_multiple_rack_mount_servers()
else:
if not self.data.get('name'):
raise OneViewModuleValueError(self.MSG_MANDATORY_FIELD_MISSING.format("data.name"))
if self.state == 'absent':
return self.resource_absent(method='remove')
else:
if not self.current_resource:
raise OneViewModuleResourceNotFound(self.MSG_SERVER_HARDWARE_NOT_FOUND)
if self.state == 'power_state_set':
changed, msg, ansible_facts = self.__set_power_state()
elif self.state == 'refresh_state_set':
changed, msg, ansible_facts = self.__set_refresh_state()
elif self.state == 'ilo_firmware_version_updated':
changed, msg, ansible_facts = self.__update_mp_firmware_version()
elif self.state == 'environmental_configuration_set':
changed, msg, ansible_facts = self.__set_environmental_configuration()
else:
changed, msg, ansible_facts = self.__patch()
return dict(changed=changed,
msg=msg,
ansible_facts=ansible_facts)
def execute_module(self):
changed, msg, ansible_facts = False, '', {}
logical_enclosure = self.oneview_client.logical_enclosures.get_by_name(self.data['name'])
if self.state == 'present':
changed, msg, ansible_facts = self.__present(self.data, logical_enclosure)
elif self.state == 'absent':
changed, msg, ansible_facts = self.__absent(logical_enclosure)
else:
if not logical_enclosure:
raise OneViewModuleResourceNotFound(self.MSG_REQUIRED)
if self.state == 'firmware_updated':
changed, msg, ansible_facts = self.__update_firmware(self.data, logical_enclosure)
elif self.state == 'script_updated':
changed, msg, ansible_facts = self.__update_script(self.data, logical_enclosure)
elif self.state == 'dumped':
changed, msg, ansible_facts = self.__support_dump(self.data, logical_enclosure)
elif self.state == 'reconfigured':
changed, msg, ansible_facts = self.__reconfigure(logical_enclosure)
elif self.state == 'updated_from_group':
changed, msg, ansible_facts = self.__update_from_group(logical_enclosure)
return dict(changed=changed,
msg=msg,
ansible_facts=ansible_facts)
def __present(self, data, resource):
changed = False
msg = self.MSG_ALREADY_PRESENT
if not resource:
if self.oneview_client.api_version >= 500:
raise OneViewModuleResourceNotFound(self.MSG_RESOURCE_NOT_FOUND)
else:
resource = self.oneview_client.storage_pools.add(data)
changed = True
msg = self.MSG_CREATED
else:
merged_data = resource.copy()
merged_data.update(self.data)
if compare(resource, merged_data):
msg = self.MSG_ALREADY_PRESENT
else:
resource = self.resource_client.update(merged_data)
changed = True
msg = self.MSG_UPDATED
return dict(changed=changed,
msg=msg,
ansible_facts=dict(storage_pool=resource))
def __replace_logical_interconnect_name_by_uri(self):
if 'logicalInterconnectName' in self.data:
name = self.data.pop('logicalInterconnectName')
logical_interconnect = self.oneview_client.logical_interconnects.get_by_name(name)
if logical_interconnect:
self.data['logicalInterconnectUri'] = logical_interconnect['uri']
else:
raise OneViewModuleResourceNotFound(self.MSG_LOGICAL_INTERCONNECT_NOT_FOUND)
def __absent(self):
if self.oneview_client.api_version >= 500:
if self.current_resource:
raise OneViewModuleResourceNotFound(self.MSG_RESOURCE_FOUND)
else:
return dict(changed=False, msg=self.MSG_ALREADY_ABSENT, ansible_facts=dict(storage_pool=None))
else:
return self.resource_absent('remove')
def __resolve_log_interconnect_names(self, interconnectNames):
uris = []
for name in interconnectNames:
li = self.get_by_name(name)
if not li:
raise OneViewModuleResourceNotFound(self.MSG_NOT_FOUND)
uris.append(li['uri'])
return uris
def __replace_snmpv3_username_by_userid(self):
if self.data and self.data.get('userName'):
username = self.data.pop('userName', None)
result = self.oneview_client.appliance_device_snmp_v3_users.get_by('userName', username)
if result:
self.data['userId'] = result[0]['id']
else:
raise OneViewModuleResourceNotFound(self.MSG_USER_NOT_FOUND)
def __get_network_uri(self, network_name_or_uri):
if network_name_or_uri.startswith('/rest/ethernet-networks'):
return network_name_or_uri
else:
enet_network = self.__get_ethernet_network_by_name(network_name_or_uri)
if enet_network:
return enet_network['uri']
else:
raise OneViewModuleResourceNotFound(self.MSG_ETHERNET_NETWORK_NOT_FOUND + network_name_or_uri)
def __refresh(self, data, resource):
if not resource:
raise OneViewModuleResourceNotFound(
self.MSG_LOGICAL_SWITCH_NOT_FOUND)
else:
logical_switch = self.oneview_client.logical_switches.refresh(
resource['uri'])
return True, self.MSG_REFRESHED, dict(
logical_switch=logical_switch)
def __replace_group_name_by_uri(self, data):
if 'logicalSwitch' in data and 'logicalSwitchGroupName' in data['logicalSwitch']:
group_name = data['logicalSwitch']['logicalSwitchGroupName']
logical_switch_group = self.oneview_client.logical_switch_groups.get_by('name', group_name)
if logical_switch_group:
data['logicalSwitch'].pop('logicalSwitchGroupName')
data['logicalSwitch']['logicalSwitchGroupUri'] = logical_switch_group[0]['uri']
else:
raise OneViewModuleResourceNotFound(self.MSG_LOGICAL_SWITCH_GROUP_NOT_FOUND)
def __download_archive(self):
self.allbackups = self.resource_client.get_all_backups()
if len(self.allbackups) == 0:
raise OneViewModuleResourceNotFound(self.MSG_BACKUP_REQUIRED)
self.current_resource = self.resource_client.get_backup(
self.allbackups[0]['uri'])
self.current_resource.download_archive(
self.data['destinationFilePath'])
return False, self.MSG_ARCHIVE_DOWNLOADED, {}
def __extract_backup(self):
self.allbackups = self.resource_client.get_all_backups()
if len(self.allbackups) == 0:
raise OneViewModuleResourceNotFound(self.MSG_BACKUP_REQUIRED)
self.current_resource = self.resource_client.get_backup(
self.allbackups[0]['uri'])
resource = self.current_resource.extract_backup(self.data)
return True, self.MSG_BACKUP_EXTRACTED, dict(
artifact_bundle_deployment_group=resource)
def __get_server_profile_uri(self, server_profile):
if "/" in server_profile:
return server_profile
else:
profile = self.oneview_client.server_profiles.get_by_name(server_profile)
if profile:
return profile.data['uri']
else:
raise OneViewModuleResourceNotFound(self.PROFILE_NOT_FOUND)
def __get_network_uri(self, name, network_type):
if network_type == 'Ethernet':
network_name = self.oneview_client.ethernet_networks.get_by_name(
name)
else:
network_name = self.oneview_client.fc_networks.get_by_name(name)
if network_name:
return network_name.data['uri']
else:
raise OneViewModuleResourceNotFound(self.MSG_NETWORK_NOT_FOUND)
def __get_snmpv3_user_by_uri(self, snmpv3_user_name_or_uri):
if snmpv3_user_name_or_uri.startswith(
'/rest/appliance/snmpv3-trap-forwarding/users'):
return snmpv3_user_name_or_uri
else:
snmpv3_user = self.__get_snmpv3_user_by_username(
snmpv3_user_name_or_uri)
if snmpv3_user:
return snmpv3_user['uri']
else:
raise OneViewModuleResourceNotFound(self.MSG_USER_NOT_FOUND)
def __get_drive_enclosure(self, data):
name = data.get('name')
if not name:
raise OneViewModuleValueError(self.MSG_NAME_REQUIRED)
else:
result = self.oneview_client.drive_enclosures.get_by('name', name)
if not result:
raise OneViewModuleResourceNotFound(self.MSG_NOT_FOUND)
return result[0]
def __find_interconnect(self):
interconnect_ip = self.module.params['ip']
if not interconnect_ip and not self.module.params["name"]:
raise OneViewModuleValueError(self.MSG_MISSING_KEY)
if not self.current_resource and interconnect_ip:
interconnects = self.oneview_client.interconnects.get_by('interconnectIP', interconnect_ip) or []
if interconnects:
self.current_resource = self.resource_client.get_by_uri(interconnects[0]["uri"])
if not self.current_resource:
raise OneViewModuleResourceNotFound(self.MSG_INTERCONNECT_NOT_FOUND)
def execute_module(self):
resource = self.__get_by_name(self.data)
if not resource:
raise OneViewModuleResourceNotFound(self.MSG_NOT_FOUND)
changed, msg, ansible_facts = False, '', dict()
uri = resource['uri']
if self.state == 'compliant':
changed, msg, ansible_facts = self.__compliance(uri)
elif self.state == 'ethernet_settings_updated':
changed, msg, ansible_facts = self.__update_ethernet_settings(
resource, self.data)
elif self.state == 'internal_networks_updated':
changed, msg, ansible_facts = self.__update_internal_networks(
uri, self.data)
elif self.state == 'settings_updated':
changed, msg, ansible_facts = self.__update_settings(
resource, self.data)
elif self.state == 'forwarding_information_base_generated':
changed, msg, ansible_facts = self.__generate_forwarding_information_base(
uri)
elif self.state == 'qos_aggregated_configuration_updated':
changed, msg, ansible_facts = self.__update_qos_configuration(
uri, self.data)
elif self.state == 'snmp_configuration_updated':
changed, msg, ansible_facts = self.__update_snmp_configuration(
uri, self.data)
elif self.state == 'port_monitor_updated':
changed, msg, ansible_facts = self.__update_port_monitor(
uri, self.data)
elif self.state == 'configuration_updated':
changed, msg, ansible_facts = self.__update_configuration(uri)
elif self.state == 'firmware_installed':
changed, msg, ansible_facts = self.__install_firmware(
uri, self.data)
elif self.state == 'telemetry_configuration_updated':
changed, msg, ansible_facts = self.__update_telemetry_configuration(
resource, self.data)
elif self.state == 'scopes_updated':
changed, msg, ansible_facts = self.__update_scopes(
resource, self.data)
if ansible_facts:
result = dict(changed=changed,
msg=msg,
ansible_facts=ansible_facts)
else:
result = dict(changed=changed, msg=msg)
return result