Synnefo

#!/bin/bash

# This is an example of a Ganeti kvm ifup script that configures network

# interfaces based on the initial deployment of the Okeanos project

TAP_CONSTANT_MAC=cc:47:52:4e:45:54 # GRNET in hex :-)

MAC2EUI64=/usr/bin/mac2eui64

NFDHCPD_STATE_DIR=/var/lib/nfdhcpd

function routed_setup_ipv4 {

	# get the link's default gateway

	gw=$(ip route list table $LINK | sed -n 's/default via \([^ ]\+\).*/\1/p' | head -1)

	# mangle ARPs to come from the gw's IP

	arptables -D OUTPUT -o $INTERFACE --opcode request -j mangle >/dev/null 2>&1

	arptables -A OUTPUT -o $INTERFACE --opcode request -j mangle --mangle-ip-s "$gw"

	# route interface to the proper routing table

	while ip rule del dev $INTERFACE; do :; done

	ip rule add dev $INTERFACE table $LINK

	# static route mapping IP -> INTERFACE

	ip route replace $IP table $LINK proto static dev $INTERFACE

	# Enable proxy ARP

	echo 1 > /proc/sys/net/ipv4/conf/$INTERFACE/proxy_arp

}

function routed_setup_ipv6 {

	# Add a routing entry for the eui-64

	prefix=$(ip -6 route list table $LINK | awk '/\/64/ {print $1; exit}')

	uplink=$(ip -6 route list table $LINK | sed -n 's/default via .* dev \([^ ]\+\).*/\1/p' | head -1)

	eui64=$($MAC2EUI64 $MAC $prefix)

	while ip -6 rule del dev $INTERFACE; do :; done

	ip -6 rule add dev $INTERFACE table $LINK

	ip -6 ro replace $eui64/128 dev $INTERFACE table $LINK

	ip -6 neigh add proxy $eui64 dev $uplink

	# disable proxy NDP since we're handling this on userspace

	# this should be the default, but better safe than sorry

	echo 0 > /proc/sys/net/ipv6/conf/$INTERFACE/proxy_ndp

}

# pick a firewall profile per NIC, based on tags (and apply it)

function routed_setup_firewall {

	ifprefix="synnefo:network:$INTERFACE_INDEX:"

	for tag in $TAGS; do

		case ${tag#$ifprefix} in

		protected)

			chain=protected

		;;

		unprotected)

			chain=unprotected

		;;

		limited)

			chain=limited

		;;

		esac

	done

	# Flush any old rules. We have to consider all chains, since

	# we are not sure the instance was on the same chain, or had the same

	# tap interface.

	for oldchain in protected unprotected limited; do

		iptables  -D FORWARD -o $INTERFACE -j $oldchain 2>/dev/null

		ip6tables -D FORWARD -o $INTERFACE -j $oldchain 2>/dev/null

	done

	if [ "x$chain" != "x" ]; then

		iptables  -A FORWARD -o $INTERFACE -j $chain

		ip6tables -A FORWARD -o $INTERFACE -j $chain

	fi

}

function routed_setup_nfdhcpd {

	umask 022

	cat >$NFDHCPD_STATE_DIR/$INTERFACE <<EOF

IP=$IP

MAC=$MAC

LINK=$LINK

HOSTNAME=$INSTANCE

TAGS="$TAGS"

EOF

}

if [ "$MODE" = "routed" ]; then

	# special proxy-ARP/NDP routing mode

	# use a constant predefined MAC address for the tap

	ip link set $INTERFACE addr $TAP_CONSTANT_MAC

	# bring the tap up

	ifconfig $INTERFACE 0.0.0.0 up

	# Drop unicast BOOTP/DHCP packets

	iptables -D FORWARD -i $INTERFACE -p udp --dport 67 -j DROP 2>/dev/null

	iptables -A FORWARD -i $INTERFACE -p udp --dport 67 -j DROP

	routed_setup_ipv4

	routed_setup_ipv6

	routed_setup_firewall

	routed_setup_nfdhcpd

elif [ "$MODE" = "bridged" ]; then

	ifconfig $INTERFACE 0.0.0.0 up

	brctl addif $BRIDGE $INTERFACE

	rm -f $NFDHCPD_STATE_DIR/$INTERFACE

fi

#!/usr/bin/env python

#

# -*- coding: utf-8 -*-

#

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

#

"""Ganeti hooks for Synnefo

These are the individual Ganeti hooks for Synnefo.

"""

import sys

import os

import time

import json

import socket

import logging

from amqplib import client_0_8 as amqp

from synnefo.util.mac2eui64 import mac2eui64

import synnefo.settings as settings

def ganeti_net_status(logger, environ):

    """Produce notifications of type 'Ganeti-net-status'

    Process all GANETI_INSTANCE_NICx_y environment variables,

    where x is the NIC index, starting at 0,

    and y is one of "MAC", "IP", "BRIDGE".

    The result is returned as a single notification message

    of type 'ganeti-net-status', detailing the NIC configuration

    of a Ganeti instance.

    """

    nics = {}

    key_to_attr = { 'IP': 'ip', 'MAC': 'mac', 'BRIDGE': 'link' }

    for env in environ.keys():

        if env.startswith("GANETI_INSTANCE_NIC"):

            s = env.replace("GANETI_INSTANCE_NIC", "").split('_', 1)

            if len(s) == 2 and s[0].isdigit() and s[1] in ('MAC', 'IP', 'BRIDGE'):

                index = int(s[0])

                key = key_to_attr[s[1]]

                if nics.has_key(index):

                    nics[index][key] = environ[env]

                else:

                    nics[index] = { key: environ[env] }

                # IPv6 support:

                #

                # The IPv6 of NIC with index 0 [the public NIC]

                # is derived using an EUI64 scheme.

                if index == 0 and key == 'mac':

                    nics[0]['ipv6'] = mac2eui64(nics[0]['mac'],

                                                settings.PUBLIC_IPV6_PREFIX)

    # Amend notification with firewall settings

    tags = environ.get('GANETI_INSTANCE_TAGS', '')

    for tag in tags.split(' '):

        t = tag.split(':')

        if t[0:2] == ['synnefo', 'network']:

            if len(t) != 4:

                logger.error("Malformed synnefo tag %s", tag)

                continue

            try:

                index = int(t[2])

                nics[index]['firewall'] = t[3]

            except ValueError:

                logger.error("Malformed synnefo tag %s", tag)

            except KeyError:

                logger.error("Found tag %s for non-existent NIC %d",

                             tag, index)

    # Verify our findings are consistent with the Ganeti environment

    indexes = list(nics.keys())

    ganeti_nic_count = int(environ['GANETI_INSTANCE_NIC_COUNT'])

    if len(indexes) != ganeti_nic_count:

        logger.error("I have %d NICs, Ganeti says number of NICs is %d",

            len(indexes), ganeti_nic_count)

        raise Exception("Inconsistent number of NICs in Ganeti environment")

    if indexes != range(0, len(indexes)):

        logger.error("Ganeti NIC indexes are not consecutive starting at zero.");

        logger.error("NIC indexes are: %s. Environment is: %s", indexes, environ)

        raise Exception("Unexpected inconsistency in the Ganeti environment")

    # Construct the notification

    instance = environ['GANETI_INSTANCE_NAME']

    nics_list = []

    for i in indexes:

        nics_list.append(nics[i])

    msg = {

        "type": "ganeti-net-status",

        "instance": instance,

        "nics": nics_list

    }

    return msg

class GanetiHook():

    def __init__(self, logger, environ, instance, prefix):

        self.logger = logger

        self.environ = environ

        self.instance = instance

        self.prefix = prefix

    def on_master(self):

        """Return True if running on the Ganeti master"""

        return socket.getfqdn() == self.environ['GANETI_MASTER']

    def publish_msgs(self, msgs):

        for (msgtype, msg) in msgs:

            routekey = "ganeti.%s.event.%s" % (self.prefix, msgtype)

            self.logger.debug("Pushing message to RabbitMQ: %s (key = %s)",

                json.dumps(msg), routekey)

            msg = amqp.Message(json.dumps(msg))

            msg.properties["delivery_mode"] = 2  # Persistent

            # Retry up to five times to open a channel to RabbitMQ.

            # The hook needs to abort if this count is exceeded, because it

            # runs synchronously with VM creation inside Ganeti, and may only

            # run for a finite amount of time.

            #

            # FIXME: We need a reconciliation mechanism between the DB and

            #        Ganeti, for cases exactly like this.

            conn = None

            sent = False

            retry = 0

            while not sent and retry < 5:

                self.logger.debug("Attempting to publish to RabbitMQ at %s",

                    settings.RABBIT_HOST)

                try:

                    if not conn:

                        conn = amqp.Connection(host=settings.RABBIT_HOST,

                            userid=settings.RABBIT_USERNAME,

                            password=settings.RABBIT_PASSWORD,

                            virtual_host=settings.RABBIT_VHOST)

                        chann = conn.channel()

                        self.logger.debug("Successfully connected to RabbitMQ at %s",

                            settings.RABBIT_HOST)

                    chann.basic_publish(msg,

                        exchange=settings.EXCHANGE_GANETI,

                        routing_key=routekey)

                    sent = True

                    self.logger.debug("Successfully sent message to RabbitMQ")

                except socket.error:

                    conn = False

                    retry += 1

                    self.logger.exception("Publish to RabbitMQ failed, retry=%d in 1s",

                        retry)

                    time.sleep(1)

            if not sent:

                raise Exception("Publish to RabbitMQ failed after %d tries, aborting" % retry)

class PostStartHook(GanetiHook):

    """Post-instance-startup Ganeti Hook.

    Produce notifications to the rest of the Synnefo

    infrastructure in the post-instance-start phase of Ganeti.

    Currently, this list only contains a single message,

    detailing the net configuration of an instance.

    This hook only runs on the Ganeti master.

    """

    def run(self):

        if self.on_master():

            notifs = []

            notifs.append(("net", ganeti_net_status(self.logger, self.environ)))

            self.publish_msgs(notifs)

        return 0

class PostStopHook(GanetiHook):

    def run(self):

        return 0

#!/usr/bin/env python

#

# -*- coding: utf-8 -*-

#

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

#

"""Ganeti notification daemon with AMQP support

A daemon to monitor the Ganeti job queue and publish job progress

and Ganeti VM state notifications to the ganeti exchange

"""

#from django.core.management import setup_environ

import sys

import os

path = os.path.normpath(os.path.join(os.getcwd(), '..'))

sys.path.append(path)

import synnefo.settings as settings

#setup_environ(settings)

import time

import json

import logging

import pyinotify

import daemon

import daemon.pidlockfile

import socket

from signal import signal, SIGINT, SIGTERM

from amqplib import client_0_8 as amqp

from ganeti import utils

from ganeti import jqueue

from ganeti import constants

from ganeti import serializer

class JobFileHandler(pyinotify.ProcessEvent):

    def __init__(self, logger):

        pyinotify.ProcessEvent.__init__(self)

        self.logger = logger

        self.chan = None

    def open_channel(self):

        conn = None

        while conn == None:

            handler_logger.info("Attempting to connect to %s",

                settings.RABBIT_HOST)

            try:

                conn = amqp.Connection(host=settings.RABBIT_HOST,

                     userid=settings.RABBIT_USERNAME,

                     password=settings.RABBIT_PASSWORD,

                     virtual_host=settings.RABBIT_VHOST)

            except socket.error:

                time.sleep(1)

        handler_logger.info("Connection succesful, opening channel")

        return conn.channel()

    def process_IN_CLOSE_WRITE(self, event):

        self.process_IN_MOVED_TO(event)

    def process_IN_MOVED_TO(self, event):

        if self.chan == None:

            self.chan = self.open_channel()

        jobfile = os.path.join(event.path, event.name)

        if not event.name.startswith("job-"):

            self.logger.debug("Not a job file: %s" % event.path)

            return

        try:

            data = utils.ReadFile(jobfile)

        except IOError:

            return

        data = serializer.LoadJson(data)

        job = jqueue._QueuedJob.Restore(None, data)

        for op in job.ops:

            instances = ""

            try:

                instances = " ".join(op.input.instances)

            except AttributeError:

                pass

            try:

                instances = op.input.instance_name

            except AttributeError:

                pass

            # Get the last line of the op log as message

            try:

                logmsg = op.log[-1][-1]

            except IndexError:

                logmsg = None

            self.logger.debug("Job: %d: %s(%s) %s %s",

                    int(job.id), op.input.OP_ID, instances, op.status, logmsg)

            # Construct message

            msg = {

                    "type": "ganeti-op-status",

                    "instance": instances,

                    "operation": op.input.OP_ID,

                    "jobId": int(job.id),

                    "status": op.status,

                    "logmsg": logmsg

                    }

            if logmsg:

                msg["message"] = logmsg

            instance = instances.split('-')[0]

            routekey = "ganeti.%s.event.op" % instance

            self.logger.debug("Delivering msg: %s (key=%s)",

                json.dumps(msg), routekey)

            msg = amqp.Message(json.dumps(msg))

            msg.properties["delivery_mode"] = 2  # Persistent

            while True:

                try:

                    self.chan.basic_publish(msg,

                            exchange=settings.EXCHANGE_GANETI,

                            routing_key=routekey)

                    return

                except socket.error:

                    self.logger.exception("Server went away, reconnecting...")

                    self.chan = self.open_channel()

                except Exception:

                    self.logger.exception("Caught unexpected exception, msg: ",

                                          msg)

                    raise

handler_logger = None

def fatal_signal_handler(signum, frame):

    global handler_logger

    handler_logger.info("Caught fatal signal %d, will raise SystemExit",

                        signum)

    raise SystemExit

def parse_arguments(args):

    from optparse import OptionParser

    parser = OptionParser()

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

                      help="Enable debugging information")

    parser.add_option("-l", "--log", dest="log_file",

                      default=settings.GANETI_EVENTD_LOG_FILE,

                      metavar="FILE",

                      help="Write log to FILE instead of %s" %

                           settings.GANETI_EVENTD_LOG_FILE)

    parser.add_option('--pid-file', dest="pid_file",

                      default=settings.GANETI_EVENTD_PID_FILE,

                      metavar='PIDFILE',

                      help="Save PID to file (default: %s)" %

                           settings.GANETI_EVENTD_PID_FILE)

    return parser.parse_args(args)

def main():

    global handler_logger

    (opts, args) = parse_arguments(sys.argv[1:])

    # Create pidfile

    pidf = daemon.pidlockfile.TimeoutPIDLockFile(opts.pid_file, 10)

    # Initialize logger

    lvl = logging.DEBUG if opts.debug else logging.INFO

    logger = logging.getLogger("ganeti.eventd")

    logger.setLevel(lvl)

    formatter = logging.Formatter(

        "%(asctime)s %(module)s[%(process)d] %(levelname)s: %(message)s",

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

    handler = logging.FileHandler(opts.log_file)

    handler.setFormatter(formatter)

    logger.addHandler(handler)

    handler_logger = logger

    # Become a daemon:

    # Redirect stdout and stderr to handler.stream to catch

    # early errors in the daemonization process [e.g., pidfile creation]

    # which will otherwise go to /dev/null.

    daemon_context = daemon.DaemonContext(

            pidfile=pidf,

            umask=022,

            stdout=handler.stream,

            stderr=handler.stream,

            files_preserve=[handler.stream])

    daemon_context.open()

    logger.info("Became a daemon")

    # Catch signals to ensure graceful shutdown

    signal(SIGINT, fatal_signal_handler)

    signal(SIGTERM, fatal_signal_handler)

    # Monitor the Ganeti job queue, create and push notifications

    wm = pyinotify.WatchManager()

    mask = pyinotify.EventsCodes.ALL_FLAGS["IN_MOVED_TO"] | \

           pyinotify.EventsCodes.ALL_FLAGS["IN_CLOSE_WRITE"]

    handler = JobFileHandler(logger)

    notifier = pyinotify.Notifier(wm, handler)

    try:

        # Fail if adding the inotify() watch fails for any reason

        res = wm.add_watch(constants.QUEUE_DIR, mask)

        if res[constants.QUEUE_DIR] < 0:

            raise Exception("pyinotify add_watch returned negative descriptor")

        logger.info("Now watching %s" % constants.QUEUE_DIR)

        while True:    # loop forever

            # process the queue of events as explained above

            notifier.process_events()

            if notifier.check_events():

                # read notified events and enqeue them

                notifier.read_events()

    except SystemExit:

        logger.info("SystemExit")

    except:

        logger.exception("Caught exception, terminating")

    finally:

        # destroy the inotify's instance on this interrupt (stop monitoring)

        notifier.stop()

        raise

if __name__ == "__main__":

    sys.exit(main())

# vim: set sta sts=4 shiftwidth=4 sw=4 et ai :

#!/bin/bash

#

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

# 

# This must be set to the root of the the Django project for Synnefo

SYNNEFO_PROJECT_DIR=/home/devel/synnefo

# Include the parent of the Django project dir in the PYTHONPATH

export PYTHONPATH=$PYTHONPATH:$(dirname "$SYNNEFO_PROJECT_DIR")

exec "$SYNNEFO_PROJECT_DIR"/ganeti/snf-ganeti-hook.py

#!/usr/bin/env python

#

# -*- coding: utf-8 -*-

#

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

#

"""Ganeti hook for Synnefo

This is the generic Synnefo Ganeti hook.

It uses the full path of the hook, as passed through sys.argv[0]

to discover the root of the Synnefo project, then passes

control to the function which implements this specific hook,

based on the GANETI_HOOKS_PATH and GANETI_HOOKS_PHASE env variables,

set by Ganeti.

"""

import logging

import sys

import os

# IMPORTANT: PYTHONPATH must contain the parent of the Synnefo project root.

try:

    import synnefo.settings as settings

except ImportError:

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

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

# A hook runs either in the "pre" or "post" phase of a Ganeti operation.

# Possible values for the Ganeti operation are "instance-start",

# "instance-stop", "instance-reboot", "instance-modify". See the Ganeti

# documentation for a full list.

# The operation and phase for which the hook run are determined from the

# values of the GANETI_HOOK_PATH and GANETI_HOOK_PHASE environment variables.

# For each valid (operation, phase) pair control passes to the corresponding

# Python function, based on the following dictionary.

from synnefo.ganeti.hooks import \

    PostStartHook, PostStopHook

hooks = {

    ("instance-add", "post"): PostStartHook,

    ("instance-start", "post"): PostStartHook,

    ("instance-reboot", "post"): PostStartHook,

    ("instance-stop", "post"): PostStopHook,

    ("instance-modify", "post"): PostStartHook

}

def main():

    logging.basicConfig(level=logging.DEBUG)

    logger = logging.getLogger("synnefo.ganeti")

    try:

        instance = os.environ['GANETI_INSTANCE_NAME']

        op = os.environ['GANETI_HOOKS_PATH']

        phase = os.environ['GANETI_HOOKS_PHASE']

    except KeyError:

        raise Exception("Environment missing one of: " \

            "GANETI_INSTANCE_NAME, GANETI_HOOKS_PATH, GANETI_HOOKS_PHASE")

    prefix = instance.split('-')[0]

    # FIXME: The hooks should only run for Synnefo instances.

    # Uncomment the following lines for a shared Ganeti deployment.

    # Currently, the following code is commented out because multiple

    # backend prefixes are used in the same Ganeti installation during development.

    #if not instance.startswith(settings.BACKEND_PREFIX_ID):

    #    logger.warning("Ignoring non-Synnefo instance %s", instance)

    #    return 0

    try:

        hook = hooks[(op, phase)](logger, os.environ, instance, prefix)

    except KeyError:

        raise Exception("No hook found for operation = '%s', phase = '%s'" % (op, phase))

    return hook.run()

if __name__ == "__main__":

    sys.exit(main())

# vim: set ts=4 sts=4 sw=4 et ai :

#!/bin/bash

#

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

# 

# This must be set to the root of the the Django project for Synnefo

SYNNEFO_PROJECT_DIR=/home/devel/synnefo

# Include the parent of the Django project dir in the PYTHONPATH

export PYTHONPATH=$PYTHONPATH:$(dirname "$SYNNEFO_PROJECT_DIR")

exec "$SYNNEFO_PROJECT_DIR"/ganeti/snf-progress-monitor.py $*

#!/usr/bin/env python

# -*- coding: utf-8 -*-

#

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

import sys

import time

import json

import prctl

import signal

import socket

from amqplib import client_0_8 as amqp

try:

    import synnefo.settings as settings

except ImportError:

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

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

class AMQPClient(object):

    def __init__(self, routekey):

        self.conn = None

        self.chan = None

        self.routekey = routekey

    def open_channel(self):

        if not self.conn:

            try:

                sys.stderr.write("Attempting to connect to %s\n" %

                                 settings.RABBIT_HOST)

                self.conn = amqp.Connection(host=settings.RABBIT_HOST,

                                            userid=settings.RABBIT_USERNAME,

                                            password=settings.RABBIT_PASSWORD,

                                            virtual_host=settings.RABBIT_VHOST)

            except socket.error:

                sys.stderr.write("Connection failed, will retry in 1s\n")

                time.sleep(1)

        if self.conn:

            sys.stderr.write("Connection succesful, opening channel\n")

        self.chan = self.conn.channel()

    def send_message(self, msg):

        sys.stderr.write("Delivering msg with key=%s:\n%s\n" %

                         (self.routekey, json.dumps(msg)))

        msg = amqp.Message(json.dumps(msg))

        msg.properties["delivery_mode"] = 2  # Persistent

        if not self.chan:

            self.open_channel()

        if not self.chan:

            return

        try:

            self.chan.basic_publish(msg,

                                    exchange=settings.EXCHANGE_GANETI,

                                    routing_key=self.routekey)

        except socket.error:

            sys.stderr.write("Server went away, reconnecting...\n")

            self.conn = None

            self.chan = None

def parse_arguments(args):

    from optparse import OptionParser

    kw = {}

    kw['usage'] = "%prog [options] command [args...]"

    kw['description'] = \

        "%prog runs 'command' with the specified arguments, monitoring the " \

        "number of bytes read and written by it. 'command' is assumed to be " \

        "A program used to install the OS for a Ganeti instance. %prog " \

        "periodically issues notifications of type 'ganeti-create-progress' " \

        "to the rest of the Synnefo infrastructure over AMQP."

    parser = OptionParser(**kw)

    parser.disable_interspersed_args()

    parser.add_option("-r", "--read-bytes",

                      action="store", type="int", dest="read_bytes",

                      metavar="BYTES_TO_READ",

                      help="The expected number of bytes to be read, " \

                           "used to compute input progress",

                      default=0)

    parser.add_option("-w", "--write-bytes",

                      action="store", type="int", dest="write_bytes",

                      metavar="BYTES_TO_WRITE",

                      help="The expected number of bytes to be written, " \

                           "used to compute output progress",

                      default=0)

    parser.add_option("-i", "--instance-name",

                      dest="instance_name",

                      metavar="GANETI_INSTANCE",

                      help="The Ganeti instance name to be used in AMQP " \

                           "notifications")

    (opts, args) = parser.parse_args(args)

    if opts.instance_name is None or (opts.read_bytes == 0 and

                                      opts.write_bytes == 0):

        sys.stderr.write("Fatal: Options '-i' and at least one of '-r' " \

                         "or '-w' are mandatory.\n")

        parser.print_help()

        sys.exit(1)

    if len(args) == 0:

        sys.stderr.write("Fatal: You need to specify the command to run.\n")

        parser.print_help()

        sys.exit(1)

    return (opts, args)

def report_wait_status(pid, status):

    if os.WIFEXITED(status):

        sys.stderr.write("Child PID = %d exited, status = %d\n" %

                         (pid, os.WEXITSTATUS(status)))

    elif os.WIFSIGNALED(status):

        sys.stderr.write("Child PID = %d died by signal, signal = %d\n" %

                         (pid, os.WTERMSIG(status)))

    elif os.WIFSTOPPED(status):

        sys.stderr.write("Child PID = %d stopped by signal, signal = %d\n" %

                         (pid, os.WSTOPSIG(status)))

    else:

        sys.stderr.write("Internal error: Unhandled case, " \

                         "PID = %d, status = %d\n" % (pid, status))

        sys.exit(1)

    sys.stderr.flush()

def main():

    (opts, args) = parse_arguments(sys.argv[1:])

    # WARNING: This assumes that instance names

    # are of the form prefix-id, and uses prefix to

    # determine the routekey for AMPQ

    prefix = opts.instance_name.split('-')[0]

    routekey = "ganeti.%s.event.progress" % prefix

    amqp = AMQPClient(routekey)

    pid = os.fork()

    if pid == 0:

        # In child process:

        # Make sure we die we the parent and are not left behind

        # WARNING: This uses the prctl(2) call and is Linux-specific.

        prctl.set_pdeathsig(signal.SIGHUP)

        # exec command specified in arguments,

        # searching the $PATH, keeping all environment

        os.execvpe(args[0], args, os.environ)

        sys.stderr.write("execvpe failed, exiting with non-zero status")

        os.exit(1)

    # In parent process:

    iofname = "/proc/%d/io" % pid

    iof = open(iofname, "r", 0)   # 0: unbuffered open

    sys.stderr.write("%s: created child PID = %d, monitoring file %s\n" %

                     (sys.argv[0], pid, iofname))

    while True:

        # check if the child process is still alive

        (wpid, status) = os.waitpid(pid, os.WNOHANG)

        if wpid == pid:

            report_wait_status(pid, status)

            if (os.WIFEXITED(status) or os.WIFSIGNALED(status)):

                if not (os.WIFEXITED(status) and os.WEXITSTATUS(status) == 0):

                    return 1

                else:

                    return 0

        # retrieve the current values of the read/write byte counters

        iof.seek(0)

        for l in iof.readlines():

            if l.startswith("rchar:"):

                rchar = int(l.split(': ')[1])

            if l.startswith("wchar:"):

                wchar = int(l.split(': ')[1])

        # Construct notification of type 'ganeti-create-progress'

        msg = dict(type="ganeti-create-progress",

                   instance=opts.instance_name)

        if opts.read_bytes:

            msg['rprogress'] =  float("%2.2f" %

                                      (rchar * 100.0 / opts.read_bytes))

        if opts.write_bytes:

            msg['wprogress'] =  float("%2.2f" %

                                      (wchar * 100.0 / opts.write_bytes))

        # and send it over AMQP

        amqp.send_message(msg)

        # Sleep for a while

        time.sleep(3)

if __name__ == "__main__":

    sys.exit(main())

#

# Unit Tests for the Ganeti-specific interfaces

#

# Provides unit tests for the code implementing

# the Ganeti notification daemon and the Ganeti hook in Synnefo.

#

# Copyright 2011 Greek Research and Technology Network

#

import logging

from django.test import TestCase

from django.conf import settings

from ganeti.hooks import ganeti_net_status

class GanetiHookTestCase(TestCase):

    def setUp(self):

        # Example Ganeti environment, based on from

        # http://docs.ganeti.org/ganeti/master/html/hooks.html?highlight=hooks#examples

        self.env = {

            'GANETI_CLUSTER': 'cluster1.example.com',

            'GANETI_DATA_DIR': '/var/lib/ganeti',

            'GANETI_FORCE': 'False',

            'GANETI_HOOKS_PATH': 'instance-start',

            'GANETI_HOOKS_PHASE': 'post',

            'GANETI_HOOKS_VERSION': '2',

            'GANETI_INSTANCE_DISK0_MODE': 'rw',

            'GANETI_INSTANCE_DISK0_SIZE': '128',

            'GANETI_INSTANCE_DISK_COUNT': '1',

            'GANETI_INSTANCE_DISK_TEMPLATE': 'drbd',

            'GANETI_INSTANCE_MEMORY': '128',

            'GANETI_INSTANCE_TAGS': 'tag1 synnefo:network:0:protected tag2',

            'GANETI_INSTANCE_NAME': 'instance2.example.com',

            'GANETI_INSTANCE_NIC0_BRIDGE': 'xen-br0',

            'GANETI_INSTANCE_NIC0_IP': '147.102.3.1',

            'GANETI_INSTANCE_NIC0_MAC': '00:01:de:ad:be:ef',

            'GANETI_INSTANCE_NIC1_MAC': '00:01:de:ad:ba:be',

            'GANETI_INSTANCE_NIC2_MAC': '00:01:02:03:04:05',

            'GANETI_INSTANCE_NIC2_IP': '147.102.3.98',

            'GANETI_INSTANCE_NIC_COUNT': '3',

            'GANETI_INSTANCE_OS_TYPE': 'debootstrap',

            'GANETI_INSTANCE_PRIMARY': 'node3.example.com',

            'GANETI_INSTANCE_SECONDARY': 'node5.example.com',

            'GANETI_INSTANCE_STATUS': 'down',

            'GANETI_INSTANCE_VCPUS': '1',

            'GANETI_MASTER': 'node1.example.com',

            'GANETI_OBJECT_TYPE': 'INSTANCE',

            'GANETI_OP_CODE': 'OP_INSTANCE_STARTUP',

            'GANETI_OP_TARGET': 'instance2.example.com'

        }

    def test_ganeti_net_status(self):

        e = self.env

        expected = {

            'type': 'ganeti-net-status',

            'instance': 'instance2.example.com',

            'nics': [

                {

                    'ip': '147.102.3.1', 'mac': '00:01:de:ad:be:ef',

                    'link': 'xen-br0', 'ipv6': '2001:db8::201:deff:fead:beef',

                    'firewall': 'protected'

                },

                { 'mac': '00:01:de:ad:ba:be' },

                { 'ip': '147.102.3.98', 'mac': '00:01:02:03:04:05' }

            ]

        }

        self.assertEqual(ganeti_net_status(logging, e), expected)