def computevpool_update(self, name, label,
systemtype,
description,
usematchedpools,
minprocessors, maxprocessors,
mincores, maxcores,
minthreads, maxthreads,
mincpuspeed, maxcpuspeed,
minmemory, maxmemory,
minnics, maxnics,
minhbas, maxhbas,
varray_add, varray_remove,
templates_add, templates_remove):
compute_uri = self.computevpool_query(name)
params = {
'name': label
}
self._computevpool_prepare_payload(params, systemtype,
description,
usematchedpools,
minprocessors, maxprocessors,
mincores, maxcores,
minthreads, maxthreads,
mincpuspeed, maxcpuspeed,
minmemory, maxmemory,
minnics, maxnics,
minhbas, maxhbas)
nhobj = VirtualArray(self.__ipAddr, self.__port)
if (varray_add):
add_varr_list = []
for varray in varray_add:
add_varr_list.append(nhobj.varray_query(varray))
params['varray_changes'] = {'add': {'varrays': add_varr_list}}
if (varray_remove):
remove_varr_list = []
for varray in varray_remove:
remove_varr_list.append(nhobj.varray_query(varray))
params['varray_changes'] = {'remove':
{'varrays': remove_varr_list}}
if(templates_add):
params['service_profile_template_changes'] = {'add':
{'service_profile_template': templates_add}}
if(templates_remove):
params['service_profile_template_changes'] = {'remove':
{'service_profile_template':
templates_remove}}
body = json.dumps(params)
(s, h) = common.service_json_request(self.__ipAddr,
self.__port, "PUT",
self.URI_COMPUTE_VPOOL_ID.format(compute_uri),
body)
return common.json_decode(s)
def storagepool_update(self, storagesystem, serialnumber, devicetype, poolname, nhadds, nhrems, volumetype, maxresources, maxpoolutilization, maxthinpoolsubscription):
nhassignments = dict();
#parms['varray_assignment_changes'] = nhassignments
if (nhadds):
nhlst = []
for iter in nhadds:
from virtualarray import VirtualArray
obj = VirtualArray(self.__ipAddr, self.__port)
nbhuri = obj.varray_query(iter)
if(nbhuri):
nhlst.append(nbhuri)
if(nhlst):
nh = dict();
nh['varrays'] = nhlst
nhassignments['add'] = nh;
if (nhrems):
nhlst = []
for iter in nhrems:
from virtualarray import VirtualArray
obj = VirtualArray(self.__ipAddr, self.__port)
nbhuri = obj.varray_query(iter)
if(nbhuri):
nhlst.append(nbhuri)
if(nhlst):
nh = dict();
nh['varrays'] = nhlst
nhassignments['remove'] = nh;
if(storagesystem):
device_id = self.storagesystem_query(storagesystem, devicetype, None)
else:
device_id = self.storagesystem_query(None, devicetype, serialnumber)
storagepool_ids = self.storagepool_list_by_uri(device_id)
for uri in storagepool_ids:
storpool = self.storagepool_show_by_uri(device_id,uri)
if(poolname):
if(storpool['pool_name'] == poolname):
if ( (volumetype) and (storpool['supported_volume_types'] == volumetype) ):
self.storagepool_update_by_uri(storpool['id'], nhassignments, maxresources, maxpoolutilization, maxthinpoolsubscription )
if (not volumetype):
self.storagepool_update_by_uri(storpool['id'], nhassignments, maxresources, maxpoolutilization, maxthinpoolsubscription )
else:
if (not volumetype):
self.storagepool_update_by_uri(storpool['id'], nhassignments, maxresources, maxpoolutilization, maxthinpoolsubscription)
if ( (volumetype) and (storpool['supported_volume_types'] == volumetype) ):
self.storagepool_update_by_uri(storpool['id'], nhassignments, maxresources, maxpoolutilization, maxthinpoolsubscription)
def computevpool_update(self, name, label, systemtype, description,
usematchedpools, minprocessors, maxprocessors,
mincores, maxcores, minthreads, maxthreads,
mincpuspeed, maxcpuspeed, minmemory, maxmemory,
minnics, maxnics, minhbas, maxhbas, varray_add,
varray_remove, templates_add, templates_remove):
compute_uri = self.computevpool_query(name)
params = {'name': label}
self._computevpool_prepare_payload(params, systemtype, description,
usematchedpools, minprocessors,
maxprocessors, mincores, maxcores,
minthreads, maxthreads, mincpuspeed,
maxcpuspeed, minmemory, maxmemory,
minnics, maxnics, minhbas, maxhbas)
nhobj = VirtualArray(self.__ipAddr, self.__port)
if (varray_add):
add_varr_list = []
for varray in varray_add:
add_varr_list.append(nhobj.varray_query(varray))
params['varray_changes'] = {'add': {'varrays': add_varr_list}}
if (varray_remove):
remove_varr_list = []
for varray in varray_remove:
remove_varr_list.append(nhobj.varray_query(varray))
params['varray_changes'] = {
'remove': {
'varrays': remove_varr_list
}
}
if (templates_add):
params['service_profile_template_changes'] = {
'add': {
'service_profile_template': templates_add
}
}
if (templates_remove):
params['service_profile_template_changes'] = {
'remove': {
'service_profile_template': templates_remove
}
}
body = json.dumps(params)
(s, h) = common.service_json_request(
self.__ipAddr, self.__port, "PUT",
self.URI_COMPUTE_VPOOL_ID.format(compute_uri), body)
return common.json_decode(s)
def protection_copyparam(self,
copyvarray,
pit,
type="native",
sync='false'):
copies_param = dict()
copy = dict()
copy_entries = []
copy['type'] = type
if (pit != ""):
copy['pointInTime'] = pit
#true=split
if (sync == 'true'):
copy['sync'] = "true"
else:
copy['sync'] = "false"
#for rp and srdf target virtual array should be provided
from virtualarray import VirtualArray
varray_obj = VirtualArray(self.__ipAddr, self.__port)
varray_uri = varray_obj.varray_query(copyvarray)
copy['copyID'] = varray_uri
copy_entries.append(copy)
copies_param['copy'] = copy_entries
return json.dumps(copies_param)
def assign(self, name, varray):
"""
Retrieves network details based on network name
Parameters:
name: name of the network.
varray: varray to be assigned
Returns:
Network details in JSON response payload
"""
turi = self.network_query(name, None)
nuri = None
nlst = []
if varray:
from virtualarray import VirtualArray
varray_obj = VirtualArray(self.__ipAddr, self.__port)
for iter in varray:
nuri = varray_obj.varray_query(iter)
nlst.append(nuri)
if len(nlst) > 0:
parms = {"varrays": nlst}
else:
parms = {"varrays": []}
body = json.dumps(parms)
(s, h) = common.service_json_request(self.__ipAddr, self.__port, "PUT", Network.URI_NETWORK.format(turi), body)
def assign(self, name, varray=None):
'''
Retrieves network details based on network name
Parameters:
name: name of the network.
varray: varray to be assigned
Returns:
Network details in JSON response payload
'''
turi = self.query_by_name(name)
nuri = None
nlst = []
if(varray):
varray_obj = VirtualArray(self.__ipAddr, self.__port)
for item in varray:
nuri = varray_obj.varray_query(item)
nlst.append(nuri)
if(len(nlst) > 0):
parms = {
'varrays': nlst
}
else:
parms = {
'varrays': []
}
body = json.dumps(parms)
common.service_json_request(self.__ipAddr, self.__port,
"PUT",
Network.URI_NETWORK.format(turi),
body)
def assign(self, name, varray=None):
'''
Retrieves network details based on network name
Parameters:
name: name of the network.
varray: varray to be assigned
Returns:
Network details in JSON response payload
'''
turi = self.query_by_name(name)
nuri = None
nlst = []
if (varray):
varray_obj = VirtualArray(self.__ipAddr, self.__port)
for item in varray:
nuri = varray_obj.varray_query(item)
nlst.append(nuri)
if (len(nlst) > 0):
parms = {'varrays': nlst}
else:
parms = {'varrays': []}
body = json.dumps(parms)
common.service_json_request(self.__ipAddr, self.__port, "PUT",
Network.URI_NETWORK.format(turi), body)
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 protection_copyparam(
self, copyvarray, pit, accessmode, type="native", sync='false'):
copies_param = dict()
copy = dict()
copy_entries = []
copy['type'] = type
if(pit != ""):
copy['pointInTime'] = pit
if(accessmode != ""):
copy['accessMode'] = accessmode
#true=split
if(sync == 'true'):
copy['sync'] = "true"
else:
copy['sync'] = "false"
#for rp and srdf target virtual array should be provided
from virtualarray import VirtualArray
varray_obj = VirtualArray(self.__ipAddr, self.__port)
varray_uri = varray_obj.varray_query(copyvarray)
copy['copyID'] = varray_uri
copy_entries.append(copy)
copies_param['copy'] = copy_entries
return json.dumps(copies_param)
def exportgroup_create(self, name, project, tenant, varray, exportgrouptype, export_destination=None):
"""
This function will take export group name and project name as input
and it will create the Export group with given name.
parameters:
name : Name of the export group.
project: Name of the project path.
tenant: Container tenant name.
return
returns with status of creation.
"""
# check for existance of export group.
try:
status = self.exportgroup_show(name, project, tenant)
except SOSError as e:
if e.err_code == SOSError.NOT_FOUND_ERR:
if tenant is None:
tenant = ""
fullproj = tenant + "/" + project
projObject = Project(self.__ipAddr, self.__port)
projuri = projObject.project_query(fullproj)
varrayObject = VirtualArray(self.__ipAddr, self.__port)
nhuri = varrayObject.varray_query(varray)
parms = {"name": name, "project": projuri, "varray": nhuri, "type": exportgrouptype}
if exportgrouptype and export_destination:
if exportgrouptype == "Cluster":
cluster_obj = Cluster(self.__ipAddr, self.__port)
try:
cluster_uri = cluster_obj.cluster_query(export_destination, fullproj)
except SOSError as e:
raise e
parms["clusters"] = [cluster_uri]
elif exportgrouptype == "Host":
host_obj = Host(self.__ipAddr, self.__port)
try:
host_uri = host_obj.query_by_name(export_destination)
except SOSError as e:
raise e
parms["hosts"] = [host_uri]
body = json.dumps(parms)
(s, h) = common.service_json_request(self.__ipAddr, self.__port, "POST", self.URI_EXPORT_GROUP, body)
o = common.json_decode(s)
return o
else:
raise e
if status:
raise SOSError(SOSError.ENTRY_ALREADY_EXISTS_ERR, "Export group with name " + name + " already exists")
def list_networks(self, varray):
'''
Makes REST API call to list networks in a varray
Parameters:
varray: name of varray
Returns:
List of network uuids in JSONo response payload
'''
varray_uri = None
if (varray):
varray_obj = VirtualArray(self.__ipAddr, self.__port)
varray_uri = varray_obj.varray_query(varray)
return self.list_by_uri(varray_uri)
def list_networks(self, varray):
'''
Makes REST API call to list networks in a varray
Parameters:
varray: name of varray
Returns:
List of network uuids in JSONo response payload
'''
varray_uri = None
if(varray):
varray_obj = VirtualArray(self.__ipAddr, self.__port)
varray_uri = varray_obj.varray_query(varray)
return self.list_by_uri(varray_uri)
def create(self, varray, name, type):
"""
Makes REST API call to create network in a varray
Parameters:
varray: name of varray
name: name of network
type: type of transport protocol. FC, IP or Ethernet
Returns:
Created task details in JSON response payload
"""
network_exists = True
try:
self.show(name, varray)
except SOSError as e:
if e.err_code == SOSError.NOT_FOUND_ERR:
network_exists = False
else:
raise e
if network_exists:
raise SOSError(SOSError.ENTRY_ALREADY_EXISTS_ERR, "Network with name: " + name + " already exists")
from virtualarray import VirtualArray
varray_obj = VirtualArray(self.__ipAddr, self.__port)
varray_uri = varray_obj.varray_query(varray)
# As per the ViPR Source Code 5th July
body = json.dumps({"name": name, "transport_type": type})
# As per the wiki apec
"""
body = json.dumps({'network':
{
'name' : name,
'' :
[
{ "name" : endpoint }
]
}
})
"""
(s, h) = common.service_json_request(
self.__ipAddr, self.__port, "POST", Network.URI_VIRTUALARRAY_NETWORK.format(varray_uri), body
)
o = common.json_decode(s)
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 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 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)
def storagepool_update(self, storagesystem, serialnumber, devicetype,
poolname, nhadds, nhrems, volumetype, maxresources,
maxpoolutilization, maxthinpoolsubscription):
nhassignments = dict()
#parms['varray_assignment_changes'] = nhassignments
if (nhadds):
nhlst = []
for iter in nhadds:
from virtualarray import VirtualArray
obj = VirtualArray(self.__ipAddr, self.__port)
nbhuri = obj.varray_query(iter)
if (nbhuri):
nhlst.append(nbhuri)
if (nhlst):
nh = dict()
nh['varrays'] = nhlst
nhassignments['add'] = nh
if (nhrems):
nhlst = []
for iter in nhrems:
from virtualarray import VirtualArray
obj = VirtualArray(self.__ipAddr, self.__port)
nbhuri = obj.varray_query(iter)
if (nbhuri):
nhlst.append(nbhuri)
if (nhlst):
nh = dict()
nh['varrays'] = nhlst
nhassignments['remove'] = nh
if (storagesystem):
device_id = self.storagesystem_query(storagesystem, devicetype,
None)
else:
device_id = self.storagesystem_query(None, devicetype,
serialnumber)
storagepool_ids = self.storagepool_list_by_uri(device_id)
not_found = 1
for uri in storagepool_ids:
storpool = self.storagepool_show_by_uri(device_id, uri)
if (storpool['pool_name']) == poolname:
not_found = 0
if (poolname):
if (storpool['pool_name'] == poolname):
if ((volumetype) and
(storpool['supported_resource_types'] == volumetype)):
self.storagepool_update_by_uri(
storpool['id'], nhassignments, maxresources,
maxpoolutilization, maxthinpoolsubscription)
if (not volumetype):
self.storagepool_update_by_uri(
storpool['id'], nhassignments, maxresources,
maxpoolutilization, maxthinpoolsubscription)
else:
if (not volumetype):
self.storagepool_update_by_uri(storpool['id'],
nhassignments, maxresources,
maxpoolutilization,
maxthinpoolsubscription)
if ((volumetype) and
(storpool['supported_resource_types'] == volumetype)):
self.storagepool_update_by_uri(storpool['id'],
nhassignments, maxresources,
maxpoolutilization,
maxthinpoolsubscription)
if (poolname is not None):
if (not_found == 1):
raise SOSError(
SOSError.NOT_FOUND_ERR,
"Storagepool with name " + str(poolname) + " not found\n")
def storagepool_update(self, storagesystem, serialnumber, devicetype,
poolname,
nhadds, nhrems,
volumetype, maxresources,
maxpoolutilization,
maxthinpoolsubscription):
nhassignments = dict()
#parms['varray_assignment_changes'] = nhassignments
if (nhadds):
nhlst = []
for iter in nhadds:
from virtualarray import VirtualArray
obj = VirtualArray(self.__ipAddr, self.__port)
nbhuri = obj.varray_query(iter)
if(nbhuri):
nhlst.append(nbhuri)
if(nhlst):
nh = dict()
nh['varrays'] = nhlst
nhassignments['add'] = nh
if (nhrems):
nhlst = []
for iter in nhrems:
from virtualarray import VirtualArray
obj = VirtualArray(self.__ipAddr, self.__port)
nbhuri = obj.varray_query(iter)
if(nbhuri):
nhlst.append(nbhuri)
if(nhlst):
nh = dict()
nh['varrays'] = nhlst
nhassignments['remove'] = nh
if(storagesystem):
device_id = self.storagesystem_query(storagesystem,
devicetype,
None)
else:
device_id = self.storagesystem_query(None, devicetype,
serialnumber)
storagepool_ids = self.storagepool_list_by_uri(device_id)
not_found=1
for uri in storagepool_ids:
storpool = self.storagepool_show_by_uri(device_id, uri)
if(storpool['pool_name'])==poolname:
not_found=0
if(poolname):
if(storpool['pool_name'] == poolname):
if ((volumetype) and
(storpool['supported_resource_types'] == volumetype)):
self.storagepool_update_by_uri(storpool['id'],
nhassignments,
maxresources,
maxpoolutilization,
maxthinpoolsubscription)
if (not volumetype):
self.storagepool_update_by_uri(storpool['id'],
nhassignments,
maxresources,
maxpoolutilization,
maxthinpoolsubscription)
else:
if (not volumetype):
self.storagepool_update_by_uri(storpool['id'],
nhassignments,
maxresources,
maxpoolutilization,
maxthinpoolsubscription)
if ((volumetype) and
(storpool['supported_resource_types'] == volumetype)):
self.storagepool_update_by_uri(storpool['id'],
nhassignments,
maxresources,
maxpoolutilization,maxthinpoolsubscription)
if(poolname is not None):
if(not_found==1):
raise SOSError(SOSError.NOT_FOUND_ERR,
"Storagepool with name "
+ str(poolname) + " not found\n")
