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 __init__(self, name, introspection_adapter):
"""
Initialize ProviderApiInterface
: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._name = name
self._adapter = introspection_adapter
iface_id = InterfaceIdentifier(
'com.vmware.vapi.std.introspection.provider')
method_defs = {}
# get method
get_method_id = MethodIdentifier(iface_id, 'get')
output_def = StructDefinition(
'com.vmware.vapi.std.introspection.provider.info',
[('id', StringDefinition()), ('checksum', StringDefinition())])
method_defs[get_method_id] = MethodDefinition(
get_method_id, StructDefinition(OPERATION_INPUT, []), output_def,
[])
methods = {}
methods[get_method_id] = self._get
IntrospectionBaseApiInterface.__init__(self, iface_id, method_defs,
methods)
def get_method(self, service_id, operation_id):
"""
Get method definition for the specified operation
:type service_id: :class:`str`
:param service_id: Service identifier
:type operation_id: :class:`str`
:param operation_id: Operation identifier
:rtype: :class:`vmware.vapi.core.MethodDefinition`
:return: Method definition of the specified operation
"""
info = self._operation.get(service_id=service_id,
operation_id=operation_id)
input_def = convert_data_value_to_data_def(
info.input_definition.get_struct_value())
output_def = convert_data_value_to_data_def(
info.output_definition.get_struct_value())
error_defs = [convert_data_value_to_data_def(error_def.get_struct_value())
for error_def in info.error_definitions]
interface_id = InterfaceIdentifier(service_id)
method_id = MethodIdentifier(interface_id, operation_id)
method_definition = MethodDefinition(method_id,
input_def,
output_def,
error_defs)
return method_definition
def get_method_definition(self, method_id):
name = method_id.get_name()
if name == mock_method_name:
input_ = mock_input_def
else:
input_ = input_def
output = VoidDefinition()
errors = [not_found_error_def]
return MethodDefinition(method_id, input_, output, errors)
def get_method_definition(self, method_id):
op_info = self._operations.get(method_id.get_name())
if op_info is None:
return
errors_defs = [
e.definition for e in six.itervalues(op_info.get('errors'))]
return MethodDefinition(method_id,
op_info.get('input_type').definition,
op_info.get('output_type').definition,
errors_defs)
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 augment_method_def_with_errors(method_def, errors):
"""
Add errors reported by this ApiProviderFilter to a method definition.
This method clones the input method definition and appends errors. It
does not modify the parameter.
:type method_def: :class:`vmware.vapi.core.MethodDefinition`
:param method_def: Method definition
:type errors: :class:`list` of
:class:`vmware.vapi.data.definition.ErrorDefinition`
:param errors: Error definitions to augment to MethodDefinition
:rtype: :class:`vmware.vapi.core.MethodDefinition`
:return: Method definition after augmenting the errors
"""
method_errors = method_def.get_error_definitions()
return MethodDefinition(method_def.get_identifier(),
method_def.get_input_definition(),
method_def.get_output_definition(),
method_errors.union(errors))
def test_get_error_definition(self):
method_def = MethodDefinition(
MethodIdentifier(InterfaceIdentifier('interface'), 'method1'),
StructDefinition('method1_input', []), VoidDefinition(),
[self.error_def1, self.error_def2, self.error_def3])
self.assertEquals(self.error_def1,
method_def.get_error_definition(self.ERROR1_NAME))
self.assertEquals(self.error_def2,
method_def.get_error_definition(self.ERROR2_NAME))
self.assertEquals(self.error_def3,
method_def.get_error_definition(self.ERROR3_NAME))
self.assertEquals(
None, method_def.get_error_definition(self.BOGUS_ERROR_NAME))
def get_method_definition(self, method_id):
op_info = self._operations.get(method_id.get_name())
if op_info is None:
return None
errors_defs = [e.definition for e in op_info['errors']]
for error_def in self._error_defs_to_augment:
if error_def not in errors_defs:
errors_defs.append(error_def)
# XXX: This loop should be removed when once the runtime/bindings
# check for invocations using API features that are disabled by feature
# switch and report these errors (so provider implementations don't need
# to report them).
for error_def in self._unchecked_error_defs:
if error_def not in errors_defs:
errors_defs.append(error_def)
return MethodDefinition(method_id,
op_info['input_type'].definition,
op_info['output_type'].definition,
errors_defs)
def get_method_definition(self, method_id):
name = method_id.get_name()
if name == 'bogus_method':
return None
if name == missing_input_definition:
input_ = None
elif name == invalid_input_definition:
input_ = 'not a StructDefinition'
elif name == mock_definition:
input_ = StructDefinition(OPERATION_INPUT, [])
else:
input_ = StructDefinition(OPERATION_INPUT,
[(param_name, IntegerDefinition())])
if name == missing_output_definition:
output = None
elif name == invalid_input_definition:
output = 'not a DataDefinition'
else:
output = VoidDefinition()
errors = []
if name == report_declared_error:
errors.append(not_found_error_def)
return MethodDefinition(method_id, input_, output, errors)
field_instance = build_adhoc_data_value(field_def)
instance.set_field(field_name, field_instance)
elif data_def.type == Type.LIST:
# TODO: Randomize list len?
instance.add_all([build_adhoc_data_value(data_def.element_type) for val in range(1,7)])
elif data_def.type == Type.OPTIONAL:
# TODO: Randomize optional set or not set?
instance = data_def.new_value(build_adhoc_data_value(data_def.element_type))
return instance
fake_iface_id = 'vmware.test.fake.iface'
null_method_id = 'Null'
null_method_def = MethodDefinition(MethodIdentifier(
InterfaceIdentifier(fake_iface_id), null_method_id),
VoidDefinition(),
VoidDefinition(),
[make_std_error_def('error1'),
make_std_error_def('error2')]
)
echo_method_id = 'Echo'
echo_method_def = MethodDefinition(MethodIdentifier(
InterfaceIdentifier(fake_iface_id), echo_method_id),
StructDefinition('struct',
[('int', IntegerDefinition()),
('str', StringDefinition())]
),
StructDefinition('struct',
[('int', IntegerDefinition()),
('str', StringDefinition())]
),
[make_std_error_def('e1'),
def get_method_definition(self, method_id):
input_ = StructDefinition('mock', [])
output = IntegerDefinition()
return MethodDefinition(method_id, input_, output, [])
from vmware.vapi.security.oauth import OAUTH_SCHEME_ID, ACCESS_TOKEN
from vmware.vapi.security.session import SESSION_SCHEME_ID, SESSION_ID
from vmware.vapi.security.sso import SAML_SCHEME_ID, SAML_BEARER_SCHEME_ID, SAML_TOKEN, PRIVATE_KEY
from vmware.vapi.security.user_identity import UserIdentity
from vmware.vapi.lib.constants import SCHEME_ID
from vmware.vapi.settings.config import ProviderConfig
from vmware.vapi.provider.local import LocalProvider
DATA_DIR = os.path.join(os.path.dirname(os.path.realpath(__file__)),
'resources')
mock_interface_id = InterfaceIdentifier('mock')
mock_method_id = MethodIdentifier(mock_interface_id, 'mock')
mock_interface_def = InterfaceDefinition(mock_interface_id, [mock_method_id])
mock_method_def = MethodDefinition(
mock_method_id, StructDefinition('input', [('input', VoidDefinition())]),
IntegerDefinition(), [])
errors = [
'com.vmware.vapi.std.errors.internal_server_error',
'com.vmware.vapi.std.errors.invalid_argument',
'com.vmware.vapi.std.errors.operation_not_found',
'com.vmware.vapi.std.errors.unauthenticated',
]
error_defs = [make_std_error_def(error) for error in errors]
error_values = ListValue(
[convert_data_def_to_data_value(error_def) for error_def in error_defs])
logging.basicConfig(level=logging.INFO)
class MockupApiInterface(ApiInterface):