"""
Bindings data classes
"""
__author__ = 'VMware, Inc.'
__copyright__ = 'Copyright 2013-2014 VMware, Inc. All rights reserved. -- VMware Confidential'
import six
import sys
from vmware.vapi.bindings.common import raise_core_exception
# TODO: Split this into static and dynamic structures.
[docs]class VapiStruct(object):
"""
Representation of IDL Structure in python language bindings
"""
_validator_list = None
def __init__(self, mappings=None, struct_value=None):
"""
Initialize VapiStruct
:type mappings: :class:`dict` or :class:`None`
:param mappings: A mapping for all field names whose IDL name does
not match PEP8 standard name
:type struct_value: :class:`vmware.vapi.data.value.StructValue`
:param struct_value: StructValue to be used for VapiStruct or :class:`None`
"""
self._mappings = mappings
# fields will either be in native form or in unknown
# fields
self._unexpected_fields = None
self._struct_value = struct_value
[docs] def get_field(self, attr):
"""
Returns the struct field value
:type attr: :class:`str`
:param attr: Field name as defined in IDL
:rtype: :class:`object`
:return: Field value
"""
if self._mappings and attr in self._mappings:
return getattr(self, self._mappings[attr])
else:
return getattr(self, attr)
@classmethod
[docs] def validate_struct_value(cls, struct_value):
"""
Validate if the given struct value satisfies all
the constraints of this VapiStruct.
:type struct_value: :class:`vmware.vapi.data.value.StructValue`
:param struct_value: StructValue to be validated
:type validators: :class:`list` of :class:`vmware.vapi.data.validator.Validator`
:param validators: List of validators
:raise :class:`vmware.vapi.exception.CoreException` if a constraint is
not satisfied
"""
if cls._validator_list:
for validator in cls._validator_list:
msg_list = validator.validate(struct_value, None)
raise_core_exception(msg_list)
[docs] def validate_constraints(self):
"""
Validate if the current VapiStruct instance satisfies all the
constraints of this VapiStruct type.
:raise :class:`vmware.vapi.exception.CoreException` if a constraint is
not satisfied
"""
struct_value = self.get_struct_value()
self.validate_struct_value(struct_value)
@classmethod
[docs] def get_binding_type(cls):
"""
Returns the corresponding BindingType for the VapiStruct class
:rtype: :class:`vmware.vapi.bindings.type.BindingType`
:return: BindingType for this VapiStruct
"""
return getattr(cls, '_binding_type', None)
@classmethod
def _set_binding_type(cls, binding_type):
"""
Set the underlying BindingType for this VapiStruct.
:type binding_type: :class:`vmware.vapi.bindings.type.BindingType`
:param binding_type: BindingType for this VapiStruct
"""
cls._binding_type = binding_type
[docs] def get_struct_value(self):
"""
Returns the corresponding StructValue for the VapiStruct class
:rtype: :class:`vmware.vapi.data.value.StructValue`
:return: StructValue for this VapiStruct
"""
# For dynamic structures
if self._struct_value:
return self._struct_value
else:
# For static structures
from vmware.vapi.bindings.converter import TypeConverter
struct_value = TypeConverter.convert_to_vapi(self, self._binding_type)
unexpected_fields = self._unexpected_fields or {}
for k, v in six.iteritems(unexpected_fields):
struct_value.set_field(k, v)
return struct_value
def _set_unexpected_fields(self, unexpected_fields=None):
"""
Set the underlying StructValue for this VapiStruct. This is
an internal method and should only be used by vAPI runtime.
:type unexpected_fields: :class:`dict` of :class:`str` and
:class:`vmware.vapi.data.value.DataValue` or :class:`None`
:param struct_value: StructValue for this VapiStruct
"""
self._unexpected_fields = unexpected_fields
[docs] def convert_to(self, cls):
"""
Convert the underlying StructValue to an instance of the provided class
if possible. Conversion will be possible if the StructValue contains
all the fields expected by the provided class and the type of the value
in each fields matches the type of the field expected by the provided
class.
:type cls: :class:`vmware.vapi.data.value.StructValue`
:param cls: The type to convert to
:rtype: :class:'vmware.vapi.bindings.struct.VapiStruct'
:return: The converted value
"""
from vmware.vapi.bindings.converter import TypeConverter
return TypeConverter.convert_to_python(self.get_struct_value(),
cls.get_binding_type())
def _get_attrs(self):
"""
Returns the attributes of the vAPI structure object
:rtype: :class:`list` of :class:`str`
:return: List of attributes of this object
"""
# Using getmembers in inspect to return all the attributes
# of this object. And later filter those to get only the
# public data attributes
return [k for k in six.iterkeys(vars(self))
if not k.startswith('_')]
def __eq__(self, other):
for attr in self._get_attrs():
if getattr(self, attr) != getattr(other, attr):
return False
return True
def __ne__(self, other):
return not (self == other)
def __repr__(self):
class_name = self.__class__.__name__
attrs = self._get_attrs()
result = ', '.join(
['%s=%s' % (attr, repr(getattr(self, attr)))
for attr in attrs])
return '%s(%s)' % (class_name, result)
def __str__(self):
attrs = self._get_attrs()
result = ', '.join(
['%s : %s' % (attr, str(getattr(self, attr)))
for attr in attrs])
return '{%s}' % result
def __hash__(self):
return str(self).__hash__()
[docs]class PrettyPrinter(object):
"""
Helper class to Pretty print VapiStruct objects
"""
def __init__(self, stream=sys.stdout, indent=2):
"""
Initialize PrettyPrinter
:type stream: :class:`object`
:param stream: A stream object that implements File protocol's
write operation
:type indent: :class:`int`
:param indent: Indentation to be used for new lines
"""
self._stream = stream
self._indent = indent
[docs] def pprint(self, value, level=0):
"""
Print a vAPI native struct value
:type value: :class:`vmware.vapi.bindings.struct.VapiStruct`
:param value: VapiStruct to be pretty printed
:type level: :class:`int`
:param level: Indentation level
"""
self._pprint_struct(value, level + self._indent)
def _print_level(self, value, level, newline=True):
"""
Print data at a given identation level
:type value: :class:`str`
:param value: String to be printed
:type level: :class:`int`
:param level: Indentation level
:type newline: :class:`bool`
:param newline: If true, prints a new line after the data. If false,
only prints the data
"""
if level:
self._stream.write(' ' * level + value)
else:
self._stream.write(value)
if newline:
self._stream.write('\n')
def _process_value(self, value, level=0):
"""
Process a value
:type value: :class:`object`
:param value: Value to be processed
:type level: :class:`int`
:param level: Indentation level
"""
if isinstance(value, VapiStruct):
self._pprint_struct(value, level + self._indent)
elif isinstance(value, dict):
self._pprint_dict(value, level + self._indent)
elif isinstance(value, list):
self._pprint_list(value, level + self._indent)
elif isinstance(value, six.string_types):
self._print_level("'%s'," % value, 0)
elif isinstance(value, six.integer_types):
self._print_level('%s,' % value, 0)
elif value is None:
self._print_level('None,', 0)
else:
self._print_level('%s,' % value, level)
def _pprint_struct(self, value, level=0):
"""
Pretty print a struct
:type value: :class:`vmware.vapi.bindings.struct.VapiStruct`
:param value: Value to be processed
:type level: :class:`int`
:param level: Indentation level
"""
class_name = value.__class__.__name__
self._print_level(class_name + '(', 0)
for k in sorted(value._get_attrs()): # pylint: disable=W0212
v = getattr(value, k)
self._print_level('%s=' % k, level, False)
self._process_value(v, level)
self._print_level('),', level - self._indent)
def _pprint_dict(self, value, level=0):
"""
Pretty print a dictionary
:type value: :class:`dict`
:param value: Value to be processed
:type level: :class:`int`
:param level: Indentation level
"""
if not value:
self._print_level('{},', 0)
return
self._print_level('{', 0)
for k in sorted(value.keys()):
self._print_level("'%s':" % k, level, False)
self._process_value(value[k], level)
self._print_level('},', level - self._indent)
def _pprint_list(self, value, level=0):
"""
Pretty print a list
:type value: :class:`list`
:param value: Value to be processed
:type level: :class:`int`
:param level: Indentation level
"""
if not value:
self._print_level('[],', 0)
return
self._print_level('[', 0)
for v in value:
self._print_level('', level, False)
self._process_value(v, level)
self._print_level('],', level - self._indent)