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 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 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 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 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 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 datastore_create(self, type, label, varray, cos, size, token,
mountpoint):
if ((varray) and (not common.is_uri(varray))):
from virtualarray import VirtualArray
obj = VirtualArray(self.__ipAddr, self.__port)
nbhinst = obj.varray_show(varray)
varray = nbhinst['id']
if (not common.is_uri(cos)):
from cos import Cos
obj = Cos(self.__ipAddr, self.__port)
# check this
cosinst = obj.cos_show(cos, 'object')
cos_uri = cosinst['id']
parms = {
'name': label,
'object_cos': cos_uri,
}
if (size):
parms['size'] = size
if (varray):
parms['varray'] = varray
if (mountpoint):
parms['mount_point'] = mountpoint
if (not token):
token = 'cli-create-' + cos
body = json.dumps(parms)
uri = self.URI_DATA_STORE_LIST + "/" + type
qparms = {'task': token}
if (qparms):
for qk in qparms.iterkeys():
if (qparms[qk] is not None):
uri += '&' if ('?' in uri) else '?'
uri += qk + '=' + qparms[qk]
(s, h) = common.service_json_request(self.__ipAddr, self.__port,
"POST", uri, body)
o = 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 init_vipr_cli_components(self):
import common as vipr_utils
vipr_utils.COOKIE = None
from exportgroup import ExportGroup
from host import Host
from hostinitiators import HostInitiator
from snapshot import Snapshot
from virtualarray import VirtualArray
from volume import Volume
# instantiate a few vipr cli objects for later use
self.volume_obj = Volume(self.configuration.vipr_hostname,
self.configuration.vipr_port)
self.exportgroup_obj = ExportGroup(self.configuration.vipr_hostname,
self.configuration.vipr_port)
self.host_obj = Host(self.configuration.vipr_hostname,
self.configuration.vipr_port)
self.hostinitiator_obj = HostInitiator(
self.configuration.vipr_hostname, self.configuration.vipr_port)
self.varray_obj = VirtualArray(self.configuration.vipr_hostname,
self.configuration.vipr_port)
self.snapshot_obj = Snapshot(self.configuration.vipr_hostname,
self.configuration.vipr_port)
def getVarrayList(self, varrays):
varray_obj = VirtualArray(self.__ipAddr, self.__port)
return varray_obj.convertNamesToUris(varrays)
def storagepool_list(args):
obj = StoragePool(args.ip, args.port)
try:
from storagesystem import StorageSystem
sys = StorageSystem(args.ip, args.port)
if (args.serialnumber):
device_id = sys.query_by_serial_number_and_type(
args.serialnumber, args.type)
else:
device = sys.show(name=args.storagesystem, type=args.type)
device_id = device['id']
uris = obj.storagepool_list_by_uri(device_id)
output = []
for uri in uris:
result = obj.storagepool_show_by_uri(device_id, uri)
# adding new column storage tier names assicated with pools
if ("tier_utilization_percentages" in result and args.long == True
and (result['registration_status'] == 'REGISTERED')):
tierUtilizationPercentages = result[
'tier_utilization_percentages']
# Go and fetch storage-tiers only if the utilization value is present
# Assumption here is, if there some utilization value, then
# such a pool has storage tiers
if (tierUtilizationPercentages is not None
and len(tierUtilizationPercentages) > 0):
tiernamelst = []
returnlst = []
# get list of storage tier objects
returnlst = obj.storagepool_get_tiers_by_uri(uri)
for item in returnlst:
tiernamelst.append(item['name'])
result["storage_tiers"] = tiernamelst
if (result):
output.append(result)
if (len(output) > 0):
if (args.verbose == True):
return common.format_json_object(output)
for iter in output:
from decimal import Decimal
if (iter['free_gb'] / (1024 * 1024) >= 1):
iter['free'] = Decimal(
Decimal(iter['free_gb']) / (1024 * 1024))
iter['free'] = str(iter['free']) + ' PB'
elif (iter['free_gb'] / (1024) >= 1):
iter['free'] = Decimal(Decimal(iter['free_gb']) / (1024))
iter['free'] = str(iter['free']) + ' TB'
else:
iter['free'] = str(iter['free_gb']) + ' GB'
if (iter['used_gb'] / (1024 * 1024) >= 1):
iter['used'] = Decimal(
Decimal(iter['used_gb']) / (1024 * 1024))
iter['used'] = str(iter['used']) + ' PB'
elif (iter['used_gb'] / (1024) >= 1):
iter['used'] = Decimal(Decimal(iter['used_gb']) / (1024))
iter['used'] = str(iter['used']) + ' TB'
else:
iter['used'] = str(iter['used_gb']) + ' GB'
if (args.long == True):
for iter in output:
if ('vpool_set' in iter):
vpoolnames = ''
for vpooliter in iter['vpool_set']:
from virtualpool import VirtualPool
obj = VirtualPool(args.ip, args.port)
if (args.type in ['isilon', 'vnxfile', 'netapp']):
vpooltype = 'file'
else:
vpooltype = 'block'
vpool = obj.vpool_show_uri(vpooltype,
vpooliter['id'])
if (vpool):
vpoolnames = vpoolnames + vpool['name'] + ','
if (len(vpoolnames) > 0):
vpoolnames = vpoolnames[0:len(vpoolnames) - 1]
if (vpoolnames):
iter['vpool_set'] = vpoolnames
else:
iter['vpool_set'] = 'NULL'
if ('tagged_varrays' in iter):
nbhnames = ''
for nbhiter in iter['tagged_varrays']:
from virtualarray import VirtualArray
obj = VirtualArray(args.ip, args.port)
nbh = obj.varray_show(nbhiter)
if (nbh):
nbhnames = nbhnames + nbh['name'] + ','
if (len(nbhnames) > 0):
nbhnames = nbhnames[0:len(nbhnames) - 1]
if (nbhnames):
iter['tagged_varrays'] = nbhnames
else:
iter['tagged_varrays'] = 'NULL'
from common import TableGenerator
TableGenerator(output, [
'pool_name', 'registration_status', 'free', 'used',
'vpool_set', 'tagged_varrays', 'storage_tiers'
]).printTable()
else:
from common import TableGenerator
TableGenerator(
output,
['pool_name', 'registration_status', 'free', 'used'
]).printTable()
except SOSError as e:
if (e.err_code == SOSError.NOT_FOUND_ERR):
raise SOSError(SOSError.NOT_FOUND_ERR,
"Storagepool list failed: " + e.err_text)
else:
raise e
def 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 ps_update(self, name, deviceip, deviceport, username, type, clusterid,
varraysToAdd, varraysToRemove):
'''
This is the function will
create the RecoverPoint with given name and type.
It will send REST API request to ViPR instance.
parameters:
name : Name of the protection system.
type : Type of the protection system { 'rp' }
username : Username to access protection system (usually "admin")
deviceip : IP address of management access of protection system
deviceport : Port to access protection system
clusterid : ID of cluster (RecoverPoint specific)
varraysToAdd : Assign virtual arrays to cluster
varraysToRemove : Unassign virtual arrays to cluster
Note: If clusterid is used, CLI supports changing only one cluster
virtual array assignments per command.
return
returns with protection system object with all details.
'''
# check for existance of Protection system.
passwd = None
if (username and len(username) > 0):
if sys.stdin.isatty():
passwd = getpass.getpass(
prompt="Enter password of the protection system: ")
else:
passwd = sys.stdin.readline().rstrip()
if (len(passwd) > 0):
if sys.stdin.isatty():
confirm_passwd = getpass.getpass(
prompt="Retype password: "******" " + sys.argv[1] + " " + sys.argv[2] +
": error: Passwords mismatch")
else:
raise SOSError(
SOSError.CMD_LINE_ERR, sys.argv[0] + " " + sys.argv[1] +
" " + sys.argv[2] + ": error: Invalid password")
parms = dict()
if (deviceip):
parms['ip_address'] = deviceip
if (deviceport):
parms['port_number'] = deviceport
if (username):
parms['user_name'] = username
if (passwd):
parms['password'] = passwd
if (clusterid):
# varray changes
varray_obj = VirtualArray(self.__ipAddr, self.__port)
addvarrayList = varray_obj.convertNamesToUris(varraysToAdd)
removevarrayList = varray_obj.convertNamesToUris(varraysToRemove)
parms = {
'varray_assignment_changes': [{
'add': {
'varrays': addvarrayList
},
'remove': {
'varrays': removevarrayList
},
'cluster_id': clusterid
}]
}
uri = self.ps_query(name)
body = json.dumps(parms)
(s, h) = common.service_json_request(
self.__ipAddr, self.__port, "PUT",
self.URI_PROTECTION_SYSTEM_UPDATE.format(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)
