def many_from_config(config: ConfigParams) -> List['ConnectionParams']:
"""
Retrieves all ConnectionParams from configuration parameters
from "connections" section. If "connection" section is present instead,
than it returns a list with only one ConnectionParams.
:param config: a configuration parameters to retrieve connections
:return: a list of retrieved ConnectionParams
"""
result = []
# Try to get multiple connections first
connections = config.get_section("connections")
if len(connections) > 0:
sections_names = connections.get_section_names()
for section in sections_names:
connection = connections.get_section(section)
result.append(ConnectionParams(connection))
# Then try to get a single connection
else:
connection = config.get_section("connection")
result.append(ConnectionParams(connection))
return result
def concat(options1: ConfigParams, options2: ConfigParams,
*keys: str) -> ConfigParams:
"""
Concatinates two options by combining duplicated properties into comma-separated list
:param options1: first options to merge
:param options2: second options to merge
:param keys: when define it limits only to specific keys
"""
options = ConfigParams.from_value(options1)
for key in options2.get_keys():
value1 = options1.get_as_string(key) or ''
value2 = options2.get_as_string(key) or ''
if value1 != '' and value2 != '':
if keys is None or len(keys) == 0 or key in keys:
options.set_as_object(key, value1 + ',' + value2)
elif value1 != '':
options.set_as_object(key, value1)
elif value2 != '':
options.set_as_object(key, value2)
return options
def __init__(self, base_route, config: ConfigParams,
commands: List[ICommand]):
self.__content: str = ''
self.commands: List[ICommand] = commands or []
config = config or ConfigParams()
self.version: str = '3.0.2'
self.base_route: str = base_route
self.info_title: str = config.get_as_string_with_default(
"name", "CommandableHttpService")
self.info_description: str = config.get_as_string_with_default(
"description", "Commandable microservice")
self.info_version: str = '1'
self.info_terms_of_service: Optional[str] = None
self.info_contact_name: Optional[str] = None
self.info_contact_url: Optional[str] = None
self.info_contact_email: Optional[str] = None
self.info_license_name: Optional[str] = None
self.info_license_url: Optional[str] = None
self._object_type: Dict[str, Any] = {'type': 'object'}
def test_config_sections(self):
config = ConfigParams.from_tuples("Section1.Key1", "Value1",
"Section1.Key2", "Value2",
"Section1.Key3", "Value3")
assert 3 == len(config)
assert "Value1" == config.get("Section1.Key1")
assert "Value2" == config.get("Section1.Key2")
assert "Value3" == config.get("Section1.Key3")
assert None == config.get("Section1.Key4")
section2 = ConfigParams.from_tuples("Key1", "ValueA", "Key2", "ValueB")
config.add_section("Section2", section2)
assert 5 == len(config)
assert "ValueA" == config.get("Section2.Key1")
assert "ValueB" == config.get("Section2.Key2")
sections = config.get_section_names()
assert 2 == len(sections)
assert "Section1" in sections
assert "Section2" in sections
section1 = config.get_section("Section1")
assert 3 == len(section1)
assert "Value1" == section1.get("Key1")
assert "Value2" == section1.get("Key2")
assert "Value3" == section1.get("Key3")
def configure(self, config: ConfigParams):
"""
Configures component by passing configuration parameters.
:param config: configuration parameters to be set.
"""
self._interval = config.get_as_float_with_default("interval", self._interval)
self._max_cache_size = config.get_as_integer_with_default("options.max_cache_size", self._max_cache_size)
def test_read_config(self):
config = ConfigParams.from_tuples("id", "ABC")
name = NameResolver.resolve(config)
assert "ABC" == name
config = ConfigParams.from_tuples("name", "ABC")
name = NameResolver.resolve(config)
assert "ABC" == name
def configure(self, config: ConfigParams):
"""
Configures component by passing configuration parameters.
:param config: configuration parameters to be set.
"""
config = config.set_defaults(self.__default_config)
self._connection_resolver.configure(config)
self._options = self._options.override(config.get_section('options'))
def configure(self, config: ConfigParams):
config = config.set_defaults(SessionsOperationsV1.__default_config)
self._dependency_resolver.configure(config)
self.__cookie_enabled = config.get_as_boolean_with_default(
'options.cookie_enabled', self.__cookie_enabled)
self.__cookie = config.get_as_string_with_default(
'options.cookie', self.__cookie)
self.__max_cookie_age = config.get_as_long_with_default(
'options.max_cookie_age', self.__max_cookie_age)
def configure(self, config: ConfigParams):
"""
Configures component by passing configuration parameters.
:param config: configuration parameters to be set.
"""
self._level = LogLevelConverter.to_log_level(
config.get_as_object("level"))
self._source = config.get_as_string_with_default(
"source", self._source)
def configure(self, config: ConfigParams):
"""
Configures component by passing configuration parameters.
:param config: configuration parameters to be set.
"""
self.__timeout = config.get_as_long_with_default(
"options.timeout", self.__default_timeout)
self.__max_size = config.get_as_long_with_default(
"options.max_size", self.__default_max_size)
def configure(self, config: ConfigParams):
"""
Configures component by passing configuration parameters.
:param config: configuration parameters to be set.
"""
self.__mode = config.get_as_string_with_default('mode', self.__mode)
self.__min_timeout = config.get_as_integer_with_default(
'min_timeout', self.__min_timeout)
self.__max_timeout = config.get_as_integer_with_default(
'max_timeout', self.__max_timeout)
def configure(self, config: ConfigParams):
"""
Configures component by passing configuration parameters.
:param config: configuration parameters to be set.
"""
super().configure(config)
self.__listen_interval = config.get_as_integer_with_default(
'listen_interval', self.__listen_interval)
self.__listen_interval = config.get_as_integer_with_default(
'options.listen_interval', self.__listen_interval)
def __init__(self):
"""
Creates a new instance of the connection component.
"""
self.__default_config = ConfigParams.from_tuples(
'options.max_pool_size', 2, 'options.keep_alive', 1,
'options.connect_timeout', 5000, 'options.auto_reconnect', True,
'options.max_page_size', 100, 'options.debug', True)
self._logger = CompositeLogger()
self._connection_resolver = MongoDbConnectionResolver()
self._options = ConfigParams()
def configure(self, config: ConfigParams):
"""
Configures component by passing configuration parameters.
:param config: configuration parameters to be set.
"""
self.__connection_resolver.configure(config)
self.__credential_resolver.configure(config)
self.__timeout = config.get_as_integer_with_default(
'options.timeout', self.__timeout)
self.__retries = config.get_as_integer_with_default(
'options.retries', self.__retries)
def configure(self, config: ConfigParams):
"""
Configures component by passing configuration parameters.
:param config: configuration parameters to be set.
"""
self.__name = config.get_as_string_with_default("name", self.__name)
self.__name = config.get_as_string_with_default("info.name", self.__name)
self.__description = config.get_as_string_with_default("description", self.__description)
self.__description = config.get_as_string_with_default("info.description", self.__description)
self.__properties = config.get_section("properties")
def __init__(self):
"""
Creates a new instance of the client.
"""
self._connection_resolver = HttpConnectionResolver()
self._default_config = ConfigParams.from_tuples(
"connection.protocol", "http", "connection.host", "0.0.0.0",
"connection.port", 3000, "options.timeout", 10000,
"options.request_max_size", 1024 * 1024, "options.connect_timeout",
10000, "options.retries", 3, "options.debug", True)
self._logger = CompositeLogger()
self._counters = CompositeCounters()
self._options = ConfigParams()
self._headers = {}
def configure(self, config: ConfigParams):
"""
Configures component by passing configuration parameters.
:param config: configuration parameters to be set.
"""
super().configure(config)
self.__connection_resolver.configure(config)
self.__index = config.get_as_string_with_default('index', self.__index)
self._date_format = config.get_as_string_with_default(
'date_format', self._date_format)
self.__daily_index = config.get_as_boolean_with_default(
'daily', self.__daily_index)
self.__reconnect = config.get_as_integer_with_default(
'options.reconnect', self.__reconnect)
self.__timeout = config.get_as_integer_with_default(
'options.timeout', self.__timeout)
self.__max_retries = config.get_as_integer_with_default(
'options.max_retries', self.__max_retries)
self.__index_message = config.get_as_boolean_with_default(
'options.index_message', self.__index_message)
self.__include_type_name = config.get_as_boolean_with_default(
'options.include_type_name', self.__include_type_name)
def test_concat_options(self):
options1 = ConfigParams.from_tuples("host", "server1", "port", "8080",
"param1", "ABC")
options2 = ConfigParams.from_tuples("host", "server2", "port", "8080",
"param2", "XYZ")
options = ConnectionUtils.concat(options1, options2)
assert len(options) == 4
assert "server1,server2" == options.get_as_nullable_string("host")
assert "8080,8080" == options.get_as_nullable_string("port")
assert "ABC" == options.get_as_nullable_string("param1")
assert "XYZ" == options.get_as_nullable_string("param2")
def from_config(config: ConfigParams) -> 'ComponentConfig':
"""
Creates a new instance of ComponentConfig based on section from container configuration.
:param config: component parameters from container configuration
:return: a newly created ComponentConfig
"""
descriptor = Descriptor.from_string(config.get_as_nullable_string("descriptor"))
type = TypeDescriptor.from_string(config.get_as_nullable_string("type"))
if descriptor is None and type is None:
raise ConfigException(None, "BAD_CONFIG", "Component configuration must have descriptor or type")
return ComponentConfig(descriptor, type, config)
def configure(self, config: ConfigParams):
"""
Configures component by passing configuration parameters.
:param config: configuration parameters to be set.
"""
config = config.set_defaults(MySqlPersistence._default_config)
self.__config = config
self._dependency_resolver.configure(config)
self._table_name = config.get_as_string_with_default('collection', self._table_name)
self._table_name = config.get_as_string_with_default('table', self._table_name)
self._schema_name = config.get_as_string_with_default('schema', self._schema_name)
self._max_page_size = config.get_as_integer_with_default('options.max_page_size', self._max_page_size)
def configure(self, config: ConfigParams):
"""
Configures component by passing configuration parameters.
:param config: configuration parameters to be set.
"""
super().configure(config)
self.__connection_resolver.configure(config)
self.__source = config.get_as_float_with_default(
'source', self.__source)
self.__instance = config.get_as_float_with_default(
'instance', self.__instance)
self.__push_enabled = config.get_as_float_with_default(
'push_enabled', True)
def _get_parameters(self):
# Process command line parameters
args = sys.argv
line = ''
index = 0
while index < len(args):
arg = args[index]
next_arg = args[index + 1] if index < len(args) - 1 else None
next_arg = None if next_arg != None and next_arg.startswith(
'-') else next_arg
if next_arg != None:
if arg == "--param" or arg == "--params" or arg == "-p":
if len(line) > 0:
line = line + ';'
line = line + next_arg
index += 1
index += 1
parameters = ConfigParams.from_string(line)
# Process environmental variables
for (k, v) in os.environ.items():
parameters[k] = v
return parameters
def configure(self, config: ConfigParams):
"""
Configures component by passing configuration parameters.
:param config: configuration parameters to be set.
"""
config = config.set_defaults(self._default_config)
self._config = config
self._dependency_resolver.configure(config)
self._base_route = config.get_as_string_with_default(
"base_route", self._base_route)
self._swagger_enabled = self._config.get_as_boolean_with_default(
"swagger.enable", self._swagger_enabled)
self._swagger_route = self._config.get_as_string_with_default(
"swagger.route", self._swagger_route)
def test_lookup_and_store(self):
config = ConfigParams.from_tuples('key1.user', 'user1', 'key1.pass',
'pass1', 'key2.user', 'user2',
'key2.pass', 'pass2')
credential_store = MemoryCredentialStore()
credential_store.read_credentials(config)
cred1 = credential_store.lookup('123', 'key1')
cred2 = credential_store.lookup('123', 'key2')
assert cred1.get_username() == 'user1'
assert cred1.get_password() == 'pass1'
assert cred2.get_username() == 'user2'
assert cred2.get_password() == 'pass2'
cred_config = CredentialParams.from_tuples('user', 'user3', 'pass',
'pass3', 'access_id', '123')
credential_store.store(None, 'key3', cred_config)
cred3 = credential_store.lookup('123', 'key3')
assert cred3.get_username() == 'user3'
assert cred3.get_password() == 'pass3'
assert cred3.get_access_id() == '123'
def test_get_open_api_override(self):
open_api_content = "swagger yaml content"
# recreate service with new configuration
self.service.close(None)
config = rest_config.set_defaults(
ConfigParams.from_tuples("swagger.auto", False))
ctrl = DummyController()
self.service = DummyCommandableHttpService()
self.service.configure(config)
references = References.from_tuples(
Descriptor('pip-services-dummies', 'controller', 'default',
'default', '1.0'), ctrl,
Descriptor('pip-services-dummies', 'service', 'http', 'default',
'1.0'), self.service)
self.service.set_references(references)
try:
self.service.open(None)
response = requests.request('GET',
'http://localhost:3005/dummy/swagger')
assert response.text == open_api_content
finally:
self.service.close(None)
def configure(self, config: ConfigParams):
"""
Configures component by passing configuration parameters.
:param config: configuration parameters to be set.
"""
self.__path = config.get_as_string_with_default('path', self.__path)
def __compose_connection(
self,
connections: List[ConnectionParams],
credential: CredentialParams = None) -> ConfigParams:
connection = ConfigParams.merge_configs(*connections)
uri = connection.get_as_string('uri')
if uri is None or uri == "":
protocol = connection.get_as_string_with_default('protocol', "uri")
host = connection.get_as_string('host')
port = connection.get_as_integer('port')
uri = protocol + "://" + host if host else None
if port != 0:
uri = uri + ":" + str(port)
connection.set_as_object('uri', uri)
else:
address = urlparse(uri)
connection.set_as_object('protocol', address.scheme)
connection.set_as_object('host', address.hostname)
connection.set_as_object('port', address.port)
if connection.get_as_string('protocol') == 'https':
if credential.get_as_nullable_string('internal_network') is None:
connection = connection.override(credential)
return connection
def resolve(self,
correlation_id: Optional[str]) -> Optional[ConnectionParams]:
"""
Resolves a single component connection. If connections are configured to be retrieved
from Discovery service it finds a :class:`IDiscovery <pip_services3_components.connect.IDiscovery.IDiscovery>` and resolves the connection there.
:param correlation_id: (optional) transaction id to trace execution through call chain.
:return: resolved connection parameters or null if nothing was found.
"""
if len(self.__connections) == 0: return None
# Return connection that doesn't require discovery
for connection in self.__connections:
if not connection.use_discovery():
return connection
# Return connection that require discovery
for connection in self.__connections:
if connection.use_discovery():
resolved_connection = self.__resolve_in_discovery(
correlation_id, connection)
if not (resolved_connection is None):
# Merge configured and new parameters
resolved_connection = ConnectionParams(
ConfigParams.merge_configs(connection,
resolved_connection))
return resolved_connection
return None
def test_lookup(self):
credential_resolver = CredentialResolver()
credential = credential_resolver.lookup("correlation_id")
assert None == credential
RestConfigWithoutStoreKey = ConfigParams.from_tuples(
"credential.username", "Negrienko",
"credential.password", "qwerty",
"credential.access_key", "key"
)
credential_resolver = CredentialResolver(RestConfigWithoutStoreKey)
credential = credential_resolver.lookup("correlation_id")
assert "Negrienko" == credential.get("username")
assert "qwerty" == credential.get("password")
assert "key" == credential.get("access_key")
assert None == credential.get("store_key")
credential_resolver = CredentialResolver(RestConfig)
credential = credential_resolver.lookup("correlation_id")
assert None == credential
credential_resolver.set_references(References())
try:
credential = credential_resolver.lookup("correlation_id")
except Exception as ex:
assert "Cannot locate reference: Credential store wasn't found to make lookup" == ex.message
def resolve_all(self,
correlation_id: Optional[str]) -> List[ConnectionParams]:
"""
Resolves all component connection. If connections are configured to be retrieved
from Discovery service it finds a :class:`IDiscovery <pip_services3_components.connect.IDiscovery.IDiscovery>` and resolves the connection there.
:param correlation_id: (optional) transaction id to trace execution through call chain.
:return: a list of resolved connections.
"""
resolved = []
to_resolve = []
# Sort connections
for connection in self.__connections:
if connection.use_discovery():
to_resolve.append(connection)
else:
resolved.append(connection)
# Resolve addresses that require that
if len(to_resolve) > 0:
for connection in to_resolve:
resolved_connections = self.__resolve_all_in_discovery(
correlation_id, connection)
for resolved_connection in resolved_connections:
# Merge configured and new parameters
resolved_connection = ConnectionParams(
ConfigParams.merge_configs(connection,
resolved_connection))
resolved.append(resolved_connection)
return resolved
