Merge branch 'master' into issue-298

Conflicts:
	circle/dashboard/urls.py
	circle/dashboard/views/node.py
	circle/vm/models/node.py

circle/dashboard/static/dashboard/dashboard.css

@@ -973,3 +973,25 @@ textarea[name="new_members"] {
 .hilight .autocomplete-hl {
   color: orange;
 }
+
+.node-list-table tbody>tr>td, .node-list-table thead>tr>th {
+  vertical-align: middle;
+}
+
+.node-list-table thead>tr>th,
+.node-list-table .enabled, .node-list-table .priority,
+.node-list-table .overcommit, .node-list-table .number_of_VMs {
+  text-align: center;
+}
+
+.node-list-table-thin {
+  width: 10px;
+}
+
+.node-list-table-monitor {
+  width: 250px;
+}
+
+.graph-images img {
+  max-width: 100%;
+}

circle/dashboard/static/dashboard/dashboard.js

@@ -397,6 +397,20 @@ $(function () {
     clientInstalledAction(connectUri);
     return false;
   });
+
+  /* change graphs */
+  $(".graph-buttons a").click(function() {
+    var time = $(this).data("graph-time");
+    $(".graph-images img").each(function() {
+      var src = $(this).prop("src");
+      var new_src = src.substring(0, src.lastIndexOf("/") + 1) + time;
+      $(this).prop("src", new_src);
+    });
+    // change the buttons too
+    $(".graph-buttons a").removeClass("btn-primary").addClass("btn-default");
+    $(this).removeClass("btn-default").addClass("btn-primary");
+    return false;
+  });
 });
 
 function generateVmHTML(pk, name, host, icon, _status, fav, is_last) {

circle/dashboard/templates/dashboard/_graph-time-buttons.html

+{% for o in graph_time_options %}
+  <a class="btn btn-xs
+    btn-{% if graph_time == o.time %}primary{% else %}default{% endif %}"
+    href="?graph_time={{ o.time }}"
+    data-graph-time="{{ o.time }}">
+    {{ o.name }}
+  </a>
+{% endfor %}

circle/dashboard/templates/dashboard/node-detail/home.html

@@ -30,15 +30,22 @@
   </div>
   <div class="col-md-8">
     {% if graphite_enabled %}
-    <img src="{% url "dashboard.views.node-graph" node.pk "cpu" "6h" %}" style="width:100%"/>
-    <img src="{% url "dashboard.views.node-graph" node.pk "memory" "6h" %}" style="width:100%"/>
-    <img src="{% url "dashboard.views.node-graph" node.pk "network" "6h" %}" style="width:100%"/>
+    <div class="text-center graph-buttons">
+      {% include "dashboard/_graph-time-buttons.html" %}
+    </div>
+    <div class="graph-images text-center">
+      <img src="{% url "dashboard.views.node-graph" node.pk "cpu" graph_time %}"/>
+      <img src="{% url "dashboard.views.node-graph" node.pk "memory" graph_time %}"/>
+      <img src="{% url "dashboard.views.node-graph" node.pk "network" graph_time %}"/>
+      <img src="{% url "dashboard.views.node-graph" node.pk "vm" graph_time %}"/>
+      <img src="{% url "dashboard.views.node-graph" node.pk "alloc" graph_time %}"/>
+    </div>
     {% endif %}
   </div>
-  </div>
-  <style>
-  .form-group {
-    margin: 0px;
-  }
+</div>
 
-</style>
+  <style>
+    .form-group {
+      margin: 0px;
+    }
+  </style>

circle/dashboard/templates/dashboard/node-list.html

@@ -21,25 +21,23 @@
   </div>
 </div>
 
-<style>
-  .node-list-table tbody>tr>td, .node-list-table thead>tr>th {
-    vertical-align: middle;
-  }
-
-  .node-list-table thead>tr>th, 
-  .node-list-table .enabled, .node-list-table .priority, 
-  .node-list-table .overcommit, .node-list-table .number_of_VMs {
-    text-align: center;
-  }
-
-  .node-list-table-thin {
-    width: 10px;
-  }
+<div class="row">
+  <div class="col-md-12">
+    <div class="panel panel-default">
+      <div class="panel-heading">
+        <div class="pull-right graph-buttons">
+          {% include "dashboard/_graph-time-buttons.html" %}
+        </div>
+        <h3 class="no-margin"><i class="fa fa-area-chart"></i> {% trans "Graphs" %}</h3>
+      </div>
+      <div class="text-center graph-images">
+        <img src="{% url "dashboard.views.node-list-graph" "alloc" graph_time %}"/>
+        <img src="{% url "dashboard.views.node-list-graph" "vm" graph_time %}"/>
+      </div>
+    </div>
+  </div><!-- -col-md-12 -->
+</div><!-- .row -->
 
-  .node-list-table-monitor {
-    width: 250px;
-  }
-</style>
 {% endblock %}
 
 {% block extra_js %}

circle/dashboard/templates/dashboard/vm-detail/home.html

@@ -123,9 +123,14 @@
   </div>
   <div class="col-md-8">
     {% if graphite_enabled %}
-    <img src="{% url "dashboard.views.vm-graph" instance.pk "cpu" "6h" %}" style="width:100%"/>
-    <img src="{% url "dashboard.views.vm-graph" instance.pk "memory" "6h" %}" style="width:100%"/>
-    <img src="{% url "dashboard.views.vm-graph" instance.pk "network" "6h" %}" style="width:100%"/>
+    <div class="text-center graph-buttons">
+      {% include "dashboard/_graph-time-buttons.html" %}
+    </div>
+    <div class="graph-images text-center">
+      <img src="{% url "dashboard.views.vm-graph" instance.pk "cpu" graph_time %}"/>
+      <img src="{% url "dashboard.views.vm-graph" instance.pk "memory" graph_time %}"/>
+      <img src="{% url "dashboard.views.vm-graph" instance.pk "network" graph_time %}"/>
+    </div>
     {% endif %}
   </div>
 </div>

circle/dashboard/urls.py

@@ -25,11 +25,11 @@ from .views import (
     GroupDetailView, GroupList, IndexView,
     InstanceActivityDetail, LeaseCreate, LeaseDelete, LeaseDetail,
     MyPreferencesView, NodeAddTraitView, NodeCreate, NodeDelete,
-    NodeDetailView, NodeGraphView, NodeList, NodeStatus,
+    NodeDetailView, NodeList, NodeStatus,
     NotificationView, PortDelete, TemplateAclUpdateView, TemplateCreate,
     TemplateDelete, TemplateDetail, TemplateList, TransferOwnershipConfirmView,
     TransferOwnershipView, vm_activity, VmCreate, VmDetailView,
-    VmDetailVncTokenView, VmGraphView, VmList,
+    VmDetailVncTokenView, VmList,
     DiskRemoveView, get_disk_download_status, InterfaceDeleteView,
     GroupRemoveUserView,
     GroupRemoveFutureUserView,
@@ -46,6 +46,7 @@ from .views import (
     GroupPermissionsView,
     LeaseAclUpdateView,
     ClientCheck, TokenLogin,
+    VmGraphView, NodeGraphView, NodeListGraphView,
 )
 from .views.vm import vm_ops, vm_mass_ops
 from .views.node import node_ops
@@ -119,14 +120,18 @@ urlpatterns = patterns(
         name="dashboard.views.delete-group"),
     url(r'^group/list/$', GroupList.as_view(),
         name='dashboard.views.group-list'),
-    url((r'^vm/(?P<pk>\d+)/graph/(?P<metric>cpu|memory|network)/'
+    url((r'^vm/(?P<pk>\d+)/graph/(?P<metric>[a-z]+)/'
          r'(?P<time>[0-9]{1,2}[hdwy])$'),
         VmGraphView.as_view(),
         name='dashboard.views.vm-graph'),
-    url((r'^node/(?P<pk>\d+)/graph/(?P<metric>cpu|memory|network)/'
+    url((r'^node/(?P<pk>\d+)/graph/(?P<metric>[a-z]+)/'
          r'(?P<time>[0-9]{1,2}[hdwy])$'),
         NodeGraphView.as_view(),
         name='dashboard.views.node-graph'),
+    url((r'^node/graph/(?P<metric>[a-z]+)/'
+         r'(?P<time>[0-9]{1,2}[hdwy])$'),
+        NodeListGraphView.as_view(),
+        name='dashboard.views.node-list-graph'),
     url(r'^group/(?P<pk>\d+)/$', GroupDetailView.as_view(),
         name='dashboard.views.group-detail'),
     url(r'^group/(?P<pk>\d+)/update/$', GroupProfileUpdate.as_view(),

circle/dashboard/views/__init__.py

@@ -11,3 +11,4 @@ from template import *
 from user import *
 from util import *
 from vm import *
+from graph import *

circle/dashboard/views/graph.py

+# Copyright 2014 Budapest University of Technology and Economics (BME IK)
+#
+# This file is part of CIRCLE Cloud.
+#
+# CIRCLE is free software: you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option)
+# any later version.
+#
+# CIRCLE is distributed in the hope that it will be useful, but WITHOUT ANY
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along
+# with CIRCLE.  If not, see <http://www.gnu.org/licenses/>.
+
+from __future__ import absolute_import, unicode_literals
+
+import logging
+import requests
+
+from django.conf import settings
+from django.core.exceptions import PermissionDenied
+from django.http import HttpResponse, Http404
+from django.utils.translation import ugettext_lazy as _
+from django.views.generic import View
+
+from braces.views import LoginRequiredMixin, SuperuserRequiredMixin
+
+from vm.models import Instance, Node
+
+
+logger = logging.getLogger(__name__)
+
+
+def register_graph(metric_cls, graph_name, graphview_cls):
+    if not hasattr(graphview_cls, 'metrics'):
+        graphview_cls.metrics = {}
+    graphview_cls.metrics[graph_name] = metric_cls
+
+
+class GraphViewBase(LoginRequiredMixin, View):
+    def create_class(self, cls):
+        return type(str(cls.__name__ + 'Metric'), (cls, self.base), {})
+
+    def get(self, request, pk, metric, time, *args, **kwargs):
+        graphite_url = settings.GRAPHITE_URL
+        if graphite_url is None:
+            raise Http404()
+
+        try:
+            metric = self.metrics[metric]
+        except KeyError:
+            raise Http404()
+
+        try:
+            instance = self.get_object(request, pk)
+        except self.model.DoesNotExist:
+            raise Http404()
+
+        metric = self.create_class(metric)(instance)
+
+        return HttpResponse(metric.get_graph(graphite_url, time),
+                            mimetype="image/png")
+
+    def get_object(self, request, pk):
+        instance = self.model.objects.get(id=pk)
+        if not instance.has_level(request.user, 'user'):
+            raise PermissionDenied()
+        return instance
+
+
+class Metric(object):
+    cacti_style = True
+    derivative = False
+    scale_to_seconds = None
+    metric_name = None
+    title = None
+    label = None
+
+    def __init__(self, obj, metric_name=None):
+        self.obj = obj
+        self.metric_name = (
+            metric_name or self.metric_name or self.__class__.__name__.lower())
+
+    def get_metric_name(self):
+        return self.metric_name
+
+    def get_label(self):
+        return self.label or self.get_metric_name()
+
+    def get_title(self):
+        return self.title or self.get_metric_name()
+
+    def get_minmax(self):
+        return (None, None)
+
+    def get_target(self):
+        target = '%s.%s' % (self.obj.metric_prefix, self.get_metric_name())
+        if self.derivative:
+            target = 'nonNegativeDerivative(%s)' % target
+        if self.scale_to_seconds:
+            target = 'scaleToSeconds(%s, %d)' % (target, self.scale_to_seconds)
+        target = 'alias(%s, "%s")' % (target, self.get_label())
+        if self.cacti_style:
+            target = 'cactiStyle(%s)' % target
+        return target
+
+    def get_graph(self, graphite_url, time, width=500, height=200):
+        params = {'target': self.get_target(),
+                  'from': '-%s' % time,
+                  'title': self.get_title().encode('UTF-8'),
+                  'width': width,
+                  'height': height}
+
+        ymin, ymax = self.get_minmax()
+        if ymin is not None:
+            params['yMin'] = ymin
+        if ymax is not None:
+            params['yMax'] = ymax
+
+        logger.debug('%s %s', graphite_url, params)
+        response = requests.get('%s/render/' % graphite_url, params=params)
+        return response.content
+
+
+class VmMetric(Metric):
+    def get_title(self):
+        title = super(VmMetric, self).get_title()
+        return '%s (%s) - %s' % (self.obj.name, self.obj.vm_name, title)
+
+
+class NodeMetric(Metric):
+    def get_title(self):
+        title = super(NodeMetric, self).get_title()
+        return '%s (%s) - %s' % (self.obj.name, self.obj.host.hostname, title)
+
+
+class VmGraphView(GraphViewBase):
+    model = Instance
+    base = VmMetric
+
+
+class NodeGraphView(SuperuserRequiredMixin, GraphViewBase):
+    model = Node
+    base = NodeMetric
+
+    def get_object(self, request, pk):
+        return self.model.objects.get(id=pk)
+
+
+class NodeListGraphView(SuperuserRequiredMixin, GraphViewBase):
+    model = Node
+    base = Metric
+
+    def get_object(self, request, pk):
+        return Node.objects.filter(enabled=True)
+
+    def get(self, request, metric, time, *args, **kwargs):
+        return super(NodeListGraphView, self).get(request, None, metric, time)
+
+
+class Ram(object):
+    metric_name = "memory.usage"
+    title = _("RAM usage (%)")
+    label = _("RAM usage (%)")
+
+    def get_minmax(self):
+        return (0, 105)
+
+register_graph(Ram, 'memory', VmGraphView)
+register_graph(Ram, 'memory', NodeGraphView)
+
+
+class Cpu(object):
+    metric_name = "cpu.percent"
+    title = _("CPU usage (%)")
+    label = _("CPU usage (%)")
+
+    def get_minmax(self):
+        if isinstance(self.obj, Node):
+            return (0, 105)
+        else:
+            return (0, self.obj.num_cores * 100 + 5)
+
+register_graph(Cpu, 'cpu', VmGraphView)
+register_graph(Cpu, 'cpu', NodeGraphView)
+
+
+class VmNetwork(object):
+    title = _("Network")
+
+    def get_minmax(self):
+        return (0, None)
+
+    def get_target(self):
+        metrics = []
+        for n in self.obj.interface_set.all():
+            params = (self.obj.metric_prefix, n.vlan.vid, n.vlan.name)
+            metrics.append(
+                'alias(scaleToSeconds(nonNegativeDerivative('
+                '%s.network.bytes_recv-%s), 10), "out - %s (bits/s)")' % (
+                    params))
+            metrics.append(
+                'alias(scaleToSeconds(nonNegativeDerivative('
+                '%s.network.bytes_sent-%s), 10), "in - %s (bits/s)")' % (
+                    params))
+        return 'group(%s)' % ','.join(metrics)
+
+register_graph(VmNetwork, 'network', VmGraphView)
+
+
+class NodeNetwork(object):
+    title = _("Network")
+
+    def get_minmax(self):
+        return (0, None)
+
+    def get_target(self):
+        return (
+            'aliasSub(scaleToSeconds(nonNegativeDerivative(%s.network.b*),'
+            '10), ".*\.bytes_(sent|recv)-([a-zA-Z0-9]+).*", "\\2 \\1")' % (
+                self.obj.metric_prefix))
+
+register_graph(NodeNetwork, 'network', NodeGraphView)
+
+
+class NodeVms(object):
+    metric_name = "vmcount"
+    title = _("Instance count")
+    label = _("instance count")
+
+    def get_minmax(self):
+        return (0, None)
+
+register_graph(NodeVms, 'vm', NodeGraphView)
+
+
+class NodeAllocated(object):
+    title = _("Allocated memory (bytes)")
+
+    def get_target(self):
+        prefix = self.obj.metric_prefix
+        if self.obj.online and self.obj.enabled:
+            ram_size = self.obj.ram_size
+        else:
+            ram_size = 0
+        used = 'alias(%s.memory.used_bytes, "used")' % prefix
+        allocated = 'alias(%s.memory.allocated, "allocated")' % prefix
+        max = 'threshold(%d, "max")' % ram_size
+        return 'cactiStyle(group(%s, %s, %s))' % (used, allocated, max)
+
+    def get_minmax(self):
+        return (0, None)
+
+register_graph(NodeAllocated, 'alloc', NodeGraphView)
+
+
+class NodeListAllocated(object):
+    title = _("Allocated memory (bytes)")
+
+    def get_target(self):
+        nodes = self.obj
+        used = ','.join('%s.memory.used_bytes' % n.metric_prefix
+                        for n in nodes)
+        allocated = 'alias(sumSeries(%s), "allocated")' % ','.join(
+            '%s.memory.allocated' % n.metric_prefix for n in nodes)
+        max = 'threshold(%d, "max")' % sum(
+            n.ram_size for n in nodes if n.online)
+        return ('group(aliasSub(aliasByNode(stacked(group(%s)), 1), "$",'
+                '"  (used)"), %s, %s)' % (used, allocated, max))
+
+    def get_minmax(self):
+        return (0, None)
+
+register_graph(NodeListAllocated, 'alloc', NodeListGraphView)
+
+
+class NodeListVms(object):
+    title = _("Instance count")
+
+    def get_target(self):
+        vmcount = ','.join('%s.vmcount' % n.metric_prefix for n in self.obj)
+        return 'group(aliasByNode(stacked(group(%s)), 1))' % vmcount
+
+    def get_minmax(self):
+        return (0, None)
+
+register_graph(NodeListVms, 'vm', NodeListGraphView)

circle/dashboard/views/node.py

@@ -38,7 +38,7 @@ from vm.models import Node, NodeActivity, Trait
 
 from ..forms import TraitForm, HostForm, NodeForm
 from ..tables import NodeListTable
-from .util import GraphViewBase, AjaxOperationMixin, OperationView
+from .util import GraphViewBase, AjaxOperationMixin, OperationView, GraphMixin
 
 
 def get_operations(instance, user):
@@ -73,7 +73,8 @@ node_ops = OrderedDict([
 ])
 
 
-class NodeDetailView(LoginRequiredMixin, SuperuserRequiredMixin, DetailView):
+class NodeDetailView(LoginRequiredMixin, SuperuserRequiredMixin,
+                     GraphMixin, DetailView):
     template_name = "dashboard/node-detail.html"
     model = Node
     form = None
@@ -142,7 +143,8 @@ class NodeDetailView(LoginRequiredMixin, SuperuserRequiredMixin, DetailView):
             return redirect(self.object.get_absolute_url())
 
 
-class NodeList(LoginRequiredMixin, SuperuserRequiredMixin, SingleTableView):
+class NodeList(LoginRequiredMixin, SuperuserRequiredMixin,
+               GraphMixin, SingleTableView):
     template_name = "dashboard/node-list.html"
     table_class = NodeListTable
     table_pagination = False

circle/dashboard/views/util.py

@@ -22,18 +22,16 @@ import re
 from collections import OrderedDict
 from urlparse import urljoin
 
-import requests
-
 from django.conf import settings
 from django.contrib.auth.models import User, Group
-from django.core.exceptions import PermissionDenied, SuspiciousOperation
+from django.core.exceptions import PermissionDenied
 from django.core.urlresolvers import reverse
 from django.contrib import messages
 from django.contrib.auth.views import redirect_to_login
 from django.db.models import Q
-from django.http import HttpResponse, Http404, HttpResponseRedirect
+from django.http import HttpResponse, HttpResponseRedirect
 from django.shortcuts import redirect
-from django.utils.translation import ugettext as _
+from django.utils.translation import ugettext_lazy as _
 from django.views.generic import DetailView, View
 from django.views.generic.detail import SingleObjectMixin
 
@@ -537,43 +535,29 @@ class AclUpdateView(LoginRequiredMixin, View, SingleObjectMixin):
         return redirect("%s#access" % self.instance.get_absolute_url())
 
 
-class GraphViewBase(LoginRequiredMixin, View):
-    def get(self, request, pk, metric, time, *args, **kwargs):
-        graphite_url = settings.GRAPHITE_URL
-        if graphite_url is None:
-            raise Http404()
-
-        if metric not in self.metrics.keys():
-            raise SuspiciousOperation()
-
-        try:
-            instance = self.get_object(request, pk)
-        except self.model.DoesNotExist:
-            raise Http404()
-
-        prefix = self.get_prefix(instance)
-        target = self.metrics[metric] % {'prefix': prefix}
-        title = self.get_title(instance, metric)
-        params = {'target': target,
-                  'from': '-%s' % time,
-                  'title': title.encode('UTF-8'),
-                  'width': '500',
-                  'height': '200'}
-        logger.debug('%s %s', graphite_url, params)
-        response = requests.get('%s/render/' % graphite_url, params=params)
-        return HttpResponse(response.content, mimetype="image/png")
-
-    def get_prefix(self, instance):
-        raise NotImplementedError("Subclass must implement abstract method")
-
-    def get_title(self, instance, metric):
-        raise NotImplementedError("Subclass must implement abstract method")
-
-    def get_object(self, request, pk):
-        instance = self.model.objects.get(id=pk)
-        if not instance.has_level(request.user, 'user'):
-            raise PermissionDenied()
-        return instance
+class GraphMixin(object):
+    graph_time_options = [
+        {'time': "1h", 'name': _("1 hour")},
+        {'time': "6h", 'name': _("6 hours")},
+        {'time': "1d", 'name': _("1 day")},
+        {'time': "1w", 'name': _("1 week")},
+        {'time': "30d", 'name': _("1 month")},
+        {'time': "26w", 'name': _("6 months")},
+    ]
+    default_graph_time = "6h"
+
+    def get_context_data(self, *args, **kwargs):
+        context = super(GraphMixin, self).get_context_data(*args, **kwargs)
+        graph_time = self.request.GET.get("graph_time",
+                                          self.default_graph_time)
+        if not re.match("^[0-9]{1,2}[hdwy]$", graph_time):
+            messages.warning(self.request, _("Bad graph time format, "
+                                             "available periods are: "
+                                             "h, d, w, and y."))
+            graph_time = self.default_graph_time
+        context['graph_time'] = graph_time
+        context['graph_time_options'] = self.graph_time_options
+        return context
 
 
 def absolute_url(url):

circle/dashboard/views/vm.py

@@ -52,7 +52,7 @@ from vm.models import (
 )
 from .util import (
     CheckedDetailView, AjaxOperationMixin, OperationView, AclUpdateView,
-    FormOperationMixin, FilterMixin, GraphViewBase, search_user,
+    FormOperationMixin, FilterMixin, search_user, GraphMixin,
 )
 from ..forms import (
     AclUserOrGroupAddForm, VmResourcesForm, TraitsForm, RawDataForm,
@@ -89,7 +89,7 @@ class VmDetailVncTokenView(CheckedDetailView):
             raise Http404()
 
 
-class VmDetailView(CheckedDetailView):
+class VmDetailView(GraphMixin, CheckedDetailView):
     template_name = "dashboard/vm-detail.html"
     model = Instance
 
@@ -986,28 +986,6 @@ class VmCreate(LoginRequiredMixin, TemplateView):
         return create_func(request, *args, **kwargs)
 
 
-class VmGraphView(GraphViewBase):
-    metrics = {
-        'cpu': ('cactiStyle(alias(nonNegativeDerivative(%(prefix)s.cpu.usage),'
-                '"cpu usage (%%)"))'),
-        'memory': ('cactiStyle(alias(%(prefix)s.memory.usage,'
-                   '"memory usage (%%)"))'),
-        'network': (
-            'group('
-            'aliasSub(nonNegativeDerivative(%(prefix)s.network.bytes_recv*),'
-            ' ".*-(\d+)\\)", "out (vlan \\1)"),'
-            'aliasSub(nonNegativeDerivative(%(prefix)s.network.bytes_sent*),'
-            ' ".*-(\d+)\\)", "in (vlan \\1)"))'),
-    }
-    model = Instance
-
-    def get_prefix(self, instance):
-        return 'vm.%s' % instance.vm_name
-
-    def get_title(self, instance, metric):
-        return '%s (%s) - %s' % (instance.name, instance.vm_name, metric)
-
-
 @require_GET
 def get_vm_screenshot(request, pk):
     instance = get_object_or_404(Instance, pk=pk)

circle/fabfile.py

@@ -119,11 +119,13 @@ def stop_portal(test=False):
 @roles('node')
 def update_node():
     "Update and restart nodes"
-    with _stopped("node", "agentdriver"):
+    with _stopped("node", "agentdriver", "monitor-client"):
         pull("~/vmdriver")
         pip("vmdriver", "~/vmdriver/requirements/production.txt")
         pull("~/agentdriver")
         pip("agentdriver", "~/agentdriver/requirements.txt")
+        pull("~/monitor-client")
+        pip("monitor-client", "~/monitor-client/requirements.txt")
 
 
 @parallel

circle/manager/moncelery.py

@@ -61,6 +61,12 @@ celery.conf.update(
             'schedule': timedelta(seconds=30),
             'options': {'queue': 'localhost.monitor'}
         },
+        'monitor.allocated_memory': {
+            'task': 'monitor.tasks.local_periodic_tasks.'
+                    'allocated_memory',
+            'schedule': timedelta(seconds=30),
+            'options': {'queue': 'localhost.monitor'}
+        },
     }
 
 )

circle/manager/scheduler.py

@@ -17,7 +17,6 @@
 
 from logging import getLogger
 
-from django.db.models import Sum
 from django.utils.translation import ugettext_noop
 
 from common.models import HumanReadableException
@@ -95,8 +94,7 @@ def has_enough_ram(ram_size, node):
         unused = total - used
 
         overcommit = node.ram_size_with_overcommit
-        reserved = (node.instance_set.aggregate(
-            r=Sum('ram_size'))['r'] or 0) * 1024 * 1024
+        reserved = node.allocated_ram
         free = overcommit - reserved
 
         retval = ram_size < unused and ram_size < free

circle/monitor/tasks/local_periodic_tasks.py

@@ -107,3 +107,19 @@ def instance_per_template():
                                        time()))
 
     Client().send(metrics)
+
+
+@celery.task(ignore_result=True)
+def allocated_memory():
+    graphite_string = lambda hostname, val, time: (
+        "circle.%s.memory.allocated %d %s" % (
+            hostname, val, time)
+    )
+
+    metrics = []
+    for n in Node.objects.all():
+        print n.allocated_ram
+        metrics.append(graphite_string(
+            n.host.hostname, n.allocated_ram, time()))
+
+    Client().send(metrics)

circle/vm/models/instance.py

@@ -1003,3 +1003,7 @@ class Instance(AclBase, VirtualMachineDescModel, StatusModel, OperatedMixin,
         latest = self.get_latest_activity_in_progress()
         return (latest and latest.resultant_state is not None
                 and self.status != latest.resultant_state)
+
+    @property
+    def metric_prefix(self):
+        return 'vm.%s' % self.vm_name

circle/vm/models/node.py

@@ -24,7 +24,7 @@ import requests
 from django.conf import settings
 from django.db.models import (
     CharField, IntegerField, ForeignKey, BooleanField, ManyToManyField,
-    FloatField, permalink,
+    FloatField, permalink, Sum
 )
 from django.utils import timezone
 from django.utils.translation import ugettext_lazy as _
@@ -121,6 +121,11 @@ class Node(OperatedMixin, TimeStampedModel):
     info = property(get_info)
 
     @property
+    def allocated_ram(self):
+        return (self.instance_set.aggregate(
+            r=Sum('ram_size'))['r'] or 0) * 1024 * 1024
+
+    @property
     def ram_size(self):
         warn('Use Node.info["ram_size"]', DeprecationWarning)
         return self.info['ram_size']
@@ -247,7 +252,7 @@ class Node(OperatedMixin, TimeStampedModel):
     @node_available
     @method_cache(10)
     def monitor_info(self):
-        metrics = ('cpu.usage', 'memory.usage')
+        metrics = ('cpu.percent', 'memory.usage')
         prefix = 'circle.%s.' % self.host.hostname
         params = [('target', '%s%s' % (prefix, metric))
                   for metric in metrics]
@@ -283,7 +288,7 @@ class Node(OperatedMixin, TimeStampedModel):
     @property
     @node_available
     def cpu_usage(self):
-        return self.monitor_info.get('cpu.usage') / 100
+        return self.monitor_info.get('cpu.percent') / 100
 
     @property
     @node_available
@@ -372,3 +377,7 @@ class Node(OperatedMixin, TimeStampedModel):
         if not self.enabled:
             self.schedule_enabled = False
         super(Node, self).save(*args, **kwargs)
+
+    @property
+    def metric_prefix(self):
+        return 'circle.%s' % self.host.hostname