Synnefo

from astakos.im.models import Service

                m = ('Input should be a JSON dict containing "service" '

                     'and "resource" keys.')

                try:

                    data = json.load(file_data)

                except json.JSONDecodeError:

                if not isinstance(data, dict):

                    raise CommandError(m)

                else:

                    try:

                        service = data['service']

                        resources = data['resources']

                    except KeyError:

                        raise CommandError(m)

        self.add_resources(service, resources)

    def add_resources(self, service, resources):

        try:

            s = Service.objects.get(name=service)

        except Service.DoesNotExist:

            raise CommandError("Service '%s' is not registered." % (service))

            if not isinstance(resource, dict):

                raise CommandError("Malformed resource dict.")

            exists = add_resource(s, resource)

            if exists:

                m = "Resource '%s' updated in database.\n" % (name)

            else:

                m = ("Resource '%s' created in database with default "

                     "quota limit 0.\n" % (name))

            self.stdout.write(m)

from django.utils import simplejson as json

    help = ("Modify a resource (currently only change the default base quota)."

            "\nIf no resource is specified, all resources are considered.")

                    help="Specify default base quota"),

        make_option('--interactive',

                    action='store_true',

                    dest='interactive',

                    default=None,

                    help="Prompt user to change default base quotas"),

        make_option('--from-file',

                    dest='from_file',

                    metavar='<limits_file.json>',

                    help="Read default base quotas from a json file"),

        resource_name = args[0] if len(args) > 0 else None

        actions = {

            'limit': self.change_limit,

            'interactive': self.change_interactive,

            'from_file': self.change_from_file,

        }

        opts = [(key, value)

                for (key, value) in options.items()

                if key in actions and value is not None]

        if len(opts) != 1:

            raise CommandError("Please provide exactly one option.")

        key, value = opts[0]

        action = actions[key]

        action(resource_name, value)

    def get_resource(self, resource_name):

        try:

            return Resource.objects.get_for_update(name=resource_name)

        except Resource.DoesNotExist:

            raise CommandError("Resource %s does not exist."

                               % resource_name)

    def change_limit(self, resource_name, limit):

        if resource_name is None:

        resource = self.get_resource(resource_name)

        self.change_resource_limit(resource, limit)

    def change_from_file(self, resource_name, filename):

        with open(filename) as file_data:

            try:

                config = json.load(file_data)

            except json.JSONDecodeError:

                raise CommandError("Malformed JSON file.")

            if not isinstance(config, dict):

                raise CommandError("Malformed JSON file.")

            self.change_with_conf(resource_name, config)

    def change_with_conf(self, resource_name, config):

        if resource_name is None:

            resources = Resource.objects.all().select_for_update()

        else:

            resources = [self.get_resource(resource_name)]

        for resource in resources:

            limit = config.get(resource.name)

            if limit is not None:

                self.change_resource_limit(resource, limit)

    def change_interactive(self, resource_name, _placeholder):

        if resource_name is None:

            resources = Resource.objects.all().select_for_update()

        else:

            resources = [self.get_resource(resource_name)]

        for resource in resources:

            self.stdout.write("Resource '%s' (%s)\n" %

                              (resource.name, resource.desc))

            unit = (" in %s" % resource.unit) if resource.unit else ""

            self.stdout.write("Current limit%s: %s\n"

                              % (unit, resource.uplimit))

            while True:

                self.stdout.write("New limit%s (leave blank to keep current): "

                                  % (unit))

                response = raw_input()

                if response == "":

                    break

                else:

                    try:

                        value = int(response)

                    except ValueError:

                        continue

                    update_resource(resource, value)

                    break

    def change_resource_limit(self, resource, limit):

        update_resource(resource, limit)

from astakos.im.models import Resource

fields = ['name', 'desc', 'unit']

class ResourceException(Exception):

    pass

def add_resource(service, resource_dict):

    name = resource_dict.get('name')

    if not name:

        raise ResourceException("Malformed resource dict.")

        exists = True

        r = Resource(uplimit=0)

        exists = False

    r.service = service

    for field in fields:

        value = resource_dict.get(field)

        if value is not None:

            setattr(r, field, value)

    if not exists:

        qh_sync_new_resource(r, 0)

    if exists:

        logger.info("Updated resource %s." % (name))

        logger.info("Added resource %s." % (name))

    return exists

def update_resource(resource, uplimit):

    old_uplimit = resource.uplimit

    resource.uplimit = uplimit

    resource.save()

    logger.info("Updated resource %s with limit %s."

                % (resource.name, uplimit))

        qh_add_resource_limit(resource, diff)