Synnefo

def qh_add_quota(serial, quotalimits_list):

    data = []

    append = data.append

    for ql in quotalimits_list:

        append(args)

                         add_quota=data)

        transaction.commit()

        trigger_sync()

class ExclusiveOrRaise(object):

    """Context Manager to exclusively execute a critical code section.

       The exclusion must be global.

       (IPC semaphores will not protect across OS,

        DB locks will if it's the same DB)

    """

    class Busy(Exception):

        pass

    def __init__(self, locked=False):

        init = 0 if locked else 1

        from multiprocessing import Semaphore

        self._sema = Semaphore(init)

    def enter(self):

        acquired = self._sema.acquire(False)

        if not acquired:

            raise self.Busy()

    def leave(self):

        self._sema.release()

    def __enter__(self):

        self.enter()

        return self

    def __exit__(self, exc_type, exc_value, exc_traceback):

        self.leave()

exclusive_or_raise = ExclusiveOrRaise(locked=False)

        trigger_sync()

        trigger_sync()

    def get_diff_quotas(self, limits_list=None, remove=False):

        if limits_list is None:

            limits_list = []

        append = limits_list.append

        key = "1"

        tmp_grants = {}

            f = -1

                name = grant.resource.name

                tmp_grants[name] = QuotaLimits(

                                holder       = holder,

                                resource     = name,

                                capacity     = f * grant.member_capacity,

                                import_limit = f * grant.member_import_limit,

                                export_limit = f * grant.member_export_limit)

                name = new_grant.resource.name

                cur_grant = tmp_grants.pop(name, None)

                if cur_grant is None:

                    # if limits on a new resource, set 0 current values

                    capacity = 0

                    import_limit = 0

                    export_limit = 0

                else:

                    capacity = cur_grant.capacity

                    import_limit = cur_grant.import_limit

                    export_limit = cur_grant.export_limit

                capacity += new_grant.member_capacity

                import_limit += new_grant.member_import_limit

                export_limit += new_grant.member_export_limit

                append(QuotaLimits(holder       = holder,

                                   key          = key,

                                   resource     = name,

                                   capacity     = capacity,

                                   import_limit = import_limit,

                                   export_limit = export_limit))

        # third, append all the inverted current limits for removed resources

        limits_list.extend(tmp_grants.itervalues())

        return limits_list

    quotas = []

        membership.get_diff_quotas(quotas)

        membership.get_diff_quotas(quotas, remove=True)

    qh_add_quota(serial, quotas)

    def add_quota(self, context={}, clientkey=None, serial=None, add_quota=()):

        all_pairs = [(q[0], q[1]) for q in add_quota]

        for (   entity, resource, key,

                quantity, capacity,

                import_limit, export_limit ) in add_quota:

                try:

                    e = Entity.objects.get(entity=entity, key=key)

                except Entity.DoesNotExist:

                    append((entity, resource))

                    continue

                try:

                    h = db_get_holding(entity=entity, resource=resource,

                                       for_update=True)

                    p = h.policy

                except Holding.DoesNotExist:

                    h = Holding(entity=e, resource=resource, flags=0)

                    p = None

                policy = newname('policy_')

                newp = Policy(policy=policy)

                newp.quantity = _add(p.quantity if p else 0, quantity)

                newp.capacity = _add(p.capacity if p else 0, capacity)

                newp.import_limit = _add(p.import_limit if p else 0,

                                              import_limit)

                newp.export_limit = _add(p.export_limit if p else 0,

                                              export_limit)

                new_values = [newp.capacity,

                              newp.import_limit, newp.export_limit]

                if any(map(_isneg, new_values)):

                    append((entity, resource))

                    continue

                h.policy = newp

                # the order is intentionally reversed so that it

                # would break if we are not within a transaction.

                # Has helped before.

                h.save()

                newp.save()

                if p is not None and p.holding_set.count() == 0:

                    p.delete()

def _add(x, y):

    return x + y

            set_quota=[(e0, resource0, k0) + (5, 5, 5, 5) + (0,),

                              add_quota=[(e0, resource0, k0, 0, (-2), None, 0),

        self.assertEqual(r, [(e0, resource0, 5, 5 - 2, None, 5)

                              add_quota=[(e0, resource0, k0, 0, 2, None, 0),

                                         (e0, resource1, k0, 0, None, (-5), 0)])

        self.assertEqual(r, [(e0, resource0), (e0, resource1)])