def __init__(self): self.argument_spec = netapp_utils.ontap_sf_host_argument_spec() self.argument_spec.update( dict(account_id=dict(required=True, type='str'), src_volume_id=dict(required=True, type='str'), dest_volume_name=dict(required=True, type='str'), src_snapshot_id=dict(required=True, type='str'))) self.module = AnsibleModule(argument_spec=self.argument_spec, supports_check_mode=True) input_params = self.module.params self.account_id = input_params['account_id'] self.src_volume_id = input_params['src_volume_id'] self.dest_volume_name = input_params['dest_volume_name'] self.src_snapshot_id = input_params['src_snapshot_id'] if HAS_SF_SDK is False: self.module.fail_json( msg="Unable to import the SolidFire Python SDK") else: self.sfe = netapp_utils.create_sf_connection(module=self.module) self.elementsw_helper = NaElementSWModule(self.sfe) # add telemetry attributes self.attributes = self.elementsw_helper.set_element_attributes( source='na_elementsw_snapshot_restore')
def __init__(self): self.argument_spec = netapp_utils.ontap_sf_host_argument_spec() self.argument_spec.update( dict( state=dict(required=True, choices=['present', 'absent']), name=dict(required=True, type='str'), flexvol_name=dict(type='str'), vserver=dict(required=True, type='str'), )) self.module = AnsibleModule(argument_spec=self.argument_spec, required_if=[('state', 'present', ['flexvol_name'])], supports_check_mode=True) p = self.module.params # set up state variables self.state = p['state'] self.name = p['name'] self.flexvol_name = p['flexvol_name'] self.vserver = p['vserver'] if HAS_NETAPP_LIB is False: self.module.fail_json( msg="the python NetApp-Lib module is required") else: self.server = netapp_utils.setup_ontap_zapi(module=self.module, vserver=self.vserver)
def __init__(self): self.argument_spec = netapp_utils.ontap_sf_host_argument_spec() self.argument_spec.update( dict(state=dict(required=False, type='str', choices=['present', 'absent'], default='present'), peer_addresses=dict(required=False, type='list'), passphrase=dict(required=False, type='str'), cluster_name=dict(required=False, type='str'))) self.module = AnsibleModule( argument_spec=self.argument_spec, required_together=['peer_addresses', 'passphrase'], required_if=[('state', 'absent', ['cluster_name'])], supports_check_mode=True) self.na_helper = NetAppModule() self.parameters = self.na_helper.set_parameters(self.module.params) if HAS_NETAPP_LIB is False: self.module.fail_json( msg="the python NetApp-Lib module is required") else: self.server = netapp_utils.setup_ontap_zapi(module=self.module)
def __init__(self): self.argument_spec = netapp_utils.ontap_sf_host_argument_spec() self.argument_spec.update( dict(state=dict(required=False, choices=['present', 'absent', 'clean'], default='present'), drive_id=dict(required=False, type='str'), node_id=dict(required=True, type='str'), force_during_upgrade=dict(required=False, type='bool'), force_during_bin_sync=dict(required=False, type='bool'))) self.module = AnsibleModule(argument_spec=self.argument_spec, supports_check_mode=True) input_params = self.module.params self.state = input_params['state'] self.drive_id = input_params['drive_id'] self.node_id = input_params['node_id'] self.force_during_upgrade = input_params['force_during_upgrade'] self.force_during_bin_sync = input_params['force_during_bin_sync'] if HAS_SF_SDK is False: self.module.fail_json( msg="Unable to import the SolidFire Python SDK") else: self.sfe = netapp_utils.create_sf_connection(module=self.module)
def __init__(self): self.argument_spec = netapp_utils.ontap_sf_host_argument_spec() self.argument_spec.update( dict(state=dict(required=True, choices=['present', 'absent']), name=dict(required=True, type='str'), disk_count=dict(required=False, type='int'), raid_type=dict( require=False, type='str', choices=['raid0', 'raid4', 'raid_dp', 'raid_tec'], default='raid_dp'))) self.module = AnsibleModule(argument_spec=self.argument_spec, required_if=[('state', 'present', ['disk_count'])], supports_check_mode=True) p = self.module.params # set up state variables self.state = p['state'] self.name = p['name'] self.disk_count = p['disk_count'] self.raid_type = p['raid_type'] if HAS_NETAPP_LIB is False: self.module.fail_json( msg="the python NetApp-Lib module is required") else: self.server = netapp_utils.setup_ontap_zapi(module=self.module)
def __init__(self): self.argument_spec = netapp_utils.ontap_sf_host_argument_spec() self.argument_spec.update(dict( state=dict(required=True, choices=['present', 'absent']), name=dict(required=True, type='str'), command_directory_name=dict(required=True, type='str'), access_level=dict(required=False, type='str', default='all', choices=['none', 'readonly', 'all']), vserver=dict(required=True, type='str'), )) self.module = AnsibleModule( argument_spec=self.argument_spec, supports_check_mode=True ) p = self.module.params # set up state variables self.state = p['state'] self.name = p['name'] self.command_directory_name = p['command_directory_name'] self.access_level = p['access_level'] self.vserver = p['vserver'] if HAS_NETAPP_LIB is False: self.module.fail_json(msg="the python NetApp-Lib module is required") else: self.server = netapp_utils.setup_ontap_zapi(module=self.module)
def __init__(self): self.argument_spec = netapp_utils.ontap_sf_host_argument_spec() self.argument_spec.update( dict( state=dict(type='str', choices=['present', 'absent'], default='present'), snmp_v3_enabled=dict(type='bool'), networks=dict(type='dict', options=dict(access=dict( type='str', choices=['ro', 'rw', 'rosys']), cidr=dict(type='int', default=None), community=dict(type='str', default=None), network=dict(type='str', default=None))), usm_users=dict( type='dict', options=dict( access=dict(type='str', choices=['rouser', 'rwuser', 'rosys']), name=dict(type='str', default=None), password=dict(type='str', default=None), passphrase=dict(type='str', default=None), secLevel=dict(type='str', choices=['auth', 'noauth', 'priv']))), )) self.module = AnsibleModule( argument_spec=self.argument_spec, required_if=[('state', 'present', ['snmp_v3_enabled']), ('snmp_v3_enabled', True, ['usm_users']), ('snmp_v3_enabled', False, ['networks'])], supports_check_mode=True) self.na_helper = NetAppModule() self.parameters = self.na_helper.set_parameters(self.module.params) if self.parameters.get('state') == "present": if self.parameters.get('usm_users') is not None: # Getting the configuration details to configure SNMP Version3 self.access_usm = self.parameters.get('usm_users')['access'] self.name = self.parameters.get('usm_users')['name'] self.password = self.parameters.get('usm_users')['password'] self.passphrase = self.parameters.get( 'usm_users')['passphrase'] self.secLevel = self.parameters.get('usm_users')['secLevel'] if self.parameters.get('networks') is not None: # Getting the configuration details to configure SNMP Version2 self.access_network = self.parameters.get('networks')['access'] self.cidr = self.parameters.get('networks')['cidr'] self.community = self.parameters.get('networks')['community'] self.network = self.parameters.get('networks')['network'] if HAS_SF_SDK is False: self.module.fail_json( msg="Unable to import the SolidFire Python SDK") else: self.sfe = netapp_utils.create_sf_connection(module=self.module)
def __init__(self): self.argument_spec = netapp_utils.ontap_sf_host_argument_spec() self.argument_spec.update( dict( state=dict(required=True, choices=['present', 'absent']), name=dict(required=True, type='str'), time_interval_days=dict(required=False, type='int', default=1), time_interval_hours=dict(required=False, type='int', default=0), time_interval_minutes=dict(required=False, type='int', default=0), paused=dict(required=False, type='bool'), recurring=dict(required=False, type='bool'), starting_date=dict(type='str'), snapshot_name=dict(required=False, type='str'), volumes=dict(required=False, type='list'), retention=dict(required=False, type='str'), schedule_id=dict(type='int'), )) self.module = AnsibleModule(argument_spec=self.argument_spec, required_if=[('state', 'present', ['starting_date', 'volumes'])], supports_check_mode=True) p = self.module.params # set up state variables self.state = p['state'] self.name = p['name'] # self.interval = p['interval'] self.time_interval_days = p['time_interval_days'] self.time_interval_hours = p['time_interval_hours'] self.time_interval_minutes = p['time_interval_minutes'] self.paused = p['paused'] self.recurring = p['recurring'] self.starting_date = p['starting_date'] if self.starting_date is not None: self.starting_date = self.starting_date.replace("--", "-") self.snapshot_name = p['snapshot_name'] self.volumes = p['volumes'] self.retention = p['retention'] self.schedule_id = p['schedule_id'] self.create_schedule_result = None if HAS_SF_SDK is False: self.module.fail_json( msg="Unable to import the SolidFire Python SDK") else: self.sfe = netapp_utils.create_sf_connection(module=self.module)
def __init__(self): self.argument_spec = netapp_utils.ontap_sf_host_argument_spec() self.argument_spec.update( dict( state=dict(required=True, choices=['present', 'absent']), name=dict(required=True, type='str'), account_id=dict(required=False, type='int', default=None), new_name=dict(required=False, type='str', default=None), initiator_secret=dict(required=False, type='str'), target_secret=dict(required=False, type='str'), attributes=dict(required=False, type='dict'), status=dict(required=False, type='str'), )) self.module = AnsibleModule(argument_spec=self.argument_spec, supports_check_mode=True) p = self.module.params # set up state variables self.state = p['state'] self.name = p['name'] self.account_id = p['account_id'] self.new_name = p['new_name'] self.initiator_secret = p['initiator_secret'] self.target_secret = p['target_secret'] self.attributes = p['attributes'] self.status = p['status'] if HAS_SF_SDK is False: self.module.fail_json( msg="Unable to import the SolidFire Python SDK") else: self.sfe = netapp_utils.create_sf_connection(module=self.module)
def __init__(self): self.argument_spec = netapp_utils.ontap_sf_host_argument_spec() self.argument_spec.update( dict( state=dict(required=True, choices=['present', 'absent']), name=dict(required=True, type='str'), command_directory_name=dict(required=True, type='str'), access_level=dict(required=False, type='str', default='all', choices=['none', 'readonly', 'all']), vserver=dict(required=True, type='str'), )) self.module = AnsibleModule(argument_spec=self.argument_spec, supports_check_mode=True) p = self.module.params # set up state variables self.state = p['state'] self.name = p['name'] self.command_directory_name = p['command_directory_name'] self.access_level = p['access_level'] self.vserver = p['vserver'] if HAS_NETAPP_LIB is False: self.module.fail_json( msg="the python NetApp-Lib module is required") else: self.server = netapp_utils.setup_ontap_zapi(module=self.module)
def __init__(self): self.argument_spec = netapp_utils.ontap_sf_host_argument_spec() self.argument_spec.update( dict( state=dict(required=True, choices=['present', 'absent']), name=dict(required=True, type='str'), root_volume=dict(type='str'), root_volume_aggregate=dict(type='str'), root_volume_security_style=dict( type='str', choices=['unix', 'ntfs', 'mixed', 'unified']), )) self.module = AnsibleModule(argument_spec=self.argument_spec, required_if=[('state', 'present', [ 'root_volume', 'root_volume_aggregate', 'root_volume_security_style' ])], supports_check_mode=True) p = self.module.params # set up state variables self.state = p['state'] self.name = p['name'] self.root_volume = p['root_volume'] self.root_volume_aggregate = p['root_volume_aggregate'] self.root_volume_security_style = p['root_volume_security_style'] if HAS_NETAPP_LIB is False: self.module.fail_json( msg="the python NetApp-Lib module is required") else: self.server = netapp_utils.setup_ontap_zapi(module=self.module)
def __init__(self): self.argument_spec = netapp_utils.ontap_sf_host_argument_spec() self.argument_spec.update( dict(state=dict(required=False, type='str', choices=['present', 'absent'], default='present'), vserver=dict(required=True, type='str'), peer_vserver=dict(required=True, type='str'), peer_cluster=dict(required=False, type='str'), applications=dict( required=False, type='list', choices=['snapmirror', 'file_copy', 'lun_copy']))) self.module = AnsibleModule(argument_spec=self.argument_spec, supports_check_mode=True) self.na_helper = NetAppModule() self.parameters = self.na_helper.set_parameters(self.module.params) if HAS_NETAPP_LIB is False: self.module.fail_json( msg="the python NetApp-Lib module is required") else: self.server = netapp_utils.setup_ontap_zapi(module=self.module)
def __init__(self): self.argument_spec = netapp_utils.ontap_sf_host_argument_spec() self.argument_spec.update(dict( state=dict(required=True, choices=['present', 'absent']), name=dict(required=True, type='str'), flexvol_name=dict(type='str'), vserver=dict(required=True, type='str'), )) self.module = AnsibleModule( argument_spec=self.argument_spec, required_if=[ ('state', 'present', ['flexvol_name']) ], supports_check_mode=True ) p = self.module.params # set up state variables self.state = p['state'] self.name = p['name'] self.flexvol_name = p['flexvol_name'] self.vserver = p['vserver'] if HAS_NETAPP_LIB is False: self.module.fail_json(msg="the python NetApp-Lib module is required") else: self.server = netapp_utils.setup_ontap_zapi(module=self.module, vserver=self.vserver)
def __init__(self): """ Initialize the NetAppElementSWAdminUser class. """ self.argument_spec = netapp_utils.ontap_sf_host_argument_spec() self.argument_spec.update( dict(state=dict(required=True, choices=['present', 'absent']), element_username=dict(required=True, type='str'), element_password=dict(required=False, type='str', no_log=True), acceptEula=dict(required=False, type='bool'), access=dict(required=False, type='list'))) self.module = AnsibleModule(argument_spec=self.argument_spec, supports_check_mode=True) param = self.module.params # set up state variables self.state = param['state'] self.element_username = param['element_username'] self.element_password = param['element_password'] self.acceptEula = param['acceptEula'] self.access = param['access'] if HAS_SF_SDK is False: self.module.fail_json( msg="Unable to import the SolidFire Python SDK") else: self.sfe = netapp_utils.create_sf_connection(module=self.module) self.elementsw_helper = NaElementSWModule(self.sfe) # add telemetry attributes self.attributes = self.elementsw_helper.set_element_attributes( source='na_elementsw_admin_users')
def __init__(self): """ Initializes the NetAppOntapVlan function """ self.argument_spec = netapp_utils.ontap_sf_host_argument_spec() self.argument_spec.update( dict( state=dict(required=False, choices=['present', 'absent'], default='present'), parent_interface=dict(required=True, type='str'), vlanid=dict(required=True, type='str'), node=dict(required=True, type='str'), )) self.module = AnsibleModule(argument_spec=self.argument_spec, supports_check_mode=True) p = self.module.params # set up state variables self.state = p['state'] self.parent_interface = p['parent_interface'] self.vlanid = p['vlanid'] self.node = p['node'] self.interface_name = str(p['parent_interface']) + '-' + str( self.vlanid) if HAS_NETAPP_LIB is False: self.module.fail_json( msg="the python NetApp-Lib module is required") else: self.server = netapp_utils.setup_ontap_zapi(module=self.module) return
def __init__(self): self.argument_spec = netapp_utils.ontap_sf_host_argument_spec() self.argument_spec.update( dict(state=dict(required=False, type='str', choices=['present', 'absent'], default='present'), node=dict(required=False, type='list'), package_version=dict(required=True, type='str'), package_url=dict(required=True, type='str'), ignore_validation_warning=dict(required=False, type='bool', default=False))) self.module = AnsibleModule(argument_spec=self.argument_spec, supports_check_mode=True) self.na_helper = NetAppModule() self.parameters = self.na_helper.set_parameters(self.module.params) if HAS_NETAPP_LIB is False: self.module.fail_json( msg="the python NetApp-Lib module is required") else: self.server = netapp_utils.setup_ontap_zapi(module=self.module)
def __init__(self): self.argument_spec = netapp_utils.ontap_sf_host_argument_spec() self.argument_spec.update(dict( modify_cluster_full_threshold=dict( type='dict', options=dict( stage2_aware_threshold=dict(type='int', default=None), stage3_block_threshold_percent=dict(type='int', default=None), max_metadata_over_provision_factor=dict(type='int', default=None) ) ), encryption_at_rest=dict(type='str', choices=['present', 'absent']), set_ntp_info=dict( type='dict', options=dict( broadcastclient=dict(type='bool', default=False), ntp_servers=dict(type='list') ) ), enable_virtual_volumes=dict(type='bool', default=True) )) self.module = AnsibleModule( argument_spec=self.argument_spec, supports_check_mode=True ) self.na_helper = NetAppModule() self.parameters = self.na_helper.set_parameters(self.module.params) if HAS_SF_SDK is False: self.module.fail_json(msg="Unable to import the SolidFire Python SDK") else: self.sfe = netapp_utils.create_sf_connection(module=self.module)
def __init__(self): self.argument_spec = netapp_utils.ontap_sf_host_argument_spec() self.argument_spec.update( dict(skip=dict(required=False, type='str', default=None, choices=['mvip', 'svip']), mvip=dict(required=False, type='str', default=None), svip=dict(required=False, type='str', default=None))) self.module = AnsibleModule(argument_spec=self.argument_spec, required_if=[('skip', 'svip', ['mvip']), ('skip', 'mvip', ['svip'])], supports_check_mode=True) self.na_helper = NetAppModule() self.parameters = self.module.params.copy() self.msg = "" if HAS_SF_SDK is False: self.module.fail_json( msg="Unable to import the ElementSW Python SDK") else: self.elem = netapp_utils.create_sf_connection(self.module, port=442)
def __init__(self): self.argument_spec = netapp_utils.ontap_sf_host_argument_spec() self.argument_spec.update(dict( serial_number=dict(required=False, type='str', default=None), remove_unused=dict(default=False, type='bool'), remove_expired=dict(default=False, type='bool'), licenses=dict(default=False, type='dict'), )) self.module = AnsibleModule( argument_spec=self.argument_spec, supports_check_mode=False ) p = self.module.params # set up state variables self.serial_number = p['serial_number'] self.remove_unused = p['remove_unused'] self.remove_expired = p['remove_expired'] self.licenses = p['licenses'] if HAS_NETAPP_LIB is False: self.module.fail_json(msg="the python NetApp-Lib module is required") else: self.server = netapp_utils.setup_ontap_zapi(module=self.module)
def __init__(self): self.argument_spec = netapp_utils.ontap_sf_host_argument_spec() self.argument_spec.update( dict( serial_number=dict(required=False, type='str', default=None), remove_unused=dict(default=False, type='bool'), remove_expired=dict(default=False, type='bool'), licenses=dict(default=False, type='dict'), )) self.module = AnsibleModule(argument_spec=self.argument_spec, supports_check_mode=False) p = self.module.params # set up state variables self.serial_number = p['serial_number'] self.remove_unused = p['remove_unused'] self.remove_expired = p['remove_expired'] self.licenses = p['licenses'] if HAS_NETAPP_LIB is False: self.module.fail_json( msg="the python NetApp-Lib module is required") else: self.server = netapp_utils.setup_ontap_zapi(module=self.module)
def __init__(self): self.argument_spec = netapp_utils.ontap_sf_host_argument_spec() self.argument_spec.update( dict(skip=dict(required=False, type='str', default=None, choices=['mvip', 'svip']), mvip=dict(required=False, type='str', default=None), svip=dict(required=False, type='str', default=None))) self.module = AnsibleModule(argument_spec=self.argument_spec, supports_check_mode=True) p = self.module.params # set up state variables self.skip = p['skip'] self.mvip = p['mvip'] self.svip = p['svip'] if HAS_SF_SDK is False: self.module.fail_json( msg="Unable to import the SolidFire Python SDK") else: self.sfe = netapp_utils.ElementFactory.create(p['hostname'], p['username'], p['password'], port=442)
def __init__(self): self._size_unit_map = dict(bytes=1, b=1, kb=1024, mb=1024**2, gb=1024**3, tb=1024**4, pb=1024**5, eb=1024**6, zb=1024**7, yb=1024**8) self.argument_spec = netapp_utils.ontap_sf_host_argument_spec() self.argument_spec.update( dict( state=dict(required=True, choices=['present', 'absent']), name=dict(required=True, type='str'), size=dict(type='int'), size_unit=dict(default='gb', choices=[ 'bytes', 'b', 'kb', 'mb', 'gb', 'tb', 'pb', 'eb', 'zb', 'yb' ], type='str'), force_resize=dict(default=False, type='bool'), force_remove=dict(default=False, type='bool'), force_remove_fenced=dict(default=False, type='bool'), flexvol_name=dict(type='str'), vserver=dict(required=True, type='str'), )) self.module = AnsibleModule(argument_spec=self.argument_spec, required_if=[('state', 'present', ['flexvol_name', 'size'])], supports_check_mode=True) p = self.module.params # set up state variables self.state = p['state'] self.name = p['name'] self.size_unit = p['size_unit'] if p['size'] is not None: self.size = p['size'] * self._size_unit_map[self.size_unit] else: self.size = None self.force_resize = p['force_resize'] self.force_remove = p['force_remove'] self.force_remove_fenced = p['force_remove_fenced'] self.flexvol_name = p['flexvol_name'] self.vserver = p['vserver'] if HAS_NETAPP_LIB is False: self.module.fail_json( msg="the python NetApp-Lib module is required") else: self.server = netapp_utils.setup_ontap_zapi(module=self.module, vserver=self.vserver)
def __init__(self): self.argument_spec = netapp_utils.ontap_sf_host_argument_spec() self.argument_spec.update( method=dict(type='str', required=True, choices=['loopback', 'manual', 'dhcp', 'static']), ip_address_1g=dict(type='str', required=True), ip_address_10g=dict(type='str', required=True), subnet_1g=dict(type='str', required=True), subnet_10g=dict(type='str', required=True), gateway_address_1g=dict(type='str', required=True), gateway_address_10g=dict(type='str', required=True), mtu_1g=dict(type='str', default='1500'), mtu_10g=dict(type='str', default='1500'), dns_nameservers=dict(type='list'), dns_search_domains=dict(type='list'), bond_mode_1g=dict(type='str', default='ActivePassive', choices=['ActivePassive', 'ALB', 'LACP']), bond_mode_10g=dict(type='str', default='ActivePassive', choices=['ActivePassive', 'ALB', 'LACP']), lacp_1g=dict(type='str', default='Slow', choices=['Fast', 'Slow']), lacp_10g=dict(type='str', default='Slow', choices=['Fast', 'Slow']), virtual_network_tag=dict(type='str'), ) self.module = AnsibleModule( argument_spec=self.argument_spec, supports_check_mode=True, ) input_params = self.module.params self.method = input_params['method'] self.ip_address_1g = input_params['ip_address_1g'] self.ip_address_10g = input_params['ip_address_10g'] self.subnet_1g = input_params['subnet_1g'] self.subnet_10g = input_params['subnet_10g'] self.gateway_address_1g = input_params['gateway_address_1g'] self.gateway_address_10g = input_params['gateway_address_10g'] self.mtu_1g = input_params['mtu_1g'] self.mtu_10g = input_params['mtu_10g'] self.dns_nameservers = input_params['dns_nameservers'] self.dns_search_domains = input_params['dns_search_domains'] self.bond_mode_1g = input_params['bond_mode_1g'] self.bond_mode_10g = input_params['bond_mode_10g'] self.lacp_1g = input_params['lacp_1g'] self.lacp_10g = input_params['lacp_10g'] self.virtual_network_tag = input_params['virtual_network_tag'] if HAS_SF_SDK is False: self.module.fail_json( msg="Unable to import the SolidFire Python SDK") else: self.sfe = netapp_utils.create_sf_connection(module=self.module, port=442)
def __init__(self): self._size_unit_map = dict( bytes=1, b=1, kb=1024, mb=1024 ** 2, gb=1024 ** 3, tb=1024 ** 4, pb=1024 ** 5, eb=1024 ** 6, zb=1024 ** 7, yb=1024 ** 8 ) self.argument_spec = netapp_utils.ontap_sf_host_argument_spec() self.argument_spec.update(dict( state=dict(required=True, choices=['present', 'absent']), name=dict(required=True, type='str'), size=dict(type='int'), size_unit=dict(default='gb', choices=['bytes', 'b', 'kb', 'mb', 'gb', 'tb', 'pb', 'eb', 'zb', 'yb'], type='str'), force_resize=dict(default=False, type='bool'), force_remove=dict(default=False, type='bool'), force_remove_fenced=dict(default=False, type='bool'), flexvol_name=dict(type='str'), vserver=dict(required=True, type='str'), )) self.module = AnsibleModule( argument_spec=self.argument_spec, required_if=[ ('state', 'present', ['flexvol_name', 'size']) ], supports_check_mode=True ) p = self.module.params # set up state variables self.state = p['state'] self.name = p['name'] self.size_unit = p['size_unit'] if p['size'] is not None: self.size = p['size'] * self._size_unit_map[self.size_unit] else: self.size = None self.force_resize = p['force_resize'] self.force_remove = p['force_remove'] self.force_remove_fenced = p['force_remove_fenced'] self.flexvol_name = p['flexvol_name'] self.vserver = p['vserver'] if HAS_NETAPP_LIB is False: self.module.fail_json(msg="the python NetApp-Lib module is required") else: self.server = netapp_utils.setup_ontap_zapi(module=self.module, vserver=self.vserver)
def __init__(self): self._size_unit_map = netapp_utils.SF_BYTE_MAP self.argument_spec = netapp_utils.ontap_sf_host_argument_spec() self.argument_spec.update( dict( state=dict(required=True, choices=['present', 'absent']), name=dict(required=True, type='str'), account_id=dict(required=True, type='int'), enable512e=dict(type='bool', aliases=['512emulation']), qos=dict(required=False, type='dict', default=None), attributes=dict(required=False, type='dict', default=None), volume_id=dict(type='int', default=None), size=dict(type='int'), size_unit=dict(default='gb', choices=[ 'bytes', 'b', 'kb', 'mb', 'gb', 'tb', 'pb', 'eb', 'zb', 'yb' ], type='str'), access=dict(required=False, type='str', default=None, choices=[ 'readOnly', 'readWrite', 'locked', 'replicationTarget' ]), )) self.module = AnsibleModule(argument_spec=self.argument_spec, required_if=[('state', 'present', ['size', 'enable512e'])], supports_check_mode=True) p = self.module.params # set up state variables self.state = p['state'] self.name = p['name'] self.account_id = p['account_id'] self.enable512e = p['enable512e'] self.qos = p['qos'] self.attributes = p['attributes'] self.volume_id = p['volume_id'] self.size_unit = p['size_unit'] if p['size'] is not None: self.size = p['size'] * self._size_unit_map[self.size_unit] else: self.size = None self.access = p['access'] if HAS_SF_SDK is False: self.module.fail_json( msg="Unable to import the SolidFire Python SDK") else: self.sfe = netapp_utils.create_sf_connection(module=self.module)
def __init__(self): self.argument_spec = netapp_utils.ontap_sf_host_argument_spec() self.argument_spec.update( dict( state=dict(required=True, choices=['present', 'absent']), src_access_group_id=dict(required=False, type='str'), new_name=dict(required=False, type='str'), initiators=dict(required=False, type='list'), volumes=dict(required=False, type='list'), virtual_network_id=dict(required=False, type='list'), virtual_network_tags=dict(required=False, type='list'), attributes=dict(required=False, type='dict'), )) self.module = AnsibleModule(argument_spec=self.argument_spec, supports_check_mode=True) input_params = self.module.params # Set up state variables self.state = input_params['state'] self.src_access_group_id = input_params['src_access_group_id'] self.new_name = input_params['new_name'] self.initiators = input_params['initiators'] self.volumes = input_params['volumes'] self.virtual_network_id = input_params['virtual_network_id'] self.virtual_network_tags = input_params['virtual_network_tags'] self.attributes = input_params['attributes'] if self.state == "absent" and self.src_access_group_id is None: self.module.fail_json( msg= "For delete operation, src_access_group_id parameter is required" ) if self.state == 'present' and self.new_name is None and self.src_access_group_id is None: self.module.fail_json( msg= "new_name parameter or src_access_group is required parameter") if HAS_SF_SDK is False: self.module.fail_json( msg="Unable to import the SolidFire Python SDK") else: self.sfe = netapp_utils.create_sf_connection(module=self.module) self.elementsw_helper = NaElementSWModule(self.sfe) # add telemetry attributes if self.attributes is not None: self.attributes.update( self.elementsw_helper.set_element_attributes( source='na_elementsw_access_group')) else: self.attributes = self.elementsw_helper.set_element_attributes( source='na_elementsw_access_group')
def __init__(self): self.argument_spec = netapp_utils.ontap_sf_host_argument_spec() self.argument_spec.update( dict(state=dict(required=False, choices=['present', 'absent'], default='present'), account_id=dict(required=True, type='str'), name=dict(required=False, type='str'), src_volume_id=dict(required=True, type='str'), retention=dict(required=False, type='str'), src_snapshot_id=dict(required=False, type='str'), enable_remote_replication=dict(required=False, type='bool'), expiration_time=dict(required=False, type='str'), snap_mirror_label=dict(required=False, type='str'))) self.module = AnsibleModule(argument_spec=self.argument_spec, supports_check_mode=True) input_params = self.module.params self.state = input_params['state'] self.name = input_params['name'] self.account_id = input_params['account_id'] self.src_volume_id = input_params['src_volume_id'] self.src_snapshot_id = input_params['src_snapshot_id'] self.retention = input_params['retention'] self.properties_provided = False self.expiration_time = input_params['expiration_time'] if input_params['expiration_time'] is not None: self.properties_provided = True self.enable_remote_replication = input_params[ 'enable_remote_replication'] if input_params['enable_remote_replication'] is not None: self.properties_provided = True self.snap_mirror_label = input_params['snap_mirror_label'] if input_params['snap_mirror_label'] is not None: self.properties_provided = True if self.state == 'absent' and self.src_snapshot_id is None: self.module.fail_json( msg="Please provide required parameter : snapshot_id") if HAS_SF_SDK is False: self.module.fail_json( msg="Unable to import the SolidFire Python SDK") else: self.sfe = netapp_utils.create_sf_connection(module=self.module) self.elementsw_helper = NaElementSWModule(self.sfe) # add telemetry attributes self.attributes = self.elementsw_helper.set_element_attributes( source='na_elementsw_snapshot')
def __init__(self): self.argument_spec = netapp_utils.ontap_sf_host_argument_spec() self.argument_spec.update( dict(management_virtual_ip=dict(required=True, type='str'), storage_virtual_ip=dict(required=True, type='str'), replica_count=dict(required=False, type='str', default='2'), cluster_admin_username=dict(required=False, type='str'), cluster_admin_password=dict(required=False, type='str', no_log=True), accept_eula=dict(required=True, type='bool'), nodes=dict(required=False, type=list, default=None), attributes=dict(required=False, type=list, default=None))) self.module = AnsibleModule(argument_spec=self.argument_spec, supports_check_mode=True) input_params = self.module.params self.management_virtual_ip = input_params['management_virtual_ip'] self.storage_virtual_ip = input_params['storage_virtual_ip'] self.replica_count = input_params['replica_count'] self.accept_eula = input_params['accept_eula'] self.attributes = input_params['attributes'] self.nodes = input_params['nodes'] if input_params['cluster_admin_username'] is None: self.cluster_admin_username = self.username else: self.cluster_admin_username = input_params[ 'cluster_admin_username'] if input_params['cluster_admin_password']: self.cluster_admin_password = self.password else: self.cluster_admin_password = input_params[ 'cluster_admin_password'] if HAS_SF_SDK is False: self.module.fail_json( msg="Unable to import the SolidFire Python SDK") else: self.sfe = netapp_utils.create_sf_connection(module=self.module, port=442) self.elementsw_helper = NaElementSWModule(self.sfe) # add telemetry attributes if self.attributes is not None: self.attributes.update( self.elementsw_helper.set_element_attributes( source='na_elementsw_cluster')) else: self.attributes = self.elementsw_helper.set_element_attributes( source='na_elementsw_cluster')
def __init__(self): self._size_unit_map = netapp_utils.SF_BYTE_MAP self.argument_spec = netapp_utils.ontap_sf_host_argument_spec() self.argument_spec.update(dict( state=dict(required=True, choices=['present', 'absent']), name=dict(required=True, type='str'), account_id=dict(required=True, type='int'), enable512e=dict(type='bool', aliases=['512emulation']), qos=dict(required=False, type='dict', default=None), attributes=dict(required=False, type='dict', default=None), volume_id=dict(type='int', default=None), size=dict(type='int'), size_unit=dict(default='gb', choices=['bytes', 'b', 'kb', 'mb', 'gb', 'tb', 'pb', 'eb', 'zb', 'yb'], type='str'), access=dict(required=False, type='str', default=None, choices=['readOnly', 'readWrite', 'locked', 'replicationTarget']), )) self.module = AnsibleModule( argument_spec=self.argument_spec, required_if=[ ('state', 'present', ['size', 'enable512e']) ], supports_check_mode=True ) p = self.module.params # set up state variables self.state = p['state'] self.name = p['name'] self.account_id = p['account_id'] self.enable512e = p['enable512e'] self.qos = p['qos'] self.attributes = p['attributes'] self.volume_id = p['volume_id'] self.size_unit = p['size_unit'] if p['size'] is not None: self.size = p['size'] * self._size_unit_map[self.size_unit] else: self.size = None self.access = p['access'] if HAS_SF_SDK is False: self.module.fail_json(msg="Unable to import the SolidFire Python SDK") else: self.sfe = netapp_utils.create_sf_connection(module=self.module)
def main(): argument_spec = netapp_utils.ontap_sf_host_argument_spec() required_if = netapp_utils.ontap_sf_host_argument_required_if() argument_spec.update(dict(state=dict(default='info', choices=['info']), )) module = AnsibleModule(argument_spec=argument_spec, required_if=required_if, supports_check_mode=True) state = module.params['state'] v = NetAppGatherFacts(module) g = v.get_all() result = {'state': state, 'changed': False, 'netapp_info': g} module.exit_json(**result)
def __init__(self): """ Setup Ansible parameters and SolidFire connection """ self.argument_spec = netapp_utils.ontap_sf_host_argument_spec() self.argument_spec.update(dict( src_volume_id=dict(aliases=['volume_id'], required=True, type='str'), dest_hostname=dict(required=False, type='str'), dest_username=dict(required=False, type='str'), dest_password=dict(required=False, type='str', no_log=True), dest_volume_id=dict(required=True, type='str'), format=dict(required=False, choices=['native', 'uncompressed'], default='native'), script=dict(required=False, type='str'), script_parameters=dict(required=False, type='dict') )) self.module = AnsibleModule( argument_spec=self.argument_spec, required_together=[['script', 'script_parameters']], supports_check_mode=True ) if HAS_SF_SDK is False: self.module.fail_json(msg="Unable to import the SolidFire Python SDK") # If destination cluster details are not specified , set the destination to be the same as the source if self.module.params["dest_hostname"] is None: self.module.params["dest_hostname"] = self.module.params["hostname"] if self.module.params["dest_username"] is None: self.module.params["dest_username"] = self.module.params["username"] if self.module.params["dest_password"] is None: self.module.params["dest_password"] = self.module.params["password"] params = self.module.params # establish a connection to both source and destination elementsw clusters self.src_connection = netapp_utils.create_sf_connection(self.module) self.module.params["username"] = params["dest_username"] self.module.params["password"] = params["dest_password"] self.module.params["hostname"] = params["dest_hostname"] self.dest_connection = netapp_utils.create_sf_connection(self.module) self.elementsw_helper = NaElementSWModule(self.src_connection) # add telemetry attributes self.attributes = self.elementsw_helper.set_element_attributes(source='na_elementsw_backup')
def __init__(self): self.argument_spec = netapp_utils.ontap_sf_host_argument_spec() self.argument_spec.update( dict( state=dict(required=True, choices=['present', 'absent']), element_username=dict(required=True, type='str'), account_id=dict(required=False, type='int', default=None), new_element_username=dict(required=False, type='str', default=None), initiator_secret=dict(required=False, type='str'), target_secret=dict(required=False, type='str'), attributes=dict(required=False, type='dict'), status=dict(required=False, type='str'), )) self.module = AnsibleModule(argument_spec=self.argument_spec, supports_check_mode=True) params = self.module.params # set up state variables self.state = params['state'] self.element_username = params['element_username'] self.account_id = params['account_id'] self.new_element_username = params['new_element_username'] self.initiator_secret = params['initiator_secret'] self.target_secret = params['target_secret'] self.attributes = params['attributes'] self.status = params['status'] if HAS_SF_SDK is False: self.module.fail_json( msg="Unable to import the Element SW Python SDK") else: self.sfe = netapp_utils.create_sf_connection(module=self.module) self.elementsw_helper = NaElementSWModule(self.sfe) # add telemetry attributes if self.attributes is not None: self.attributes.update( self.elementsw_helper.set_element_attributes( source='na_elementsw_account')) else: self.attributes = self.elementsw_helper.set_element_attributes( source='na_elementsw_account')
def __init__(self): self.argument_spec = netapp_utils.ontap_sf_host_argument_spec() self.argument_spec.update( dict( state=dict(required=True, choices=['present', 'absent']), name=dict(required=True, type='str'), application=dict(required=True, type='str', choices=[ 'console', 'http', 'ontapi', 'rsh', 'snmp', 'sp', 'ssh', 'telnet' ]), authentication_method=dict(required=True, type='str', choices=[ 'community', 'password', 'publickey', 'domain', 'nsswitch', 'usm' ]), set_password=dict(required=False, type='str', default=None), role_name=dict(required=False, type='str'), vserver=dict(required=True, type='str'), )) self.module = AnsibleModule(argument_spec=self.argument_spec, required_if=[('state', 'present', ['role_name'])], supports_check_mode=True) p = self.module.params # set up state variables self.state = p['state'] self.name = p['name'] self.application = p['application'] self.authentication_method = p['authentication_method'] self.set_password = p['set_password'] self.role_name = p['role_name'] self.vserver = p['vserver'] if HAS_NETAPP_LIB is False: self.module.fail_json( msg="the python NetApp-Lib module is required") else: self.server = netapp_utils.setup_ontap_zapi(module=self.module)
def __init__(self): self.argument_spec = netapp_utils.ontap_sf_host_argument_spec() self.argument_spec.update( dict(state=dict(required=False, type='str', choices=['present', 'absent'], default='present'), source_intercluster_lif=dict(required=False, type='str'), dest_intercluster_lif=dict(required=False, type='str'), passphrase=dict(required=False, type='str', no_log=True), dest_hostname=dict(required=True, type='str'), dest_username=dict(required=False, type='str'), dest_password=dict(required=False, type='str', no_log=True), source_cluster_name=dict(required=False, type='str'), dest_cluster_name=dict(required=False, type='str'))) self.module = AnsibleModule(argument_spec=self.argument_spec, required_together=[[ 'source_intercluster_lif', 'dest_intercluster_lif', 'passphrase' ]], required_if=[('state', 'absent', [ 'source_cluster_name', 'dest_cluster_name' ])], supports_check_mode=True) self.na_helper = NetAppModule() self.parameters = self.na_helper.set_parameters(self.module.params) if HAS_NETAPP_LIB is False: self.module.fail_json( msg="the python NetApp-Lib module is required") else: self.server = netapp_utils.setup_ontap_zapi(module=self.module) # set destination server connection self.module.params['hostname'] = self.parameters['dest_hostname'] if self.parameters.get('dest_username'): self.module.params['username'] = self.parameters[ 'dest_username'] if self.parameters.get('dest_password'): self.module.params['password'] = self.parameters[ 'dest_password'] self.dest_server = netapp_utils.setup_ontap_zapi( module=self.module)
def __init__(self): self.argument_spec = netapp_utils.ontap_sf_host_argument_spec() self.argument_spec.update( dict(state=dict(required=True, choices=['present', 'absent']), authType=dict(required=False, choices=['DirectBind', 'SearchAndBind']), groupSearchBaseDn=dict(required=False, type=str), groupSearchType=dict( required=False, choices=['NoGroup', 'ActiveDirectory', 'MemberDN']), serverURIs=dict(required=False, type=str), userSearchBaseDN=dict(required=False, type=str), searchBindDN=dict(required=False, type=str), searchBindPassword=dict(required=False, type=str, no_log=True), userSearchFilter=dict(required=False, type=str), userDNTemplate=dict(required=False, type=str), groupSearchCustomFilter=dict(required=False, type=str))) self.module = AnsibleModule(argument_spec=self.argument_spec, supports_check_mode=True) param = self.module.params # set up state variables self.state = param['state'] self.authType = param['authType'] self.groupSearchBaseDn = param['groupSearchBaseDn'] self.groupSearchType = param['groupSearchType'] self.serverURIs = param['serverURIs'] if self.serverURIs is not None: self.serverURIs = self.serverURIs.split(',') self.userSearchBaseDN = param['userSearchBaseDN'] self.searchBindDN = param['searchBindDN'] self.searchBindPassword = param['searchBindPassword'] self.userSearchFilter = param['userSearchFilter'] self.userDNTemplate = param['userDNTemplate'] self.groupSearchCustomFilter = param['groupSearchCustomFilter'] if HAS_SF_SDK is False: self.module.fail_json( msg="Unable to import the SolidFire Python SDK") else: self.sfe = netapp_utils.create_sf_connection(module=self.module)
def __init__(self): self.argument_spec = netapp_utils.ontap_sf_host_argument_spec() self.argument_spec.update(dict( state=dict(required=True, choices=['present', 'absent']), name=dict(required=True, type='str'), application=dict(required=True, type='str', choices=[ 'console', 'http', 'ontapi', 'rsh', 'snmp', 'sp', 'ssh', 'telnet']), authentication_method=dict(required=True, type='str', choices=['community', 'password', 'publickey', 'domain', 'nsswitch', 'usm']), set_password=dict(required=False, type='str', default=None), role_name=dict(required=False, type='str'), vserver=dict(required=True, type='str'), )) self.module = AnsibleModule( argument_spec=self.argument_spec, required_if=[ ('state', 'present', ['role_name']) ], supports_check_mode=True ) p = self.module.params # set up state variables self.state = p['state'] self.name = p['name'] self.application = p['application'] self.authentication_method = p['authentication_method'] self.set_password = p['set_password'] self.role_name = p['role_name'] self.vserver = p['vserver'] if HAS_NETAPP_LIB is False: self.module.fail_json(msg="the python NetApp-Lib module is required") else: self.server = netapp_utils.setup_ontap_zapi(module=self.module)
def __init__(self): self.argument_spec = netapp_utils.ontap_sf_host_argument_spec() self.argument_spec.update(dict( state=dict(required=True, choices=['present', 'absent']), name=dict(required=True, type='str'), root_volume=dict(type='str'), root_volume_aggregate=dict(type='str'), root_volume_security_style=dict(type='str', choices=['unix', 'ntfs', 'mixed', 'unified' ]), )) self.module = AnsibleModule( argument_spec=self.argument_spec, required_if=[ ('state', 'present', ['root_volume', 'root_volume_aggregate', 'root_volume_security_style']) ], supports_check_mode=True ) p = self.module.params # set up state variables self.state = p['state'] self.name = p['name'] self.root_volume = p['root_volume'] self.root_volume_aggregate = p['root_volume_aggregate'] self.root_volume_security_style = p['root_volume_security_style'] if HAS_NETAPP_LIB is False: self.module.fail_json(msg="the python NetApp-Lib module is required") else: self.server = netapp_utils.setup_ontap_zapi(module=self.module)
def __init__(self): self.argument_spec = netapp_utils.ontap_sf_host_argument_spec() self.argument_spec.update(dict( state=dict(required=True, choices=['present', 'absent']), name=dict(required=True, type='str'), volume_access_group_id=dict(required=False, type='int', default=None), initiators=dict(required=False, type='list', default=None), volumes=dict(required=False, type='list', default=None), virtual_network_id=dict(required=False, type='list', default=None), virtual_network_tags=dict(required=False, type='list', default=None), attributes=dict(required=False, type='dict', default=None), )) self.module = AnsibleModule( argument_spec=self.argument_spec, supports_check_mode=True ) p = self.module.params # set up state variables self.state = p['state'] self.name = p['name'] self.volume_access_group_id = p['volume_access_group_id'] self.initiators = p['initiators'] self.volumes = p['volumes'] self.virtual_network_id = p['virtual_network_id'] self.virtual_network_tags = p['virtual_network_tags'] self.attributes = p['attributes'] if HAS_SF_SDK is False: self.module.fail_json(msg="Unable to import the SolidFire Python SDK") else: self.sfe = netapp_utils.create_sf_connection(module=self.module)
def __init__(self): self.argument_spec = netapp_utils.ontap_sf_host_argument_spec() self.argument_spec.update(dict( skip=dict(required=False, type='str', default=None, choices=['mvip', 'svip']), mvip=dict(required=False, type='str', default=None), svip=dict(required=False, type='str', default=None) )) self.module = AnsibleModule( argument_spec=self.argument_spec, supports_check_mode=True ) p = self.module.params # set up state variables self.skip = p['skip'] self.mvip = p['mvip'] self.svip = p['svip'] if HAS_SF_SDK is False: self.module.fail_json(msg="Unable to import the SolidFire Python SDK") else: self.sfe = netapp_utils.ElementFactory.create(p['hostname'], p['username'], p['password'], port=442)
def __init__(self): self.argument_spec = netapp_utils.ontap_sf_host_argument_spec() self.argument_spec.update(dict( state=dict(required=True, choices=['present', 'absent']), name=dict(required=True, type='str'), account_id=dict(required=False, type='int', default=None), new_name=dict(required=False, type='str', default=None), initiator_secret=dict(required=False, type='str'), target_secret=dict(required=False, type='str'), attributes=dict(required=False, type='dict'), status=dict(required=False, type='str'), )) self.module = AnsibleModule( argument_spec=self.argument_spec, supports_check_mode=True ) p = self.module.params # set up state variables self.state = p['state'] self.name = p['name'] self.account_id = p['account_id'] self.new_name = p['new_name'] self.initiator_secret = p['initiator_secret'] self.target_secret = p['target_secret'] self.attributes = p['attributes'] self.status = p['status'] if HAS_SF_SDK is False: self.module.fail_json(msg="Unable to import the SolidFire Python SDK") else: self.sfe = netapp_utils.create_sf_connection(module=self.module)
def __init__(self): self._size_unit_map = dict( bytes=1, b=1, kb=1024, mb=1024 ** 2, gb=1024 ** 3, tb=1024 ** 4, pb=1024 ** 5, eb=1024 ** 6, zb=1024 ** 7, yb=1024 ** 8 ) self.argument_spec = netapp_utils.ontap_sf_host_argument_spec() self.argument_spec.update(dict( state=dict(required=True, choices=['present', 'absent']), name=dict(required=True, type='str'), is_infinite=dict(required=False, type='bool', default=False, aliases=['infinite']), is_online=dict(required=False, type='bool', default=True, aliases=['online']), size=dict(type='int'), size_unit=dict(default='gb', choices=['bytes', 'b', 'kb', 'mb', 'gb', 'tb', 'pb', 'eb', 'zb', 'yb'], type='str'), aggregate_name=dict(type='str'), vserver=dict(required=True, type='str', default=None), junction_path=dict(required=False, type='str', default=None), export_policy=dict(required=False, type='str', default='default'), snapshot_policy=dict(required=False, type='str', default='default'), )) self.module = AnsibleModule( argument_spec=self.argument_spec, required_if=[ ('state', 'present', ['aggregate_name', 'size']) ], supports_check_mode=True ) p = self.module.params # set up state variables self.state = p['state'] self.name = p['name'] self.is_infinite = p['is_infinite'] self.is_online = p['is_online'] self.size_unit = p['size_unit'] self.vserver = p['vserver'] self.junction_path = p['junction_path'] self.export_policy = p['export_policy'] self.snapshot_policy = p['snapshot_policy'] if p['size'] is not None: self.size = p['size'] * self._size_unit_map[self.size_unit] else: self.size = None self.aggregate_name = p['aggregate_name'] if HAS_NETAPP_LIB is False: self.module.fail_json(msg="the python NetApp-Lib module is required") else: self.server = netapp_utils.setup_ontap_zapi(module=self.module, vserver=self.vserver)
def __init__(self): self.argument_spec = netapp_utils.ontap_sf_host_argument_spec() self.argument_spec.update(dict( state=dict(required=True, choices=['present', 'absent']), name=dict(required=True, type='str'), time_interval_days=dict(required=False, type='int', default=1), time_interval_hours=dict(required=False, type='int', default=0), time_interval_minutes=dict(required=False, type='int', default=0), paused=dict(required=False, type='bool'), recurring=dict(required=False, type='bool'), starting_date=dict(type='str'), snapshot_name=dict(required=False, type='str'), volumes=dict(required=False, type='list'), retention=dict(required=False, type='str'), schedule_id=dict(type='int'), )) self.module = AnsibleModule( argument_spec=self.argument_spec, required_if=[ ('state', 'present', ['starting_date', 'volumes']) ], supports_check_mode=True ) p = self.module.params # set up state variables self.state = p['state'] self.name = p['name'] # self.interval = p['interval'] self.time_interval_days = p['time_interval_days'] self.time_interval_hours = p['time_interval_hours'] self.time_interval_minutes = p['time_interval_minutes'] self.paused = p['paused'] self.recurring = p['recurring'] self.starting_date = p['starting_date'] if self.starting_date is not None: self.starting_date = self.starting_date.replace("--", "-") self.snapshot_name = p['snapshot_name'] self.volumes = p['volumes'] self.retention = p['retention'] self.schedule_id = p['schedule_id'] self.create_schedule_result = None if HAS_SF_SDK is False: self.module.fail_json(msg="Unable to import the SolidFire Python SDK") else: self.sfe = netapp_utils.create_sf_connection(module=self.module)