Synnefo

# Copyright 2012, 2013 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.

from functools import partial

from astakos.quotaholder.exception import (

    QuotaholderError,

    NoCommissionError,

    CorruptedError, InvalidDataError,

    NoHoldingError,

    DuplicateError)

from astakos.quotaholder.commission import (

    Import, Release, Operations)

from astakos.quotaholder.utils.newname import newname

from astakos.quotaholder.api import QH_PRACTICALLY_INFINITE

from .models import (Holding,

                     Commission, Provision, ProvisionLog,

                     now,

                     db_get_holding,

                     db_get_commission, db_filter_provision)

class QuotaholderDjangoDBCallpoint(object):

    def get_holder_quota(self, holders=None, sources=None, resources=None):

        holdings = Holding.objects.filter(holder__in=holders)

        if sources is not None:

            holdings = holdings.filter(source__in=sources)

        if resources is not None:

            holdings = holdings.filter(resource__in=resources)

        quotas = {}

        for holding in holdings:

            key = (holding.holder, holding.source, holding.resource)

            value = (holding.limit, holding.imported_min, holding.imported_max)

            quotas[key] = value

        return quotas

    def _get_holdings_for_update(self, holding_keys):

        holding_keys = sorted(holding_keys)

        holdings = {}

        for (holder, source, resource) in holding_keys:

            try:

                h = Holding.objects.get_for_update(

                    holder=holder, source=source, resource=resource)

                holdings[(holder, source, resource)] = h

            except Holding.DoesNotExist:

                pass

        return holdings

    def _provisions_to_list(self, provisions):

        lst = []

        for provision in provisions:

            try:

                holder = provision['holder']

                source = provision['source']

                resource = provision['resource']

                quantity = provision['quantity']

                key = (holder, source, resource)

                lst.append((key, quantity))

            except KeyError:

                raise InvalidDataError("Malformed provision")

        return lst

    def _mkProvision(self, key, quantity):

        holder, source, resource = key

        return {'holder': holder,

                'source': source,

                'resource': resource,

                'quantity': quantity,

                }

    def set_holder_quota(self, quotas):

        q = self._level_quota_dict(quotas)

        self.set_quota(q)

    def _level_quota_dict(self, quotas):

        lst = []

        for holder, holder_quota in quotas.iteritems():

            for source, source_quota in holder_quota.iteritems():

                for resource, limit in source_quota.iteritems():

                    key = (holder, source, resource)

                    lst.append((key, limit))

        return lst

    def set_quota(self, quotas):

        holding_keys = [key for (key, limit) in quotas]

        holdings = self._get_holdings_for_update(holding_keys)

        for key, limit in quotas:

            try:

                h = holdings[key]

            except KeyError:

                holder, source, resource = key

                h = Holding(holder=holder,

                            source=source,

                            resource=resource)

            h.limit = limit

            h.save()

            holdings[key] = h

    def issue_commission(self,

                         context=None,

                         clientkey=None,

                         name=None,

                         force=False,

                         provisions=()):

        if name is None:

            name = ""

        create = Commission.objects.create

        commission = create(clientkey=clientkey, name=name)

        serial = commission.serial

        operations = Operations()

        provisions = self._provisions_to_list(provisions)

        keys = [key for (key, value) in provisions]

        holdings = self._get_holdings_for_update(keys)

        try:

            checked = []

            for key, quantity in provisions:

                if not isinstance(quantity, (int, long)):

                    raise InvalidDataError("Malformed provision")

                if key in checked:

                    m = "Duplicate provision for %s" % str(key)

                    provision = self._mkProvision(key, quantity)

                    raise DuplicateError(m,

                                         provision=provision)

                checked.append(key)

                # Target

                try:

                    th = holdings[key]

                except KeyError:

                    m = ("There is no such holding %s" % key)

                    provision = self._mkProvision(key, quantity)

                    raise NoHoldingError(m,

                                         provision=provision)

                if quantity >= 0:

                    operations.prepare(Import, th, quantity, force)

                else: # release

                    abs_quantity = -quantity

                    operations.prepare(Release, th, abs_quantity, force)

                holdings[key] = th

                Provision.objects.create(serial=commission,

                                         holding=th,

                                         quantity=quantity)

        except QuotaholderError:

            operations.revert()

            raise

        return serial

    def _log_provision(self,

                       commission, provision, log_time, reason):

        holding = provision.holding

        kwargs = {

            'serial':              commission.serial,

            'name':                commission.name,

            'holder':              holding.holder,

            'source':              holding.source,

            'resource':            holding.resource,

            'limit':               holding.limit,

            'imported_min':        holding.imported_min,

            'imported_max':        holding.imported_max,

            'delta_quantity':      provision.quantity,

            'issue_time':          commission.issue_time,

            'log_time':            log_time,

            'reason':              reason,

        }

        ProvisionLog.objects.create(**kwargs)

    def accept_commission(self,

                          context=None, clientkey=None,

                          serial=None, reason=''):

        log_time = now()

        try:

            c = db_get_commission(clientkey=clientkey, serial=serial,

                                  for_update=True)

        except Commission.DoesNotExist:

            return False

        operations = Operations()

        provisions = db_filter_provision(serial=serial, for_update=True)

        for pv in provisions:

            try:

                th = db_get_holding(id=pv.holding_id,

                                    for_update=True)

            except Holding.DoesNotExist:

                m = "Corrupted provision"

                raise CorruptedError(m)

            quantity = pv.quantity

            if quantity >= 0:

                operations.finalize(Import, th, quantity)

            else: # release

                abs_quantity = -quantity

                operations.finalize(Release, th, abs_quantity)

            reason = 'ACCEPT:' + reason[-121:]

            self._log_provision(c, pv, log_time, reason)

            pv.delete()

        c.delete()

        return True

    def reject_commission(self,

                          context=None, clientkey=None,

                          serial=None, reason=''):

        log_time = now()

        try:

            c = db_get_commission(clientkey=clientkey, serial=serial,

                                  for_update=True)

        except Commission.DoesNotExist:

            return False

        operations = Operations()

        provisions = db_filter_provision(serial=serial, for_update=True)

        for pv in provisions:

            try:

                th = db_get_holding(id=pv.holding_id,

                                    for_update=True)

            except Holding.DoesNotExist:

                m = "Corrupted provision"

                raise CorruptedError(m)

            quantity = pv.quantity

            if quantity >= 0:

                operations.undo(Import, th, quantity)

            else: # release

                abs_quantity = -quantity

                operations.undo(Release, th, abs_quantity)

            reason = 'REJECT:' + reason[-121:]

            self._log_provision(c, pv, log_time, reason)

            pv.delete()

        c.delete()

        return True

    def get_pending_commissions(self, context=None, clientkey=None):

        pending = Commission.objects.filter(clientkey=clientkey)

        pending_list = pending.values_list('serial', flat=True)

        return list(pending_list)

    def get_commission(self, clientkey=None, serial=None):

        try:

            commission = Commission.objects.get(clientkey=clientkey,

                                                serial=serial)

        except Commission.DoesNotExist:

            raise NoCommissionError(serial)

        objs = Provision.objects.select_related('holding')

        provisions = objs.filter(serial=commission)

        ps = [p.todict() for p in provisions]

        response = {'serial':     serial,

                    'provisions': ps,

                    'issue_time': commission.issue_time,

                    }

        return response

    def _resolve(self, include, exclude, operation):

        done = []

        failed = []

        for serial in include:

            if serial in exclude:

                failed.append((serial, 'CONFLICT'))

            else:

                response = operation(serial=serial)

                if response:

                    done.append(serial)

                else:

                    failed.append((serial, 'NOTFOUND'))

        return done, failed

    def resolve_pending_commissions(self,

                                    context=None, clientkey=None,

                                    accept_set=[], reject_set=[]):

        accept_set = set(accept_set)

        reject_set = set(reject_set)

        accept = partial(self.accept_commission, clientkey=clientkey)

        reject = partial(self.reject_commission, clientkey=clientkey)

        accepted, failed_ac = self._resolve(accept_set, reject_set, accept)

        rejected, failed_re = self._resolve(reject_set, accept_set, reject)

        failed = list(set(failed_ac + failed_re))

        return accepted, rejected, failed

API_Callpoint = QuotaholderDjangoDBCallpoint