Synnefo

#!/usr/bin/env python

import sys

from IPy import IP

if len(sys.argv) != 3:

    sys.stderr.write("Usage: %s <mac_address> <IPv6 prefix>\n" % sys.argv[0])

    sys.exit(127)

mac = sys.argv[1]

try:

    prefix = IP(sys.argv[2])

except ValueError:

    sys.stderr.write("Invalid IPv6 prefix '%s'\n" % sys.argv[2])

if prefix.version() != 6:

    sys.stderr.write("%s is not a valid IPv6 prefix\n" % prefix)

    sys.exit(1)

if prefix.prefixlen() != 64:

    sys.stderr.write("Cannot generate an EUI-64 address on a non-64 subnet\n")

    sys.exit(1)

mac_parts = mac.split(":")

pfx_parts = prefix.net().strFullsize().split(":")

if len(mac_parts) != 6:

    sys.stderr.write("%s is not a valid MAC-48 address\n" % mac)

    sys.exit(1)

eui64 = mac_parts[:3] + [ "ff", "fe" ] + mac_parts[3:]

eui64[0] = "%02x" % (int(eui64[0], 16) ^ 0x02)

ip = ":".join(pfx_parts[:4])

for l in range(0, len(eui64), 2):

    ip += ":%s" % "".join(eui64[l:l+2])

try:

    print IP(ip).strCompressed()

except ValueError, e:

    sys.stderr.write("Ooops, something went wrong: '%s'!\n" % str(e))

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

from synnefo.util.mac2eui64 import mac2eui64

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

                {

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

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

                },

            ipv4=nic.get('ip', ''),

            ipv6=nic.get('ipv6',''))

# 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 THE REGENTS AND CONTRIBUTORS ``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 THE REGENTS 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.

# Callback functions used by the dispatcher to process incoming notifications

# from AMQP queues.

import socket

import traceback

import json

import logging

import sys

from synnefo.db.models import VirtualMachine

from synnefo.logic import utils, backend, email_send

_logger = logging.getLogger("synnefo.dispatcher")

def update_db(message):

    """Process the status of a VM based on a ganeti status message"""

    _logger.debug("Processing ganeti-op-status msg: %s", message.body)

    try:

        msg = _parse_json(message.body)

        if msg["type"] != "ganeti-op-status":

            _logger.error("Message is of unknown type %s.", msg["type"])

            return

        if msg["operation"] == "OP_INSTANCE_QUERY_DATA":

            return status_job_finished(message)

        vmid = utils.id_from_instance_name(msg["instance"])

        vm = VirtualMachine.objects.get(id=vmid)

        backend.process_op_status(vm, msg["jobId"], msg["operation"],

                                  msg["status"], msg["logmsg"])

        _logger.debug("Done processing ganeti-op-status msg for vm %s.",

                      msg["instance"])

        message.channel.basic_ack(message.delivery_tag)

    except KeyError:

        _logger.error("Malformed incoming JSON, missing attributes: %s",

                      message.body)

    except VirtualMachine.InvalidBackendIdError:

        _logger.debug("Ignoring msg for unknown instance %s.",

                      msg["instance"])

    except VirtualMachine.DoesNotExist:

        _logger.error("VM for instance %s with id %d not found in DB.",

                      msg["instance"], vmid)

    except Exception as e:

        _logger.error("Unexpected error:\n%s" %

            "".join(traceback.format_exception(*sys.exc_info())))

def update_net(message):

    """Process a network status update notification from Ganeti"""

    _logger.debug("Processing ganeti-net-status msg: %s", message.body)

    try:

        msg = _parse_json(message.body)

        if msg["type"] != "ganeti-net-status":

            _logger.error("Message is of unknown type %s", msg["type"])

            return

        vmid = utils.id_from_instance_name(msg["instance"])

        vm = VirtualMachine.objects.get(id=vmid)

        backend.process_net_status(vm, msg["nics"])

        _logger.debug("Done processing ganeti-net-status msg for vm %s.",

                      msg["instance"])

        message.channel.basic_ack(message.delivery_tag)

    except KeyError:

        _logger.error("Malformed incoming JSON, missing attributes: %s",

                      message.body)

    except VirtualMachine.InvalidBackendIdError:

        _logger.debug("Ignoring msg for unknown instance %s.",

                      msg["instance"])

    except VirtualMachine.DoesNotExist:

        _logger.error("VM for instance %s with id %d not found in DB.",

                      msg["instance"], vmid)

    except Exception as e:

        _logger.error("Unexpected error:\n%s" %

            "".join(traceback.format_exception(*sys.exc_info())))

def send_email(message):

    """Process an email submission request"""

    try:

        msg = json.loads(message.body)

        email_send.send(sender=msg['frm'], recipient = msg['to'],

                        body=msg['body'], subject=msg['subject'])

        message.channel.basic_ack(message.delivery_tag)

    except KeyError:

        _logger.error("Malformed incoming JSON, missing attributes: %s",

                      message.body)

    except socket.error as e:

        _logger.error("Cannot connect to SMTP server:%s\n", e)

    except Exception as e:

        _logger.error("Unexpected error:%s\n", e)

        raise

def update_credits(message):

    _logger.debug("Request to update credits")

    message.channel.basic_ack(message.delivery_tag)

def trigger_status_update(message):

    """

        Triggers a status update job for a specific VM id.

    """

    _logger.debug("Request to trigger status update: %s", message.body)

    try:

        msg = _parse_json(message.body)

        if msg["type"] != "reconcile" :

             _logger.error("Message is of unknown type %s", msg["type"])

             return

        if msg["vmid"] == "" :

            _logger.error("Reconciliate message does not specify a VM id")

            return

        vm = VirtualMachine.objects.get(id=msg["vmid"])

        backend.request_status_update(vm)

        message.channel.basic_ack(message.delivery_tag)

    except KeyError as k:

        _logger.error("Malformed incoming JSON, missing attributes: %s", k)

    except Exception as e:

        _logger.error("Unexpected error:%s", e)

def status_job_finished (message) :

    """

        Updates VM status based on a previously sent status update request

    """

    try:

        msg = _parse_json(message.body)

        if msg["operation"] != 'OP_INSTANCE_QUERY_DATA':

            _logger.error("Message is of unknown type %s", msg["operation"])

            return

        if msg["status"] != "success" :

            _logger.warn("Ignoring non-success status update from job %d on VM %s",

                          msg['jobId'], msg['instance'])

            message.channel.basic_ack(message.delivery_tag)

            return

        status = backend.get_job_status(msg['jobId'])

        _logger.debug("Node status job result: %s" % status)

        if status['summary'][0] != u'INSTANCE_QUERY_DATA' :

             _logger.error("Status update is of unknown type %s", status['summary'])

             return

        conf_state = status['opresult'][0][msg['instance']]['config_state']

        run_state = status['opresult'][0][msg['instance']]['run_state']

        # XXX: The following assumes names like snf-12

        instid = msg['instance'].split('-')[1]

        vm = VirtualMachine.objects.get(id = instid)

        if run_state == "up":

            opcode = "OP_INSTANCE_REBOOT"

        else :

            opcode = "OP_INSTANCE_SHUTDOWN"

        backend.process_op_status(vm=vm, jobid=msg['jobId'],opcode=opcode,

                                  status="success",

                                  logmsg="Reconciliation: simulated event")

        message.channel.basic_ack(message.delivery_tag)

    except KeyError as k:

        _logger.error("Malformed incoming JSON, missing attributes: %s", k)

    except Exception as e:

        _logger.error("Unexpected error:%s"%e)

def dummy_proc(message):

    try:

        msg = _logger.debug(message.body)

        _logger.debug("Msg (exchange:%s) ", msg)

        message.channel.basic_ack(message.delivery_tag)

    except Exception as e:

        _logger.error("Could not receive message %s" % e.message)

        pass

def _parse_json(data):

    try:

        return json.loads(data)

    except Exception as e:

        _logger.error("Could not parse JSON file: %s", e)

        raise

from synnefo.logic import callbacks

                callback = getattr(callbacks, binding[3])

# Public IPv6: A /64 IPv6 prefix for autoconfiguration with EUI-64 addresses

PUBLIC_IPV6_PREFIX = "2001:db8::/64"

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

from IPy import IP

# Adapted from NFDHCPD's mac2eui64 utility, repository commit:feca7bb95

def mac2eui64(mac, prefixstr):

    try:

        prefix = IP(prefixstr)

    except ValueError:

        raise Exception("Invalid IPv6 prefix '%s'" % prefixstr)

    if prefix.version() != 6:

        raise Exception("%s is not a valid IPv6 prefix" % prefixstr)

    if prefix.prefixlen() != 64:

        raise Exception("Cannot generate an EUI-64 address on a non-64 subnet")

    mac_parts = mac.split(":")

    pfx_parts = prefix.net().strFullsize().split(":")

    if len(mac_parts) != 6:

        raise Exception("%s is not a valid MAC-48 address" % mac)

    eui64 = mac_parts[:3] + [ "ff", "fe" ] + mac_parts[3:]

    eui64[0] = "%02x" % (int(eui64[0], 16) ^ 0x02)

    ip = ":".join(pfx_parts[:4])

    for l in range(0, len(eui64), 2):

        ip += ":%s" % "".join(eui64[l:l+2])

    return IP(ip).strCompressed()

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