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)
