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 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)
