Synnefo

# Copyright 2012 GRNET S.A. All rights reserved.

from synnefo.quotas import get_quota_holder

# Copyright 2012 GRNET S.A. All rights reserved.

from synnefo.db.models import QuotaHolderSerial, VirtualMachine, Network

if CYCLADES_USE_QUOTAHOLDER:

    from synnefo.settings import (CYCLADES_QUOTAHOLDER_URL,

                                  CYCLADES_QUOTAHOLDER_TOKEN,

                                  CYCLADES_QUOTAHOLDER_POOLSIZE)

    from synnefo.lib.quotaholder import QuotaholderClient

else:

    from synnefo.settings import (VMS_USER_QUOTA, MAX_VMS_PER_USER,

                                  NETWORKS_USER_QUOTA, MAX_NETWORKS_PER_USER)

from synnefo.lib.quotaholder.api import (NoCapacityError, NoQuantityError,

                                         NoEntityError, CallError)

class DummySerial(QuotaHolderSerial):

    accepted = True

    rejected = True

    pending = True

    id = None

    def save(*args, **kwargs):

        pass

class DummyQuotaholderClient(object):

    def issue_commission(self, **commission_info):

        provisions = commission_info["provisions"]

        userid = commission_info["target"]

        for provision in provisions:

            entity, resource, size = provision

            if resource == "cyclades.vm" and size > 0:

                user_vms = VirtualMachine.objects.filter(userid=userid,

                                                         deleted=False).count()

                user_vm_limit = VMS_USER_QUOTA.get(userid, MAX_VMS_PER_USER)

                log.debug("Users VMs %s User Limits %s", user_vms,

                          user_vm_limit)

                if user_vms + size > user_vm_limit:

                    raise NoQuantityError(source='cyclades',

                                          target=userid,

                                          resource=resource,

                                          requested=size,

                                          current=user_vms,

                                          limit=user_vm_limit)

            if resource == "cyclades.network.private" and size > 0:

                user_networks = Network.objects.filter(userid=userid,

                                                       deleted=False).count()

                user_network_limit =\

                    NETWORKS_USER_QUOTA.get(userid, MAX_NETWORKS_PER_USER)

                if user_networks + size > user_network_limit:

                    raise NoQuantityError(source='cyclades',

                                          target=userid,

                                          resource=resource,

                                          requested=size,

                                          current=user_networks,

                                          limit=user_network_limit)

        return None

    def accept_commission(self, *args, **kwargs):

        pass

    def reject_commission(self, *args, **kwargs):

        pass

    def get_pending_commissions(self, *args, **kwargs):

        return []

@contextmanager

def get_quota_holder():

    """Context manager for using a QuotaHolder."""

    if CYCLADES_USE_QUOTAHOLDER:

        quotaholder = QuotaholderClient(CYCLADES_QUOTAHOLDER_URL,

                                        token=CYCLADES_QUOTAHOLDER_TOKEN,

                                        poolsize=CYCLADES_QUOTAHOLDER_POOLSIZE)

    else:

        quotaholder = DummyQuotaholderClient()

    try:

        yield quotaholder

    finally:

        pass

    with get_quota_holder() as qh:

        qh.accept_commission(context={},

                             clientkey='cyclades',

                             serials=[s.serial for s in serials])

    with get_quota_holder() as qh:

        qh.reject_commission(context={},

                             clientkey='cyclades',

                             serials=[s.serial for s in serials])

def issue_commission(**commission_info):

    with get_quota_holder() as qh:

        try:

            serial = qh.issue_commission(**commission_info)

        except (NoCapacityError, NoQuantityError) as e:

            msg, details = render_quotaholder_exception(e)

            raise faults.OverLimit(msg, details=details)

        except CallError as e:

            log.exception("Unexpected error")

            raise

    elif not CYCLADES_USE_QUOTAHOLDER:

        return DummySerial()

    resources = get_server_resources(flavor)

    commission_info = create_commission(user, resources, delete)

    return issue_commission(**commission_info)

    resources = get_network_resources()

    commission_info = create_commission(user, resources, delete)

    return issue_commission(**commission_info)

def invert_resources(resources_dict):

    return dict((r, -s) for r, s in resources_dict.items())

def create_commission(user, resources, delete=False):

        resources = invert_resources(resources)

    provisions = [('cyclades', 'cyclades.' + r, s)

                  for r, s in resources.items()]

    return {"context": {},

            "target": user,

            "key": "1",

            "clientkey": "cyclades",

            #"owner":      "",

            #"ownerkey":   "1",

            "name": "",

            "provisions": provisions}

    with get_quota_holder() as qh:

        qh.accept_commission(context={},

                             clientkey='cyclades',

                             serials=accepted)

    with get_quota_holder() as qh:

            qh.reject_commission(context={},

                                 clientkey='cyclades',

                                 serials=rejected)

    with get_quota_holder() as qh:

        if accepted:

            qh.accept_commission(context={},

                                 clientkey='cyclades',

                                 serials=accepted)

        if rejected:

            qh.reject_commission(context={},

                                 clientkey='cyclades',

                                 serials=rejected)

    with get_quota_holder() as qh:

        pending_serials = qh.get_pending_commissions(context={},

                                                     clientkey='cyclades')

def render_quotaholder_exception(e):

    res = e.resource.replace("cyclades.", "", 1)

    requested = e.requested

    current = e.current

    limit = e.limit

              " Current value: %s, Limit: %s, Requested: %s"\

              % (resource, current, limit, requested)

# Copyright 2012 GRNET S.A. All rights reserved.

from synnefo.quotas import get_quota_holder

        with get_quota_holder() as qh:

            for user, resources in db_holdings.items():

                if not user:

                    continue

                reset_holding = []

                for res, val in resources.items():

                    reset_holding.append((user, "cyclades." + res, "1", val, 0,

                                          0, 0))

                if not options['dry_run']:

                    try:

                        qh.reset_holding(context={},

                                         reset_holding=reset_holding)

                    except Exception as e:

                        self.stderr.write("Can not set up holding:%s" % e)

                else:

                    self.stdout.write("Reseting holding: %s\n" % reset_holding)

# Copyright 2012 GRNET S.A. All rights reserved.

from synnefo.quotas.util import get_db_holdings, get_quotaholder_holdings

        qh_holdings = get_quotaholder_holdings(users)

            qh = qh_holdings[user]

            if not self.verify_resources(user, db.keys(), qh.keys()):

                continue

            for res in db.keys():

                if db[res] != qh[res]:

                    unsynced.append((user, res, str(db[res]), str(qh[res])))

    def verify_resources(self, user, db_resources, qh_resources):

        write = self.stderr.write

        db_res = set(db_resources)

        qh_res = set(qh_resources)

        if qh_res == db_res:

            return True

        db_extra = db_res - qh_res

        if db_extra:

            for res in db_extra:

                write("Resource %s exists in DB for %s but not in QH\n"

                      % (res, user))

        qh_extra = qh_res - db_res

        if qh_extra:

            for res in qh_extra:

                write("Resource %s exists in QH for %s but not in DB\n"

                      % (res, user))

        return False

# Copyright 2012 GRNET S.A. All rights reserved.

from synnefo.quotas import get_quota_holder, NoEntityError

def get_quotaholder_holdings(users=[]):

    """Get holdings from Quotaholder.

    If the entity for the user does not exist in quotaholder, no holding

    is returned.

    users = filter(lambda u: not u is None, users)

    holdings = {}

    with get_quota_holder() as qh:

        list_holdings = [(user, "1") for user in users]

        (qh_holdings, rejected) = qh.list_holdings(context={},

                                                   list_holdings=list_holdings)

        found_users = filter(lambda u: not u in rejected, users)

    for user, user_holdings in zip(found_users, qh_holdings):

        if not user_holdings:

            continue

        for h in user_holdings:

            assert(h[0] == user)

        user_holdings = filter(lambda x: x[1].startswith("cyclades."),

                               user_holdings)

        holdings[user] = dict(map(decode_holding, user_holdings))

    return holdings

def decode_holding(holding):

    entity, resource, imported, exported, returned, released = holding

    res = resource.replace("cyclades.", "")

    return (res, imported - exported + returned - released)