def vnasserver_list(args): obj = VnasServer(args.ip, args.port) from common import TableGenerator from project import Project try: vnasServerList = obj.list_vnasserver_names() resultList = [] for iter in vnasServerList: rslt = obj.vnasserver_show(iter['name']) #rslt['parent_nas']['name'] should be printed under PARENT_NAS_SERVER. #Updating it as a new element in the map if('parent_nas' in rslt) and ('name' in rslt['parent_nas']): rslt['parent_nas_server'] = rslt['parent_nas']['name'] pr_object = None project_list = '' if ('associated_projects' in rslt): for project_id in rslt['associated_projects']: pr_object = Project(args.ip, args.port).project_show_by_uri(project_id) if pr_object and ('name' in pr_object): if (project_list == ''): project_list = pr_object['name'] else : project_list = project_list + ',' + pr_object['name'] st_object = None if ('storage_device' in rslt) and ('id' in rslt['storage_device']): st_object = StorageSystem(args.ip, args.port).show_by_uri(rslt['storage_device']['id']) if pr_object and ('name' in pr_object): rslt['project_name'] = project_list if st_object and ('name' in st_object): rslt['storage_system'] = st_object['name'] if(rslt is not None): resultList.append(rslt) if(len(resultList) > 0): # show a short table if(args.verbose is False and args.long is False): TableGenerator(vnasServerList, ["name"]).printTable() # show a long table if(args.verbose is False and args.long is True): TableGenerator( resultList, ["nas_name","parent_nas_server","nas_state","storage_domains","project_name","protocols", "storage_system"]).printTable() # show all items in json format if(args.verbose): return common.format_json_object(resultList) else: return except SOSError as e: raise e
def storageportgroup_add(self, storage_device_name, serial_number, storage_device_type, portgroup_name, storageports): storage_system = StorageSystem(self.__ipAddr, self.__port) storage_system_uri = None if (serial_number): storage_system_uri \ = storage_system.query_by_serial_number_and_type( serial_number, storage_device_type) elif (storage_device_name): storage_system_uri = storage_system.query_by_name_and_type( storage_device_name, storage_device_type) addports = [] for portname in storageports: storage_port = Storageport(self.__ipAddr, self.__port) porturi = storage_port.storageport_query(storage_system_uri, portname) addports.append(porturi) body = json.dumps({'name': portgroup_name, 'storage_ports': addports}) common.service_json_request( self.__ipAddr, self.__port, "POST", Storageportgroup.URI_STORAGEPORTGROUP_LIST.format( storage_system_uri), body)
def aliasget(self, initiator_uri, device_name, device_type): ''' Makes a REST API call to get the initiator alias against a storage system ''' from storagesystem import StorageSystem obj = StorageSystem(self.__ipAddr, self.__port) device_detail = obj.show(name=device_name, type=device_type) system_uri = device_detail['id'] (s, h) = common.service_json_request( self.__ipAddr, self.__port, "GET", HostInitiator.URI_INITIATOR_ALIASGET.format( initiator_uri, system_uri), None) o = common.json_decode(s) return o
def storagesystem_query(self, storagedeviceName, serialNumber, storagedeviceType): urideviceid = None storagesystemObj = StorageSystem(self.__ipAddr, self.__port) if (serialNumber): urideviceid = storagesystemObj.query_by_serial_number_and_type( serialNumber, storagedeviceType) elif (storagedeviceName): urideviceidTemp = storagesystemObj.show(name=storagedeviceName, type=storagedeviceType) urideviceid = urideviceidTemp['id'] else: return return urideviceid
def storagepool_register_main(self, serialnumber, deviceType, poolName): ''' Registers a storagepool with specified parameters Parameters: serialnumber: serial number of the storage system protocol: (optional) protocols supported by pool maxSnapshots: (optional) maxSnapshots permitted on the storage pool consistency: (optional) consistency details of storage pool deviceType: storage system type poolName: (optional) specific pool name to be registered returns: JSON payload of the created storagepool ''' obj_ss = StorageSystem(self.__ipAddr, self.__port) #uri = obj_ss.query_storagesystem_by_serial_number(serialnumber) systemuri = obj_ss.query_by_serial_number_and_type( serialnumber, deviceType) pooluris = self.storagepool_list_by_uri(systemuri) if (poolName): # Need to check if pool is found found = False else: found = True for pooluri in pooluris: if (poolName): storpool = self.storagepool_show_by_uri(systemuri, pooluri) compval = None compval = storpool['pool_name'] if (poolName == compval): found = True self.storagepool_register(systemuri, pooluri) else: self.storagepool_register(systemuri, pooluri) # Print error if named pool is not found if (not (found)): raise SOSError( SOSError.NOT_FOUND_ERR, "Storagepool with name " + poolName + " not found\n")
def aliasset(self, initiator_uri, device_name, device_type, alias): ''' Makes a REST API call to get the initiator alias against a storage system ''' from storagesystem import StorageSystem obj = StorageSystem(self.__ipAddr, self.__port) device_detail = obj.show(name=device_name, type=device_type) system_uri = device_detail['id'] request = {'system_uri': system_uri, 'initiator_alias': alias} body = json.dumps(request) (s, h) = common.service_json_request( self.__ipAddr, self.__port, "PUT", HostInitiator.URI_INITIATOR_ALIASSET.format(initiator_uri), body) o = common.json_decode(s) return o
def list_storageports(self, varrayName, network_connectivity=False): from storagesystem import StorageSystem storageSystemObj = StorageSystem(self.__ipAddr, self.__port) varrayUri = self.varray_query(varrayName) if (network_connectivity is True): (s, h) = common.service_json_request( self.__ipAddr, self.__port, "GET", VirtualArray.URI_LIST_STORAGE_PORTS.format(varrayUri) + "?network_connectivity=true", None) else: (s, h) = common.service_json_request( self.__ipAddr, self.__port, "GET", VirtualArray.URI_LIST_STORAGE_PORTS.format(varrayUri), None) o = common.json_decode(s) portList = [] for item in o['storage_port']: portList.append(item['id']) portDetailsList = [] if (portList): for porturi in portList: (s, h) = common.service_json_request( self.__ipAddr, self.__port, "GET", self.URI_STORAGE_PORT_DETAILS.format(porturi), None) portDetails = common.json_decode(s) # Get the storage system name to which the port belongs to storageSystemUri = portDetails['storage_system']['id'] ssDetails = storageSystemObj.show_by_uri( storageSystemUri, False) portDetails['storage_system'] = ssDetails['name'] portDetailsList.append(portDetails) return portDetailsList
def storageport_add(self, storage_device_name, serial_number, storage_device_type, port_name, port_id, transport_type): storage_system = StorageSystem(self.__ipAddr, self.__port) storage_system_uri = None if (serial_number): storage_system_uri \ = storage_system.query_by_serial_number_and_type( serial_number, storage_device_type) elif (storage_device_name): storage_system_uri = storage_system.query_by_name_and_type( storage_device_name, storage_device_type) is_storageport_exist = True try: self.storageport_query(storage_system_uri, port_name) except SOSError as e: if (e.err_code == SOSError.NOT_FOUND_ERR): is_storageport_exist = False else: raise e if (is_storageport_exist): raise SOSError( SOSError.ENTRY_ALREADY_EXISTS_ERR, "storageport with name " + port_name + " already exists ") body = json.dumps({ 'name': port_name, 'port_network_id': port_id, 'transport_type': transport_type }) common.service_json_request( self.__ipAddr, self.__port, "POST", Storageport.URI_STORAGEPORT_LIST.format(storage_system_uri), body)
def storagesystem_query(self, devicename, devicetype, serialnumber=None): ''' Returns the URI of the storage system given either name or serialnumber Parameters: devicename:name of the system devicetype: type of system serialnumber: serial number Returns: System URI ''' from storagesystem import StorageSystem if (not common.is_uri(devicename)): obj = StorageSystem(self.__ipAddr, self.__port) if (serialnumber and len(serialnumber) > 0): device_id = obj.query_by_serial_number_and_type( serialnumber, devicetype) else: device = obj.show(name=devicename, type=devicetype) device_id = device['id'] else: device_id = devicename return device_id
def objectuser_secretkey_create(self, storagesystem, objectuser, secretkey): ''' Makes a REST API call to retrieve create secret key of an object user ''' stsystem_uri = None from storagesystem import StorageSystem obj = StorageSystem(self.__ipAddr, self.__port) stsystem_uri = obj.query_by_name_and_type(storagesystem, "ecs") request = {} if (secretkey): request = {'secret_key': secretkey} body = json.dumps(request) (s, h) = common.service_json_request( self.__ipAddr, self.__port, "POST", ObjectUser.URI_OBJECTUSER_SECRET_KEYS.format( stsystem_uri, objectuser), body) o = common.json_decode(s) return o
def storagepool_list(args): obj = StoragePool(args.ip, args.port) try: from storagesystem import StorageSystem sys = StorageSystem(args.ip, args.port) if (args.serialnumber): device_id = sys.query_by_serial_number_and_type( args.serialnumber, args.type) else: device = sys.show(name=args.storagesystem, type=args.type) device_id = device['id'] uris = obj.storagepool_list_by_uri(device_id) output = [] for uri in uris: result = obj.storagepool_show_by_uri(device_id, uri) # adding new column storage tier names assicated with pools if ("tier_utilization_percentages" in result and args.long == True and (result['registration_status'] == 'REGISTERED')): tierUtilizationPercentages = result[ 'tier_utilization_percentages'] # Go and fetch storage-tiers only if the utilization value is present # Assumption here is, if there some utilization value, then # such a pool has storage tiers if (tierUtilizationPercentages is not None and len(tierUtilizationPercentages) > 0): tiernamelst = [] returnlst = [] # get list of storage tier objects returnlst = obj.storagepool_get_tiers_by_uri(uri) for item in returnlst: tiernamelst.append(item['name']) result["storage_tiers"] = tiernamelst if (result): output.append(result) if (len(output) > 0): if (args.verbose == True): return common.format_json_object(output) for iter in output: from decimal import Decimal if (iter['free_gb'] / (1024 * 1024) >= 1): iter['free'] = Decimal( Decimal(iter['free_gb']) / (1024 * 1024)) iter['free'] = str(iter['free']) + ' PB' elif (iter['free_gb'] / (1024) >= 1): iter['free'] = Decimal(Decimal(iter['free_gb']) / (1024)) iter['free'] = str(iter['free']) + ' TB' else: iter['free'] = str(iter['free_gb']) + ' GB' if (iter['used_gb'] / (1024 * 1024) >= 1): iter['used'] = Decimal( Decimal(iter['used_gb']) / (1024 * 1024)) iter['used'] = str(iter['used']) + ' PB' elif (iter['used_gb'] / (1024) >= 1): iter['used'] = Decimal(Decimal(iter['used_gb']) / (1024)) iter['used'] = str(iter['used']) + ' TB' else: iter['used'] = str(iter['used_gb']) + ' GB' if (args.long == True): for iter in output: if ('vpool_set' in iter): vpoolnames = '' for vpooliter in iter['vpool_set']: from virtualpool import VirtualPool obj = VirtualPool(args.ip, args.port) if (args.type in ['isilon', 'vnxfile', 'netapp']): vpooltype = 'file' else: vpooltype = 'block' vpool = obj.vpool_show_uri(vpooltype, vpooliter['id']) if (vpool): vpoolnames = vpoolnames + vpool['name'] + ',' if (len(vpoolnames) > 0): vpoolnames = vpoolnames[0:len(vpoolnames) - 1] if (vpoolnames): iter['vpool_set'] = vpoolnames else: iter['vpool_set'] = 'NULL' if ('tagged_varrays' in iter): nbhnames = '' for nbhiter in iter['tagged_varrays']: from virtualarray import VirtualArray obj = VirtualArray(args.ip, args.port) nbh = obj.varray_show(nbhiter) if (nbh): nbhnames = nbhnames + nbh['name'] + ',' if (len(nbhnames) > 0): nbhnames = nbhnames[0:len(nbhnames) - 1] if (nbhnames): iter['tagged_varrays'] = nbhnames else: iter['tagged_varrays'] = 'NULL' from common import TableGenerator TableGenerator(output, [ 'pool_name', 'registration_status', 'free', 'used', 'vpool_set', 'tagged_varrays', 'storage_tiers' ]).printTable() else: from common import TableGenerator TableGenerator( output, ['pool_name', 'registration_status', 'free', 'used' ]).printTable() except SOSError as e: if (e.err_code == SOSError.NOT_FOUND_ERR): raise SOSError(SOSError.NOT_FOUND_ERR, "Storagepool list failed: " + e.err_text) else: raise e
def storagepool_create(self, storagename, poolname, protocol, maxSnapshots, consistency, freeCapacity, totalCapacity, extensions, deviceType): ''' Creates a storagepool with specified parameters Parameters: storagename: name of the storage system poolname: name of the storage pool protocol: protocols supported by pool nativeId: native ID fothe pool extentions: extended parameters and attributes resiliency: resiliency assosiated with pool performance: performance associated with the storage pool efficiency: efficiency associated with the storage pool allocation allocation of storage pool maxSnapshots: maxSnapshots permitted on the storage pool consistency: consistency details of storage pool resiliencymap: resiliencymap of the storage pool freeCapacity: freeCapacity of the storage pool totalCapacity: totalCapacity of the storage pool returns: JSON payload of the created storagepool ''' uri = None sstype = None if (not common.is_uri(storagename)): from storagesystem import StorageSystem obj = StorageSystem(self.__ipAddr, self.__port) device = obj.show(name=storagename, type=deviceType) uri = device['id'] sstype = deviceType checklist = [] for iter in extensions: (key, value) = iter.split('=', 1) checklist.append(key) if ((sstype == 'vnxblock') or (sstype == 'vnxfile') or (sstype == 'vmax')): if ('NativeId' not in checklist) or ('PoolType' not in checklist): raise SOSError( SOSError.CMD_LINE_ERR, "error: For device type " + sstype + " -nativeid, -pooltype are required") if (sstype == 'vnxfile'): if ('Name' not in checklist): raise SOSError( SOSError.CMD_LINE_ERR, "error: For device type " + sstype + " -controllerpoolname is required") '''check for storage pool with existing name''' storage_pool_exists = True try: self.storagepool_show(poolname, storagename, None, deviceType) except SOSError as e: if (e.err_code == SOSError.NOT_FOUND_ERR): storage_pool_exists = False else: raise e if (storage_pool_exists): raise SOSError( SOSError.ENTRY_ALREADY_EXISTS_ERR, "Storage pool with name: " + poolname + " already exists") parms = dict() if (poolname): parms['name'] = poolname if (protocol): parms['protocols'] = protocol if (maxSnapshots): parms['max_snapshots'] = maxSnapshots if (consistency): parms['multi_volume_consistency'] = consistency if (extensions): parms['controller_params'] = self.__encode_map(extensions) if (freeCapacity): parms['free_capacity'] = freeCapacity if (totalCapacity): parms['total_capacity'] = totalCapacity body = None if (parms): body = json.dumps(parms) (s, h) = common.service_json_request( self.__ipAddr, self.__port, "POST", StoragePool.URI_STORAGEPOOLS.format(uri), body) o = common.json_decode(s) return o