def project_query(self, name):
'''
Retrieves UUID of project based on its name
Parameters:
name: name of project
Returns: UUID of project
Throws:
SOSError - when project name is not found
'''
if (common.is_uri(name)):
return name
(tenant_name, project_name) = common.get_parent_child_from_xpath(name)
from tenant import Tenant
tenant_obj = Tenant(self.__ipAddr, self.__port)
try:
tenant_uri = tenant_obj.tenant_query(tenant_name)
projects = self.project_list(tenant_uri)
if(projects and len(projects) > 0):
for project in projects:
if (project):
project_detail = self.project_show_by_uri(project['id'])
if(project_detail and project_detail['name'] == project_name):
return project_detail['id']
raise SOSError(SOSError.NOT_FOUND_ERR, 'Project: ' + project_name + ' not found')
except SOSError as e:
raise e
def key_delete(self, key, keypool, tenant, apitype, version, uid, secret):
'''
Makes a REST API call to delete a key by its name
Parameters:
key: label of the key
keypool: label of the keypool
project: project name
tenant: tenant name
apitype: api to be used
uid: user id
secret: secret
Returns:
JSON payload of key list
'''
if (not common.is_uri(tenant)):
from tenant import Tenant
tenant_obj = Tenant(self.__ipAddr, self.__port)
namespace = tenant_obj.namespace_get(tenant)
if (apitype == 's3'):
s3_key_delete(namespace, keypool, key, version, uid, secret)
elif (apitype == 'swift'):
swift_object_delete(namespace, keypool, key, version, uid, secret)
elif (apitype == 'atmos'):
atmos_object_delete(namespace, keypool, key, uid, secret)
else:
raise SOSError(SOSError.VALUE_ERR,
"Wrong API type " + apitype + " specified")
def varray_allow_tenant(self, varray, tenant):
'''
Makes a REST API call to retrieve details of a varray
based on its UUID
'''
uri = self.varray_query(varray)
from tenant import Tenant
tenant_obj = Tenant(self.__ipAddr, self.__port)
tenanturi = tenant_obj.tenant_query(tenant)
parms = {
'add': [{
'privilege': ['USE'],
'tenant': tenanturi,
}]
}
body = json.dumps(parms)
(s, h) = common.service_json_request(
self.__ipAddr, self.__port, "PUT",
self.URI_VIRTUALARRAY_ACLS.format(uri), body)
return s
def __init__(self, bs):
# self.name = ""
# self.bs = BeautifulSoup("", "xml")
# self.evaluation = {"":0}
# self.tenants_placed = [Tenant(bs)]
# self.names_rejected = set("")
# self.tenants_try = [Tenant(bs)]
self.bs = bs
self.name = bs.find("dcxml")["name"]
self.evaluation = None
self.tenants_placed = []
self.names_rejected = set()
self.tenants_try = []
for tenant_bs in bs.find_all("tenant"):
assigned = all([(x.get("assignedTo", None) is not None)
for x in (list(tenant_bs.find_all("vm")) +
list(tenant_bs.find_all("st")))])
if assigned:
tenant = Tenant(tenant_bs)
self.tenants_placed.append(tenant)
tenant.mark = self.name
bs.find("tenants").extract()
bs.find("dcxml").append(bs.new_tag('tenants'))
def keypool_update(self, keypool, tenant, versioning, apitype, uid,
secret):
'''
update keypool versioning
parameters:
keypool: label of the keypool
project: project name
tenant: tenant name
uid: user id
secret: secret key
Returns:
JSON payload response
'''
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_update(namespace, keypool, versioning, uid,
secretkey)
else:
raise SOSError(SOSError.VALUE_ERR,
"Wrong API type " + apitype + " specified")
except SOSError as e:
raise e
def add_or_remove_vcenter_acls(self, vcenter_name, tenants, operation):
vcenter_uri = self.vcenter_query(vcenter_name, VCenter.VCENTERS_FROM_ALL_TENANTS)
tenants_array = []
tenants_array = tenants.split(',')
from tenant import Tenant
obj = Tenant(self.__ipAddr, self.__port)
acl_entries = []
for tenant in tenants_array:
acl_entry = dict()
acl_entry['privilege'] = ['USE']
acl_entry['tenant'] = str(obj.tenant_query(tenant))
acl_entries.append(acl_entry)
request = {operation: acl_entries}
body = json.dumps(request)
(s, h) = common.service_json_request(self.__ipAddr, self.__port, "PUT",
VCenter.URI_VCENTER_ACL.format(vcenter_uri), body)
o = common.json_decode(s)
return o
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 keypool_show(self, keypool, tenant, uid, secret):
'''
show keypool
parameters:
keypool: label of the keypool
tenant: tenant name
uid: user id
secret: secret key
Returns:
JSON payload response
'''
#uri = self.keypool_query(label)
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_show(namespace, keypool, uid, secretkey)
elif (apitype == 'swift'):
return swift_container_show(namespace, keypool, uid, secretkey)
elif (apitype == 'atmos'):
return atmos_subtenant_show(namespace, keypool, uid, secretkey)
else:
raise SOSError(SOSError.VALUE_ERR,
"Wrong API type " + apitype + " specified")
except SOSError as e:
raise e
def keypool_delete(self, keypool, tenant, uid, secret):
'''Makes a REST API call to delete a keypool by its name,
project and tenant
'''
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_delete(namespace, keypool, uid, secretkey)
elif(apitype == 'swift'):
return swift_container_delete(namespace,
keypool,
uid,
secretkey)
elif(apitype == 'atmos'):
return atmos_subtenant_delete(namespace,
keypool,
uid,
secretkey)
else:
raise SOSError(SOSError.VALUE_ERR,
"Wrong API type " + apitype + " specified")
except SOSError as e:
raise e
def key_list_versions(self, keypool, key, tenant, apitype, uid, secret):
'''
Returns versions of the key`
Parameters:
key: label of the key
keypool: label of the keypool
project: project name
tenant: tenant name
apitype: api to be used
uid: user id
secret: secret
Returns:
JSON payload of key list
'''
if (not common.is_uri(tenant)):
from tenant import Tenant
tenant_obj = Tenant(self.__ipAddr, self.__port)
namespace = tenant_obj.namespace_get(tenant)
if(apitype == 's3'):
s3_key_list_versions(namespace, keypool, key, uid, secret )
elif ( (apitype =='swift') or (apitype=='atmos')) :
raise SOSError(SOSError.NOT_FOUND_ERR,
"Versioning not available with API type " + apitype)
else:
raise SOSError(SOSError.VALUE_ERR,
"Wroing API type " + apitype + " specified")
def cluster_create(self, label, tenant, datacenter, vcenter):
tenant_obj = Tenant(self.__ipAddr, self.__port)
vdatacenterobj = VcenterDatacenter(self.__ipAddr, self.__port)
if(tenant is None):
tenant_uri = tenant_obj.tenant_getid()
else:
tenant_uri = tenant_obj.tenant_query(tenant)
parms = {'name': label}
# datacenter
if(datacenter):
# on failure, query raise exception
parms['vcenter_data_center'] = \
vdatacenterobj.vcenterdatacenter_query(
datacenter, vcenter, tenant)
body = json.dumps(parms)
(s, h) = common.service_json_request(
self.__ipAddr, self.__port,
"POST",
Cluster.URI_TENANTS_CLUSTERS.format(tenant_uri),
body)
o = common.json_decode(s)
def project_query(self, name):
'''
Retrieves UUID of project based on its name
Parameters:
name: name of project
Returns: UUID of project
Throws:
SOSError - when project name is not found
'''
if (common.is_uri(name)):
return name
(tenant_name, project_name) = common.get_parent_child_from_xpath(name)
from tenant import Tenant
tenant_obj = Tenant(self.__ipAddr, self.__port)
try:
tenant_uri = tenant_obj.tenant_query(tenant_name)
projects = self.project_list(tenant_uri)
if(projects and len(projects) > 0):
for project in projects:
if (project):
project_detail = self.project_show_by_uri(
project['id'])
if(project_detail and
project_detail['name'] == project_name):
return project_detail['id']
raise SOSError(SOSError.NOT_FOUND_ERR,
'Project: ' + project_name + ' not found')
except SOSError as e:
raise e
def keypool_show(self, keypool, tenant, uid, secret):
'''
show keypool
parameters:
keypool: label of the keypool
tenant: tenant name
uid: user id
secret: secret key
Returns:
JSON payload response
'''
#uri = self.keypool_query(label)
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_show(namespace, keypool, uid, secretkey)
elif(apitype == 'swift'):
return swift_container_show(namespace, keypool, uid, secretkey)
elif(apitype == 'atmos'):
return atmos_subtenant_show(namespace, keypool, uid, secretkey)
else:
raise SOSError(SOSError.VALUE_ERR,
"Wrong API type " + apitype + " specified")
except SOSError as e:
raise e
def keypool_update(
self, keypool, tenant, versioning, apitype, uid, secret):
'''
update keypool versioning
parameters:
keypool: label of the keypool
project: project name
tenant: tenant name
uid: user id
secret: secret key
Returns:
JSON payload response
'''
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_update(
namespace, keypool, versioning, uid, secretkey)
else:
raise SOSError(SOSError.VALUE_ERR,
"Wrong API type " + apitype + " specified")
except SOSError as e:
raise e
def key_write(self, key, filepath , keypool, tenant, apitype, uid, secret, type):
'''
write a key
parameters:
key: key
keypool: keypool
tenant: tenant name
value: value
apitype: api to be used
uid: user id
secret: secret
Returns:
JSON payload response
'''
if (not common.is_uri(tenant)):
from tenant import Tenant
tenant_obj = Tenant(self.__ipAddr, self.__port)
namespace = tenant_obj.namespace_get(tenant)
if(apitype == 's3'):
s3_key_write(namespace, keypool, key, filepath, uid, secret )
elif(apitype == 'swift'):
swift_object_write(namespace, keypool, key, filepath, uid, secret )
elif(apitype == 'atmos'):
atmos_object_write(namespace, keypool, key, filepath, uid, secret, type )
else:
raise SOSError(SOSError.VALUE_ERR,
"Wrong API type " + apitype + " specified")
def varray_disallow_tenant(self, varray, tenant):
'''
Makes a REST API call to retrieve details of a varray
based on its UUID
'''
uri = self.varray_query(varray)
from tenant import Tenant
tenant_obj = Tenant(self.__ipAddr, self.__port)
tenanturi = tenant_obj.tenant_query(tenant)
parms = {
'remove': [{
'privilege': ['USE'],
'tenant': tenanturi,
}]
}
body = json.dumps(parms)
(s, h) = common.service_json_request(
self.__ipAddr, self.__port, "PUT",
self.URI_VIRTUALARRAY_ACLS.format(uri),
body)
return s
def key_delete(self, key, keypool, tenant, apitype, version, uid, secret):
'''
Makes a REST API call to delete a key by its name
Parameters:
key: label of the key
keypool: label of the keypool
project: project name
tenant: tenant name
apitype: api to be used
uid: user id
secret: secret
Returns:
JSON payload of key list
'''
if (not common.is_uri(tenant)):
from tenant import Tenant
tenant_obj = Tenant(self.__ipAddr, self.__port)
namespace = tenant_obj.namespace_get(tenant)
if(apitype == 's3'):
s3_key_delete(namespace, keypool, key, version, uid, secret )
elif(apitype == 'swift'):
swift_object_delete(namespace, keypool, key, version, uid, secret )
elif(apitype == 'atmos'):
atmos_object_delete(namespace, keypool, key, uid, secret )
else:
raise SOSError(SOSError.VALUE_ERR,
"Wrong API type " + apitype + " specified")
def varray_list(self, vdcname=None, tenant=None):
'''
Returns all the varrays in a vdc
Parameters:
Returns:
JSON payload of varray list
'''
vdcuri = None
vdcrestapi = None
if(tenant != None):
from tenant import Tenant
tenant_obj = Tenant(self.__ipAddr, self.__port)
tenanturi = tenant_obj.tenant_query(tenant)
if(vdcname != None):
vdcrestapi = VirtualArray.URI_VIRTUALARRAY_BY_VDC_ID_AND_TENANT_ID.format(vdcname, tenanturi)
else:
vdcrestapi = VirtualArray.URI_VIRTUALARRAY_BY_TENANT_ID.format(tenanturi)
else:
if(vdcname != None):
vdcrestapi = VirtualArray.URI_VIRTUALARRAY_BY_VDC_ID.format(vdcname)
else:
vdcrestapi = VirtualArray.URI_VIRTUALARRAY
(s, h) = common.service_json_request(
self.__ipAddr, self.__port, "GET",
vdcrestapi, None)
o = common.json_decode(s)
returnlst = []
for item in o['varray']:
returnlst.append(item['id'])
return returnlst
def cluster_create(self, label, tenant, datacenter, vcenter):
tenant_obj = Tenant(self.__ipAddr, self.__port)
vdatacenterobj = VcenterDatacenter(self.__ipAddr, self.__port)
if(tenant is None):
tenant_uri = tenant_obj.tenant_getid()
else:
tenant_uri = tenant_obj.tenant_query(tenant)
parms = {'name': label}
# datacenter
if(datacenter):
# on failure, query raise exception
parms['vcenter_data_center'] = \
vdatacenterobj.vcenterdatacenter_query(
datacenter, vcenter, tenant)
body = json.dumps(parms)
(s, h) = common.service_json_request(
self.__ipAddr, self.__port,
"POST",
Cluster.URI_TENANTS_CLUSTERS.format(tenant_uri),
body)
o = common.json_decode(s)
def key_write(self, key, filepath, keypool, tenant, apitype, uid, secret,
type):
'''
write a key
parameters:
key: key
keypool: keypool
tenant: tenant name
value: value
apitype: api to be used
uid: user id
secret: secret
Returns:
JSON payload response
'''
if (not common.is_uri(tenant)):
from tenant import Tenant
tenant_obj = Tenant(self.__ipAddr, self.__port)
namespace = tenant_obj.namespace_get(tenant)
if (apitype == 's3'):
s3_key_write(namespace, keypool, key, filepath, uid, secret)
elif (apitype == 'swift'):
swift_object_write(namespace, keypool, key, filepath, uid, secret)
elif (apitype == 'atmos'):
atmos_object_write(namespace, keypool, key, filepath, uid, secret,
type)
else:
raise SOSError(SOSError.VALUE_ERR,
"Wrong API type " + apitype + " specified")
def cluster_create(self, label, tenant, project, datacenter, vcenter):
tenant_obj = Tenant(self.__ipAddr, self.__port)
vdatacenterobj = VcenterDatacenter(self.__ipAddr, self.__port)
projectobj = Project(self.__ipAddr, self.__port)
if(tenant == None):
tenant_uri = tenant_obj.tenant_getid()
else:
tenant_uri = tenant_obj.tenant_query(tenant)
parms = { 'name' : label
}
#project
if(project):
if(tenant):
projectname = tenant + "/" + project
else:
projectname = "" + "/" + project
#on failure, query raise exception
parms['project'] = projectobj.project_query(projectname)
#datacenter
if(datacenter):
#on failure, query raise exception
parms['vcenter_data_center'] = vdatacenterobj.vcenterdatacenter_query(datacenter, vcenter)
body = json.dumps(parms)
(s, h) = common.service_json_request(self.__ipAddr, self.__port,
"POST",
Cluster.URI_TENANTS_CLUSTERS.format(tenant_uri),
body)
o = common.json_decode(s)
def key_list_versions(self, keypool, key, tenant, apitype, uid, secret):
'''
Returns versions of the key`
Parameters:
key: label of the key
keypool: label of the keypool
project: project name
tenant: tenant name
apitype: api to be used
uid: user id
secret: secret
Returns:
JSON payload of key list
'''
if (not common.is_uri(tenant)):
from tenant import Tenant
tenant_obj = Tenant(self.__ipAddr, self.__port)
namespace = tenant_obj.namespace_get(tenant)
if (apitype == 's3'):
s3_key_list_versions(namespace, keypool, key, uid, secret)
elif ((apitype == 'swift') or (apitype == 'atmos')):
raise SOSError(
SOSError.NOT_FOUND_ERR,
"Versioning not available with API type " + apitype)
else:
raise SOSError(SOSError.VALUE_ERR,
"Wroing API type " + apitype + " specified")
def get_tenant_id(self, tenantName):
"""
Fetch the tenant id
"""
tenantObj = Tenant(self.__ipAddr, self.__port)
tenantId = tenantObj.get_tenant_by_name(tenantName)
return tenantId
def test0_volumes(self):
tenant1 = Tenant("client1")
tenant2 = Tenant("client2")
user_tenant = UserTenant("rauburtin")
user_tenant.add_tenant(tenant1)
user_tenant.add_tenant(tenant2)
print user_tenant.volumes, user_tenant.volumes_binds
def test0_volumes(self):
return
tenant1=Tenant("client1")
tenant2=Tenant("client2")
container_user_tenant=ContainerUserTenant("rauburtin")
container_user_tenant.add_tenant(tenant1)
container_user_tenant.add_tenant(tenant2)
print container_user_tenant.volumes,container_user_tenant.volumes_binds
container_user_tenant.start()
print container_user_tenant.logs
container_user_tenant.remove()
def get_tenant_uri_from_name(self, tenantname):
if (tenantname is None or
tenantname == "" or
tenantname.lower() == VCenter.VCENTERS_FROM_ALL_TENANTS.lower() or
tenantname.lower() == VCenter.VCENTERS_WITH_NO_TENANTS.lower()):
tenanturi = tenantname
else:
from tenant import Tenant
obj = Tenant(self.__ipAddr, self.__port)
tenanturi = obj.tenant_query(tenantname)
return tenanturi
def policy_list(self, tenantname):
tenant_obj = Tenant(self.__ipAddr, self.__port)
tenant_uri = tenant_obj.tenant_query(tenantname)
(s, h) = common.service_json_request(
self.__ipAddr, self.__port,
"GET",
Schedulepolicy.URI_SNAPSHOT_SCHEDULE_POLICY_CREATE.format(
tenant_uri),
None)
res = common.json_decode(s)
return res['schedule_policy']
def create(
self,
tenant,
policyname,
policytype,
schedulefrequency,
schedulerepeat,
scheduletime,
scheddom,
scheddow,
expiretype,
expirevalue,
):
tenant_obj = Tenant(self.__ipAddr, self.__port)
tenant_uri = tenant_obj.tenant_query(tenant)
schedule = dict()
schedule = {
"schedule_frequency": schedulefrequency,
"schedule_repeat": schedulerepeat,
"schedule_time": scheduletime,
}
if schedulefrequency == "weeks":
schedule["schedule_day_of_week"] = scheddow
elif schedulefrequency == "months":
schedule["schedule_day_of_month"] = scheddom
parms = {"policy_type": policytype, "policy_name": policyname}
body = None
parms["schedule"] = schedule
snapshot_expire = dict()
if expiretype or expirevalue:
snapshot_expire = {"expire_type": expiretype, "expire_value": expirevalue}
parms["snapshot_expire"] = snapshot_expire
body = json.dumps(parms)
(s, h) = common.service_json_request(
self.__ipAddr,
self.__port,
"POST",
Schedulepolicy.URI_SNAPSHOT_SCHEDULE_POLICY_CREATE.format(tenant_uri),
body,
)
return
def policy_list(self, tenantname):
tenant_obj = Tenant(self.__ipAddr, self.__port)
tenant_uri = tenant_obj.tenant_query(tenantname)
(s, h) = common.service_json_request(
self.__ipAddr,
self.__port,
"GET",
Schedulepolicy.URI_SNAPSHOT_SCHEDULE_POLICY_CREATE.format(tenant_uri),
None,
)
res = common.json_decode(s)
return res["schedule_policy"]
def get_vcenter_uri_with_tenant_param(self, tenant):
uri = ""
if (tenant is None or
tenant == "" or
tenant.lower() == VCenter.VCENTERS_FROM_ALL_TENANTS.lower()):
uri = VCenter.URI_VCENTERS_WITH_TENANT_PARAM.format(VCenter.VCENTERS_FROM_ALL_TENANTS)
elif tenant.lower() == VCenter.VCENTERS_WITH_NO_TENANTS.lower():
uri = VCenter.URI_VCENTERS_WITH_TENANT_PARAM.format(tenant)
else:
from tenant import Tenant
obj = Tenant(self.__ipAddr, self.__port)
tenant_uri = obj.tenant_query(tenant)
uri = VCenter.URI_VCENTERS_WITH_TENANT_PARAM.format(tenant_uri)
return uri
def vcenterdatacenter_update(self, label, vcenter, tenantname,
newtenantname):
'''
updates a vcenterdatacenter
parameters:
label: label of the vcenterdatacenter
Returns:
JSON payload response
'''
try:
check = self.vcenterdatacenter_show(label, vcenter, tenantname)
if check:
raise SOSError(SOSError.ENTRY_ALREADY_EXISTS_ERR,
"vcenterdatacenter " + label + ": found")
except SOSError as e:
if e.err_code == SOSError.ENTRY_ALREADY_EXISTS_ERR:
uri = self.vcenterdatacenter_query(
label, vcenter,
VcenterDatacenter.DATACENTERS_FROM_ALL_TENANTS)
params = dict()
params['name'] = label
if newtenantname is not None and newtenantname != 'null':
from tenant import Tenant
obj = Tenant(self.__ipAddr, self.__port)
params['tenant'] = obj.tenant_query(newtenantname)
elif newtenantname is not None:
params['tenant'] = newtenantname
body = json.dumps(params)
(s, h) = common.service_json_request(
self.__ipAddr, self.__port, "PUT",
VcenterDatacenter.URI_DATACENTER.format(uri), body)
o = common.json_decode(s)
return o
else:
raise e
if not check:
raise SOSError(
SOSError.NOT_FOUND_ERR,
"vcenterdatacenter with name " + label + " dost not exist")
def keypool_list(self, projectname, tenant, apitype, uid, secret):
'''
Returns all the keypools in a vdc
Parameters:
keypool: label of the keypool
project: project name
tenant: tenant name
apitype: api type(s3, swift or atmos)
uid: user id
secret: secret key
Returns:
JSON payload of keypool list
'''
if (not common.is_uri(tenant)):
from tenant import Tenant
tenant_obj = Tenant(self.__ipAddr, self.__port)
namespace = tenant_obj.namespace_get(tenant)
kplst = []
try:
if((not apitype) or (apitype == 's3')):
kplst.append(
s3_bucket_list(
namespace,
projectname,
uid,
secretkey))
if((not apitype) or (apitype == 'swift')):
kplst.append(
swift_container_list(
namespace,
projectname,
uid,
secretkey))
if((not apitype) or (apitype == 'atmos')):
kplst.append(
atmos_subtenant_list(
namespace,
projectname,
uid,
secretkey))
# need to convert to table format
return kplst
except SOSError as e:
raise e
def create(
self,
name,
tenantname,
type,
hourOfDay,
length,
lengthType,
dayOfWeek,
dayOfMonth,
minuteOfHour,
lastDayOfMonth=False,
):
new_request = {
"tenant": tenantname,
"hour_of_day_in_utc": hourOfDay,
"minute_of_hour_in_utc": minuteOfHour,
"execution_window_length": length,
"execution_window_length_type": lengthType,
"execution_window_type": type,
"day_of_week": dayOfWeek,
"day_of_month": dayOfMonth,
"last_day_of_month": lastDayOfMonth,
"name": name,
}
if minuteOfHour is not None:
new_request["minute_of_hour_in_utc"] = minuteOfHour
if tenantname is not None:
from tenant import Tenant
tenant_obj = Tenant(self.__ipAddr, self.__port)
try:
tenant_uri = tenant_obj.tenant_query(None)
except SOSError as e:
raise e
new_request["tenant"] = tenant_uri
body = json.dumps(new_request)
command = singletonURIHelperInstance.getUri(self.COMPONENT_TYPE, "create")
(s, h) = common.service_json_request(self.__ipAddr, self.__port, "POST", command, body)
o = common.json_decode(s)
return o
def vcenter_create(self, label, tenant, ipaddress, devport, username,
password, osversion, usessl):
'''
creates a vcenter
parameters:
label: label of the vcenter
Returns:
JSON payload response
'''
try:
check = self.vcenter_show(label, tenant)
if (not check):
raise SOSError(SOSError.NOT_FOUND_ERR,
"vcenter " + label + ": not found")
except SOSError as e:
if (e.err_code == SOSError.NOT_FOUND_ERR):
from tenant import Tenant
obj = Tenant(self.__ipAddr, self.__port)
uri = obj.tenant_query(tenant)
var = dict()
params = dict()
params = {
'name': label,
'ip_address': ipaddress,
'os_version': osversion,
'port_number': devport,
'user_name': username,
'password': password,
'use_ssl': usessl
}
body = json.dumps(params)
(s, h) = common.service_json_request(
self.__ipAddr, self.__port, "POST",
VCenter.URI_TENANTS_VCENTERS.format(uri), body)
o = common.json_decode(s)
return o
else:
raise e
if (check):
raise SOSError(SOSError.ENTRY_ALREADY_EXISTS_ERR,
"vcenter with name " + label + " already exists")
def create(self,
name,
tenantname,
type,
hourOfDay,
length,
lengthType,
dayOfWeek,
dayOfMonth,
minuteOfHour,
lastDayOfMonth=False):
new_request = {
"tenant": tenantname,
"hour_of_day_in_utc": hourOfDay,
"minute_of_hour_in_utc": minuteOfHour,
"execution_window_length": length,
"execution_window_length_type": lengthType,
"execution_window_type": type,
"day_of_week": dayOfWeek,
"day_of_month": dayOfMonth,
"last_day_of_month": lastDayOfMonth,
"name": name
}
if (minuteOfHour is not None):
new_request["minute_of_hour_in_utc"] = minuteOfHour
if (tenantname is not None):
from tenant import Tenant
tenant_obj = Tenant(self.__ipAddr, self.__port)
try:
tenant_uri = tenant_obj.tenant_query(None)
except SOSError as e:
raise e
new_request["tenant"] = tenant_uri
body = json.dumps(new_request)
command = singletonURIHelperInstance.getUri(self.COMPONENT_TYPE,
"create")
(s, h) = common.service_json_request(self.__ipAddr, self.__port,
"POST", command, body)
o = common.json_decode(s)
return o
def event_list(self, tenant):
uri = Tenant(self.__ipAddr, self.__port).tenant_query(tenant)
(s, h) = common.service_json_request(self.__ipAddr, self.__port, "GET",
Event.URI_EVENTS.format(uri),
None)
o = common.json_decode(s)
return o['event']
def vcenter_create(self, label, tenant, ipaddress, devport,
username, password, osversion, usessl):
'''
creates a vcenter
parameters:
label: label of the vcenter
Returns:
JSON payload response
'''
try:
check = self.vcenter_show(label, tenant)
if(not check):
raise SOSError(SOSError.NOT_FOUND_ERR,
"vcenter " + label + ": not found")
except SOSError as e:
if(e.err_code == SOSError.NOT_FOUND_ERR):
from tenant import Tenant
obj = Tenant(self.__ipAddr, self.__port)
uri = obj.tenant_query(tenant)
var = dict()
params = dict()
params = {'name': label,
'ip_address': ipaddress,
'os_version': osversion,
'port_number': devport,
'user_name': username,
'password': password,
'use_ssl': usessl
}
body = json.dumps(params)
(s, h) = common.service_json_request(
self.__ipAddr, self.__port, "POST",
VCenter.URI_TENANTS_VCENTERS.format(uri), body)
o = common.json_decode(s)
return o
else:
raise e
if(check):
raise SOSError(SOSError.ENTRY_ALREADY_EXISTS_ERR,
"vcenter with name " + label + " already exists")
def test0_sshcont(self):
#return
tenant1=Tenant("client1")
tenant2=Tenant("client2")
#tenant3=Tenant("client3")
sshd_container_user_tenant=SshdContainerUserTenant("rauburtin")
sshd_container_user_tenant.add_tenant(tenant1)
sshd_container_user_tenant.add_tenant(tenant2)
#sshd_container_user_tenant.add_tenant(tenant3)
print sshd_container_user_tenant.volumes,sshd_container_user_tenant.volumes_binds
sshd_container_user_tenant.start()
sshd_container_user_tenant.wait()
print 'logs',sshd_container_user_tenant.logs
print sshd_container_user_tenant.ports
print sshd_container_user_tenant.exposed_port
def vcenterdatacenter_update(self, label, vcenter, tenantname, newtenantname):
'''
updates a vcenterdatacenter
parameters:
label: label of the vcenterdatacenter
Returns:
JSON payload response
'''
try:
check = self.vcenterdatacenter_show(label, vcenter, tenantname)
if check:
raise SOSError(SOSError.NOT_FOUND_ERR,
"vcenterdatacenter " + label + ": found")
except SOSError as e:
if e.err_code == SOSError.NOT_FOUND_ERR:
uri = self.vcenterdatacenter_query(label, vcenter, VcenterDatacenter.DATACENTERS_FROM_ALL_TENANTS)
params = dict()
params['name'] = label
if newtenantname is not None and newtenantname != 'null':
from tenant import Tenant
obj = Tenant(self.__ipAddr, self.__port)
params['tenant'] = obj.tenant_query(newtenantname)
elif newtenantname is not None:
params['tenant'] = newtenantname
body = json.dumps(params)
(s, h) = common.service_json_request(
self.__ipAddr, self.__port, "PUT",
VcenterDatacenter.URI_DATACENTER.format(uri), body)
o = common.json_decode(s)
return o
else:
raise e
if not check:
raise SOSError(SOSError.ENTRY_ALREADY_EXISTS_ERR,
"vcenterdatacenter with name " + label +
" dost not exist")
def varray_get_acl(args):
obj = VirtualArray(args.ip, args.port)
try:
res = obj.varray_get_acl(args.name)
output = res['acl']
from tenant import Tenant
tenant_obj = Tenant(args.ip, args.port)
for item in output:
tenantval = tenant_obj.tenant_show(item['tenant'])
item['tenantname'] = tenantval['name']
from common import TableGenerator
TableGenerator(output, ['tenantname', 'privilege']).printTable()
except SOSError as e:
common.format_err_msg_and_raise("get_acl", "varray",
e.err_text, e.err_code)
def add_user_tenant(self, username, tenantname):
tenant = Tenant(tenantname)
if not username in self.user_tenants_dict:
user_tenant = UserTenant(username)
user_tenant.add_tenant(tenant)
self.user_tenants_dict[username] = user_tenant
else:
user_tenant = self.user_tenants_dict[username]
user_tenant.add_tenant(tenant)
def cluster_list(self, tenant):
uri = Tenant(self.__ipAddr, self.__port).tenant_query(tenant)
(s, h) = common.service_json_request(
self.__ipAddr, self.__port, "GET",
Cluster.URI_TENANTS_CLUSTERS.format(uri), None)
o = common.json_decode(s)
return o['cluster']
'''
def varray_get_acl(args):
obj = VirtualArray(args.ip, args.port)
try:
res = obj.varray_get_acl(args.name)
output = res['acl']
from tenant import Tenant
tenant_obj = Tenant(args.ip, args.port)
for item in output:
tenantval = tenant_obj.tenant_show(item['tenant'])
item['tenantname'] = tenantval['name']
from common import TableGenerator
TableGenerator(output, ['tenantname', 'privilege']).printTable()
except SOSError as e:
common.format_err_msg_and_raise("get_acl", "varray", e.err_text,
e.err_code)
def create(self, tenant, policyname, policytype, schedulefrequency,
schedulerepeat,scheduletime, scheddom, scheddow, expiretype,
expirevalue):
tenant_obj = Tenant(self.__ipAddr, self.__port)
tenant_uri = tenant_obj.tenant_query(tenant)
schedule = dict()
schedule = {
'schedule_frequency' : schedulefrequency,
'schedule_repeat' : schedulerepeat,
'schedule_time' : scheduletime
}
if schedulefrequency == 'weeks':
schedule['schedule_day_of_week'] = scheddow
elif schedulefrequency == 'months':
schedule['schedule_day_of_month'] = scheddom
parms = {
'policy_type' : policytype,
'policy_name' : policyname}
body = None
parms['schedule'] = schedule
snapshot_expire = dict()
if expiretype or expirevalue :
snapshot_expire = {
'expire_type' : expiretype,
'expire_value' : expirevalue}
parms['snapshot_expire'] = snapshot_expire
body = json.dumps(parms)
(s, h) = common.service_json_request(
self.__ipAddr, self.__port,
"POST",
Schedulepolicy.URI_SNAPSHOT_SCHEDULE_POLICY_CREATE.format(
tenant_uri),
body)
return
def read_tenants_from_file(filename):
tenants = []
content = None
with open(filename, "r") as f:
content = f.read()
bs = BeautifulSoup(content, 'xml')
for tenant_bs in bs.find_all("tenant"):
tenants.append(Tenant(tenant_bs))
return tenants
def vcenter_query(self, name, tenantname):
'''
Returns the UID of the vcenter specified by the name
'''
if (common.is_uri(name)):
return name
from tenant import Tenant
obj = Tenant(self.__ipAddr, self.__port)
tenanturi = obj.tenant_query(tenantname)
vcenters = self.vcenter_list(tenanturi)
for vcenter in vcenters:
if (vcenter['name'] == name):
return vcenter['id']
raise SOSError(SOSError.NOT_FOUND_ERR,
"vcenter " + name + ": not found")
def key_read(self, key, keypool, tenant, apitype, version, filepath , uid, secret, type ):
'''
Makes a REST API call to retrieve details of a key based on its key, keypool, apitype,uid, secret
'''
if (not common.is_uri(tenant)):
from tenant import Tenant
tenant_obj = Tenant(self.__ipAddr, self.__port)
namespace = tenant_obj.namespace_get(tenant)
if(apitype == 's3'):
return s3_key_read(namespace, keypool, key, version, filepath, uid, secret )
elif(apitype == 'swift'):
return swift_object_read(namespace, keypool, key, version, filepath, uid, secret )
elif(apitype == 'atmos'):
return atmos_object_read(namespace, keypool, key, version, filepath, uid, secret, type )
else:
raise SOSError(SOSError.VALUE_ERR,
"Wrong API type " + apitype + " specified")
def vcenter_query(self, name, tenantname):
'''
Returns the UID of the vcenter specified by the name
'''
if (common.is_uri(name)):
return name
from tenant import Tenant
obj = Tenant(self.__ipAddr, self.__port)
tenanturi = obj.tenant_query(tenantname)
vcenters = self.vcenter_list(tenanturi)
for vcenter in vcenters:
if (vcenter['name'] == name):
return vcenter['id']
raise SOSError(SOSError.NOT_FOUND_ERR,
"vcenter " + name + ": not found")
def vcenter_list(self, tenant):
'''
Returns all the vcenters associated with a tenant
Parameters:
Returns:
JSON payload of vcenter list
'''
from tenant import Tenant
obj = Tenant(self.__ipAddr, self.__port)
uri = obj.tenant_query(tenant)
(s, h) = common.service_json_request(
self.__ipAddr, self.__port, "GET",
VCenter.URI_TENANTS_VCENTERS.format(uri), None)
o = common.json_decode(s)
return o['vcenter']
def vcenter_list(self, tenant):
'''
Returns all the vcenters associated with a tenant
Parameters:
Returns:
JSON payload of vcenter list
'''
from tenant import Tenant
obj = Tenant(self.__ipAddr, self.__port)
uri = obj.tenant_query(tenant)
(s, h) = common.service_json_request(
self.__ipAddr, self.__port, "GET",
VCenter.URI_TENANTS_VCENTERS.format(uri), None)
o = common.json_decode(s)
return o['vcenter']
def project_list(self, tenant_name):
'''
Makes REST API call and retrieves projects based on tenant UUID
Parameters: None
Returns:
List of project UUIDs in JSON response payload
'''
from tenant import Tenant
tenant_obj = Tenant(self.__ipAddr, self.__port)
try:
tenant_uri = tenant_obj.tenant_query(tenant_name)
except SOSError as e:
raise e
(s, h) = common.service_json_request(self.__ipAddr, self.__port, "GET",
Project.URI_PROJECT_LIST.format(tenant_uri), None)
o = common.json_decode(s)
if("project" in o):
return common.get_list(o, 'project')
return []
def project_list(self, tenant_name):
'''
Makes REST API call and retrieves projects based on tenant UUID
Parameters: None
Returns:
List of project UUIDs in JSON response payload
'''
from tenant import Tenant
tenant_obj = Tenant(self.__ipAddr, self.__port)
try:
tenant_uri = tenant_obj.tenant_query(tenant_name)
except SOSError as e:
raise e
(s, h) = common.service_json_request(self.__ipAddr, self.__port, "GET",
Project.URI_PROJECT_LIST.format(tenant_uri), None)
o = common.json_decode(s)
if("project" in o):
return common.get_list(o, 'project')
return []
def project_create(self, name, tenant_name):
'''
Makes REST API call to create project under a tenant
Parameters:
name: name of project
tenant_name: name of the tenant under which project
is to be created
Returns:
Created project details in JSON response payload
'''
from tenant import Tenant
tenant_obj = Tenant(self.__ipAddr, self.__port)
try:
tenant_uri = tenant_obj.tenant_query(tenant_name)
except SOSError as e:
raise e
project_already_exists = True
try:
if(not tenant_name):
tenant_name = ""
self.project_query(tenant_name + "/" + name)
except SOSError as e:
if(e.err_code == SOSError.NOT_FOUND_ERR):
project_already_exists = False
else:
raise e
if(project_already_exists):
raise SOSError(SOSError.ENTRY_ALREADY_EXISTS_ERR,
"Project with name: " + name +
" already exists")
body = common.json_encode('name', name)
(s, h) = common.service_json_request(self.__ipAddr, self.__port,
"POST",
Project.URI_PROJECT_LIST.format(tenant_uri), body)
o = common.json_decode(s)
return o
def varray_get_acl(args):
obj = VirtualArray(args.ip, args.port)
try:
res = obj.varray_get_acl(args.name)
output = res['acl']
from tenant import Tenant
tenant_obj = Tenant(args.ip, args.port)
for iter in output:
tenantval = tenant_obj.tenant_show(iter['tenant'])
iter['tenantname'] = tenantval['name']
from common import TableGenerator
TableGenerator(output, [ 'tenantname', 'privilege']).printTable()
except SOSError as e:
if(e.err_code == SOSError.NOT_FOUND_ERR):
raise SOSError(SOSError.NOT_FOUND_ERR,
"varray Get ACL failed: " + e.err_text)
else:
raise e
def list_from_all_tenants(self):
hostList = []
from tenant import Tenant
obj = Tenant(self.__ipAddr, self.__port)
tenants = obj.tenant_list()
uris = []
for tenant in tenants:
uris.append(tenant["id"])
defaultTenantId = obj.tenant_getid()
uris.append(defaultTenantId)
for uri in uris:
if hostList.__len__() == 0:
hostList = self.list_by_tenant(uri)
else:
tempList = self.list_by_tenant(uri)
for tempHost in tempList:
hostList.append(tempHost)
return hostList
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
