def _append_dependencies(self):
# Add factories
self.put(None, self._factory)
# Add service
# TODO: check this
facade_service = FacadeServiceV1()
facade_service.configure(
ConfigParams.from_tuples(
'root_path',
'', # '/api/1.0',
'connection.protocol',
'http',
'connection.host',
'localhost',
'connection.port',
3000))
self.put(None, facade_service)
# Add services
self.put(Descriptor('beacons', 'client', 'direct', '*', '1.0'),
BeaconsDirectClientV1())
self.put(
Descriptor('beacons', 'persistence', 'file', 'default', '1.0'),
BeaconsFilePersistence('./data/beacons.test.json'))
self.put(
Descriptor('beacons', 'controller', 'default', 'default', '1.0'),
BeaconsController())
class DefaultLoggerFactory(Factory):
"""
Creates :class:`ILogger <pip_services3_components.log.ILogger.ILogger>` components by their descriptors.
See :class:`Factory <pip_services3_components.build.Factory.Factory>`,
:class:`NullLogger <pip_services3_components.log.NullLogger.NullLogger>`,
:class:`ConsoleLogger <pip_services3_components.log.ConsoleLogger.ConsoleLogger>`,
:class:`CompositeLogger <pip_services3_components.log.CompositeLogger.CompositeLogger>`
"""
NullLoggerDescriptor = Descriptor("pip-services", "logger", "null", "*",
"1.0")
ConsoleLoggerDescriptor = Descriptor("pip-services", "logger", "console",
"*", "1.0")
CompositeLoggerDescriptor = Descriptor("pip-services", "logger",
"composite", "*", "1.0")
def __init__(self):
"""
Create a new instance of the factory.
"""
super().__init__()
self.register_as_type(DefaultLoggerFactory.NullLoggerDescriptor,
NullLogger)
self.register_as_type(DefaultLoggerFactory.ConsoleLoggerDescriptor,
ConsoleLogger)
self.register_as_type(DefaultLoggerFactory.CompositeLoggerDescriptor,
CompositeLogger)
class DefaultCountersFactory(Factory):
"""
Creates :class:`ICounters <pip_services3_components.count.ICounters.ICounters>` components by their descriptors.
See :class:`Factory <pip_services3_components.build.Factory.Factory>`,
:class:`NullCounters <pip_services3_components.count.NullCounters.NullCounters>`,
:class:`LogCounters <pip_services3_components.count.LogCounters.LogCounters>`,
:class:`CompositeCounters <pip_services3_components.count.CompositeCounters.CompositeCounters>`
"""
NullCountersDescriptor = Descriptor("pip-services", "counters", "null",
"*", "1.0")
LogCountersDescriptor = Descriptor("pip-services", "counters", "log", "*",
"1.0")
CompositeCountersDescriptor = Descriptor("pip-services", "counters",
"composite", "*", "1.0")
def __init__(self):
"""
Create a new instance of the factory.
"""
super().__init__()
self.register_as_type(DefaultCountersFactory.NullCountersDescriptor,
NullCounters)
self.register_as_type(DefaultCountersFactory.LogCountersDescriptor,
LogCounters)
self.register_as_type(
DefaultCountersFactory.CompositeCountersDescriptor,
CompositeCounters)
class DefaultCacheFactory(Factory):
"""
Creates :class:`ICache <pip_services3_components.cache.ICache.ICache>` components by their descriptors.
See :class:`Factory <pip_services3_components.build.Factory.Factory>`,
:class:`ICache <pip_services3_components.cache.ICache.ICache>`,
:class:`MemoryCache <pip_services3_components.cache.MemoryCache.MemoryCache>`,
:class:`NullCache <pip_services3_components.cache.NullCache.NullCache>`
"""
NullCacheDescriptor = Descriptor("pip-services", "cache", "null", "*",
"1.0")
MemoryCacheDescriptor = Descriptor("pip-services", "cache", "memory", "*",
"1.0")
descriptor = Descriptor("pip-services", "factory", "cache", "default",
"1.0")
def __init__(self):
"""
Create a new instance of the factory.
"""
super().__init__()
self.register_as_type(DefaultCacheFactory.NullCacheDescriptor,
NullCache)
self.register_as_type(DefaultCacheFactory.MemoryCacheDescriptor,
MemoryCache)
def setup_method(self, method):
refs = References.from_tuples(
Descriptor("pip-services", "logger", "null", "default", "1.0"),
NullLogger(),
Descriptor("pip-services", "logger", "console", "default", "1.0"),
ConsoleLogger())
self.log = CompositeLogger(refs)
self.fixture = LoggerFixture(self.log)
def setup_method(self, method):
refs = References.from_tuples(
Descriptor('pip-services-commons', 'logger', 'console', 'default',
'1.0'), ConsoleLogger(),
Descriptor('pip-services-commons', 'logger', 'null', 'default',
'1.0'), NullLogger())
self.log = CompositeLogger(refs)
self.fixture = LoggerFixture(self.log)
class FacadeFactory(Factory):
FacadeServiceV1Descriptor = Descriptor('pip-facades-example', 'service',
'http', '*', '1.0')
FacadeServiceV2Descriptor = Descriptor('pip-facades-example', 'service',
'http', '*', '2.0')
def __init__(self):
super(FacadeFactory, self).__init__()
self.register_as_type(FacadeFactory.FacadeServiceV1Descriptor,
FacadeServiceV1)
self.register_as_type(FacadeFactory.FacadeServiceV2Descriptor,
FacadeServiceV2)
def setup_class(cls):
ctrl = DummyController()
cls.service = DummyCommandableGrpcService()
cls.service.configure(grpc_config)
references = References.from_tuples(
Descriptor('pip-services-dummies', 'controller', 'default',
'default', '1.0'), ctrl,
Descriptor('pip-services-dummies', 'service', 'grpc', 'default',
'1.0'), cls.service)
cls.service.set_references(references)
cls.service.open(None)
def __init__(self):
self.service_name = 'dummies.Dummies.service'
super().__init__(self.service_name)
self._dependency_resolver.put(
'controller',
Descriptor('pip-services-dummies', 'controller', 'default', '*',
'*'))
class DefaultGrpcFactory(Factory):
"""
Creates GRPC components by their descriptors.
See [Factory]
See [GrpcEndpoint]
See [HeartbeatGrpcService]
See [StatusGrpcService]
"""
DESCRIPTOR = Descriptor("pip-services", "factory", "grpc", "default", "1.0")
GrpcEndpointDescriptor = Descriptor("pip-services", "endpoint", "grpc", "*", "1.0")
def __init__(self):
"""
Create a new instance of the factory.
"""
self.register_as_type(DefaultGrpcFactory.GrpcEndpointDescriptor, GrpcEndpoint)
class BeaconsClientFactory(Factory):
null_client_descriptor = Descriptor('beacons', 'client', 'null', '*',
'1.0')
direct_client_descriptor = Descriptor('beacons', 'client', 'direct', '*',
'1.0')
http_client_descriptor = Descriptor('beacons', 'client', 'http', '*',
'1.0')
def __init__(self):
super(BeaconsClientFactory, self).__init__()
self.register_as_type(BeaconsClientFactory.null_client_descriptor,
BeaconsNullClientV1)
self.register_as_type(BeaconsClientFactory.http_client_descriptor,
BeaconsHttpClientV1)
self.register_as_type(BeaconsClientFactory.direct_client_descriptor,
BeaconsDirectClientV1)
class FacadeFactory(Factory):
facade_service_v1_descriptor = Descriptor("pip-services-facade", "service",
"http", "*", "1.0")
def __init__(self):
super(FacadeFactory, self).__init__()
self.register_as_type(FacadeFactory.facade_service_v1_descriptor,
FacadeServiceV1)
class DefaultGrpcFactory(Factory):
"""
Creates GRPC components by their descriptors.
See :class:`Factory <pip_services3_components.build.Factory.Factory>`, :class:`GrpcEndpoint <pip_services3_grpc.services.GrpcEndpoint.GrpcEndpoint>`, :class:`HeartbeatGrpcService <pip_services3_grpc.services.HeartbeatGrpcService.HeartbeatGrpcService>`, :class:`StatusGrpcService <pip_services3_grpc.services.StatusGrpcService.StatusGrpcService>`
"""
descriptor = Descriptor("pip-services", "factory", "grpc", "default",
"1.0")
GrpcEndpointDescriptor = Descriptor("pip-services", "endpoint", "grpc",
"*", "1.0")
def __init__(self):
"""
Create a new instance of the factory.
"""
super().__init__()
self.register_as_type(DefaultGrpcFactory.GrpcEndpointDescriptor,
GrpcEndpoint)
def _append_dependencies(self):
# Add factories
self.put(None, self._factory)
# Add service
self.put(None, FacadeServiceV1())
# Add services
self.append(Descriptor('beacons', 'client', 'direct', '*', '1.0'))
class DefaultInfoFactory(Factory):
"""
Creates information components by their descriptors.
See :class:`IFactory <pip_services3_components.build.IFactory.IFactory>`,
:class:`ContextInfo <pip_services3_components.info.ContextInfo.ContextInfo>`
"""
ContextInfoDescriptor = Descriptor("pip-services", "context-info", "default", "*", "1.0")
ContainerInfoDescriptor = Descriptor("pip-services", "container-info", "default", "*", "1.0")
def __init__(self):
"""
Create a new instance of the factory.
"""
super().__init__()
self.register_as_type(DefaultInfoFactory.ContextInfoDescriptor, ContextInfo)
self.register_as_type(DefaultInfoFactory.ContainerInfoDescriptor, ContextInfo)
def _configure_service(self):
# Configure Facade service
service = self.get_one_required(Descriptor('pip-services', 'endpoint', 'http', 'default', '*'))
service.configure(ConfigParams.from_tuples(
'root_path', '/api/1.0',
'connection.protocol', 'http',
'connection.host', '0.0.0.0',
'connection.port', 3000
))
class DefaultMongoDbFactory(Factory):
__descriptor = Descriptor("pip-services", "factory", "rpc", "default",
"1.0")
__mongo_db_connection_descriptor = Descriptor("pip-services", "connection",
"mongodb", "*", "1.0")
def __init__(self):
super(DefaultMongoDbFactory, self).__init__()
self.register_as_type(
DefaultMongoDbFactory.mongo_db_connection_descriptor,
MongoDbConnection)
@property
def mongo_db_connection_descriptor(self):
return self.__mongo_db_connection_descriptor
@property
def descriptor(self):
return self.__descriptor
def set_references(self, references: IReferences):
"""
Sets references to dependent components.
:param references: references to locate the component dependencies.
"""
descriptor = Descriptor(None, "counters", None, None, None)
counters = references.get_optional(descriptor)
for counter in counters:
if isinstance(counter, ICounters):
self._counters.append(counter)
def set_references(self, references: IReferences):
"""
Sets references to dependent components.
:param references: references to locate the component dependencies.
"""
super(CompositeLogger, self).set_references(references)
# descriptor = Descriptor(None, "logger", None, None, None)
loggers = references.get_optional(Descriptor(None, "logger", None, None, None))
for logger in loggers:
if isinstance(logger, ILogger):
self.__loggers.append(logger)
class FacadeFactory(Factory):
descriptor = Descriptor("pip-services", "factory", "facade", "default",
"1.0")
main_facade_service_descriptor = Descriptor("pip-services",
"facade-service", "default",
"*", "1.0")
partition_facade_service_descriptor = Descriptor("pip-services",
"facade-partition",
"default", "*", "1.0")
auth_manager_descriptor = Descriptor("pip-service", "facade-authorization",
"default", "*", "1.0")
session_manager_descriptor = Descriptor("pip-services", "facade-session",
"default", "*", "1.0")
about_operations_descriptor = Descriptor("pip-services",
"facade-operations", "about", "*",
"1.0")
def __init__(self):
super(FacadeFactory, self).__init__()
self.register_as_type(FacadeFactory.main_facade_service_descriptor,
MainFacadeService)
self.register_as_type(
FacadeFactory.partition_facade_service_descriptor,
PartitionFacadeService)
self.register_as_type(FacadeFactory.about_operations_descriptor,
AboutOperations)
class DefaultConfigReaderFactory(Factory):
"""
Creates :class:`IConfigReader <pip_services3_components.config.IConfigReader.IConfigReader>` components by their descriptors.
See :class:`Factory <pip_services3_components.build.Factory.Factory>`,
:class:`MemoryConfigReader <pip_services3_components.config.MemoryConfigReader.MemoryConfigReader>`,
:class:`JsonConfigReader <pip_services3_components.config.JsonConfigReader.JsonConfigReader>`,
:class:`YamlConfigReader <pip_services3_components.config.YamlConfigReader.YamlConfigReader>`
"""
MemoryConfigReaderDescriptor = Descriptor("pip-services", "config-reader", "memory", "*", "1.0")
JsonConfigReaderDescriptor = Descriptor("pip-services", "config-reader", "json", "*", "1.0")
YamlConfigReaderDescriptor = Descriptor("pip-services", "config-reader", "yaml", "*", "1.0")
def __init__(self):
"""
Create a new instance of the factory.
"""
super().__init__()
self.register_as_type(DefaultConfigReaderFactory.MemoryConfigReaderDescriptor, MemoryConfigReader)
self.register_as_type(DefaultConfigReaderFactory.JsonConfigReaderDescriptor, JsonConfigReader)
self.register_as_type(DefaultConfigReaderFactory.YamlConfigReaderDescriptor, YamlConfigReader)
class DefaultMongoDbFactory(Factory):
"""
Creates MongoDb components by their descriptors.
See :class:`Factory <pip_services3_components.build.Factory.Factory>`, :class:`MongoDbConnection <pip_services3_mongodb.persistence.MongoDbConnection.MongoDbConnection>`
"""
MongoDbConnectionDescriptor: Descriptor = Descriptor("pip-services", "connection", "mongodb", "*", "1.0")
def __init__(self):
"""
Create a new instance of the factory.
"""
super(DefaultMongoDbFactory, self).__init__()
self.register_as_type(DefaultMongoDbFactory.MongoDbConnectionDescriptor, MongoDbConnection)
def _register_in_discovery(self, correlation_id, connection):
if connection.use_discovery() == False: return False
key = connection.get_discovery_key()
if self._references == None:
return False
descriptor = Descriptor("*", "discovery", "*", "*", "*")
components = self._references.get_optional(descriptor)
if components == None:
return False
for component in components:
if isinstance(component, IDiscovery):
component.register(correlation_id, key, connection)
return True
class DefaultCredentialStoreFactory(Factory):
"""
Creates :class:`ICredentialStore <pip_services3_components.auth.ICredentialStore.ICredentialStore>`
components by their descriptors.
See :class:`IFactory <pip_services3_components.build.IFactory.IFactory>`,
:class:`ICredentialStore <pip_services3_components.auth.ICredentialStore.ICredentialStore>`,
:class:`MemoryCredentialStore <pip_services3_components.auth.MemoryCredentialStore.MemoryCredentialStore>`,
"""
MemoryCredentialStoreDescriptor = Descriptor("pip-services", "credential-store", "memory", "*", "1.0")
def __init__(self):
"""
Create a new instance of the factory.
"""
super().__init__()
self.register_as_type(self.MemoryCredentialStoreDescriptor, MemoryCredentialStore)
def __register_in_discovery(self, correlation_id: Optional[str],
connection: ConnectionParams) -> bool:
if connection.use_discovery() is False: return False
key = connection.get_discovery_key()
if self.__references is None:
return False
descriptor = Descriptor("*", "discovery", "*", "*", "*")
components = self.__references.get_optional(descriptor)
if components is None:
return False
for component in components:
if isinstance(component, IDiscovery):
component.register(correlation_id, key, connection)
return True
def _resolve_in_discovery(self, correlation_id, connection):
if connection.use_discovery() == False: return None
key = connection.get_discovery_key()
descriptor = Descriptor("*", "discovery", "*", "*", "*")
components = self._references.get_optional(descriptor)
if len(components) == 0:
raise ConfigException(correlation_id, "CANNOT_RESOLVE",
"Discovery wasn't found to make resolution")
for component in components:
if isinstance(component, IDiscovery):
resolved_connection = component.resolve_one(
correlation_id, key)
if resolved_connection != None:
return resolved_connection
return None
class DefaultDiscoveryFactory(Factory):
"""
Creates :class:`IDiscovery <pip_services3_components.connect.IDiscovery.IDiscovery>` components by their descriptors.
See :class:`Factory <pip_services3_components.build.Factory.Factory>`,
:class:`IDiscovery <pip_services3_components.connect.IDiscovery.IDiscovery>`,
:class:`MemoryDiscovery <pip_services3_components.connect.MemoryDiscovery.MemoryDiscovery>`,
"""
MemoryDiscoveryDescriptor = Descriptor("pip-services", "discovery",
"memory", "*", "1.0")
def __init__(self):
"""
Create a new instance of the factory.
"""
super().__init__()
self.register_as_type(
DefaultDiscoveryFactory.MemoryDiscoveryDescriptor, MemoryDiscovery)
def _lookup_in_stores(self, correlation_id, credential):
if credential.use_credential_store() == False: return None
key = credential.get_store_key()
if self._references == None:
return None
descriptor = Descriptor("*", "credential_store", "*", "*", "*")
components = self._references.get_optional(descriptor)
if len(components) == 0:
raise ReferenceException(
correlation_id, "Credential store wasn't found to make lookup")
for component in components:
if isinstance(component, ICredentialStore):
resolved_credential = component.lookup(correlation_id, key)
if resolved_credential != None:
return resolved_credential
return None
def setup_class(cls):
if cls.mongoUri is None and cls.mongoHost is None:
return
db_config = ConfigParams.from_tuples('connection.uri', cls.mongoUri,
'connection.host', cls.mongoHost,
'connection.port', cls.mongoPort,
'connection.database',
cls.mongoDatabase)
cls.connection = MongoDbConnection()
cls.connection.configure(db_config)
cls.persistence = DummyMongoDbPersistence()
cls.persistence.set_references(
References.from_tuples(
Descriptor("pip-services", "connection", "mongodb", "default",
"1.0"), cls.connection))
cls.fixture = DummyPersistenceFixture(cls.persistence)
cls.connection.open(None)
cls.persistence.open(None)
cls.persistence.clear(None)
def __lookup_in_stores(self, correlation_id: Optional[str],
credential: CredentialParams):
if credential.use_credential_store() is False: return None
key = credential.get_store_key()
if self.__references is None:
return None
descriptor = Descriptor("*", "credential-store", "*", "*", "*")
components = self.__references.get_optional(descriptor)
if len(components) == 0:
raise ReferenceException(
correlation_id, "Credential store wasn't found to make lookup")
# TODO: create assync
for component in components:
if isinstance(component, ICredentialStore):
resolved_credential = component.lookup(correlation_id, key)
if not (resolved_credential is None):
return resolved_credential
return None
