Synnefo

    quotas.qh_sync_membership(membership)

    quotas.qh_sync_membership(membership)

    quotas.qh_sync_membership(membership)

        quotas.qh_sync_membership(membership)

        quotas.qh_sync_membership(membership)

    qh_release_pending_app(application.applicant)

    quotas.qh_sync_project(project)

def qh_add_pending_app(user, project=None, force=False, assign_project=None):

    if assign_project is None:

        assign_project = user.base_project

    return quotas.register_pending_apps(user, assign_project,

                                        diff, force=force)

def qh_release_pending_app(user, assign_project=None):

    if assign_project is None:

        assign_project = user.base_project

    quotas.register_pending_apps(user, assign_project, -1)

def collect_holder_quotas(holder_quotas, style=None):

            fields = (source, resource, limit, usage)

def show_user_quotas(holder_quotas, style=None):

    labels = ('source', 'resource', 'limit', 'usage')

    print_data = collect_holder_quotas(holder_quotas, style=style)

def show_quotas(qh_quotas, info=None, style=None):

    labels = ('holder', 'source', 'resource', 'limit', 'usage')

        h_data = collect_holder_quotas(holder_quotas, style=style)

from astakos.im import quotas

        make_option('--quota',

                    action='store_true',

                    dest='list_quotas',

                    default=False,

                    help="List project quota"),

            self.print_project(project, show_quota)

    def print_project(self, project, show_quota=False):

        quota = (quotas.get_project_quota(project)

                 if show_quota else None)

        self.print_resources(project, quota=quota)

    def print_resources(self, project, quota=None):

        fields, labels = resource_fields(policies, quota, self.unit_style)

def resource_fields(policies, quota, style):

    labels = ('name', 'max per member', 'max per project')

    if quota:

        labels += ('usage',)

        p_capacity = policy.project_capacity

        row = (name,

               show_resource_value(capacity, name, style),

               show_resource_value(p_capacity, name, style))

        if quota:

            r_quota = quota.get(name)

            usage = r_quota.get('project_usage')

            row += (show_resource_value(usage, name, style),)

        collect.append(row)

        "limit": ("limit", filtering.parse_with_unit),

        QHQ = Q()

        qh_quotas = list_user_quotas(

            users, qhflt=QHQ)

            qh_quotas, info, style=unit_style)

from astakos.im.quotas import get_user_quotas

                quotas = get_user_quotas(user)

                    print_data, labels = show_user_quotas(quotas,

    def actually_accepted(self, projects=None):

        if projects is not None:

            q &= Q(project__in=projects)

    Project, ProjectMembership, ProjectResourceQuota)

from synnefo.util.keypath import set_path

PROJECT_TAG = "project:"

USER_TAG = "user:"

def project_ref(value):

    return  PROJECT_TAG + value

def get_project_ref(project):

    return project_ref(project.uuid)

def user_ref(value):

    return USER_TAG + value

def get_user_ref(user):

    return user_ref(user.uuid)

def from_holding(holding, is_project=False):

    prefix = 'project_' if is_project else ''

    body = {prefix+'limit':   limit,

            prefix+'usage':   usage_max,

            prefix+'pending': usage_max-usage_min,

def get_user_counters(users, resources=None, sources=None, flt=None):

    holders = [get_user_ref(user) for user in users]

    return qh.get_quota(holders=holders,

                        resources=resources,

                        sources=sources,

                        flt=flt)

def get_project_counters(projects, resources=None, sources=None):

    holders = [get_project_ref(project) for project in projects]

    return qh.get_quota(holders=holders,

                        resources=resources,

                        sources=sources)

def strip_names(counters):

    stripped = {}

    for ((holder, source, resource), value) in counters.iteritems():

        prefix, sep, holder = holder.partition(":")

        assert prefix in ["user", "project"]

        if source is not None:

            prefix, sep, source = source.partition(":")

            assert prefix == "project"

        stripped[(holder, source, resource)] = value

    return stripped

def get_related_sources(counters):

    projects = set()

    for (holder, source, resource) in counters.iterkeys():

        projects.add(source)

    return list(projects)

def mk_quota_dict(users_counters, project_counters):

    quota = {}

    for (holder, source, resource), u_value in users_counters.iteritems():

        p_value = project_counters[(source, None, resource)]

        values_dict = from_holding(u_value)

        values_dict.update(from_holding(p_value, is_project=True))

        set_path(quota, [holder, source, resource], values_dict,

                 createpath=True)

    return quota

def get_users_quotas_counters(users, resources=None, sources=None, flt=None):

    user_counters = get_user_counters(users, resources, sources, flt=flt)

    projects = get_related_sources(user_counters)

    project_counters = qh.get_quota(holders=projects, resources=resources)

    return strip_names(user_counters), strip_names(project_counters)

def get_users_quotas(users, resources=None, sources=None, flt=None):

    u_c, p_c = get_users_quotas_counters(users, resources, sources, flt=flt)

    return mk_quota_dict(u_c, p_c)

    astakosusers = AstakosUser.objects.verified()

    if users is not None:

        astakosusers = astakosusers.filter(uuid__in=users)

    return get_users_quotas(astakosusers, resources=resource_names)

def mk_limits_dict(counters):

    quota = {}

    for key, (limit, _, _) in counters.iteritems():

        path = list(key)

        set_path(quota, path, limit, createpath=True)

    return quota

def mk_project_quota_dict(project_counters):

    quota = {}

    for (holder, _, resource), p_value in project_counters.iteritems():

        values_dict = from_holding(p_value, is_project=True)

        set_path(quota, [holder, resource], values_dict,

                 createpath=True)

    return quota

def get_projects_quota(projects, resources=None, sources=None):

    project_counters = get_project_counters(projects, resources, sources)

    return mk_project_quota_dict(strip_names(project_counters))

def get_project_quota(project, resources=None, sources=None):

    quotas = get_projects_quota([project], resources, sources)

    return quotas.get(project.uuid, {})

def get_projects_quota_limits():

    project_counters = qh.get_quota(flt=Q(holder__startswith=PROJECT_TAG))

    user_counters = qh.get_quota(flt=Q(holder__startswith=USER_TAG))

    return mk_limits_dict(project_counters), mk_limits_dict(user_counters)

def set_quota(quotas, resource=None):

def mk_user_provision(user, source, resource, quantity):

    holder = user_ref(user)

    source = project_ref(source)

    return (holder, source, resource), quantity

def mk_project_provision(project, resource, quantity):

    holder = project_ref(project)

    return (holder, None, resource), quantity

def _mk_provisions(holder, source, resource, quantity):

    return [((holder, source, resource), quantity),

            ((source, None, resource), quantity)]

def register_pending_apps(user, project, quantity, force=False):

    provisions = _mk_provisions(get_user_ref(user), get_project_ref(project),

                                PENDING_APP_RESOURCE, quantity)

                                provisions=provisions)

    source = user.base_project.uuid

    return quota[source][PENDING_APP_RESOURCE]

def astakos_project_quotas(projects, resource=None):

    flt = Q(resource__name=resource) if resource is not None else Q()

    grants = objs.filter(project__in=projects).filter(flt)

    grants_d = _partition_by(lambda g: g.project_id, grants)

    objs = ProjectMembership.objects

    memberships = objs.initialized(projects).select_related(

        "person", "project")

    memberships_d = _partition_by(lambda m: m.project_id, memberships)

    user_quota = {}

    project_quota = {}

    for project in projects:

        pr_ref = get_project_ref(project)

        state = project.state

        if state not in Project.INITIALIZED_STATES:

            continue

        project_grants = grants_d.get(project.id, [])

        project_memberships = memberships_d.get(project.id, [])

        for grant in project_grants:

            resource = grant.resource.name

            path = [pr_ref, None, resource]

            val = grant.project_capacity if state == Project.NORMAL else 0

            set_path(project_quota, path, val, createpath=True)

            for membership in project_memberships:

                u_ref = get_user_ref(membership.person)

                path = [u_ref, pr_ref, resource]

                val = grant.member_capacity if membership.is_active() else 0

                set_path(user_quota, path, val, createpath=True)

    return project_quota, user_quota

def list_user_quotas(users, qhflt=None):

    return qh_quotas

def qh_sync_projects(projects, resource=None):

    p_quota, u_quota = astakos_project_quotas(projects, resource=resource)

    p_quota.update(u_quota)

    set_quota(p_quota, resource=resource)

def qh_sync_project(project):

    qh_sync_projects([project])

def membership_quota(membership):

    project = membership.project

    pr_ref = get_project_ref(project)

    u_ref = get_user_ref(membership.person)

    objs = ProjectResourceQuota.objects.select_related()

    grants = objs.filter(project=project)

    user_quota = {}

    is_active = membership.is_active()

    for grant in grants:

        resource = grant.resource.name

        path = [u_ref, pr_ref, resource]

        value = grant.member_capacity if is_active else 0

        set_path(user_quota, path, value, createpath=True)

    return user_quota

def qh_sync_membership(membership):

    quota = membership_quota(membership)

    set_quota(quota)

def compute_diff_quota(local, registered):

    diff = {}

    for holder, h_quota in local.iteritems():

        for source, value in h_quota.iteritems():

            reg_h_quota = registered.get(holder, {})

            reg_value = reg_h_quota.get(source, {})

            if value != reg_value:

                set_path(diff, [holder, source], value, createpath=True)

    return diff

def qh_sync_projects_diffs(projects, sync=True):

    local_project, local_user = astakos_project_quotas(projects)

    registered_project, registered_user = get_projects_quota_limits(projects)

    diff_quotas = compute_diff_quota(local_project, registered_project)

    diff_quotas.update(compute_diff_quota(local_user, registered_user))

        set_quota(diff_quotas)

    all_registered = registered_project

    all_registered.update(registered_user)

    return all_registered, diff_quotas

    projects = Project.objects.filter(state__in=Project.INITIALIZED_STATES).\

        select_for_update()

    for project in projects:

        limit = pick_limit_scheme(project, resource)

            ProjectResourceQuota(

                project=project,

                resource=resource,

                project_capacity=limit,

                member_capacity=limit))

    ProjectResourceQuota.objects.bulk_create(entries)

    qh_sync_projects(projects, resource=resource.name)