Synnefo

def get_vms(users=None, projects=None):

    if projects is not None:

        vms = vms.filter(project__in=projects)

    vmsdict = _partition_by(lambda vm: vm.project, vms)

    for project, projectdict in vmsdict.iteritems():

        vmsdict[project] = _partition_by(lambda vm: vm.userid, projectdict)

    return vmsdict

def get_floating_ips(users=None, projects=None):

    if projects is not None:

        ips = ips.filter(project__in=projects)

    ipsdict = _partition_by(lambda ip: ip.project, ips)

    for project, projectdict in ipsdict.iteritems():

        ipsdict[project] = _partition_by(lambda ip: ip.userid, projectdict)

    return ipsdict

def get_actual_resources(resource_type, users=None, projects=None):

    return ACTUAL_RESOURCES[resource_type](users=users, projects=projects)

def skip_check(obj, to_check=None, excluded=None):

    return (to_check is not None and obj not in to_check or

            excluded is not None and obj in excluded)

def pick_project_resources(project_dict, users=None, excluded_users=None):

    resources = []

    for user, user_resources in project_dict.iteritems():

        if skip_check(user, users, excluded_users):

            continue

        resources += user_resources

    return resources

        make_option("--projects",

                    help=("Enforce resources only for the specified list "

                          "of projects, e.g uuid1,uuid2")),

        make_option("--exclude-projects",

                    help=("Exclude list of projects from resource enforcement")

                    ),

        handlers = self.get_handlers(options["resources"])

        excluded_users = options['exclude_users']

        excluded_users = set(excluded_users.split(',')

                             if excluded_users is not None else [])

        users_to_check = options['users']

        if users_to_check is not None:

            users_to_check = set(users_to_check.split(',')) - excluded_users

        try:

            qh_holdings = util.get_qh_users_holdings(users_to_check)

        except errors.AstakosClientException as e:

            raise CommandError(e)

        excluded_projects = options["exclude_projects"]

        excluded_projects = set(excluded_projects.split(',')

                                if excluded_projects is not None else [])

        projects_to_check = options["projects"]

        if projects_to_check is not None:

            projects_to_check = set(projects_to_check.split(',')) - \

                excluded_projects

            qh_project_holdings = util.get_qh_project_holdings(

                projects_to_check)

        qh_project_holdings = sorted(qh_project_holdings.items())

        for resource, handle_resource, resource_type in handlers:

            if resource_type not in actions:

                actions[resource_type] = OrderedDict()

            actual_resources = enforce.get_actual_resources(

                resource_type, projects=projects_to_check)

            for project, project_quota in qh_project_holdings:

                if enforce.skip_check(project, projects_to_check,

                                      excluded_projects):

                    continue

                try:

                    qh = util.transform_project_quotas(project_quota)

                    qh_value, qh_limit, qh_pending = qh[resource]

                except KeyError:

                    write("Resource '%s' does not exist in Quotaholder"

                          " for project '%s'!\n" %

                          (resource, project))

                    continue

                if qh_pending:

                    write("Pending commission for project '%s', "

                          "resource '%s'. Skipping\n" %

                          (project, resource))

                    continue

                diff = qh_value - qh_limit

                if diff > 0:

                    viol_id += 1

                    overlimit.append((viol_id, "project", project, "",

                                      resource, qh_limit, qh_value))

                    relevant_resources = enforce.pick_project_resources(

                        actual_resources[project], users=users_to_check,

                        excluded_users=excluded_users)

                    handle_resource(viol_id, resource, relevant_resources,

                                    diff, actions)

                                                            users_to_check)

                if enforce.skip_check(user, users_to_check, excluded_users):

                    if enforce.skip_check(source, projects_to_check,

                                          excluded_projects):

                        continue

                        overlimit.append((viol_id, "user", user, source,

                                          resource, qh_limit, qh_value))

                        relevant_resources = actual_resources[source][user]

        headers = ("#", "Type", "Holder", "Source", "Resource", "Limit",

                   "Usage")

def get_qh_project_holdings(projects=None):

    qh = Quotaholder.get()

    if projects is None or len(projects) != 1:

        req = None

    else:

        req = projects[0]

    quotas = qh.service_get_project_quotas(req)

    if projects is None:

        return quotas

    qs = {}

    for project in projects:

        try:

            qs[project] = quotas[project]

        except KeyError:

            pass

    return qs

def transform_project_quotas(quotas):

    d = {}

    for resource, counters in quotas.iteritems():

        used = counters['project_usage']

        limit = counters['project_limit']

        pending = counters['project_pending']

        d[resource] = (used, limit, pending)

    return d