Synnefo » ./kamaki

# 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.

__version__ = '0.3'

class ComputeClient(Client):

class ImagesClient(Client):

    def list_public(self, detail=False):

        path = '/images/detail' if detail else '/images/'

        return self._get(path)

# 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.

import json

import logging

import os

log = logging.getLogger('kamaki.config')

class ConfigError(Exception):

    pass

class Config(object):

    def __init__(self, path, env, defaults):

        self.path = os.environ.get(env, path)

        self.defaults = defaults

        d = self.read()

        for key, val in d.items():

            if key not in defaults:

                log.warning('Ignoring unknown config key "%s".', key)

        self.d = d

        self.overrides = {}

    def read(self):

        if not os.path.exists(self.path):

            return {}

        with open(self.path) as f:

            data = f.read()

        try:

            d = json.loads(data)

            assert isinstance(d, dict)

            return d

        except (ValueError, AssertionError):

            msg = '"%s" does not look like a kamaki config file.' % self.path

            raise ConfigError(msg)

    def write(self):

        self.read()     # Make sure we don't overwrite anything wrong

        with open(self.path, 'w') as f:

            data = json.dumps(self.d, indent=True)

            f.write(data)

    def items(self):

        for key, val in self.defaults.items():

            yield key, self.get(key)

    def get(self, key):

        if key in self.overrides:

            return self.overrides[key]

        if key in self.d:

            return self.d[key]

        return self.defaults.get(key)

    def set(self, key, val):

        if key not in self.defaults:

            log.warning('Ignoring unknown config key "%s".', key)

            return

        self.d[key] = val

        self.write()

    def delete(self, key):

        if key not in self.defaults:

            log.warning('Ignoring unknown config key "%s".', key)

            return

        self.d.pop(key, None)

        self.write()

    def override(self, key, val):

        assert key in self.defaults

        if val is not None:

            self.overrides[key] = val

"""

To add a command create a new class and add a 'command' decorator. The class

must have a 'main' method which will contain the code to be executed.

Optionally a command can implement an 'update_parser' class method in order

to add command line arguments, or modify the OptionParser in any way.

The name of the class is important and it will determine the name and grouping

of the command. This behavior can be overriden with the 'group' and 'name'

decorator arguments:

    @command(api='nova')

    class server_list(object):

        # This command will be named 'list' under group 'server'

        ...

    @command(api='nova', name='ls')

    class server_list(object):

        # This command will be named 'ls' under group 'server'

        ...

The docstring of a command class will be used as the command description in

help messages, unless overriden with the 'description' decorator argument.

The syntax of a command will be generated dynamically based on the signature

of the 'main' method, unless overriden with the 'syntax' decorator argument:

    def main(self, server_id, network=None):

        # This syntax of this command will be: '<server id> [network]'

        ...

The order of commands is important, it will be preserved in the help output.

"""

from client import ComputeClient, ImagesClient, ClientError

from config import Config, ConfigError

from utils import OrderedDict, print_addresses, print_dict, print_items

# Path to the file that stores the configuration

CONFIG_PATH = os.path.expanduser('~/.kamakirc')

# Name of a shell variable to bypass the CONFIG_PATH value

CONFIG_ENV = 'KAMAKI_CONFIG'

# The defaults also determine the allowed keys

CONFIG_DEFAULTS = {

    'apis': 'nova synnefo glance plankton',

    'token': '',

    'compute_url': 'https://okeanos.grnet.gr/api/v1',

    'images_url': 'https://okeanos.grnet.gr/plankton',

}

_commands = OrderedDict()

def command(api=None, group=None, name=None, description=None, syntax=None):

    """Class decorator that registers a class as a CLI command."""

    def decorator(cls):

        grp, sep, cmd = cls.__name__.partition('_')

        if not sep:

            grp, cmd = None, cls.__name__

        cls.api = api

        cls.group = group or grp

        cls.name = name or cmd

        cls.description = description or cls.__doc__

        cls.syntax = syntax

        if cls.syntax is None:

            # Generate a syntax string based on main's arguments

            spec = inspect.getargspec(cls.main.im_func)

            args = spec.args[1:]

            n = len(args) - len(spec.defaults or ())

            required = ' '.join('<%s>' % x.replace('_', ' ') for x in args[:n])

            optional = ' '.join('[%s]' % x.replace('_', ' ') for x in args[n:])

            cls.syntax = ' '.join(x for x in [required, optional] if x)

        if cls.group not in _commands:

            _commands[cls.group] = OrderedDict()

        _commands[cls.group][cls.name] = cls

        return cls

    return decorator

@command()

class config_list(object):

    """list configuration options"""

    def main(self):

        for key, val in sorted(self.config.items()):

            print '%s=%s' % (key, val)

@command()

class config_get(object):

    """get a configuration option"""

    def main(self, key):

        val = self.config.get(key)

        if val is not None:

            print val

@command()

class config_set(object):

    """set a configuration option"""

    def main(self, key, val):

        self.config.set(key, val)

@command()

class config_del(object):

    """delete a configuration option"""

    def main(self, key):

        self.config.delete(key)

@command(api='nova')

class server_list(object):

    """list servers"""

    @classmethod

    def update_parser(cls, parser):

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

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

        servers = self.client.list_servers(self.options.detail)

        print_items(servers, self.options.detail)

@command(api='nova')

class server_info(object):

    """get server details"""

@command(api='nova')

class server_create(object):

    """create server"""

    @classmethod

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

        parser.epilog = "If missing, optional personality values will be " \

                "filled based on the file at PATH if missing."

    def main(self, name, flavor_id, image_id):

        for personality in self.options.personalities:

                return 1

                return 1

        reply = self.client.create_server(name, int(flavor_id), image_id,

                personalities)

@command(api='nova')

class server_rename(object):

    """update server name"""

@command(api='nova')

class server_delete(object):

    """delete server"""

@command(api='nova')

class server_reboot(object):

    """reboot server"""

    @classmethod

    def update_parser(cls, parser):

        parser.add_option('-f', dest='hard', action='store_true',

                default=False, help='perform a hard reboot')

        self.client.reboot_server(int(server_id), self.options.hard)

@command(api='synnefo')

class server_start(object):

    """start server"""

@command(api='synnefo')

class server_shutdown(object):

    """shutdown server"""

@command(api='synnefo')

class server_console(object):

    """get a VNC console"""

@command(api='synnefo')

class server_firewall(object):

    """set the firewall profile"""

@command(api='synnefo')

class server_addr(object):

    """list server addresses"""

@command(api='nova')

class server_meta(object):

    """get server metadata"""

@command(api='nova')

class server_addmeta(object):

    """add server metadata"""

@command(api='nova')

class server_setmeta(object):

    """update server metadata"""

@command(api='nova')

class server_delmeta(object):

    """delete server metadata"""

@command(api='synnefo')

class server_stats(object):

    """get server statistics"""

@command(api='nova')

class flavor_list(object):

    """list flavors"""

    @classmethod

    def update_parser(cls, parser):

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

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

        flavors = self.client.list_flavors(self.options.detail)

        print_items(flavors, self.options.detail)

@command(api='nova')

class flavor_info(object):

    """get flavor details"""

@command(api='nova')

class image_list(object):

    """list images"""

    @classmethod

    def update_parser(cls, parser):

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

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

        images = self.client.list_images(self.options.detail)

        print_items(images, self.options.detail)

@command(api='nova')

class image_info(object):

    """get image details"""

        image = self.client.get_image_details(image_id)

@command(api='nova')

class image_create(object):

    """create image"""

@command(api='nova')

class image_delete(object):

    """delete image"""

        self.client.delete_image(image_id)

@command(api='nova')

class image_meta(object):

    """get image metadata"""

        reply = self.client.get_image_metadata(image_id, key)

@command(api='nova')

class image_addmeta(object):

    """add image metadata"""

        reply = self.client.create_image_metadata(image_id, key, val)

@command(api='nova')

class image_setmeta(object):

    """update image metadata"""

        reply = self.client.update_image_metadata(image_id, **metadata)

@command(api='nova')

class image_delmeta(object):

    """delete image metadata"""

        self.client.delete_image_metadata(image_id, key)

@command(api='synnefo')

class network_list(object):

    """list networks"""

    @classmethod

    def update_parser(cls, parser):

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

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

        networks = self.client.list_networks(self.options.detail)

        print_items(networks, self.options.detail)

@command(api='synnefo')

class network_create(object):

    """create a network"""

@command(api='synnefo')

class network_info(object):

    """get network details"""

@command(api='synnefo')

class network_rename(object):

    """update network name"""

    def main(self, network_id, new_name):

        self.client.update_network_name(network_id, new_name)

@command(api='synnefo')

class network_delete(object):

    """delete a network"""

@command(api='synnefo')

class network_connect(object):

    """connect a server to a network"""

@command(api='synnefo')

class network_disconnect(object):

    """disconnect a server from a network"""

@command(api='glance')

class glance_list(object):

    """list images"""

    def main(self):

        images = self.client.list_public()

        print images

def print_groups(groups):

    print

    print 'Groups:'

    for group in groups:

        print '  %s' % group

def print_commands(group, commands):

    for name, cls in _commands[group].items():

        if name in commands:

            print '  %s %s' % (name.ljust(10), cls.description)

    parser = OptionParser(add_help_option=False)

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

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

            default=False, help='show this help message and exit')

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

            help='API to use (can be used multiple times)')

    parser.add_option('--compute-url', dest='compute_url', metavar='URL',

            help='URL for the compute API')

    parser.add_option('--images-url', dest='images_url', metavar='URL',

            help='URL for the images API')

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

            help='use token TOKEN')

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

            help='use verbose output')

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

            help='use debug output')

    # Do a preliminary parsing, ignore any errors since we will print help

    # anyway if we don't reach the main parsing.

    _error = parser.error

    parser.error = lambda msg: None

    options, args = parser.parse_args(sys.argv)

    parser.error = _error

    if options.debug:

        log.setLevel(logging.DEBUG)

    elif options.verbose:

        log.setLevel(logging.INFO)

    else:

        log.setLevel(logging.WARNING)

    try:

        config = Config(CONFIG_PATH, CONFIG_ENV, CONFIG_DEFAULTS)

    except ConfigError, e:

        log.error('%s', e.args[0])

        return 1

    for key in CONFIG_DEFAULTS:

        config.override(key, getattr(options, key))

    apis = config.get('apis').split()

    # Find available groups based on the given APIs

    available_groups = []

    for group, group_commands in _commands.items():

        for name, cls in group_commands.items():

            if cls.api is None or cls.api in apis:

                available_groups.append(group)

                break

    if len(args) < 2:

        parser.print_help()

        print_groups(available_groups)

        return 0

    group = args[1]

    if group not in available_groups:

        parser.print_help()

        print_groups(available_groups)

        return 1

    # Find available commands based on the given APIs

    available_commands = []

    for name, cls in _commands[group].items():

        if cls.api is None or cls.api in apis:

            available_commands.append(name)

            continue

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

    if len(args) < 3:

        parser.print_help()

        print_commands(group, available_commands)

        return 0

    name = args[2]

    if name not in available_commands:

        parser.print_help()

        print_commands(group, available_commands)

        return 1

    cls = _commands[group][name]

    cls.config = config

    syntax = '%s [options]' % cls.syntax if cls.syntax else '[options]'

    parser.usage = '%%prog %s %s %s' % (group, name, syntax)

    parser.epilog = ''

    if hasattr(cls, 'update_parser'):

        cls.update_parser(parser)

    options, args = parser.parse_args(sys.argv)

    if options.help:

        parser.print_help()

        return 0

    cmd = cls()

    cmd.config = config

    cmd.options = options

    if cmd.api in ('nova', 'synnefo'):

        url = config.get('compute_url')

        token = config.get('token')

        cmd.client = ComputeClient(url, token)

    elif cmd.api in ('glance', 'plankton'):

        url = config.get('images_url')

        token = config.get('token')

        cmd.client = ImagesClient(url, token)

        return cmd.main(*args[3:])

    except TypeError:

        parser.print_help()

        return 1

        return 2

    err = main() or 0

    sys.exit(err)

# 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.

class OrderedDict(dict):

    """An ordered dict implementation for Python versions prior to 2.7"""

    def __init__(self):

        dict.__init__(self)

        self._keys = []

    def __delitem__(self, key):

        dict.__delitem__(self, key)

        self._keys.remove(key)

    def __iter__(self):

        return iter(self._keys)

    def __repr__(self):

        return repr(self.items())

    def __setitem__(self, key, value):

        if key not in self:

            self._keys.append(key)

        dict.__setitem__(self, key, value)

    def keys(self):

        return self._keys

    def iteritems(self):

        for key in self._keys:

            yield key, self[key]

    def items(self):

        return list(self.iteritems())

def print_addresses(addresses, margin):

    for address in addresses:

        if address['id'] == 'public':

            net = 'public'

        else:

            net = '%s/%s' % (address['id'], address['name'])

        print '%s:' % net.rjust(margin + 4)

        ether = address.get('mac', None)

        if ether:

            print '%s: %s' % ('ether'.rjust(margin + 8), ether)

        firewall = address.get('firewallProfile', None)

        if firewall:

            print '%s: %s' % ('firewall'.rjust(margin + 8), firewall)

        for ip in address.get('values', []):

            key = 'inet' if ip['version'] == 4 else 'inet6'

            print '%s: %s' % (key.rjust(margin + 8), ip['addr'])

def print_metadata(metadata, margin):

    print '%s:' % 'metadata'.rjust(margin)

    for key, val in metadata.get('values', {}).items():

        print '%s: %s' % (key.rjust(margin + 4), val)

def print_dict(d, exclude=()):

    if not d:

        return

    margin = max(len(key) for key in d) + 1

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

        if key in exclude:

            continue

        if key == 'addresses':

            print '%s:' % 'addresses'.rjust(margin)

            print_addresses(val.get('values', []), margin)

            continue

        elif key == 'metadata':

            print_metadata(val, margin)

            continue

        elif key == 'servers':

            val = ', '.join(str(x) for x in val['values'])

        print '%s: %s' % (key.rjust(margin), val)

def print_items(items, detail=False):

    for item in items:

        print '%s %s' % (item['id'], item.get('name', ''))

        if detail:

            print_dict(item, exclude=('id', 'name'))

            print