Synnefo

# Copyright 2012 GRNET S.A. All rights reserved.

#

# Redistribution and use in source and binary forms, with or

# without modification, are permitted provided that the following

# conditions are met:

#

#   1. Redistributions of source code must retain the above

#      copyright notice, this list of conditions and the following

#      disclaimer.

#

#   2. Redistributions in binary form must reproduce the above

#      copyright notice, this list of conditions and the following

#      disclaimer in the documentation and/or other materials

#      provided with the distribution.

#

# THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS

# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR

# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

# POSSIBILITY OF SUCH DAMAGE.

#

# The views and conclusions contained in the software and

# documentation are those of the authors and should not be

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

from django.core.management.base import NoArgsCommand, CommandError

from optparse import make_option

from pithos.api.util import get_backend

import logging

logger = logging.getLogger(__name__)

CLIENTKEY = 'pithos'

class Command(NoArgsCommand):

    help = "Display unresolved commissions and trigger their recovery"

    option_list = NoArgsCommand.option_list + (

        make_option('--fix',

                    dest='fix',

                    action="store_true",

                    default=False,

                    help="Fix unresolved commissions"),

    )

    def handle_noargs(self, **options):

        b = get_backend()

        try:

            pending_commissions = b.quotaholder.get_pending_commissions(

                token=b.quotaholder_token)

            if pending_commissions:

                self.stdout.write(

                    "Unresolved commissions: %s\n" % pending_commissions

                )

            else:

                self.stdout.write( "No unresolved commissions were found\n")

                return

            if options['fix']:

                to_accept = b.quotaholder_serials.lookup(pending_commissions)

                to_reject = list(set(pending_commissions) - set(to_accept))

                response = b.quotaholder.resolve_commissions(

                    token=b.quotaholder_token,

                    accept_serials=to_accept,

                    reject_serials=to_reject

                )

                accepted = response['accepted']

                rejected = response['rejected']

                failed = response['failed']

                self.stdout.write("Accepted commissions: %s\n" %  accepted)

                self.stdout.write("Rejected commissions: %s\n" %  rejected)

                self.stdout.write("Failed commissions:\n")

                for i in failed:

                    self.stdout.write('%s\n' % i)

                b.quotaholder_serials.delete_many(accepted)

        except Exception, e:

            logger.exception(e)

            raise CommandError(e)

        finally:

            b.close()

# Copyright 2012 GRNET S.A. All rights reserved.

#

# Redistribution and use in source and binary forms, with or

# without modification, are permitted provided that the following

# conditions are met:

#

#   1. Redistributions of source code must retain the above

#      copyright notice, this list of conditions and the following

#      disclaimer.

#

#   2. Redistributions in binary form must reproduce the above

#      copyright notice, this list of conditions and the following

#      disclaimer in the documentation and/or other materials

#      provided with the distribution.

#

# THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS

# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR

# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

# POSSIBILITY OF SUCH DAMAGE.

#

# The views and conclusions contained in the software and

# documentation are those of the authors and should not be

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

from django.core.management.base import NoArgsCommand, CommandError

from optparse import make_option

from pithos.api.util import get_backend

from pithos.backends.modular import CLUSTER_NORMAL, DEFAULT_SOURCE

from synnefo.webproject.management import utils

from astakosclient.errors import AstakosClientException

ENTITY_KEY = '1'

backend = get_backend()

class Command(NoArgsCommand):

    help = "List and reset pithos usage"

    option_list = NoArgsCommand.option_list + (

        make_option('--list',

                    dest='list',

                    action="store_true",

                    default=True,

                    help="List usage for all or specified user"),

        make_option('--reset',

                    dest='reset',

                    action="store_true",

                    default=False,

                    help="Reset usage for all or specified users"),

        make_option('--diverging',

                    dest='diverging',

                    action="store_true",

                    default=False,

                    help=("List or reset diverging usages")),

        make_option('--user',

                    dest='users',

                    action='append',

                    metavar='USER_UUID',

                    help=("Specify which users --list or --reset applies."

                          "This option can be repeated several times."

                          "If no user is specified --list or --reset "

                          "will be applied globally.")),

        make_option(

            "--no-headers",

            dest="headers",

            action="store_false",

            default=True,

            help="Do not display headers"),

        make_option(

            "--output-format",

            dest="output_format",

            metavar="[pretty, csv, json]",

            default="pretty",

            choices=["pretty", "csv", "json"],

            help="Select the output format: pretty [the default], tabs"

                 " [tab-separated output], csv [comma-separated output]"),

    )

    def handle_noargs(self, **options):

        try:

            account_nodes = backend.node.node_accounts(options['users'])

            if not account_nodes:

                raise CommandError('No users found.')

            db_usage = {}

            for path, node in account_nodes:

                size = backend.node.node_account_usage(node, CLUSTER_NORMAL)

                db_usage[path] = size or 0

            result = backend.quotaholder.service_get_quotas(

                backend.quotaholder_token,

            )

            qh_usage = {}

            resource = 'pithos.diskspace'

            pending_list = []

            for uuid, d in result.iteritems():

                pithos_dict = d.get(DEFAULT_SOURCE, {}).get(resource, {})

                pending = pithos_dict.get('pending', 0)

                if pending != 0:

                    pending_list.append(pending)

                    continue

                qh_usage[uuid] = pithos_dict.get('usage', 0)

            if pending_list:

                self.stdout.write((

                    "There are pending commissions for: %s.\n"

                    "Reconcile commissions and retry"

                    "in order to list/reset their quota.\n"

                ) % pending_list)

            headers = ['uuid', 'usage']

            table = []

            provisions = []

            for uuid in db_usage.keys():

                try:

                    delta = db_usage[uuid] - qh_usage[uuid]

                except KeyError:

                    self.stdout.write('Unknown holder: %s\n' % uuid)

                    continue

                else:

                    if options['diverging'] and delta == 0:

                        continue

                    table.append((uuid, db_usage[uuid]))

                    provisions.append({"holder": uuid,

                                       "source": DEFAULT_SOURCE,

                                       "resource": resource,

                                       "quantity": delta

                    })

            if options['reset']:

                if not provisions:

                    raise CommandError('Nothing to reset')

                request = {}

                request['force'] = True

                request['auto_accept'] = True

                request['provisions'] = provisions

                try:

                    serial = backend.quotaholder.issue_commission(

                        backend.quotaholder_token, request

                    )

                except AstakosClientException, e:

                    self.stdout.write(e.details)

                else:

                    backend.quotaholder_serials.insert_many([serial])

            elif options['list'] and table:

                output_format = options["output_format"]

                if output_format != "json" and not options["headers"]:

                    headers = None

                utils.pprint_table(self.stdout, table, headers, output_format)

        finally:

            backend.close()

        return sorted([path for path, _ in self.backend.node.node_accounts()])

    def node_accounts(self, accounts=()):

        s = select([self.nodes.c.path, self.nodes.c.node])

        s = s.where(and_(self.nodes.c.node != 0,

                         self.nodes.c.parent == 0))

        if accounts:

            s = s.where(self.nodes.c.path.in_(accounts))

        r = self.conn.execute(s)

        rows = r.fetchall()

        r.close()

        return rows

    def node_account_usage(self, account_node, cluster):

        select_children = select(

            [self.nodes.c.node]).where(self.nodes.c.parent == account_node)

        select_descendants = select([self.nodes.c.node]).where(

            or_(self.nodes.c.parent.in_(select_children),

                self.nodes.c.node.in_(select_children)))

        s = select([func.sum(self.versions.c.size)])

        s = s.group_by(self.versions.c.cluster)

        s = s.where(self.nodes.c.node == self.versions.c.node)

        s = s.where(self.nodes.c.node.in_(select_descendants))

        s = s.where(self.versions.c.cluster == cluster)

        r = self.conn.execute(s)

        usage = r.fetchone()[0]

        r.close()

        return usage

    def node_accounts(self, accounts=()):

        q = ("select path, node from nodes where node != 0 and parent == 0 ")

        args = []

        if accounts:

            placeholders = ','.join('?' for a in accounts)

            q += ("and path in (%s)" % placeholders)

            args += accounts

        return self.execute(q, args).fetchall()

    def node_account_usage(self, account_node, cluster):

        select_children = ("select node from nodes where parent = ?")

        select_descedents = ("select node from nodes "

                             "where parent in (%s) "

                             "or node in (%s) ") % ((select_children,)*2)

        args = [account_node]*2

        q = ("select sum(v.size) from versions v, nodes n "

             "where v.node = n.node "

             "and n.node in (%s) "

             "and v.cluster = ?") % select_descedents

        args += [cluster]

        self.execute(q, args)

        return self.fetchone()[0]