async def unregister(cls, request): """ Unregister a service :Example: curl -X DELETE http://localhost:8082/foglamp/service/dc9bfc01-066a-4cc0-b068-9c35486db87f """ try: service_id = request.match_info.get('service_id', None) if not service_id: raise web.HTTPBadRequest(reason='Service id is required') try: ServiceRegistry.get(idx=service_id) except service_registry_exceptions.DoesNotExist: raise web.HTTPBadRequest( reason='Service with {} does not exist'.format(service_id)) ServiceRegistry.unregister(service_id) _resp = {'id': str(service_id), 'message': 'Service unregistered'} return web.json_response(_resp) except ValueError as ex: raise web.HTTPNotFound(reason=str(ex))
async def test__monitor_good_uptime(self): async def async_mock(return_value): return return_value # used to mock client session context manager class AsyncSessionContextManagerMock(MagicMock): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) async def __aenter__(self): client_response_mock = MagicMock(spec=aiohttp.ClientResponse) # mock response (good) client_response_mock.text.side_effect = [ async_mock('{"uptime": "bla"}') ] return client_response_mock async def __aexit__(self, *args): return None # as monitor loop is as infinite loop, this exception is thrown when we need to exit the loop class TestMonitorException(Exception): pass # register a service with patch.object(ServiceRegistry._logger, 'info') as log_info: s_id_1 = ServiceRegistry.register('sname1', 'Storage', 'saddress1', 1, 1, 'protocol1') assert 1 == log_info.call_count args, kwargs = log_info.call_args assert args[0].startswith('Registered service instance id=') assert args[0].endswith( ': <sname1, type=Storage, protocol=protocol1, address=saddress1, service port=1, ' 'management port=1, status=1>') monitor = Monitor() monitor._sleep_interval = Monitor._DEFAULT_SLEEP_INTERVAL monitor._max_attempts = Monitor._DEFAULT_MAX_ATTEMPTS # throw the TestMonitorException when sleep is called (end of infinite loop) with patch.object(Monitor, '_sleep', side_effect=TestMonitorException()): with patch.object(aiohttp.ClientSession, 'get', return_value=AsyncSessionContextManagerMock()): with pytest.raises(Exception) as excinfo: await monitor._monitor_loop() assert excinfo.type is TestMonitorException # service is good, so it should remain in the service registry assert len(ServiceRegistry.get(idx=s_id_1)) is 1 assert ServiceRegistry.get( idx=s_id_1)[0]._status is ServiceRecord.Status.Running
async def get_service(cls, request): """ Returns a list of all services or as per name &|| type filter :Example: curl -X GET http://localhost:<core mgt port>/foglamp/service curl -X GET http://localhost:<core mgt port>/foglamp/service?name=X&type=Storage """ service_name = request.query[ 'name'] if 'name' in request.query else None service_type = request.query[ 'type'] if 'type' in request.query else None try: if not service_name and not service_type: services_list = ServiceRegistry.all() elif service_name and not service_type: services_list = ServiceRegistry.get(name=service_name) elif not service_name and service_type: services_list = ServiceRegistry.get(s_type=service_type) else: services_list = ServiceRegistry.filter_by_name_and_type( name=service_name, s_type=service_type) except service_registry_exceptions.DoesNotExist as ex: if not service_name and not service_type: msg = 'No service found' elif service_name and not service_type: msg = 'Service with name {} does not exist'.format( service_name) elif not service_name and service_type: msg = 'Service with type {} does not exist'.format( service_type) else: msg = 'Service with name {} and type {} does not exist'.format( service_name, service_type) raise web.HTTPNotFound(reason=msg) services = [] for service in services_list: svc = dict() svc["id"] = service._id svc["name"] = service._name svc["type"] = service._type svc["address"] = service._address svc["management_port"] = service._management_port svc["protocol"] = service._protocol svc["status"] = ServiceRecord.Status(int( service._status)).name.lower() if service._port: svc["service_port"] = service._port services.append(svc) return web.json_response({"services": services})
async def test_get_fail(self): with pytest.raises(DoesNotExist) as excinfo: with patch.object(Service._logger, 'info') as log_info: Service.register("StorageService", "Storage", "127.0.0.1", 8888, 9999) Service.get('incorrect_id') assert 1 == log_info.call_count args, kwargs = log_info.call_args assert args[0].startswith('Registered service instance id=') assert args[0].endswith( ': <StorageService1, type=Storage, protocol=http, address=127.0.0.1, service port=8888,' ' management port=9999, status=1>') assert str(excinfo).endswith('DoesNotExist')
async def test_unregister(self): # register a service idx = Service.register("StorageService2", "Storage", "127.0.0.1", 8888, 1888) assert str(uuid.UUID(idx, version=4)) == idx # deregister the same t = Service.unregister(idx) assert idx == t with pytest.raises(DoesNotExist) as excinfo: Service.get(idx) assert str(excinfo).endswith('DoesNotExist')
async def unregister(cls, request): """ Unregister a service :Example: curl -X DELETE http://localhost:<core mgt port>/foglamp/service/dc9bfc01-066a-4cc0-b068-9c35486db87f """ try: service_id = request.match_info.get('service_id', None) try: services = ServiceRegistry.get(idx=service_id) except service_registry_exceptions.DoesNotExist: raise ValueError( 'Service with {} does not exist'.format(service_id)) ServiceRegistry.unregister(service_id) if cls._storage_client_async is not None and services[ 0]._name not in ("FogLAMP Storage", "FogLAMP Core"): try: cls._audit = AuditLogger(cls._storage_client_async) await cls._audit.information('SRVUN', {'name': services[0]._name}) except Exception as ex: _logger.exception(str(ex)) _resp = {'id': str(service_id), 'message': 'Service unregistered'} return web.json_response(_resp) except ValueError as ex: raise web.HTTPNotFound(reason=str(ex))
async def test_get(self): s = Service.register("StorageService", "Storage", "localhost", 8881, 1888) c = Service.register("CoreService", "Core", "localhost", 7771, 1777) d = Service.register("SouthService", "Southbound", "127.0.0.1", 9991, 1999, "https") l = Service.get() assert 3 == len(l) assert s == l[0]._id assert "StorageService" == l[0]._name assert "Storage" == l[0]._type assert "localhost" == l[0]._address assert 8881 == int(l[0]._port) assert 1888 == int(l[0]._management_port) # validates default set to HTTP assert "http" == l[0]._protocol assert c == l[1]._id assert "CoreService" == l[1]._name assert "Core" == l[1]._type assert "localhost" == l[1]._address assert 7771 == int(l[1]._port) assert 1777 == int(l[1]._management_port) # validates default set to HTTP assert "http" == l[1]._protocol assert d == l[2]._id assert "SouthService" == l[2]._name assert "Southbound" == l[2]._type assert "127.0.0.1" == l[2]._address assert 9991 == int(l[2]._port) assert 1999 == int(l[2]._management_port) assert "https" == l[2]._protocol
async def test_unregister(self, mocker): # register a service with patch.object(Service._logger, 'info') as log_info: idx = Service.register("StorageService2", "Storage", "127.0.0.1", 8888, 1888) assert str(uuid.UUID(idx, version=4)) == idx assert 1 == log_info.call_count arg, kwarg = log_info.call_args assert arg[0].startswith('Registered service instance id=') assert arg[0].endswith( ': <StorageService2, type=Storage, protocol=http, address=127.0.0.1, service port=8888,' ' management port=1888, status=1>') mocker.patch.object(InterestRegistry, '__init__', return_value=None) mocker.patch.object(InterestRegistry, 'get', return_value=list()) # deregister the same with patch.object(Service._logger, 'info') as log_info2: t = Service.unregister(idx) assert idx == t assert 1 == log_info2.call_count args, kwargs = log_info2.call_args assert args[0].startswith('Stopped service instance id=') assert args[0].endswith( ': <StorageService2, type=Storage, protocol=http, address=127.0.0.1, ' 'service port=8888, management port=1888, status=2>') s = Service.get(idx) assert s[0]._status == 2 # Unregistered
async def get_plugin(request): """ GET lists of rule plugins and delivery plugins :Example: curl -X GET http://localhost:8081/foglamp/notification/plugin """ try: notification_service = ServiceRegistry.get( s_type=ServiceRecord.Type.Notification.name) _address, _port = notification_service[ 0]._address, notification_service[0]._port except service_registry_exceptions.DoesNotExist: raise web.HTTPNotFound(reason="No Notification service available.") try: url = 'http://{}:{}/notification/rules'.format(_address, _port) rule_plugins = json.loads(await _hit_get_url(url)) url = 'http://{}:{}/notification/delivery'.format(_address, _port) delivery_plugins = json.loads(await _hit_get_url(url)) except Exception as ex: raise web.HTTPInternalServerError(reason=ex) else: return web.json_response({ 'rules': rule_plugins, 'delivery': delivery_plugins })
def test_unregister(self, mocker): mocker.patch.object(InterestRegistry, '__init__', return_value=None) mocker.patch.object(InterestRegistry, 'get', return_value=list()) with patch.object(ServiceRegistry._logger, 'info') as log_info1: reg_id = ServiceRegistry.register("A name", "Storage", "127.0.0.1", 1234, 4321, 'http') assert 1 == len(ServiceRegistry._registry) assert 1 == log_info1.call_count arg, kwarg = log_info1.call_args assert arg[0].startswith('Registered service instance id=') assert arg[0].endswith( ': <A name, type=Storage, protocol=http, address=127.0.0.1, service port=1234,' ' management port=4321, status=1>') with patch.object(ServiceRegistry._logger, 'info') as log_info2: s_id = ServiceRegistry.unregister(reg_id) assert 36 == len(s_id) # uuid version 4 len assert 1 == len(ServiceRegistry._registry) s = ServiceRegistry.get(idx=s_id) assert s[0]._status == 2 assert 1 == log_info2.call_count args, kwargs = log_info2.call_args assert args[0].startswith('Stopped service instance id=') assert args[0].endswith( ': <A name, type=Storage, protocol=http, address=127.0.0.1, service port=1234,' ' management port=4321, status=2>')
def stop_storage(cls): """ stop Storage service """ # TODO: FOGL-653 shutdown implementation # remove me, and allow this call in service registry API found_services = ServiceRegistry.get(name="FogLAMP Storage") svc = found_services[0] if svc is None: return management_api_url = '{}:{}'.format(svc._address, svc._management_port) conn = http.client.HTTPConnection(management_api_url) # TODO: need to set http / https based on service protocol conn.request('POST', url='/foglamp/service/shutdown', body=None) r = conn.getresponse() # TODO: FOGL-615 # log error with message if status is 4xx or 5xx if r.status in range(400, 500): _logger.error("Client error code: %d", r.status) if r.status in range(500, 600): _logger.error("Server error code: %d", r.status) res = r.read().decode() conn.close() return json.loads(res)
async def _services_with_assets(storage_client, south_services): sr_list = list() try: try: services_from_registry = ServiceRegistry.get(s_type="Southbound") except DoesNotExist: services_from_registry = [] def is_svc_in_service_registry(name): return next( (svc for svc in services_from_registry if svc._name == name), None) for s_record in services_from_registry: sr_list.append({ 'name': s_record._name, 'address': s_record._address, 'management_port': s_record._management_port, 'service_port': s_record._port, 'protocol': s_record._protocol, 'status': ServiceRecord.Status(int(s_record._status)).name.lower(), 'assets': await _get_tracked_assets_and_readings(storage_client, s_record._name), 'schedule_enabled': await _get_schedule_status(storage_client, s_record._name) }) for s_name in south_services: south_svc = is_svc_in_service_registry(s_name) if not south_svc: sr_list.append({ 'name': s_name, 'address': '', 'management_port': '', 'service_port': '', 'protocol': '', 'status': '', 'assets': await _get_tracked_assets_and_readings(storage_client, s_name), 'schedule_enabled': await _get_schedule_status(storage_client, s_name) }) except: raise else: return sr_list
def get_storage(): """ Storage Object """ try: services = ServiceRegistry.get(name="FogLAMP Storage") storage_svc = services[0] _storage = StorageClient(core_management_host=None, core_management_port=None, svc=storage_svc) # _logger.info(type(_storage)) except Exception as ex: _logger.exception(str(ex)) raise return _storage
async def _get_storage_client(cls): storage_service = None while storage_service is None and cls._storage_client_async is None: try: found_services = ServiceRegistry.get(name="FogLAMP Storage") storage_service = found_services[0] cls._storage_client_async = StorageClientAsync( cls._host, cls.core_management_port, svc=storage_service) except (service_registry_exceptions.DoesNotExist, InvalidServiceInstance, StorageServiceUnavailable, Exception) as ex: await asyncio.sleep(5)
async def run(category_name): """ Callback run by configuration category to notify changes to interested microservices Note: this method is async as needed Args: configuration_name (str): name of category that was changed """ # get all interest records regarding category_name cfg_mgr = ConfigurationManager() interest_registry = InterestRegistry(cfg_mgr) try: interest_records = interest_registry.get(category_name=category_name) except interest_registry_exceptions.DoesNotExist: return category_value = await cfg_mgr.get_category_all_items(category_name) payload = {"category": category_name, "items": category_value} headers = {'content-type': 'application/json'} # for each microservice interested in category_name, notify change for i in interest_records: # get microservice management server info of microservice through service registry try: service_record = ServiceRegistry.get(idx=i._microservice_uuid)[0] except service_registry_exceptions.DoesNotExist: _LOGGER.exception( "Unable to notify microservice with uuid %s as it is not found in the service registry", i._microservice_uuid) continue url = "{}://{}:{}/foglamp/change".format( service_record._protocol, service_record._address, service_record._management_port) async with aiohttp.ClientSession() as session: try: async with session.post(url, data=json.dumps(payload, sort_keys=True), headers=headers) as resp: result = await resp.text() status_code = resp.status if status_code in range(400, 500): _LOGGER.error("Bad request error code: %d, reason: %s", status_code, resp.reason) if status_code in range(500, 600): _LOGGER.error("Server error code: %d, reason: %s", status_code, resp.reason) except Exception as ex: _LOGGER.exception( "Unable to notify microservice with uuid %s due to exception: %s", i._microservice_uuid, str(ex)) continue
async def get_service(cls, request): """ Returns a list of all services or of the selected service :Example: curl -X GET http://localhost:8082/foglamp/service :Example: curl -X GET http://localhost:8082/foglamp/service?name=X&type=Storage """ service_name = request.query[ 'name'] if 'name' in request.query else None service_type = request.query[ 'type'] if 'type' in request.query else None try: if not service_name and not service_type: services_list = ServiceRegistry.all() elif service_name and not service_type: services_list = ServiceRegistry.get(name=service_name) elif not service_name and service_type: services_list = ServiceRegistry.get(s_type=service_type) else: services_list = ServiceRegistry.filter_by_name_and_type( name=service_name, s_type=service_type) except service_registry_exceptions.DoesNotExist as ex: raise web.HTTPBadRequest( reason="Invalid service name and/or type provided" + str(ex)) services = [] for service in services_list: svc = dict() svc["id"] = service._id svc["name"] = service._name svc["type"] = service._type svc["address"] = service._address svc["management_port"] = service._management_port svc["protocol"] = service._protocol svc["status"] = service._status if service._port: svc["service_port"] = service._port services.append(svc) return web.json_response({"services": services})
async def delete_service(request): """ Delete an existing service :Example: curl -X DELETE http://localhost:8081/foglamp/service/<svc name> """ try: svc = request.match_info.get('service_name', None) storage = connect.get_storage_async() result = await get_schedule(storage, svc) if result['count'] == 0: return web.HTTPNotFound( reason='{} service does not exist.'.format(svc)) config_mgr = ConfigurationManager(storage) # In case of notification service, if notifications exists, then deletion is not allowed if 'notification' in result['rows'][0]['process_name']: notf_children = await config_mgr.get_category_child( category_name="Notifications") children = [x['key'] for x in notf_children] if len(notf_children) > 0: return web.HTTPBadRequest( reason= 'Notification service `{}` can not be deleted, as {} notification instances exist.' .format(svc, children)) # First disable the schedule svc_schedule = result['rows'][0] sch_id = uuid.UUID(svc_schedule['id']) if svc_schedule['enabled'].lower() == 't': await server.Server.scheduler.disable_schedule(sch_id) # Delete all configuration for the service name await config_mgr.delete_category_and_children_recursively(svc) # Remove from registry as it has been already shutdown via disable_schedule() and since # we intend to delete the schedule also, there is no use of its Service registry entry try: services = ServiceRegistry.get(name=svc) ServiceRegistry.remove_from_registry(services[0]._id) except service_registry_exceptions.DoesNotExist: pass # Delete schedule await server.Server.scheduler.delete_schedule(sch_id) except Exception as ex: raise web.HTTPInternalServerError(reason=ex) else: return web.json_response( {'result': 'Service {} deleted successfully.'.format(svc)})
def get_readings_async(): """ Storage Object """ try: services = ServiceRegistry.get(name="FogLAMP Storage") storage_svc = services[0] _readings = ReadingsStorageClientAsync(core_mgt_host=None, core_mgt_port=None, svc=storage_svc) # _logger.info(type(_storage)) except Exception as ex: _logger.exception(str(ex)) raise return _readings
async def test_unregister(self, mocker): # register a service idx = Service.register("StorageService2", "Storage", "127.0.0.1", 8888, 1888) assert str(uuid.UUID(idx, version=4)) == idx mocker.patch.object(InterestRegistry, '__init__', return_value=None) mocker.patch.object(InterestRegistry, 'get', return_value=list()) # deregister the same t = Service.unregister(idx) assert idx == t s = Service.get(idx) assert s[0]._status == 2 # Unregistered
async def stop_storage(cls): """Stops Storage service """ try: found_services = ServiceRegistry.get(name="FogLAMP Storage") except service_registry_exceptions.DoesNotExist: raise svc = found_services[0] if svc is None: _logger.info( "FogLAMP Storage shut down requested, but could not be found.") return await cls._request_microservice_shutdown(svc)
async def test__monitor_exceed_attempts(self, reset_service_registry): async def async_mock(return_value): return return_value # used to mock client session context manager class AsyncSessionContextManagerMock(MagicMock): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) async def __aenter__(self): # mock response (error- exception) raise Exception() async def __aexit__(self, *args): return None # as monitor loop is as infinite loop, this exception is thrown when we need to exit the loop class TestMonitorException(Exception): pass # register a service s_id_1 = ServiceRegistry.register('sname1', 'Storage', 'saddress1', 1, 1, 'protocol1') monitor = Monitor() monitor._sleep_interval = Monitor._DEFAULT_SLEEP_INTERVAL monitor._max_attempts = Monitor._DEFAULT_MAX_ATTEMPTS sleep_side_effect_list = list() # _MAX_ATTEMPTS is 15 # throw exception on the 16th time sleep is called - the first 15 sleeps are used during retries for i in range(0, 15): sleep_side_effect_list.append(async_mock(None)) sleep_side_effect_list.append(TestMonitorException()) with patch.object(Monitor, '_sleep', side_effect=sleep_side_effect_list): with patch.object(aiohttp.ClientSession, 'get', return_value=AsyncSessionContextManagerMock()): with pytest.raises(TestMonitorException) as excinfo: await monitor._monitor_loop() assert ServiceRegistry.get( idx=s_id_1)[0]._status is ServiceRecord.Status.Failed
async def delete_notification(request): """ Delete an existing notification :Example: curl -X DELETE http://localhost:8081/foglamp/notification/<notification_name> """ try: notification_service = ServiceRegistry.get( s_type=ServiceRecord.Type.Notification.name) _address, _port = notification_service[ 0]._address, notification_service[0]._port except service_registry_exceptions.DoesNotExist: raise web.HTTPNotFound(reason="No Notification service available.") try: notif = request.match_info.get('notification_name', None) if notif is None: raise ValueError("Notification name is required for deletion.") # Stop & remove notification url = 'http://{}:{}/notification/{}'.format(_address, _port, urllib.parse.quote(notif)) notification = json.loads(await _hit_delete_url(url)) # Removes the child categories for the rule and delivery plugins, Removes the category for the notification itself storage = connect.get_storage_async() config_mgr = ConfigurationManager(storage) await config_mgr.delete_category_and_children_recursively(notif) audit = AuditLogger(storage) await audit.information('NTFDL', {"name": notif}) except ValueError as ex: raise web.HTTPBadRequest(reason=str(ex)) except Exception as ex: raise web.HTTPInternalServerError(reason=str(ex)) else: return web.json_response( {'result': 'Notification {} deleted successfully.'.format(notif)})
async def test_get(self): with patch.object(Service._logger, 'info') as log_info: s = Service.register("StorageService", "Storage", "localhost", 8881, 1888) c = Service.register("CoreService", "Core", "localhost", 7771, 1777) d = Service.register("SouthService", "Southbound", "127.0.0.1", 9991, 1999, "https") assert 3 == log_info.call_count _service = Service.get() assert 3 == len(_service) assert s == _service[0]._id assert "StorageService" == _service[0]._name assert "Storage" == _service[0]._type assert "localhost" == _service[0]._address assert 8881 == int(_service[0]._port) assert 1888 == int(_service[0]._management_port) # validates default set to HTTP assert "http" == _service[0]._protocol assert c == _service[1]._id assert "CoreService" == _service[1]._name assert "Core" == _service[1]._type assert "localhost" == _service[1]._address assert 7771 == int(_service[1]._port) assert 1777 == int(_service[1]._management_port) # validates default set to HTTP assert "http" == _service[1]._protocol assert d == _service[2]._id assert "SouthService" == _service[2]._name assert "Southbound" == _service[2]._type assert "127.0.0.1" == _service[2]._address assert 9991 == int(_service[2]._port) assert 1999 == int(_service[2]._management_port) assert "https" == _service[2]._protocol
async def stop_microservices(cls): """ call shutdown endpoint for non core micro-services There are 3 types of services - Core - Storage - Southbound """ try: found_services = ServiceRegistry.get() services_to_stop = list() for fs in found_services: if fs._name in ("FogLAMP Storage", "FogLAMP Core"): continue if fs._status not in [ ServiceRecord.Status.Running, ServiceRecord.Status.Unresponsive ]: continue services_to_stop.append(fs) if len(services_to_stop) == 0: _logger.info( "No service found except the core, and(or) storage.") return tasks = [ cls._request_microservice_shutdown(svc) for svc in services_to_stop ] await asyncio.wait(tasks) except service_registry_exceptions.DoesNotExist: pass except Exception as ex: _logger.exception(str(ex))
async def post_notification(request): """ Create a new notification to run a specific plugin :Example: curl -X POST http://localhost:8081/foglamp/notification -d '{"name": "Test Notification", "description":"Test Notification", "rule": "threshold", "channel": "email", "notification_type": "one shot", "enabled": false}' curl -X POST http://localhost:8081/foglamp/notification -d '{"name": "Test Notification", "description":"Test Notification", "rule": "threshold", "channel": "email", "notification_type": "one shot", "enabled": false, "rule_config": {}, "delivery_config": {}}' """ try: notification_service = ServiceRegistry.get(s_type=ServiceRecord.Type.Notification.name) _address, _port = notification_service[0]._address, notification_service[0]._port except service_registry_exceptions.DoesNotExist: raise web.HTTPNotFound(reason="No Notification service available.") try: data = await request.json() if not isinstance(data, dict): raise ValueError('Data payload must be a valid JSON') name = data.get('name', None) description = data.get('description', None) rule = data.get('rule', None) channel = data.get('channel', None) notification_type = data.get('notification_type', None) enabled = data.get('enabled', None) rule_config = data.get('rule_config', {}) delivery_config = data.get('delivery_config', {}) if name is None or name.strip() == "": raise ValueError('Missing name property in payload.') if description is None: raise ValueError('Missing description property in payload.') if rule is None: raise ValueError('Missing rule property in payload.') if channel is None: raise ValueError('Missing channel property in payload.') if notification_type is None: raise ValueError('Missing notification_type property in payload.') if utils.check_reserved(name) is False: raise ValueError('Invalid name property in payload.') if utils.check_reserved(rule) is False: raise ValueError('Invalid rule property in payload.') if utils.check_reserved(channel) is False: raise ValueError('Invalid channel property in payload.') if notification_type not in NOTIFICATION_TYPE: raise ValueError('Invalid notification_type property in payload.') if enabled is not None: if enabled not in ['true', 'false', True, False]: raise ValueError('Only "true", "false", true, false are allowed for value of enabled.') is_enabled = "true" if ((type(enabled) is str and enabled.lower() in ['true']) or ( (type(enabled) is bool and enabled is True))) else "false" try: # Get default config for rule and channel plugins url = '{}/plugin'.format(request.url) list_plugins = json.loads(await _hit_get_url(url)) r = list(filter(lambda rules: rules['name'] == rule, list_plugins['rules'])) c = list(filter(lambda channels: channels['name'] == channel, list_plugins['delivery'])) if len(r) == 0 or len(c) == 0: raise KeyError rule_plugin_config = r[0]['config'] delivery_plugin_config = c[0]['config'] except KeyError: raise ValueError("Invalid rule plugin:[{}] and/or delivery plugin:[{}] supplied.".format(rule, channel)) # Verify if rule_config contains valid keys if rule_config != {}: for k, v in rule_config.items(): if k not in rule_plugin_config: raise ValueError("Invalid key:[{}] in rule_config:[{}] supplied for plugin [{}].".format(k, rule_config, rule)) # Verify if delivery_config contains valid keys if delivery_config != {}: for k, v in delivery_config.items(): if k not in delivery_plugin_config: raise ValueError( "Invalid key:[{}] in delivery_config:[{}] supplied for plugin [{}].".format(k, delivery_config, channel)) # First create templates for notification and rule, channel plugins post_url = 'http://{}:{}/notification/{}'.format(_address, _port, urllib.parse.quote(name)) await _hit_post_url(post_url) # Create Notification template post_url = 'http://{}:{}/notification/{}/rule/{}'.format(_address, _port, urllib.parse.quote(name), urllib.parse.quote(rule)) await _hit_post_url(post_url) # Create Notification rule template post_url = 'http://{}:{}/notification/{}/delivery/{}'.format(_address, _port, urllib.parse.quote(name), urllib.parse.quote(channel)) await _hit_post_url(post_url) # Create Notification delivery template # Create configurations storage = connect.get_storage_async() config_mgr = ConfigurationManager(storage) notification_config = { "rule": rule, "channel": channel, "notification_type": notification_type, "enable":is_enabled, } await _update_configurations(config_mgr, name, notification_config, rule_config, delivery_config) audit = AuditLogger(storage) await audit.information('NTFAD', {"name": name}) except ValueError as ex: raise web.HTTPBadRequest(reason=str(ex)) except Exception as e: raise web.HTTPInternalServerError(reason=str(e)) else: return web.json_response({'result': "Notification {} created successfully".format(name)})
async def put_notification(request): """ Update an existing notification :Example: curl -X PUT http://localhost:8081/foglamp/notification/<notification_name> -d '{"description":"Test Notification modified"}' curl -X PUT http://localhost:8081/foglamp/notification/<notification_name> -d '{"rule": "threshold", "channel": "email"}' curl -X PUT http://localhost:8081/foglamp/notification/<notification_name> -d '{"notification_type": "one shot", "enabled": false}' curl -X PUT http://localhost:8081/foglamp/notification/<notification_name> -d '{"enabled": false}' curl -X PUT http://localhost:8081/foglamp/notification/<notification_name> -d '{"description":"Test Notification", "rule": "threshold", "channel": "email", "notification_type": "one shot", "enabled": false, "rule_config": {}, "delivery_config": {}}' """ try: notification_service = ServiceRegistry.get(s_type=ServiceRecord.Type.Notification.name) _address, _port = notification_service[0]._address, notification_service[0]._port except service_registry_exceptions.DoesNotExist: raise web.HTTPNotFound(reason="No Notification service available.") try: notif = request.match_info.get('notification_name', None) if notif is None: raise ValueError("Notification name is required for updation.") # TODO: Stop notification before update data = await request.json() if not isinstance(data, dict): raise ValueError('Data payload must be a valid JSON') description = data.get('description', None) rule = data.get('rule', None) channel = data.get('channel', None) notification_type = data.get('notification_type', None) enabled = data.get('enabled', None) rule_config = data.get('rule_config', {}) delivery_config = data.get('delivery_config', {}) if utils.check_reserved(notif) is False: raise ValueError('Invalid notification name parameter.') if rule is not None and utils.check_reserved(rule) is False: raise ValueError('Invalid rule property in payload.') if channel is not None and utils.check_reserved(channel) is False: raise ValueError('Invalid channel property in payload.') if notification_type is not None and notification_type not in NOTIFICATION_TYPE: raise ValueError('Invalid notification_type property in payload.') if enabled is not None: if enabled not in ['true', 'false', True, False]: raise ValueError('Only "true", "false", true, false are allowed for value of enabled.') is_enabled = "true" if ((type(enabled) is str and enabled.lower() in ['true']) or ( (type(enabled) is bool and enabled is True))) else "false" storage = connect.get_storage_async() config_mgr = ConfigurationManager(storage) current_config = await config_mgr._read_category_val(notif) rule_changed = True if rule is not None and rule != current_config['rule']['value'] else False channel_changed = True if channel is not None and channel != current_config['channel']['value'] else False try: # Get default config for rule and channel plugins url = str(request.url) url_parts = url.split("/foglamp/notification") url = '{}/foglamp/notification/plugin'.format(url_parts[0]) list_plugins = json.loads(await _hit_get_url(url)) search_rule = rule if rule_changed else current_config['rule']['value'] r = list(filter(lambda rules: rules['name'] == search_rule, list_plugins['rules'])) if len(r) == 0: raise KeyError rule_plugin_config = r[0]['config'] search_channel = channel if channel_changed else current_config['channel']['value'] c = list(filter(lambda channels: channels['name'] == search_channel, list_plugins['delivery'])) if len(c) == 0: raise KeyError delivery_plugin_config = c[0]['config'] except KeyError: raise ValueError("Invalid rule plugin:{} and/or delivery plugin:{} supplied.".format(rule, channel)) # Verify if rule_config contains valid keys if rule_config != {}: for k, v in rule_config.items(): if k not in rule_plugin_config: raise ValueError("Invalid key:{} in rule plugin:{}".format(k, rule_plugin_config)) # Verify if delivery_config contains valid keys if delivery_config != {}: for k, v in delivery_config.items(): if k not in delivery_plugin_config: raise ValueError( "Invalid key:{} in delivery plugin:{}".format(k, delivery_plugin_config)) if rule_changed: # A new rule has been supplied category_desc = rule_plugin_config['plugin']['description'] category_name = "rule{}".format(notif) await config_mgr.create_category(category_name=category_name, category_description=category_desc, category_value=rule_plugin_config, keep_original_items=False) if channel_changed: # A new delivery has been supplied category_desc = delivery_plugin_config['plugin']['description'] category_name = "delivery{}".format(notif) await config_mgr.create_category(category_name=category_name, category_description=category_desc, category_value=delivery_plugin_config, keep_original_items=False) notification_config = {} if description is not None: notification_config.update({"description": description}) if rule is not None: notification_config.update({"rule": rule}) if channel is not None: notification_config.update({"channel": channel}) if notification_type is not None: notification_config.update({"notification_type": notification_type}) if enabled is not None: notification_config.update({"enable": is_enabled}) await _update_configurations(config_mgr, notif, notification_config, rule_config, delivery_config) except ValueError as ex: raise web.HTTPBadRequest(reason=str(ex)) except Exception as e: raise web.HTTPInternalServerError(reason=str(e)) else: # TODO: Start notification after update return web.json_response({'result': "Notification {} updated successfully".format(notif)})
async def test_get_fail(self): with pytest.raises(DoesNotExist) as excinfo: Service.register("StorageService", "Storage", "127.0.0.1", 8888, 9999) Service.get('incorrect_id') assert str(excinfo).endswith('DoesNotExist')