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)
