Synnefo

#!/usr/bin/env python

# Copyright 2011 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 getpass import getuser

from optparse import OptionParser

from os import environ

from sys import argv, exit, stdin, stdout

from pithos.lib.client import Client, Fault

from datetime import datetime

import json

import logging

import types

import re

import time as _time

import os

DEFAULT_HOST = 'pithos.dev.grnet.gr'

#DEFAULT_HOST = '127.0.0.1:8000'

#DEFAULT_API = 'v1'

_cli_commands = {}

def cli_command(*args):

    def decorator(cls):

        cls.commands = args

        for name in args:

            _cli_commands[name] = cls

        return cls

    return decorator

def class_for_cli_command(name):

    return _cli_commands[name]

class Command(object):

    syntax = ''

    def __init__(self, name, argv):

        parser = OptionParser('%%prog %s [options] %s' % (name, self.syntax))

        parser.add_option('--host', dest='host', metavar='HOST',

                          default=DEFAULT_HOST, help='use server HOST')

        parser.add_option('--user', dest='user', metavar='USERNAME',

                          default=_get_user(),

                          help='use account USERNAME')

        parser.add_option('--token', dest='token', metavar='AUTH',

                          default=_get_auth(),

                          help='use account AUTH')

        parser.add_option('--api', dest='api', metavar='API',

                          default=DEFAULT_API, help='use api API')

        parser.add_option('-v', action='store_true', dest='verbose',

                          default=False, help='use verbose output')

        parser.add_option('-d', action='store_true', dest='debug',

                          default=False, help='use debug output')

        self.add_options(parser)

        options, args = parser.parse_args(argv)

        # Add options to self

        for opt in parser.option_list:

            key = opt.dest

            if key:

                val = getattr(options, key)

                setattr(self, key, val)

        self.client = Client(self.host, self.token, self.user, self.api, self.verbose,

                             self.debug)

        self.parser = parser

        self.args = args

    def add_options(self, parser):

        pass

    def execute(self, *args):

        pass

@cli_command('list', 'ls')

class List(Command):

    syntax = '[<container>[/<object>]]'

    description = 'list containers or objects'

    def add_options(self, parser):

        parser.add_option('-l', action='store_true', dest='detail',

                          default=False, help='show detailed output')

        parser.add_option('-n', action='store', type='int', dest='limit',

                          default=1000, help='show limited output')

        parser.add_option('--marker', action='store', type='str',

                          dest='marker', default=None,

                          help='show output greater then marker')

        parser.add_option('--prefix', action='store', type='str',

                          dest='prefix', default=None,

                          help='show output starting with prefix')

        parser.add_option('--delimiter', action='store', type='str',

                          dest='delimiter', default=None,

                          help='show output up to the delimiter')

        parser.add_option('--path', action='store', type='str',

                          dest='path', default=None,

                          help='show output starting with prefix up to /')

        parser.add_option('--meta', action='store', type='str',

                          dest='meta', default=None,

                          help='show output having the specified meta keys')

        parser.add_option('--if-modified-since', action='store', type='str',

                          dest='if_modified_since', default=None,

                          help='show output if modified since then')

        parser.add_option('--if-unmodified-since', action='store', type='str',

                          dest='if_unmodified_since', default=None,

                          help='show output if not modified since then')

        parser.add_option('--until', action='store', dest='until',

                          default=False, help='show metadata until that date')

        parser.add_option('--format', action='store', dest='format',

                          default='%d/%m/%Y', help='format to parse until date')

    def execute(self, container=None):

        if container:

            self.list_objects(container)

        else:

            self.list_containers()

    def list_containers(self):

        params = {'limit':self.limit, 'marker':self.marker}

        headers = {'IF_MODIFIED_SINCE':self.if_modified_since,

                   'IF_UNMODIFIED_SINCE':self.if_unmodified_since}

        if self.until:

            t = _time.strptime(self.until, self.format)

            params['until'] = int(_time.mktime(t))

        l = self.client.list_containers(self.detail, params, headers)

        print_list(l)

    def list_objects(self, container):

        #prepate params

        params = {}

        attrs = ['limit', 'marker', 'prefix', 'delimiter', 'path', 'meta']

        for a in [a for a in attrs if getattr(self, a)]:

            params[a] = getattr(self, a)

        if self.until:

            t = _time.strptime(self.until, self.format)

            params['until'] = int(_time.mktime(t))

        headers = {'IF_MODIFIED_SINCE':self.if_modified_since,

                   'IF_UNMODIFIED_SINCE':self.if_unmodified_since}

        container, sep, object = container.partition('/')

        if object:

            return

        detail = 'json'

        #if request with meta quering disable trash filtering

        show_trashed = True if self.meta else False

        l = self.client.list_objects(container, detail, headers,

                                     include_trashed = show_trashed, **params)

        print_list(l, detail=self.detail)

@cli_command('meta')

class Meta(Command):

    syntax = '[<container>[/<object>]]'

    description = 'get account/container/object metadata'

    def add_options(self, parser):

        parser.add_option('-r', action='store_true', dest='restricted',

                          default=False, help='show only user defined metadata')

        parser.add_option('--until', action='store', dest='until',

                          default=False, help='show metadata until that date')

        parser.add_option('--format', action='store', dest='format',

                          default='%d/%m/%Y', help='format to parse until date')

        parser.add_option('--version', action='store', dest='version',

                          default=None, help='show specific version \

                                  (applies only for objects)')

    def execute(self, path=''):

        container, sep, object = path.partition('/')

        if self.until:

            t = _time.strptime(self.until, self.format)

            self.until = int(_time.mktime(t))

        if object:

            meta = self.client.retrieve_object_metadata(container, object,

                                                        self.restricted,

                                                        self.version)

        elif container:

            meta = self.client.retrieve_container_metadata(container,

                                                           self.restricted,

                                                           self.until)

        else:

            meta = self.client.account_metadata(self.restricted, self.until)

        if meta == None:

            print 'Entity does not exist'

        else:

            print_dict(meta, header=None)

@cli_command('create')

class CreateContainer(Command):

    syntax = '<container> [key=val] [...]'

    description = 'create a container'

    def execute(self, container, *args):

        headers = {}

        meta = {}

        for arg in args:

            key, sep, val = arg.partition('=')

            meta[key] = val

        ret = self.client.create_container(container, headers, **meta)

        if not ret:

            print 'Container already exists'

@cli_command('delete', 'rm')

class Delete(Command):

    syntax = '<container>[/<object>]'

    description = 'delete a container or an object'

    def execute(self, path):

        container, sep, object = path.partition('/')

        if object:

            self.client.delete_object(container, object)

        else:

            self.client.delete_container(container)

@cli_command('get')

class GetObject(Command):

    syntax = '<container>/<object>'

    description = 'get the data of an object'

    def add_options(self, parser):

        parser.add_option('-l', action='store_true', dest='detail',

                          default=False, help='show detailed output')

        parser.add_option('--range', action='store', dest='range',

                          default=None, help='show range of data')

        parser.add_option('--if-range', action='store', dest='if-range',

                          default=None, help='show range of data')

        parser.add_option('--if-match', action='store', dest='if-match',

                          default=None, help='show output if ETags match')

        parser.add_option('--if-none-match', action='store',

                          dest='if-none-match', default=None,

                          help='show output if ETags don\'t match')

        parser.add_option('--if-modified-since', action='store', type='str',

                          dest='if-modified-since', default=None,

                          help='show output if modified since then')

        parser.add_option('--if-unmodified-since', action='store', type='str',

                          dest='if-unmodified-since', default=None,

                          help='show output if not modified since then')

        parser.add_option('-o', action='store', type='str',

                          dest='file', default=None,

                          help='save output in file')

        parser.add_option('--version', action='store', type='str',

                          dest='version', default=None,

                          help='get the specific \

                               version')

        parser.add_option('--versionlist', action='store_true',

                          dest='versionlist', default=False,

                          help='get the full object version list')

    def execute(self, path):

        headers = {}

        if self.range:

            headers['RANGE'] = 'bytes=%s' %self.range

        if getattr(self, 'if-range'):

            headers['IF_RANGE'] = 'If-Range:%s' % getattr(self, 'if-range')

        attrs = ['if-match', 'if-none-match', 'if-modified-since',

                 'if-unmodified-since']

        attrs = [a for a in attrs if getattr(self, a)]

        for a in attrs:

            headers[a.replace('-', '_').upper()] = getattr(self, a)

        container, sep, object = path.partition('/')

        if self.versionlist:

            self.version = 'list'

            self.detail = True

        data = self.client.retrieve_object(container, object, self.detail,

                                          headers, self.version)

        f = self.file and open(self.file, 'w') or stdout

        if self.detail:

            data = json.loads(data)

            if self.versionlist:

                print_versions(data, f=f)

            else:

                print_dict(data, f=f)

        else:

            f.write(data)

        f.close()

@cli_command('mkdir')

class PutMarker(Command):

    syntax = '<container>/<directory marker>'

    description = 'create a directory marker'

    def execute(self, path):

        container, sep, object = path.partition('/')

        self.client.create_directory_marker(container, object)

@cli_command('put')

class PutObject(Command):

    syntax = '<container>/<object> [key=val] [...]'

    description = 'create/override object'

    def add_options(self, parser):

        parser.add_option('--use_hashes', action='store_true', dest='use_hashes',

                          default=False, help='provide hashmap instead of data')

        parser.add_option('--chunked', action='store_true', dest='chunked',

                          default=False, help='set chunked transfer mode')

        parser.add_option('--etag', action='store', dest='etag',

                          default=None, help='check written data')

        parser.add_option('--content-encoding', action='store',

                          dest='content-encoding', default=None,

                          help='provide the object MIME content type')

        parser.add_option('--content-disposition', action='store', type='str',

                          dest='content-disposition', default=None,

                          help='provide the presentation style of the object')

        parser.add_option('-S', action='store',

                          dest='segment-size', default=False,

                          help='use for large file support')

        parser.add_option('--manifest', action='store_true',

                          dest='manifest', default=None,

                          help='upload a manifestation file')

        parser.add_option('--type', action='store',

                          dest='content-type', default=False,

                          help='create object with specific content type')

        parser.add_option('--sharing', action='store',

                          dest='sharing', default=None,

                          help='define sharing object policy')

        parser.add_option('-f', action='store',

                          dest='srcpath', default=None,

                          help='file descriptor to read from (pass - for standard input)')

        parser.add_option('--public', action='store',

                          dest='public', default=None,

                          help='make object publicly accessible (\'True\'/\'False\')')

    def execute(self, path, *args):

        if path.find('=') != -1:

            raise Fault('Missing path argument')

        #prepare user defined meta

        meta = {}

        for arg in args:

            key, sep, val = arg.partition('=')

            meta[key] = val

        headers = {}

        manifest = getattr(self, 'manifest')

        if manifest:

            # if it's manifestation file

            # send zero-byte data with X-Object-Manifest header

            self.touch = True

            headers['X_OBJECT_MANIFEST'] = manifest

        if self.sharing:

            headers['X_OBJECT_SHARING'] = self.sharing

        attrs = ['etag', 'content-encoding', 'content-disposition',

                 'content-type']

        attrs = [a for a in attrs if getattr(self, a)]

        for a in attrs:

            headers[a.replace('-', '_').upper()] = getattr(self, a)

        container, sep, object = path.partition('/')

        f = None

        if self.srcpath:

            f = open(self.srcpath) if self.srcpath != '-' else stdin

        if self.use_hashes and not f:

            raise Fault('Illegal option combination')

        if self.public not in ['True', 'False', None]:

            raise Fault('Not acceptable value for public')

        public = eval(self.public) if self.public else None

        self.client.create_object(container, object, f, chunked=self.chunked,

                                  headers=headers, use_hashes=self.use_hashes,

                                  public=public, **meta)

        if f:

            f.close()

@cli_command('copy', 'cp')

class CopyObject(Command):

    syntax = '<src container>/<src object> [<dst container>/]<dst object>'

    description = 'copy an object to a different location'

    def add_options(self, parser):

        parser.add_option('--version', action='store',

                          dest='version', default=False,

                          help='copy specific version')

        parser.add_option('--public', action='store',

                          dest='public', default=None,

                          help='publish/unpublish object (\'True\'/\'False\')')

    def execute(self, src, dst):

        src_container, sep, src_object = src.partition('/')

        dst_container, sep, dst_object = dst.partition('/')

        if not sep:

            dst_container = src_container

            dst_object = dst

        version = getattr(self, 'version')

        headers = None

        if version:

            headers = {}

            headers['X_SOURCE_VERSION'] = version

        if self.public and self.nopublic:

            raise Fault('Conflicting options')

        if self.public not in ['True', 'False', None]:

            raise Fault('Not acceptable value for public')

        public = eval(self.public) if self.public else None

        self.client.copy_object(src_container, src_object, dst_container,

                                dst_object, public, headers)

@cli_command('set')

class SetMeta(Command):

    syntax = '[<container>[/<object>]] key=val [key=val] [...]'

    description = 'set account/container/object metadata'

    def execute(self, path, *args):

        #in case of account fix the args

        if path.find('=') != -1:

            args = list(args)

            args.append(path)

            args = tuple(args)

            path = ''

        meta = {}

        for arg in args:

            key, sep, val = arg.partition('=')

            meta[key.strip()] = val.strip()

        container, sep, object = path.partition('/')

        if object:

            self.client.update_object_metadata(container, object, **meta)

        elif container:

            self.client.update_container_metadata(container, **meta)

        else:

            self.client.update_account_metadata(**meta)

@cli_command('update')

class UpdateObject(Command):

    syntax = '<container>/<object> path [key=val] [...]'

    description = 'update object metadata/data (default mode: append)'

    def add_options(self, parser):

        parser.add_option('-a', action='store_true', dest='append',

                          default=True, help='append data')

        parser.add_option('--offset', action='store',

                          dest='offset',

                          default=None, help='starting offest to be updated')

        parser.add_option('--range', action='store', dest='content-range',

                          default=None, help='range of data to be updated')

        parser.add_option('--chunked', action='store_true', dest='chunked',

                          default=False, help='set chunked transfer mode')

        parser.add_option('--content-encoding', action='store',

                          dest='content-encoding', default=None,

                          help='provide the object MIME content type')

        parser.add_option('--content-disposition', action='store', type='str',

                          dest='content-disposition', default=None,

                          help='provide the presentation style of the object')

        parser.add_option('--manifest', action='store', type='str',

                          dest='manifest', default=None,

                          help='use for large file support')        

        parser.add_option('--sharing', action='store',

                          dest='sharing', default=None,

                          help='define sharing object policy')

        parser.add_option('--nosharing', action='store_true',

                          dest='no_sharing', default=None,

                          help='clear object sharing policy')

        parser.add_option('-f', action='store',

                          dest='srcpath', default=None,

                          help='file descriptor to read from: pass - for standard input')

        parser.add_option('--public', action='store',

                          dest='public', default=None,

                          help='publish/unpublish object (\'True\'/\'False\')')

    def execute(self, path, *args):

        if path.find('=') != -1:

            raise Fault('Missing path argument')

        headers = {}

        if self.manifest:

            headers['X_OBJECT_MANIFEST'] = self.manifest

        if self.sharing:

            headers['X_OBJECT_SHARING'] = self.sharing

        if self.no_sharing:

            headers['X_OBJECT_SHARING'] = ''

        attrs = ['content-encoding', 'content-disposition']

        attrs = [a for a in attrs if getattr(self, a)]

        for a in attrs:

            headers[a.replace('-', '_').upper()] = getattr(self, a)

        #prepare user defined meta

        meta = {}

        for arg in args:

            key, sep, val = arg.partition('=')

            meta[key] = val

        container, sep, object = path.partition('/')

        f = None

        chunked = False

        if self.srcpath:

            f = self.srcpath != '-' and open(self.srcpath) or stdin

        if f:

            chunked = True if (self.chunked or f == stdin) else False

        if self.public not in ['True', 'False', None]:

            raise Fault('Not acceptable value for public')

        public = eval(self.public) if self.public else None

        self.client.update_object(container, object, f, chunked=chunked,

                                  headers=headers, offset=self.offset,

                                  public=public, **meta)

        if f:

            f.close()

@cli_command('move', 'mv')

class MoveObject(Command):

    syntax = '<src container>/<src object> [<dst container>/]<dst object>'

    description = 'move an object to a different location'

    def add_options(self, parser):

        parser.add_option('--public', action='store',

                          dest='public', default=None,

                          help='publish/unpublish object (\'True\'/\'False\')')

    def execute(self, src, dst):

        src_container, sep, src_object = src.partition('/')

        dst_container, sep, dst_object = dst.partition('/')

        if not sep:

            dst_container = src_container

            dst_object = dst

        if self.public not in ['True', 'False', None]:

            raise Fault('Not acceptable value for public')

        public = eval(self.public) if self.public else None

        self.client.move_object(src_container, src_object, dst_container,

                                dst_object, public, headers)

@cli_command('remove')

class TrashObject(Command):

    syntax = '<container>/<object>'

    description = 'trash an object'

    def execute(self, src):

        src_container, sep, src_object = src.partition('/')

        self.client.trash_object(src_container, src_object)

@cli_command('restore')

class RestoreObject(Command):

    syntax = '<container>/<object>'

    description = 'restore a trashed object'

    def execute(self, src):

        src_container, sep, src_object = src.partition('/')

        self.client.restore_object(src_container, src_object)

@cli_command('unset')

class UnsetObject(Command):

    syntax = '<container>/[<object>] key [key] [...]'

    description = 'delete metadata info'

    def execute(self, path, *args):

        #in case of account fix the args

        if len(args) == 0:

            args = list(args)

            args.append(path)

            args = tuple(args)

            path = ''

        meta = []

        for key in args:

            meta.append(key)

        container, sep, object = path.partition('/')

        if object:

            self.client.delete_object_metadata(container, object, meta)

        elif container:

            self.client.delete_container_metadata(container, meta)

        else:

            self.client.delete_account_metadata(meta)

@cli_command('group')

class CreateGroup(Command):

    syntax = 'key=val [key=val] [...]'

    description = 'create account groups'

    def execute(self, *args):

        groups = {}

        for arg in args:

            key, sep, val = arg.partition('=')

            groups[key] = val

        self.client.set_account_groups(**groups)

@cli_command('ungroup')

class DeleteGroup(Command):

    syntax = 'key [key] [...]'

    description = 'delete account groups'

    def execute(self, *args):

        groups = []

        for arg in args:

            groups.append(arg)

        self.client.unset_account_groups(groups)

@cli_command('policy')

class SetPolicy(Command):

    syntax = 'container key=val [key=val] [...]'

    description = 'set container policies'

    def execute(self, path, *args):

        if path.find('=') != -1:

            raise Fault('Missing container argument')

        container, sep, object = path.partition('/')

        if object:

            raise Fault('Only containers have policies')

        policies = {}

        for arg in args:

            key, sep, val = arg.partition('=')

            policies[key] = val

        self.client.set_container_policies(container, **policies)

@cli_command('publish')

class PublishObject(Command):

    syntax = '<container>/<object>'

    description = 'publish an object'

    def execute(self, src):

        src_container, sep, src_object = src.partition('/')

        self.client.publish_object(src_container, src_object)

@cli_command('unpublish')

class UnpublishObject(Command):

    syntax = '<container>/<object>'

    description = 'unpublish an object'

    def execute(self, src):

        src_container, sep, src_object = src.partition('/')

        self.client.unpublish_object(src_container, src_object)

def print_usage():

    cmd = Command('', [])

    parser = cmd.parser

    parser.usage = '%prog <command> [options]'

    parser.print_help()

    commands = []

    for cls in set(_cli_commands.values()):

        name = ', '.join(cls.commands)

        description = getattr(cls, 'description', '')

        commands.append('  %s %s' % (name.ljust(12), description))

    print '\nCommands:\n' + '\n'.join(sorted(commands))

def print_dict(d, header='name', f=stdout, detail=True):

    header = header in d and header or 'subdir'

    if header and header in d:

        f.write('%s\n' %d.pop(header))

    if detail:

        patterns = ['^x_(account|container|object)_meta_(\w+)$']

        patterns.append(patterns[0].replace('_', '-'))

        for key, val in sorted(d.items()):

            for p in patterns:

                p = re.compile(p)

                m = p.match(key)

                if m:

                    key = m.group(2)

            f.write('%s: %s\n' % (key.rjust(30), val))

def print_list(l, verbose=False, f=stdout, detail=True):

    for elem in l:

        #if it's empty string continue

        if not elem:

            continue

        if type(elem) == types.DictionaryType:

            print_dict(elem, f=f, detail=detail)

        elif type(elem) == types.StringType:

            if not verbose:

                elem = elem.split('Traceback')[0]

            f.write('%s\n' % elem)

        else:

            f.write('%s\n' % elem)

def print_versions(data, f=stdout):

    if 'versions' not in data:

        f.write('%s\n' %data)

        return

    f.write('versions:\n')

    for id, t in data['versions']:

        f.write('%s @ %s\n' % (str(id).rjust(30), datetime.fromtimestamp(t)))

def _get_user():

        try:

            return os.environ['PITHOS_USER']

        except KeyError:

            return getuser()

def _get_auth():

        try:

            return os.environ['PITHOS_AUTH']

        except KeyError:

            return '0000'

def main():

    try:

        name = argv[1]

        cls = class_for_cli_command(name)

    except (IndexError, KeyError):

        print_usage()

        exit(1)

    cmd = cls(name, argv[2:])

    try:

        cmd.execute(*cmd.args)

    except TypeError, e:

        cmd.parser.print_help()

        exit(1)

    except Fault, f:

        status = f.status and '%s ' % f.status or ''

        print '%s%s' % (status, f.data)

if __name__ == '__main__':

    main()