Synnefo

from __future__ import with_statement

import re

import tempfile

import ast

from snfdeploy import massedit

    print("Loading configuration for synnefo...")

    print(" * Using config files under %s..." % confdir)

    autoconf = ast.literal_eval(autoconf)

    disable_colors = ast.literal_eval(disable_colors)

    env.key_inject = ast.literal_eval(key_inject)

    env.env = Env(conf)

    env.local = autoconf

    if disable_colors:

        disable_color()

    else:

    else:

    env.roledefs = {

        "nodes": env.env.ips,

        "cms": [env.env.cms.ip],

        "mq": [env.env.mq.ip],

        "db": [env.env.db.ip],

        "ns": [env.env.ns.ip],

        "client": [env.env.client.ip],

        "router": [env.env.router.ip],

def install_package(package):

    debug(env.host, " * Installing package %s..." % package)

    host_info = env.env.ips_info[env.host]

    env.env.update_packages(host_info.os)

    if ast.literal_eval(env.env.use_local_packages):

        with settings(warn_only=True):

                        capture=True)

            if deb:

                put(deb, "/tmp/")

                try_run("rm /tmp/%s" % os.path.basename(deb))

                return

    info = getattr(env.env, package)

    elif info:

    else:

    return

@roles("ns")

def update_ns_for_ganeti():

    update_arecord(env.env.cluster)

    update_ptrrecord(env.env.cluster)

    try_run("/etc/init.d/bind9 restart")

    """.format(host.ptrrecord, filename)

    try_run(cmd)

@roles("nodes")

def apt_get_update():

    debug(env.host, "apt-get update....")

    try_run("apt-get update")

@roles("ns")

def setup_ns():

    debug(env.host, "Setting up name server..")

    install_package("bind9")

    tmpl = "/etc/bind/named.conf.local"

    replace = {

    custom = customize_settings_from_tmpl(tmpl, replace)

    put(custom, tmpl)

    try_run("mkdir -p /etc/bind/zones")

    tmpl = "/etc/bind/zones/example.com"

    replace = {

    custom = customize_settings_from_tmpl(tmpl, replace)

    remote = "/etc/bind/zones/" + env.env.domain

    put(custom, remote)

    try_run("mkdir -p /etc/bind/rev")

    tmpl = "/etc/bind/rev/synnefo.in-addr.arpa.zone"

    replace = {

    custom = customize_settings_from_tmpl(tmpl, replace)

    put(custom, tmpl)

    tmpl = "/etc/bind/named.conf.options"

    replace = {

    custom = customize_settings_from_tmpl(tmpl, replace)

    put(custom, tmpl, mode=0644)

    for n, info in env.env.nodes_info.iteritems():

        try_run("ping -c 1 " + info.ip, True)

@roles("nodes")

def check_dns():

    debug(env.host, "Checking fqdns for synnefo..")

    for n, info in env.env.roles.iteritems():

        try_run("ping -c 1 " + info.fqdn, True)

@roles("nodes")

def check_connectivity():

    debug(env.host, "Checking internet connectivity..")

@roles("ips")

def add_keys():

    if not env.key_inject:

    else:

    try_run("mkdir -p /root/.ssh")

    cmd = """

for f in $(ls /root/.ssh/*); do

    files = ["authorized_keys", "id_dsa", "id_dsa.pub",

             "id_rsa", "id_rsa.pub"]

    for f in files:

    cmd = """

if [ -e /root/.ssh/authorized_keys.bak ]; then

    debug(env.host, "Updating exising authorized keys..")

    try_run(cmd)

@roles("ips")

def setup_resolv_conf():

    debug(env.host, "Tweak /etc/resolv.conf...")

    try_run("cp /etc/resolv.conf /etc/resolv.conf.bak")

    tmpl = "/etc/resolv.conf"

    replace = {

    custom = customize_settings_from_tmpl(tmpl, replace)

    try:

    except:

    try_run("chattr +i /etc/resolv.conf")

def try_run(cmd, abort=False):

    try:

    except:

def create_bridges():

    debug(env.host, " * Creating bridges...")

def connect_bridges():

    debug(env.host, " * Connecting bridges...")

    #try_run(cmd)

    try_run(cmd)

    host_info = env.env.ips_info[env.host]

    if host_info.os == "squeeze":

    else:

    replace = {}

    custom = customize_settings_from_tmpl(tmpl, replace)

    put(custom, tmpl)

    try_run(cmd)

    try_run("/etc/init.d/postgresql restart")

@roles("db")

def setup_db():

    debug(env.host, "Setting up DataBase server...")

    }

    custom = customize_settings_from_tmpl(tmpl, replace)

    put(custom, tmpl, mode=0644)

    try_run("/etc/init.d/gunicorn restart")

@roles("accounts")

def astakos_loaddata():

    debug(env.host, " * Loading initial data to astakos...")

@roles("accounts")

def add_user():

    debug(env.host, " * adding user %s to astakos..." % env.env.user_email)

    cmd = """

    snf-manage user-add {0} {1} {2}

    """.format(email, name, lastname)

@roles("accounts")

def activate_user(user_email=None):

    if not user_email:

    debug(env.host, " * Activate user %s..." % user_email)

    with settings(host_string=env.env.db.ip):

        uid, user_auth_token, user_uuid = get_auth_token_from_db(user_email)

    """.format(uid)

    try_run(cmd)

@roles("accounts")

def setup_astakos():

    debug(env.host, "Setting up snf-astakos-app...")

    tmpl = "/etc/synnefo/astakos.conf"

    replace = {

    }

    custom = customize_settings_from_tmpl(tmpl, replace)

    put(custom, tmpl, mode=0644)

    if env.csrf_disable:

cat <<EOF >> /etc/synnefo/astakos.conf

try:

  MIDDLEWARE_CLASSES.remove('django.middleware.csrf.CsrfViewMiddleware')

  pass

EOF

"""

    try_run("/etc/init.d/gunicorn restart")

@roles("accounts")

def get_service_details(service="pithos"):

    result = try_run("snf-manage component-list")

    r = re.compile(r".*%s.*" % service, re.M)

    service_id, _, _, service_token = r.search(result).group().split()

@roles("db")

def get_auth_token_from_db(user_email=None):

    if not user_email:

    cmd = """

    result = try_run(cmd)

    r = re.compile(r"(\d+)[ |]*(\S+)[ |]*(\S+)[ |]*" + user_email, re.M)

def cms_loaddata():

    debug(env.host, " * Loading cms initial data...")

    if env.cms_pass:

    tmpl = "/tmp/sites.json"

    replace = {}

    custom = customize_settings_from_tmpl(tmpl, replace)

def setup_cms():

    debug(env.host, "Setting up cms...")

    if env.cms_pass:

    with settings(hide("everything")):

        try_run("ping -c1 accounts." + env.env.domain)

    setup_gunicorn()

    put(custom, tmpl, mode=0644)

    try_run("/etc/init.d/gunicorn restart")

    cmd = """

    snf-manage syncdb

    snf-manage migrate --delete-ghost-migrations

@roles("nodes")

def setup_nfs_clients():

    if env.host == env.env.pithos.ip:

    host_info = env.env.ips_info[env.host]

    debug(env.host, " * Mounting pithos NFS mount point...")

    install_package("nfs-common")

    for d in [env.env.pithos_dir, env.env.image_dir]:

@roles("pithos")

def update_nfs_exports(ip):

    tmpl = "/tmp/exports"

    replace = {

    custom = customize_settings_from_tmpl(tmpl, replace)

    put(custom, tmpl)

    try_run("cat %s >> /etc/exports" % tmpl)

    try_run("/etc/init.d/nfs-kernel-server restart")

@roles("pithos")

def setup_nfs_server():

    debug(env.host, " * Setting up NFS server for pithos...")

    result = try_run(cmd)

    cmd = """

    echo "{0} {1}{2} write" >> /var/lib/ganeti/rapi/users

    try_run(cmd)

    try_run("/etc/init.d/ganeti restart")

@roles("master")

def add_nodes():

    nodes = env.env.cluster_nodes.split(",")

    for n in nodes:

        add_node(n)

@roles("master")

def add_node(node):

    node_info = env.env.nodes_info[node]

    debug(env.host, " * Adding node %s to Ganeti backend..." % node_info.fqdn)

    try_run(cmd)

@roles("ganeti")

def enable_drbd():

    if env.enable_drbd:

        debug(env.host, " * Enabling DRBD...")

        try_run("modprobe drbd minor_count=255 usermode_helper=/bin/true")

@roles("master")

def setup_drbd_dparams():

    if env.enable_drbd:

        cmd = """

        gnt-cluster modify --disk-parameters=drbd:metavg={0}

        gnt-group modify --disk-parameters=drbd:metavg={0} default

        """.format(env.env.vg)

        try_run(cmd)

@roles("master")

def enable_lvm():

    if env.enable_lvm:

        debug(env.host, " * Disabling LVM...")

        try_run("gnt-cluster modify --no-lvm-storage")

@roles("master")

def destroy_cluster():

    debug(env.host, " * Destroying Ganeti cluster...")

    allnodes = env.env.cluster_hostnames[:]

    allnodes.remove(env.host)

    for n in allnodes:

    try_run("gnt-cluster destroy --yes-do-it")

    extra = " --no-lvm-storage --no-drbd-storage "

    cmd = """

    gnt-cluster init --enabled-hypervisors=kvm \

    """.format(extra, env.env.common_bridge,

               env.env.cluster_netdev, env.env.cluster.fqdn)

    try_run(cmd)

def setup_iptables():

    debug(env.host, " * Setting up iptables to mangle DHCP requests...")

    cmd = """

    """

    try_run(cmd)

@roles("ganeti")

def setup_network():

    install_package("nfqueue-bindings-python")

    install_package("nfdhcpd")

    tmpl = "/etc/nfdhcpd/nfdhcpd.conf"

    replace = {

    custom = customize_settings_from_tmpl(tmpl, replace)

    put(custom, tmpl)

    try_run("/etc/init.d/nfdhcpd restart")

    install_package("snf-network")

    cmd = """

    """

    try_run(cmd)

@roles("cyclades")

def get_backend_id(cluster_name="ganeti1.synnefo.deploy.local"):

    return backend_id

@roles("cyclades")

def add_backend():

    with settings(hide("everything")):

        try_run("ping -c1 " + env.env.cluster.fqdn)

    cmd = """

    backend_id = get_backend_id(env.env.cluster.fqdn)

    try_run("snf-manage backend-modify --drained=False " + backend_id)

@roles("cyclades")

def pin_user_to_backend(user_email):

    backend_id = get_backend_id(env.env.cluster.fqdn)

cat <<EOF >> /etc/synnefo/cyclades.conf

BACKEND_PER_USER = {

}

EOF

/etc/init.d/gunicorn restart

    try_run(cmd)

@roles("cyclades")

def add_pools():

    try_run("snf-manage pool-create --type=bridge --base=prv --size=20")

    debug(env.host, " * Registering services to astakos...")

    for service in ["cyclades", "pithos", "astakos"]:

        filename = "%s_services.json" % service

        cmd = "snf-manage service-import --json=%s" % filename

        run(cmd)

    try_run(cmd)

    try_run("/etc/init.d/vncauthproxy restart")

@roles("client")

def setup_kamaki():

    debug(env.host, "Setting up kamaki client...")

        try_run("ping -c1 pithos." + env.env.domain)

    with settings(host_string=env.env.db.ip):

    install_package("python-progress")

    install_package("kamaki")

    try_run(cmd)

    try_run("kamaki file create images")

@roles("client")

def upload_image(image="debian_base.diskdump"):

    debug(env.host, " * Uploading initial image to pithos...")

    try_run("wget {0} -O /tmp/{1}".format(env.env.debian_base_url, image))

    try_run("kamaki file upload --container images /tmp/{0} {0}".format(image))

@roles("client")

def register_image(image="debian_base.diskdump"):

    debug(env.host, " * Register image to plankton...")

    # with settings(host_string=env.env.db.ip):

    image_location = "images:{0}".format(image)

    cmd = """

    sleep 5

    """.format(image_location)

    try_run(cmd)

@roles("client")

def setup_burnin():

    debug(env.host, "Setting up burnin testing tool...")

    install_package("kamaki")

    install_package("snf-tools")

@roles("pithos")

def add_image_locally():

    image = "debian_base.diskdump"

@roles("master")

def gnt_instance_add(name="test"):

    debug(env.host, " * Adding test instance to Ganeti...")

    cmd = """

    """.format(osp, name)

    try_run(cmd)

@roles("master")

    debug(env.host, " * Adding test network to Ganeti...")

    cmd = """

    gnt-network add --network={1} --gateway={2} {0}

    """.format(name, subnet, gw, mode, link)

    try_run(cmd)

@roles("ips")

def test():

    debug(env.host, "Testing...")