def quotadirectory_list_uri(self, ouri):
(s, h) = common.service_json_request(
self.__ipAddr, self.__port,
"GET",
QuotaDirectory.URI_QUOTA_DIRECTORY.format(ouri), None)
o = common.json_decode(s)
return o['quota_dir']
def computepool_assgin(self, name, computesystemname, computele_add,
computele_remove):
compute_uri = self.computevpool_query(name)
vpool = {}
parms = {}
computele_uri = None
#add compute element
computeleobj = ComputeElement(self.__ipAddr, self.__port)
if (computele_add):
add_vpooluirs = []
for computele in computele_add:
computele_uri = computeleobj.query_compute_element(
computele, computesystemname)
add_vpooluirs.append(computele_uri)
add_vpool = {'compute_element': add_vpooluirs}
parms['add'] = add_vpool
if (computele_remove):
remove_voluris = []
for computele in computele_remove:
computele_uri = computeleobj.query_compute_element(
computele, computesystemname)
remove_voluris.append(computele_uri)
remove_vpool = {'compute_element': remove_voluris}
parms['remove'] = remove_vpool
vpool['assigned_element_changes'] = parms
body = json.dumps(vpool)
(s, h) = common.service_json_request(
self.__ipAddr, self.__port, "PUT",
self.URI_COMPUTE_VPOOL_ASSIGNED.format(compute_uri), body)
return common.json_decode(s)
def create(self, ouri, name, size, oplock, securitystyle, sync):
parms = {
'name': name,
}
if(size):
size = common.to_bytes(size)
parms["size"] = size
if(oplock):
parms["oplock"] = oplock
if(securitystyle):
parms["security_style"] = securitystyle
body = json.dumps(parms)
# REST api call
(s, h) = common.service_json_request(
self.__ipAddr, self.__port,
"POST",
QuotaDirectory.URI_QUOTA_DIRECTORY.format(ouri), body)
o = common.json_decode(s)
if(sync):
return (
self.block_until_complete(
o['resource']['id'],
o["id"])
)
else:
return o
def storagepool_register(self, systemuri, pooluri):
'''
Creates a storagepool with specified parameters
Parameters:
storagename: name of the storage system
protocol: protocols supported by pool
maxSnapshots: maxSnapshots permitted on the storage pool
consistency: consistency details of storage pool
returns:
JSON payload of the created storagepool
'''
parms = dict()
body = None
if (parms):
body = json.dumps(parms)
(s, h) = common.service_json_request(self.__ipAddr, self.__port,
"POST",
StoragePool.URI_STORAGEPOOL_REGISTER.format(systemuri,
pooluri),
body)
o = common.json_decode(s)
return o
def consitencygroup_protection_failover_ops(self, name, project, tenant, copyvarray,
type="native", op="failover"):
'''
Failover the consistency group protection
Parameters:
name : name of the consistency group
project : name of the project
copyvarray : name of the copy target virtual array
type : type of protection
Returns:
result of the action.
'''
group_uri = self.consistencygroup_query(name, project, tenant)
body = self.protection_copyparam(copyvarray, type)
uri = self.URI_BLOCK_CONSISTENCY_GROUP_FAILOVER.format(group_uri)
if op == 'failover_cancel':
uri = self.URI_BLOCK_CONSISTENCY_GROUP_FAILOVER_CANCEL.format(
group_uri)
elif op == 'swap':
uri = self.URI_BLOCK_CONSISTENCY_GROUP_SWAP.format(
group_uri)
(s, h) = common.service_json_request(
self.__ipAddr, self.__port,
"POST",
uri,
body)
return common.json_decode(s)
def varray_list(self, vdcname=None):
'''
Returns all the varrays in a vdc
Parameters:
Returns:
JSON payload of varray list
'''
vdcuri = None
vdcrestapi = None
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 create_computesystem(self, type, name, ipaddress, portnumber, username,
password, osinstallnetwork, use_ssl,
computeimageserver):
parms = {
'name': name,
'user_name': username,
'password': password,
'ip_address': ipaddress,
'port_number': portnumber,
'system_type': type,
'use_ssl': use_ssl
}
if (osinstallnetwork):
parms['os_install_network'] = osinstallnetwork
if (computeimageserver):
from computeimageserver import ComputeImageServers
compute_image_server = ComputeImageServers(self.__ipAddr,
self.__port)
compute_image_server_uri = compute_image_server.query_computeimageserver(
computeimageserver)
parms['compute_image_server'] = compute_image_server_uri
body = json.dumps(parms)
(s, h) = common.service_json_request(self.__ipAddr, self.__port,
"POST", self.URI_COMPUTE_SYSTEM,
body)
return common.json_decode(s)
def unassign(self, name, project=None):
'''
Vnasserver unassign
Parameters:
name: name of the vnasserver.
project : varray to be assigned .
Returns:
'''
vnasserverList = self.getvnasserverList(name)
request = {'vnas_server': vnasserverList}
if (project):
proj_object = Project(self.__ipAddr, self.__port)
pro_uri = proj_object.project_query(project)
body = json.dumps(request)
(s, h) = common.service_json_request(
self.__ipAddr, self.__port, "PUT",
VnasServer.URI_VNASSERVER_UNASSIGN.format(pro_uri), body)
if (s is not None and len(s) > 0):
print s
o = common.json_decode(s)
return o
def create(self, hostlabel, protocol, ipAddress,
netMask, prefixLength, scopeId, name, tenant):
hostUri = self.get_host_uri(hostlabel, tenant)
request = {'protocol': protocol,
'ip_address': ipAddress,
#'netmask ' : netMask,
#'prefix_length' :prefixLength,
#'scope_id' : scopeId
}
if(netMask):
request['netmask'] = netMask
if(prefixLength):
request['prefix_length'] = prefixLength
if(scopeId):
request['scopeid'] = scopeId
if(name):
request['name'] = name
body = json.dumps(request)
(s, h) = common.service_json_request(
self.__ipAddr, self.__port,
"POST",
HostIPInterface.URI_HOST_LIST_IPINTERFACES.format(hostUri),
body)
o = common.json_decode(s)
return o
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 update(self, hostName, ipinterfaceAddress, newprotocol,
newipAddress, newNetMask, newPrefixLength, newScopeId, tenant):
ipinterfaceUri = self.query_by_ipaddress(ipinterfaceAddress, hostName, tenant)
request = dict()
if(newprotocol):
request['protocol'] = newprotocol
if(newipAddress):
request['ip_address'] = newipAddress
if(newNetMask):
request['netmask'] = newNetMask
if(newPrefixLength):
request['prefix_length'] = newPrefixLength
if(newScopeId):
request['scope_id'] = newScopeId
body = json.dumps(request)
(s, h) = common.service_json_request(
self.__ipAddr, self.__port,
"PUT",
HostIPInterface.URI_IPINTERFACE_DETAILS.format(ipinterfaceUri),
body)
o = common.json_decode(s)
return o
def project_show_by_uri(self, uri, xml=False):
'''
Makes REST API call and retrieves project derails based on UUID
Parameters:
uri: UUID of project
Returns:
Project details in JSON response payload
'''
if (xml):
(s,
h) = common.service_json_request(self.__ipAddr, self.__port,
"GET",
Project.URI_PROJECT.format(uri),
None, None, xml)
return s
(s, h) = common.service_json_request(self.__ipAddr, self.__port, "GET",
Project.URI_PROJECT.format(uri),
None)
o = common.json_decode(s)
inactive = common.get_node_value(o, 'inactive')
if (inactive == True):
return None
return o
def computevpool_create(self, name, systemtype, description,
usematchedpools, varrays, minprocessors,
maxprocessors, mincores, maxcores, minthreads,
maxthreads, mincpuspeed, maxcpuspeed, minmemory,
maxmemory, minnics, maxnics, minhbas, maxhbas,
templates):
params = {'name': name}
#varray details to computevpool
if (varrays):
varrobj = VirtualArray(self.__ipAddr, self.__port)
varr_list = []
for varray in varrays:
varr_list.append(varrobj.varray_query(varray))
params["varrays"] = varr_list
#service profile templates
if (templates):
params["service_profile_template"] = templates
self._computevpool_prepare_payload(params, systemtype, description,
usematchedpools, minprocessors,
maxprocessors, mincores, maxcores,
minthreads, maxthreads, mincpuspeed,
maxcpuspeed, minmemory, maxmemory,
minnics, maxnics, minhbas, maxhbas)
body = json.dumps(params)
(s, h) = common.service_json_request(self.__ipAddr, self.__port,
"POST", self.URI_COMPUTE_VPOOL,
body)
return common.json_decode(s)
def create(
self, name, ip_address, port, user_name, passwd,
use_ssl, interface, sio_cli, element_manager_url, secondary_username, secondary_password, secondary_url):
body = json.dumps(
{
'name': name,
'ip_address': ip_address,
'port_number': port,
'user_name': user_name,
'password': passwd,
'use_ssl': use_ssl,
'interface_type': interface,
'sio_cli': sio_cli,
'element_manager_url': element_manager_url,
'secondary_username': secondary_username,
'secondary_password': secondary_password,
'secondary_url': secondary_url
}
)
(s, h) = common.service_json_request(
self.__ipAddr, self.__port, "POST",
StorageProvider.URI_STORAGEPROVIDER_LIST,
body)
o = common.json_decode(s)
return o
def update_computesystem(self, name, label, portnumber, username, password,
osinstallnetwork, use_ssl, computeimageserver):
parms = {}
if (label):
parms['name'] = label
if (portnumber):
parms['port_number'] = portnumber
if (username):
parms['user_name'] = username
if (password):
parms['password'] = password
if (osinstallnetwork):
parms['os_install_network'] = osinstallnetwork
if (use_ssl):
parms['use_ssl'] = use_ssl
if (computeimageserver):
from computeimageserver import ComputeImageServers
compute_image_server = ComputeImageServers(self.__ipAddr,
self.__port)
compute_image_server_uri = compute_image_server.query_computeimageserver(
computeimageserver)
parms['compute_image_server'] = compute_image_server_uri
uri = self.query_computesystem(name)
body = json.dumps(parms)
(s, h) = common.service_json_request(
self.__ipAddr, self.__port, "PUT",
self.URI_COMPUTE_SYSTEM_ID.format(uri), body)
return common.json_decode(s)
def storageport_update_uri(
self, spuri, tzuri, varraysToAdd, varrayToRemove, port_nw_id):
# varray changes
varray_obj = VirtualArray(self.__ipAddr, self.__port)
addvarrayList = varray_obj.convertNamesToUris(varraysToAdd)
removevarrayList = varray_obj.convertNamesToUris(varrayToRemove)
parms = {
'varray_assignment_changes': {'add':
{'varrays': addvarrayList},
'remove':
{'varrays': removevarrayList}
}
}
# Network to be associated
if(tzuri):
parms['network'] = tzuri
if(port_nw_id):
parms['port_network_id'] = port_nw_id
body = json.dumps(parms)
(s, h) = common.service_json_request(
self.__ipAddr, self.__port,
"PUT",
Storageport.URI_STORAGEPORT_UPDATE.format(spuri), body)
return common.json_decode(s)
def list_storageport_groups(self,
varrayName,
tenantName=None,
projectName=None,
exportGroupName=None):
varrayUri = self.varray_query(varrayName)
if (exportGroupName):
from exportgroup import ExportGroup
exportgroupObj = ExportGroup(self.__ipAddr, self.__port)
exportgroup_uri = exportgroupObj.exportgroup_query(
exportGroupName, projectName, tenantName, varrayuri)
(s, h) = common.service_json_request(
self.__ipAddr, self.__port, "GET",
VirtualArray.URI_LIST_VIRTUALARRAY_STORAGE_PORT_GROUPS.format(
varrayUri) + "?export_group=" + exportgroup_uri, None)
else:
(s, h) = common.service_json_request(
self.__ipAddr, self.__port, "GET",
VirtualArray.URI_LIST_VIRTUALARRAY_STORAGE_PORT_GROUPS.format(
varrayUri), None)
result = common.json_decode(s)
return result['storage_port_group']
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 list(self, project, tenant):
'''
This function will give us the list of consistency group uris
separated by comma.
prameters:
project: Name of the project path.
return
returns with list of consistency group ids separated by comma.
'''
if(tenant is None):
tenant = ""
projobj = Project(self.__ipAddr, self.__port)
fullproj = tenant + "/" + project
projuri = projobj.project_query(fullproj)
(s, h) = common.service_json_request(
self.__ipAddr, self.__port, "GET",
self.URI_CONSISTENCY_GROUPS_SEARCH.format(projuri), None)
o = common.json_decode(s)
if not o:
return []
congroups = []
resources = common.get_node_value(o, "resource")
for resource in resources:
congroups.append(resource["id"])
return congroups
def varray_create(self, label, autosanzoning,
devicereg, protection):
'''
creates a varray
parameters:
label: label of the varray
Returns:
JSON payload response
'''
try:
check = self.varray_show(label)
except SOSError as e:
if(e.err_code == SOSError.NOT_FOUND_ERR):
params = dict()
params['name'] = label
if(autosanzoning):
params['auto_san_zoning'] = autosanzoning
if(devicereg):
params['device_registered'] = devicereg
if(protection):
params['protection_type'] = protection
body = json.dumps(params)
(s, h) = common.service_json_request(
self.__ipAddr, self.__port, "POST",
VirtualArray.URI_VIRTUALARRAY, body)
o = common.json_decode(s)
return o
else:
raise e
if(check):
raise SOSError(SOSError.ENTRY_ALREADY_EXISTS_ERR,
"varray with name " + label + " already exists")
def show(self, name, project, tenant, xml=False):
'''
This function will take consistency group name and project name
as input and It will display the consistency group with details.
parameters:
name : Name of the consistency group.
project: Name of the project.
return
returns with Details of consistency group.
'''
uri = self.consistencygroup_query(name, project, tenant)
(s, h) = common.service_json_request(
self.__ipAddr, self.__port, "GET",
self.URI_CONSISTENCY_GROUPS_INSTANCE.format(uri), None)
o = common.json_decode(s)
if(o['inactive']):
return None
if(xml is False):
return o
(s, h) = common.service_json_request(
self.__ipAddr, self.__port, "GET",
self.URI_CONSISTENCY_GROUPS_INSTANCE.format(uri), None, None, xml)
if not s:
return None
return s
def s3_bucket_create(self,
namespace,
bucket,
projecturi,
vpooluri,
uid,
secret):
_headers = dict()
_headers['x-emc-namespace'] = namespace
if _headers.get("x-amz-date") is None:
_headers['Date'] = formatdate()
_headers = common.s3_hmac_base64_sig(
'PUT',
bucket,
None,
uid,
secret,
'application/json',
_headers,
None)
(s, h) = common.service_json_request(self.__ipAddr, S3_PORT, "PUT",
self.URI_S3_BUCKET_INSTANCE.
format(bucket), None, None, False,
'application/json',
None, _headers)
o = common.json_decode(s)
return o
def show_by_uri(self, uri, xml=False):
'''
Makes REST API call and retrieves network details based on UUID
Parameters:
uri: UUID of network
Returns:
Network details in JSON response payload
'''
(s, h) = common.service_json_request(self.__ipAddr, self.__port, "GET",
Network.URI_NETWORK.format(uri),
None)
o = common.json_decode(s)
if ('inactive' in o):
if (o['inactive']):
return None
if (xml):
(s,
h) = common.service_json_request(self.__ipAddr, self.__port,
"GET",
Network.URI_NETWORK.format(uri),
None, None, xml)
return s
return o
def update(self, uri, name, type, hourOfDay, length, lengthType, dayOfWeek, dayOfMonth, lastDayOfMonth=False):
request = dict()
if name is not None:
request["label"] = name
if type is not None:
request["executionWindowType"] = type
if hourOfDay is not None:
request["hourOfDayInUTC"] = hourOfDay
if length is not None:
request["executionWindowLength"] = length
if lengthType is not None:
request["executionWindowLengthType"] = lengthType
if dayOfWeek is not None:
request["dayOfWeek"] = dayOfWeek
if dayOfMonth is not None:
request["dayOfMonth"] = dayOfMonth
if lastDayOfMonth is not None:
request["lastDayOfMonth"] = lastDayOfMonth
body = json.dumps(request)
command = singletonURIHelperInstance.getUri(self.COMPONENT_TYPE, "show")
(s, h) = common.service_json_request(self.__ipAddr, self.__port, "PUT", command.format(uri), body)
o = common.json_decode(s)
return o
def create(self, name, nwtype, varrays=None, endpoints=None):
'''
Makes REST API call to create network
Parameters:
name: name of network
type: type of transport protocol. FC, IP or Ethernet
varrays : List of varrays to be associated
endpoints : List of endpoints to be added to network
Returns:
Created task details in JSON response payload
'''
networkId = self.query_by_name(name)
if (networkId):
raise SOSError(SOSError.ENTRY_ALREADY_EXISTS_ERR,
"Network with name " + name + " already exists")
request = dict()
request['name'] = name
request['transport_type'] = nwtype
if (varrays):
request['varrays'] = self.getVarrayList(varrays)
if (endpoints):
request['endpoints'] = self.getEndPointList(endpoints)
body = json.dumps(request)
(s, h) = common.service_json_request(self.__ipAddr, self.__port,
"POST", Network.URI_NETWORKS,
body)
o = common.json_decode(s)
return o
def show(self, name, project, tenant, xml = False):
'''
This function will take consistency group name and project name as input and
It will display the consistency group with details.
parameters:
name : Name of the consistency group.
project: Name of the project.
return
returns with Details of consistency group.
'''
uri = self.consistencygroup_query(name, project, tenant)
(s, h) = common.service_json_request(self.__ipAddr, self.__port, "GET",
self.URI_CONSISTENCY_GROUPS_INSTANCE.format(uri), None)
o = common.json_decode(s)
if( o['inactive']):
return None
if(xml == False):
return o
(s, h) = common.service_json_request(self.__ipAddr, self.__port, "GET",
self.URI_CONSISTENCY_GROUPS_INSTANCE.format(uri), None, None, xml)
if not s:
return None
return s
def storageportgroup_register_uri(self, sspuri, spguri):
(s, h) = common.service_json_request(
self.__ipAddr, self.__port, "POST",
Storageportgroup.URI_STORAGEPORTGROUP_REGISTER.format(
sspuri, spguri), None)
return common.json_decode(s)
def unassign(self, name, project=None):
'''
Vnasserver unassign
Parameters:
name: name of the vnasserver.
project : varray to be assigned .
Returns:
'''
vnasserverList = self.getvnasserverList(name)
request = {'vnas_server' : vnasserverList }
if(project):
proj_object = Project(self.__ipAddr, self.__port)
pro_uri = proj_object.project_query(project)
body = json.dumps(request)
(s, h) = common.service_json_request(self.__ipAddr, self.__port,
"PUT",
VnasServer.URI_VNASSERVER_UNASSIGN.format(pro_uri),
body)
if(s is not None and len(s) > 0):
print s
o = common.json_decode(s)
return o
def list_computeimageserver(self):
(s, h) = common.service_json_request(
self.__ipAddr, self.__port, "GET",
ComputeImageServers.URI_COMPUTE_IMAGE_SERVERS, None)
o = common.json_decode(s)
return o['compute_imageserver']
def update(self, name, new_name, ip_address, port, user_name, passwd,
use_ssl, interface, element_manager_url, secondary_username, secondary_password, secondary_url):
storageprovider_uri = self.query_by_name(name)
body = json.dumps(
{
'name': new_name,
'ip_address': ip_address,
'port_number': port,
'user_name': user_name,
'password': passwd,
'use_ssl': use_ssl,
'interface_type': interface,
'element_manager_url': element_manager_url,
'secondary_username': secondary_username,
'secondary_password': secondary_password,
'secondary_url': secondary_url
}
)
(s, h) = common.service_json_request(
self.__ipAddr, self.__port, "PUT",
StorageProvider.URI_STORAGEPROVIDER_DETAILS.format(
storageprovider_uri), body)
o = common.json_decode(s)
return o
def update_computeimageserver(self, name, label, imageserverip,
imageserversecondip, username, password,
tftpbootdir, osinstalltimeout, sshtimeout,
imageimporttimeout):
parms = {}
if (label):
parms['name'] = label
if (imageserverip):
parms['imageserver_ip'] = imageserverip
if (username):
parms['imageserver_user'] = username
if (password):
parms['imageserver_password'] = password
if (imageserversecondip):
parms['imageserver_secondip'] = imageserversecondip
if (tftpbootdir):
parms['tftpBootDir'] = tftpbootdir
if (osinstalltimeout):
parms['osinstall_timeout'] = osinstalltimeout
if (sshtimeout):
parms['ssh_timeout'] = sshtimeout
if (imageimporttimeout):
parms['imageimport_timeout'] = imageimporttimeout
uri = self.query_computeimageserver(name)
body = json.dumps(parms)
(s, h) = common.service_json_request(
self.__ipAddr, self.__port, "PUT",
self.URI_COMPUTE_IMAGE_SERVER_ID.format(uri), body)
return common.json_decode(s)
def scan(self):
(s, h) = common.service_json_request(
self.__ipAddr, self.__port,
'POST', StorageProvider.URI_STORAGEPROVIDER_SCAN,
None, None)
o = common.json_decode(s)
return o
def register_computesystem(self, computesystem):
uri = self.query_computesystem(computesystem)
(s, h) = common.service_json_request(
self.__ipAddr, self.__port, "POST",
ComputeSystem.URI_COMPUTE_SYSTEM_REGISTER.format(uri), None)
return common.json_decode(s)
def storageport_show_id(self, ssuri, spuri, xml=False):
(s, h) = common.service_json_request(self.__ipAddr, self.__port,
"GET", Storageport.URI_STORAGEPORT_DETAILS.format(ssuri, spuri), None, None, xml)
if(xml==False):
return common.json_decode(s)
else:
return s
def create(
self, name, ip_address, port, user_name, passwd,
use_ssl, interface, sio_cli, element_manager_url, secondary_username, secondary_password):
body = json.dumps(
{
'name': name,
'ip_address': ip_address,
'port_number': port,
'user_name': user_name,
'password': passwd,
'use_ssl': use_ssl,
'interface_type': interface,
'sio_cli': sio_cli,
'element_manager_url': element_manager_url,
'secondary_username': secondary_username,
'secondary_password': secondary_password
}
)
(s, h) = common.service_json_request(
self.__ipAddr, self.__port, "POST",
StorageProvider.URI_STORAGEPROVIDER_LIST,
body)
o = common.json_decode(s)
return o
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 scan(self):
(s, h) = common.service_json_request(
self.__ipAddr, self.__port,
'POST', StorageProvider.URI_STORAGEPROVIDER_SCAN,
None, None)
o = common.json_decode(s)
return o
def full_update_acl(self, project_name):
project_uri = self.project_query(project_name)
(s, h) = common.service_json_request(self.__ipAddr, self.__port, "PUT",
Project.URI_PROJECT_ACL.format(project_uri), None)
o = common.json_decode(s)
return o
def update(self, name, new_name, ip_address, port, user_name, passwd,
use_ssl, interface, element_manager_url, secondary_username, secondary_password):
storageprovider_uri = self.query_by_name(name)
body = json.dumps(
{
'name': new_name,
'ip_address': ip_address,
'port_number': port,
'user_name': user_name,
'password': passwd,
'use_ssl': use_ssl,
'interface_type': interface,
'element_manager_url': element_manager_url,
'secondary_username': secondary_username,
'secondary_password': secondary_password
}
)
(s, h) = common.service_json_request(
self.__ipAddr, self.__port, "PUT",
StorageProvider.URI_STORAGEPROVIDER_DETAILS.format(
storageprovider_uri), body)
o = common.json_decode(s)
return o
def consitencygroup_protection_failover_ops(self, name, project, tenant, copyvarray,
pit, accessmode, type="native", op="failover"):
'''
Failover the consistency group protection
Parameters:
name : name of the consistency group
project : name of the project
copyvarray : name of the copy target virtual array
pit : any UTC point-in-time formatted as "yyyy-MM-dd_HH:mm:ss" or datetime in milliseconds
accessmode : access mode
type : type of protection
Returns:
result of the action.
'''
group_uri = self.consistencygroup_query(name, project, tenant)
body = self.protection_copyparam(copyvarray, pit, accessmode, type)
uri = self.URI_BLOCK_CONSISTENCY_GROUP_FAILOVER.format(group_uri)
if op == 'failover_cancel':
uri = self.URI_BLOCK_CONSISTENCY_GROUP_FAILOVER_CANCEL.format(
group_uri)
elif op == 'swap':
uri = self.URI_BLOCK_CONSISTENCY_GROUP_SWAP.format(
group_uri)
elif op == 'update-access-mode':
uri = self.URI_BLOCK_CONSISTENCY_GROUP_ACCESS_MODE.format(
group_uri)
(s, h) = common.service_json_request(
self.__ipAddr, self.__port,
"POST",
uri,
body)
return common.json_decode(s)
def vdc_update(self, name, label, endpoint, key, certificatefile,
privatekeyfile, description):
uri = self.vdc_query(name)
parms = {}
if (name):
parms["name"] = label
if (endpoint):
parms["api_endpoint"] = endpoint
if (key):
parms["key"] = key
if (certificatefile is not None or privatekeyfile is not None):
key_and_certificate = dict()
if (certificatefile):
try:
certificatefs = open(certificatefile, 'r').read()
key_and_certificate['certificate_chain'] = certificatefs
except IOError as e:
raise SOSError(e.errno, e.strerror)
if (privatekeyfile):
try:
privatekey = open(privatekeyfile, 'r').read()
key_and_certificate['private_key'] = privatekey
except IOError as e:
raise SOSError(e.errno, e.strerror)
parms['key_and_certificate'] = key_and_certificate
if (description):
parms['description'] = description
body = json.dumps(parms)
(s, h) = common.service_json_request(
self.__ipAddr, self.__port, "PUT",
VirtualDatacenter.URI_VDC_GET.format(uri), body)
o = common.json_decode(s)
return o
def varray_update(self, label, autosanzoning,
devicereg, protection):
'''
creates a varray
parameters:
label: label of the varray
Returns:
JSON payload response
'''
uri = self.varray_query(label)
params = dict()
params['name'] = label
if(autosanzoning):
params['auto_san_zoning'] = autosanzoning
if(devicereg):
params['device_registered'] = devicereg
if(protection):
params['protection_type'] = protection
body = json.dumps(params)
(s, h) = common.service_json_request(
self.__ipAddr, self.__port, "PUT",
VirtualArray.URI_VIRTUALARRAY_URI.format(uri), body)
o = common.json_decode(s)
return o
def update(self, name, newtzonename, varrayname, newvarray):
"""
Makes REST API call to update network information
Parameters:
name: name of the network to be updated
varray: current varray name
newvarraylist: updated varray list
Returns
Created task details in JSON response payload
"""
turi = self.network_query(name, varrayname)
nhurilist = []
# update the new varray
if newvarray:
nhuri = VirtualArray(self.__ipAddr, self.__port).varray_query(newvarray)
nhurilist.append(nhuri)
else: # add a varray, That already exist with that zone
if varrayname != None:
nhuri = VirtualArray(self.__ipAddr, self.__port).varray_query(varrayname)
nhurilist.append(nhuri)
parms = {"name": newtzonename, "varrays": nhurilist}
body = json.dumps(parms)
(s, h) = common.service_json_request(self.__ipAddr, self.__port, "PUT", Network.URI_NETWORK.format(turi), body)
o = common.json_decode(s)
return o
def consitencygroup_protection_failover_ops(self,
name,
project,
tenant,
copyvarray,
pit,
type="native",
op="failover"):
'''
Failover the consistency group protection
Parameters:
name : name of the consistency group
project : name of the project
copyvarray : name of the copy target virtual array
pit : any UTC point-in-time formatted as "yyyy-MM-dd_HH:mm:ss" or datetime in milliseconds
type : type of protection
Returns:
result of the action.
'''
group_uri = self.consistencygroup_query(name, project, tenant)
body = self.protection_copyparam(copyvarray, pit, type)
uri = self.URI_BLOCK_CONSISTENCY_GROUP_FAILOVER.format(group_uri)
if op == 'failover_cancel':
uri = self.URI_BLOCK_CONSISTENCY_GROUP_FAILOVER_CANCEL.format(
group_uri)
elif op == 'swap':
uri = self.URI_BLOCK_CONSISTENCY_GROUP_SWAP.format(group_uri)
(s, h) = common.service_json_request(self.__ipAddr, self.__port,
"POST", uri, body)
return common.json_decode(s)
def list_computeimage(self, imagetype=None):
(s, h) = common.service_json_request(self.__ipAddr, self.__port, "GET",
ComputeImage.URI_COMPUTE_IMAGE,
None)
o = common.json_decode(s)
return o['compute_image']
def s3_bucket_list(namespace, projectname, uid, secret):
_headers = dict()
_headers['x-emc-namespace'] = namespace
_headers['Date'] = formatdate()
# use projectname if the api supports it
# check this below line
_headers = common.s3_hmac_base64_sig(
'GET',
None,
None,
uid,
secret,
'application/json',
_headers,
None)
(s, h) = common.service_json_request(self.__ipAddr, S3_PORT, "GET",
self.URI_S3_SERVICE_BASE, None,
None, False,
'application/json',
None, _headers)
o = common.json_decode(s)
return o
def varray_create(self, label, autosanzoning, devicereg, protection):
'''
creates a varray
parameters:
label: label of the varray
Returns:
JSON payload response
'''
try:
check = self.varray_show(label)
except SOSError as e:
if (e.err_code == SOSError.NOT_FOUND_ERR):
params = dict()
params['name'] = label
if (autosanzoning):
params['auto_san_zoning'] = autosanzoning
if (devicereg):
params['device_registered'] = devicereg
if (protection):
params['protection_type'] = protection
body = json.dumps(params)
(s, h) = common.service_json_request(
self.__ipAddr, self.__port, "POST",
VirtualArray.URI_VIRTUALARRAY, body)
o = common.json_decode(s)
return o
else:
raise e
if (check):
raise SOSError(SOSError.ENTRY_ALREADY_EXISTS_ERR,
"varray with name " + label + " already exists")
def update(self, ouri, name, size, oplock, securitystyle, sync):
qduri = self.quotadirectory_query(ouri, name)
params = dict()
if(size):
size = common.to_bytes(size)
params['size'] = size
if(oplock):
params['oplock'] = oplock
if(securitystyle):
params['security_style'] = securitystyle
body = json.dumps(params)
(s, h) = common.service_json_request(
self.__ipAddr, self.__port,
"PUT",
QuotaDirectory.URI_QUOTA_DIRECTORY_UPDATE.format(qduri), body)
o = common.json_decode(s)
if(sync):
return (
self.block_until_complete(
o['resource']['id'],
o["id"])
)
else:
return o
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 storagepool_update_by_uri(self, pooluri, varrays,
maxresources,
maxpoolutilization,
maxthinpoolsubscription):
'''
Updates a storagepool
'''
parms = dict()
body = None
if (maxresources):
parms['max_resources'] = maxresources
if (maxpoolutilization):
parms['max_pool_utilization_percentage'] = maxpoolutilization
if (maxthinpoolsubscription):
parms[
'max_thin_pool_subscription_percentage'] = maxthinpoolsubscription
if(varrays):
parms['varray_assignment_changes'] = varrays
body = json.dumps(parms)
#myuri = '/vdc/storage-pools/'+ pooluri +'/matched-vpool'
(s, h) = common.service_json_request(self.__ipAddr, self.__port, "PUT",
StoragePool.URI_STORAGEPOOL_UPDATE.format(pooluri), body)
o = common.json_decode(s)
return o
def backupset_restore_status(self, bname, islocal):
body = None
uri = Backup.URI_BACKUPSET_RESTORE_STATUS + "?" + "backupname=" + bname + "&" + "isLocal=" + islocal
(s, h) = common.service_json_request(self.__ipAddr, self.__port, "GET", uri, body)
o = common.json_decode(s)
return o
def list(self, project, tenant):
'''
This function will give us the list of consistency group uris
separated by comma.
prameters:
project: Name of the project path.
return
returns with list of consistency group ids separated by comma.
'''
if(tenant == None):
tenant = ""
projobj = Project(self.__ipAddr, self.__port)
fullproj = tenant+"/"+project
projuri = projobj.project_query(fullproj)
(s, h) = common.service_json_request(self.__ipAddr, self.__port, "GET",
self.URI_CONSISTENCY_GROUPS_SEARCH.format(projuri), None)
o = common.json_decode(s)
if not o:
return []
congroups=[]
resources = common.get_node_value(o, "resource")
for resource in resources:
congroups.append(resource["id"])
return congroups
def quotadirectory_updates(self, resourceUri, name, size, oplock,
securitystyle, advlim, softlim, grace):
qdUri = self.quotadirectory_query(resourceUri, name)
parms = dict()
if (size):
size = common.to_bytes(size)
parms["size"] = size
if (oplock):
parms["oplock"] = oplock
if (securitystyle):
parms["security_style"] = securitystyle
if advlim:
parms['notification_limit'] = advlim
if softlim:
parms['soft_limit'] = softlim
if grace:
parms['soft_grace'] = grace
body = json.dumps(parms)
# REST api call
(s, h) = common.service_json_request(
self.__ipAddr, self.__port, "POST",
QuotaDirectory.URI_QUOTA_DIRECTORY_UPDATE.format(qdUri), body)
o = common.json_decode(s)
return
def datastore_query(self, type, name):
'''
Returns the UID of the datastore specified by the name
'''
if (common.is_uri(name)):
return name
(s, h) = common.service_json_request(self.__ipAddr, self.__port, "GET",
URI_DATA_STORE_LIST, None)
o = common.json_decode(s)
pools = o['data_store']
ids = []
if (not o):
return ()
else:
if (not isinstance(pools, list)):
pools = [pools]
for pool in pools:
try:
pool_details = self.datastore_show_by_uri(
self.URI_DATA_STORE_LIST +
'/' +
type +
'/' +
uri)
if (pool_details['name'] == name):
return pool.get('id')
except:
pass
raise Exception('Bad Data Store name')
def create(self, ouri, name, size, oplock, securitystyle, sync,
synctimeout, advlim, softlim, grace):
parms = {
'name': name,
}
if (size):
size = common.to_bytes(size)
parms["size"] = size
if (oplock):
parms["oplock"] = oplock
if (securitystyle):
parms["security_style"] = securitystyle
if advlim:
parms['notification_limit'] = advlim
if softlim:
parms['soft_limit'] = softlim
if grace:
parms['soft_grace'] = grace
body = json.dumps(parms)
# REST api call
(s, h) = common.service_json_request(
self.__ipAddr, self.__port, "POST",
QuotaDirectory.URI_QUOTA_DIRECTORY.format(ouri), body)
o = common.json_decode(s)
if (sync):
return (self.block_until_complete(o['resource']['id'], o["id"],
synctimeout))
else:
return o
def quotadirectory_updates(self, resourceUri, name, size, oplock, securitystyle, advlim, softlim, grace):
qdUri = self.quotadirectory_query(
resourceUri,
name)
parms = dict()
if(size):
size = common.to_bytes(size)
parms["size"] = size
if(oplock):
parms["oplock"] = oplock
if(securitystyle):
parms["security_style"] = securitystyle
if advlim:
parms['notification_limit'] = advlim
if softlim:
parms['soft_limit'] = softlim
if grace:
parms['soft_grace'] = grace
body = json.dumps(parms)
# REST api call
(s, h) = common.service_json_request(
self.__ipAddr, self.__port,
"POST",
QuotaDirectory.URI_QUOTA_DIRECTORY_UPDATE.format(qdUri), body)
o = common.json_decode(s)
return
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 full_update_acl(self, project_name):
project_uri = self.project_query(project_name)
(s, h) = common.service_json_request(self.__ipAddr, self.__port, "PUT",
Project.URI_PROJECT_ACL.format(project_uri), None)
o = common.json_decode(s)
return o
def computevpool_list(self):
(s, h) = common.service_json_request(self.__ipAddr, self.__port, "GET",
ComputeVpool.URI_COMPUTE_VPOOL,
None)
o = common.json_decode(s)
return o['computevirtualpool']
