/ - Diff - ./kamaki - Greek Research and Technology Network's projects

Revision 6a0b1658

     from pwd import getpwuid
     from sys import argv, exit, stdout
     from clint.textui import puts, puts_err, indent
     from clint import args
     from clint.textui import puts, puts_err, indent, progress
     from clint.textui.colored import magenta, red, yellow
     from clint.textui.cols import columns
     from requests.exceptions import ConnectionError
     from kamaki import clients
     from kamaki.config import Config
     from kamaki.utils import OrderedDict, print_addresses, print_dict, print_items
-...
             cls.api = api
             cls.group = group or grp
             cls.name = name or cmd
             cls.description = description or cls.__doc__
             cls.syntax = syntax
             short_description, sep, long_description = cls.__doc__.partition('\n')
             cls.description = short_description
-...
     @command(api='compute')
     class server_list(object):
         """list servers"""
         """List servers"""
         def update_parser(cls, parser):
             parser.add_option('-l', dest='detail', action='store_true',
-...
     @command(api='compute')
     class server_info(object):
         """get server details"""
         """Get server details"""
         def main(self, server_id):
             server = self.client.get_server_details(int(server_id))
-...
     @command(api='compute')
     class server_create(object):
         """create server"""
         """Create a server"""
         def update_parser(cls, parser):
             parser.add_option('--personality', dest='personalities',
                     action='append', default=[],
                     metavar='PATH[,SERVER PATH[,OWNER[,GROUP,[MODE]]]]',
                     help='add a personality file')
                               action='append', default=[],
                               metavar='PATH[,SERVER PATH[,OWNER[,GROUP,[MODE]]]]',
                               help='add a personality file')
             parser.epilog = "If missing, optional personality values will be " \
                     "filled based on the file at PATH if missing."
                             "filled based on the file at PATH."
         def main(self, name, flavor_id, image_id):
             personalities = []
-...
     @command(api='compute')
     class server_rename(object):
         """update server name"""
         """Update a server's name"""
         def main(self, server_id, new_name):
             self.client.update_server_name(int(server_id), new_name)
-...
     @command(api='compute')
     class server_delete(object):
         """delete server"""
         """Delete a server"""
         def main(self, server_id):
             self.client.delete_server(int(server_id))
-...
     @command(api='compute')
     class server_reboot(object):
         """reboot server"""
         """Reboot a server"""
         def update_parser(cls, parser):
             parser.add_option('-f', dest='hard', action='store_true',
-...
     @command(api='cyclades')
     class server_start(object):
         """start server"""
         """Start a server"""
         def main(self, server_id):
             self.client.start_server(int(server_id))
-...
     @command(api='cyclades')
     class server_shutdown(object):
         """shutdown server"""
         """Shutdown a server"""
         def main(self, server_id):
             self.client.shutdown_server(int(server_id))
-...
     @command(api='cyclades')
     class server_console(object):
         """get a VNC console"""
         """Get a VNC console"""
         def main(self, server_id):
             reply = self.client.get_server_console(int(server_id))
-...
     @command(api='cyclades')
     class server_firewall(object):
         """set the firewall profile"""
         """Set the server's firewall profile"""
         def main(self, server_id, profile):
             self.client.set_firewall_profile(int(server_id), profile)
-...
     @command(api='cyclades')
     class server_addr(object):
         """list server addresses"""
         """List a server's addresses"""
         def main(self, server_id, network=None):
             reply = self.client.list_server_addresses(int(server_id), network)
-...
     @command(api='compute')
     class server_meta(object):
         """get server metadata"""
         """Get a server's metadata"""
         def main(self, server_id, key=None):
             reply = self.client.get_server_metadata(int(server_id), key)
-...
     @command(api='compute')
     class server_addmeta(object):
         """add server metadata"""
         """Add server metadata"""
         def main(self, server_id, key, val):
             reply = self.client.create_server_metadata(int(server_id), key, val)
-...
     @command(api='compute')
     class server_setmeta(object):
         """update server metadata"""
         """Update server's metadata"""
         def main(self, server_id, key, val):
             metadata = {key: val}
-...
     @command(api='compute')
     class server_delmeta(object):
         """delete server metadata"""
         """Delete server metadata"""
         def main(self, server_id, key):
             self.client.delete_server_metadata(int(server_id), key)
-...
     @command(api='cyclades')
     class server_stats(object):
         """get server statistics"""
         """Get server statistics"""
         def main(self, server_id):
             reply = self.client.get_server_stats(int(server_id))
-...
     @command(api='compute')
     class flavor_list(object):
         """list flavors"""
         """List flavors"""
         def update_parser(cls, parser):
             parser.add_option('-l', dest='detail', action='store_true',
-...
     @command(api='compute')
     class flavor_info(object):
         """get flavor details"""
         """Get flavor details"""
         def main(self, flavor_id):
             flavor = self.client.get_flavor_details(int(flavor_id))
-...
     @command(api='compute')
     class image_list(object):
         """list images"""
         """List images"""
         def update_parser(cls, parser):
             parser.add_option('-l', dest='detail', action='store_true',
-...
     @command(api='compute')
     class image_info(object):
         """get image details"""
         """Get image details"""
         def main(self, image_id):
             image = self.client.get_image_details(image_id)
-...
     @command(api='compute')
     class image_delete(object):
         """delete image"""
         """Delete image"""
         def main(self, image_id):
             self.client.delete_image(image_id)
-...
     @command(api='compute')
     class image_meta(object):
         """get image metadata"""
         """Get image metadata"""
         def main(self, image_id, key=None):
             reply = self.client.get_image_metadata(image_id, key)
-...
     @command(api='compute')
     class image_addmeta(object):
         """add image metadata"""
         """Add image metadata"""
         def main(self, image_id, key, val):
             reply = self.client.create_image_metadata(image_id, key, val)
-...
     @command(api='compute')
     class image_setmeta(object):
         """update image metadata"""
         """Update image metadata"""
         def main(self, image_id, key, val):
             metadata = {key: val}
-...
     @command(api='compute')
     class image_delmeta(object):
         """delete image metadata"""
         """Delete image metadata"""
         def main(self, image_id, key):
             self.client.delete_image_metadata(image_id, key)
-...
     @command(api='cyclades')
     class network_list(object):
         """list networks"""
         """List networks"""
         def update_parser(cls, parser):
             parser.add_option('-l', dest='detail', action='store_true',
-...
     @command(api='cyclades')
     class network_create(object):
         """create a network"""
         """Create a network"""
         def main(self, name):
             reply = self.client.create_network(name)
-...
     @command(api='cyclades')
     class network_info(object):
         """get network details"""
         """Get network details"""
         def main(self, network_id):
             network = self.client.get_network_details(network_id)
-...
     @command(api='cyclades')
     class network_rename(object):
         """update network name"""
         """Update network name"""
         def main(self, network_id, new_name):
             self.client.update_network_name(network_id, new_name)
-...
     @command(api='cyclades')
     class network_delete(object):
         """delete a network"""
         """Delete a network"""
         def main(self, network_id):
             self.client.delete_network(network_id)
-...
     @command(api='cyclades')
     class network_connect(object):
         """connect a server to a network"""
         """Connect a server to a network"""
         def main(self, server_id, network_id):
             self.client.connect_server(server_id, network_id)
-...
     @command(api='cyclades')
     class network_disconnect(object):
         """disconnect a server from a network"""
         """Disconnect a server from a network"""
         def main(self, server_id, network_id):
             self.client.disconnect_server(server_id, network_id)
-...
     @command(api='image')
     class glance_list(object):
         """list images"""
         """List images"""
         def update_parser(cls, parser):
             parser.add_option('-l', dest='detail', action='store_true',
-...
     @command(api='image')
     class glance_meta(object):
         """get image metadata"""
         """Get image metadata"""
         def main(self, image_id):
             image = self.client.get_meta(image_id)
-...
     @command(api='image')
     class glance_register(object):
         """register an image"""
         """Register an image"""
         def update_parser(cls, parser):
             parser.add_option('--checksum', dest='checksum', metavar='CHECKSUM',
-...
         def main(self, name, location):
             params = {}
             for key in ('checksum', 'container_format', 'disk_format', 'id',
                         'owner', 'is_public', 'size'):
                         'owner', 'size'):
                 val = getattr(self.options, key)
                 if val is not None:
                     params[key] = val
             if self.options.is_public:
                 params['is_public'] = 'true'
             properties = {}
             for property in self.options.properties or []:
                 key, sep, val = property.partition('=')
-...
     @command(api='image')
     class glance_members(object):
         """get image members"""
         """Get image members"""
         def main(self, image_id):
             members = self.client.list_members(image_id)
-...
     @command(api='image')
     class glance_shared(object):
         """list shared images"""
         """List shared images"""
         def main(self, member):
             images = self.client.list_shared(member)
-...
     @command(api='image')
     class glance_addmember(object):
         """add a member to an image"""
         """Add a member to an image"""
         def main(self, image_id, member):
             self.client.add_member(image_id, member)
-...
     @command(api='image')
     class glance_delmember(object):
         """remove a member from an image"""
         """Remove a member from an image"""
         def main(self, image_id, member):
             self.client.remove_member(image_id, member)
-...
     @command(api='image')
     class glance_setmembers(object):
         """set the members of an image"""
         """Set the members of an image"""
         def main(self, image_id, *member):
             self.client.set_members(image_id, member)
-...
         def update_parser(cls, parser):
             parser.add_option('--account', dest='account', metavar='NAME',
                     help='use account NAME')
                               help="Specify an account to use")
             parser.add_option('--container', dest='container', metavar='NAME',
                     help='use container NAME')
                               help="Specify a container to use")
         def main(self):
             self.config.override('storage_account', self.options.account)
             self.config.override('storage_container', self.options.container)
         def progress(self, message):
             """Return a generator function to be used for progress tracking"""
             MESSAGE_LENGTH = 25
             MAX_PROGRESS_LENGTH = 32
             def progress_gen(n):
                 msg = message.ljust(MESSAGE_LENGTH)
                 width = min(n, MAX_PROGRESS_LENGTH)
                 hide = self.config.get('global', 'silent') or (n < 2)
                 for i in progress.bar(range(n), msg, width, hide):
                     yield
                 yield
             # Use the more efficient Pithos client if available
             if 'pithos' in self.config.get('apis').split():
                 self.client = clients.PithosClient(self.config)
             return progress_gen
         def main(self):
             if self.options.account is not None:
                 self.client.account = self.options.account
             if self.options.container is not None:
                 self.client.container = self.options.container
     @command(api='storage')
     class store_create(object):
         """create a container"""
         """Create a container"""
         def update_parser(cls, parser):
             parser.add_option('--account', dest='account', metavar='ACCOUNT',
                     help='use account ACCOUNT')
             parser.add_option('--account', dest='account', metavar='NAME',
                               help="Specify an account to use")
         def main(self, container):
             self.config.override('storage_account', self.options.account)
             if self.options.account:
                 self.client.account = self.options.account
             self.client.create_container(container)
     @command(api='storage')
     class store_container(store_command):
         """get container info"""
     class store_container(object):
         """Get container info"""
         def main(self):
             store_command.main(self)
             reply = self.client.get_container_meta()
         def update_parser(cls, parser):
             parser.add_option('--account', dest='account', metavar='NAME',
                               help="Specify an account to use")
         def main(self, container):
             if self.options.account:
                 self.client.account = self.options.account
             reply = self.client.get_container_meta(container)
             print_dict(reply)
     @command(api='storage')
     class store_upload(store_command):
         """upload a file"""
         """Upload a file"""
         def main(self, path, remote_path=None):
             store_command.main(self)
             super(store_upload, self).main()
             if remote_path is None:
                 remote_path = basename(path)
             with open(path) as f:
                 self.client.create_object(remote_path, f)
                 hash_cb = self.progress('Calculating block hashes')
                 upload_cb = self.progress('Uploading blocks')
                 self.client.create_object(remote_path, f, hash_cb=hash_cb,
                                           upload_cb=upload_cb)
     @command(api='storage')
     class store_download(store_command):
         """download a file"""
         def main(self, remote_path, local_path):
             store_command.main(self)
             f = self.client.get_object(remote_path)
         """Download a file"""
         def main(self, remote_path, local_path='-'):
             super(store_download, self).main()
             f, size = self.client.get_object(remote_path)
             out = open(local_path, 'w') if local_path != '-' else stdout
             block = 4096
             data = f.read(block)
             blocksize = 4 * 1024**2
             nblocks = 1 + (size - 1) // blocksize
             cb = self.progress('Downloading blocks') if local_path != '-' else None
             if cb:
                 gen = cb(nblocks)
                 gen.next()
             data = f.read(blocksize)
             while data:
                 out.write(data)
                 data = f.read(block)
                 data = f.read(blocksize)
                 if cb:
                     gen.next()
     @command(api='storage')
     class store_delete(store_command):
         """delete a file"""
         """Delete a file"""
         def main(self, path):
             store_command.main(self)
-...
                 puts(columns([name, 12], [cls.description, 60]))
     def add_handler(name, level, prefix=''):
         h = logging.StreamHandler()
         fmt = logging.Formatter(prefix + '%(message)s')
         h.setFormatter(fmt)
         logger = logging.getLogger(name)
         logger.addHandler(h)
         logger.setLevel(level)
     def main():
         parser = OptionParser(add_help_option=False)
         parser.usage = '%prog <group> <command> [options]'
-...
                           help="Show this help message and exit")
         parser.add_option('--config', dest='config', metavar='PATH',
                           help="Specify the path to the configuration file")
         parser.add_option('-d', '--debug', dest='debug', action='store_true',
                           default=False,
                           help="Include debug output")
         parser.add_option('-i', '--include', dest='include', action='store_true',
                           default=False,
                           help="Include protocol headers in the output")
-...
             print "kamaki %s" % kamaki.__version__
             exit(0)
         if args.contains(['-s', '--silent']):
             level = logging.CRITICAL
         elif args.contains(['-v', '--verbose']):
             level = logging.INFO
         else:
             level = logging.WARNING
         logging.basicConfig(level=level, format='%(message)s')
         if '--config' in args:
             config_path = args.grouped['--config'].get(0)
         else:
-...
         if hasattr(cmd, 'update_parser'):
             cmd.update_parser(parser)
         if args.contains(['-h', '--help']):
         options, arguments = parser.parse_args(argv)
         if options.help:
             parser.print_help()
             exit(0)
         cmd.options, cmd.args = parser.parse_args(argv)
         if options.silent:
             add_handler('', logging.CRITICAL)
         elif options.debug:
             add_handler('requests', logging.INFO, prefix='* ')
             add_handler('clients.send', logging.DEBUG, prefix='> ')
             add_handler('clients.recv', logging.DEBUG, prefix='< ')
         elif options.verbose:
             add_handler('requests', logging.INFO, prefix='* ')
             add_handler('clients.send', logging.INFO, prefix='> ')
             add_handler('clients.recv', logging.INFO, prefix='< ')
         elif options.include:
             add_handler('clients.recv', logging.INFO)
         else:
             add_handler('', logging.WARNING)
         api = cmd.api
         if api == 'config':
             cmd.config = config
         elif api in ('compute', 'image', 'storage'):
             token = config.get(api, 'token') or config.get('gobal', 'token')
             url = config.get(api, 'url')
             client_cls = getattr(clients, api)
             kwargs = dict(base_url=url, token=token)
             # Special cases
             if api == 'compute' and config.getboolean(api, 'cyclades_extensions'):
                 client_cls = clients.cyclades
             elif api == 'storage':
                 kwargs['account'] = config.get(api, 'account')
                 kwargs['container'] = config.get(api, 'container')
                 if config.getboolean(api, 'pithos_extensions'):
                     client_cls = clients.pithos
             cmd.client = client_cls(**kwargs)
         if api in ('compute', 'cyclades'):
             url = config.get('compute', 'url')
             token = config.get('compute', 'token') or config.get('global', 'token')
             if config.getboolean('compute', 'cyclades_extensions'):
                 cmd.client = clients.cyclades(url, token)
             else:
                 cmd.client = clients.compute(url, token)
         elif api in ('storage', 'pithos'):
             url = config.get('storage', 'url')
             token = config.get('storage', 'token') or config.get('global', 'token')
             account = config.get('storage', 'account')
             container = config.get('storage', 'container')
             if config.getboolean('storage', 'pithos_extensions'):
                 cmd.client = clients.pithos(url, token, account, container)
             else:
                 cmd.client = clients.storage(url, token, account, container)
         elif api == 'image':
             url = config.get('image', 'url')
             token = config.get('image', 'token') or config.get('global', 'token')
             cmd.client = clients.image(url, token)
         cmd.options = options
         cmd.config = config
         try:
             ret = cmd.main(*args.grouped['_'][2:])
             ret = cmd.main(*arguments[3:])
             exit(ret)
         except TypeError as e:
             if e.args and e.args[0].startswith('main()'):
-...
                 exit(1)
             else:
                 raise
         except clients.ClientError, err:
             log.error('%s', err.message)
             log.info('%s', err.details)
         except clients.ClientError as err:
             if err.status == 404:
                 color = yellow
             elif 500 <= err.status < 600:
                 color = magenta
             else:
                 color = red
             puts_err(color(err.message))
             if err.details and (options.verbose or options.debug):
                 puts_err(err.details)
             exit(2)
         except ConnectionError as err:
             puts_err(red("Connection error"))
             exit(1)
     if __name__ == '__main__':

     # interpreted as representing official policies, either expressed
     # or implied, of GRNET S.A.
     import json
     import logging
     import requests
     from requests.auth import AuthBase
     sendlog = logging.getLogger('clients.send')
     recvlog = logging.getLogger('clients.recv')
     # Add a convenience json property to the responses
     def _json(self):
         try:
             return json.loads(self.content)
         except ValueError:
             raise ClientError("Invalid JSON reply", self.status_code)
     requests.Response.json = property(_json)
     # Add a convenience status property to the responses
     def _status(self):
         return requests.status_codes._codes[self.status_code][0].upper()
     requests.Response.status = property(_status)
     class XAuthTokenAuth(AuthBase):
         def __init__(self, token):
             self.token = token
         def __call__(self, r):
             r.headers['X-Auth-Token'] = self.token
             return r
     class ClientError(Exception):
         def __init__(self, message, status=0, details=''):
             self.message = message
             self.status = status
             self.details = details
         def __int__(self):
             return int(self.status)
         def __str__(self):
             r = self.message
             if self.status:
                 r += "\nHTTP Status: %d" % self.status
             if self.details:
                 r += "\nDetails: \n%s" % self.details
     class Client(object):
         def __init__(self, base_url, token, include=False, verbose=False):
             self.base_url = base_url
             self.auth = XAuthTokenAuth(token)
             self.include = include
             self.verbose = verbose
         def raise_for_status(self, r):
             if 400 <= r.status_code < 500:
                 message, sep, details = r.text.partition('\n')
             elif 500 <= r.status_code < 600:
                 message = '%d Server Error' % (r.status_code,)
                 details = r.text
             else:
                 message = '%d Unknown Error' % (r.status_code,)
                 details = r.text
             message = message or "HTTP Error %d" % (r.status_code,)
             raise ClientError(message, r.status_code, details)
         def request(self, method, path, **kwargs):
             raw = kwargs.pop('raw', False)
             success = kwargs.pop('success', 200)
             if 'json' in kwargs:
                 data = json.dumps(kwargs.pop('json'))
                 kwargs['data'] = data
                 headers = kwargs.setdefault('headers', {})
                 headers['content-type'] = 'application/json'
             url = self.base_url + path
             kwargs.setdefault('auth', self.auth)
             r = requests.request(method, url, **kwargs)
             req = r.request
             sendlog.info('%s %s', req.method, req.url)
             for key, val in req.headers.items():
                 sendlog.info('%s: %s', key, val)
             sendlog.info('')
             if req.data:
                 sendlog.info('%s', req.data)
             recvlog.info('%d %s', r.status_code, r.status)
             for key, val in r.headers.items():
                 recvlog.info('%s: %s', key, val)
             recvlog.info('')
             if not raw and r.text:
                 recvlog.debug(r.text)
             if success is not None:
                 # Success can either be an in or a collection
                 success = (success,) if isinstance(success, int) else success
                 if r.status_code not in success:
                     self.raise_for_status(r)
             return r
         def delete(self, path, **kwargs):
             return self.request('delete', path, **kwargs)
         def get(self, path, **kwargs):
             return self.request('get', path, **kwargs)
         def head(self, path, **kwargs):
             return self.request('head', path, **kwargs)
         def post(self, path, **kwargs):
             return self.request('post', path, **kwargs)
         def put(self, path, **kwargs):
             return self.request('put', path, **kwargs)
     from .compute import ComputeClient
     from .image import ImageClient
     from .storage import StorageClient
     from .cyclades import CycladesClient
     from .pithos import PithosClient
     from .compute import ComputeClient as compute
     from .image import ImageClient as image
     from .storage import StorageClient as storage
     from .cyclades import CycladesClient as cyclades
     from .pithos import PithosClient as pithos

     # interpreted as representing official policies, either expressed
     # or implied, of GRNET S.A.
     import json
     from . import Client, ClientError
     from . import ClientError
     from .http import HTTPClient
     class ComputeClient(HTTPClient):
     class ComputeClient(Client):
         """OpenStack Compute API 1.1 client"""
         @property
         def url(self):
             url = self.config.get('compute_url') or self.config.get('url')
             if not url:
                 raise ClientError('No URL was given')
             return url
         @property
         def token(self):
             token = self.config.get('compute_token') or self.config.get('token')
             if not token:
                 raise ClientError('No token was given')
             return token
         def raise_for_status(self, r):
             d = r.json
             key = d.keys()[0]
             val = d[key]
             message = '%s: %s' % (key, val.get('message', ''))
             details = val.get('details', '')
             raise ClientError(message, r.status_code, details)
         def list_servers(self, detail=False):
             """List servers, returned detailed output if detailed is True"""
             path = '/servers/detail' if detail else '/servers'
             reply = self.http_get(path)
             return reply['servers']['values']
             r = self.get(path, success=200)
             return r.json['servers']['values']
         def get_server_details(self, server_id):
             """Return detailed output on a server specified by its id"""
             path = '/servers/%d' % server_id
             reply = self.http_get(path)
             return reply['server']
             path = '/servers/%s' % (server_id,)
             r = self.get(path, success=200)
             return r.json['server']
         def create_server(self, name, flavor_id, image_id, personality=None):
             """Submit request to create a new server
-...
             The call returns a dictionary describing the newly created server.
             """
             req = {'name': name, 'flavorRef': flavor_id, 'imageRef': image_id}
             req = {'server': {'name': name,
                               'flavorRef': flavor_id,
                               'imageRef': image_id}}
             if personality:
                 req['personality'] = personality
             body = json.dumps({'server': req})
             reply = self.http_post('/servers', body)
             return reply['server']
             r = self.post('/servers', json=req, success=202)
             return r.json['server']
         def update_server_name(self, server_id, new_name):
             """Update the name of the server as reported by the API.
-...
             This call does not modify the hostname actually used by the server
             internally.
             """
             path = '/servers/%d' % server_id
             body = json.dumps({'server': {'name': new_name}})
             self.http_put(path, body)
             path = '/servers/%s' % (server_id,)
             req = {'server': {'name': new_name}}
             self.put(path, json=req, success=204)
         def delete_server(self, server_id):
             """Submit a deletion request for a server specified by id"""
             path = '/servers/%d' % server_id
             self.http_delete(path)
             path = '/servers/%s' % (server_id,)
             self.delete(path, success=204)
         def reboot_server(self, server_id, hard=False):
             """Submit a reboot request for a server specified by id"""
             path = '/servers/%d/action' % server_id
             type = 'HARD' if hard else 'SOFT'
             body = json.dumps({'reboot': {'type': type}})
             self.http_post(path, body)
             path = '/servers/%s/action' % (server_id,)
             type = 'HARD' if hard else 'SOFT'
             req = {'reboot': {'type': type}}
             self.post(path, json=req, success=202)
         def get_server_metadata(self, server_id, key=None):
             path = '/servers/%d/meta' % server_id
             path = '/servers/%s/meta' % (server_id,)
             if key:
                 path += '/%s' % key
             reply = self.http_get(path)
             return reply['meta'] if key else reply['metadata']['values']
             r = self.get(path, success=200)
             return r.json['meta'] if key else r.json['metadata']['values']
         def create_server_metadata(self, server_id, key, val):
             path = '/servers/%d/meta/%s' % (server_id, key)
             body = json.dumps({'meta': {key: val}})
             reply = self.http_put(path, body, success=201)
             return reply['meta']
             req = {'meta': {key: val}}
             r = self.put(path, json=req, success=201)
             return r.json['meta']
         def update_server_metadata(self, server_id, **metadata):
             path = '/servers/%d/meta' % server_id
             body = json.dumps({'metadata': metadata})
             reply = self.http_post(path, body, success=201)
             return reply['metadata']
             path = '/servers/%d/meta' % (server_id,)
             req = {'metadata': metadata}
             r = self.post(path, json=req, success=201)
             return r.json['metadata']
         def delete_server_metadata(self, server_id, key):
             path = '/servers/%d/meta/%s' % (server_id, key)
             reply = self.http_delete(path)
             self.delete(path, success=204)
         def list_flavors(self, detail=False):
             path = '/flavors/detail' if detail else '/flavors'
             reply = self.http_get(path)
             return reply['flavors']['values']
             r = self.get(path, success=200)
             return r.json['flavors']['values']
         def get_flavor_details(self, flavor_id):
             path = '/flavors/%d' % flavor_id
             reply = self.http_get(path)
             return reply['flavor']
             r = self.get(path, success=200)
             return r.json['flavor']
         def list_images(self, detail=False):
             path = '/images/detail' if detail else '/images'
             reply = self.http_get(path)
             return reply['images']['values']
             r = self.get(path, success=200)
             return r.json['images']['values']
         def get_image_details(self, image_id):
             path = '/images/%s' % image_id
             reply = self.http_get(path)
             return reply['image']
             path = '/images/%s' % (image_id,)
             r = self.get(path, success=200)
             return r.json['image']
         def delete_image(self, image_id):
             path = '/images/%s' % image_id
             self.http_delete(path)
             path = '/images/%s' % (image_id,)
             self.delete(path, success=204)
         def get_image_metadata(self, image_id, key=None):
             path = '/images/%s/meta' % image_id
             path = '/images/%s/meta' % (image_id,)
             if key:
                 path += '/%s' % key
             reply = self.http_get(path)
             return reply['meta'] if key else reply['metadata']['values']
             r = self.get(path, success=200)
             return r.json['meta'] if key else r.json['metadata']['values']
         def create_image_metadata(self, image_id, key, val):
             path = '/images/%s/meta/%s' % (image_id, key)
             body = json.dumps({'meta': {key: val}})
             reply = self.http_put(path, body, success=201)
             return reply['meta']
             req = {'meta': {key: val}}
             r = self.put(path, json=req, success=201)
             return r.json['meta']
         def update_image_metadata(self, image_id, **metadata):
             path = '/images/%s/meta' % image_id
             body = json.dumps({'metadata': metadata})
             reply = self.http_post(path, body, success=201)
             return reply['metadata']
             path = '/images/%s/meta' % (image_id,)
             req = {'metadata': metadata}
             r = self.post(path, json=req, success=201)
             return r.json['metadata']
         def delete_image_metadata(self, image_id, key):
             path = '/images/%s/meta/%s' % (image_id, key)
             self.http_delete(path)
             self.delete(path, success=204)

     # interpreted as representing official policies, either expressed
     # or implied, of GRNET S.A.
     import json
     from .compute import ComputeClient
-...
         def start_server(self, server_id):
             """Submit a startup request for a server specified by id"""
             path = '/servers/%d/action' % server_id
             body = json.dumps({'start': {}})
             self.http_post(path, body)
             path = '/servers/%s/action' % (server_id,)
             req = {'start': {}}
             self.post(path, json=req, success=202)
         def shutdown_server(self, server_id):
             """Submit a shutdown request for a server specified by id"""
             path = '/servers/%d/action' % server_id
             body = json.dumps({'shutdown': {}})
             self.http_post(path, body)
             path = '/servers/%s/action' % (server_id,)
             req = {'shutdown': {}}
             self.post(path, json=req, success=202)
         def get_server_console(self, server_id):
             """Get a VNC connection to the console of a server specified by id"""
             path = '/servers/%d/action' % server_id
             body = json.dumps({'console': {'type': 'vnc'}})
             reply = self.http_post(path, body, success=200)
             return reply['console']
             path = '/servers/%s/action' % (server_id,)
             req = {'console': {'type': 'vnc'}}
             r = self.post(path, json=req, success=200)
             return r.json['console']
         def set_firewall_profile(self, server_id, profile):
             """Set the firewall profile for the public interface of a server
-...
             The server is specified by id, the profile argument
             is one of (ENABLED, DISABLED, PROTECTED).
             """
             path = '/servers/%d/action' % server_id
             body = json.dumps({'firewallProfile': {'profile': profile}})
             self.http_post(path, body)
             path = '/servers/%s/action' % (server_id,)
             req = {'firewallProfile': {'profile': profile}}
             self.post(path, json=req, success=202)
         def list_server_addresses(self, server_id, network=None):
             path = '/servers/%d/ips' % server_id
             path = '/servers/%s/ips' % (server_id,)
             if network:
                 path += '/%s' % network
             reply = self.http_get(path)
             return [reply['network']] if network else reply['addresses']['values']
             r = self.get(path, success=200)
             if network:
                 return [r.json['network']]
             else:
                 return r.json['addresses']['values']
         def get_server_stats(self, server_id):
             path = '/servers/%d/stats' % server_id
             reply = self.http_get(path)
             return reply['stats']
             path = '/servers/%s/stats' % (server_id,)
             r = self.get(path, success=200)
             return r.json['stats']
         def list_networks(self, detail=False):
             path = '/networks/detail' if detail else '/networks'
             reply = self.http_get(path)
             return reply['networks']['values']
             r = self.get(path, success=200)
             return r.json['networks']['values']
         def create_network(self, name):
             body = json.dumps({'network': {'name': name}})
             reply = self.http_post('/networks', body)
             return reply['network']
             req = {'network': {'name': name}}
             r = self.post('/networks', json=req, success=202)
             return r.json['network']
         def get_network_details(self, network_id):
             path = '/networks/%s' % network_id
             reply = self.http_get(path)
             return reply['network']
             path = '/networks/%s' % (network_id,)
             r = self.get(path, success=200)
             return r.json['network']
         def update_network_name(self, network_id, new_name):
             path = '/networks/%s' % network_id
             body = json.dumps({'network': {'name': new_name}})
             self.http_put(path, body)
             path = '/networks/%s' % (network_id,)
             req = {'network': {'name': new_name}}
             self.put(path, json=req, success=204)
         def delete_network(self, network_id):
             path = '/networks/%s' % network_id
             self.http_delete(path)
             path = '/networks/%s' % (network_id,)
             self.delete(path, success=204)
         def connect_server(self, server_id, network_id):
             path = '/networks/%s/action' % network_id
             body = json.dumps({'add': {'serverRef': server_id}})
             self.http_post(path, body)
             path = '/networks/%s/action' % (network_id,)
             req = {'add': {'serverRef': server_id}}
             self.post(path, json=req, success=202)
         def disconnect_server(self, server_id, network_id):
             path = '/networks/%s/action' % network_id
             body = json.dumps({'remove': {'serverRef': server_id}})
             self.http_post(path, body)
             path = '/networks/%s/action' % (network_id,)
             req = {'remove': {'serverRef': server_id}}
             self.post(path, json=req, success=202)

     # or implied, of GRNET S.A.
     import hashlib
     import json
     import os
     from . import ClientError
     from .storage import StorageClient
     from ..utils import OrderedDict
     from .storage import StorageClient
     def pithos_hash(block, blockhash):
         h = hashlib.new(blockhash)
         h.update(block.rstrip('\x00'))
         return h.hexdigest()
     class PithosClient(StorageClient):
         """GRNet Pithos API client"""
         def put_block(self, data, hash):
             path = '/%s/%s?update' % (self.account, self.container)
             path = '/%s/%s' % (self.account, self.container)
             params = {'update': ''}
             headers = {'Content-Type': 'application/octet-stream',
                        'Content-Length': len(data)}
             resp, reply = self.raw_http_cmd('POST', path, data, headers,
                                             success=202)
             assert reply.strip() == hash, 'Local hash does not match server'
                        'Content-Length': str(len(data))}
             r = self.post(path, params=params, data=data, headers=headers,
                           success=202)
             assert r.text.strip() == hash, 'Local hash does not match server'
         def create_object(self, object, f):
             meta = self.get_container_meta()
         def create_object(self, object, f, hash_cb=None, upload_cb=None):
             """Create an object by uploading only the missing blocks
             hash_cb is a generator function taking the total number of blocks to
             be hashed as an argument. Its next() will be called every time a block
             is hashed.
             upload_cb is a generator function with the same properties that is
             called every time a block is uploaded.
             """
             self.assert_container()
             meta = self.get_container_meta(self.container)
             blocksize = int(meta['block-size'])
             blockhash = meta['block-hash']
             size = 0
             file_size = os.fstat(f.fileno()).st_size
             nblocks = 1 + (file_size - 1) // blocksize
             hashes = OrderedDict()
             data = f.read(blocksize)
             while data:
                 bytes = len(data)
                 h = hashlib.new(blockhash)
                 h.update(data.rstrip('\x00'))
                 hash = h.hexdigest()
             size = 0
             if hash_cb:
                 hash_gen = hash_cb(nblocks)
                 hash_gen.next()
             for i in range(nblocks):
                 block = f.read(blocksize)
                 bytes = len(block)
                 hash = pithos_hash(block, blockhash)
                 hashes[hash] = (size, bytes)
                 size += bytes
                 data = f.read(blocksize)
                 if hash_cb:
                     hash_gen.next()
             assert size == file_size
             path = '/%s/%s/%s?hashmap&format=json' % (self.account, self.container,
                                                       object)
             path = '/%s/%s/%s' % (self.account, self.container, object)
             params = {'hashmap': '', 'format': 'json'}
             hashmap = dict(bytes=size, hashes=hashes.keys())
             req = json.dumps(hashmap)
             resp, reply = self.raw_http_cmd('PUT', path, req, success=None)
             if resp.status not in (201, 409):
                 raise ClientError('Invalid response from the server')
             r = self.put(path, params=params, json=hashmap, success=(201, 409))
             if resp.status == 201:
             if r.status_code == 201:
                 return
             missing = json.loads(reply)
             missing = r.json
             if upload_cb:
                 upload_gen = upload_cb(len(missing))
                 upload_gen.next()
             for hash in missing:
                 offset, bytes = hashes[hash]
                 f.seek(offset)
                 data = f.read(bytes)
                 self.put_block(data, hash)
                 if upload_cb:
                     upload_gen.next()
             self.http_put(path, req, success=201)
             self.put(path, params=params, json=hashmap, success=201)

     # interpreted as representing official policies, either expressed
     # or implied, of GRNET S.A.
     from . import ClientError
     from .http import HTTPClient
     from . import Client, ClientError
     class StorageClient(HTTPClient):
     class StorageClient(Client):
         """OpenStack Object Storage API 1.0 client"""
         @property
         def url(self):
             url = self.config.get('storage_url') or self.config.get('url')
             if not url:
                 raise ClientError('No URL was given')
             return url
         @property
         def token(self):
             token = self.config.get('storage_token') or self.config.get('token')
             if not token:
                 raise ClientError('No token was given')
             return token
         def __init__(self, base_url, token, account=None, container=None):
             super(StorageClient, self).__init__(base_url, token)
             self.account = account
             self.container = container
         @property
         def account(self):
             account = self.config.get('storage_account')
             if not account:
                 raise ClientError('No account was given')
             return account
         def assert_account(self):
             if not self.account:
                 raise ClientError("Please provide an account")
         @property
         def container(self):
             container = self.config.get('storage_container')
             if not container:
                 raise ClientError('No container was given')
             return container
         def assert_container(self):
             self.assert_account()
             if not self.container:
                 raise ClientError("Please provide a container")
         def create_container(self, container):
             self.assert_account()
             path = '/%s/%s' % (self.account, container)
             self.http_put(path, success=201)
             r = self.put(path, success=(201, 202))
             if r.status_code == 202:
                 raise ClientError("Container already exists")
         def get_container_meta(self):
             path = '/%s/%s' % (self.account, self.container)
             resp, reply = self.raw_http_cmd('HEAD', path, success=204)
         def get_container_meta(self, container):
             self.assert_account()
             path = '/%s/%s' % (self.account, container)
             r = self.head(path, success=(204, 404))
             if r.status_code == 404:
                 raise ClientError("Container does not exist", r.status_code)
             reply = {}
             prefix = 'x-container-'
             for key, val in resp.getheaders():
             for key, val in r.headers.items():
                 key = key.lower()
                 if key.startswith(prefix):
                     reply[key[len(prefix):]] = val
             return reply
         def create_object(self, object, f):
         def create_object(self, object, f, hash_cb=None, upload_cb=None):
             # This is a naive implementation, it loads the whole file in memory
             self.assert_container()
             path = '/%s/%s/%s' % (self.account, self.container, object)
             data = f.read()
             self.http_put(path, data, success=201)
             self.put(path, data=data, success=201)
         def get_object(self, object):
             self.assert_container()
             path = '/%s/%s/%s' % (self.account, self.container, object)
             resp, reply = self.raw_http_cmd('GET', path, success=200,
                     skip_read=True)
             return resp.fp
             r = self.get(path, raw=True)
             size = int(r.headers['content-length'])
             return r.raw, size
         def delete_object(self, object):
             self.assert_container()
             path = '/%s/%s/%s' % (self.account, self.container, object)
             self.http_delete(path)
             self.delete(path, success=204)

b/setup.py
51	51	'console_scripts': ['kamaki = kamaki.cli:main']
52	52	},
53	53	install_requires=[
	54	'requests>=0.10.2',
54	55	'clint>=0.3'
55	56	]
56	57	)

Also available in: Unified diff

Synnefo » ./kamaki

Revision 6a0b1658