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

Revision e496f888

         return result
     def get_holding(payload):
         c = get_client()
         if not c:
             return
         if payload == []:
             return []
         result = c.get_holding(context={}, get_holding=payload)
         logger.debug('get_holding: %s reply: %s' % (payload, result))
         return result
     def qh_get_holdings(users, resources):
         payload = []
         append = payload.append
         for user in users:
             for resource in resources:
                 append((user.uuid, resource),)
         result = get_holding(payload)
         return result
     def quota_limits_per_user_from_get(lst):
         quotas = {}
         for holder, resource, q, c, imp, exp, ret, rel, flags in lst:
             userquotas = quotas.get(holder, {})
             userquotas[resource] = QuotaValues(quantity=q, capacity=c,
+                                               )
             quotas[holder] = userquotas
         return quotas
     def quotas_per_user_from_get(lst):
         limits = {}
         counters = {}
         for holder, resource, q, c, imp, exp, ret, rel, flags in lst:
         usage = {}
         for holder, resource, c, imp_min, imp_max, st_min, st_max, flags in lst:
             userlimits = limits.get(holder, {})
             userlimits[resource] = QuotaValues(quantity=q, capacity=c,
+                                               )
             userlimits[resource] = c
             limits[holder] = userlimits
             usercounters = counters.get(holder, {})
             usercounters[resource] = QuotaCounters(imported=imp, exported=exp,
                                                    returned=ret, released=rel)
             counters[holder] = usercounters
         return limits, counters
             user_usage = usage.get(holder, {})
             user_usage[resource] = imp_max
             usage[holder] = user_usage
         return limits, usage
     def qh_get_quota(users, resources):
-...
         append = payload.append
         for user in users:
             for resource in resources:
                 append((user.uuid, resource),)
                 append((user.uuid, str(resource)),)
         if payload == []:
             return []
-...
         return result
     def qh_get_quota_limits(users, resources):
         result = qh_get_quota(users, resources)
         return quota_limits_per_user_from_get(result)
     def qh_get_quotas(users, resources):
         result = qh_get_quota(users, resources)
         return quotas_per_user_from_get(result)
-...
     SetQuotaPayload = namedtuple('SetQuotaPayload', ('holder',
                                                      'resource',
                                                      'quantity',
                                                      'capacity',
                                                      'flags'))
-...
                                              'capacity',
                                              ))
     QuotaCounters = namedtuple('QuotaCounters', ('imported',
                                                  'exported',
                                                  'returned',
                                                  'released'))
     class QuotaValues(namedtuple('QuotaValues', ('quantity',
                                                  'capacity',
                                                  ))):
         __slots__ = ()
         def __dir__(self):
                 return ['quantity', 'capacity']
         def __str__(self):
             return '\t'.join(['%s=%s' % (f, strbigdec(getattr(self, f)))
                               for f in dir(self)])
     def add_quota_values(q1, q2):
         return QuotaValues(
             quantity = q1.quantity + q2.quantity,
             capacity = q1.capacity + q2.capacity,
+            )
     def register_quotas(quotas):
         if not quotas:
-...
         payload = []
         append = payload.append
         for uuid, userquotas in quotas.iteritems():
             for resource, q in userquotas.iteritems():
             for resource, capacity in userquotas.iteritems():
                 append(SetQuotaPayload(
                         holder=uuid,
                         resource=resource,
                         quantity=q.quantity,
                         capacity=q.capacity,
                         resource=str(resource),
                         capacity=capacity,
                         flags=0))
         return set_quota(payload)
-...
             for resource, q in quotas.iteritems():
                 append(SetQuotaPayload(
                         holder=holder,
                         resource=resource,
                         quantity=q.quantity,
                         resource=str(resource),
                         capacity=q.capacity,
                         flags=0))
         return set_quota(payload)
     def initial_commission(resources):
         c = get_client()
         if not c:
             return
         for resource in resources:
             s = c.issue_commission(
                 clientkey=clientkey,
                 target=str(resource.service),
                 name='initialization',
                 provisions=[(None, str(resource), QH_PRACTICALLY_INFINITE)])
             c.accept_commission(clientkey=clientkey, serials=[s], reason='')
     def register_resources(resources):
         payload = list(SetQuotaPayload(
                 holder=resource.service,
                 resource=resource,
                 quantity=QH_PRACTICALLY_INFINITE,
                 holder=str(resource.service),
                 resource=str(resource),
                 capacity=QH_PRACTICALLY_INFINITE,
                 flags=0) for resource in resources)
         return set_quota(payload)
         set_quota(payload)
         initial_commission(resources)
     def qh_add_quota(sub_list, add_list):
         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,
 , ql.capacity)
             sub_append(args)
         for ql in add_list:
             args = (ql.holder, ql.resource,
 , ql.capacity)
             add_append(args)
         result = c.add_quota(context=context,
                              sub_quota=sub_quota,
                              add_quota=add_quota)
                              sub_quota=sub_list,
                              add_quota=add_list)
         return result

                 h_initial = astakos_initial[holder]
                 email = info[holder]
                 for resource, limits in resources.iteritems():
                     initials = h_initial[resource]
                     initial = str(initials.capacity)
                     capacity = str(limits.capacity)
                     c = h_counters[resource]
                     used = str(c.imported - c.exported + c.returned - c.released)
                     initial = str(h_initial[resource])
                     capacity = str(limits)
                     used = str(h_counters[resource])
                     fields = holder, email, resource, initial, capacity, used
                     output = []

     AddResourceArgs = namedtuple('AddQuotaArgs', ('resource',
                                                   'capacity',
                                                   'quantity',
                                                   ))
     class Command(BaseCommand):
-...
         The file must contain non-empty lines, and each line must
         contain a single-space-separated list of values:
         <user> <resource name> <capacity> <quantity>
         <user> <resource name> <capacity>
         For example to grant the following user with 10 private networks
         (independent of any he receives from projects):
 a50b-cbc7-42c0-bafc-4b6570e3f6ac cyclades.network.private 10 0
 a50b-cbc7-42c0-bafc-4b6570e3f6ac cyclades.network.private 10
         When setting quota from the command line, specify only capacity.
         Quantity and import/export limit will get default values. Example:
         Similar syntax is used when setting quota from the command line:
         --set-capacity 6119a50b-cbc7-42c0-bafc-4b6570e3f6ac cyclades.vm 10
-...
             args = AddResourceArgs(resource=resource,
                                    capacity=capacity,
                                    quantity=0,
+                                   )
             try:

             for user in users:
                 quotas = user.all_quotas()
                 showable_quotas = {}
                 for resource, limits in quotas.iteritems():
                     showable_quotas[resource] = limits.capacity
                 settings_dict = {}
                 settings = user.settings()
-...
                 if settings_dict:
                     kv['settings'] = settings_dict
                 kv['resources'] = showable_quotas
                 kv['resources'] = quotas
                 if get_latest_terms():
                     has_signed_terms = user.signed_terms

     from astakos.im.endpoints.qh import (
         send_quotas, qh_get_quotas,
         register_resources, qh_add_quota, QuotaLimits,
         QuotaValues, add_quota_values)
+        )
     from astakos.im import auth_providers as auth
     import astakos.im.messages as astakos_messages
-...
         register_resources(rs)
     def _quota_values(capacity):
         return QuotaValues(
             quantity = 0,
             capacity = capacity,
+            )
     def get_default_quota():
         _DEFAULT_QUOTA = {}
         resources = Resource.objects.select_related('service').all()
         for resource in resources:
             capacity = resource.uplimit
             limits = _quota_values(capacity)
             _DEFAULT_QUOTA[resource.full_name()] = limits
             _DEFAULT_QUOTA[resource.full_name()] = capacity
         return _DEFAULT_QUOTA
-...
                 self.add_resource_policy(**p)
         def add_resource_policy(
                 self, resource, capacity, quantity,
                 self, resource, capacity,
                 update=True):
             """Raises ObjectDoesNotExist, IntegrityError"""
             s, sep, r = resource.partition(RESOURCE_SEPARATOR)
-...
                 AstakosUserQuota.objects.update_or_create(
                     user=self, resource=resource, defaults={
                         'capacity':capacity,
                         'quantity': quantity,
                         })
             else:
                 q = self.astakosuserquota_set
-...
             uuid = user_quota.user.uuid
             user_init = initial.get(uuid, {})
             resource = user_quota.resource.full_name()
             user_init[resource] = user_quota.quota_values()
             user_init[resource] = user_quota.capacity
             initial[uuid] = user_init
         return initial
-...
                     continue
                 resource = grant.resource.full_name()
                 prev = userquotas.get(resource, 0)
                 new = add_quota_values(prev, grant.member_quota_values())
                 new = prev + grant.member_capacity
                 userquotas[resource] = new
             quotas[uuid] = userquotas
-...
         class Meta:
             unique_together = ("resource", "user")
         def quota_values(self):
             return QuotaValues(
                 quantity = self.quantity,
                 capacity = self.capacity,
+                )
     class ApprovalTerms(models.Model):
         """
-...
         class Meta:
             unique_together = ("resource", "project_application")
         def member_quota_values(self):
             return QuotaValues(
                 quantity = 0,
                 capacity = self.member_capacity,
+                )
         def display_member_capacity(self):
             if self.member_capacity:
                 if self.resource.unit:

Also available in: Unified diff