def __present(self):
changed = False
msg = self.MSG_ALREADY_PRESENT
if not self.current_resource:
if self.oneview_client.api_version >= 500:
raise OneViewModuleResourceNotFound(
self.MSG_RESOURCE_NOT_FOUND)
else:
self.current_resource = self.resource_client.add(self.data)
changed = True
msg = self.MSG_CREATED
else:
merged_data = self.current_resource.data.copy()
merged_data.update(self.data)
if compare(self.current_resource.data, merged_data):
changed = False
msg = self.MSG_ALREADY_PRESENT
else:
self.current_resource.update(merged_data)
changed = True
msg = self.MSG_UPDATED
return dict(
changed=changed,
msg=msg,
ansible_facts=dict(storage_pool=self.current_resource.data))
def __update(self):
if "newName" in self.data:
new_resource = self.resource_client.get_by_name(
self.data["newName"])
if new_resource:
raise OneViewModuleValueError(self.MSG_NEW_NAME_INVALID)
self.data["name"] = self.data.pop("newName")
merged_data = self.current_resource.data.copy()
input_data = self.data.copy()
if input_data.get("properties"):
del input_data["properties"]
if input_data.get("templateUri"):
input_data["volumeTemplateUri"] = input_data.pop("templateUri")
merged_data.update(input_data)
if compare(self.current_resource.data, merged_data):
changed = False
msg = self.MSG_NO_CHANGES_PROVIDED
else:
changed = True
self.current_resource.update(merged_data)
msg = self.MSG_UPDATED
return dict(
changed=changed,
msg=msg,
ansible_facts=dict(storage_volume=self.current_resource.data))
def __present(self, resource, data):
self.__replace_names_by_uris(data)
changed = False
if "newName" in data:
data["name"] = data.pop("newName")
if not resource:
resource = self.oneview_client.os_deployment_servers.add(data)
changed = True
msg = self.MSG_CREATED
else:
appliance_uri = data.pop('applianceUri', '')
if appliance_uri:
data['primaryActiveAppliance'] = appliance_uri
merged_data = resource.copy()
merged_data.update(data)
if not compare(resource, merged_data):
resource = self.oneview_client.os_deployment_servers.update(
merged_data)
changed = True
msg = self.MSG_UPDATED
else:
msg = self.MSG_ALREADY_PRESENT
return dict(changed=changed,
msg=msg,
ansible_facts=dict(os_deployment_server=resource))
def __present(self):
server_template_name = self.data.pop('serverProfileTemplateName', '')
server_hardware_name = self.data.pop('serverHardwareName', '')
changed = False
created = False
ServerProfileReplaceNamesByUris().replace(self.oneview_client, self.data)
if server_hardware_name:
selected_server_hardware = self.__get_server_hardware_by_name(server_hardware_name)
if not selected_server_hardware:
raise OneViewModuleValueError(self.MSG_HARDWARE_NOT_FOUND.format(server_hardware_name))
self.data['serverHardwareUri'] = selected_server_hardware['uri']
if server_template_name:
self.server_template = self.server_profile_templates.get_by_name(server_template_name)
if not self.server_template:
raise OneViewModuleValueError(self.MSG_TEMPLATE_NOT_FOUND.format(server_template_name))
self.data['serverProfileTemplateUri'] = self.server_template.data['uri']
elif self.data.get('serverProfileTemplateUri'):
self.server_template = self.server_profile_templates.get_by_uri(self.data['serverProfileTemplateUri'])
if not self.current_resource:
self.current_resource = self.__create_profile()
changed = True
created = True
msg = self.MSG_CREATED
else:
# This allows unassigning a profile if a SH key is specifically passed in as None
if not self.auto_assign_server_hardware:
server_hardware_uri_exists = False
if 'serverHardwareUri' in self.module.params['data'].keys() or 'serverHardwareName' in self.module.params['data'].keys():
server_hardware_uri_exists = True
if self.data.get('serverHardwareUri') is None and server_hardware_uri_exists:
self.data['serverHardwareUri'] = None
# Auto assigns a Server Hardware to Server Profile if auto_assign_server_hardware is True and no SH uris/enclosure uri and bay exist
if not self.current_resource.data.get('serverHardwareUri') and not self.data.get('serverHardwareUri') and self.auto_assign_server_hardware \
and not self.current_resource.data.get('enclosureUri') and not self.current_resource.data.get('enclosureBay') \
and not self.data.get('enclosureUri') and not self.data.get('enclosureBay'):
self.data['serverHardwareUri'] = self._auto_assign_server_profile()
merged_data = ServerProfileMerger().merge_data(self.current_resource.data, self.data)
self.__validations_for_os_custom_attributes(merged_data, self.current_resource.data)
# removed the below fields as part of idempotency checks
updated_data = deepcopy(merged_data)
updated_data.pop('initialScopeUris', None)
if updated_data.get('firmware'):
updated_data['firmware'].pop('firmwareActivationType', None)
if not compare(self.current_resource.data, updated_data):
self.__update_server_profile(merged_data)
changed = True
msg = self.MSG_UPDATED
else:
msg = self.MSG_ALREADY_PRESENT
return created, changed, msg, self.current_resource.data
def __present(self, resource):
changed = False
msg = ''
if not resource:
resource = self.resource_client.create(self.data)
msg = self.MSG_CREATED
changed = True
else:
merged_data = resource.data.copy()
merged_data.update(self.data)
# remove password, it cannot be used in comparison
if 'password' in merged_data:
del merged_data['password']
if compare(resource.data, 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(user=resource.data))
def __present(self):
changed = False
msg = ''
if not self.current_resource:
if 'credentials' not in self.data:
raise OneViewModuleValueError(self.MSG_CREDENTIALS_MANDATORY)
if self.oneview_client.api_version < 500:
self.current_resource = self.resource_client.add(
self.data['credentials'])
else:
options = self.data['credentials'].copy()
options['family'] = self.data.get('family', None)
options['hostname'] = self.data.get('hostname', None)
self.current_resource = self.resource_client.add(options)
changed = True
msg = self.MSG_ADDED
else:
resource = deepcopy(self.current_resource.data)
data = self.data.copy()
merged_data = dict_merge(resource, data)
temp_list = []
merged_data_copy = deepcopy(merged_data)
if merged_data_copy.get('deviceSpecificAttributes') and merged_data_copy.get('deviceSpecificAttributes').get('discoveredPools') and \
merged_data_copy.get('deviceSpecificAttributes').get('managedPools'):
for discoveredPool in merged_data_copy[
'deviceSpecificAttributes']['discoveredPools']:
for managedPool in merged_data['deviceSpecificAttributes'][
'managedPools']:
if discoveredPool['name'] == managedPool['name']:
temp_list.append(discoveredPool)
merged_data['deviceSpecificAttributes'][
'discoveredPools'].remove(discoveredPool)
merged_data['deviceSpecificAttributes'][
'managedPools'] = temp_list
# remove password, it cannot be used in comparison
if 'credentials' in merged_data and 'password' in merged_data[
'credentials']:
del merged_data['credentials']['password']
if not compare(self.current_resource.data, merged_data):
# update the resource
self.current_resource.update(merged_data)
# if not changed:
changed = True
msg = self.MSG_UPDATED
else:
msg = self.MSG_ALREADY_PRESENT
return dict(
changed=changed,
msg=msg,
ansible_facts=dict(storage_system=self.current_resource.data))
def __update_settings(self):
self.__validate_settings(self.data)
ethernet_settings_merged = self.__merge_network_settings(
'ethernetSettings', self.current_resource.data, self.data)
fcoe_settings_merged = self.__merge_network_settings(
'fcoeSettings', self.current_resource.data, self.data)
if compare(self.current_resource.data['ethernetSettings'], ethernet_settings_merged) and \
compare(self.current_resource.data['fcoeSettings'], fcoe_settings_merged):
return False, self.MSG_NO_CHANGES_PROVIDED, dict(
logical_interconnect=self.current_resource.data)
else:
settings = {
'ethernetSettings': ethernet_settings_merged,
'fcoeSettings': fcoe_settings_merged
}
li = self.current_resource.update_settings(settings)
return True, self.MSG_SETTINGS_UPDATED, dict(
logical_interconnect=li)
def __set_environmental_configuration(self):
get_env_config = self.current_resource.get_environmental_configuration(
)
merged_env_config = dict_merge(
get_env_config, self.data['environmentalConfigurationData'])
if compare(get_env_config, merged_env_config):
return False, self.MSG_ALREADY_PRESENT, dict(
server_hardware=self.current_resource.data)
else:
resource = self.current_resource.update_environmental_configuration(
self.data['environmentalConfigurationData'])
return True, self.MSG_ENV_CONFIG_UPDATED, dict(
server_hardware=resource)
def __update_port_monitor(self):
self.__validate_options('portMonitor', self.data)
monitor_config = self.__get_port_monitor_configuration()
monitor_config_merged = self.__merge_options(self.data['portMonitor'],
monitor_config)
if compare(monitor_config_merged, monitor_config):
return False, self.MSG_NO_CHANGES_PROVIDED, None
else:
monitor_config_updated = self.current_resource.update_port_monitor(
monitor_config_merged)
result = dict(port_monitor=monitor_config_updated)
return True, self.MSG_PORT_MONITOR_UPDATED, result
def __update(self):
if "newName" in self.data:
self.data["name"] = self.data.pop("newName")
merged_data = self.current_resource.data.copy()
merged_data.update(self.data)
if not compare(self.current_resource.data, merged_data):
self.current_resource.update(merged_data)
return True, self.MSG_UPDATED, dict(
logical_enclosure=self.current_resource.data)
else:
return False, self.MSG_ALREADY_PRESENT, dict(
logical_enclosure=self.current_resource.data)
def __update_port_flap_settings(self):
self.__validate_options('portFlapProtection', self.data)
port_flap_config = self.current_resource.data['portFlapProtection']
port_flap_config_merged = self.__merge_options(
self.data['portFlapProtection'], port_flap_config)
if compare(port_flap_config_merged, port_flap_config):
return False, self.MSG_NO_CHANGES_PROVIDED, None
else:
port_flap_config_updated = self.current_resource.update_port_flap_settings(
port_flap_config_merged)
result = dict(port_flap_settings=port_flap_config_updated)
return True, self.MSG_PORT_FLAP_SETTINGS_UPDATED, result
def __update(self, data):
merged_data = ServerProfileMerger().merge_data(
self.current_resource.data, data)
equal = compare(merged_data, self.current_resource.data)
if equal:
msg = self.MSG_ALREADY_PRESENT
else:
self.current_resource.update(merged_data, **self.params)
msg = self.MSG_UPDATED
changed = not equal
return changed, msg, self.current_resource.data
def __update(self):
changed = False
existing_data = self.current_resource.data.copy()
updated_data = dict_merge(existing_data, self.data)
state_change, updated_data = self.__compare_resource_assignments(existing_data, updated_data)
if compare(self.current_resource.data, updated_data) and state_change is False:
msg = self.MSG_ALREADY_PRESENT
else:
self.current_resource.update(updated_data)
changed = True
msg = self.MSG_UPDATED
return changed, msg
def __update_ethernet_settings(self):
self.__validate_options('ethernetSettings', self.data)
ethernet_settings_merged = self.current_resource.data[
'ethernetSettings'].copy()
ethernet_settings_merged.update(self.data['ethernetSettings'])
if compare(self.current_resource.data['ethernetSettings'],
ethernet_settings_merged):
return False, self.MSG_NO_CHANGES_PROVIDED, dict()
else:
li = self.current_resource.update_ethernet_settings(
ethernet_settings_merged)
return True, self.MSG_ETH_SETTINGS_UPDATED, dict(
logical_interconnect=li)
def __update_qos_configuration(self):
self.__validate_options('qosConfiguration', self.data)
qos_config = self.__get_qos_aggregated_configuration()
qos_config_merged = self.__merge_options(self.data['qosConfiguration'],
qos_config)
if compare(qos_config_merged, qos_config):
return False, self.MSG_NO_CHANGES_PROVIDED, dict()
else:
qos_config_updated = self.current_resource.update_qos_aggregated_configuration(
qos_config_merged)
return True, self.MSG_QOS_UPDATED, dict(
qos_configuration=qos_config_updated)
def __update_igmp_settings(self):
self.__validate_options('igmpSettings', self.data)
igmp_settings = self.__get_igmp_settings()
igmp_settings_merged = self.__merge_options(self.data['igmpSettings'],
igmp_settings)
if compare(igmp_settings_merged, igmp_settings):
return False, self.MSG_NO_CHANGES_PROVIDED, None
else:
igmp_settings_updated = self.current_resource.update_igmp_settings(
igmp_settings_merged)
return True, self.MSG_IGMP_UPDATED, dict(
igmp_settings=igmp_settings_updated)
def __update_snmp_configuration(self):
self.__validate_options('snmpConfiguration', self.data)
snmp_config = self.__get_snmp_configuration()
snmp_config_merged = self.__merge_options(
self.data['snmpConfiguration'], snmp_config)
if compare(snmp_config_merged, snmp_config):
return False, self.MSG_NO_CHANGES_PROVIDED, None
else:
snmp_config_updated = self.current_resource.update_snmp_configuration(
snmp_config_merged)
return True, self.MSG_SNMP_UPDATED, dict(
snmp_configuration=snmp_config_updated)
def __update_connection_template(self, bandwidth):
if 'connectionTemplateUri' not in self.current_resource.data:
raise OneViewModuleResourceNotFound(
self.MSG_CONNECTION_TEMPLATE_NOT_FOUND)
connection_template = self.connection_templates.get_by_uri(
self.current_resource.data['connectionTemplateUri'])
merged_data = connection_template.data.copy()
merged_data.update({'bandwidth': bandwidth})
if not compare(connection_template.data, merged_data):
connection_template.update(merged_data)
return True, connection_template.data
else:
return False, connection_template.data
def __present(self):
resource_data = {}
self.current_resource = self.resource_client.get_all()
if self.current_resource:
resource_data = self.current_resource.data.copy()
merged_data = resource_data.copy()
merged_data.update(self.data)
if not compare(resource_data, merged_data):
self.current_resource = self.resource_client.create(self.data)
return True, self.MSG_CREATED, dict(
appliance_time_and_locale_configuration=self.current_resource.
data)
else:
return False, self.MSG_ALREADY_PRESENT, dict(
appliance_time_and_locale_configuration=self.current_resource.
data)
def __update(self, data):
merged_data = ServerProfileMerger().merge_data(
self.current_resource.data, data)
updated_data = deepcopy(merged_data)
updated_data.pop('initialScopeUris', None)
equal = compare(updated_data, self.current_resource.data)
if equal:
msg = self.MSG_ALREADY_PRESENT
else:
self.current_resource.update(merged_data, **self.params)
msg = self.MSG_UPDATED
changed = not equal
return changed, msg, self.current_resource.data
def __update_connection_template(self, bandwidth):
if 'connectionTemplateUri' not in self.current_resource.data:
return False, None
connection_template = self.connection_templates.get_by_uri(
self.current_resource.data['connectionTemplateUri'])
merged_data = connection_template.data.copy()
merged_data.update({'bandwidth': bandwidth})
if not compare(connection_template.data, merged_data):
connection_template.update(merged_data)
return True, connection_template.data
else:
return False, None
def _present(self):
if not self.current_resource:
return self.resource_present(fact_name='storage_volume_template')
else:
changed = False
merged_data = _update_dict_with_depth(
deepcopy(self.current_resource.data), self.data)
if compare(self.current_resource.data, merged_data):
msg = self.MSG_ALREADY_PRESENT
else:
self.current_resource.update(merged_data)
changed = True
msg = self.MSG_UPDATED
return dict(msg=msg,
changed=changed,
ansible_facts={
'storage_volume_template':
self.current_resource.data
})
def __present(self, data, resource):
changed = False
msg = ''
if "newName" in data:
data["name"] = data.pop("newName")
self.__replace_name_by_uris(data)
self.__check_present_consistency(data)
file_path = data.pop('localImageFilePath', None)
if not resource:
if data.get('osVolumeURI'):
resource = self.i3s_client.golden_images.create(data)
msg = self.MSG_CREATED
changed = True
elif file_path:
resource = self.i3s_client.golden_images.upload(file_path, data)
msg = self.MSG_UPLOADED
changed = True
else:
raise OneViewModuleValueError(self.MSG_MISSING_MANDATORY_ATTRIBUTES)
else:
merged_data = resource.copy()
merged_data.update(data)
if not compare(resource, merged_data):
resource = self.i3s_client.golden_images.update(merged_data)
changed = True
msg = self.MSG_UPDATED
else:
msg = self.MSG_ALREADY_PRESENT
return changed, msg, dict(golden_image=resource)
