def __init__(self, ip, username, password, port=443, verify=False):
super(UnityClient, self).__init__()
self.ip = ip
self._rest = UnityRESTConnector(ip,
port=port,
user=username,
password=password,
verify=verify)
self._system_version = None
def __init__(self,
ip,
username,
password,
port=443,
verify=False,
retries=None,
cache_interval=0):
super(UnityClient, self).__init__()
self.ip = ip
self._rest = UnityRESTConnector(ip,
port=port,
user=username,
password=password,
verify=verify,
retries=retries,
cache_interval=cache_interval)
self._system_version = None
class UnityClient(PerfManager):
def __init__(self,
ip,
username,
password,
port=443,
verify=False,
retries=None,
cache_interval=0):
super(UnityClient, self).__init__()
self.ip = ip
self._rest = UnityRESTConnector(ip,
port=port,
user=username,
password=password,
verify=verify,
retries=retries,
cache_interval=cache_interval)
self._system_version = None
@wrap_not_supported
def get_all(self,
type_name,
base_fields=None,
the_filter=None,
nested_fields=None):
"""Get the resource by resource id.
:param nested_fields: nested resource fields
:param base_fields: fields of this resource
:param the_filter: dictionary of filter like `{'name': 'abc'}`
:param type_name: Resource type. For example, pool, lun, nasServer.
:return: List of resource class objects
"""
fields = self.get_fields(type_name, base_fields, nested_fields)
the_filter = self.dict_to_filter_string(the_filter)
url = '/api/types/{}/instances'.format(type_name)
resp = self.rest_get(url, fields=fields, filter=the_filter)
ret = resp
while resp.has_next_page:
resp = self.rest_get(url,
fields=fields,
filter=the_filter,
page=resp.next_page)
ret.entries.extend(resp.entries)
return ret
@classmethod
def dict_to_filter_string(cls, the_filter):
def _get_non_list_value(k, v):
if isinstance(v, six.string_types):
r = '{} eq "{}"'.format(k, v)
elif isinstance(v, UnityEnum):
r = '{} eq {}'.format(k, v.value[0])
elif isinstance(v, UnityResource):
r = '{} eq "{}"'.format(k, v.get_id())
else:
r = '{} eq {}'.format(k, v)
return r
if the_filter:
items = []
for key in sorted(the_filter.keys()):
value = the_filter[key]
if value is None:
continue
if isinstance(value, (list, tuple, UnityEnumList)):
list_ret = ' or '.join(
[_get_non_list_value(key, item) for item in value])
items.append(list_ret)
else:
items.append(_get_non_list_value(key, value))
if items:
ret = ' and '.join(items)
else:
ret = None
else:
ret = None
return ret
def rest_get(self, url, fields=None, **params):
if fields is None:
fields = []
params['fields'] = ','.join(map(str, sorted(fields)))
url = self.assemble_url(url, **params)
return RestResponse(self._rest.get(url))
def rest_post(self, url, body=None, files=None, **params):
url = self.assemble_url(url, **params)
return RestResponse(self._rest.post(url, files=files, body=body))
def rest_delete(self, url, body=None, **params):
url = self.assemble_url(url, **params)
return RestResponse(self._rest.delete(url, body=body))
@classmethod
def assemble_url(cls, url, **params):
if not url.startswith('/'):
url = '/{}'.format(url)
if 'compact' not in params:
params['compact'] = True
param_list = []
for key in sorted(params.keys()):
if params[key] is None:
continue
param_list.append('{}={}'.format(key, params[key]))
url = '{}?{}'.format(url, '&'.join(param_list))
return url
@instance_cache
def _get_type_resource(self, type_name):
type_clz = storops.unity.resource.type_resource.UnityType
return type_clz(type_name, self)
def get_fields(self, type_name, base_fields=None, nested_fields=None):
if base_fields is not None:
ret = base_fields
else:
unity_type = self._get_type_resource(type_name)
ret = unity_type.fields
if nested_fields is not None:
if isinstance(nested_fields, six.text_type):
nested_fields = tuple([nested_fields])
ret = ret + nested_fields
return ret
def get_doc(self, clz):
return UnityDoc.get_doc(self, clz)
@wrap_not_supported
def get(self, type_name, obj_id, base_fields=None, nested_fields=None):
"""Get the resource by resource id.
:param nested_fields: nested resource fields.
:param type_name: Resource type. For example, pool, lun, nasServer.
:param obj_id: Resource id
:param base_fields: Resource fields to return
:return: List of tuple [(name, res_inst)]
"""
base_fields = self.get_fields(type_name, base_fields, nested_fields)
url = '/api/instances/{}/{}'.format(type_name, obj_id)
return self.rest_get(url, fields=base_fields)
def post(self, type_name, **kwargs):
url = '/api/types/{}/instances'.format(type_name)
body = self.make_body(kwargs)
return self.rest_post(url, body)
def action(self, type_name, obj_id, action, **kwargs):
base_url = '/api/instances/{}/{}/action/{}'
url = base_url.format(type_name, obj_id, action)
url_params = {}
if 'async_mode' in kwargs:
async_mode = kwargs['async_mode']
del kwargs['async_mode']
if async_mode:
url_params['timeout'] = 0
body = self.make_body(kwargs, allow_empty=True)
return self.rest_post(url, body, **url_params)
def modify(self, type_name, obj_id, **kwargs):
return self.action(type_name, obj_id, 'modify', **kwargs)
def type_action(self, type_name, action, **kwargs):
url = '/api/types/{}/action/{}'.format(type_name, action)
body = self.make_body(kwargs)
return self.rest_post(url, body)
def delete(self, type_name, _id, **kwargs):
url = '/api/instances/{}/{}'.format(type_name, _id)
url_params = {'compact': True}
if 'async_mode' in kwargs:
async_mode = kwargs['async_mode']
del kwargs['async_mode']
if async_mode:
url_params['timeout'] = 0
body = self.make_body(kwargs)
return self.rest_delete(url, body, **url_params)
@classmethod
def _is_empty(cls, value):
if isinstance(value, (dict, tuple, list)) and len(value) == 0:
ret = True
else:
ret = False
return ret
@classmethod
def make_body(cls, value=None, allow_empty=False, **kwargs):
if value is None and kwargs:
value = kwargs
if isinstance(value, dict):
ret = {}
for k, v in value.items():
v = cls.make_body(v, allow_empty=allow_empty)
if v is not None and (allow_empty or not cls._is_empty(v)):
ret[k] = v
elif isinstance(value,
(list, tuple, UnityResourceList, UnityEnumList)):
ret = [cls.make_body(v, allow_empty=allow_empty) for v in value]
elif isinstance(value, UnityEnum):
ret = value.index
elif isinstance(value, UnityResource):
ret = {'id': value.get_id()}
else:
ret = value
return ret
def set_system_version(self, version):
self._system_version = version
@property
def system_version(self):
if self._system_version is None:
clz = storops.unity.resource.system.UnityBasicSystemInfo
self._system_version = clz.get(cli=self).software_version
return self._system_version
def __init__(self, ip, username, password, port=443):
self._rest = UnityRESTConnector(ip,
port=port,
user=username,
password=password)
def __init__(self, ip, username, password, port=443):
self._rest = UnityRESTConnector(ip, port=port, user=username,
password=password)
self._smis = UnityWbemConnector(ip, user=username, password=password)
class UnityClient(object):
def __init__(self, ip, username, password, port=443):
self._rest = UnityRESTConnector(ip, port=port, user=username,
password=password)
self._smis = UnityWbemConnector(ip, user=username, password=password)
def get_all(self, type_name, fields=None, the_filter=None):
"""Get the resource by resource id.
:param the_filter: dictionary of filter like `{'name': 'abc'}`
:param type_name: Resource type. For example, pool, lun, nasServer.
:param fields: Resource fields to return
:return: List of resource class objects
"""
fields = self.get_fields(type_name, fields)
the_filter = self.dict_to_filter_string(the_filter)
url = '/api/types/{}/instances'.format(type_name)
return self.rest_get(url, fields=fields, filter=the_filter)
@classmethod
def dict_to_filter_string(cls, the_filter):
def _get_non_list_value(k, v):
if isinstance(v, six.string_types):
ret = '{} eq "{}"'.format(k, v)
elif isinstance(v, UnityEnum):
ret = '{} eq {}'.format(k, v.value[0])
else:
ret = '{} eq {}'.format(k, v)
return ret
if the_filter:
items = []
for k, v in the_filter.items():
if v is None:
continue
if isinstance(v, (list, tuple, UnityEnumList)):
list_ret = ' or '.join([_get_non_list_value(k, item)
for item in v])
items.append(list_ret)
else:
items.append(_get_non_list_value(k, v))
if items:
ret = ' and '.join(items)
else:
ret = None
else:
ret = None
return ret
def rest_get(self, url, fields=None, **params):
if fields is None:
fields = []
params['fields'] = ','.join(map(str, sorted(fields)))
url = self.assemble_url(url, **params)
return RestResponse(self._rest.get(url))
def rest_post(self, url, body=None, **params):
url = self.assemble_url(url, **params)
return RestResponse(self._rest.post(url, body=body))
def rest_delete(self, url, body=None, **params):
url = self.assemble_url(url, **params)
return RestResponse(self._rest.delete(url, body=body))
@classmethod
def assemble_url(cls, url, **params):
if not url.startswith('/'):
url = '/{}'.format(url)
if 'compact' not in params:
params['compact'] = True
param_list = []
for key in sorted(params.keys()):
if params[key] is None:
continue
param_list.append('{}={}'.format(key, params[key]))
url = '{}?{}'.format(url, '&'.join(param_list))
return url
@instance_cache
def _get_type_resource(self, type_name):
type_clz = storops.unity.resource.type_resource.UnityType
return type_clz(type_name, self)
def get_fields(self, type_name, fields=None):
if fields is not None:
ret = fields
else:
unity_type = self._get_type_resource(type_name)
ret = unity_type.fields
return ret
def get_doc(self, clz):
return UnityDoc.get_doc(self, clz)
def get(self, type_name, obj_id, fields=None):
"""Get the resource by resource id.
:param type_name: Resource type. For example, pool, lun, nasServer.
:param obj_id: Resource id
:param fields: Resource fields to return
:return: List of tuple [(name, res_inst)]
"""
fields = self.get_fields(type_name, fields)
url = '/api/instances/{}/{}'.format(
type_name, obj_id, ','.join(fields))
return self.rest_get(url, fields=fields)
def post(self, type_name, **kwargs):
url = '/api/types/{}/instances'.format(type_name)
body = self.make_body(kwargs)
return self.rest_post(url, body)
def action(self, type_name, obj_id, action, **kwargs):
base_url = '/api/instances/{}/{}/action/{}'
url = base_url.format(type_name, obj_id, action)
url_params = {}
if 'async' in kwargs:
async = kwargs['async']
del kwargs['async']
if async:
url_params['timeout'] = 0
body = self.make_body(kwargs, allow_empty=True)
return self.rest_post(url, body, **url_params)
def modify(self, type_name, obj_id, **kwargs):
return self.action(type_name, obj_id, 'modify', **kwargs)
def type_action(self, type_name, action, **kwargs):
url = '/api/types/{}/action/{}'.format(type_name, action)
body = self.make_body(kwargs)
return self.rest_post(url, body)
def delete(self, type_name, _id, **kwargs):
url = '/api/instances/{}/{}'.format(type_name, _id)
url_params = {'compact': True}
if 'async' in kwargs:
async = kwargs['async']
del kwargs['async']
if async:
url_params['timeout'] = 0
body = self.make_body(kwargs)
return self.rest_delete(url, body, **url_params)
@classmethod
def _is_empty(cls, value):
if isinstance(value, (dict, tuple, list)) and len(value) == 0:
ret = True
else:
ret = False
return ret
@classmethod
def make_body(cls, value=None, allow_empty=False, **kwargs):
if value is None and kwargs:
value = kwargs
if isinstance(value, dict):
ret = {}
for k, v in value.items():
v = cls.make_body(v, allow_empty=allow_empty)
if v is not None and (allow_empty or not cls._is_empty(v)):
ret[k] = v
elif isinstance(value, (list, tuple, UnityResourceList,
UnityEnumList)):
ret = [cls.make_body(v, allow_empty=allow_empty) for v in value]
elif isinstance(value, UnityEnum):
ret = value.index
elif isinstance(value, UnityResource):
ret = {'id': value.get_id()}
else:
ret = value
return ret
@property
@instance_cache
def account_management_service(self):
return self.ei_first('CIM_AccountManagementService')
@property
@instance_cache
def system(self):
return self.ei_first('EMC_VNXe_StorageSystemLeaf')
def ei(self, clz_name):
return self._smis.ei(clz_name)
def ai(self, from_inst_name, assoc_clz, result_clz):
return self._smis.ai(from_inst_name, assoc_clz, result_clz)
def ei_first(self, clz_name):
return self._smis.ei_first(clz_name)
def im(self, method_name, instance_name, **kwargs):
ret = self._smis.im(method_name, instance_name, **kwargs)
return CimResponse(ret)
def ref(self, obj_name, result_clz):
return self._smis.ref(obj_name, result_clz)
def di(self, obj_name):
return CimResponse(self._smis.di(obj_name))
def gi(self, obj_name):
return self._smis.gi(obj_name)