def __init__(self, next_provider=None, provider_config=None): """ Initialize AuthorizationFilter :type next_provider: :class:`vmware.vapi.core.ApiProvider` :param next_provider: API Provider to invoke the requests :type provider_config: :class:`vmware.vapi.settings.config.ProviderConfig` or :class:`None` :param provider_config: Provider configuration object """ handler_names = [] self._metadata = None if provider_config: # Get the registered AuthN handlers from config file (handler_names, metadata_file) = \ provider_config.get_authorization_handlers_and_file() self._metadata = get_metadata(metadata_file) from vmware.vapi.lib.load import dynamic_import self._authz_handlers = [] for handler_name in handler_names: # Dynamically load the AuthZ handler handler_constructor = dynamic_import(handler_name) if handler_constructor is None: raise ImportError('Could not import %s' % handler_name) self._authz_handlers.append(handler_constructor()) self._internal_server_error_def = make_std_error_def( 'com.vmware.vapi.std.errors.internal_server_error') self._unauthorized_error_def = make_std_error_def( 'com.vmware.vapi.std.errors.unauthorized') ApiProviderFilter.__init__( self, next_provider, [self._internal_server_error_def, self._unauthorized_error_def])
def __init__(self, http_provider, post_processors, rest_metadata_map=None, is_vapi_rest=True): """ Rest rpc client provider init :type http_provider: :class:`vmware.vapi.protocol.client.rpc.provider.HTTPProvider` :param http_provider: rpc provider object :type post_processors: :class:`list` of :class:`str` :param post_processors: List of post processor class names :type rest_metadata_map: :class:`dict` of (:class:`str`, :class:`str`) and :class:`vmware.vapi.lib.rest.OperationRestMetadata` :param rest_metadata_map: Rest metadata for all operations :type is_vapi_rest: :class:`bool` :param is_vapi_rest: Whether the Rest json message format is VAPI Rest or not """ ApiProvider.__init__(self) self._http_provider = http_provider self._rest_metadata_map = rest_metadata_map or {} self._is_vapi_rest = is_vapi_rest # Load all the post processors self.post_processors = [dynamic_import(p)() for p in post_processors]
def _resolve(self): """ Resolves the struct or enum reference """ tokens = self._type_name.split('.') target = dynamic_import(self._context_name) # Get the required reference by walking down the fully qualified name for token in tokens: target = getattr(target, token) self._resolved_type = target.get_binding_type()
def __init__(self, stub_config): """ Initialize StubFactoryBase :type stub_config: :class:`vmware.vapi.bindings.stub.StubConfiguration` :param stub_config: Stub config instance """ self._stub_config = stub_config for k, val in six.viewitems(self._attrs): if isinstance(val, six.string_types): # If the value in the _attr dict is a string, then import the # type and set it as the value in the same dict val = dynamic_import(val) self._attrs[k] = val # Set every key, value in _attrs dict as an instance variable setattr(self, k, val)
def get_connector(self, protocol, *args, **kwargs): """ Create protocol connector :type protocol: :class:`str` :param protocol: protocol name :type args: :class:`tuple` :param args: position parameters to protocol connector constructor :type kwargs: :class:`dict` :param kwargs: key parameters to protocol connector constructor :rtype: :class:`vmware.vapi.protocol.client.connector.Connector` :return: Connector object """ constructor = self.connectors.get(protocol) if constructor is not None: constructor = dynamic_import(constructor) if constructor: return constructor(*args, **kwargs)
def get_rpc_provider(self, rpc_provider_name, *args, **kwargs): """ Create rpc provider :type rpc_provider_name: :param rpc_provider_name: :type args: :class:`tuple` :param args: position parameters to rpc provider constructor :type kwargs: :class:`dict` :param kwargs: key parameters to rpc provider constructor :rtype: :class:`vmware.vapi.protocol.client.rpc.provider.RpcProvider` :return: Rpc provider object """ constructor = self.rpc_providers.get(rpc_provider_name) if constructor is not None: constructor = dynamic_import(constructor) if constructor: return constructor(*args, **kwargs)
def get_handler(self, protocol_name, *args, **kwargs): """ Create protocol handler :type protocol: :class:`str` :param protocol: protocol name :type args: :class:`tuple` :param args: position parameters to protocol handler constructor :type kwargs: :class:`dict` :param kwargs: key parameters to protocol handler constructor :rtype: :class:`vmware.vapi.protocol.server.api_handler.ApiHandler` :return: Api handler object """ constructor = self.handlers.get(protocol_name) if constructor is not None: constructor = dynamic_import(constructor) if constructor: return constructor(*args, **kwargs)
def setup_provider_chain(provider_cfg, singleton): """ Setup the API Provider chain In the properties file, users would specify the order of ApiProviders For ex: InterposerProvider, ApiAggregator. In this case all incoming requests would first go to InterposerProvider and then forwarded to ApiAggregator after processing. This function initializes all these providers in the reverse order and passes the reference of n+1th provider to nth provider. :type provider_cfg: :class:`vmware.vapi.settings.config.ProviderConfig` :param provider_cfg: Provider Configuration :type singleton: :class:`bool` :param singleton: Specify whether to create new instances of Providers or use existing ones :rtype: :class:`list` of :class:`vmware.vapi.core.ApiProvider` :return: List of API Providers """ # This import cannot be at the top as we need to wait for logger to get # initialized with right handlers from vmware.vapi.lib.load import dynamic_import singleton_providers = { 'ApiAggregator': 'vmware.vapi.provider.aggregator.get_provider', 'LocalProvider': 'vmware.vapi.provider.local.get_provider', 'InterposerProvider': 'vmware.vapi.provider.interposer.get_provider', 'AuthenticationFilter': 'vmware.vapi.security.authentication_filter.get_provider', 'AuthorizationFilter': 'vmware.vapi.security.authorization_filter.get_provider', } providers = { 'ApiAggregator': 'vmware.vapi.provider.aggregator.AggregatorProvider', 'LocalProvider': 'vmware.vapi.provider.local.LocalProvider', 'InterposerProvider': 'vmware.vapi.provider.interposer.InterposerProvider', 'AuthenticationFilter': 'vmware.vapi.security.authentication_filter.AuthenticationFilter', 'AuthorizationFilter': 'vmware.vapi.security.authorization_filter.AuthorizationFilter', } provider_types = provider_cfg.get_providers() provider_map = singleton_providers if singleton else providers filter_kwargs = {} if singleton else {'provider_config': provider_cfg} providers = [] for i, provider_type in enumerate(reversed(provider_types)): provider_name = provider_map.get(provider_type) if provider_name: provider_constructor = dynamic_import(provider_name) if provider_constructor is None: raise ImportError('Could not import %s' % provider_name) if i == 0: # TODO: Add validation to make sure that the last provider # can support registration of services provider = provider_constructor() provider.register_by_properties(provider_cfg) else: provider = provider_constructor(**filter_kwargs) provider.next_provider = providers[i - 1] providers.append(provider) else: logger.error('Could not load provider') return [] return providers[::-1]
def create_servers(spec, singleton=False): """ Create RPC servers :type spec: :class:`str` :param spec: Provider configuration :type singleton: :class:`bool` :kwarg singleton: Specify whether to create new instances of Providers or use existing ones :rtype: :class:`list` of :class:`vmware.vapi.server.server_interface.ServerInterface` :return: list of servers """ server_providers = { 'twisted': 'vmware.vapi.server.twisted_server.get_server', 'stdio': 'vmware.vapi.server.stdio_server.get_server', 'wsgi': 'vmware.vapi.server.wsgi_server.get_server', } provider_cfg, providers = _create_provider_int(spec, singleton) provider = providers[0] try: protocol_configs = provider_cfg.get_provider_protocols() except configparser.NoOptionError: raise Exception('No protocol configurations specified') # These import cannot be at the top as we need to wait for logger to get # initialized with right handlers from vmware.vapi.lib.load import dynamic_import from vmware.vapi.protocol.server.msg.handler_factory import ( ProtocolHandlerFactory) from vmware.vapi.protocol.server.transport.async_server_adapter_factory \ import AsyncServerAdapterFactory servers = {} msg_handlers = {} protocol_handlers = {} is_wsgi = False for protocol_config in protocol_configs: url = provider_cfg.get_provider_url(protocol_config) logger.info('url: %s', url) transport_protocol = get_url_scheme(url) logger.info('transport protocol: %s', transport_protocol) # Get request handler msg_handler_factory = ProtocolHandlerFactory() # Add all pre processors # TODO Add these as default values in provider config instead of # hardcoding here pre_processors = ['vmware.vapi.security.sso.JSONSSOVerifier'] msg_protocol = provider_cfg.get_provider_message_format( protocol_config) msg_handler = msg_handler_factory.get_handler(msg_protocol, provider, pre_processors) msg_handlers[(msg_protocol, provider)] = msg_handler # Get server constructor rpc_server = provider_cfg.get_provider_server(protocol_config) logger.info('rpc server: %s', rpc_server) # Get async server to msg handler adapter adapter_factory = AsyncServerAdapterFactory() if rpc_server in ['wsgi', 'stdio']: protocol_handler = msg_handler else: protocol_handler = adapter_factory.get_adapter( transport_protocol, msg_handler) # Extract ssl arguments ssl_args = provider_cfg.get_provider_ssl_args(protocol_config) # Register handler server = servers.get(rpc_server) if not server: server_name = server_providers.get(rpc_server) if server_name is not None: server_constructor = dynamic_import(server_name) if server_constructor is None: raise Exception('Could not find RPC constructor') server = server_constructor() if rpc_server == 'wsgi': server.provider_config = provider_cfg servers[rpc_server] = server server.register_handler(url, msg_protocol, protocol_handler, ssl_args) # Get tasks configuration if provider_cfg.are_tasks_enabled(): thread_count = provider_cfg.get_provider_task_threads() from vmware.vapi.lib.thread_pool import get_threadpool thread_pool = get_threadpool(thread_count) task_manager = provider_cfg.get_provider_task_manager() task_manager_constructor = dynamic_import(task_manager) from vmware.vapi.task.task_manager_impl import get_task_manager task_manager_instance = get_task_manager(task_manager_constructor) priv_validator = provider_cfg.get_provider_privilege_validator() if priv_validator is not None: priv_validator_constructor = dynamic_import(priv_validator) from vmware.vapi.security.privilege import ( get_privilege_validator) privilege_validator_instance = get_privilege_validator( priv_validator_constructor) return list(servers.values())
def test_load_failure_attr(self): di = dynamic_import('vmware.vapi.lib.load.dynamic_importx') self.assertEqual(di, None)
def test_load_success(self): di = dynamic_import('vmware.vapi.lib.load.dynamic_import') self.assertEqual(di.__name__, 'dynamic_import') self.assertEqual(di.__module__, 'vmware.vapi.lib.load')