Synnefo

        profile.save()

        if update:

        else:

    help = "Cleanup sessions and session catalog"

    def handle_noargs(self, **options):

        call_command('cleanup')

        engine = import_module(settings.SESSION_ENGINE)

        store = engine.SessionStore()

        tbd = (entry for entry in SessionCatalog.objects.all()

            fixed = fix_superusers()

            count = len(fixed)

            if count != 0:

            else:

        except BaseException, e:

            raise CommandError(e)

            raise CommandError("Invalid number of arguments")

        Group.objects.get_or_create(name=args[0].strip())

            s = '1 expired project:\n'

        else:

            s = '%d expired projects:\n' % (length,)

        if length > 0:

            labels = ('Project', 'Name', 'Status', 'Expiration date')

            columns = (10, 30, 14, 30)

            line = ' '.join(l.rjust(w) for l, w in zip(labels, columns))

            sep = '-' * len(line)

            for project in projects:

                line = ' '.join(f.rjust(w) for f, w in zip(project, columns))

            if execute:

                    length,))

    def expire(self, execute=False):

    def print_sync(self, diff_quotas):

        size = len(diff_quotas)

        if size == 0:

        else:

            uuids = diff_quotas.keys()

            users = AstakosUser.objects.filter(uuid__in=uuids)

            for user in users:

    def print_verify(self, qh_limits, diff_quotas):

        for holder, local in diff_quotas.iteritems():

            registered = qh_limits.pop(holder, None)

            user = get_user_by_uuid(holder)

            if registered is None:

                    "No quota for %s (%s) in quotaholder.\n" %

                    (holder, user.username))

            else:

        diffs = len(diff_quotas)

        if diffs:

    @transaction.commit_on_success

    def handle(self, *args, **options):

        force = options['force']

        userid = options['userid']

        headers = ("User", "Resource", "Astakos", "Quotaholder")

        if unsynced:

            if options["fix"]:

                provisions = map(create_provision, unsynced)

                try:

        resource = self.get_resource(resource_name)

        resource.api_visible = allow

        if not allow and resource.ui_visible:

            resource.ui_visible = False

        resource.save()

        resource.ui_visible = allow

        if allow and not resource.api_visible:

            resource.api_visible = True

        resource.save()

                    updates.append((resource, value))

                    break

        if updates:

            update_resources(updates)

    def parse_limit(self, limit):

        self.add_services(data)

    def add_services(self, data):

        output = []

        for name, service_dict in data.iteritems():

            try:

            try:

                existed = add_service(component, name, service_type, endpoints,

            except RegisterException as e:

                raise CommandError(e.message)

            activation_backend.send_user_verification_email(user)

                group = Group.objects.get(name=groupname)

                user.groups.add(group)

            except Group.DoesNotExist, e:

                    "Group named %s does not exist\n" % groupname)

        groupname = options.get('delete-group')

                group = Group.objects.get(name=groupname)

                user.groups.remove(group)

            except Group.DoesNotExist, e:

                    "Group named %s does not exist\n" % groupname)

        pname = options.get('add-permission')

            try:

                r, created = add_user_permission(user, pname)

                if created:

                        'Permission: %s created successfully\n' % pname)

                if r > 0:

                        'Permission: %s added successfully\n' % pname)

                elif r == 0:

                        'User has already permission: %s\n' % pname)

            except Exception, e:

                raise CommandError(e)

            try:

                r = remove_user_permission(user, pname)

                if r < 0:

                        'Invalid permission codename: %s\n' % pname)

                elif r == 0:

                elif r > 0:

                        'Permission: %s removed successfully\n' % pname)

            except Exception, e:

                raise CommandError(e)

        self.stdout.write("Confirm? [y/N] ")

        response = raw_input()

        if string.lower(response) not in ['y', 'yes']:

            exit()

    def handle_limits_user(self, user, res, capacity, style):

import os

os.environ['DJANGO_SETTINGS_MODULE'] = 'synnefo.settings'

from optparse import OptionParser

from synnefo.lib.services import fill_endpoints, filter_public

from django.utils import simplejson as json

    try:

        services = definitions[component]

    except KeyError:

        exit(1)

    base_url = args[1]

    print_definitions(services, base_url)

    )

    def confirm(self):

        response = raw_input()

        if string.lower(response) not in ['y', 'yes']:

            exit()

    def get_handlers(self, resources):

            return

        headers = ("#", "User", "Source", "Resource", "Limit", "Usage")

                     options["output_format"], title="Violations")

        if any(actions.values()):

            if fix:

                if dangerous and not force:

                    write("You are enforcing resources that may permanently "

            headers = ("Type", "ID", "State", "Backend", "Action", "Violation")

            if fix:

                headers += ("Result",)

                         options["output_format"], title=title)

    )

    def handle(self, *args, **options):

        userid = options['userid']

        # Get holdings from Cyclades DB

        headers = ("User", "Resource", "Database", "Quotaholder")

        if unsynced:

            if options["fix"]:

                qh = quotas.Quotaholder.get()

                request = {}