Synnefo » Pithos

#!/usr/bin/env python

from getpass import getuser

from optparse import OptionParser

from os.path import basename

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

DEFAULT_HOST = 'pithos.dev.grnet.gr'

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):

    def __init__(self, argv):

        parser = OptionParser()

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

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

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

                          default=getuser(), help='use account USERNAME')

        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.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):

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

                  'prefix':self.prefix, 'delimiter':self.delimiter,

                  'path':self.path, 'meta':self.meta}

        headers = {'IF_MODIFIED_SINCE':self.if_modified_since,

                   'IF_UNMODIFIED_SINCE':self.if_unmodified_since}

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

        if object:

            print '%s/%s is an object' %(container, object)

            return

        if self.until:

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

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

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

        print_list(l)

@cli_command('meta')

class Meta(Command):

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

    description = 'get the metadata of an account, a container or an object'

    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 = {}

        for arg in args:

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

            headers['X_CONTAINER_META_%s' %key.strip().upper()] = val.strip()

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

        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-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('-f', action='store', type='str',

                          dest='file', default=None,

                          help='save output in file')

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

                          dest='version', default='list',

                          help='if \'list\' and in detailed mode get object\'s \

                               full version list otherwise get the specific \

                               version')

    def execute(self, path):

        headers = {}

        if self.range:

            headers['RANGE'] = 'bytes=%s' %self.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('/')

        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.version == 'list':

                print_versions(data, f=f)

            else:

                print_dict(data, f=f)

        else:

            f.write(data)

        f.close()

@cli_command('put')

class PutObject(Command):

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

    description = 'create/override object with path contents or standard input'

    def add_options(self, parser):

        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('--manifest', action='store', type='str',

                          dest='manifest', default=None,

                          help='use for large file support')

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

                          dest='touch', default=False,

                          help='create object with zero data')

    def execute(self, path, srcpath='-', *args):

        headers = {}

        if self.manifest:

            headers['X_OBJECT_MANIFEST'] = self.manifest

        attrs = ['etag', '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

        for arg in args:

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

            headers['X_OBJECT_META_%s' %key.strip().upper()] = val.strip()

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

        f = None

        chunked = False

        if not self.touch:

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

            chunked = (self.chunked or f == stdin) and True or False

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

                                  headers=headers)

        if f:

            f.close()

@cli_command('copy', 'cp')

class CopyObject(Command):

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

    description = 'copies an object to a different location'

    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

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

                                dst_object)

@cli_command('set')

class SetMeta(Command):

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

    description = 'set 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('--start', action='store',

                          dest='start',

                          default=None, help='range of data 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')

    def execute(self, path, srcpath='-', *args):

        headers = {}

        if self.manifest:

            headers['X_OBJECT_MANIFEST'] = self.manifest

        if self.append:

            headers['CONTENT_RANGE'] = 'bytes */*'

        elif self.start:

            headers['CONTENT_RANGE'] = 'bytes %s-/*' % self.first-byte-pos

        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

        for arg in args:

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

            headers['X_OBJECT_META_%s' %key.strip().upper()] = val.strip()

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

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

        chunked = (self.chunked or f == stdin) and True or False

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

                                  headers=headers)

        f.close()

@cli_command('move', 'mv')

class MoveObject(Command):

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

    description = 'moves an object to a different location'

    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

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

                                dst_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):

    header = header in d and header or 'subdir'

    if header and header in d:

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

    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):

    for elem in l:

        #if it's empty string continue

        if not elem:

            continue

        if type(elem) == types.DictionaryType:

            print_dict(elem, f=f)

        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 main():

    try:

        name = argv[1]

        cls = class_for_cli_command(name)

    except (IndexError, KeyError):

        print_usage()

        exit(1)

    cmd = cls(argv[2:])

    try:

        cmd.execute(*cmd.args)

    except TypeError, e:

        print e

        cmd.parser.usage = '%%prog %s [options] %s' % (name, cmd.syntax)

        cmd.parser.print_help()

        exit(1)

    except Fault, f:

        print f.status, f.data

if __name__ == '__main__':

    main()