async def post(self) -> web.Response: request_data = await self.request.json() await add_contact_to_contact_group( self.request.app['dbcon'], cast(int, require_int(request_data.get('contact_group_id'))), cast(int, require_int(request_data.get('contact_id')))) return web.json_response(True)
async def _get_monitor_metadata( self, dbcon: DBConnection) -> Optional[Dict[int, Dict[str, str]]]: include_metadata = require_bool(get_request_param( self.request, 'include_metadata', error_if_missing=False), convert=True) or False if not include_metadata: return None if 'id' in self.request.rel_url.query: metadata_models = await metadata.get_metadata_for_object( dbcon, 'active_monitor', require_int(cast(str, get_request_param(self.request, 'id')))) elif 'meta_key' in self.request.rel_url.query: meta_key = require_str(get_request_param(self.request, 'meta_key')) meta_value = require_str( get_request_param(self.request, 'meta_value')) metadata_models = await metadata.get_metadata_for_object_metadata( dbcon, meta_key, meta_value, 'active_monitor', 'active_monitors') elif 'monitor_group_id' in self.request.rel_url.query: metadata_models = await monitor_group.get_active_monitor_metadata_for_monitor_group( dbcon, require_int( cast(str, get_request_param(self.request, 'monitor_group_id')))) else: metadata_models = await metadata.get_metadata_for_object_type( dbcon, 'active_monitor') metadata_dict = {} # type: Dict[int, Dict[str, str]] for metadata_model in metadata_models: if metadata_model.object_id not in metadata_dict: metadata_dict[metadata_model.object_id] = {} metadata_dict[metadata_model.object_id][ metadata_model.key] = metadata_model.value return metadata_dict
async def post(self) -> web.Response: request_data = await self.request.json() await monitor_group.add_active_monitor_to_monitor_group( self.request.app['dbcon'], cast(int, require_int(request_data.get('monitor_group_id'))), cast(int, require_int(request_data.get('monitor_id')))) return web.json_response(True)
async def delete(self) -> web.Response: request_data = await self.request.json() await monitor_group.delete_contact_group_from_monitor_group( self.request.app['dbcon'], cast(int, require_int(request_data.get('monitor_group_id'))), cast(int, require_int(request_data.get('contact_group_id')))) return web.json_response(True)
async def get(self) -> web.Response: contact_group_id = cast( int, require_int(get_request_param(self.request, 'contact_group_id'))) ret = await get_contacts_for_contact_group(self.request.app['dbcon'], contact_group_id) return web.json_response(object_models.list_asdict(ret))
async def post(self) -> web.Response: request_data = await self.request.json() monitor_group_id = await monitor_group.create_monitor_group( self.request.app['dbcon'], require_int(request_data.get('parent_id', None), allow_none=True), require_str(request_data.get('name', None), allow_none=True)) return web.json_response(monitor_group_id)
async def put(self) -> web.Response: request_data = await self.request.json() contact_group_id = cast( int, require_int(get_request_param(self.request, 'id'))) dbcon = self.request.app['dbcon'] await update_contact_group(dbcon, contact_group_id, request_data) return web.json_response(True)
def _get_request_monitor(self, request: web.Request) -> ActiveMonitor: monitor_id = require_int(cast(str, get_request_param(request, 'id'))) monitor = request.app['active_monitor_manager'].monitors.get( monitor_id, None) if not monitor: raise errors.NotFound() return monitor
async def get(self) -> web.Response: dbcon = self.request.app['dbcon'] if 'id' in self.request.rel_url.query: monitor_group_id = require_int( get_request_param(self.request, 'id')) monitor_group_item = await monitor_group.get_monitor_group( dbcon, monitor_group_id) monitor_group_list = [ ] # type: Iterable[object_models.MonitorGroup] if monitor_group_item: monitor_group_list = [monitor_group_item] metadata_list = await metadata.get_metadata_for_object( dbcon, 'monitor_group', monitor_group_id) elif 'meta_key' in self.request.rel_url.query: meta_key = require_str(get_request_param(self.request, 'meta_key')) meta_value = require_str( get_request_param(self.request, 'meta_value')) monitor_group_list = await monitor_group.get_monitor_groups_for_metadata( dbcon, meta_key, meta_value) metadata_list = await metadata.get_metadata_for_object_metadata( dbcon, meta_key, meta_value, 'monitor_group', 'monitor_groups') else: monitor_group_list = await monitor_group.get_all_monitor_groups( dbcon) metadata_list = await metadata.get_metadata_for_object_type( dbcon, 'monitor_group') return web.json_response( apply_metadata_to_model_list(monitor_group_list, metadata_list))
async def put(self) -> web.Response: request_data = await self.request.json() await set_contact_group_contacts( self.request.app['dbcon'], cast(int, require_int(request_data.get('contact_group_id'))), cast(List[int], require_list(request_data.get('contact_ids'), int))) return web.json_response(True)
def _get_request_monitor_def(self, request: web.Request) -> ActiveMonitorDef: monitor_def_id = require_int(get_request_param(request, 'id')) monitor_def = self.request.app[ 'active_monitor_manager'].monitor_defs.get(monitor_def_id, None) if not monitor_def: raise errors.NotFound() return monitor_def
async def get(self) -> web.Response: object_type = cast( str, require_str(get_request_param(self.request, 'object_type'))) object_id = cast( int, require_int(get_request_param(self.request, 'object_id'))) metadict = await metadata.get_metadata(self.request.app['dbcon'], object_type, object_id) return web.json_response(metadict)
async def post(self) -> web.Response: request_data = await self.request.json() await metadata.update_metadata( self.request.app['dbcon'], require_str(request_data.get('object_type')), require_int(request_data.get('object_id')), require_dict(request_data.get('metadict'), str)) return web.json_response(True)
async def delete(self) -> web.Response: request_data = await self.request.json() await metadata.delete_metadata( self.request.app['dbcon'], require_str(request_data.get('object_type')), require_int(request_data.get('object_id')), require_list(request_data.get('keys', None), allow_none=True)) return web.json_response(True)
async def delete(self) -> web.Response: object_type = cast( str, require_str(get_request_param(self.request, 'object_type'))) object_id = cast( int, require_int(get_request_param(self.request, 'object_id'))) key = cast(str, require_str(get_request_param(self.request, 'key'))) await bindata.delete_bindata(self.request.app['dbcon'], object_type, object_id, key) return web.Response(text='')
async def delete(self) -> web.Response: monitor_group_id = cast( int, require_int(get_request_param(self.request, 'id'))) dbcon = self.request.app['dbcon'] exists = await monitor_group.monitor_group_exists( dbcon, monitor_group_id) if not exists: raise errors.NotFound() await monitor_group.delete_monitor_group(dbcon, monitor_group_id) return web.json_response(True)
async def post(self) -> web.Response: object_type = cast( str, require_str(get_request_param(self.request, 'object_type'))) object_id = cast( int, require_int(get_request_param(self.request, 'object_id'))) key = cast(str, require_str(get_request_param(self.request, 'key'))) value = await self.request.read() await bindata.set_bindata(self.request.app['dbcon'], object_type, object_id, key, value) return web.Response(text='')
async def get(self) -> web.Response: object_type = cast( str, require_str(get_request_param(self.request, 'object_type'))) object_id = cast( int, require_int(get_request_param(self.request, 'object_id'))) key = cast(str, require_str(get_request_param(self.request, 'key'))) ret = await bindata.get_bindata(self.request.app['dbcon'], object_type, object_id, key) if ret is None: raise errors.NotFound() return web.Response(body=ret)
async def get(self) -> web.Response: # noinspection PyUnusedLocal q_args = () # type: Tuple if 'monitor_id' in self.request.rel_url.query: if 'only_active' in self.request.rel_url.query: q = """select id, monitor_id, start_ts, end_ts, alert_msg from active_monitor_alerts where monitor_id=%s and end_ts=0 order by start_ts desc""" else: q = """select id, monitor_id, start_ts, end_ts, alert_msg from active_monitor_alerts where monitor_id=%s order by start_ts desc""" monitor_id = require_int( get_request_param(self.request, 'monitor_id')) q_args = (monitor_id, ) ret = await self._get_alerts(q, q_args) elif 'meta_key' in self.request.rel_url.query: if 'only_active' in self.request.rel_url.query: q = """select alert.id, alert.monitor_id, alert.start_ts, alert.end_ts, alert.alert_msg from object_metadata as meta left join active_monitors on active_monitors.id=meta.object_id right join active_monitor_alerts as alert on alert.monitor_id=active_monitors.id where meta.key=%s and meta.value=%s and meta.object_type="active_monitor" and alert.end_ts=0 order by alert.start_ts desc""" else: q = """select alert.id, alert.monitor_id, alert.start_ts, alert.end_ts, alert.alert_msg from object_metadata as meta left join active_monitors on active_monitors.id=meta.object_id right join active_monitor_alerts as alert on alert.monitor_id=active_monitors.id where meta.key=%s and meta.value=%s and meta.object_type="active_monitor" order by alert.start_ts desc""" meta_key = require_str(get_request_param(self.request, 'meta_key')) meta_value = require_str( get_request_param(self.request, 'meta_value')) q_args = (meta_key, meta_value) ret = await self._get_alerts(q, q_args) else: if 'only_active' in self.request.rel_url.query: q = """select id, monitor_id, start_ts, end_ts, alert_msg from active_monitor_alerts where end_ts=0 order by start_ts desc""" else: q = """select id, monitor_id, start_ts, end_ts, alert_msg from active_monitor_alerts order by start_ts desc""" ret = await self._get_alerts(q, ()) return web.json_response(ret)
async def get(self) -> web.Response: monitor_id = cast( int, require_int(get_request_param(self.request, 'monitor_id'))) if 'include_all' in self.request.rel_url.query: contacts = await get_all_contacts_for_active_monitor( self.request.app['dbcon'], monitor_id) else: contacts = object_models.asdict(await get_contacts_for_active_monitor( self.request.app['dbcon'], monitor_id)) ret = object_models.list_asdict(contacts) return web.json_response(ret)
async def _get_monitor_ids(self, dbcon: DBConnection) -> List[int]: if 'id' in self.request.rel_url.query: ids = [ require_int(cast(str, get_request_param(self.request, 'id'))) ] elif 'meta_key' in self.request.rel_url.query: meta_key = require_str(get_request_param(self.request, 'meta_key')) meta_value = require_str( get_request_param(self.request, 'meta_value')) active_monitor_models = await active_sql.get_active_monitors_for_metadata( dbcon, meta_key, meta_value) ids = [monitor.id for monitor in active_monitor_models] elif 'monitor_group_id' in self.request.rel_url.query: monitor_group_id = require_int( get_request_param(self.request, 'monitor_group_id')) active_monitor_models = await monitor_group.get_active_monitors_for_monitor_group( dbcon, monitor_group_id) ids = [monitor.id for monitor in active_monitor_models] else: active_monitor_models = await active_sql.get_all_active_monitors( dbcon) ids = [monitor.id for monitor in active_monitor_models] return ids
async def post(self) -> None: request_data = await self.request.json() args = require_dict(request_data['args'], str, None) if request_data.get('use_monitor_def_name', False): monitor_def = get_monitor_def_by_name( self.request.app['active_monitor_manager'], require_str(request_data['monitor_def'])) else: monitor_def = self.request.app[ 'active_monitor_manager'].monitor_defs.get( require_int(request_data['monitor_def'])) if not monitor_def: raise errors.InvalidData('Monitor def not found') monitor = await create_active_monitor( self.request.app['active_monitor_manager'], args, monitor_def) if not monitor: raise errors.InvalidData('invalid monitor arguments') return web.json_response(monitor.id)
async def get(self) -> web.Response: dbcon = self.request.app['dbcon'] if 'id' in self.request.rel_url.query: monitor_def_id = require_int(get_request_param(self.request, 'id')) monitor_def_item = await active_sql.get_active_monitor_def( dbcon, monitor_def_id) monitor_def_list = [ ] # type: Iterable[object_models.ActiveMonitorDef] if monitor_def_item: monitor_def_list = [monitor_def_item] metadata_list = await metadata.get_metadata_for_object( dbcon, 'active_monitor_def', monitor_def_id) arg_list = await active_sql.get_active_monitor_def_args_for_def( dbcon, monitor_def_id) else: monitor_def_list = await active_sql.get_all_active_monitor_defs( dbcon) metadata_list = await metadata.get_metadata_for_object_type( dbcon, 'active_monitor_def') arg_list = await active_sql.get_all_active_monitor_def_args(dbcon) monitor_def_dict = { item.id: object_models.asdict(item) for item in monitor_def_list } for monitor_def in monitor_def_dict.values(): monitor_def['metadata'] = {} monitor_def['arg_def'] = [] for arg in arg_list: monitor_def = monitor_def_dict.get(arg.active_monitor_def_id) if monitor_def: monitor_def['arg_def'].append(object_models.asdict(arg)) for metadata_obj in metadata_list: monitor_def = monitor_def_dict.get(metadata_obj.object_id) if monitor_def: monitor_def['metadata'][metadata_obj.key] = metadata_obj.value return web.json_response(list(monitor_def_dict.values()))
async def get(self) -> web.Response: dbcon = self.request.app['dbcon'] if 'id' in self.request.rel_url.query: contact_id = require_int(get_request_param(self.request, 'id')) c = await contact.get_contact(dbcon, contact_id) contact_list = [] # type: Iterable[object_models.Contact] if c: contact_list = [c] metadata_list = await metadata.get_metadata_for_object( dbcon, 'contact', contact_id) elif 'meta_key' in self.request.rel_url.query: meta_key = require_str(get_request_param(self.request, 'meta_key')) meta_value = require_str( get_request_param(self.request, 'meta_value')) contact_list = await contact.get_contacts_for_metadata( dbcon, meta_key, meta_value) metadata_list = await metadata.get_metadata_for_object_metadata( dbcon, meta_key, meta_value, 'contact', 'contacts') else: contact_list = await contact.get_all_contacts(dbcon) metadata_list = await metadata.get_metadata_for_object_type( dbcon, 'contact') return web.json_response( apply_metadata_to_model_list(contact_list, metadata_list))
async def delete(self) -> web.Response: contact_group_id = cast( int, require_int(get_request_param(self.request, 'id'))) dbcon = self.request.app['dbcon'] await delete_contact_group(dbcon, contact_group_id) return web.json_response(True)