/ - Diff - Synnefo - Greek Research and Technology Network's projects

Revision d03796c2

     from astakos.quotaholder.exception import (
         QuotaholderError,
         CorruptedError, InvalidDataError,
         NoQuantityError, NoCapacityError,
         NoStockError, NoCapacityError,
         DuplicateError)
     from astakos.quotaholder.commission import (
         Import, Export, Reclaim, Release, Operations)
     from astakos.quotaholder.utils.newname import newname
     from astakos.quotaholder.api import QH_PRACTICALLY_INFINITE
-...
                 except Policy.DoesNotExist:
                     continue
                 append((policy, p.quantity, p.capacity))
                 append((policy, p.capacity))
             return limits
         def set_limits(self, context=None, set_limits=[]):
             for (policy, quantity, capacity) in set_limits:
             for (policy, capacity) in set_limits:
                 try:
                     policy = db_get_policy(policy=policy, for_update=True)
                 except Policy.DoesNotExist:
                     Policy.objects.create(policy=policy,
                                           quantity=quantity,
                                           capacity=capacity,
+                                          )
                 else:
                     policy.quantity = quantity
                     policy.capacity = capacity
                     policy.save()
-...
                     continue
                 append((h.holder, h.resource, h.policy.policy,
                         h.imported, h.exported,
                         h.returned, h.released, h.flags))
                         h.imported_min, h.imported_max,
                         h.stock_min, h.stock_max, h.flags))
             return holdings
-...
         def _init_holding(self,
                           holder, resource, policy,
                           imported, exported, returned, released,
                           imported_min, imported_max, stock_min, stock_max,
                           flags):
             try:
                 h = db_get_holding(holder=holder, resource=resource,
-...
             h.policy = policy
             h.flags = flags
             h.imported = imported
             h.importing = imported
             h.exported = exported
             h.exporting = exported
             h.returned = returned
             h.returning = returned
             h.released = released
             h.releasing = released
             h.imported_min = imported_min
             h.imported_max = imported_max
             h.stock_min = stock_min
             h.stock_max = stock_max
             h.save()
         def init_holding(self, context=None, init_holding=[]):
-...
             for idx, sfh in enumerate(init_holding):
                 (holder, resource, policy,
                  imported, exported, returned, released,
                  imported_min, imported_max, stock_min, stock_max,
                  flags) = sfh
                 try:
-...
                     continue
                 self._init_holding(holder, resource, p,
                                    imported, exported,
                                    returned, released,
                                    imported_min, imported_max,
                                    stock_min, stock_max,
                                    flags)
             if rejected:
                 raise QuotaholderError(rejected)
-...
             for idx, tpl in enumerate(reset_holding):
                 (holder, resource,
                  imported, exported, returned, released) = tpl
                  imported_min, imported_max, stock_min, stock_max) = tpl
                 try:
                     h = db_get_holding(holder=holder, resource=resource,
                                        for_update=True)
                     h.imported = imported
                     h.importing = imported
                     h.exported = exported
                     h.exporting = exported
                     h.returned = returned
                     h.returning = returned
                     h.released = released
                     h.releasing = released
                     h.imported_min = imported_min
                     h.imported_max = imported_max
                     h.stock_min = stock_min
                     h.stock_max = stock_max
                     h.save()
                 except Holding.DoesNotExist:
                     append(idx)
-...
             return as_target + as_source
         def _actual_quantity(self, holding):
             hp = holding.policy
             return hp.quantity + (holding.imported + holding.returned -
                                   holding.exported - holding.released)
         def release_holding(self, context=None, release_holding=[]):
             rejected = []
             append = rejected.append
-...
                     append(idx)
                     continue
                 q = self._actual_quantity(h)
                 if q > 0:
                 if h.imported_max > 0:
                     append(idx)
                     continue
-...
                     continue
                 append([(holder, h.resource,
                          h.imported, h.exported, h.returned, h.released)
                          h.imported_min, h.imported_max, h.stock_min, h.stock_max)
                         for h in holdings])
             return holdings_list, rejected
-...
                 p = h.policy
                 append((h.holder, h.resource, p.quantity, p.capacity,
                         h.imported, h.exported,
                         h.returned, h.released,
                 append((h.holder, h.resource, p.capacity,
                         h.imported_min, h.imported_max,
                         h.stock_min, h.stock_max,
                         h.flags))
             return quotas
-...
             q_holdings = Q()
             holders = []
             for (holder, resource, _, _, _) in set_quota:
             for (holder, resource, _, _) in set_quota:
                 holders.append(holder)
             hs = Holding.objects.filter(holder__in=holders).select_for_update()
-...
             old_policies = []
             for (holder, resource,
                  quantity, capacity,
                  capacity,
                  flags) in set_quota:
                 policy = newname('policy_')
                 newp = Policy(policy=policy,
                               quantity=quantity,
                               capacity=capacity,
+                              )
-...
             sources = sub_quota + add_quota
             q_holdings = Q()
             holders = []
             for (holder, resource, _, _) in sources:
             for (holder, resource, _) in sources:
                 holders.append(holder)
             hs = Holding.objects.filter(holder__in=holders).select_for_update()
-...
             for removing, source in [(True, sub_quota), (False, add_quota)]:
                 for (holder, resource,
                      quantity, capacity,
                      capacity,
                      ) in source:
                     try:
-...
                     policy = newname('policy_')
                     newp = Policy(policy=policy)
                     newp.quantity = _add(p.quantity if p else 0, quantity,
                                          invert=removing)
                     newp.capacity = _add(p.capacity if p else 0, capacity,
                                          invert=removing)
-...
                              clientkey=None,
                              target=None,
                              name=None,
                              provisions=[]):
                              provisions=()):
             create = Commission.objects.create
             commission = create(holder=target, clientkey=clientkey, name=name)
             serial = commission.serial
             checked = []
             for holder, resource, quantity in provisions:
             operations = Operations()
                 if holder == target:
                     m = "Cannot issue commission from an holder to itself (%s)" % (
                         holder,)
                     raise InvalidDataError(m)
                 ent_res = holder, resource
                 if ent_res in checked:
                     m = "Duplicate provision for %s.%s" % ent_res
                     raise DuplicateError(m)
                 checked.append(ent_res)
             try:
                 checked = []
                 for holder, resource, quantity in provisions:
                 release = 0
                 if quantity < 0:
                     release = 1
                     if holder == target:
                         m = ("Cannot issue commission from a holder "
                              "to itself (%s)" % (holder,))
                         raise InvalidDataError(m)
                 # Source limits checks
                 try:
                     h = db_get_holding(holder=holder, resource=resource,
                                        for_update=True)
                 except Holding.DoesNotExist:
                     m = ("There is no quantity "
                          "to allocate from in %s.%s" % (holder, resource))
                     raise NoQuantityError(m,
                                           source=holder, target=target,
                                           resource=resource, requested=quantity,
                                           current=0, limit=0)
                 hp = h.policy
                 if not release:
                     limit = hp.quantity + h.imported - h.releasing
                     unavailable = h.exporting - h.returned
                     available = limit - unavailable
                     if quantity > available:
                         m = ("There is not enough quantity "
                              "to allocate from in %s.%s" % (holder, resource))
                         raise NoQuantityError(m,
                                               source=holder,
                                               target=target,
                                               resource=resource,
                                               requested=quantity,
                                               current=unavailable,
                                               limit=limit)
                 else:
                     current = (+ h.importing + h.returning
                                - h.exported - h.returned)
                     limit = hp.capacity
                     if current - quantity > limit:
                         m = ("There is not enough capacity "
                              "to release to in %s.%s" % (holder, resource))
                         raise NoQuantityError(m,
                                               source=holder,
                                               target=target,
                                               resource=resource,
                                               requested=quantity,
                                               current=current,
                                               limit=limit)
                     ent_res = holder, resource
                     if ent_res in checked:
                         m = "Duplicate provision for %s.%s" % ent_res
                         raise DuplicateError(m)
                     checked.append(ent_res)
                 # Target limits checks
                 try:
                     th = db_get_holding(holder=target, resource=resource,
                                         for_update=True)
                 except Holding.DoesNotExist:
                     m = ("There is no capacity "
                          "to allocate into in %s.%s" % (target, resource))
                     raise NoCapacityError(m,
                                           source=holder,
                                           target=target,
                                           resource=resource,
                                           requested=quantity,
                                           current=0,
                                           limit=0)
                 tp = th.policy
                 if not release:
                     limit = tp.quantity + tp.capacity
                     current = (+ th.importing + th.returning + tp.quantity
                                - th.exported - th.released)
                     if current + quantity > limit:
                         m = ("There is not enough capacity "
                     # Source
                     try:
                         h = db_get_holding(holder=holder, resource=resource,
                                            for_update=True)
                     except Holding.DoesNotExist:
                         m = ("%s has no stock of %s." % (holder, resource))
                         raise NoStockError(m,
                                            holder=holder,
                                            resource=resource,
                                            requested=quantity,
                                            current=0,
                                            limit=0)
                     # Target
                     try:
                         th = db_get_holding(holder=target, resource=resource,
                                             for_update=True)
                     except Holding.DoesNotExist:
                         m = ("There is no capacity "
                              "to allocate into in %s.%s" % (target, resource))
                         raise NoCapacityError(m,
                                               source=holder,
                                               target=target,
                                               holder=holder,
                                               resource=resource,
                                               requested=quantity,
                                               current=current,
                                               limit=limit)
                 else:
                     limit = tp.quantity + th.imported - th.releasing
                     unavailable = th.exporting - th.returned
                     available = limit - unavailable
                                               current=0,
                                               limit=0)
                     if available + quantity < 0:
                         m = ("There is not enough quantity "
                              "to release from in %s.%s" % (target, resource))
                         raise NoCapacityError(m,
                                               source=holder,
                                               target=target,
                                               resource=resource,
                                               requested=quantity,
                                               current=unavailable,
                                               limit=limit)
                 Provision.objects.create(serial=commission,
                                          holder=holder,
                                          resource=resource,
                                          quantity=quantity)
                 if release:
                     h.returning -= quantity
                     th.releasing -= quantity
                 else:
                     h.exporting += quantity
                     th.importing += quantity
                     if quantity >= 0:
                         operations.prepare(Export, h, quantity)
                         operations.prepare(Import, th, quantity)
                 h.save()
                 th.save()
                     else: # release
                         abs_quantity = -quantity
                         operations.prepare(Reclaim, h, abs_quantity)
                         operations.prepare(Release, th, abs_quantity)
                     Provision.objects.create(serial=commission,
                                              holder=holder,
                                              resource=resource,
                                              quantity=quantity)
             except QuotaholderError:
                 operations.revert()
                 raise
             return serial
-...
                 'source':              s_holder,
                 'target':              t_holder,
                 'resource':            provision.resource,
                 'source_quantity':     s_policy.quantity,
                 'source_capacity':     s_policy.capacity,
                 'source_imported':     s_holding.imported,
                 'source_exported':     s_holding.exported,
                 'source_returned':     s_holding.returned,
                 'source_released':     s_holding.released,
                 'target_quantity':     t_policy.quantity,
                 'source_imported_min': s_holding.imported_min,
                 'source_imported_max': s_holding.imported_max,
                 'source_stock_min':    s_holding.stock_min,
                 'source_stock_max':    s_holding.stock_max,
                 'target_capacity':     t_policy.capacity,
                 'target_imported':     t_holding.imported,
                 'target_exported':     t_holding.exported,
                 'target_returned':     t_holding.returned,
                 'target_released':     t_holding.released,
                 'target_imported_min': t_holding.imported_min,
                 'target_imported_max': t_holding.imported_max,
                 'target_stock_min':    t_holding.stock_min,
                 'target_stock_max':    t_holding.stock_max,
                 'delta_quantity':      provision.quantity,
                 'issue_time':          commission.issue_time,
                 'log_time':            log_time,
-...
                 t = c.holder
                 operations = Operations()
                 provisions = db_filter_provision(serial=serial, for_update=True)
                 for pv in provisions:
                     try:
-...
                         raise CorruptedError(m)
                     quantity = pv.quantity
                     release = 0
                     if quantity < 0:
                         release = 1
                     if release:
                         h.returned -= quantity
                         th.released -= quantity
                     else:
                         h.exported += quantity
                         th.imported += quantity
                     if quantity >= 0:
                         operations.finalize(Export, h, quantity)
                         operations.finalize(Import, th, quantity)
                     else: # release
                         abs_quantity = -quantity
                         operations.finalize(Reclaim, h, abs_quantity)
                         operations.finalize(Release, th, abs_quantity)
                     reason = 'ACCEPT:' + reason[-121:]
                     self._log_provision(c, h, th, pv, log_time, reason)
                     h.save()
                     th.save()
                     pv.delete()
                 c.delete()
-...
                 t = c.holder
                 operations = Operations()
                 provisions = db_filter_provision(serial=serial, for_update=True)
                 for pv in provisions:
                     try:
-...
                         raise CorruptedError(m)
                     quantity = pv.quantity
                     release = 0
                     if quantity < 0:
                         release = 1
                     if release:
                         h.returning += quantity
                         th.releasing += quantity
                     else:
                         h.exporting -= quantity
                         th.importing -= quantity
                     if quantity >= 0:
                         operations.undo(Export, h, quantity)
                         operations.undo(Import, th, quantity)
                     else: # release
                         abs_quantity = -quantity
                         operations.undo(Reclaim, h, abs_quantity)
                         operations.undo(Release, th, abs_quantity)
                     reason = 'REJECT:' + reason[-121:]
                     self._log_provision(c, h, th, pv, log_time, reason)
                     h.save()
                     th.save()
                     pv.delete()
                 c.delete()

     # Copyright 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 astakos.quotaholder.exception import (
         NoCapacityError, NoStockError,
         NonImportedError, NoStockReleaseError, NonExportedError)
     class Operation(object):
         @staticmethod
         def assertions(holding):
             assert(0 <= holding.imported_min)
             assert(holding.imported_min <= holding.imported_max)
             assert(0 <= holding.stock_min)
             assert(holding.stock_min <= holding.stock_max)
         @classmethod
         def _prepare(cls, holding, quantity, check=True):
             raise NotImplementedError
         @classmethod
         def prepare(cls, holding, quantity, check=True):
             cls.assertions(holding)
             cls._prepare(holding, quantity, check=True)
         @classmethod
         def _finalize(cls, holding, quantity):
             raise NotImplementedError
         @classmethod
         def finalize(cls, holding, quantity):
             cls.assertions(holding)
             cls._finalize(holding, quantity)
         @classmethod
         def undo(cls, holding, quantity):
             cls.prepare(holding, -quantity, check=False)
         @classmethod
         def revert(cls, holding, quantity):
             # Assertions do not hold when reverting
             cls._prepare(holding, -quantity, check=False)
     class Import(Operation):
         @classmethod
         def _prepare(cls, holding, quantity, check=True):
             imported_max = holding.imported_max
             new_imported_max = imported_max + quantity
             capacity = holding.policy.capacity
             if check and new_imported_max > capacity:
                 holder = holding.holder
                 resource = holding.resource
                 m = ("%s has not enough capacity of %s." % (holder, resource))
                 raise NoCapacityError(m,
                                       holder=holder,
                                       resource=resource,
                                       requested=quantity,
                                       current=imported_max,
                                       limit=capacity)
             holding.imported_max = new_imported_max
             holding.save()
         @classmethod
         def _finalize(cls, holding, quantity):
             holding.imported_min += quantity
             holding.stock_min += quantity
             holding.stock_max += quantity
             holding.save()
     class Export(Operation):
         @classmethod
         def _prepare(cls, holding, quantity, check=True):
             stock_min = holding.stock_min
             new_stock_min = stock_min - quantity
             if check and new_stock_min < 0:
                 holder = holding.holder
                 resource = holding.resource
                 m = ("%s has not enough stock of %s." % (holder, resource))
                 raise NoStockError(m,
                                    holder=holder,
                                    resource=resource,
                                    requested=quantity,
                                    limit=stock_min)
             holding.stock_min = new_stock_min
             holding.save()
         @classmethod
         def _finalize(cls, holding, quantity):
             holding.stock_max -= quantity
             holding.save()
     class Release(Operation):
         @classmethod
         def _prepare(cls, holding, quantity, check=True):
             imported_min = holding.imported_min
             new_imported_min = imported_min - quantity
             stock_min = holding.stock_min
             new_stock_min = stock_min - quantity
             stock_max = holding.stock_max
             new_stock_max = stock_max - quantity
             if check and new_imported_min < 0:
                 holder = holding.holder
                 resource = holding.resource
                 m = ("%s attempts to release more %s than it contains." %
                      (holder, resource))
                 raise NonImportedError(m,
                                        holder=holder,
                                        resource=resource,
                                        requested=quantity,
                                        limit=imported_min)
             if check and new_stock_min < 0:
                 holder = holding.holder
                 resource = holding.resource
                 m = ("%s attempts to release %s that has been reexported." %
                      (holder, resource))
                 raise NoStockReleaseError(m,
                                           holder=holder,
                                           resource=resource,
                                           requested=quantity,
                                           limit=stock_min)
             holding.imported_min = new_imported_min
             holding.stock_min = new_stock_min
             holding.stock_max = new_stock_max
             holding.save()
         @classmethod
         def _finalize(cls, holding, quantity):
             holding.imported_max -= quantity
             holding.save()
     class Reclaim(Operation):
         @classmethod
         def _prepare(cls, holding, quantity, check=True):
             stock_max = holding.stock_max
             new_stock_max = stock_max + quantity
             imported_min = holding.imported_min
             if check and new_stock_max > imported_min:
                 holder = holding.holder
                 resource = holding.resource
                 m = ("%s attempts to reclaim %s not originating by itself." %
                      (holder, resource))
                 raise NonExportedError(m,
                                        holder=holder,
                                        resource=resource,
                                        requested=quantity,
                                        current=stock_max,
                                        limit=imported_min)
             holding.stock_max = new_stock_max
             holding.save()
         @classmethod
         def _finalize(cls, holding, quantity):
             holding.stock_min += quantity
             holding.save()
     class Operations(object):
         def __init__(self):
             self.operations = []
         def prepare(self, operation, holding, quantity):
             operation.prepare(holding, quantity)
             self.operations.append((operation, holding, quantity))
         def finalize(self, operation, holding, quantity):
             operation.finalize(holding, quantity)
             self.operations.append((operation, holding, quantity))
         def undo(self, operation, holding, quantity):
             operation.undo(holding, quantity)
             self.operations.append((operation, holding, quantity))
         def revert(self):
             for (operation, holding, quantity) in self.operations:
                 operation.revert(holding, quantity)

     class CommissionValueException(CommissionException):
         def __init__(self, *args, **kwargs):
             self.source    = kwargs['source']
             self.target    = kwargs['target']
             self.resource  = kwargs['resource']
             self.requested = kwargs['requested']
             self.current   = kwargs['current']
             self.limit     = kwargs['limit']
             self.holder    = kwargs.pop('holder', None)
             self.resource  = kwargs.pop('resource', None)
             self.requested = kwargs.pop('requested', None)
             self.current   = kwargs.pop('current', None)
             self.limit     = kwargs.pop('limit', None)
             CommissionException.__init__(self, *args, **kwargs)
     class NoQuantityError(CommissionValueException):
     class NoStockError(CommissionValueException):
         pass
-...
         pass
     class NonImportedError(CommissionValueException):
         pass
     class NoStockReleaseError(CommissionValueException):
         pass
     class NonExportedError(CommissionValueException):
         pass
     class DuplicateError(CommissionException):
         pass

     class Policy(Model):
         policy          =   CharField(max_length=4096, primary_key=True)
         quantity        =   intDecimalField()
         capacity        =   intDecimalField()
         objects     =   ForUpdateManager()
-...
         policy      =   ForeignKey(Policy, to_field='policy')
         flags       =   BigIntegerField(null=False, default=0)
         imported    =   intDecimalField(default=0)
         importing   =   intDecimalField(default=0)
         exported    =   intDecimalField(default=0)
         exporting   =   intDecimalField(default=0)
         returned    =   intDecimalField(default=0)
         returning   =   intDecimalField(default=0)
         released    =   intDecimalField(default=0)
         releasing   =   intDecimalField(default=0)
         imported_min    =   intDecimalField(default=0)
         imported_max    =   intDecimalField(default=0)
         stock_min       =   intDecimalField(default=0)
         stock_max       =   intDecimalField(default=0)
         objects     =   ForUpdateManager()
-...
         issue_time          =   CharField(max_length=4096)
         log_time            =   CharField(max_length=4096)
         resource            =   CharField(max_length=4096)
         source_quantity     =   intDecimalField()
         source_capacity     =   intDecimalField()
         source_imported     =   intDecimalField()
         source_exported     =   intDecimalField()
         source_returned     =   intDecimalField()
         source_released     =   intDecimalField()
         target_quantity     =   intDecimalField()
         source_imported_min =   intDecimalField()
         source_imported_max =   intDecimalField()
         source_stock_min    =   intDecimalField()
         source_stock_max    =   intDecimalField()
         target_capacity     =   intDecimalField()
         target_imported     =   intDecimalField()
         target_exported     =   intDecimalField()
         target_returned     =   intDecimalField()
         target_released     =   intDecimalField()
         target_imported_min =   intDecimalField()
         target_imported_max =   intDecimalField()
         target_stock_min    =   intDecimalField()
         target_stock_max    =   intDecimalField()
         delta_quantity      =   intDecimalField()
         reason              =   CharField(max_length=4096)
         objects     =   ForUpdateManager()
         def source_allocated_through(self):
             return self.source_imported - self.source_released
         def source_allocated(self):
             return (+ self.source_allocated_through()
                     - self.source_exported
                     + self.source_returned)
         def source_inbound_through(self):
             return self.source_imported
         def source_inbound(self):
             return self.source_inbound_through() + self.source_returned
         def source_outbound_through(self):
             return self.source_released
         def source_outbound(self):
             return self.source_outbound_through() + self.source_exported
         def target_allocated_through(self):
             return self.target_imported - self.target_released
         def target_allocated(self):
             return (+ self.target_allocated_through()
                     - self.target_exported
                     + self.target_returned)
         def target_inbound_through(self):
             return self.target_imported
         def target_inbound(self):
             return self.target_inbound_through() + self.target_returned
         def target_outbound_through(self):
             return self.target_released
         def target_outbound(self):
             return self.target_outbound_through() + self.target_exported
     def _get(*args, **kwargs):
         model = args[0]

     from astakos.quotaholder.exception import (
                                 QuotaholderError,
                                 InvalidDataError,
                                 NoQuantityError, NoCapacityError,
                                 NoCapacityError,
                                 NoStockError,
                                 NonExportedError,
                                 CommissionValueException,
                                 DuplicateError)
-...
             return self.rand_name(self.used_resources)
         def rand_limits(self):
             q = random_nat()
             c = random_nat()
             return q, c,
             return (c,)
         def rand_policy_limits(self):
             p = self.rand_policy()
-...
             resource1 = self.rand_resource()
             self.qh.set_quota(
                 set_quota=[(e0, resource0) + (5, QH_PRACTICALLY_INFINITE) + (0,),
                            (e1, resource0) + (5, 5) + (0,)])
                 set_quota=[(e0, resource0) + (QH_PRACTICALLY_INFINITE, 0),
                            (e1, resource0) + (5, 0)])
             self.qh.add_quota(sub_quota=[(e0, resource0,
 , QH_PRACTICALLY_INFINITE)],
                                           QH_PRACTICALLY_INFINITE)],
                               add_quota=[(e0, resource0,
 , 3),
 ),
                                          # new holding
                                          (e0, resource1,
 , QH_PRACTICALLY_INFINITE)])
                                           QH_PRACTICALLY_INFINITE)])
             r = self.qh.get_quota(get_quota=[(e0, resource0),
                                              (e0, resource1)])
             self.assertEqual(r, [(e0, resource0, 5, 3)
             self.assertEqual(r, [(e0, resource0, 3)
                                  + DEFAULT_HOLDING + (0,),
                                  (e0, resource1, 0, QH_PRACTICALLY_INFINITE)
                                  (e0, resource1, QH_PRACTICALLY_INFINITE)
                                  + DEFAULT_HOLDING + (0,)])
             with self.assertRaises(QuotaholderError) as cm:
                 self.qh.add_quota(add_quota=[(e1, resource0,
 , (-10)),
                                              (e0, resource1, 1, 0)])
                                               (-10)),
                                              (e0, resource1, 0)])
             err = cm.exception
             self.assertEqual(err.message, [(e1, resource0)])
-...
             self.qh.set_quota(
                 set_quota=[(e0, resource0) +
                            (5, QH_PRACTICALLY_INFINITE) + (0,)])
                            (QH_PRACTICALLY_INFINITE,) + (0,)])
             self.qh.add_quota(add_quota=[(e0, resource0,
 , QH_PRACTICALLY_INFINITE)])
                                           QH_PRACTICALLY_INFINITE)])
             r = self.qh.get_quota(get_quota=[(e0, resource0)])
             self.assertEqual(r, [(e0, resource0, 5, 2*QH_PRACTICALLY_INFINITE)
             self.assertEqual(r, [(e0, resource0, 2*QH_PRACTICALLY_INFINITE)
                                  + DEFAULT_HOLDING + (0,)])
         @transaction.commit_on_success
-...
             e0 = self.rand_holder()
             e1 = self.rand_holder()
             resource = self.rand_resource()
             q0, c0 = self.new_quota(e0, resource)
             q1, c1 = self.new_quota(e1, resource)
             most = min(c0, q1)
             if most < 0:
                 raise AssertionError("%s <= 0" % most)
             c0, = self.new_quota(e0, resource)
             c1, = self.new_quota(e1, resource)
             @transaction.commit_on_success
             def f():
                 self.qh.reset_holding(
                     reset_holding=[(e1, resource, c1, c1, c1, c1)])
                 most = min(c0, c1)
                 if most < 0:
                     raise AssertionError("%s <= 0" % most)
                 return self.qh.issue_commission(clientkey=self.client, target=e0,
                                                 name='something',
                                                 provisions=[(e1, resource, most)])
             r = f()
             self.assertEqual(r, 1)
             @transaction.commit_on_success
-...
             et1 = self.rand_holder()
             et2 = self.rand_holder()
             resource = self.rand_resource()
             self.new_quota(es1, resource, (10, 5))
             self.new_quota(es2, resource, (10, 5))
             self.new_quota(et1, resource, (0, 15))
             self.new_quota(et2, resource, (0, 15))
             self.new_quota(es1, resource, (10,))
             self.new_quota(es2, resource, (10,))
             self.new_quota(et1, resource, (15,))
             self.new_quota(et2, resource, (15,))
             with self.assertRaises(NoQuantityError) as cm:
             self.qh.reset_holding(
                 reset_holding=[(es1, resource, 10, 10, 10, 10),
                                (es2, resource, 10, 10, 10, 10)])
             with self.assertRaises(NoStockError) as cm:
                 self.qh.issue_commission(clientkey=self.client, target=et1,
                                          name='something',
                                          provisions=[(es1, resource, 12)])
             e = cm.exception
             self.assertEqual(e.source, es1)
             self.assertEqual(e.target, et1)
             self.assertEqual(e.holder, es1)
             self.assertEqual(e.resource, resource)
             self.assertEqual(int(e.limit), 10)
             self.assertEqual(int(e.requested), 12)
             self.assertEqual(int(e.current), 0)
             r = self.qh.issue_commission(clientkey=self.client, target=et1,
                                          name='something',
                                          provisions=[(es1, resource, 2)])
             self.assertGreater(r, 0)
             # with self.assertRaises(ImportLimitError) as cm:
             #     self.qh.issue_commission(clientkey=self.client, target=et1,
             #                              name='something',
             #                              provisions=[(es1, resource, 2)])
             # e = cm.exception
             # self.assertEqual(e.source, es1)
             # self.assertEqual(e.target, et1)
             # self.assertEqual(e.resource, resource)
             # self.assertEqual(int(e.limit), 3)
             # self.assertEqual(int(e.requested), 2)
             # self.assertEqual(int(e.current), 2)
             r = self.qh.issue_commission(clientkey=self.client, target=et2,
                                          name='something',
-...
                                          provisions=[(es2, resource, 1),
                                                      (es1, resource, 6)])
             e = cm.exception
             self.assertEqual(e.source, es1)
             self.assertEqual(e.target, et2)
             self.assertEqual(e.holder, et2)
             self.assertEqual(e.resource, resource)
             self.assertEqual(int(e.limit), 15)
             self.assertEqual(int(e.requested), 6)
-...
             resource = 'list_holdings_resource'
             sys = 'system'
             self.qh.set_quota(set_quota=[(sys, resource, 10, 0, 0),
                                          (e0, resource, 0, 10, 0),
                                          (e1, resource, 0, 10, 0)])
             self.qh.set_quota(set_quota=[(sys, resource, 10, 0),
                                          (e0, resource, 10, 0),
                                          (e1, resource, 10, 0)])
             self.qh.reset_holding(
                 reset_holding=[(sys, resource, 10, 10, 10, 10)])
             s0 = self.qh.issue_commission(clientkey=self.client, target=e0,
                                           name='a commission',
-...
                                           name='a commission',
                                           provisions=[('system', resource, 4)])
             holdings_list, rejected = self.qh.list_holdings(
                 list_holdings=[e0, e1, e0+e1])
             self.assertEqual(rejected, [e0+e1])
             self.assertEqual(holdings_list, [[(e0, resource, 0, 3, 0, 0)],
                                              [(e1, resource, 0, 4, 0, 0)]])
             self.qh.accept_commission(clientkey=self.client, serials=[s0, s1])
             holdings_list, rejected = self.qh.list_holdings(
                 list_holdings=[e0, e1, e0+e1])
             self.assertEqual(rejected, [e0+e1])
             self.assertEqual(holdings_list, [[(e0, resource, 3, 0, 0, 0)],
                                              [(e1, resource, 4, 0, 0, 0)]])
             self.assertEqual(holdings_list, [[(e0, resource, 3, 3, 3, 3)],
                                              [(e1, resource, 4, 4, 4, 4)]])
         @transaction.commit_on_success
         def test_0130_release_holding(self):
             e = self.rand_holder()
             resource = self.rand_resource()
             limits = self.new_quota(e, resource, (1, 2))
             limits = self.new_quota(e, resource, (2,))
             self.qh.reset_holding(
                 reset_holding=[(e, resource, 1, 1, 1, 1)])
             with self.assertRaises(QuotaholderError) as cm:
                 self.qh.release_holding(release_holding=[(e, resource)])
-...
         def test_0131_release_holding(self):
             e = self.rand_holder()
             resource = self.rand_resource()
             limits = self.new_quota(e, resource, (0, 2))
             limits = self.new_quota(e, resource, (2,))
             self.qh.release_holding(release_holding=[(e, resource)])
-...
             resource = self.rand_resource()
             es = self.rand_holder()
             limits_s = self.new_quota(es, resource, (3, 3))
             limits_s = self.new_quota(es, resource, (3,))
             self.qh.reset_holding(
                 reset_holding=[(es, resource, 3, 3, 3, 3)])
             e = self.rand_holder()
             limits = self.new_quota(e, resource, (0, 2))
             limits = self.new_quota(e, resource, (2,))
             r = self.qh.issue_commission(clientkey=self.client, target=e,
                                          name='something',
-...
             resource = "resource"
             target = "test_015_release_nocapacity_target"
             flags = 0
             source_limits  = [source, 6, 0]
             source_limits  = [source, 6]
             source_holding = [source, resource, source, flags]
             target_limits  = [target, 0, 5]
             target_limits  = [target, 5]
             target_holding = [target, resource, target, flags]
             failed = AssertionError("Quotaholder call failed")
-...
             if qh.set_holding(set_holding=[source_holding, target_holding]):
                 raise failed
             self.qh.reset_holding(
                 reset_holding=[(source, resource, 6, 6, 6, 6)])
             serial = qh.issue_commission(clientkey=self.client, target=target,
                                          name="something",
                                          provisions=[(source, resource, 5)])
-...
             holding = qh.get_holding(get_holding=[[source, resource]])
             self.assertEqual(tuple(holding[0]),
                              (source, resource, source, 0, 5, 0, 0, flags))
                              (source, resource, source, 6, 6, 1, 1, flags))
             holding = qh.get_holding(get_holding=[[target, resource]])
             self.assertEqual(tuple(holding[0]),
                              (target, resource, target, 5, 0, 0, 0, flags))
                              (target, resource, target, 5, 5, 5, 5, flags))
             if qh.reset_holding(reset_holding=[[target, resource, 10, 0, 0, 0]]):
             if qh.reset_holding(
                 reset_holding=[[target, resource, 10, 10, 10, 10]]):
                 raise failed
             with self.assertRaises(NoCapacityError):
-...
                                     name="something",
                                     provisions=[(source, resource, 1)])
             with self.assertRaises(NoQuantityError):
             with self.assertRaises(NonExportedError):
                 qh.issue_commission(clientkey=self.client, target=target,
                                     name="something",
                                     provisions=[(source, resource, -7)])
             source_limits  = [source, 6, 10]
             if qh.set_limits(set_limits=[source_limits]):
                 raise failed
             serial = qh.issue_commission(clientkey=self.client, target=target,
                                          name="something",
                                          provisions=[(source, resource, -1)])
-...
             holding = qh.get_holding(get_holding=[[source, resource]])
             self.assertEqual(tuple(holding[0]),
                              (source, resource, source, 0, 5, 1, 0, flags))
                              (source, resource, source, 6, 6, 2, 2, flags))
             holding = qh.get_holding(get_holding=[[target, resource]])
             self.assertEqual(tuple(holding[0]),
                              (target, resource, target, 10, 0, 0, 1, flags))
                              (target, resource, target, 9, 9, 9, 9, flags))
             with self.assertRaises(NoCapacityError):
             with self.assertRaises(NonExportedError):
                 qh.issue_commission(clientkey=self.client, target=target,
                                     name="something",
                                     provisions=[(source, resource, -10)])

Also available in: Unified diff