Synnefo

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

#

# Redistribution and use in source and binary forms, with or

# without modification, are permitted provided that the following

# conditions are met:

#

#   1. Redistributions of source code must retain the above

#      copyright notice, this list of conditions and the following

#      disclaimer.

#

#   2. Redistributions in binary form must reproduce the above

#      copyright notice, this list of conditions and the following

#      disclaimer in the documentation and/or other materials

#      provided with the distribution.

#

# THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS

# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR

# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

# POSSIBILITY OF SUCH DAMAGE.

#

# The views and conclusions contained in the software and

# documentation are those of the authors and should not be

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

import logging

import itertools

from functools import wraps

from collections import namedtuple

from django.utils.translation import ugettext as _

from astakos.im.settings import (

        QUOTAHOLDER_URL, QUOTAHOLDER_TOKEN, LOGGING_LEVEL)

if QUOTAHOLDER_URL:

    from kamaki.clients.quotaholder import QuotaholderClient

ENTITY_KEY = '1'

inf = float('inf')

logger = logging.getLogger(__name__)

inf = float('inf')

clientkey = 'astakos'

_client = None

def get_client():

    global _client

    if _client:

        return _client

    if not QUOTAHOLDER_URL:

        return

    _client = QuotaholderClient(QUOTAHOLDER_URL, token=QUOTAHOLDER_TOKEN)

    return _client

def set_quota(payload):

    c = get_client()

    if not c:

        return

    result = c.set_quota(context={}, clientkey=clientkey, set_quota=payload)

    logger.info('set_quota: %s rejected: %s' % (payload, result))

    return result

def get_quota(user):

    c = get_client()

    if not c:

        return

    payload = []

    append = payload.append

    for r in user.quota.keys():

        append((user.uuid, r, ENTITY_KEY),)

    result = c.get_quota(context={}, clientkey=clientkey, get_quota=payload)

    logger.info('get_quota: %s rejected: %s' % (payload, result))

    return result

def create_entity(payload):

    c = get_client()

    if not c:

        return

    result = c.create_entity(context={}, clientkey=clientkey, create_entity=payload)

    logger.info('create_entity: %s rejected: %s' % (payload, result))

    return result

SetQuotaPayload = namedtuple('SetQuotaPayload', ('holder',

                                                 'resource',

                                                 'key',

                                                 'quantity',

                                                 'capacity',

                                                 'import_limit',

                                                 'export_limit',

                                                 'flags'))

GetQuotaPayload = namedtuple('GetQuotaPayload', ('holder',

                                                 'resource',

                                                 'key'))

CreateEntityPayload = namedtuple('CreateEntityPayload', ('entity',

                                                         'owner',

                                                         'key',

                                                         'ownerkey'))

QuotaLimits = namedtuple('QuotaLimits', ('holder',

                                         'resource',

                                         'capacity',

                                         'import_limit',

                                         'export_limit'))

def register_users(users):

    payload = list(CreateEntityPayload(

                    entity=u.uuid,

                    owner='system',

                    key=ENTITY_KEY,

                    ownerkey='') for u in users)

    rejected = create_entity(payload)

    if not rejected:

        payload = []

        append = payload.append

        for u in users:

            for resource, uplimit in u.quota.iteritems():

                append( SetQuotaPayload(

                                holder=u.uuid,

                                resource=resource,

                                key=ENTITY_KEY,

                                quantity=0,

                                capacity=uplimit if uplimit != inf else None,

                                import_limit=0,

                                export_limit=0,

                                flags=0))

        return set_quota(payload)

def register_resources(resources):

    rdata = ((r.service, r) for r in resources)

    services = set(r.service for r in resources)

    payload = list(CreateEntityPayload(

                    entity=service,

                    owner='system',

                    key=ENTITY_KEY,

                    ownerkey='') for service in set(services))

    rejected = create_entity(payload)

    if not rejected:

        payload = list(SetQuotaPayload(

                        holder=resource.service,

                        resource=resource,

                        key=ENTITY_KEY,

                        quantity=None,

                        capacity=None,

                        import_limit=None,

                        export_limit=None,

                        flags=0) for resource in resources)

        return set_quota(payload)

def qh_add_quota(serial, sub_list, add_list):

    if not QUOTAHOLDER_URL:

        return ()

    context = {}

    c = get_client()

    sub_quota = []

    sub_append = sub_quota.append

    add_quota = []

    add_append = add_quota.append

    for ql in sub_list:

        args = (ql.holder, ql.resource, ENTITY_KEY,

                0, ql.capacity, ql.import_limit, ql.export_limit)

        sub_append(args)

    for ql in add_list:

        args = (ql.holder, ql.resource, ENTITY_KEY,

                0, ql.capacity, ql.import_limit, ql.export_limit)

        add_append(args)

    result = c.add_quota(context=context,

                         clientkey=clientkey,

                         serial=serial,

                         sub_quota=sub_quota,

                         add_quota=add_quota)

    return result

def qh_query_serials(serials):

    if not QUOTAHOLDER_URL:

        return ()

    context = {}

    c = get_client()

    result = c.query_serials(context=context,

                             clientkey=clientkey,

                             serials=serials)

    return result

def qh_ack_serials(serials):

    if not QUOTAHOLDER_URL:

        return ()

    context = {}

    c = get_client()

    result = c.ack_serials(context=context,

                           clientkey=clientkey,

                           serials=serials)

    return

from datetime import datetime

strptime = datetime.strptime

timefmt = '%Y-%m-%dT%H:%M:%S.%f'

SECOND_RESOLUTION = 1

def total_seconds(timedelta_object):

    return timedelta_object.seconds + timedelta_object.days * 86400

def iter_timeline(timeline, before):

    if not timeline:

        return

    for t in timeline:

        yield t

    t = dict(t)

    t['issue_time'] = before

    yield t

def _usage_units(timeline, after, before, details=0):

    t_total = 0

    uu_total = 0

    t_after = strptime(after, timefmt)

    t_before = strptime(before, timefmt)

    t0 = t_after

    u0 = 0

    for point in iter_timeline(timeline, before):

        issue_time = point['issue_time']

        if issue_time <= after:

            u0 = point['target_allocated_through']

            continue

        t = strptime(issue_time, timefmt) if issue_time <= before else t_before

        t_diff = int(total_seconds(t - t0) * SECOND_RESOLUTION)

        t_total += t_diff

        uu_cost = u0 * t_diff

        uu_total += uu_cost

        t0 = t

        u0 = point['target_allocated_through']

        target = point['target']

        if details:

            yield  (target,

                    point['resource'],

                    point['name'],

                    issue_time,

                    uu_cost,

                    uu_total)

    if not t_total:

        return

    yield  (target,

            'total',

            point['resource'],

            issue_time,

            uu_total / t_total,

            uu_total)

def usage_units(timeline, after, before, details=0):

    return list(_usage_units(timeline, after, before, details=details))

def traffic_units(timeline, after, before, details=0):

    tu_total = 0

    target = None

    issue_time = None

    for point in timeline:

        issue_time = point['issue_time']

        if issue_time <= after:

            continue

        if issue_time > before:

            break

        target = point['target']

        tu = point['target_allocated_through']

        tu_total += tu

        if details:

            yield  (target,

                    point['resource'],

                    point['name'],

                    issue_time,

                    tu,

                    tu_total)

    if not tu_total:

        return

    yield  (target,

            'total',

            point['resource'],

            issue_time,

            tu_total // len(timeline),

            tu_total)

def timeline_charge(entity, resource, after, before, details, charge_type):

    key = '1'

    if charge_type == 'charge_usage':

        charge_units = usage_units

    elif charge_type == 'charge_traffic':

        charge_units = traffic_units

    else:

        m = 'charge type %s not supported' % charge_type

        raise ValueError(m)

    quotaholder = QuotaholderClient(QUOTAHOLDER_URL, token=QUOTAHOLDER_TOKEN)

    timeline = quotaholder.get_timeline(

        context={},

        after=after,

        before=before,

        get_timeline=[[entity, resource, key]])

    cu = charge_units(timeline, after, before, details=details)

    return cu