def get_data_definition(self):
# Get a cover all data definitions
data_defs = [
VoidDefinition(),
IntegerDefinition(),
DoubleDefinition(),
StringDefinition(),
SecretDefinition(),
BooleanDefinition(),
BlobDefinition(),
OpaqueDefinition(),
OptionalDefinition(IntegerDefinition()),
ListDefinition(IntegerDefinition()),
StructDefinition('struct',
[ ('int', IntegerDefinition()),
('str', StringDefinition()),
('struct', StructDefinition('struct1',
[('double', DoubleDefinition()),
('secret', SecretDefinition())])),
('list', ListDefinition(StructDefinition('struct1',
[('double', DoubleDefinition()),
('secret', SecretDefinition())]))),
('optional', ListDefinition(StructDefinition('struct1',
[('double', DoubleDefinition()),
('secret', SecretDefinition())]))) ]),
ErrorDefinition('error',
[ ('int', IntegerDefinition()),
('str', StringDefinition()) ]),
]
return data_defs
def __init__(self, name, introspection_adapter):
"""
Initialize OperationApiInterface
:type name: :class:`str`
:param name: Name of the provider
:type introspection_adapter:
:class:`vmware.vapi.provider.introspection.ApiProviderIntrospector`
:param introspection_adapter: Adapter for fetching introspection information
"""
self._adapter = introspection_adapter
iface_id = InterfaceIdentifier(
'com.vmware.vapi.std.introspection.operation')
method_defs = {}
methods = {}
# list method
list_method_id = MethodIdentifier(iface_id, 'list')
output_def = ListDefinition(StringDefinition())
method_defs[list_method_id] = MethodDefinition(
list_method_id,
StructDefinition(OPERATION_INPUT,
[('service_id', StringDefinition())]), output_def,
[not_found_def])
methods[list_method_id] = self._list
# get method
get_method_id = MethodIdentifier(iface_id, 'get')
data_ref_def = StructRefDefinition(
'com.vmware.vapi.std.introspection.operation.data_definition')
field_def = StructDefinition(MAP_ENTRY, [('key', StringDefinition()),
('value', data_ref_def)])
data_def = StructDefinition(
'com.vmware.vapi.std.introspection.operation.data_definition',
[('type', StringDefinition()),
('element_definition', OptionalDefinition(data_ref_def)),
('name', OptionalDefinition(StringDefinition())),
('fields', OptionalDefinition(ListDefinition(field_def)))])
data_ref_def.target = data_def
output_def = StructDefinition(
'com.vmware.vapi.std.introspection.operation.info',
[('input_definition', data_def), ('output_definition', data_def),
('error_definitions', ListDefinition(data_def))])
method_defs[get_method_id] = MethodDefinition(
get_method_id,
StructDefinition(OPERATION_INPUT,
[('service_id', StringDefinition()),
('operation_id', StringDefinition())]),
output_def, [not_found_def])
methods[get_method_id] = self._get
IntrospectionBaseApiInterface.__init__(self, iface_id, method_defs,
methods)
def test_list_type(self):
list_type = ListType(IntegerType())
self.assertNotEqual(list_type, None)
self.assertEqual(list_type.definition,
ListDefinition(IntegerDefinition()))
self.assertEqual(list_type.element_type.definition,
IntegerDefinition())
def test_map_type(self):
map_type = MapType(StringType(), StringType())
self.assertNotEqual(map_type, None)
self.assertEqual(
map_type.definition,
ListDefinition(
StructDefinition(MAP_ENTRY, [('key', StringDefinition()),
('value', StringDefinition())])))
self.assertRaises(TypeError, MapType, 'bogus', StringType())
self.assertRaises(TypeError, MapType, StringType(), 'bogus')
def visit_set(self, typ):
"""
Visit a set value
:type typ: :class:`SetType`
:param typ: Binding type of the value
"""
typ.element_type.accept(self)
element_def = self._out_value
self._out_value = ListDefinition(element_def)
def make_map_def(key, value):
"""
Internal function to create map definition from a key and value
definitions. For use only by vAPI runtime.
:type key: :class:`vmware.vapi.data.type.DataDefinition`
:param key: DataDefintion for the map key
:type value: :class:`vmware.vapi.data.type.DataDefinition`
:param value: DataDefintion for the map value
"""
return ListDefinition(
StructDefinition(MAP_ENTRY, ((_MAP_KEY_FIELD_NAME, key),
(_MAP_VALUE_FIELD_NAME, value))))
def __init__(self, name, introspection_adapter):
"""
Initialize ServiceApiInterface
:type name: :class:`str`
:param name: Name of the provider
:type introspection_adapter:
:class:`vmware.vapi.provider.introspection.ApiProviderIntrospector`
:param introspection_adapter: Adapter for fetching introspection information
"""
self._adapter = introspection_adapter
iface_id = InterfaceIdentifier(
'com.vmware.vapi.std.introspection.service')
method_defs = {}
methods = {}
# list method
list_method_id = MethodIdentifier(iface_id, 'list')
output_def = ListDefinition(StringDefinition())
method_defs[list_method_id] = MethodDefinition(
list_method_id, StructDefinition(OPERATION_INPUT, []), output_def,
[])
methods[list_method_id] = self._list
# get method
get_method_id = MethodIdentifier(iface_id, 'get')
output_def = StructDefinition(
'com.vmware.vapi.std.introspection.service.info',
[('operations', ListDefinition(StringDefinition()))])
method_defs[get_method_id] = MethodDefinition(
get_method_id,
StructDefinition(OPERATION_INPUT, [('id', StringDefinition())]),
output_def, [not_found_def])
methods[get_method_id] = self._get
IntrospectionBaseApiInterface.__init__(self, iface_id, method_defs,
methods)
def visit_map(self, typ):
"""
Visit a map value
:type typ: :class:`MapType`
:param typ: Binding type of the value
"""
field_defs = []
typ.key_type.accept(self)
key_def = self._out_value
field_defs.append((MAP_KEY_FIELD, key_def))
typ.value_type.accept(self)
value_def = self._out_value
field_defs.append((MAP_VALUE_FIELD, value_def))
element_def = StructDefinition(MAP_ENTRY, field_defs)
self._out_value = ListDefinition(element_def)
__copyright__ = 'Copyright 2015 VMware, Inc. All rights reserved. -- VMware Confidential' # pylint: disable=line-too-long
from vmware.vapi.data.definition import (
DynamicStructDefinition, ErrorDefinition, ListDefinition,
OptionalDefinition, StringDefinition, StructDefinition)
from vmware.vapi.l10n.runtime import message_factory
_ID_FIELD_NAME = 'id'
_DEFAULT_MESSAGE_FIELD_NAME = 'default_message'
_ARGS_FIELD_NAME = 'args'
localizable_message_def = StructDefinition(
'com.vmware.vapi.std.localizable_message',
((_ID_FIELD_NAME, StringDefinition()),
(_DEFAULT_MESSAGE_FIELD_NAME, StringDefinition()),
(_ARGS_FIELD_NAME, ListDefinition(StringDefinition()))))
_MESSAGES_FIELD_NAME = 'messages'
messages_list_def = ListDefinition(localizable_message_def)
_DATA_FIELD_NAME = 'data'
data_optional_dynamicstructure_def = OptionalDefinition(
DynamicStructDefinition())
_ERROR_DEF_FIELDS = [(_MESSAGES_FIELD_NAME, messages_list_def),
(_DATA_FIELD_NAME, data_optional_dynamicstructure_def)]
def make_std_error_def(name):
"""
Internal function to create a "standard" ErrorDefinition for use only by
the vAPI runtime.
def build_data_value(py_value, data_def):
"""
Converts a native python value to data value
using the provided data definition
:type py_value: :class:`object`
:param py_value: Python native value
:type data_def: :class:`vmware.vapi.data.definition.DataDefinition`
:param data_def: Data definition
:rtype: :class:`vmware.vapi.data.value.DataValue`
:return: Data value
"""
output_val = None
if data_def.type == Type.OPTIONAL:
output_val = data_def.new_value()
if py_value is not None:
output_val.value = build_data_value(py_value,
data_def.element_type)
elif data_def.type == Type.LIST:
output_val = data_def.new_value()
if py_value:
for output in py_value:
output_val.add(build_data_value(output, data_def.element_type))
elif data_def.type in (Type.STRUCTURE, Type.ERROR):
output_val = data_def.new_value()
for field in data_def.get_field_names():
field_def = data_def.get_field(field)
if py_value is None:
if field_def.type == Type.OPTIONAL:
output_val.set_field(field,
OptionalValue())
else:
msg = message_factory.get_message(
'vapi.data.structure.field.missing', data_def.name,
field)
raise CoreException(msg)
else:
if isinstance(py_value, dict):
value = py_value.get(field)
elif isinstance(py_value, VapiStruct):
# If Class used in python bindings is the struct
value = py_value.get_field(field)
else:
msg = message_factory.get_message(
'vapi.data.structure.field.invalid', field)
raise CoreException(msg)
output_val.set_field(
field, build_data_value(value, data_def.get_field(field)))
elif data_def.type == Type.DYNAMIC_STRUCTURE:
output_val = StructValue(DYNAMIC_STRUCTURE)
if isinstance(py_value, dict):
for key, val in six.iteritems(py_value):
if val is None:
field_data_def = OptionalDefinition(StringDefinition())
elif isinstance(val, list):
if len(val) == 0:
# empty list
field_data_def = ListDefinition(StringDefinition())
else:
# at least one element
field_data_def = ListDefinition(
_py_to_data_def_map.get(type(val[0]))())
elif isinstance(val, dict):
field_data_def = DynamicStructDefinition()
else:
try:
# Field is probably a primitive/atomic type
field_data_def_type = _py_to_data_def_map[type(val)]
field_data_def = field_data_def_type()
except KeyError:
msg = message_factory.get_message(
'vapi.data.serializers.python.unsupported.'
'python.type',
type(val), key)
raise CoreException(msg)
output_val.set_field(key, build_data_value(val, field_data_def))
elif data_def.type == Type.VOID:
output_val = data_def.new_value()
elif data_def.type == Type.OPAQUE:
output_val = py_value
# Primitive type Integer/Double/String/Boolean/Secret
else:
output_val = data_def.new_value(py_value)
return output_val
def test_set_type(self):
set_type = SetType(StringType())
self.assertNotEqual(set_type, None)
self.assertEqual(set_type.definition,
ListDefinition(StringDefinition()))
self.assertRaises(TypeError, SetType, 'bogus')