def __init__(self, *args, **kwargs):
super(MuteForm, self).__init__(*args, **kwargs)
all_servers = server_model.get_all()
if all_servers:
server_fields = [
('all', 'All'),
] + [(v['_id'], v['name']) for v in all_servers]
else:
server_fields = [
('all', 'All'),
]
self.fields['server'] = forms.ChoiceField(choices=server_fields)
self.fields['server'].widget.attrs.update({
'server-dropdown': '',
'data-size': 250
})
all_tags = tags_model.get_all()
if all_tags:
tags_fields = [
(v['_id'],
"{0}:{1}".format(v.get('group', {}).get('name'), v['name']))
for v in all_tags
]
self.fields['tags'] = forms.MultipleChoiceField(
choices=tags_fields, required=False)
self.fields['tags'].widget.attrs.update({
'select2-dropdown': '',
'data-size': 400
})
def add_alert(request):
all_servers = server_model.get_all()
tags = tags_model.get_all()
notifications = notifications_model.get_all_formated()
if request.method == 'POST':
form = HealthCheckAlertForm(request.POST, all_servers=all_servers)
if form.is_valid():
data = form.cleaned_data
form_data = {
"command": request.POST.get('command'),
"param": request.POST.get('param'),
"tags": request.POST.getlist('tags'),
"notifications": request.POST.getlist('notifications'),
"rule_type": "health_check",
}
data.update(form_data)
alerts_model.save(data)
return redirect(reverse('alerts'))
else:
form = HealthCheckAlertForm(all_servers=all_servers)
return render(
request, 'alerts/add_healthcheck.html', {
"form": form,
'tags': tags,
'notifications': notifications,
"all_servers": all_servers
})
def all(request):
all_servers = server_model.get_all(account_id=request.account_id)
alerts = []
if all_servers:
for server in all_servers:
types = ['system', 'process', 'uptime', 'plugin']
for alert_type in types:
result = alerts_model.get_alerts(type=alert_type, server=server)
if result:
[alerts.append(x) for x in result]
global_alerts = alerts_model.get_global_alerts_with_notifications(all_servers=all_servers, account_id=request.account_id, include_all_types=True)
if global_alerts:
[alerts.append(x) for x in global_alerts]
global_health_check_alerts = alerts_model.get_alerts(type='health_check')
if global_health_check_alerts:
[alerts.append(x) for x in global_health_check_alerts]
return render(request, 'alerts/all.html', {
"alerts": alerts,
"all_servers": all_servers,
"server_metrics": settings.SERVER_METRICS,
"common_metrics": settings.COMMON_METRICS,
"total_alerts": len(alerts),
})
def index(request):
all_sort_fields = map_model.get_fields()
all_servers = server_model.get_all()
tag_groups = tag_groups_model.get_all()
servers_data = []
GET_group_id = request.GET.get('group_id', False)
sort_by = request.GET.get('sort_by', 'system:cpu.system')
servers_data = map_model.sort_by(field=sort_by)
grouped_servers = []
if GET_group_id:
grouped_servers = map_model.group_by(group_id=GET_group_id,
data=servers_data)
active_tag_groups = set([])
if all_servers:
for server in all_servers:
server_tags = server.get('tags', [])
for t in server_tags:
group_id = t.get('group_id', False)
if group_id is not False:
active_tag_groups.add(str(group_id))
return render(
request, 'map/view.html', {
"all_sort_fields": all_sort_fields,
"grouped_servers": grouped_servers,
"servers_data": servers_data,
"group_id": GET_group_id,
"sort_by": sort_by,
"tag_groups": tag_groups,
"active_tag_groups": active_tag_groups,
})
def index(request):
all_sort_fields = map_model.get_fields()
all_servers = server_model.get_all()
tag_groups = tag_groups_model.get_all()
servers_data = []
GET_group_id = request.GET.get('group_id', False)
sort_by = request.GET.get('sort_by', 'system:cpu.system')
servers_data = map_model.sort_by(field=sort_by)
grouped_servers = []
if GET_group_id:
grouped_servers = map_model.group_by(group_id=GET_group_id, data=servers_data)
active_tag_groups = set([])
if all_servers:
for server in all_servers:
server_tags = server.get('tags', [])
for t in server_tags:
group_id = t.get('group_id', False)
if group_id is not False:
active_tag_groups.add(str(group_id))
return render(request, 'map/view.html', {
"all_sort_fields": all_sort_fields,
"grouped_servers": grouped_servers,
"servers_data": servers_data,
"group_id": GET_group_id,
"sort_by": sort_by,
"tag_groups": tag_groups,
"active_tag_groups": active_tag_groups,
})
def all(request):
all_servers = server_model.get_all(account_id=request.account_id)
alerts = []
if all_servers:
for server in all_servers:
types = ['system', 'process', 'uptime', 'plugin']
for alert_type in types:
result = alerts_model.get_alerts(type=alert_type, server=server)
if result:
[alerts.append(x) for x in result]
global_alerts = alerts_model.get_global_alerts_with_notifications(all_servers=all_servers, account_id=request.account_id, include_all_types=True)
if global_alerts:
[alerts.append(x) for x in global_alerts]
global_health_check_alerts = alerts_model.get_alerts(type='health_check')
if global_health_check_alerts:
[alerts.append(x) for x in global_health_check_alerts]
return render(request, 'alerts/all.html', {
"alerts": alerts,
"all_servers": all_servers,
"server_metrics": settings.SERVER_METRICS,
"common_metrics": settings.COMMON_METRICS,
"total_alerts": len(alerts),
})
def edit_alert(request, alert_id):
all_servers = server_model.get_all(account_id=request.account_id)
alert = alerts_model.get_by_id(alert_id, recipients_dict=False)
tags = tags_model.get_all()
server = alert.get('server', None) # If the alert is for specific server, it could be global
notifications = notifications_model.get_all_formated()
selected_metric = alerts_api_model.get_selected_metric(alert=alert)
if request.method == 'POST':
form = EditAlertForm(request.POST, all_servers=all_servers)
if form.is_valid():
data = form.cleaned_data
form_data = {
"tags": request.POST.getlist('tags', None),
"metric_value": data.get('metric_value'),
"above_below": data.get('above_below'),
"period": data.get('period'),
"server": server,
"metric_type": request.POST.get('metric_type'),
"notifications": request.POST.getlist('notifications')
}
alerts_model.update(form_data, alert_id)
return redirect(reverse('alerts'))
else:
form = EditAlertForm(all_servers=all_servers, initial={
'metric_value': alert['metric_value'],
'period': alert['period'],
'server':server,
"above_below": alert['above_below'],
})
# TODO - Fix that angular bug sometime
metric_types = ''
metric = alert.get('metric')
if metric:
metric = metric.lower()
metric_types = ["%"] if metric == 'cpu' else []
metric_types = ["%", "MB"] if metric == 'memory' else metric_types
metric_types = ["%", "MB", "GB"] if metric == 'disk' else metric_types
metric_types = ["KB/s"] if metric in ['network/inbound', 'network/outbound'] else metric_types
return render(request, 'alerts/edit.html', {
"server": server,
'tags': tags,
"alert": alert,
"form": form,
"selected_metric": selected_metric,
"notifications": notifications,
"metric_types": metric_types,
})
def edit_alert(request, alert_id):
all_servers = server_model.get_all(account_id=request.account_id)
alert = alerts_model.get_by_id(alert_id, recipients_dict=False)
tags = tags_model.get_all()
server = alert.get('server', None) # If the alert is for specific server, it could be global
notifications = notifications_model.get_all_formated()
selected_metric = alerts_api_model.get_selected_metric(alert=alert)
if request.method == 'POST':
form = EditAlertForm(request.POST, all_servers=all_servers)
if form.is_valid():
data = form.cleaned_data
form_data = {
"tags": request.POST.getlist('tags', None),
"metric_value": data.get('metric_value'),
"above_below": data.get('above_below'),
"period": data.get('period'),
"server": server,
"metric_type": request.POST.get('metric_type'),
"notifications": request.POST.getlist('notifications')
}
alerts_model.update(form_data, alert_id)
return redirect(reverse('alerts'))
else:
form = EditAlertForm(all_servers=all_servers, initial={
'metric_value': alert['metric_value'],
'period': alert['period'],
'server':server,
"above_below": alert['above_below'],
})
# TODO - Fix that angular bug sometime
metric_types = ''
metric = alert.get('metric')
if metric:
metric = metric.lower()
metric_types = ["%"] if metric == 'cpu' else []
metric_types = ["%", "MB"] if metric == 'memory' else metric_types
metric_types = ["%", "MB", "GB"] if metric == 'disk' else metric_types
metric_types = ["KB/s"] if metric in ['network/inbound', 'network/outbound'] else metric_types
return render(request, 'alerts/edit.html', {
"server": server,
'tags': tags,
"alert": alert,
"form": form,
"selected_metric": selected_metric,
"notifications": notifications,
"metric_types": metric_types,
})
def servers(request, *args, **kwargs):
account_id = kwargs['account_id']
all_servers = server_model.get_all(account_id=int(account_id))
return render(request, 'admin/servers.html', {
'all_servers': all_servers,
'title': 'Servers'
})
def servers(request, *args, **kwargs):
account_id = kwargs['account_id']
all_servers = server_model.get_all(account_id=int(account_id))
return render_to_response('admin/servers.html', {
'all_servers': all_servers,
'title': 'Servers'
},
context_instance=RequestContext(request))
def edit_dashboard(request, dashboard_id):
dashboard = dashboard_model.get_by_id(dashboard_id)
all_servers = server_model.get_all(account_id=request.account_id)
all_healthchecks = health_checks_model.get_all()
return render(request, 'dashboards/edit.html', {
"dashboard": dashboard,
"all_servers": all_servers,
"all_healthchecks": all_healthchecks
})
def servers(request, *args, **kwargs):
account_id = kwargs['account_id']
all_servers = server_model.get_all(account_id=int(account_id))
return render(request, 'admin/servers.html', {
'all_servers': all_servers,
'title': 'Servers'
})
def edit_dashboard(request, dashboard_id):
dashboard = dashboard_model.get_by_id(dashboard_id)
all_servers = server_model.get_all(account_id=request.account_id)
all_healthchecks = health_checks_model.get_all()
return render(request, 'dashboards/edit.html', {
"dashboard": dashboard,
"all_servers": all_servers,
"all_healthchecks": all_healthchecks
})
def public_dashboard_metric(request, metric_id=None):
timestamp = request.GET.get('timestamp')
dashboard_metric = dashboard_metrics_model.get_by_id(metric_id)
server_id = dashboard_metric.get('server_id')
process_id = dashboard_metric.get('process_id')
plugin_id = dashboard_metric.get('plugin_id')
metric_type = dashboard_metric.get('metric_type')
check = dashboard_metric.get('check')
# App metrics here
tags = dashboard_metric.get('tags', [])
filtered_servers = server_model.get_all()
if len(tags) > 0:
filtered_servers = server_model.get_with_tags(tags=tags)
response = {}
if metric_type == 'system':
response = get_system_data_after(timestamp=timestamp,
server_id=server_id,
check=check)
elif metric_type == 'process':
response = get_process_data_after(timestamp=timestamp,
server_id=server_id,
process_id=process_id,
check=check)
elif metric_type == 'plugin':
gauge_id = dashboard_metric.get('gauge_id')
response = get_plugin_data_after(timestamp=timestamp,
plugin_id=plugin_id,
gauge_id=gauge_id)
elif metric_type == 'system_global':
key = dashboard_metric.get('key') # loadavg.minute
response = get_global_system_data_after(
timestamp=timestamp,
check=check,
key=key,
filtered_servers=filtered_servers)
elif metric_type == 'process_global':
key = dashboard_metric.get('key') # loadavg.minute
response = get_global_process_data_after(
timestamp=timestamp,
check=check,
key=key,
filtered_servers=filtered_servers)
elif metric_type == 'plugin_global':
response = get_global_plugin_data_after(
timestamp=timestamp,
metric=dashboard_metric,
filtered_servers=filtered_servers)
return Response(response)
def edit_dashboard(request, dashboard_id):
dashboard = dashboard_model.get_by_id(dashboard_id)
all_servers = server_model.get_all(account_id=request.account_id)
all_healthchecks = health_checks_model.get_all()
return render_to_response('dashboards/edit.html', {
"dashboard": dashboard,
"all_servers": all_servers,
"all_healthchecks": all_healthchecks
},
context_instance=RequestContext(request))
def edit_alert(request, alert_id):
all_servers = server_model.get_all(account_id=request.account_id)
alert = alerts_model.get_by_id(alert_id, recipients_dict=False)
tags = tags_model.get_all()
server = alert.get(
'server',
None) # If the alert is for specific server, it could be global
selected_command = " ".join(
[alert.get("command", ""),
alert.get('params', "")])
notifications = notifications_model.get_all_formated()
if request.method == 'POST':
form = EditHealthCheckAlertForm(request.POST, all_servers=all_servers)
if form.is_valid():
data = form.cleaned_data
form_data = {
"tags": request.POST.getlist('tags', None),
"status": data.get('status'),
"period": data.get('period'),
"server": server,
"notifications": request.POST.getlist('notifications')
}
alerts_model.update(form_data, alert_id)
return redirect(reverse('alerts'))
else:
form = EditHealthCheckAlertForm(all_servers=all_servers,
initial={
'period': alert['period'],
'server': server,
"status": alert['status'],
})
return render(
request, 'alerts/edit_healthcheck.html', {
"server": server,
'tags': tags,
"alert": alert,
"form": form,
"selected_command": selected_command,
"notifications": notifications,
})
def charts_global_variables(request):
if request.user.is_authenticated():
all_servers = server_model.get_all(account_id=request.account_id)
global_variables_dict = {
'duration_form': DurationForm(),
'system_charts_form': SystemChartsForm(),
'process_charts_form': ProcessChartsForm(),
'all_servers': all_servers
}
else:
global_variables_dict = {
'duration_form': DurationForm(),
}
return global_variables_dict
def get(self, request):
servers = server_model.get_all()
filtered_servers = []
if servers != None:
for server in servers:
filtered_servers.append({
'name': server['name'],
'key': server['key'],
'id': str(server['_id']),
'last_check': server.get('last_check'),
'provider': server.get('provider')
})
status = settings.API_RESULTS['ok']
return Response({'status': status, 'servers': filtered_servers})
def delete_alert(request, alert_id):
alert = alerts_model.get_by_id(alert_id)
rule_type = alert.get('rule_type', None)
if rule_type in ['process_global', 'plugin_global', 'global', 'health_check']:
all_servers = server_model.get_all()
if all_servers:
for server in all_servers:
server_id = server.get('_id')
alerts_model.delete(server_id=server_id, alert_id=alert_id)
else:
alerts_model.delete(alert_id=alert_id)
else:
server_id = alert.get('server', None)
alerts_model.delete(server_id=server_id, alert_id=alert_id)
return redirect(reverse('alerts'))
def delete_alert(request, alert_id):
alert = alerts_model.get_by_id(alert_id)
rule_type = alert.get('rule_type', None)
if rule_type in ['process_global', 'plugin_global', 'global', 'health_check']:
all_servers = server_model.get_all()
if all_servers:
for server in all_servers:
server_id = server.get('_id')
alerts_model.delete(server_id=server_id, alert_id=alert_id)
else:
alerts_model.delete(alert_id=alert_id)
else:
server_id = alert.get('server', None)
alerts_model.delete(server_id=server_id, alert_id=alert_id)
return redirect(reverse('alerts'))
def charts_global_variables(request):
if request.user.is_authenticated:
all_servers = server_model.get_all(account_id=request.account_id)
global_variables_dict = {
'duration_form': DurationForm(),
'system_charts_form': SystemChartsForm(),
'process_charts_form': ProcessChartsForm(),
'all_servers': all_servers
}
else:
global_variables_dict = {
'duration_form': DurationForm(),
}
return global_variables_dict
def get_alerts_not_sending_data(self, metric=None):
params = {"metric": 'NotSendingData'}
alerts_list = []
result = self.collection.find(params)
if result.clone().count() > 0:
for rule in result:
rule['notifications'] = self._get_notifications(rule)
server = rule.get('server')
if server:
rule['server_data'] = [server_model.get_by_id(server)]
if rule['rule_type'] == 'global':
rule['server_data'] = server_model.get_all()
alerts_list.append(rule)
return alerts_list
def __init__(self, *args, **kwargs):
super(MuteForm, self).__init__(*args, **kwargs)
all_servers = server_model.get_all()
if all_servers:
server_fields = [('all','All'),]+[(v['_id'],v['name']) for v in all_servers]
else:
server_fields = [('all','All'),]
self.fields['server'] = forms.ChoiceField(choices=server_fields)
self.fields['server'].widget.attrs.update({'server-dropdown': '', 'data-size': 250 })
all_tags = tags_model.get_all()
if all_tags:
tags_fields = [(v['_id'],"{0}:{1}".format(v.get('group', {}).get('name'), v['name']) ) for v in all_tags]
self.fields['tags'] = forms.MultipleChoiceField(choices=tags_fields, required=False)
self.fields['tags'].widget.attrs.update({'select2-dropdown': '', 'data-size': 400})
def get(self, request):
servers = server_model.get_all()
filtered_servers = []
if servers != None:
for server in servers:
filtered_servers.append({'name': server['name'],
'key': server['key'],
'id': str(server['_id']),
'last_check': server.get('last_check'),
'provider': server.get('provider')}
)
status = settings.API_RESULTS['ok']
return Response({'status': status, 'servers': filtered_servers})
def add_alert(request):
all_servers = server_model.get_all(account_id=request.account_id)
tags = tags_model.get_all()
notifications = notifications_model.get_all_formated()
if request.method == 'POST':
form = AlertForm(request.POST, all_servers=all_servers)
if form.is_valid():
data = form.cleaned_data
metric = data.get('metric')
metric_dict = dict(item.split(":") for item in metric.split("."))
form_data = {
"metric_type": request.POST.get('metric_type'),
"tags": request.POST.getlist('tags'),
"notifications": request.POST.getlist('notifications'),
"rule_type": metric_dict.get('rule_type'),
"account_id": request.account_id,
}
form_data = dict(
list(form_data.items()) + list(metric_dict.items()))
del data['metric']
data.update(form_data)
alerts_model.save(data)
return redirect(reverse('alerts'))
else:
form = AlertForm(all_servers=all_servers)
return render_to_response('alerts/add.html', {
"common_metrics": settings.COMMON_METRICS,
"form": form,
'tags': tags,
'notifications': notifications,
"all_servers": all_servers
},
context_instance=RequestContext(request))
def ajax_get_only_server_tags(request):
all_servers = server_model.get_all()
filtered_tags = []
for s in all_servers:
server_tags = s.get('tags', [])
tags_list = [x for x in server_tags]
if len(tags_list) > 0:
filtered_tags.extend(tags_list)
# Filter by tag_id and leave only unique tags
filtered_tags = dict((v['_id'], v) for v in filtered_tags).values()
result = []
for tag in filtered_tags:
tag_dict = _tag_dict__repr__(tag=tag)
if len(tag_dict) > 0:
result.append(tag_dict)
result = sorted(result, key=itemgetter('group'))
return Response(result)
def add_alert(request):
all_servers = server_model.get_all(account_id=request.account_id)
tags = tags_model.get_all()
notifications = notifications_model.get_all_formated()
if request.method == 'POST':
form = AlertForm(request.POST, all_servers=all_servers)
if form.is_valid():
data = form.cleaned_data
metric = data.get('metric')
metric_dict = dict(item.split(":") for item in metric.split("."))
form_data = {
"metric_type": request.POST.get('metric_type'),
"tags": request.POST.getlist('tags'),
"notifications": request.POST.getlist('notifications'),
"rule_type": metric_dict.get('rule_type'),
"account_id": request.account_id,
}
form_data = dict(list(form_data.items()) + list(metric_dict.items()))
del data['metric']
data.update(form_data)
alerts_model.save(data)
return redirect(reverse('alerts'))
else:
form = AlertForm(all_servers=all_servers)
return render(request, 'alerts/add.html', {
"common_metrics": settings.COMMON_METRICS,
"form": form,
'tags': tags,
'notifications': notifications,
"all_servers": all_servers
})
def get_memory_data_test(self):
self._cleanup()
collection = system_model.data_collection
for i in range(0, 30):
memory_dict = {
"time": i,
"server_id": self.server_id,
"memory": {
"used_percent": 15,
"swap_used_mb": 0,
"total_mb": 166,
"free_mb": 4.44,
"used_mb": 66.55,
}
}
collection.insert(memory_dict)
result = system_model.get_data_after(timestamp=10,
enddate=20,
server=self.server,
check='memory')
total = result[1]['data']
eq_(len(total), 11)
for entry in total:
assert entry['x'] >= 10
assert entry['x'] <= 20
assert entry['y'] == 166
assert type(entry['y']) is float
used = result[0]['data']
eq_(len(used), 11)
for entry in used:
assert entry['x'] >= 10
assert entry['x'] <= 20
assert entry['y'] == 66.55
assert type(entry['y']) is float
keys = [
system_model.metric_tuple('total_mb', 'Total memory'),
system_model.metric_tuple('used_mb', 'Used memory'),
]
result = collection.find({
'server_id': self.server_id,
"time": {
"$gte": int(10),
"$lte": int(20)
}
}).sort('time', system_model.asc)
charts = system_model.generate_charts(check='memory',
keys=keys,
result=result)
eq_(len(charts), 2)
data = charts[0]['data']
eq_(len(data), 11)
for entry in data:
assert entry['x'] >= 10
assert entry['x'] <= 20
all_servers = server_model.get_all()
# Test global data for memory - used in the dashboards
result = system_model.get_global_data_after(
timestamp=10,
enddate=20,
filtered_servers=all_servers,
check='memory')
used_percent = result[0]['data']
eq_(len(used_percent), 11)
assert result[0]['name'] == self.server['name']
for entry in used_percent:
assert entry['x'] >= 10
assert entry['x'] <= 20
assert entry['y'] == 15.0
assert type(entry['y']) is float
self._cleanup()
def sort_by(self, field=None):
all_servers = server_model.get_all()
metric_type, metric_block = field.split(":")
name, value = metric_block.split('.')
all_data = []
calculate_max_list = []
unit_dict = {
'cpu': "%",
'memory': 'MB',
'used_percent': "%",
'network': 'kb/s',
'swap_used_percent': "%",
}
if not all_servers:
return
for s in all_servers:
v = 0
last_check = s.get('last_check', 0)
if metric_type == 'disk' or metric_type == 'network':
if metric_type == 'disk':
device_data = volumes_model.get_check_for_timestamp(s, last_check)
else:
device_data = interfaces_model.get_check_for_timestamp(s, last_check)
v = self._get_device_stats(value=value, data=device_data)
elif metric_type == 'process':
process = process_model.get_by_name_and_server_id(server_id=s['_id'], name=name)
value_in_dict = 'c' if value == 'cpu' else 'm'
if process:
process_data = process_model.get_check_for_timestamp(server=s, timestamp=process.get('last_check'))
if process_data:
for p in process_data.get('data', []):
if p.get('p') == process.get('_id'):
v = p.get(value_in_dict, 0)
else:
system_data = system_model.get_check_for_timestamp(s, last_check)
metric_dict = system_data.get(name, {})
v = metric_dict.get(value, 0)
unit = unit_dict.get(name, "")
# Overwrite, if you find an alternative unit
alterative_unit = unit_dict.get(value, False)
if alterative_unit:
unit = alterative_unit
server_data = {
'server': s,
'last_check': last_check,
'unit': unit,
'value': v,
'field': field
}
calculate_max_list.append(v)
all_data.append(server_data)
all_data = sorted(all_data, key=lambda k: k['value'], reverse=True)
result = {
'sorted_data': all_data,
'max_value': max(calculate_max_list)
}
return result
def all(request):
api_key = api_key_model.get_or_create()
all_servers = server_model.get_all(account_id=request.account_id)
servers_data = []
form = ServerForm()
tags = request.GET.get('tags', "")
bookmark_id = request.GET.get('bookmark_id')
# now = unix_utc_now()
if all_servers:
for server in all_servers:
append_server = filter_tags(server=server, tags=tags)
active_server = False
key = server.get('key')
last_check = server.get('last_check', 0)
# seconds_since_check = now - last_check
server_dict = {
'server': server,
'key': key,
'last_check': last_check
}
# Don't get data for non active servers, 48 hours as default
# Disable this check for now
# if seconds_since_check < 172800:
server_dict_data = {
'system':
system_model.get_check_for_timestamp(server, last_check),
'volume_data':
volumes_model.get_check_for_timestamp(server, last_check),
'plugins':
plugin_model.get_check_for_timestamp(server, last_check),
'processes':
process_model.get_check_for_timestamp(server, last_check),
}
server_dict.update(server_dict_data)
active_server = True
if append_server and active_server is not False:
servers_data.append(server_dict)
servers_data = sorted(servers_data,
key=lambda k: k['last_check'],
reverse=True)
else:
all_servers = False
bookmark_form = BookMarkForm(initial={'tags': tags})
return render(
request, 'servers/view.html', {
"all_servers": all_servers,
"servers_data": servers_data,
"form": form,
"tags": tags,
"bookmark_form": bookmark_form,
"bookmark_id": bookmark_id,
"api_key": api_key
})
def get_network_data_test(self):
self._cleanup()
interface = interfaces_model.get_or_create(
server_id=self.server['_id'], name='test_interface')
collection = interfaces_model.get_data_collection()
for i in range(0, 30):
collection.insert({
'server_id': self.server_id,
'device_id': interface['_id'],
't': i,
'i': 1,
'o': 2
})
result = system_model.get_device_data_after(timestamp=10,
enddate=20,
server=self.server,
check='network',
device_id=interface['_id'])
inbound = result[0]['data']
eq_(len(inbound), 11)
for entry in inbound:
assert entry['x'] >= 10
assert entry['x'] <= 20
assert entry['y'] == 1
assert type(entry['y']) is float
outbound = result[1]['data']
eq_(len(outbound), 11)
for entry in outbound:
assert entry['x'] >= 10
assert entry['x'] <= 20
assert entry['y'] == 2
# Test global data - used in the dashboards
all_servers = server_model.get_all()
result = system_model.get_global_device_data_after(
timestamp=10,
enddate=20,
filtered_servers=all_servers,
check='network',
key='i')
used_percent = result[0]['data']
eq_(len(used_percent), 11)
assert result[0]['name'] == "{0}.test_interface".format(
self.server['name'])
for entry in used_percent:
assert entry['x'] >= 10
assert entry['x'] <= 20
assert entry['y'] == 1.0
assert type(entry['y']) is float
self._cleanup()
def get_loadavg_data_test(self):
self._cleanup()
collection = system_model.data_collection
for i in range(0, 30):
data_dict = {
"time": i,
"server_id": self.server_id,
"loadavg": {
"cores": 4,
"fifteen_minutes": "0.18",
"minute": "0.34",
"five_minutes": "0.27"
}
}
collection.insert(data_dict)
result = system_model.get_data_after(timestamp=10,
enddate=20,
server=self.server,
check='loadavg')
t = ['minute', 'five_minutes', 'fifteen_minutes']
for i in range(0, 3):
result_dict = result[i]['data']
key = t[i]
eq_(len(result_dict), 11)
for entry in result_dict:
assert entry['x'] >= 10
assert entry['x'] <= 20
assert entry['y'] == float(data_dict['loadavg'][key])
assert type(entry['y']) is float
keys = [
system_model.metric_tuple('minute', '1 minute'),
system_model.metric_tuple('five_minutes', '5 minutes'),
system_model.metric_tuple('fifteen_minutes', '15 minutes'),
]
result = collection.find({
'server_id': self.server_id,
"time": {
"$gte": int(10),
"$lte": int(20)
}
}).sort('time', system_model.asc)
charts = system_model.generate_charts(check='loadavg',
keys=keys,
result=result)
eq_(len(charts), 3)
data = charts[0]['data']
eq_(len(data), 11)
for entry in data:
assert entry['x'] >= 10
assert entry['x'] <= 20
# Test global data - used in the dashboards
all_servers = server_model.get_all()
result = system_model.get_global_data_after(
timestamp=10,
enddate=20,
filtered_servers=all_servers,
check='loadavg',
key='minute')
used_percent = result[0]['data']
eq_(len(used_percent), 11)
assert result[0]['name'] == self.server['name']
for entry in used_percent:
assert entry['x'] >= 10
assert entry['x'] <= 20
assert entry['y'] == 0.34
assert type(entry['y']) is float
self._cleanup()
def get_disk_data_test(self):
self._cleanup()
volume = volumes_model.get_or_create(server_id=self.server['_id'],
name='test_volume')
collection = volumes_model.get_data_collection()
for i in range(0, 30):
collection.insert({
'server_id': self.server_id,
'device_id': volume['_id'],
't': i,
'total': 12,
'used': 2,
'percent': 60.0
})
result = system_model.get_device_data_after(timestamp=10,
enddate=20,
server=self.server,
check='disk',
device_id=volume['_id'])
total = result[1]['data']
eq_(len(total), 11)
for entry in total:
assert entry['x'] >= 10
assert entry['x'] <= 20
assert entry['y'] == 12
assert type(entry['y']) is float
used = result[0]['data']
eq_(len(used), 11)
for entry in used:
assert entry['x'] >= 10
assert entry['x'] <= 20
assert entry['y'] == 2
# Test global data - used in the dashboards
all_servers = server_model.get_all()
result = system_model.get_global_device_data_after(
timestamp=10,
enddate=20,
filtered_servers=all_servers,
check='disk',
key='percent')
used_percent = result[0]['data']
eq_(len(used_percent), 11)
assert result[0]['name'] == "{0}.test_volume".format(
self.server['name'])
for entry in used_percent:
assert entry['x'] >= 10
assert entry['x'] <= 20
assert entry['y'] == 60.0
assert type(entry['y']) is float
self._cleanup()
def sort_and_filter(self, sort_by=None, filter_by=None):
flat_list = []
sorted_result = []
all_checks = []
all_servers = server_model.get_all()
for check in self.get_all():
last_check = check.get('last_check')
try:
server = server_model.get_by_id(check['server_id'])
except:
server = None
check['server'] = server
# Append result only for existing servers
if server != None:
flat_list.append(check)
if sort_by is None and filter_by is None:
if server != None:
all_checks.append(check)
sort_priority = {'critical': 1, 'warning': 2, 'ok': 3, 'unknown': 4}
count_statuses = {'critical': 0, 'warning': 0, 'ok': 0, 'unknown': 0}
for r in flat_list:
result = r.get("last_check", {})
if result:
check_status = result.get('status')
try:
count_statuses[
check_status] = count_statuses[check_status] + 1
except:
pass
if filter_by:
reodered_list = []
for el in flat_list:
check_status = el.get('last_check', {}).get('status')
if check_status == filter_by:
reodered_list.append(el)
sorted_result = sorted(
reodered_list,
key=lambda d: d.get('last_check', {}).get('status'))
if sort_by:
# ?sort_by=host&filter_by=critical
if filter_by:
flat_list = sorted_result
if sort_by == 'status':
reodered_list = []
for el in flat_list:
try:
el['priority'] = sort_priority.get(
el.get('last_check', {}).get('status'))
except:
pass
reodered_list.append(el)
sorted_result = sorted(reodered_list,
key=itemgetter('priority'))
elif sort_by == 'host':
sorted_result = sorted(
flat_list, key=lambda d: d.get('server', {}).get('name'))
result = AmonStruct()
result.all_checks = all_checks
result.sorted_result = sorted_result
result.count_statuses = count_statuses
result.flat_list = flat_list
return result
def get_cpu_data_test(self):
self._cleanup()
collection = system_model.data_collection
for i in range(0, 30):
cpu_dict = {
"time": i,
"server_id": self.server_id,
"cpu": {
"iowait": "0.00",
"system": "7.51",
"idle": "91.15",
"user": "******",
"steal": "0.00",
"nice": "0.00"
}
}
collection.insert(cpu_dict)
result = system_model.get_data_after(timestamp=10,
enddate=20,
server=self.server,
check='cpu')
t = ['idle', 'system', 'user', 'iowait', 'steal']
for i in range(0, 5):
data_dict = result[i]['data']
key = t[i]
eq_(len(data_dict), 11)
for entry in data_dict:
assert entry['x'] >= 10
assert entry['x'] <= 20
assert entry['y'] == float(cpu_dict['cpu'][key])
assert type(entry['y']) is float
keys = [
system_model.metric_tuple('idle', 'Idle'),
system_model.metric_tuple('system', 'System'),
system_model.metric_tuple('user', 'User'),
system_model.metric_tuple('iowait', 'IOWait'),
system_model.metric_tuple('steal', 'Steal'),
]
result = collection.find({
'server_id': self.server_id,
"time": {
"$gte": int(10),
"$lte": int(20)
}
}).sort('time', system_model.asc)
charts = system_model.generate_charts(check='cpu',
keys=keys,
result=result)
eq_(len(charts), 5)
data = charts[0]['data']
eq_(len(data), 11)
for entry in data:
assert entry['x'] >= 10
assert entry['x'] <= 20
# Test global data - used in the dashboards
all_servers = server_model.get_all()
result = system_model.get_global_data_after(
timestamp=10,
enddate=20,
filtered_servers=all_servers,
check='cpu',
key='system')
used_percent = result[0]['data']
eq_(len(used_percent), 11)
assert result[0]['name'] == self.server['name']
for entry in used_percent:
assert entry['x'] >= 10
assert entry['x'] <= 20
assert entry['y'] == 7.51
assert type(entry['y']) is float
self._cleanup()
def sort_and_filter(self, sort_by=None, filter_by=None):
flat_list = []
sorted_result = []
all_checks = []
all_servers = server_model.get_all()
for check in self.get_all():
last_check = check.get('last_check')
try:
server = server_model.get_by_id(check['server_id'])
except:
server = None
check['server'] = server
# Append result only for existing servers
if server != None:
flat_list.append(check)
if sort_by is None and filter_by is None:
if server != None:
all_checks.append(check)
sort_priority = {'critical': 1, 'warning': 2, 'ok': 3, 'unknown': 4}
count_statuses = {'critical': 0, 'warning': 0, 'ok': 0, 'unknown': 0}
for r in flat_list:
result = r.get("last_check", {})
if result:
check_status = result.get('status')
try:
count_statuses[check_status] = count_statuses[check_status] + 1
except:
pass
if filter_by:
reodered_list = []
for el in flat_list:
check_status = el.get('last_check', {}).get('status')
if check_status == filter_by:
reodered_list.append(el)
sorted_result = sorted(reodered_list, key=lambda d: d.get('last_check', {}).get('status'))
if sort_by:
# ?sort_by=host&filter_by=critical
if filter_by:
flat_list = sorted_result
if sort_by == 'status':
reodered_list = []
for el in flat_list:
try:
el['priority'] = sort_priority.get(el.get('last_check', {}).get('status'))
except:
pass
reodered_list.append(el)
sorted_result = sorted(reodered_list, key=itemgetter('priority'))
elif sort_by == 'host':
sorted_result = sorted(flat_list, key=lambda d: d.get('server', {}).get('name'))
result = AmonStruct()
result.all_checks = all_checks
result.sorted_result = sorted_result
result.count_statuses = count_statuses
result.flat_list = flat_list
return result
def sort_by(self, field=None):
all_servers = server_model.get_all()
metric_type, metric_block = field.split(":")
name, value = metric_block.split('.')
all_data = []
calculate_max_list = []
unit_dict = {
'cpu': "%",
'memory': 'MB',
'used_percent': "%",
'network': 'kb/s',
'swap_used_percent': "%",
}
if not all_servers:
return
for s in all_servers:
v = 0
last_check = s.get('last_check', 0)
if metric_type == 'disk' or metric_type == 'network':
if metric_type == 'disk':
device_data = volumes_model.get_check_for_timestamp(
s, last_check)
else:
device_data = interfaces_model.get_check_for_timestamp(
s, last_check)
v = self._get_device_stats(value=value, data=device_data)
elif metric_type == 'process':
process = process_model.get_by_name_and_server_id(
server_id=s['_id'], name=name)
value_in_dict = 'c' if value == 'cpu' else 'm'
if process:
process_data = process_model.get_check_for_timestamp(
server=s, timestamp=process.get('last_check'))
if process_data:
for p in process_data.get('data', []):
if p.get('p') == process.get('_id'):
v = p.get(value_in_dict, 0)
else:
system_data = system_model.get_check_for_timestamp(
s, last_check)
metric_dict = system_data.get(name, {})
v = metric_dict.get(value, 0)
unit = unit_dict.get(name, "")
# Overwrite, if you find an alternative unit
alterative_unit = unit_dict.get(value, False)
if alterative_unit:
unit = alterative_unit
server_data = {
'server': s,
'last_check': last_check,
'unit': unit,
'value': v,
'field': field
}
calculate_max_list.append(v)
all_data.append(server_data)
all_data = sorted(all_data, key=lambda k: k['value'], reverse=True)
result = {
'sorted_data': all_data,
'max_value': max(calculate_max_list)
}
return result
