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, resource):
changed = False
msg = ''
if not resource:
resource = self.oneview_client.users.create(self.data)
msg = self.MSG_CREATED
changed = True
else:
merged_data = resource.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, 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))
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 __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 __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)
if not compare(self.current_resource.data, merged_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 __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 __reserved_vlan_range_updated(self):
resource = self.get_by_name(self.data['name'])
if not resource:
raise OneViewModuleResourceNotFound(self.MSG_NOT_FOUND)
resource_vlan_range = resource.get('reservedVlanRange')
merged_data = resource_vlan_range.copy()
merged_data.update(self.data['reservedVlanRangeParameters'])
if compare(resource_vlan_range, merged_data):
return dict(changed=False, msg=self.MSG_ALREADY_PRESENT, ansible_facts=dict(fabric=resource))
else:
return self.__update_vlan_range(self.data, resource)
def __update(self, new_data, existent_resource):
if "newName" in new_data:
new_data["name"] = new_data["newName"]
del new_data["newName"]
merged_data = existent_resource.copy()
merged_data.update(new_data)
if not compare(existent_resource, merged_data):
existent_resource = self.oneview_client.logical_enclosures.update(merged_data)
return True, self.MSG_UPDATED, dict(logical_enclosure=existent_resource)
else:
return False, self.MSG_ALREADY_PRESENT, dict(logical_enclosure=existent_resource)
def __update_settings(self, resource, data):
self.__validate_settings(data)
ethernet_settings_merged = self.__merge_network_settings(
'ethernetSettings', resource, data)
fcoe_settings_merged = self.__merge_network_settings(
'fcoeSettings', resource, data)
if compare(resource['ethernetSettings'], ethernet_settings_merged) and \
compare(resource['fcoeSettings'], fcoe_settings_merged):
return False, self.MSG_NO_CHANGES_PROVIDED, dict(
logical_interconnect=resource)
else:
settings = {
'ethernetSettings': ethernet_settings_merged,
'fcoeSettings': fcoe_settings_merged
}
li = self.oneview_client.logical_interconnects.update_settings(
resource['uri'], settings)
return True, self.MSG_SETTINGS_UPDATED, dict(
logical_interconnect=li)
def __update_ethernet_settings(self, resource, data):
self.__validate_options('ethernetSettings', data)
ethernet_settings_merged = resource['ethernetSettings'].copy()
ethernet_settings_merged.update(data['ethernetSettings'])
if compare(resource['ethernetSettings'], ethernet_settings_merged):
return False, self.MSG_NO_CHANGES_PROVIDED, dict()
else:
li = self.oneview_client.logical_interconnects.update_ethernet_settings(
resource['uri'], ethernet_settings_merged)
return True, self.MSG_ETH_SETTINGS_UPDATED, dict(
logical_interconnect=li)
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_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_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_port_monitor(self, uri, data):
self.__validate_options('portMonitor', data)
monitor_config = self.__get_port_monitor_configuration(uri)
monitor_config_merged = self.__merge_options(data['portMonitor'],
monitor_config)
if compare(monitor_config_merged, monitor_config):
return False, self.MSG_NO_CHANGES_PROVIDED, None
else:
monitor_config_updated = self.oneview_client.logical_interconnects.update_port_monitor(
uri, monitor_config_merged)
result = dict(port_monitor=monitor_config_updated)
return True, self.MSG_PORT_MONITOR_UPDATED, result
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_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
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_connection_template(self, ethernet_network, bandwidth):
if 'connectionTemplateUri' not in ethernet_network:
return False, None
connection_template = self.oneview_client.connection_templates.get(ethernet_network['connectionTemplateUri'])
merged_data = connection_template.copy()
merged_data.update({'bandwidth': bandwidth})
if not compare(connection_template, merged_data):
connection_template = self.oneview_client.connection_templates.update(merged_data)
return True, connection_template
else:
return False, None
def __update(self):
if "newName" in self.data:
self.data["name"] = self.data.pop("newName")
self.current_resource = self.current_resource[0]
merged_rack_mounts = self.__mergeRackMounts()
merged_data = dict_merge(self.data, self.current_resource)
if "rackMounts" in merged_rack_mounts:
merged_data['rackMounts'] = merged_rack_mounts['rackMounts']
if not compare(self.current_resource, merged_data):
updated_response = self.resource_client.update(merged_data)
return True, self.MSG_UPDATED, dict(rack=updated_response)
else:
return False, self.MSG_ALREADY_PRESENT, dict(
rack=self.current_resource)
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):
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_NO_CHANGES_PROVIDED
else:
changed = True
self.current_resource.update(self.data)
msg = self.MSG_UPDATED
return dict(changed=changed,
msg=msg,
ansible_facts=dict(managed_san=self.current_resource.data))
def __update(self, data, resource):
if resource is None:
resource = self.__get_by_name(data['newName'])
data["name"] = data.pop("newName")
merged_data = resource.copy()
merged_data.update(data)
if not compare(resource, merged_data):
resource = self.i3s_client.artifact_bundles.update(merged_data)
changed = True
msg = self.MSG_UPDATED
else:
changed = False
msg = self.MSG_ALREADY_PRESENT
return changed, msg, dict(artifact_bundle=resource)
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_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 __update_qos_configuration(self, uri, data):
self.__validate_options('qosConfiguration', data)
qos_config = self.__get_qos_aggregated_configuration(uri)
qos_config_merged = self.__merge_options(data['qosConfiguration'],
qos_config)
if compare(qos_config_merged, qos_config):
return False, self.MSG_NO_CHANGES_PROVIDED, dict()
else:
qos_config_updated = self.oneview_client.logical_interconnects.update_qos_aggregated_configuration(
uri, qos_config_merged)
return True, self.MSG_QOS_UPDATED, dict(
qos_configuration=qos_config_updated)
def __update_snmp_configuration(self, uri, data):
self.__validate_options('snmpConfiguration', data)
snmp_config = self.__get_snmp_configuration(uri)
snmp_config_merged = self.__merge_options(data['snmpConfiguration'],
snmp_config)
if compare(snmp_config_merged, snmp_config):
return False, self.MSG_NO_CHANGES_PROVIDED, None
else:
snmp_config_updated = self.oneview_client.logical_interconnects.update_snmp_configuration(
uri, snmp_config_merged)
return True, self.MSG_SNMP_UPDATED, dict(
snmp_configuration=snmp_config_updated)
def __update(self, data, resource):
merged_data = resource.copy()
merged_data.update(data)
if compare(resource, merged_data):
changed = False
msg = self.MSG_NO_CHANGES_PROVIDED
else:
changed = True
resource = self.oneview_client.managed_sans.update(
resource['uri'], data)
msg = self.MSG_UPDATED
return dict(changed=changed,
msg=msg,
ansible_facts=dict(managed_san=resource))
def __update(self):
if "newName" in self.data:
self.data["name"] = self.data.pop("newName")
self.__create_vswitch_layout()
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, **self.facts_params)
return True, self.MSG_UPDATED, dict(
hypervisor_cluster_profile=self.current_resource.data)
else:
return False, self.MSG_ALREADY_PRESENT, dict(
hypervisor_cluster_profile=self.current_resource.data)
