Synnefo

#!/usr/bin/python

import time

import ipaddr

import os

import signal

import ConfigParser

import sys

import re

import random

import subprocess

import imp

import binascii

HEADER = '\033[95m'

OKBLUE = '\033[94m'

OKGREEN = '\033[92m'

WARNING = '\033[93m'

FAIL = '\033[91m'

ENDC = '\033[0m'

def disable_color():

    global HEADER

    global OKBLUE

    global OKGREEN

    global WARNING

    global FAIL

    global ENDC

    HEADER = ''

    OKBLUE = ''

    OKGREEN = ''

    WARNING = ''

    FAIL = ''

    ENDC = ''

if not sys.stdout.isatty():

    disable_color()

class Host(object):

    def __init__(self, hostname, ip, mac, domain, os):

        self.hostname = hostname

        self.ip = ip

        self.mac = mac

        self.domain = domain

        self.os = os

    @property

    def fqdn(self):

        return self.hostname + "." + self.domain

    @property

    def arecord(self):

        return self.hostname + " IN A " + self.ip + "\n"

    @property

    def ptrrecord(self):

        return ".".join(raddr(self.ip)) + " IN PTR " + self.fqdn + ".\n"

class Alias(Host):

    def __init__(self, host, alias):

        super(Alias, self).__init__(host.hostname, host.ip, host.mac,

                                    host.domain, host.os)

        self.alias = alias

    @property

    def cnamerecord(self):

        return (self.alias + " IN CNAME " + self.hostname + "." +

                self.domain + ".\n")

    @property

    def fqdn(self):

        return self.alias + "." + self.domain

class Env(object):

    def update_packages(self, os):

        for section in self.conf.files[os]:

            self.evaluate(os, section)

    def evaluate(self, filename, section):

        for k, v in self.conf.get_section(filename, section):

            setattr(self, k, v)

    def __init__(self, conf):

        self.conf = conf

        for f, sections in conf.files.iteritems():

            for s in sections:

                self.evaluate(f, s)

        self.node2hostname = dict(conf.get_section("nodes", "hostnames"))

        self.node2ip = dict(conf.get_section("nodes", "ips"))

        self.node2mac = dict(conf.get_section("nodes", "macs"))

        self.node2os = dict(conf.get_section("nodes", "os"))

        self.hostnames = [self.node2hostname[n]

                          for n in self.nodes.split(",")]

        self.ips = [self.node2ip[n]

                    for n in self.nodes.split(",")]

        self.cluster_hostnames = [self.node2hostname[n]

                                  for n in self.cluster_nodes.split(",")]

        self.cluster_ips = [self.node2ip[n]

                            for n in self.cluster_nodes.split(",")]

        self.net = ipaddr.IPNetwork(self.subnet)

        self.nodes_info = {}

        self.hosts_info = {}

        self.ips_info = {}

        for node in self.nodes.split(","):

            host = Host(self.node2hostname[node],

                        self.node2ip[node],

                        self.node2mac[node], self.domain, self.node2os[node])

            self.nodes_info[node] = host

            self.hosts_info[host.hostname] = host

            self.ips_info[host.ip] = host

        self.cluster = Host(self.cluster_name, self.cluster_ip, None,

                            self.domain, None)

        self.master = self.nodes_info[self.master_node]

        self.roles = {}

        for role, node in conf.get_section("synnefo", "roles"):

            self.roles[role] = Alias(self.nodes_info[node], role)

            setattr(self, role, self.roles[role])

class Conf(object):

    files = {

        "nodes": ["network", "info"],

        "deploy": ["dirs", "packages", "keys", "options"],

        "vcluster": ["cluster", "image", "network"],

        "synnefo": ["cred", "synnefo", "roles"],

        "squeeze": ["debian", "ganeti", "synnefo", "other"],

        "wheezy": ["debian", "ganeti", "synnefo", "other"],

    }

    confdir = "/etc/snf-deploy"

    def get_ganeti(self, cluster_name):

        self.files["ganeti"] = [cluster_name]

    def __init__(self, args):

        self.confdir = args.confdir

        self.get_ganeti(args.cluster_name)

        for f in self.files.keys():

            setattr(self, f, self.read_config(f))

        for f, sections in self.files.iteritems():

            for s in sections:

                for k, v in self.get_section(f, s):

                    if getattr(args, k, None):

                        self.set(f, s, k, getattr(args, k))

        if args.autoconf:

            self.autoconf()

    def autoconf(self):

        #domain = get_domain()

        #if domain:

        #    self.nodes.set("network", "domain", get_domain())

        # self.nodes.set("network", "subnet", "/".join(get_netinfo()))

        # self.nodes.set("network", "gateway", get_default_route()[0])

        self.nodes.set("hostnames", "node1", get_hostname())

        self.nodes.set("ips", "node1", get_netinfo()[0])

        self.nodes.set("info", "nodes", "node1")

        self.nodes.set("info", "public_iface", get_default_route()[1])

    def read_config(self, f):

        config = ConfigParser.ConfigParser()

        config.optionxform = str

        filename = os.path.join(self.confdir, f) + ".conf"

        config.read(filename)

        return config

    def set(self, conf, section, option, value):

        c = getattr(self, conf)

        c.set(section, option, value)

    def get(self, conf, section, option):

        c = getattr(self, conf)

        return c.get(section, option, True)

    def get_section(self, conf, section):

        c = getattr(self, conf)

        return c.items(section, True)

    def print_config(self):

        for f in self.files.keys():

            getattr(self, f).write(sys.stdout)

def debug(host, msg):

    print HEADER + host + \

        OKBLUE + ": " + msg + ENDC

def check_pidfile(pidfile):

    print("Checking pidfile " + pidfile)

    try:

        f = open(pidfile, "r")

        pid = f.readline()

        os.kill(int(pid), signal.SIGKILL)

        f.close()

        os.remove(pidfile)

        time.sleep(5)

    except:

        pass

def random_mac():

    mac = [0x52, 0x54, 0x56,

           random.randint(0x00, 0xff),

           random.randint(0x00, 0xff),

           random.randint(0x00, 0xff)]

    return ':'.join(map(lambda x: "%02x" % x, mac))

def create_dir(d, clean=False):

    os.system("mkdir -p " + d)

    if clean:

        try:

            os.system("rm -f %s/*" % d)

        except:

            pass

def get_netinfo():

    _, pdev = get_default_route()

    r = re.compile(".*inet (\S+)/(\S+).*")

    s = subprocess.Popen(['ip', 'addr', 'show', 'dev', pdev],

                         stdout=subprocess.PIPE)

    for line in s.stdout.readlines():

        match = r.search(line)

        if match:

            ip, size = match.groups()

            break

    return ip, size

def get_hostname():

    s = subprocess.Popen(['hostname', '-s'], stdout=subprocess.PIPE)

    return s.stdout.readline().strip()

def get_domain():

    s = subprocess.Popen(['hostname', '-d'], stdout=subprocess.PIPE)

    return s.stdout.readline().strip()

def get_default_route():

    r = re.compile("default via (\S+) dev (\S+)")

    s = subprocess.Popen(['ip', 'route'], stdout=subprocess.PIPE)

    for line in s.stdout.readlines():

        match = r.search(line)

        if match:

            gw, dev = match.groups()

            break

    return (gw, dev)

def import_conf_file(filename, directory):

    return imp.load_module(filename, *imp.find_module(filename, [directory]))

def raddr(addr):

    return list(reversed(addr.replace("/", "-").split(".")))

def random_secret():

    return binascii.b2a_hex(os.urandom(15))