def test_get_asset_tracker_event_client_err(self, status_code, host):
microservice_management_host = 'host1'
microservice_management_port = 1
ms_mgt_client = MicroserviceManagementClient(
microservice_management_host, microservice_management_port)
response_mock = MagicMock(type=HTTPResponse)
undecoded_data_mock = MagicMock()
response_mock.read.return_value = undecoded_data_mock
undecoded_data_mock.decode.return_value = json.dumps({'track': []})
response_mock.status = status_code
response_mock.reason = 'this is the reason'
with patch.object(HTTPConnection, 'request') as request_patch:
with patch.object(HTTPConnection,
'getresponse',
return_value=response_mock) as response_patch:
with patch.object(_logger, "error") as log_error:
with pytest.raises(Exception) as excinfo:
ms_mgt_client.get_asset_tracker_events()
assert excinfo.type is client_exceptions.MicroserviceManagementClientError
assert 1 == log_error.call_count
msg = '{} error code: %d, Reason: %s'.format(host)
log_error.assert_called_once_with(msg, status_code,
'this is the reason')
response_patch.assert_called_once_with()
request_patch.assert_called_once_with(method='GET',
url='/foglamp/track')
def test_create_asset_tracker_event_exception(self, status_code, host):
microservice_management_host = 'host1'
microservice_management_port = 1
ms_mgt_client = MicroserviceManagementClient(
microservice_management_host, microservice_management_port)
response_mock = MagicMock(type=HTTPResponse)
undecoded_data_mock = MagicMock()
test_dict = json.dumps({
'asset': 'AirIntake',
'event': 'Ingest',
'service': 'PT100_In1',
'plugin': 'PT100'
})
undecoded_data_mock.decode.return_value = test_dict
response_mock.read.return_value = undecoded_data_mock
response_mock.status = status_code
response_mock.reason = 'this is the reason'
with patch.object(HTTPConnection, 'request') as request_patch:
with patch.object(HTTPConnection,
'getresponse',
return_value=response_mock) as response_patch:
with patch.object(_logger, "error") as log_error:
with pytest.raises(Exception) as excinfo:
ms_mgt_client.create_asset_tracker_event(test_dict)
assert excinfo.type is client_exceptions.MicroserviceManagementClientError
assert 1 == log_error.call_count
msg = '{} error code: %d, Reason: %s'.format(host)
log_error.assert_called_once_with(msg, status_code,
'this is the reason')
response_patch.assert_called_once_with()
args, kwargs = request_patch.call_args_list[0]
assert 'POST' == kwargs['method']
assert '/foglamp/track' == kwargs['url']
assert test_dict == json.loads(kwargs['body'])
def test_get_services_no_services(self):
microservice_management_host = 'host1'
microservice_management_port = 1
ms_mgt_client = MicroserviceManagementClient(
microservice_management_host, microservice_management_port)
response_mock = MagicMock(type=HTTPResponse)
undecoded_data_mock = MagicMock()
response_mock.read.return_value = undecoded_data_mock
undecoded_data_mock.decode.return_value = json.dumps(
{'notservices': 'bla'})
response_mock.status = 200
with patch.object(HTTPConnection, 'request') as request_patch:
with patch.object(HTTPConnection,
'getresponse',
return_value=response_mock) as response_patch:
with patch.object(_logger, "error") as log_error:
with pytest.raises(Exception) as excinfo:
ms_mgt_client.get_services('foo', 'bar')
assert excinfo.type is KeyError
assert 1 == log_error.call_count
log_error.assert_called_once_with(
'Could not find the micro-service for requested url %s, Reason: %s',
'/foglamp/service?name=foo&type=bar',
"'services'",
exc_info=True)
response_patch.assert_called_once_with()
request_patch.assert_called_once_with(
method='GET', url='/foglamp/service?name=foo&type=bar')
def test_create_asset_tracker_event(self):
microservice_management_host = 'host1'
microservice_management_port = 1
ms_mgt_client = MicroserviceManagementClient(
microservice_management_host, microservice_management_port)
response_mock = MagicMock(type=HTTPResponse)
undecoded_data_mock = MagicMock()
response_mock.read.return_value = undecoded_data_mock
test_dict = json.dumps({
'asset': 'AirIntake',
'event': 'Ingest',
'service': 'PT100_In1',
'plugin': 'PT100'
})
undecoded_data_mock.decode.return_value = test_dict
response_mock.status = 200
with patch.object(HTTPConnection, 'request') as request_patch:
with patch.object(HTTPConnection,
'getresponse',
return_value=response_mock) as response_patch:
ret_value = ms_mgt_client.create_asset_tracker_event(test_dict)
assert json.loads(test_dict) == ret_value
response_patch.assert_called_once_with()
args, kwargs = request_patch.call_args_list[0]
assert 'POST' == kwargs['method']
assert '/foglamp/track' == kwargs['url']
assert test_dict == json.loads(kwargs['body'])
def test_register_service_no_id(self):
microservice_management_host = 'host1'
microservice_management_port = 1
ms_mgt_client = MicroserviceManagementClient(
microservice_management_host, microservice_management_port)
response_mock = MagicMock(type=HTTPResponse)
undecoded_data_mock = MagicMock()
response_mock.read.return_value = undecoded_data_mock
undecoded_data_mock.decode.return_value = json.dumps({'notid': 'bla'})
response_mock.status = 200
with patch.object(HTTPConnection, 'request') as request_patch:
with patch.object(HTTPConnection,
'getresponse',
return_value=response_mock) as response_patch:
with patch.object(_logger, "exception") as log_exc:
with pytest.raises(Exception) as excinfo:
ms_mgt_client.register_service({})
assert excinfo.type is KeyError
assert 1 == log_exc.call_count
log_exc.assert_called_once_with(
'Could not register the microservice, From request %s, Reason: %s',
'{}', "'id'")
response_patch.assert_called_once_with()
request_patch.assert_called_once_with(body='{}',
method='POST',
url='/foglamp/service')
def test_unregister_interest_no_id(self):
microservice_management_host = 'host1'
microservice_management_port = 1
ms_mgt_client = MicroserviceManagementClient(
microservice_management_host, microservice_management_port)
response_mock = MagicMock(type=HTTPResponse)
undecoded_data_mock = MagicMock()
response_mock.read.return_value = undecoded_data_mock
undecoded_data_mock.decode.return_value = json.dumps({'notid': 'bla'})
response_mock.status = 200
with patch.object(HTTPConnection, 'request') as request_patch:
with patch.object(HTTPConnection,
'getresponse',
return_value=response_mock) as response_patch:
with patch.object(_logger, "error") as log_error:
with pytest.raises(Exception) as excinfo:
ms_mgt_client.unregister_interest('someid')
assert excinfo.type is KeyError
assert 1 == log_error.call_count
log_error.assert_called_once_with(
'Could not unregister interest for %s, Reason: %s',
'someid',
"'id'",
exc_info=True)
response_patch.assert_called_once_with()
request_patch.assert_called_once_with(method='DELETE',
url='/foglamp/interest/someid')
def __init__(self):
""" All processes must have these three command line arguments passed:
--address [core microservice management host]
--port [core microservice management port]
--name [process name]
"""
self._start_time = time.time()
try:
self._core_management_host = self.get_arg_value("--address")
self._core_management_port = self.get_arg_value("--port")
self._name = self.get_arg_value("--name")
except ArgumentParserError:
raise
if self._core_management_host is None:
raise ValueError("--address is not specified")
elif self._core_management_port is None:
raise ValueError("--port is not specified")
elif self._name is None:
raise ValueError("--name is not specified")
self._core_microservice_management_client = MicroserviceManagementClient(
self._core_management_host, self._core_management_port)
self._readings_storage_async = ReadingsStorageClientAsync(
self._core_management_host, self._core_management_port)
self._storage_async = StorageClientAsync(self._core_management_host,
self._core_management_port)
def test_delete_configuration_item_exception(self, status_code, host):
microservice_management_host = 'host1'
microservice_management_port = 1
ms_mgt_client = MicroserviceManagementClient(
microservice_management_host, microservice_management_port)
response_mock = MagicMock(type=HTTPResponse)
undecoded_data_mock = MagicMock()
response_mock.read.return_value = undecoded_data_mock
response_mock.status = status_code
response_mock.reason = 'this is the reason'
with patch.object(HTTPConnection, 'request') as request_patch:
with patch.object(HTTPConnection,
'getresponse',
return_value=response_mock) as response_patch:
with patch.object(_logger, "error") as log_error:
with pytest.raises(Exception) as excinfo:
ms_mgt_client.delete_configuration_item("TEST", "blah")
assert excinfo.type is client_exceptions.MicroserviceManagementClientError
assert 1 == log_error.call_count
msg = '{} error code: %d, Reason: %s'.format(host)
log_error.assert_called_once_with(msg, status_code,
'this is the reason')
response_patch.assert_called_once_with()
request_patch.assert_called_once_with(
method='DELETE', url='/foglamp/service/category/TEST/blah/value')
def test_get_configuration_item(self):
microservice_management_host = 'host1'
microservice_management_port = 1
ms_mgt_client = MicroserviceManagementClient(
microservice_management_host, microservice_management_port)
response_mock = MagicMock(type=HTTPResponse)
undecoded_data_mock = MagicMock()
response_mock.read.return_value = undecoded_data_mock
test_dict = {
'type': 'integer',
'description':
'Timeout for a response from any given micro-service. (must be greater than 0)',
'value': '1',
'default': '1'
}
undecoded_data_mock.decode.return_value = json.dumps(test_dict)
response_mock.status = 200
with patch.object(HTTPConnection, 'request') as request_patch:
with patch.object(HTTPConnection,
'getresponse',
return_value=response_mock) as response_patch:
ret_value = ms_mgt_client.get_configuration_item(
"SMNTR", "ping_timeout")
assert test_dict == ret_value
response_patch.assert_called_once_with()
request_patch.assert_called_once_with(
method='GET', url='/foglamp/service/category/SMNTR/ping_timeout')
def test_get_asset_tracker_event(self):
microservice_management_host = 'host1'
microservice_management_port = 1
ms_mgt_client = MicroserviceManagementClient(
microservice_management_host, microservice_management_port)
response_mock = MagicMock(type=HTTPResponse)
undecoded_data_mock = MagicMock()
response_mock.read.return_value = undecoded_data_mock
test_dict = {
"track": [{
"asset": "sinusoid",
"foglamp": "FogLAMP",
"plugin": "sinusoid",
"service": "sine",
"timestamp": "2018-08-21 16:58:45.118",
"event": "Ingest"
}]
}
undecoded_data_mock.decode.return_value = json.dumps(test_dict)
response_mock.status = 200
with patch.object(HTTPConnection, 'request') as request_patch:
with patch.object(HTTPConnection,
'getresponse',
return_value=response_mock) as response_patch:
ret_value = ms_mgt_client.get_asset_tracker_events()
response_patch.assert_called_once_with()
request_patch.assert_called_once_with(method='GET',
url='/foglamp/track')
assert test_dict == ret_value
def test_register_interest_status_client_err(self, status_code, host):
microservice_management_host = 'host1'
microservice_management_port = 1
ms_mgt_client = MicroserviceManagementClient(
microservice_management_host, microservice_management_port)
response_mock = MagicMock(type=HTTPResponse)
response_mock.status = status_code
response_mock.reason = 'this is the reason'
with patch.object(HTTPConnection, 'request') as request_patch:
with patch.object(HTTPConnection,
'getresponse',
return_value=response_mock) as response_patch:
with patch.object(_logger, "error") as log_error:
with pytest.raises(Exception) as excinfo:
ms_mgt_client.register_interest('cat', 'msid')
assert excinfo.type is client_exceptions.MicroserviceManagementClientError
assert 1 == log_error.call_count
msg = '{} error code: %d, Reason: %s'.format(host)
log_error.assert_called_once_with(msg, status_code,
'this is the reason')
response_patch.assert_called_once_with()
request_patch.assert_called_once_with(
body='{"category": "cat", "service": "msid"}',
method='POST',
url='/foglamp/interest')
def test_create_configuration_category_exception(self, status_code, host):
microservice_management_host = 'host1'
microservice_management_port = 1
ms_mgt_client = MicroserviceManagementClient(
microservice_management_host, microservice_management_port)
response_mock = MagicMock(type=HTTPResponse)
undecoded_data_mock = MagicMock()
test_dict = json.dumps({
'key': 'TEST',
'description': 'description',
'value': {
'ping_timeout': {
'type': 'integer',
'description':
'Timeout for a response from any given micro-service. (must be greater than 0)',
'value': '1',
'default': '1'
},
'sleep_interval': {
'type': 'integer',
'description':
'The time (in seconds) to sleep between health checks. (must be greater than 5)',
'value': '5',
'default': '5'
}
}
})
undecoded_data_mock.decode.return_value = test_dict
response_mock.read.return_value = undecoded_data_mock
response_mock.status = status_code
response_mock.reason = 'this is the reason'
with patch.object(HTTPConnection, 'request') as request_patch:
with patch.object(HTTPConnection,
'getresponse',
return_value=response_mock) as response_patch:
with patch.object(_logger, "error") as log_error:
with pytest.raises(Exception) as excinfo:
ms_mgt_client.create_configuration_category(test_dict)
assert excinfo.type is client_exceptions.MicroserviceManagementClientError
assert 1 == log_error.call_count
msg = '{} error code: %d, Reason: %s'.format(host)
log_error.assert_called_once_with(msg, status_code,
'this is the reason')
response_patch.assert_called_once_with()
args, kwargs = request_patch.call_args_list[0]
assert 'POST' == kwargs['method']
assert '/foglamp/service/category' == kwargs['url']
assert json.loads(test_dict) == json.loads(kwargs['body'])
def test_register_service_status_client_err(self, status_code):
microservice_management_host = 'host1'
microservice_management_port = 1
ms_mgt_client = MicroserviceManagementClient(
microservice_management_host, microservice_management_port)
response_mock = MagicMock(type=HTTPResponse)
response_mock.status = status_code
response_mock.reason = 'this is the reason'
with patch.object(HTTPConnection, 'request') as request_patch:
with patch.object(HTTPConnection,
'getresponse',
return_value=response_mock) as response_patch:
with pytest.raises(
client_exceptions.MicroserviceManagementClientError
) as excinfo:
ms_mgt_client.register_service({})
def test_register_service_no_id(self):
microservice_management_host = 'host1'
microservice_management_port = 1
ms_mgt_client = MicroserviceManagementClient(
microservice_management_host, microservice_management_port)
response_mock = MagicMock(type=HTTPResponse)
undecoded_data_mock = MagicMock()
response_mock.read.return_value = undecoded_data_mock
undecoded_data_mock.decode.return_value = json.dumps({'notid': 'bla'})
response_mock.status = 200
with patch.object(HTTPConnection, 'request') as request_patch:
with patch.object(HTTPConnection,
'getresponse',
return_value=response_mock) as response_patch:
with pytest.raises(KeyError) as excinfo:
ms_mgt_client.register_service({})
def test_unregister_service_good_id(self):
microservice_management_host = 'host1'
microservice_management_port = 1
ms_mgt_client = MicroserviceManagementClient(
microservice_management_host, microservice_management_port)
response_mock = MagicMock(type=HTTPResponse)
undecoded_data_mock = MagicMock()
response_mock.read.return_value = undecoded_data_mock
undecoded_data_mock.decode.return_value = json.dumps({'id': 'bla'})
response_mock.status = 200
with patch.object(HTTPConnection, 'request') as request_patch:
with patch.object(HTTPConnection,
'getresponse',
return_value=response_mock) as response_patch:
ret_value = ms_mgt_client.unregister_service('someid')
request_patch.assert_called_once_with(method='DELETE',
url='/foglamp/service/someid')
def test_unregister_interest_client_err(self, status_code):
microservice_management_host = 'host1'
microservice_management_port = 1
ms_mgt_client = MicroserviceManagementClient(
microservice_management_host, microservice_management_port)
response_mock = MagicMock(type=HTTPResponse)
undecoded_data_mock = MagicMock()
response_mock.read.return_value = undecoded_data_mock
undecoded_data_mock.decode.return_value = json.dumps({'notid': 'bla'})
response_mock.status = status_code
with patch.object(HTTPConnection, 'request') as request_patch:
with patch.object(HTTPConnection,
'getresponse',
return_value=response_mock) as response_patch:
with pytest.raises(
client_exceptions.MicroserviceManagementClientError
) as excinfo:
ret_value = ms_mgt_client.unregister_interest('someid')
def test_delete_configuration_item_exception(self, status_code):
microservice_management_host = 'host1'
microservice_management_port = 1
ms_mgt_client = MicroserviceManagementClient(
microservice_management_host, microservice_management_port)
response_mock = MagicMock(type=HTTPResponse)
undecoded_data_mock = MagicMock()
response_mock.read.return_value = undecoded_data_mock
response_mock.status = status_code
with patch.object(HTTPConnection, 'request') as request_patch:
with patch.object(HTTPConnection,
'getresponse',
return_value=response_mock) as response_patch:
with pytest.raises(
client_exceptions.MicroserviceManagementClientError
) as excinfo:
ret_value = ms_mgt_client.delete_configuration_item(
"TEST", "blah")
def test_get_services_good(self, name, type, url):
microservice_management_host = 'host1'
microservice_management_port = 1
ms_mgt_client = MicroserviceManagementClient(
microservice_management_host, microservice_management_port)
response_mock = MagicMock(type=HTTPResponse)
undecoded_data_mock = MagicMock()
response_mock.read.return_value = undecoded_data_mock
undecoded_data_mock.decode.return_value = json.dumps(
{'services': 'bla'})
response_mock.status = 200
with patch.object(HTTPConnection, 'request') as request_patch:
with patch.object(HTTPConnection,
'getresponse',
return_value=response_mock) as response_patch:
ret_value = ms_mgt_client.get_services(name, type)
request_patch.assert_called_once_with(method='GET', url=url)
assert ret_value == {'services': 'bla'}
def test_create_configuration_category_keep_original(self):
microservice_management_host = 'host1'
microservice_management_port = 1
ms_mgt_client = MicroserviceManagementClient(
microservice_management_host, microservice_management_port)
response_mock = MagicMock(type=HTTPResponse)
undecoded_data_mock = MagicMock()
response_mock.read.return_value = undecoded_data_mock
test_dict = {
'key': 'TEST',
'description': 'description',
'value': {
'ping_timeout': {
'type': 'integer',
'description':
'Timeout for a response from any given micro-service. (must be greater than 0)',
'value': '1',
'default': '1'
},
'sleep_interval': {
'type': 'integer',
'description':
'The time (in seconds) to sleep between health checks. (must be greater than 5)',
'value': '5',
'default': '5'
}
},
'keep_original_items': True
}
undecoded_data_mock.decode.return_value = json.dumps(test_dict)
response_mock.status = 200
with patch.object(HTTPConnection, 'request') as request_patch:
with patch.object(HTTPConnection,
'getresponse',
return_value=response_mock) as response_patch:
ret_value = ms_mgt_client.create_configuration_category(
test_dict)
response_patch.assert_called_once_with()
request_patch.assert_called_once_with(method='POST',
url='/foglamp/service/category',
body=test_dict)
assert ret_value == test_dict
def test_create_configuration_category(self):
microservice_management_host = 'host1'
microservice_management_port = 1
ms_mgt_client = MicroserviceManagementClient(
microservice_management_host, microservice_management_port)
response_mock = MagicMock(type=HTTPResponse)
undecoded_data_mock = MagicMock()
response_mock.read.return_value = undecoded_data_mock
test_dict = json.dumps({
'key': 'TEST',
'description': 'description',
'value': {
'ping_timeout': {
'type': 'integer',
'description':
'Timeout for a response from any given micro-service. (must be greater than 0)',
'value': '1',
'default': '1'
},
'sleep_interval': {
'type': 'integer',
'description':
'The time (in seconds) to sleep between health checks. (must be greater than 5)',
'value': '5',
'default': '5'
}
}
})
undecoded_data_mock.decode.return_value = test_dict
response_mock.status = 200
with patch.object(HTTPConnection, 'request') as request_patch:
with patch.object(HTTPConnection,
'getresponse',
return_value=response_mock) as response_patch:
ret_value = ms_mgt_client.create_configuration_category(
test_dict)
assert json.loads(test_dict) == ret_value
response_patch.assert_called_once_with()
args, kwargs = request_patch.call_args_list[0]
assert 'POST' == kwargs['method']
assert '/foglamp/service/category' == kwargs['url']
assert json.loads(test_dict) == json.loads(kwargs['body'])
def test_register_interest_good_id(self):
microservice_management_host = 'host1'
microservice_management_port = 1
ms_mgt_client = MicroserviceManagementClient(
microservice_management_host, microservice_management_port)
response_mock = MagicMock(type=HTTPResponse)
undecoded_data_mock = MagicMock()
response_mock.read.return_value = undecoded_data_mock
undecoded_data_mock.decode.return_value = json.dumps({'id': 'bla'})
response_mock.status = 200
with patch.object(HTTPConnection, 'request') as request_patch:
with patch.object(HTTPConnection,
'getresponse',
return_value=response_mock) as response_patch:
ret_value = ms_mgt_client.register_interest('cat', 'msid')
request_patch.assert_called_once_with(
body='{"category": "cat", "service": "msid"}',
method='POST',
url='/foglamp/interest')
assert ret_value == {'id': 'bla'}
def test_create_configuration_category_exception(self, status_code):
microservice_management_host = 'host1'
microservice_management_port = 1
ms_mgt_client = MicroserviceManagementClient(
microservice_management_host, microservice_management_port)
response_mock = MagicMock(type=HTTPResponse)
undecoded_data_mock = MagicMock()
test_dict = {
'key': 'TEST',
'description': 'description',
'value': {
'ping_timeout': {
'type': 'integer',
'description':
'Timeout for a response from any given micro-service. (must be greater than 0)',
'value': '1',
'default': '1'
},
'sleep_interval': {
'type': 'integer',
'description':
'The time (in seconds) to sleep between health checks. (must be greater than 5)',
'value': '5',
'default': '5'
}
},
'keep_original_items': False
}
undecoded_data_mock.decode.return_value = json.dumps(test_dict)
response_mock.read.return_value = undecoded_data_mock
response_mock.status = status_code
with patch.object(HTTPConnection, 'request') as request_patch:
with patch.object(HTTPConnection,
'getresponse',
return_value=response_mock) as response_patch:
with pytest.raises(
client_exceptions.MicroserviceManagementClientError
) as excinfo:
ret_value = ms_mgt_client.create_configuration_category(
test_dict)
def test_delete_configuration_item(self):
microservice_management_host = 'host1'
microservice_management_port = 1
ms_mgt_client = MicroserviceManagementClient(
microservice_management_host, microservice_management_port)
response_mock = MagicMock(type=HTTPResponse)
undecoded_data_mock = MagicMock()
response_mock.read.return_value = undecoded_data_mock
test_dict = {'value': ''}
undecoded_data_mock.decode.return_value = json.dumps(test_dict)
response_mock.status = 200
with patch.object(HTTPConnection, 'request') as request_patch:
with patch.object(HTTPConnection,
'getresponse',
return_value=response_mock) as response_patch:
ret_value = ms_mgt_client.delete_configuration_item(
"TEST", "blah")
request_patch.assert_called_once_with(
method='DELETE', url='/foglamp/service/category/TEST/blah/value')
assert ret_value == test_dict
async def test_start(self, mocker):
# GIVEN
mocker.patch.object(StorageClient, "__init__", return_value=None)
mocker.patch.object(ReadingsStorageClient,
"__init__",
return_value=None)
log_warning = mocker.patch.object(ingest._LOGGER, "warning")
mocker.patch.object(MicroserviceManagementClient,
"__init__",
return_value=None)
create_cfg = mocker.patch.object(MicroserviceManagementClient,
"create_configuration_category",
return_value=None)
get_cfg = mocker.patch.object(MicroserviceManagementClient,
"get_configuration_category",
return_value=get_cat(
Ingest.default_config))
parent_service = MagicMock(
_core_microservice_management_client=MicroserviceManagementClient(
))
mocker.patch.object(Ingest,
"_write_statistics",
return_value=mock_coro())
mocker.patch.object(Ingest,
"_insert_readings",
return_value=mock_coro())
# WHEN
await Ingest.start(core_mgt_host=None,
core_mgt_port=None,
parent=parent_service)
# THEN
assert 1 == create_cfg.call_count
assert 1 == get_cfg.call_count
assert Ingest._stop is False
assert Ingest._started is True
assert Ingest._readings_list_size == int(
Ingest._readings_buffer_size /
(Ingest._max_concurrent_readings_inserts))
assert Ingest._last_insert_time is 0
assert Ingest._max_concurrent_readings_inserts == len(
Ingest._insert_readings_tasks)
assert Ingest._max_concurrent_readings_inserts == len(
Ingest._insert_readings_wait_tasks)
assert Ingest._max_concurrent_readings_inserts == len(
Ingest._readings_list_batch_size_reached)
assert Ingest._max_concurrent_readings_inserts == len(
Ingest._readings_list_not_empty)
assert Ingest._max_concurrent_readings_inserts == len(
Ingest._readings_lists)
assert 0 == log_warning.call_count
def __init__(self):
""" All processes must have these three command line arguments passed:
--address [core microservice management host]
--port [core microservice management port]
--name [process name]
"""
self._start_time = time.time()
try:
parser = SilentArgParse()
parser.add_argument("--name", required=True)
parser.add_argument("--address", required=True)
parser.add_argument("--port", required=True, type=int)
namespace, args = parser.parse_known_args()
self._name = getattr(namespace, 'name')
self._core_management_host = getattr(namespace, 'address')
self._core_management_port = getattr(namespace, 'port')
r = range(1, 65536)
if self._core_management_port not in r:
raise ArgumentParserError("Invalid Port: {}".format(self._core_management_port))
for item in args:
if item.startswith('--'):
kv = item.split('=')
if len(kv) == 2:
if len(kv[1].strip()) == 0:
raise ArgumentParserError("Invalid value {} for optional arg {}".format(kv[1], kv[0]))
except ArgumentParserError as ex:
_logger.error("Arg parser error: %s", str(ex))
raise
self._core_microservice_management_client = MicroserviceManagementClient(self._core_management_host,
self._core_management_port)
self._readings_storage_async = ReadingsStorageClientAsync(self._core_management_host,
self._core_management_port)
self._storage_async = StorageClientAsync(self._core_management_host, self._core_management_port)
async def test_stop(self, mocker):
# GIVEN
mocker.patch.object(StorageClient, "__init__", return_value=None)
mocker.patch.object(ReadingsStorageClient,
"__init__",
return_value=None)
log_exception = mocker.patch.object(ingest._LOGGER, "exception")
mocker.patch.object(MicroserviceManagementClient,
"__init__",
return_value=None)
create_cfg = mocker.patch.object(MicroserviceManagementClient,
"create_configuration_category",
return_value=None)
get_cfg = mocker.patch.object(MicroserviceManagementClient,
"get_configuration_category",
return_value=get_cat(
Ingest.default_config))
parent_service = MagicMock(
_core_microservice_management_client=MicroserviceManagementClient(
))
mocker.patch.object(Ingest,
"_write_statistics",
return_value=mock_coro())
mocker.patch.object(Ingest,
"_insert_readings",
return_value=mock_coro())
# WHEN
await Ingest.start(core_mgt_host=None,
core_mgt_port=None,
parent=parent_service)
await asyncio.sleep(1)
await Ingest.stop()
# THEN
assert 1 == create_cfg.call_count
assert 1 == get_cfg.call_count
assert Ingest._stop is True
assert Ingest._started is False
assert Ingest._insert_readings_wait_tasks is None
assert Ingest._insert_readings_tasks is None
assert Ingest._readings_lists is None
assert Ingest._readings_list_batch_size_reached is None
assert Ingest._readings_list_not_empty is None
assert Ingest._readings_lists_not_full is None
assert 0 == log_exception.call_count
async def test_read_config(self, mocker):
# GIVEN
Ingest.storage_async = MagicMock(spec=StorageClientAsync)
Ingest.readings_storage_async = MagicMock(
spec=ReadingsStorageClientAsync)
mocker.patch.object(MicroserviceManagementClient,
"__init__",
return_value=None)
create_cfg = mocker.patch.object(MicroserviceManagementClient,
"create_configuration_category",
return_value=None)
get_cfg = mocker.patch.object(MicroserviceManagementClient,
"get_configuration_category",
return_value=get_cat(
Ingest.default_config))
mocker.patch.object(MicroserviceManagementClient,
"create_child_category",
return_value=None)
Ingest._parent_service = MagicMock(
_core_microservice_management_client=MicroserviceManagementClient(
))
# WHEN
await Ingest._read_config()
# THEN
assert 1 == create_cfg.call_count
assert 1 == get_cfg.call_count
new_config = get_cat(Ingest.default_config)
assert Ingest._readings_buffer_size == int(
new_config['readings_buffer_size']['value'])
assert Ingest._max_concurrent_readings_inserts == \
int(new_config['max_concurrent_readings_inserts']['value'])
assert Ingest._readings_insert_batch_size == int(
new_config['readings_insert_batch_size']['value'])
assert Ingest._readings_insert_batch_timeout_seconds == \
int(new_config['readings_insert_batch_timeout_seconds']['value'])
assert Ingest._max_readings_insert_batch_connection_idle_seconds == \
int(new_config['max_readings_insert_batch_connection_idle_seconds']['value'])
assert Ingest._max_readings_insert_batch_reconnect_wait_seconds == \
int(new_config['max_readings_insert_batch_reconnect_wait_seconds']['value'])
class FoglampProcess(ABC):
""" FoglampProcess for all non-core python processes.
All processes will inherit from FoglampProcess and must implement pure virtual method run()
"""
_core_management_host = None
""" string containing core's micro-service management host """
_core_management_port = None
""" int containing core's micro-service management port """
_name = None
""" name of process """
_core_microservice_management_client = None
""" MicroserviceManagementClient instance """
_readings_storage_async = None
""" foglamp.common.storage_client.storage_client.ReadingsStorageClientAsync """
_storage_async = None
""" async foglamp.common.storage_client.storage_client.StorageClientAsync """
_start_time = None
""" time at which this python process started """
def __init__(self):
""" All processes must have these three command line arguments passed:
--address [core microservice management host]
--port [core microservice management port]
--name [process name]
"""
self._start_time = time.time()
try:
self._core_management_host = self.get_arg_value("--address")
self._core_management_port = self.get_arg_value("--port")
self._name = self.get_arg_value("--name")
except ArgumentParserError:
raise
if self._core_management_host is None:
raise ValueError("--address is not specified")
elif self._core_management_port is None:
raise ValueError("--port is not specified")
elif self._name is None:
raise ValueError("--name is not specified")
self._core_microservice_management_client = MicroserviceManagementClient(
self._core_management_host, self._core_management_port)
self._readings_storage_async = ReadingsStorageClientAsync(
self._core_management_host, self._core_management_port)
self._storage_async = StorageClientAsync(self._core_management_host,
self._core_management_port)
# pure virtual method run() to be implemented by child class
@abstractmethod
def run(self):
pass
def get_arg_value(self, argument_name):
""" Parses command line arguments for a single argument of name argument_name. Returns the value of the argument specified or None if argument was not specified.
Keyword Arguments:
argument_name -- name of command line argument to retrieve value for
Return Values:
Argument value (as a string)
None (if argument was not passed)
Side Effects:
None
Known Exceptions:
ArgumentParserError
"""
parser = SilentArgParse()
return parser.silent_arg_parse(argument_name)
def get_services_from_core(self, name=None, _type=None):
return self._core_microservice_management_client.get_services(
name, _type)
def register_service_with_core(self, service_registration_payload):
""" Register a microservice with core
Keyword Arguments:
service_registration_payload -- json format dictionary
Return Values:
Argument value (as a string)
None (if argument was not passed)
Known Exceptions:
HTTPError
"""
return self._core_microservice_management_client.register_service(
service_registration_payload)
def unregister_service_with_core(self, microservice_id):
""" Unregister a microservice with core
Keyword Arguments:
microservice_id (uuid as a string)
"""
return self._core_microservice_management_client.unregister_service(
microservice_id)
def register_interest_with_core(self):
# cat name
# callback module
# self.microservice_id
raise NotImplementedError
def unregister_interest_with_core(self):
# cat name
# self.microservice_id
raise NotImplementedError
def get_configuration_categories(self):
"""
:return:
"""
return self._core_microservice_management_client.get_configuration_category(
)
def get_configuration_category(self, category_name=None):
"""
:param category_name:
:return:
"""
return self._core_microservice_management_client.get_configuration_category(
category_name)
def get_configuration_item(self, category_name, config_item):
"""
:param category_name:
:param config_item:
:return:
"""
return self._core_microservice_management_client.get_configuration_item(
category_name, config_item)
def create_configuration_category(self, category_data):
"""
:param category_data:
:return:
"""
return self._core_microservice_management_client.create_configuration_category(
category_data)
def update_configuration_item(self, category_name, config_item):
"""
:param category_name:
:param config_item:
:return:
"""
return self._core_microservice_management_client.update_configuration_item(
category_name, config_item)
def delete_configuration_item(self, category_name, config_item):
"""
:param category_name:
:param config_item:
:return:
"""
return self._core_microservice_management_client.delete_configuration_item(
category_name, config_item)
async def test_stop(self, mocker):
class mock_stat:
def __init__(self):
pass
async def register(self, key, desc):
return None
async def mock_create(storage):
return mock_stat()
# GIVEN
mocker.patch.object(StorageClientAsync, "__init__", return_value=None)
mocker.patch.object(ReadingsStorageClientAsync,
"__init__",
return_value=None)
log_exception = mocker.patch.object(ingest._LOGGER, "exception")
mocker.patch.object(MicroserviceManagementClient,
"__init__",
return_value=None)
create_cfg = mocker.patch.object(MicroserviceManagementClient,
"create_configuration_category",
return_value=None)
get_cfg = mocker.patch.object(MicroserviceManagementClient,
"get_configuration_category",
return_value=get_cat(
Ingest.default_config))
mocker.patch.object(MicroserviceManagementClient,
"get_asset_tracker_events",
return_value={'track': []})
mocker.patch.object(MicroserviceManagementClient,
"create_child_category",
return_value=None)
mocker.patch.object(statistics,
"create_statistics",
return_value=mock_create(None))
parent_service = MagicMock(
_core_microservice_management_client=MicroserviceManagementClient(
))
mocker.patch.object(Ingest,
"_write_statistics",
return_value=mock_coro())
mocker.patch.object(Ingest,
"_insert_readings",
return_value=mock_coro())
# WHEN
await Ingest.start(parent=parent_service)
await asyncio.sleep(1)
await Ingest.stop()
# THEN
assert 1 == create_cfg.call_count
assert 1 == get_cfg.call_count
assert Ingest._stop is True
assert Ingest._started is False
assert Ingest._insert_readings_wait_tasks is None
assert Ingest._insert_readings_tasks is None
assert Ingest._readings_lists is None
assert Ingest._readings_list_batch_size_reached is None
assert Ingest._readings_list_not_empty is None
assert Ingest._readings_lists_not_full is None
assert 0 == log_exception.call_count
def test_constructor(self):
microservice_management_host = 'host1'
microservice_management_port = 1
ms_mgt_client = MicroserviceManagementClient(
microservice_management_host, microservice_management_port)
assert hasattr(ms_mgt_client, '_management_client_conn')
