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 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 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 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