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 httplib import HTTPConnection, HTTPSConnection

from optparse import OptionParser

from os.path import basename

from sys import argv, exit

from urlparse import urlparse

import json

DEFAULT_API_URL = 'http://127.0.0.1:8000/api/v1.1'

DEFAULT_TOKEN = '46e427d657b20defe352804f0eb6f8a2'

MARGIN = 14

commands = {}

def command_name(name):

    def decorator(cls):

        commands[name] = cls

        return cls

    return decorator

def print_addresses(networks):

    for i, net in enumerate(networks):

        key = 'addresses:'.rjust(MARGIN + 1) if i == 0 else ' ' * (MARGIN + 1)

        addr = ''

        if 'values' in net:

            addr = '[%s]' % ' '.join(ip['addr'] for ip in net['values'])

        val = '%s/%s %s %s' % (net['id'], net['name'], net['mac'], addr)

        if 'firewallProfile' in net:

            val += ' - %s' % net['firewallProfile']

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

def print_dict(d, show_empty=True):

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

        if key == 'metadata':

            val = ', '.join('%s="%s"' % x for x in val['values'].items())

        elif key == 'addresses':

            print_addresses(val['values'])

            continue

        elif key == 'servers':

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

        if val or show_empty:

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

class Command(object):

    def __init__(self, argv):

        parser = OptionParser()

        parser.add_option('--apiurl',

                            dest='apiurl',

                            metavar='URL',

                            default=DEFAULT_API_URL,

                            help='use api API')

        parser.add_option('--token',

                            dest='token',

                            metavar='TOKEN',

                            default=DEFAULT_TOKEN,

                            help='use user token TOKEN')

        parser.add_option('-v',

                            action='store_true',

                            dest='verbose',

                            default=False,

                            help='use verbose 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.execute(*args)

    def add_options(self, parser):

        pass

    def execute(self, *args):

        pass

    def http_cmd(self, method, path, body=None, expected_status=200):

        p = urlparse(self.apiurl)

        if p.scheme == 'https':

            conn = HTTPSConnection(p.netloc)

        else:

            conn = HTTPConnection(p.netloc)

        kwargs = {}

        kwargs['headers'] = {'X-Auth-Token': self.token}

        if body:

            kwargs['headers']['Content-Type'] = 'application/json'

            kwargs['body'] = body

        conn.request(method, p.path + path, **kwargs)

        resp = conn.getresponse()

        if self.verbose:

            print '%d %s' % (resp.status, resp.reason)

            for key, val in resp.getheaders():

                print '%s: %s' % (key.capitalize(), val)

            print

        buf = resp.read() or '{}'

        try:

            reply = json.loads(buf)

        except ValueError:

            print 'Invalid response from the server.'

            if self.verbose:

                print buf

            exit(1)

        # If the response status is not the expected one,

        # assume an error has occured and treat the body

        # as a cloudfault.

        if resp.status != expected_status:

            if len(reply) == 1:

                key = reply.keys()[0]

                val = reply[key]

                print '%s: %s' % (key, val.get('message', ''))

                if self.verbose:

                    print val.get('details', '')

            else:

                print 'Invalid response from the server.'

            exit(1)

        return reply

    def http_get(self, path, expected_status=200):

        return self.http_cmd('GET', path, None, expected_status)

    def http_post(self, path, body, expected_status=202):

        return self.http_cmd('POST', path, body, expected_status)

    def http_put(self, path, body, expected_status=204):

        return self.http_cmd('PUT', path, body, expected_status)

    def http_delete(self, path, expected_status=204):

        return self.http_cmd('DELETE', path, None, expected_status)

@command_name('ls')

class ListServers(Command):

    description = 'list servers'

    def add_options(self, parser):

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

                            help='show detailed output')

        parser.add_option('-a', action='store_true', dest='show_empty', default=False,

                            help='include empty values')

    def execute(self):

        path = '/servers/detail' if self.detail else '/servers'

        reply = self.http_get(path)

        for server in reply['servers']['values']:

            id = server.pop('id')

            name = server.pop('name')

            if self.detail:

                print '%d %s' % (id, name)

                print_dict(server, self.show_empty)

                print

            else:

                print '%3d %s' % (id, name)

@command_name('info')

class GetServerDetails(Command):

    description = 'get server details'

    syntax = '<server id>'

    def add_options(self, parser):

        parser.add_option('-a', action='store_true', dest='show_empty', default=False,

                            help='include empty values')

    def execute(self, server_id):

        path = '/servers/%d' % int(server_id)

        reply = self.http_get(path)

        server = reply['server']

        server.pop('id')

        print_dict(server, self.show_empty)

@command_name('create')

class CreateServer(Command):

    description = 'create server'

    syntax = '<server name>'

    def add_options(self, parser):

        parser.add_option('-f', dest='flavor', metavar='FLAVOR_ID', default=1,

                            help='use flavor FLAVOR_ID')

        parser.add_option('-i', dest='image', metavar='IMAGE_ID', default=1,

                            help='use image IMAGE_ID')

    def execute(self, name):

        server = {

            'name': name,

            'flavorRef': self.flavor,

            'imageRef': self.image}

        body = json.dumps({'server': server})

        reply = self.http_post('/servers', body)

        server = reply['server']

        print_dict(server)

@command_name('rename')

class UpdateServerName(Command):

    description = 'update server name'

    syntax = '<server id> <new name>'

    def execute(self, server_id, name):

        path = '/servers/%d' % int(server_id)

        body = json.dumps({'server': {'name': name}})

        self.http_put(path, body)

@command_name('delete')

class DeleteServer(Command):

    description = 'delete server'

    syntax = '<server id>'

    def execute(self, server_id):

        path = '/servers/%d' % int(server_id)

        self.http_delete(path)

@command_name('reboot')

class RebootServer(Command):

    description = 'reboot server'

    syntax = '<server id>'

    def add_options(self, parser):

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

                            help='perform a hard reboot')

    def execute(self, server_id):

        path = '/servers/%d/action' % int(server_id)

        type = 'HARD' if self.hard else 'SOFT'

        body = json.dumps({'reboot': {'type': type}})

        self.http_post(path, body)

@command_name('start')

class StartServer(Command):

    description = 'start server'

    syntax = '<server id>'

    def execute(self, server_id):

        path = '/servers/%d/action' % int(server_id)

        body = json.dumps({'start': {}})

        self.http_post(path, body)

@command_name('shutdown')

class StartServer(Command):

    description = 'shutdown server'

    syntax = '<server id>'

    def execute(self, server_id):

        path = '/servers/%d/action' % int(server_id)

        body = json.dumps({'shutdown': {}})

        self.http_post(path, body)

@command_name('console')

class ServerConsole(Command):

    description = 'get VNC console'

    syntax = '<server id>'

    def execute(self, server_id):

        path = '/servers/%d/action' % int(server_id)

        body = json.dumps({'console': {'type': 'vnc'}})

        reply = self.http_cmd('POST', path, body, 200)

        print_dict(reply['console'])

@command_name('profile')

class SetFirewallProfile(Command):

    description = 'set the firewall profile'

    syntax = '<server id> <profile>'

    def execute(self, server_id, profile):

        path = '/servers/%d/action' % int(server_id)

        body = json.dumps({'firewallProfile': {'profile': profile}})

        self.http_cmd('POST', path, body, 202)

@command_name('lsaddr')

class ListAddresses(Command):

    description = 'list server addresses'

    syntax = '<server id> [network]'

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

        path = '/servers/%d/ips' % int(server_id)

        if network:

            path += '/%s' % network

        reply = self.http_get(path)

        addresses = [reply['network']] if network else reply['addresses']['values']

        print_addresses(addresses)

@command_name('lsflv')

class ListFlavors(Command):

    description = 'list flavors'

    def add_options(self, parser):

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

                            help='show detailed output')

    def execute(self):

        path = '/flavors/detail' if self.detail else '/flavors'

        reply = self.http_get(path)

        for flavor in reply['flavors']['values']:

            id = flavor.pop('id')

            name = flavor.pop('name')

            details = ' '.join('%s=%s' % item for item in sorted(flavor.items()))

            print '%3d %s %s' % (id, name, details)

@command_name('flvinfo')

class GetFlavorDetails(Command):

    description = 'get flavor details'

    syntax = '<flavor id>'

    def execute(self, flavor_id):

        path = '/flavors/%d' % int(flavor_id)

        reply = self.http_get(path)

        flavor = reply['flavor']

        id = flavor.pop('id')

        name = flavor.pop('name')

        details = ' '.join('%s=%s' % item for item in sorted(flavor.items()))

        print '%3d %s %s' % (id, name, details)

@command_name('lsimg')

class ListImages(Command):

    description = 'list images'

    def add_options(self, parser):

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

                            help='show detailed output')

    def execute(self):

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

        reply = self.http_get(path)

        for image in reply['images']['values']:

            id = image.pop('id')

            name = image.pop('name')

            if self.detail:

                print '%d %s' % (id, name)

                print_dict(image)

                print

            else:

                print '%3d %s' % (id, name)

@command_name('imginfo')

class GetImageDetails(Command):

    description = 'get image details'

    syntax = '<image id>'

    def execute(self, image_id):

        path = '/images/%d' % int(image_id)

        reply = self.http_get(path)

        image = reply['image']

        image.pop('id')

        print_dict(image)

@command_name('createimg')

class CreateImage(Command):

    description = 'create image'

    syntax = '<server id> <image name>'

    def execute(self, server_id, name):

        image = {'name': name, 'serverRef': int(server_id)}

        body = json.dumps({'image': image})

        reply = self.http_post('/images', body)

        print_dict(reply['image'])

@command_name('deleteimg')

class DeleteImage(Command):

    description = 'delete image'

    syntax = '<image id>'

    def execute(self, image_id):

        path = '/images/%d' % int(image_id)

        self.http_delete(path)

@command_name('lsmeta')

class ListServerMeta(Command):

    description = 'list server meta'

    syntax = '<server id> [key]'

    def execute(self, server_id, key=None):

        path = '/servers/%d/meta' % int(server_id)

        if key:

            path += '/' + key

        reply = self.http_get(path)

        if key:

            print_dict(reply['meta'])

        else:

            print_dict(reply['metadata']['values'])

@command_name('setmeta')

class UpdateServerMeta(Command):

    description = 'update server meta'

    syntax = '<server id> <key> <val>'

    def execute(self, server_id, key, val):

        path = '/servers/%d/meta' % int(server_id)

        metadata = {key: val}

        body = json.dumps({'metadata': metadata})

        reply = self.http_post(path, body, expected_status=201)

        print_dict(reply['metadata'])

@command_name('addmeta')

class CreateServerMeta(Command):

    description = 'add server meta'

    syntax = '<server id> <key> <val>'

    def execute(self, server_id, key, val):

        path = '/servers/%d/meta/%s' % (int(server_id), key)

        meta = {key: val}

        body = json.dumps({'meta': meta})

        reply = self.http_put(path, body, expected_status=201)

        print_dict(reply['meta'])

@command_name('delmeta')

class DeleteServerMeta(Command):

    description = 'delete server meta'

    syntax = '<server id> <key>'

    def execute(self, server_id, key):

        path = '/servers/%d/meta/%s' % (int(server_id), key)

        reply = self.http_delete(path)

@command_name('lsimgmeta')

class ListImageMeta(Command):

    description = 'list image meta'

    syntax = '<image id> [key]'

    def execute(self, image_id, key=None):

        path = '/images/%d/meta' % int(image_id)

        if key:

            path += '/' + key

        reply = self.http_get(path)

        if key:

            print_dict(reply['meta'])

        else:

            print_dict(reply['metadata']['values'])

@command_name('setimgmeta')

class UpdateImageMeta(Command):

    description = 'update image meta'

    syntax = '<image id> <key> <val>'

    def execute(self, image_id, key, val):

        path = '/images/%d/meta' % int(image_id)

        metadata = {key: val}

        body = json.dumps({'metadata': metadata})

        reply = self.http_post(path, body, expected_status=201)

        print_dict(reply['metadata'])

@command_name('addimgmeta')

class CreateImageMeta(Command):

    description = 'add image meta'

    syntax = '<image id> <key> <val>'

    def execute(self, image_id, key, val):

        path = '/images/%d/meta/%s' % (int(image_id), key)

        meta = {key: val}

        body = json.dumps({'meta': meta})

        reply = self.http_put(path, body, expected_status=201)

        print_dict(reply['meta'])

@command_name('delimgmeta')

class DeleteImageMeta(Command):

    description = 'delete image meta'

    syntax = '<image id> <key>'

    def execute(self, image_id, key):

        path = '/images/%d/meta/%s' % (int(image_id), key)

        reply = self.http_delete(path)

@command_name('lsnet')

class ListNetworks(Command):

    description = 'list networks'

    def add_options(self, parser):

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

                            help='show detailed output')

    def execute(self):

        path = '/networks/detail' if self.detail else '/networks'

        reply = self.http_get(path)

        for network in reply['networks']['values']:

            id = network.pop('id')

            name = network.pop('name')

            if self.detail:

                print '%s %s' % (id, name)

                print_dict(network)

                print

            else:

                print '%3s %s' % (id, name)

@command_name('createnet')

class CreateNetwork(Command):

    description = 'create network'

    syntax = '<network name>'

    def execute(self, name):

        network = {'name': name}

        body = json.dumps({'network': network})

        reply = self.http_post('/networks', body)

        print_dict(reply['network'])

@command_name('netinfo')

class GetNetworkDetails(Command):

    description = 'get network details'

    syntax = '<network id>'

    def execute(self, network_id):

        path = '/networks/%d' % int(network_id)

        reply = self.http_get(path)

        net = reply['network']

        name = net.pop('id')

        print_dict(net)

@command_name('renamenet')

class UpdateNetworkName(Command):

    description = 'update network name'

    syntax = '<network_id> <new name>'

    def execute(self, network_id, name):

        path = '/networks/%d' % int(network_id)

        body = json.dumps({'network': {'name': name}})

        self.http_put(path, body)

@command_name('deletenet')

class DeleteNetwork(Command):

    description = 'delete network'

    syntax = '<network id>'

    def execute(self, network_id):

        path = '/networks/%d' % int(network_id)

        self.http_delete(path)

@command_name('connect')

class AddNetwork(Command):

    description = 'connect a server to a network'

    syntax = '<server id> <network id>'

    def execute(self, server_id, network_id):

        path = '/networks/%d/action' % int(network_id)

        body = json.dumps({'add': {'serverRef': server_id}})

        self.http_post(path, body, expected_status=202)

@command_name('disconnect')

class RemoveNetwork(Command):

    description = 'disconnect a server from a network'

    syntax = '<server id> <network id>'

    def execute(self, server_id, network_id):

        path = '/networks/%s/action' % int(network_id)

        body = json.dumps({'remove': {'serverRef': server_id}})

        self.http_post(path, body, expected_status=202)

@command_name('stats')

class ServerStats(Command):

    description = 'get server stats'

    syntax = '<server id>'

    def execute(self, server_id):

        path = '/servers/%d/stats' % int(server_id)

        reply = self.http_get(path)

        stats = reply['stats']

        stats.pop('serverRef')

        print_dict(stats)

def print_usage():

    print 'Usage: %s <command>' % basename(argv[0])

    print

    print 'Commands:'

    for name, cls in sorted(commands.items()):

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

        print '  %s %s' % (name.ljust(12), description)

def main():

    try:

        name = argv[1]    

        cls = commands[name]

    except (IndexError, KeyError):

        print_usage()

        exit(1)

    try:

        cls(argv[2:])

    except TypeError:

        syntax = getattr(cls, 'syntax', '')

        if syntax:

            print 'Syntax: %s %s' % (name, syntax)

        else:

            print 'Invalid syntax'

        exit(1)

if __name__ == '__main__':

    main()

#!/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 django.core.management import setup_environ

try:

    from synnefo import settings

except ImportError:

    raise Exception("Cannot import settings, make sure PYTHONPATH contains "

                    "the parent directory of the Synnefo Django project.")

setup_environ(settings)

import inspect

import sys

from collections import defaultdict

from itertools import product

from optparse import OptionParser

from os.path import basename

from synnefo.db import models

from synnefo.invitations.invitations import add_invitation, send_invitation

from synnefo.logic import backend, users

from synnefo.util.dictconfig import dictConfig

def get_user(uid):

    try:

        uid = int(uid)

        return models.SynnefoUser.objects.get(id=uid)

    except ValueError:

        return None

    except models.SynnefoUser.DoesNotExist:

        return None

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 or key.startswith('_'):

            continue

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

def print_item(item):

    name = getattr(item, 'name', '')

    print '%d %s' % (item.id, name)

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

def print_items(items, detail=False, keys=None):

    keys = keys or ('id', 'name')

    for item in items:

        for key in keys:

            print getattr(item, key),

        print

        if detail:

            print_dict(item.__dict__, exclude=keys)

            print

class Command(object):

    group = '<group>'

    name = '<command>'

    syntax = ''

    description = ''

    hidden = False

    def __init__(self, exe, argv):

        parser = OptionParser()

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

        parser.usage = '%s %s %s' % (exe, self.name, syntax)

        parser.description = self.description

        self.add_options(parser)

        options, self.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.parser = parser

    def add_options(self, parser):

        pass

    def execute(self):

        try:

            self.main(*self.args)

        except TypeError:

            self.parser.print_help()

# Server commands

class ListServers(Command):

    group = 'server'

    name = 'list'

    syntax = '[server id]'

    description = 'list servers'

    def add_options(self, parser):

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

                        default=False, help='also list deleted servers')

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

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

        parser.add_option('-u', dest='uid', metavar='UID',

                            help='show servers of user with id UID')

    def main(self, server_id=None):

        if server_id:

            servers = [models.VirtualMachine.objects.get(id=server_id)]

        else:

            servers = models.VirtualMachine.objects.order_by('id')

            if not self.show_deleted:

                servers = servers.exclude(deleted=True)

            if self.uid:

                user = get_user(self.uid)

                if user:

                    servers = servers.filter(owner=user)

                else:

                    print 'Unknown user id'

                    return

        print_items(servers, self.detail)

# User commands

class CreateUser(Command):

    group = 'user'

    name = 'create'

    syntax = '<username> <email>'

    description = 'create a user'

    def add_options(self, parser):

        parser.add_option('--realname', dest='realname', metavar='NAME',

                            help='set real name of user')

        parser.add_option('--type', dest='type', metavar='TYPE',

                            help='set user type')

    def main(self, username, email):

        username = username.decode('utf8')

        realname = self.realname or username

        type = self.type or 'USER'

        types = [x[0] for x in models.SynnefoUser.ACCOUNT_TYPE]

        if type not in types:

            valid = ', '.join(types)

            print 'Invalid type. Must be one of:', valid

            return

        user = users._register_user(realname, username, email, type)

        print_item(user)

class InviteUser(Command):

    group = 'user'

    name = 'invite'

    syntax = '<inviter id> <invitee name> <invitee email>'

    description = 'invite a user'

    def main(self, inviter_id, name, email):

        name = name.decode('utf8')

        inviter = get_user(inviter_id)

        inv = add_invitation(inviter, name, email)

        send_invitation(inv)

class ListUsers(Command):

    group = 'user'

    name = 'list'

    syntax = '[user id]'

    description = 'list users'

    def add_options(self, parser):

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

                        default=False, help='also list deleted users')

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

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

    def main(self, user_id=None):

        if user_id:

            users = [models.SynnefoUser.objects.get(id=user_id)]

        else:

            users = models.SynnefoUser.objects.order_by('id')

            if not self.show_deleted:

                users = users.exclude(state='DELETED')

        print_items(users, self.detail, keys=('id', 'name', 'uniq'))

class ModifyUser(Command):

    group = 'user'

    name = 'modify'

    syntax = '<user id>'

    description = 'modify a user'

    def add_options(self, parser):

        types = ', '.join(x[0] for x in models.SynnefoUser.ACCOUNT_TYPE)

        states = ', '.join(x[0] for x in models.SynnefoUser.ACCOUNT_STATE)

        parser.add_option('--credit', dest='credit', metavar='VALUE',

                            help='set user credits')

        parser.add_option('--invitations', dest='invitations',

                            metavar='VALUE', help='set max invitations')

        parser.add_option('--realname', dest='realname', metavar='NAME',

                            help='set real name of user')

        parser.add_option('--type', dest='type', metavar='TYPE',

                            help='set user type (%s)' % types)

        parser.add_option('--state', dest='state', metavar='STATE',

                            help='set user state (%s)' % states)

        parser.add_option('--uniq', dest='uniq', metavar='ID',

                            help='set external unique ID')

        parser.add_option('--username', dest='username', metavar='NAME',

                            help='set username')

    def main(self, user_id):

        user = get_user(user_id)

        if self.credit:

            user.credit = self.credit

        if self.invitations:

            user.max_invitations = self.invitations

        if self.realname:

            user.realname = self.realname

        if self.type:

            allowed = [x[0] for x in models.SynnefoUser.ACCOUNT_TYPE]

            if self.type not in allowed:

                valid = ', '.join(allowed)

                print 'Invalid type. Must be one of:', valid

                return

            user.type = self.type

        if self.state:

            allowed = [x[0] for x in models.SynnefoUser.ACCOUNT_STATE]

            if self.state not in allowed:

                valid = ', '.join(allowed)

                print 'Invalid state. Must be one of:', valid

                return

            user.state = self.state

        if self.uniq:

            user.uniq = self.uniq

        if self.username:

            user.name = self.username

        user.save()

        print_item(user)

# Image commands

class ListImages(Command):

    group = 'image'

    name = 'list'

    syntax = '[image id]'

    description = 'list images'

    def add_options(self, parser):

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

                        default=False, help='also list deleted images')

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

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

    def main(self, image_id=None):

        if image_id:

            images = [models.Image.objects.get(id=image_id)]

        else:

            images = models.Image.objects.order_by('id')

            if not self.show_deleted:

                images = images.exclude(state='DELETED')

        print_items(images, self.detail)

class RegisterImage(Command):

    group = 'image'

    name = 'register'

    syntax = '<name> <backend id> <format>'

    description = 'register an image'

    def add_options(self, parser):

        parser.add_option('--meta', dest='meta', action='append',

                            metavar='KEY=VAL',

                            help='add metadata (can be used multiple times)')

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

                            default=False, help='make image public')

        parser.add_option('-u', dest='uid', metavar='UID',

                            help='assign image to user with id UID')

    def main(self, name, backend_id, format):

        formats = [x[0] for x in models.Image.FORMATS]

        if format not in formats:

            valid = ', '.join(formats)

            print 'Invalid format. Must be one of:', valid

            return

        user = None

        if self.uid:

            user = get_user(self.uid)

            if not user:

                print 'Unknown user id'

                return

        image = models.Image.objects.create(

            name=name,

            state='ACTIVE',

            owner=user,

            backend_id=backend_id,

            format=format,

            public=self.public)

        if self.meta:

            for m in self.meta:

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

                if key and val:

                    image.metadata.create(meta_key=key, meta_value=val)

                else:

                    print 'WARNING: Ignoring meta', m

        print_item(image)

class ModifyImage(Command):

    group = 'image'

    name = 'modify'

    syntax = '<image id>'

    description = 'modify an image'

    def add_options(self, parser):

        states = ', '.join(x[0] for x in models.Image.IMAGE_STATES)

        formats = ', '.join(x[0] for x in models.Image.FORMATS)

        parser.add_option('-b', dest='backend_id', metavar='BACKEND_ID',

                            help='set image backend id')

        parser.add_option('-f', dest='format', metavar='FORMAT',

                            help='set image format (%s)' % formats)

        parser.add_option('-n', dest='name', metavar='NAME',

                            help='set image name')

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

                            default=False, help='make image public')

        parser.add_option('--nopublic', action='store_true', dest='private',

                            default=False, help='make image private')

        parser.add_option('-s', dest='state', metavar='STATE', default=False,

                            help='set image state (%s)' % states)

        parser.add_option('-u', dest='uid', metavar='UID',

                            help='assign image to user with id UID')

    def main(self, image_id):

        try:

            image = models.Image.objects.get(id=image_id)

        except:

            print 'Image not found'

            return

        if self.backend_id:

            image.backend_id = self.backend_id

        if self.format:

            allowed = [x[0] for x in models.Image.FORMATS]

            if self.format not in allowed:

                valid = ', '.join(allowed)

                print 'Invalid format. Must be one of:', valid

                return

            image.format = self.format

        if self.name:

            image.name = self.name

        if self.public:

            image.public = True

        if self.private:

            image.public = False

        if self.state:

            allowed = [x[0] for x in models.Image.IMAGE_STATES]

            if self.state not in allowed:

                valid = ', '.join(allowed)

                print 'Invalid state. Must be one of:', valid

                return

            image.state = self.state

        if self.uid:

            image.owner = get_user(self.uid)

        image.save()

        print_item(image)

class ModifyImageMeta(Command):

    group = 'image'

    name = 'meta'

    syntax = '<image id> [key[=val]]'

    description = 'get and manipulate image metadata'

    def main(self, image_id, arg=''):

        try:

            image = models.Image.objects.get(id=image_id)

        except:

            print 'Image not found'

            return

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

        if not sep:

            val = None

        if not key:

            metadata = {}

            for meta in image.metadata.order_by('meta_key'):

                metadata[meta.meta_key] = meta.meta_value

            print_dict(metadata)

            return

        try:

            meta = image.metadata.get(meta_key=key)

        except models.ImageMetadata.DoesNotExist:

            meta = None

        if val is None:

            if meta:

                print_dict({key: meta.meta_value})

            return

        if val:

            if not meta:

                meta = image.metadata.create(meta_key=key)

            meta.meta_value = val

            meta.save()

        else:

            # Delete if val is empty

            if meta:

                meta.delete()

# Flavor commands

class CreateFlavor(Command):

    group = 'flavor'

    name = 'create'

    syntax = '<cpu>[,<cpu>,...] <ram>[,<ram>,...] <disk>[,<disk>,...]'

    description = 'create one or more flavors'

    def add_options(self, parser):

        disk_templates = ', '.join(t for t in settings.GANETI_DISK_TEMPLATES)

        parser.add_option('--disk-template',

            dest='disk_template',

            metavar='TEMPLATE',

            default=settings.DEFAULT_GANETI_DISK_TEMPLATE,

            help='available disk templates: %s' % disk_templates)

    def main(self, cpu, ram, disk):

        cpus = cpu.split(',')

        rams = ram.split(',')

        disks = disk.split(',')

        flavors = []

        for cpu, ram, disk in product(cpus, rams, disks):

            try:

                flavors.append((int(cpu), int(ram), int(disk)))

            except ValueError:

                print 'Invalid values'

                return

        created = []

        for cpu, ram, disk in flavors:

            flavor = models.Flavor.objects.create(

                cpu=cpu,

                ram=ram,

                disk=disk,

                disk_template=self.disk_template)

            created.append(flavor)

        print_items(created, detail=True)

class DeleteFlavor(Command):

    group = 'flavor'

    name = 'delete'

    syntax = '<flavor id> [<flavor id>] [...]'

    description = 'delete one or more flavors'

    def main(self, *args):

        if not args:

            raise TypeError

        for flavor_id in args:

            flavor = models.Flavor.objects.get(id=int(flavor_id))

            flavor.deleted = True

            flavor.save()

class ListFlavors(Command):

    group = 'flavor'

    name = 'list'

    syntax = '[flavor id]'

    description = 'list images'

    def add_options(self, parser):

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

                default=False, help='also list deleted flavors')

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

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

    def main(self, flavor_id=None):

        if flavor_id:

            flavors = [models.Flavor.objects.get(id=flavor_id)]

        else:

            flavors = models.Flavor.objects.order_by('id')

            if not self.show_deleted:

                flavors = flavors.exclude(deleted=True)

        print_items(flavors, self.detail)

class ShowStats(Command):

    group = 'stats'

    name = None

    description = 'show statistics'

    def main(self):

        stats = {}

        stats['Users'] = models.SynnefoUser.objects.count()

        stats['Images'] = models.Image.objects.exclude(state='DELETED').count()

        stats['Flavors'] = models.Flavor.objects.count()

        stats['VMs'] = models.VirtualMachine.objects.filter(deleted=False).count()

        stats['Networks'] = models.Network.objects.exclude(state='DELETED').count()

        stats['Invitations'] = models.Invitations.objects.count()

        stats['Ganeti Instances'] = len(backend.get_ganeti_instances())

        stats['Ganeti Nodes'] = len(backend.get_ganeti_nodes())

        stats['Ganeti Jobs'] = len(backend.get_ganeti_jobs())

        print_dict(stats)

class ListInvitations(Command):

    group = 'invitation'

    name = 'list'

    syntax = '[invitation id]'

    description = 'list invitations'

    def main(self, invitation_id=None):

        if invitation_id:

            invitations = [models.Invitations.objects.get(id=invitation_id)]

        else:

            invitations = models.Invitations.objects.order_by('id')

        print_items(invitations, detail=True, keys=('id',))

class ResendInviation(Command):

    group = 'invitation'

    name = 'resend'

    syntax = '<invitation id>'

    description = 'resend an invitation'

    def main(self, invitation_id):

        invitation = models.Invitations.objects.get(id=invitation_id)

        send_invitation(invitation)

def print_usage(exe, groups, group=None, shortcut=False):

    nop = Command(exe, [])

    nop.parser.print_help()

    if group:

        groups = {group: groups[group]}

    print

    print 'Commands:'

    for group, commands in sorted(groups.items()):

        for command, cls in sorted(commands.items()):

            if cls.hidden:

                continue

            name = '  %s %s' % (group, command or '')

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

        print

def main():

    groups = defaultdict(dict)

    module = sys.modules[__name__]

    for name, cls in inspect.getmembers(module, inspect.isclass):

        if not issubclass(cls, Command) or cls == Command:

            continue

        groups[cls.group][cls.name] = cls

    argv = list(sys.argv)

    exe = basename(argv.pop(0))

    prefix, sep, suffix = exe.partition('-')

    if sep and prefix == 'snf' and suffix in groups:

        # Allow shortcut aliases like snf-image, snf-server, etc

        group = suffix

    else:

        group = argv.pop(0) if argv else None

        if group in groups:

            exe = '%s %s' % (exe, group)

        else:

            exe = '%s <group>' % exe

            group = None

    command = argv.pop(0) if argv else None

    if group not in groups or command not in groups[group]:

        print_usage(exe, groups, group)

        sys.exit(1)

    cls = groups[group][command]

    cmd = cls(exe, argv)

    cmd.execute()

if __name__ == '__main__':

    dictConfig(settings.SNFADMIN_LOGGING)

    main()

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

"""Perform integration testing on a running Synnefo deployment"""

import __main__

import datetime

import inspect

import logging

import os

import paramiko

import prctl

import subprocess

import signal

import socket

import struct

import sys

import time

from IPy import IP

from multiprocessing import Process, Queue

from random import choice

from kamaki.client import Client, ClientError

from vncauthproxy.d3des import generate_response as d3des_generate_response

# Use backported unittest functionality if Python < 2.7

try:

    import unittest2 as unittest

except ImportError:

    if sys.version_info < (2, 7):

        raise Exception("The unittest2 package is required for Python < 2.7")

    import unittest

API = None

TOKEN = None

DEFAULT_API = "http://dev67.dev.grnet.gr:8000/api/v1.1"

DEFAULT_TOKEN = "46e427d657b20defe352804f0eb6f8a2"

# A unique id identifying this test run

TEST_RUN_ID = datetime.datetime.strftime(datetime.datetime.now(),

                                         "%Y%m%d%H%M%S")

SNF_TEST_PREFIX = "snf-test-"

# Setup logging (FIXME - verigak)

logging.basicConfig(format="%(message)s")

log = logging.getLogger("burnin")

log.setLevel(logging.INFO)

class UnauthorizedTestCase(unittest.TestCase):

    def test_unauthorized_access(self):

        """Test access without a valid token fails"""

        c = Client(API, "123")

        with self.assertRaises(ClientError) as cm:

            c.list_servers()

        self.assertEqual(cm.exception.status, 401)

class ImagesTestCase(unittest.TestCase):

    """Test image lists for consistency"""

    @classmethod

    def setUpClass(cls):

        """Initialize kamaki, get (detailed) list of images"""

        log.info("Getting simple and detailed list of images")

        cls.client = Client(API, TOKEN)

        cls.images = cls.client.list_images()

        cls.dimages = cls.client.list_images(detail=True)

    def test_001_list_images(self):

        """Test image list actually returns images"""

        self.assertGreater(len(self.images), 0)

    def test_002_list_images_detailed(self):

        """Test detailed image list is the same length as list"""

        self.assertEqual(len(self.dimages), len(self.images))

    def test_003_same_image_names(self):

        """Test detailed and simple image list contain same names"""

        names = sorted(map(lambda x: x["name"], self.images))

        dnames = sorted(map(lambda x: x["name"], self.dimages))

        self.assertEqual(names, dnames)

    def test_004_unique_image_names(self):

        """Test images have unique names"""

        names = sorted(map(lambda x: x["name"], self.images))

        self.assertEqual(sorted(list(set(names))), names)

    def test_005_image_metadata(self):

        """Test every image has specific metadata defined"""

        keys = frozenset(["OS", "description", "size"])

        for i in self.dimages:

            self.assertTrue(keys.issubset(i["metadata"]["values"].keys()))

class FlavorsTestCase(unittest.TestCase):

    """Test flavor lists for consistency"""

    @classmethod

    def setUpClass(cls):

        """Initialize kamaki, get (detailed) list of flavors"""

        log.info("Getting simple and detailed list of flavors")

        cls.client = Client(API, TOKEN)

        cls.flavors = cls.client.list_flavors()

        cls.dflavors = cls.client.list_flavors(detail=True)

    def test_001_list_flavors(self):

        """Test flavor list actually returns flavors"""

        self.assertGreater(len(self.flavors), 0)

    def test_002_list_flavors_detailed(self):

        """Test detailed flavor list is the same length as list"""

        self.assertEquals(len(self.dflavors), len(self.flavors))

    def test_003_same_flavor_names(self):

        """Test detailed and simple flavor list contain same names"""

        names = sorted(map(lambda x: x["name"], self.flavors))

        dnames = sorted(map(lambda x: x["name"], self.dflavors))

        self.assertEqual(names, dnames)

    def test_004_unique_flavor_names(self):

        """Test flavors have unique names"""

        names = sorted(map(lambda x: x["name"], self.flavors))

        self.assertEqual(sorted(list(set(names))), names)

    def test_005_well_formed_flavor_names(self):

        """Test flavors have names of the form CxxRyyDzz

        Where xx is vCPU count, yy is RAM in MiB, zz is Disk in GiB

        """

        for f in self.dflavors:

            self.assertEqual("C%dR%dD%d" % (f["cpu"], f["ram"], f["disk"]),

                             f["name"],

                             "Flavor %s does not match its specs." % f["name"])

class ServersTestCase(unittest.TestCase):

    """Test server lists for consistency"""

    @classmethod

    def setUpClass(cls):

        """Initialize kamaki, get (detailed) list of servers"""

        log.info("Getting simple and detailed list of servers")

        cls.client = Client(API, TOKEN)

        cls.servers = cls.client.list_servers()

        cls.dservers = cls.client.list_servers(detail=True)

    def test_001_list_servers(self):

        """Test server list actually returns servers"""