def keypool_create(self, keypool, projectname, tenant, vpoolname, apitype, uid, secret): ''' creates a keypool parameters: keypool: label of the keypool project: project name tenant: tenant name vpool: vpool name apitype: api type(s3, swift or atmos) uid: user id secret: secret key Returns: JSON payload response ''' errorcontext = 0 if ((projectname) and (not common.is_uri(projectname))): from project import Project obj = Project(self.__ipAddr, self.__port) projectlst = obj.project_list(tenant) project_uri = None for projiter in projectlst: if (projiter['name'] == projectname): project_uri = projiter['id'] if (not project_uri): raise SOSError(SOSError.VALUE_ERR, "Porject " + projectname + ": not found") if ((vpoolname) and (not common.is_uri(vpoolname))): from virtualpool import VirtualPool obj = VirtualPool(self.__ipAddr, self.__port) vpool = obj.vpool_show(vpoolname, 'object') vpool_uri = vpool['id'] if (not common.is_uri(tenant)): from tenant import Tenant tenant_obj = Tenant(self.__ipAddr, self.__port) namespace = tenant_obj.namespace_get(tenant) try: if (apitype == 's3'): return s3_bucket_create(namespace, keypool, project_uri, vpool_uri, uid, secretkey) elif (apitype == 'swift'): return swift_container_create(namespace, keypool, project_uri, vpool_uri, uid, secretkey) elif (apitype == 'atmos'): return atmos_subtenant_create(namespace, tenant, keypool, project_uri, vpool_uri, uid, secretkey) else: raise SOSError(SOSError.VALUE_ERR, "Wrong API type " + apitype + " specified") except SOSError as e: raise e
def atmos_subtenant_create( namespace, tenant, keypool, project, vpool, uid, secretkey): if(vpool): from virtualpool import VirtualPool obj = VirtualPool(self.__ipAddr, self.__port) vpool_uri = obj.vpool_query(vpool, 'object') vpool_uri = vpool_uri.strip() if ((project) and (not common.is_uri(project))): from project import Project obj = Project(self.__ipAddr, self.__port) projectlst = obj.project_list(tenant) project_uri = None for projiter in projectlst: if(projiter['name'] == projectname): project_uri = projiter['id'] if(not project_uri): raise SOSError(SOSError.NOT_FOUND_ERR, "Project " + project + ": not found") _headers = dict() _headers['x-emc-namespace'] = namespace _headers['x-emc-vpool'] = vpool_uri _headers['x-emc-project-id'] = project_uri (s, h) = common.service_json_request(self.__ipAddr, ATMOS_PORT, "PUT", self.URI_SWIFT_CONTAINER_INSTANCE. format(namespace, container), None, None, False, 'application/json', None, _headers) if(h['subtenantID']): return h['subtenantID']
def bucket_create(self, name, project, owner , varray,vpool , retention, softquota , hardquota): from project import Project proj_obj = Project(self.__ipAddr, self.__port) project_uri = proj_obj.project_query(project) from virtualpool import VirtualPool vpool_obj = VirtualPool(self.__ipAddr, self.__port) vpool_uri = vpool_obj.vpool_query(vpool, "object") from virtualarray import VirtualArray varray_obj = VirtualArray(self.__ipAddr, self.__port) varray_uri = varray_obj.varray_query(varray) uri = Bucket.URI_BUCKET_CREATE + "?project=" + project_uri request = { 'name': name, 'varray': varray_uri, 'vpool': vpool_uri } if(owner): request["owner"] = owner if(retention): request["retention"] = retention if(softquota): request["soft_quota"] = softquota if(hardquota): request["hard_quota"] = hardquota body = json.dumps(request) (s, h) = common.service_json_request( self.__ipAddr, self.__port, "POST", uri, body) o = common.json_decode(s) return o
def atmos_subtenant_create(namespace, tenant, keypool, project, vpool, uid, secretkey): if (vpool): from virtualpool import VirtualPool obj = VirtualPool(self.__ipAddr, self.__port) vpool_uri = obj.vpool_query(vpool, 'object') vpool_uri = vpool_uri.strip() if ((project) and (not common.is_uri(project))): from project import Project obj = Project(self.__ipAddr, self.__port) projectlst = obj.project_list(tenant) project_uri = None for projiter in projectlst: if (projiter['name'] == projectname): project_uri = projiter['id'] if (not project_uri): raise SOSError(SOSError.NOT_FOUND_ERR, "Project " + project + ": not found") _headers = dict() _headers['x-emc-namespace'] = namespace _headers['x-emc-vpool'] = vpool_uri _headers['x-emc-project-id'] = project_uri (s, h) = common.service_json_request( self.__ipAddr, ATMOS_PORT, "PUT", self.URI_SWIFT_CONTAINER_INSTANCE.format(namespace, container), None, None, False, 'application/json', None, _headers) if (h['subtenantID']): return h['subtenantID']
def swift_container_create(container, namespace, tenant, project, vpool, uid, secret): if ((project) and (not common.is_uri(project))): from project import Project obj = Project(self.__ipAddr, self.__port) projectlst = obj.project_list(tenant) project_uri = None for projiter in projectlst: if (projiter['name'] == projectname): project_uri = projiter['id'] if (not project_uri): raise SOSError(SOSError.NOT_FOUND_ERR, "Project " + project + ": not found") project_uri = project_uri.strip() _headers['x-emc-project-id'] = project_uri if (vpool): from virtualpool import VirtualPool obj = VirtualPool(self.__ipAddr, self.__port) vpool_uri = obj.vpool_query(vpool, 'object') vpool_uri = vpool_uri.strip() _headers['x-emc-vpool'] = vpool_uri token = self.swift_authenticate(uid, secret) _headers = dict() _headers[common.SWIFT_AUTH_TOKEN] = token (s, h) = common.service_json_request( self.__ipAddr, S3_PORT, "PUT", self.URI_SWIFT_CONTAINER_INSTANCE.format(namespace, container), None, None, False, 'application/json', None, _headers) o = common.json_decode(s)
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 filepolicy_unassign( self, name, unassign_resource_type, unassign_from_vpools, unassign_from_projects, unassign_from_filesystem, tenant, project ): filepolicy = self.filepolicy_query(name) unassign_request = {} projects_uris = [] vpools_uris = [] if unassign_resource_type == 'vpools': if unassign_from_vpools is None : raise SOSError(SOSError.VALUE_ERR,"File policy unassign error:"+ "Vpools value should be provided") vpool_obj = VirtualPool(self.__ipAddr, self.__port) if( len(unassign_from_vpools) > 1 ): vpools = unassign_from_vpools.split(',') for vpool in vpools: uri = vpool_obj.vpool_query(vpool, 'file') vpools_uris.append(uri) else : uri = vpool_obj.vpool_query(unassign_from_vpools, 'file') vpools_uris.append(uri) unassign_request['unassign_from'] = vpools_uris elif unassign_resource_type == 'projects': if unassign_from_projects is None : raise SOSError(SOSError.VALUE_ERR,"File policy unassign error:"+ "Project value should be provided") project_obj = Project(self.__ipAddr, self.__port) if( len(unassign_from_projects) > 1): projects = unassign_from_projects.split(',') for project in projects: uri = project_obj.project_query(project) projects_uris.append(uri) else : uri = project_obj.project_query(unassign_from_projects) projects_uris.append(uri) unassign_request['unassign_from'] = projects_uris elif unassign_resource_type == 'filesystem': filesystem_uris = [] if unassign_from_filesystem is None or project is None : raise SOSError(SOSError.VALUE_ERR,"File policy unassign error:"+ "Filesystem and project value should be provided") fs_obj = fileshare.Fileshare(self.__ipAddr, self.__port) resourcepath = "/" + project + "/" if(tenant is not None): resourcepath = tenant + resourcepath if( len(unassign_from_filesystem) > 1): filesystems = unassign_from_filesystem.split(',') for filesystem in filesystems: uri = fs_obj.fileshare_query(resourcepath + filesystem) filesystem_uris.append(uri) else : uri = fs_obj.fileshare_query(resourcepath + filesystem) filesystem_uris.append(uri) unassign_request['unassign_from'] = filesystem_uris try: body = json.dumps(unassign_request) (s, h) = common.service_json_request(self.__ipAddr, self.__port, 'POST', FilePolicy.URI_FILE_POLICY_UNASSIGN.format(filepolicy['id']), body) if not s: return None o = common.json_decode(s) return o except SOSError, e: errorMessage = str(e)
def filepolicy_assign( self, name, assign_to_vpools, project_assign_vpool, assign_to_projects, source_varray, target_varrays, ): filepolicy = self.filepolicy_query(name) (s, h) = common.service_json_request( self.__ipAddr, self.__port, 'GET', FilePolicy.URI_FILE_POLICY_SHOW.format(filepolicy['id']), None, None, False, ) o = common.json_decode(s) appliedat = common.get_node_value(o,"applied_at") pol_type = common.get_node_value(o,"type") assign_request = {} if ( appliedat == "vpool"): vpool_assign_param = {} assign_request_vpools = [] if assign_to_vpools is None: raise SOSError(SOSError.VALUE_ERR,"File policyassign error:"+ "Vpool(assign_to_vpools) value should be provided") elif( len(assign_to_vpools)>1): vpool_names = assign_to_vpools.split(',') vpool_obj = VirtualPool(self.__ipAddr, self.__port) for name in vpool_names: uri = vpool_obj.vpool_query(name, 'file') assign_request_vpools.append(uri) elif( assign_to_vpools is not None ): uri = vpool_obj.vpool_query(assign_to_vpools, 'file') assign_request_vpools.append(uri) vpool_assign_param['assign_to_vpools'] = assign_request_vpools assign_request['vpool_assign_param'] = vpool_assign_param elif ( appliedat == "project"): project_assign_param = {} assign_request_projects = [] assign_request_project_vpools = [] project_obj = Project(self.__ipAddr, self.__port) if assign_to_projects is None or project_assign_vpool is None: raise SOSError(SOSError.VALUE_ERR,"File policyassign error:"+ "Vpool (project_assign_vpool) and project (assign_to_projects) value should be provided") if( len(assign_to_projects)>1): project_names = assign_to_projects.split(',') for name in project_names: uri = project_obj.project_query(name) assign_request_projects.append(uri) else: uri = project_obj.project_query(assign_to_projects) assign_request_projects.append(uri) vpool_obj = VirtualPool(self.__ipAddr, self.__port) uri = vpool_obj.vpool_query(project_assign_vpool, 'file') project_assign_param['vpool'] = uri project_assign_param['assign_to_projects'] = assign_request_projects assign_request['project_assign_param'] = project_assign_param if (pol_type == "file_replication"): if (source_varray is not None and target_varrays is not None): file_replication_topologies = [] file_replication_topology = {} assign_target_varrays = [] from virtualarray import VirtualArray varray_obj = VirtualArray(self.__ipAddr, self.__port) src_varray_uri = varray_obj.varray_query(source_varray) file_replication_topology['source_varray']= src_varray_uri if( len(target_varrays)>1): trg_varrays= target_varrays.split(',') for varray in trg_varrays: uri = varray_obj.varray_query(varray) assign_target_varrays.append(uri) else: uri = varray_obj.varray_query(target_varrays) assign_target_varrays.append(uri) file_replication_topology['target_varrays']= assign_target_varrays file_replication_topologies.append(file_replication_topology) assign_request['file_replication_topologies']= file_replication_topologies else: raise SOSError(SOSError.VALUE_ERR, "File policyassign error:"+ "Target and source virtual array should be provided") try: body = json.dumps(assign_request) (s, h) = common.service_json_request(self.__ipAddr, self.__port, 'POST', FilePolicy.URI_FILE_POLICY_ASSIGN.format(filepolicy['id']), body) if not s: return None o = common.json_decode(s) return o except SOSError, e: errorMessage = str(e)