Synnefo

import itertools

import operator

import datetime

from collections import defaultdict  # , OrderedDict

from django.conf import settings

from django.db.models import Count

from synnefo.db.models import Backend

from snf_django.lib.astakos import UserCache

from synnefo.api.util import get_image

from synnefo.db.models import VirtualMachine, Network

from synnefo.logic import backend as backend_mod

        stats = get_cyclades_stats(backend, clusters, servers, resources,

                                   networks, images)

def get_cyclades_stats(backend=None, clusters=True, servers=True,

                       resources=True, networks=True, images=True):

    stats = {"datetime": datetime.datetime.now().strftime("%c")}

    if clusters:

        stats["clusters"] = get_cluster_stats(backend=backend)

    if servers:

        stats["servers"] = get_servers_stats(backend=backend)

    if resources:

        stats["resources"] = get_resources_stats(backend=backend)

    if networks:

        stats["networks"] = get_networks_stats()

    if images:

        stats["images"] = get_images_stats(backend=None)

    return stats

    datetime = stats.get("datetime")

    stdout.write("datetime: %s\n" % datetime)

def get_cluster_stats(backend):

    total = Backend.objects.all()

    stats = {"total": total.count(),

             "drained": total.filter(drained=True).count(),

             "offline": total.filter(offline=True).count()}

    return stats

def _get_total_servers(backend=None):

    total_servers = VirtualMachine.objects.all()

    if backend is not None:

        total_servers = total_servers.filter(backend=backend)

    return total_servers

def get_servers_stats(backend=None):

    total_servers = _get_total_servers(backend=backend)

    per_state = total_servers.values("operstate")\

                             .annotate(count=Count("operstate"))

    stats = {"total": 0}

    for x in per_state:

        stats[x["operstate"]] = x["count"]

        stats["total"] += x["count"]

    return stats

def get_resources_stats(backend=None):

    total_servers = _get_total_servers(backend=backend)

    active_servers = total_servers.filter(deleted=False)

    allocated = {}

    server_count = {}

    for res in ["cpu", "ram", "disk", "disk_template"]:

        server_count[res] = {}

        allocated[res] = 0

        val = "flavor__%s" % res

        results = active_servers.values(val).annotate(count=Count(val))

        for result in results:

            server_count[res][result[val]] = result["count"]

            if res != "disk_template":

                allocated[res] += result["count"]

    resources_stats = get_backend_stats(backend=backend)

    for res in ["cpu", "ram", "disk", "disk_template"]:

        if res not in resources_stats:

            resources_stats[res] = {}

        resources_stats[res]["servers"] = server_count[res]

        resources_stats[res]["allocated"] = allocated[res]

    return resources_stats

def get_images_stats(backend=None):

    total_servers = _get_total_servers(backend=backend)

    active_servers = total_servers.filter(deleted=False)

    active_servers_images = active_servers.values("imageid", "userid")\

                                          .annotate(number=Count("imageid"))

    image_cache = ImageCache()

    image_stats = defaultdict(int)

    for result in active_servers_images:

        imageid = image_cache.get_image(result["imageid"], result["userid"])

        image_stats[imageid] += result["number"]

    return dict(image_stats)

def get_networks_stats():

    total_networks = Network.objects.all()

    stats = {"public_ips": get_ip_stats(),

             "total": 0}

    per_state = total_networks.values("state")\

                              .annotate(count=Count("state"))

    for x in per_state:

        stats[x["state"]] = x["count"]

        stats["total"] += x["count"]

    return stats

def group_by_resource(objects, resource):

    stats = {}

    key = operator.attrgetter("flavor."+resource)

    grouped = itertools.groupby(sorted(objects, key=key), key)

    for val, group in grouped:

        stats[val] = len(list(group))

    return stats

def get_ip_stats():

    total, free = 0, 0,

    for network in Network.objects.filter(public=True, deleted=False):

        try:

            net_total, net_free = network.ip_count()

        except AttributeError:

            # TODO: Check that this works..

            pool = network.get_pool(locked=False)

            net_total = pool.pool_size

            net_free = pool.count_available()

        if not network.drained:

            total += net_total

            free += net_free

    return {"total": total,

            "free": free}

def get_backend_stats(backend=None):

    if backend is None:

        backends = Backend.objects.filter(offline=False)

    else:

        if backend.offline:

            return {}

        backends = [backend]

    [backend_mod.update_backend_resources(b) for b in backends]

    resources = {}

    for attr in ("dfree", "dtotal", "mfree", "mtotal", "ctotal"):

        resources[attr] = 0

        for b in backends:

            resources[attr] += getattr(b, attr)

    return {"disk": {"free": resources["dfree"], "total": resources["dtotal"]},

            "ram": {"free": resources["mfree"], "total": resources["mtotal"]},

            "cpu": {"free": resources["ctotal"], "total": resources["ctotal"]},

            "disk_template": {"free": 0, "total": 0}}

class ImageCache(object):

    def __init__(self):

        self.images = {}

        usercache = UserCache(settings.ASTAKOS_BASE_URL,

                              settings.CYCLADES_SERVICE_TOKEN)

        self.system_user_uuid = \

            usercache.get_uuid(settings.SYSTEM_IMAGES_OWNER)

    def get_image(self, imageid, userid):

        if not imageid in self.images:

            try:

                image = get_image(imageid, userid)

                owner = image["owner"]

                owner = "system" if image["owner"] == self.system_user_uuid\

                        else "user"

                self.images[imageid] = owner + ":" + image["name"]

            except Exception:

                self.images[imageid] = "unknown:unknown"

        return self.images[imageid]