Statistics
| Branch: | Tag: | Revision:

root / snf-deploy / fabfile.py @ 8665d8b6

History | View | Annotate | Download (37.9 kB)

1
from __future__ import with_statement
2
from fabric.api import *
3
from fabric.contrib.console import confirm
4
from random import choice
5
from fabric.operations import run, put
6
import re
7
import shutil, os
8
from functools import wraps
9
import imp
10
import ConfigParser
11
import sys
12
import tempfile
13
import ast
14
from snfdeploy.lib import *
15
from snfdeploy import massedit
16

    
17

    
18
def setup_env(confdir="conf", packages="packages",
19
              templates="files", cluster_name="ganeti1", autoconf=False, disable_colors=False, key_inject=False):
20
    print("Loading configuration for synnefo...")
21
    print(" * Using config files under %s..." % confdir)
22
    print(" * Using %s and %s for packages and templates accordingly..." % (packages, templates))
23

    
24
    autoconf = ast.literal_eval(autoconf)
25
    disable_colors = ast.literal_eval(disable_colors)
26
    env.key_inject = ast.literal_eval(key_inject)
27
    conf = Conf.configure(confdir=confdir, cluster_name=cluster_name, autoconf=autoconf)
28
    env.env = Env(conf)
29

    
30
    env.local = autoconf
31
    env.password = env.env.password
32
    env.user = env.env.user
33
    env.shell = "/bin/bash -c"
34

    
35
    if disable_colors:
36
        disable_color()
37

    
38
    if env.env.cms.hostname in [env.env.accounts.hostname, env.env.cyclades.hostname, env.env.pithos.hostname]:
39
      env.cms_pass = True
40
    else:
41
      env.cms_pass = False
42

    
43
    if env.env.accounts.hostname in [env.env.cyclades.hostname, env.env.pithos.hostname]:
44
      env.csrf_disable = True
45
    else:
46
      env.csrf_disable = False
47

    
48

    
49
    env.roledefs = {
50
        "nodes": env.env.ips,
51
        "ips": env.env.ips,
52
        "accounts": [env.env.accounts.ip],
53
        "cyclades": [env.env.cyclades.ip],
54
        "pithos": [env.env.pithos.ip],
55
        "cms": [env.env.cms.ip],
56
        "mq": [env.env.mq.ip],
57
        "db": [env.env.db.ip],
58
        "ns": [env.env.ns.ip],
59
        "client": [env.env.client.ip],
60
        "router": [env.env.router.ip],
61
    }
62

    
63
    env.enable_lvm = False
64
    env.enable_drbd = False
65
    if ast.literal_eval(env.env.create_extra_disk) and env.env.extra_disk:
66
        env.enable_lvm = True
67
        env.enable_drbd = True
68

    
69
    env.roledefs.update({
70
        "ganeti": env.env.cluster_ips,
71
        "master": [env.env.master.ip],
72
    })
73

    
74

    
75
def install_package(package):
76
    debug(env.host, " * Installing package %s..." % package)
77
    APT_GET = "export DEBIAN_FRONTEND=noninteractive ;apt-get install -y --force-yes "
78

    
79
    if ast.literal_eval(env.env.use_local_packages):
80
        with settings(warn_only=True):
81
            deb = local("ls %s/%s*deb" % (env.env.packages, package))
82
            if deb:
83
                debug(env.host, " * Package %s found in %s..." % (package, env.env.packages))
84
                put(deb, "/tmp/")
85
                try_run("dpkg -i /tmp/%s*deb || " % package + APT_GET + "-f")
86
                try_run("rm /tmp/%s*deb" % package)
87
                return
88

    
89
    info = getattr(env.env, package)
90
    if info in ["stable", "squeeze-backports", "testing", "unstable"]:
91
        APT_GET += " -t %s %s " % (info, package)
92
    elif info:
93
        APT_GET += " %s=%s " % (package, info)
94
    else:
95
        APT_GET += package
96

    
97
    try_run(APT_GET)
98

    
99
    return
100

    
101

    
102
@roles("ns")
103
def update_ns_for_ganeti():
104
    debug(env.host, "Updating name server entries for backend %s..." % env.env.cluster.fqdn)
105
    update_arecord(env.env.cluster)
106
    update_ptrrecord(env.env.cluster)
107
    try_run("/etc/init.d/bind9 restart")
108

    
109

    
110
@roles("ns")
111
def update_ns_for_node(node):
112
    info = env.env.nodes_info.get(node)
113
    update_arecord(info)
114
    update_ptrrecord(info)
115
    try_run("/etc/init.d/bind9 restart")
116

    
117

    
118
@roles("ns")
119
def update_arecord(host):
120
    filename = "/etc/bind/zones/" + env.env.domain
121
    cmd = """
122
    echo '{0}' >> {1}
123
    """.format(host.arecord, filename)
124
    try_run(cmd)
125

    
126

    
127
@roles("ns")
128
def update_cnamerecord(host):
129
    filename = "/etc/bind/zones/" + env.env.domain
130
    cmd = """
131
    echo '{0}' >> {1}
132
    """.format(host.cnamerecord, filename)
133
    try_run(cmd)
134

    
135

    
136
@roles("ns")
137
def update_ptrrecord(host):
138
    filename = "/etc/bind/rev/synnefo.in-addr.arpa.zone"
139
    cmd = """
140
    echo '{0}' >> {1}
141
    """.format(host.ptrrecord, filename)
142
    try_run(cmd)
143

    
144
@roles("nodes")
145
def apt_get_update():
146
    debug(env.host, "apt-get update....")
147
    try_run("apt-get update")
148

    
149
@roles("ns")
150
def setup_ns():
151
    debug(env.host, "Setting up name server..")
152
    #WARNING: this should be remove after we are done
153
    # because gevent does pick randomly nameservers and google does
154
    # not know our setup!!!!!
155
    apt_get_update()
156
    install_package("bind9")
157
    tmpl = "/etc/bind/named.conf.local"
158
    replace = {
159
      "domain": env.env.domain,
160
      }
161
    custom = customize_settings_from_tmpl(tmpl, replace)
162
    put(custom, tmpl)
163

    
164
    try_run("mkdir -p /etc/bind/zones")
165
    tmpl = "/etc/bind/zones/example.com"
166
    replace = {
167
      "domain": env.env.domain,
168
      "ns_node_ip": env.env.ns.ip,
169
      }
170
    custom = customize_settings_from_tmpl(tmpl, replace)
171
    remote = "/etc/bind/zones/" + env.env.domain
172
    put(custom, remote)
173

    
174
    try_run("mkdir -p /etc/bind/rev")
175
    tmpl = "/etc/bind/rev/synnefo.in-addr.arpa.zone"
176
    replace = {
177
      "domain": env.env.domain,
178
      }
179
    custom = customize_settings_from_tmpl(tmpl, replace)
180
    put(custom, tmpl)
181

    
182
    tmpl = "/etc/bind/named.conf.options"
183
    replace = {
184
      "NODE_IPS": ";".join(env.env.ips),
185
      }
186
    custom = customize_settings_from_tmpl(tmpl, replace)
187
    put(custom, tmpl, mode=0644)
188

    
189
    for role, info in env.env.roles.iteritems():
190
        if role == "ns":
191
            continue
192
        update_cnamerecord(info)
193
    for node, info in env.env.nodes_info.iteritems():
194
        update_arecord(info)
195
        update_ptrrecord(info)
196

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

    
199

    
200
@roles("nodes")
201
def check_dhcp():
202
    debug(env.host, "Checking IPs for synnefo..")
203
    for n, info in env.env.nodes_info.iteritems():
204
        try_run("ping -c 1 " + info.ip, True)
205

    
206
@roles("nodes")
207
def check_dns():
208
    debug(env.host, "Checking fqdns for synnefo..")
209
    for n, info in env.env.nodes_info.iteritems():
210
        try_run("ping -c 1 " + info.fqdn, True)
211

    
212
    for n, info in env.env.roles.iteritems():
213
        try_run("ping -c 1 " + info.fqdn, True)
214

    
215
@roles("nodes")
216
def check_connectivity():
217
    debug(env.host, "Checking internet connectivity..")
218
    try_run("ping -c 1 www.google.com", True)
219

    
220

    
221
@roles("nodes")
222
def check_ssh():
223
    debug(env.host, "Checking password-less ssh..")
224
    for n, info in env.env.nodes_info.iteritems():
225
        try_run("ssh " + info.fqdn + "  date", True)
226

    
227

    
228
@roles("ips")
229
def add_keys():
230
    if not env.key_inject:
231
      debug(env.host, "Skipping ssh keys injection..")
232
      return
233
    else:
234
      debug(env.host, "Adding rsa/dsa keys..")
235
    try_run("mkdir -p /root/.ssh")
236
    cmd = """
237
for f in $(ls /root/.ssh/*); do
238
  cp $f $f.bak
239
done
240
    """
241
    try_run(cmd)
242
    files = ["authorized_keys", "id_dsa", "id_dsa.pub",
243
             "id_rsa", "id_rsa.pub"]
244
    for f in files:
245
      tmpl = "/root/.ssh/" + f
246
      replace = {}
247
      custom = customize_settings_from_tmpl(tmpl, replace)
248
      put(custom, tmpl, mode=0600)
249

    
250
    cmd = """
251
if [ -e /root/.ssh/authorized_keys.bak ]; then
252
  cat /root/.ssh/authorized_keys.bak >> /root/.ssh/authorized_keys
253
fi
254
    """
255
    debug(env.host, "Updating exising authorized keys..")
256
    try_run(cmd)
257

    
258
@roles("ips")
259
def setup_resolv_conf():
260
    debug(env.host, "Tweak /etc/resolv.conf...")
261
    try_run("/etc/init.d/network-manager stop")
262
    tmpl = "/etc/dhcp/dhclient-enter-hooks.d/nodnsupdate"
263
    replace = {}
264
    custom = customize_settings_from_tmpl(tmpl, replace)
265
    put(custom, tmpl, mode=0644)
266
    try_run("cp /etc/resolv.conf /etc/resolv.conf.bak")
267
    tmpl = "/etc/resolv.conf"
268
    replace = {
269
      "domain": env.env.domain,
270
      "ns_node_ip": env.env.ns.ip,
271
      }
272
    custom = customize_settings_from_tmpl(tmpl, replace)
273
    try:
274
      put(custom, tmpl)
275
    except:
276
      pass
277
    try_run("chattr +i /etc/resolv.conf")
278

    
279

    
280
@roles("ips")
281
def setup_hosts():
282
    debug(env.host, "Tweaking /etc/hosts and ssh_config files...")
283
    try_run("echo StrictHostKeyChecking no >> /etc/ssh/ssh_config")
284
    cmd = " sed -i 's/^127.*/127.0.0.1 localhost/' /etc/hosts "
285
    try_run(cmd)
286
    host_info = env.env.ips_info[env.host]
287
    cmd = "hostname %s" % host_info.hostname
288
    try_run(cmd)
289
    cmd = "echo %s > /etc/hostname" % host_info.hostname
290
    try_run(cmd)
291

    
292

    
293
def try_run(cmd, abort=False):
294
    try:
295
      if env.local:
296
        return local(cmd, capture=True)
297
      else:
298
        return run(cmd)
299
    except:
300
      debug(env.host, "WARNING: command failed. Continuing anyway...")
301
      if abort:
302
        raise
303

    
304
def create_bridges():
305
    debug(env.host, " * Creating bridges...")
306
    install_package("bridge-utils")
307
    cmd = """
308
    brctl addbr {0} ; ip link set {0} up
309
    """.format(env.env.common_bridge)
310
    try_run(cmd)
311

    
312

    
313
def connect_bridges():
314
    debug(env.host, " * Connecting bridges...")
315
    cmd = """
316
    brctl addif {0} {1}
317
    """.format(env.env.common_bridge, env.env.public_iface)
318
    #try_run(cmd)
319

    
320

    
321
@roles("ganeti")
322
def setup_net_infra():
323
    debug(env.host, "Setup networking infrastracture..")
324
    create_bridges()
325
    connect_bridges()
326

    
327

    
328
@roles("ganeti")
329
def setup_lvm():
330
    debug(env.host, "create volume group %s for ganeti.." % env.env.vg)
331
    if env.enable_lvm:
332
        install_package("lvm2")
333
        cmd = """
334
        pvcreate {0}
335
        vgcreate {1} {0}
336
        """.format(env.env.extra_disk, env.env.vg)
337
        try_run(cmd)
338

    
339

    
340
def customize_settings_from_tmpl(tmpl, replace):
341
    debug(env.host, " * Customizing template %s..." % tmpl)
342
    local = env.env.templates + tmpl
343
    _, custom = tempfile.mkstemp()
344
    shutil.copyfile(local, custom)
345
    for k, v in replace.iteritems():
346
        regex = "re.sub('%{0}%', '{1}', line)".format(k.upper(), v)
347
        massedit.edit_files([custom], [regex], dry_run=False)
348

    
349
    return custom
350

    
351

    
352
@roles("nodes")
353
def setup_apt():
354
    debug(env.host, "Setting up apt sources...")
355
    install_package("curl")
356
    cmd = """
357
    echo 'APT::Install-Suggests "false";' >> /etc/apt/apt.conf
358
    curl -k https://dev.grnet.gr/files/apt-grnetdev.pub | apt-key add -
359
    """
360
    try_run(cmd)
361
    tmpl = "/etc/apt/sources.list.d/okeanos.list"
362
    replace = {}
363
    custom = customize_settings_from_tmpl(tmpl, replace)
364
    put(custom, tmpl)
365
    apt_get_update()
366

    
367

    
368
@roles("cyclades", "cms", "pithos", "accounts")
369
def restart_services():
370
    debug(env.host, " * Restarting apache2 and gunicorn...")
371
    try_run("/etc/init.d/gunicorn restart")
372
    try_run("/etc/init.d/apache2 restart")
373

    
374

    
375
def setup_gunicorn():
376
    debug(env.host, " * Setting up gunicorn...")
377
    install_package("gunicorn")
378
    tmpl = "/etc/gunicorn.d/synnefo"
379
    replace = {}
380
    custom = customize_settings_from_tmpl(tmpl, replace)
381
    put(custom, tmpl, mode=0644)
382
    try_run("/etc/init.d/gunicorn restart")
383

    
384

    
385
def setup_apache():
386
    debug(env.host, " * Setting up apache2...")
387
    host_info = env.env.ips_info[env.host]
388
    install_package("apache2")
389
    tmpl = "/etc/apache2/sites-available/synnefo"
390
    replace = {
391
        "HOST": host_info.fqdn,
392
    }
393
    custom = customize_settings_from_tmpl(tmpl, replace)
394
    put(custom, tmpl)
395
    tmpl = "/etc/apache2/sites-available/synnefo-ssl"
396
    custom = customize_settings_from_tmpl(tmpl, replace)
397
    put(custom, tmpl)
398
    cmd = """
399
    a2enmod ssl
400
    a2enmod rewrite
401
    a2dissite default
402
    a2ensite synnefo
403
    a2ensite synnefo-ssl
404
    a2enmod headers
405
    a2enmod proxy_http
406
    a2dismod autoindex
407
    """
408
    try_run(cmd)
409
    try_run("/etc/init.d/apache2 restart")
410

    
411

    
412
@roles("mq")
413
def setup_mq():
414
    debug(env.host, "Setting up RabbitMQ...")
415
    install_package("rabbitmq-server")
416
    cmd = """
417
    rabbitmqctl add_user {0} {1}
418
    rabbitmqctl set_permissions {0} ".*" ".*" ".*"
419
    rabbitmqctl delete_user guest
420
    rabbitmqctl set_user_tags {0} administrator
421
    """.format(env.env.synnefo_user, env.env.synnefo_rabbitmq_passwd)
422
    try_run(cmd)
423
    try_run("/etc/init.d/rabbitmq-server restart")
424

    
425

    
426
@roles("db")
427
def allow_access_in_db(ip, user="all", method="md5"):
428
    cmd = """
429
    echo host all {0} {1}/32 {2} >> /etc/postgresql/8.4/main/pg_hba.conf
430
    """.format(user, ip, method)
431
    try_run(cmd)
432
    try_run("/etc/init.d/postgresql restart")
433

    
434
@roles("db")
435
def setup_db():
436
    debug(env.host, "Setting up DataBase server...")
437
    install_package("postgresql")
438

    
439
    tmpl = "/tmp/db-init.psql"
440
    replace = {
441
        "synnefo_user": env.env.synnefo_user,
442
        "synnefo_db_passwd": env.env.synnefo_db_passwd,
443
        }
444
    custom = customize_settings_from_tmpl(tmpl, replace)
445
    put(custom, tmpl)
446
    cmd = 'su - postgres -c "psql -w -f %s" ' % tmpl
447
    try_run(cmd)
448
    cmd = """
449
    echo "listen_addresses = '*'" >> /etc/postgresql/8.4/main/postgresql.conf
450
    """
451
    try_run(cmd)
452

    
453
    allow_access_in_db(env.host, "all", "trust")
454
    try_run("/etc/init.d/postgresql restart")
455

    
456

    
457
@roles("db")
458
def destroy_db():
459
    try_run("""su - postgres -c ' psql -w -c "drop database snf_apps" '""")
460
    try_run("""su - postgres -c ' psql -w -c "drop database snf_pithos" '""")
461

    
462

    
463
def setup_webproject():
464
    debug(env.host, " * Setting up snf-webproject...")
465
    with settings(hide("everything")):
466
        try_run("ping -c1 " + env.env.db.ip)
467
    setup_common()
468
    install_package("snf-webproject")
469
    install_package("python-psycopg2")
470
    install_package("python-gevent")
471
    tmpl = "/etc/synnefo/webproject.conf"
472
    replace = {
473
        "synnefo_user": env.env.synnefo_user,
474
        "synnefo_db_passwd": env.env.synnefo_db_passwd,
475
        "db_node": env.env.db.ip,
476
        "domain": env.env.domain,
477
    }
478
    custom = customize_settings_from_tmpl(tmpl, replace)
479
    put(custom, tmpl, mode=0644)
480
    with settings(host_string=env.env.db.ip):
481
        host_info = env.env.ips_info[env.host]
482
        allow_access_in_db(host_info.ip, "all", "trust")
483
    try_run("/etc/init.d/gunicorn restart")
484

    
485

    
486
def setup_common():
487
    debug(env.host, " * Setting up snf-common...")
488
    host_info = env.env.ips_info[env.host]
489
    install_package("python-objpool")
490
    install_package("snf-common")
491
    install_package("python-astakosclient")
492
    install_package("snf-django-lib")
493
    install_package("snf-branding")
494
    tmpl = "/etc/synnefo/common.conf"
495
    replace = {
496
        #FIXME:
497
        "EMAIL_SUBJECT_PREFIX": env.host,
498
        "domain": env.env.domain,
499
        "HOST": host_info.fqdn,
500
    }
501
    custom = customize_settings_from_tmpl(tmpl, replace)
502
    put(custom, tmpl, mode=0644)
503
    try_run("/etc/init.d/gunicorn restart")
504

    
505
@roles("accounts")
506
def astakos_loaddata():
507
    debug(env.host, " * Loading initial data to astakos...")
508
    cmd = """
509
    snf-manage loaddata groups
510
    """
511
    try_run(cmd)
512

    
513

    
514
@roles("accounts")
515
def astakos_register_services():
516
    debug(env.host, " * Register services in astakos...")
517
    cmd = """
518
    snf-manage component-add "home" https://{0} home-icon.png
519
    snf-manage component-add "cyclades" https://{1}/cyclades/ui/
520
    snf-manage component-add "pithos" https://{2}/pithos/ui/
521
    snf-manage component-add "astakos" https://{3}/astakos/ui/
522
    """.format(env.env.cms.fqdn, env.env.cyclades.fqdn, env.env.pithos.fqdn, env.env.accounts.fqdn)
523
    try_run(cmd)
524
    import_service("astakos")
525
    import_service("pithos")
526
    import_service("cyclades")
527
    tmpl = "/tmp/resources.json"
528
    replace = {}
529
    custom = customize_settings_from_tmpl(tmpl, replace)
530
    put(custom, tmpl)
531
    try_run("snf-manage resource-import --json %s" % tmpl)
532
    cmd = """
533
    snf-manage resource-modify --limit 40G pithos.diskspace
534
    snf-manage resource-modify --limit 2 astakos.pending_app
535
    snf-manage resource-modify --limit 4 cyclades.vm
536
    snf-manage resource-modify --limit 40G cyclades.disk
537
    snf-manage resource-modify --limit 8G cyclades.ram
538
    snf-manage resource-modify --limit 16 cyclades.cpu
539
    snf-manage resource-modify --limit 4 cyclades.network.private
540
    """
541
    try_run(cmd)
542

    
543

    
544
@roles("accounts")
545
def add_user():
546
    debug(env.host, " * adding user %s to astakos..." % env.env.user_email)
547
    email=env.env.user_email
548
    name=env.env.user_name
549
    lastname=env.env.user_lastname
550
    passwd=env.env.user_passwd
551
    cmd = """
552
    snf-manage user-add {0} {1} {2}
553
    """.format(email, name, lastname)
554
    try_run(cmd)
555
    with settings(host_string=env.env.db.ip):
556
        uid, user_auth_token, user_uuid = get_auth_token_from_db(email)
557
    cmd = """
558
    snf-manage user-modify --password {0} {1}
559
    """.format(passwd, uid)
560
    try_run(cmd)
561

    
562

    
563
@roles("accounts")
564
def activate_user(user_email=None):
565
    if not user_email:
566
      user_email = env.env.user_email
567
    debug(env.host, " * Activate user %s..." % user_email)
568
    with settings(host_string=env.env.db.ip):
569
        uid, user_auth_token, user_uuid = get_auth_token_from_db(user_email)
570

    
571
    cmd = """
572
    snf-manage user-modify --verify {0}
573
    snf-manage user-modify --accept {0}
574
    """.format(uid)
575
    try_run(cmd)
576

    
577
@roles("accounts")
578
def setup_astakos():
579
    debug(env.host, "Setting up snf-astakos-app...")
580
    setup_gunicorn()
581
    setup_apache()
582
    setup_webproject()
583
    install_package("python-django-south")
584
    install_package("snf-astakos-app")
585
    install_package("kamaki")
586

    
587
    tmpl = "/etc/synnefo/astakos.conf"
588
    replace = {
589
      "ACCOUNTS": env.env.accounts.fqdn,
590
      "domain": env.env.domain,
591
      "CYCLADES": env.env.cyclades.fqdn,
592
      "PITHOS": env.env.pithos.fqdn,
593
    }
594
    custom = customize_settings_from_tmpl(tmpl, replace)
595
    put(custom, tmpl, mode=0644)
596
    if env.csrf_disable:
597
      cmd = """
598
cat <<EOF >> /etc/synnefo/astakos.conf
599
try:
600
  MIDDLEWARE_CLASSES.remove('django.middleware.csrf.CsrfViewMiddleware')
601
except:
602
  pass
603
EOF
604
"""
605
      try_run(cmd)
606

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

    
609
    cmd = """
610
    snf-manage syncdb --noinput
611
    snf-manage migrate im --delete-ghost-migrations
612
    snf-manage migrate quotaholder_app
613
    """
614
    try_run(cmd)
615

    
616
def import_service(service):
617
    tmpl = "/tmp/%s.json" % service
618
    replace = {
619
      "DOMAIN": env.env.domain,
620
      }
621
    custom = customize_settings_from_tmpl(tmpl, replace)
622
    put(custom, tmpl)
623
    try_run("snf-manage service-import --json %s" % tmpl)
624

    
625
@roles("accounts")
626
def get_service_details(service="pithos"):
627
    debug(env.host, " * Getting registered details for %s service..." % service)
628
    result = try_run("snf-manage component-list")
629
    r = re.compile(r".*%s.*" % service, re.M)
630
    service_id, _, _, service_token = r.search(result).group().split()
631
    # print("%s: %s %s" % (service, service_id, service_token))
632
    return (service_id, service_token)
633

    
634

    
635
@roles("db")
636
def get_auth_token_from_db(user_email=None):
637
    if not user_email:
638
        user_email=env.env.user_email
639
    debug(env.host, " * Getting authentication token and uuid for user %s..." % user_email)
640
    cmd = """
641
    echo "select id, auth_token, uuid, email from auth_user, im_astakosuser where auth_user.id = im_astakosuser.user_ptr_id and auth_user.email = '{0}';" > /tmp/psqlcmd
642
    su - postgres -c  "psql -w -d snf_apps -f /tmp/psqlcmd"
643
    """.format(user_email)
644

    
645
    result = try_run(cmd)
646
    r = re.compile(r"(\d+)[ |]*(\S+)[ |]*(\S+)[ |]*" + user_email, re.M)
647
    match = r.search(result)
648
    uid, user_auth_token, user_uuid = match.groups()
649
    # print("%s: %s %s %s" % ( user_email, uid, user_auth_token, user_uuid))
650

    
651
    return (uid, user_auth_token, user_uuid)
652

    
653

    
654
@roles("cms")
655
def cms_loaddata():
656
    debug(env.host, " * Loading cms initial data...")
657
    if env.cms_pass:
658
      debug(env.host, "Aborting. Prerequisites not met.")
659
      return
660
    tmpl = "/tmp/sites.json"
661
    replace = {}
662
    custom = customize_settings_from_tmpl(tmpl, replace)
663
    put(custom, tmpl)
664

    
665
    tmpl = "/tmp/page.json"
666
    replace = {}
667
    custom = customize_settings_from_tmpl(tmpl, replace)
668
    put(custom, tmpl)
669

    
670
    cmd = """
671
    snf-manage loaddata /tmp/sites.json
672
    snf-manage loaddata /tmp/page.json
673
    snf-manage createsuperuser --username=admin --email=admin@{0} --noinput
674
    """.format(env.env.domain)
675
    try_run(cmd)
676

    
677

    
678
@roles("cms")
679
def setup_cms():
680
    debug(env.host, "Setting up cms...")
681
    if env.cms_pass:
682
      debug(env.host, "Aborting. Prerequisites not met.")
683
      return
684
    with settings(hide("everything")):
685
        try_run("ping -c1 accounts." + env.env.domain)
686
    setup_gunicorn()
687
    setup_apache()
688
    setup_webproject()
689
    install_package("snf-cloudcms")
690

    
691
    tmpl = "/etc/synnefo/cms.conf"
692
    replace = {
693
        "ACCOUNTS": env.env.accounts.fqdn,
694
        }
695
    custom = customize_settings_from_tmpl(tmpl, replace)
696
    put(custom, tmpl, mode=0644)
697
    try_run("/etc/init.d/gunicorn restart")
698

    
699

    
700
    cmd = """
701
    snf-manage syncdb
702
    snf-manage migrate --delete-ghost-migrations
703
    """.format(env.env.domain)
704
    try_run(cmd)
705

    
706

    
707
def setup_nfs_dirs():
708
    debug(env.host, " * Creating NFS mount point for pithos and ganeti...")
709
    cmd = """
710
    mkdir -p {0}
711
    cd {0}
712
    mkdir -p data
713
    chown www-data:www-data data
714
    chmod g+ws data
715
    mkdir -p /srv/okeanos
716
    """.format(env.env.pithos_dir)
717
    try_run(cmd)
718

    
719

    
720
@roles("nodes")
721
def setup_nfs_clients():
722
    if env.host == env.env.pithos.ip:
723
      return
724

    
725
    debug(env.host, " * Mounting pithos NFS mount point...")
726
    with settings(hide("everything")):
727
        try_run("ping -c1 " + env.env.pithos.hostname)
728
    install_package("nfs-common")
729
    for d in [env.env.pithos_dir, "/srv/okeanos"]:
730
      try_run("mkdir -p " + d)
731
      cmd = """
732
      echo "{0}:/{1} {2}  nfs4 defaults,rw,noatime,nodiratime,intr,rsize=1048576,wsize=1048576,noacl" >> /etc/fstab
733
      """.format(env.env.pithos.hostname, os.path.basename(d), d)
734
      try_run(cmd)
735
      try_run("mount " + d)
736

    
737

    
738
@roles("pithos")
739
def setup_nfs_server():
740
    debug(env.host, " * Setting up NFS server for pithos...")
741
    setup_nfs_dirs()
742
    install_package("nfs-kernel-server")
743
    tmpl = "/etc/exports"
744
    replace = {
745
      "pithos_dir": env.env.pithos_dir,
746
      "srv": os.path.dirname(env.env.pithos_dir),
747
      "subnet": env.env.subnet
748
      }
749
    custom = customize_settings_from_tmpl(tmpl, replace)
750
    put(custom, tmpl)
751
    try_run("/etc/init.d/nfs-kernel-server restart")
752

    
753

    
754
@roles("pithos")
755
def setup_pithos():
756
    debug(env.host, "Setting up snf-pithos-app...")
757
    with settings(hide("everything")):
758
        try_run("ping -c1 accounts." + env.env.domain)
759
        try_run("ping -c1 " + env.env.db.ip)
760
    setup_gunicorn()
761
    setup_apache()
762
    setup_webproject()
763

    
764
    with settings(host_string=env.env.accounts.ip):
765
        service_id, service_token = get_service_details("pithos")
766

    
767
    install_package("kamaki")
768
    install_package("snf-pithos-backend")
769
    install_package("snf-pithos-app")
770
    tmpl = "/etc/synnefo/pithos.conf"
771
    replace = {
772
        "ACCOUNTS": env.env.accounts.fqdn,
773
        "PITHOS": env.env.pithos.fqdn,
774
        "db_node": env.env.db.ip,
775
        "synnefo_user": env.env.synnefo_user,
776
        "synnefo_db_passwd": env.env.synnefo_db_passwd,
777
        "pithos_dir": env.env.pithos_dir,
778
        "PITHOS_SERVICE_TOKEN": service_token,
779
        "proxy": env.env.pithos.hostname == env.env.accounts.hostname
780
        }
781
    custom = customize_settings_from_tmpl(tmpl, replace)
782
    put(custom, tmpl, mode=0644)
783
    try_run("/etc/init.d/gunicorn restart")
784

    
785
    install_package("snf-pithos-webclient")
786
    tmpl = "/etc/synnefo/webclient.conf"
787
    replace = {
788
        "ACCOUNTS": env.env.accounts.fqdn,
789
        "PITHOS_UI_CLOUDBAR_ACTIVE_SERVICE": service_id,
790
        }
791
    custom = customize_settings_from_tmpl(tmpl, replace)
792
    put(custom, tmpl, mode=0644)
793

    
794
    try_run("/etc/init.d/gunicorn restart")
795
    #TOFIX: the previous command lets pithos-backend create blocks and maps
796
    #       with root owner
797
    try_run("chown -R www-data:www-data %s/data " % env.env.pithos_dir)
798
    #try_run("pithos-migrate stamp 4c8ccdc58192")
799
    #try_run("pithos-migrate upgrade head")
800

    
801

    
802
def add_wheezy():
803
    tmpl = "/etc/apt/sources.list.d/wheezy.list"
804
    replace = {}
805
    custom = customize_settings_from_tmpl(tmpl, replace)
806
    put(custom, tmpl)
807
    apt_get_update()
808

    
809

    
810
def remove_wheezy():
811
    try_run("rm -f /etc/apt/sources.list.d/wheezy.list")
812
    apt_get_update()
813

    
814

    
815
@roles("ganeti")
816
def setup_ganeti():
817
    debug(env.host, "Setting up snf-ganeti...")
818
    node_info = env.env.ips_info[env.host]
819
    with settings(hide("everything")):
820
        #if env.enable_lvm:
821
        #    try_run("vgs " + env.env.vg)
822
        try_run("getent hosts " + env.env.cluster.fqdn)
823
        try_run("getent hosts %s | grep -v ^127" % env.host)
824
        try_run("hostname -f | grep " + node_info.fqdn)
825
        #try_run("ip link show " + env.env.common_bridge)
826
        #try_run("ip link show " + env.env.common_bridge)
827
        #try_run("apt-get update")
828
    install_package("qemu-kvm")
829
    install_package("python-bitarray")
830
    add_wheezy()
831
    install_package("ganeti-htools")
832
    remove_wheezy()
833
    install_package("snf-ganeti")
834
    try_run("mkdir -p /srv/ganeti/file-storage/")
835
    cmd = """
836
cat <<EOF > /etc/ganeti/file-storage-paths
837
/srv/ganeti/file-storage
838
/srv/ganeti/shared-file-storage
839
EOF
840
"""
841
    try_run(cmd)
842

    
843

    
844
@roles("master")
845
def add_rapi_user():
846
    debug(env.host, " * Adding RAPI user to Ganeti backend...")
847
    cmd = """
848
    echo -n "{0}:Ganeti Remote API:{1}" | openssl md5
849
    """.format(env.env.synnefo_user, env.env.synnefo_rapi_passwd)
850
    result = try_run(cmd)
851
    cmd = """
852
    echo "{0} {1}{2} write" >> /var/lib/ganeti/rapi/users
853
    """.format(env.env.synnefo_user, '{ha1}',result)
854
    try_run(cmd)
855
    try_run("/etc/init.d/ganeti restart")
856

    
857
@roles("master")
858
def add_nodes():
859
    nodes = env.env.cluster_nodes.split(",")
860
    nodes.remove(env.env.master_node)
861
    debug(env.host, " * Adding nodes to Ganeti backend...")
862
    for n in nodes:
863
        add_node(n)
864

    
865
@roles("master")
866
def add_node(node):
867
    node_info = env.env.nodes_info[node]
868
    debug(env.host, " * Adding node %s to Ganeti backend..." % node_info.fqdn)
869
    cmd = "gnt-node add --no-ssh-key-check --master-capable=yes --vm-capable=yes " + node_info.fqdn
870
    try_run(cmd)
871

    
872
@roles("ganeti")
873
def enable_drbd():
874
    if env.enable_drbd:
875
        debug(env.host, " * Enabling DRBD...")
876
        try_run("modprobe drbd minor_count=255 usermode_helper=/bin/true")
877
        try_run("echo drbd minor_count=255 usermode_helper=/bin/true >> /etc/modules")
878

    
879
@roles("master")
880
def setup_drbd_dparams():
881
    if env.enable_drbd:
882
        debug(env.host, " * Twicking drbd related disk parameters in Ganeti...")
883
        cmd = """
884
        gnt-cluster modify --disk-parameters=drbd:metavg={0}
885
        gnt-group modify --disk-parameters=drbd:metavg={0} default
886
        """.format(env.env.vg)
887
        try_run(cmd)
888

    
889
@roles("master")
890
def enable_lvm():
891
    if env.enable_lvm:
892
        debug(env.host, " * Enabling LVM...")
893
        cmd = """
894
        gnt-cluster modify --vg-name={0}
895
        """.format(env.env.vg)
896
        try_run(cmd)
897
    else:
898
        debug(env.host, " * Disabling LVM...")
899
        try_run("gnt-cluster modify --no-lvm-storage")
900

    
901
@roles("master")
902
def destroy_cluster():
903
    debug(env.host, " * Destroying Ganeti cluster...")
904
    #TODO: remove instances first
905
    allnodes = env.env.cluster_hostnames[:]
906
    allnodes.remove(env.host)
907
    for n in allnodes:
908
      host_info = env.env.ips_info[host]
909
      debug(env.host, " * Removing node %s..." % n)
910
      cmd = "gnt-node remove  " + host_info.fqdn
911
      try_run(cmd)
912
    try_run("gnt-cluster destroy --yes-do-it")
913

    
914

    
915
@roles("master")
916
def init_cluster():
917
    debug(env.host, " * Initializing Ganeti backend...")
918
    # extra = ""
919
    # if env.enable_lvm:
920
    #     extra += " --vg-name={0} ".format(env.env.vg)
921
    # else:
922
    #     extra += " --no-lvm-storage "
923
    # if not env.enable_drbd:
924
    #     extra += " --no-drbd-storage "
925
    extra = " --no-lvm-storage --no-drbd-storage "
926
    cmd = """
927
    gnt-cluster init --enabled-hypervisors=kvm \
928
                     {0} \
929
                     --nic-parameters link={1},mode=bridged \
930
                     --master-netdev {2} \
931
                     --default-iallocator hail \
932
                     --hypervisor-parameters kvm:kernel_path=,vnc_bind_address=0.0.0.0 \
933
                     --no-ssh-init --no-etc-hosts \
934
                    {3}
935

936
    """.format(extra, env.env.common_bridge,
937
               env.env.cluster_netdev, env.env.cluster.fqdn)
938
    try_run(cmd)
939

    
940

    
941
@roles("ganeti")
942
def debootstrap():
943
    install_package("ganeti-instance-debootstrap")
944

    
945

    
946
@roles("ganeti")
947
def setup_image_host():
948
    debug(env.host, "Setting up snf-image...")
949
    install_package("snf-pithos-backend")
950
    install_package("snf-image")
951
    try_run("mkdir -p /srv/okeanos")
952
    tmpl = "/etc/default/snf-image"
953
    replace = {
954
        "synnefo_user": env.env.synnefo_user,
955
        "synnefo_db_passwd": env.env.synnefo_db_passwd,
956
        "pithos_dir": env.env.pithos_dir,
957
        "db_node": env.env.db.ip,
958
    }
959
    custom = customize_settings_from_tmpl(tmpl, replace)
960
    put(custom, tmpl)
961

    
962

    
963
@roles("ganeti")
964
def setup_image_helper():
965
    debug(env.host, " * Updating helper image...")
966
    cmd = """
967
    snf-image-update-helper -y
968
    """
969
    try_run(cmd)
970

    
971

    
972
@roles("ganeti")
973
def setup_gtools():
974
    debug(env.host, " * Setting up snf-cyclades-gtools...")
975
    with settings(hide("everything")):
976
        try_run("ping -c1 " + env.env.mq.ip)
977
    setup_common()
978
    install_package("snf-cyclades-gtools")
979
    tmpl = "/etc/synnefo/gtools.conf"
980
    replace = {
981
        "synnefo_user": env.env.synnefo_user,
982
        "synnefo_rabbitmq_passwd": env.env.synnefo_rabbitmq_passwd,
983
        "mq_node": env.env.mq.ip,
984
    }
985
    custom = customize_settings_from_tmpl(tmpl, replace)
986
    put(custom, tmpl)
987

    
988
    cmd = """
989
    sed -i 's/false/true/' /etc/default/snf-ganeti-eventd
990
    /etc/init.d/snf-ganeti-eventd start
991
    """
992
    try_run(cmd)
993

    
994

    
995
@roles("ganeti")
996
def setup_iptables():
997
    debug(env.host, " * Setting up iptables to mangle DHCP requests...")
998
    cmd = """
999
    iptables -t mangle -A PREROUTING -i br+ -p udp -m udp --dport 67 -j NFQUEUE --queue-num 42
1000
    iptables -t mangle -A PREROUTING -i tap+ -p udp -m udp --dport 67 -j NFQUEUE --queue-num 42
1001
    iptables -t mangle -A PREROUTING -i prv+ -p udp -m udp --dport 67 -j NFQUEUE --queue-num 42
1002

1003
    ip6tables -t mangle -A PREROUTING -i br+ -p ipv6-icmp -m icmp6 --icmpv6-type 133 -j NFQUEUE --queue-num 43
1004
    ip6tables -t mangle -A PREROUTING -i br+ -p ipv6-icmp -m icmp6 --icmpv6-type 135 -j NFQUEUE --queue-num 44
1005
    """
1006
    try_run(cmd)
1007

    
1008
@roles("ganeti")
1009
def setup_network():
1010
    debug(env.host, "Setting up networking for Ganeti instances (nfdhcpd, etc.)...")
1011
    install_package("nfqueue-bindings-python")
1012
    install_package("nfdhcpd")
1013
    tmpl = "/etc/nfdhcpd/nfdhcpd.conf"
1014
    replace = {
1015
      "ns_node_ip": env.env.ns.ip
1016
      }
1017
    custom = customize_settings_from_tmpl(tmpl, replace)
1018
    put(custom, tmpl)
1019
    try_run("/etc/init.d/nfdhcpd restart")
1020

    
1021
    install_package("snf-network")
1022
    cmd = """
1023
    sed -i 's/MAC_MASK.*/MAC_MASK = ff:ff:f0:00:00:00/' /etc/default/snf-network
1024
    """
1025
    try_run(cmd)
1026

    
1027

    
1028
@roles("router")
1029
def setup_router():
1030
    debug(env.host, " * Setting up internal router for NAT...")
1031
    cmd = """
1032
    echo 1 > /proc/sys/net/ipv4/ip_forward
1033
    iptables -t nat -A POSTROUTING -s {0} -o {3} -j MASQUERADE
1034
    ip addr add {1} dev {2}
1035
    ip route add {0} dev {2} src {1}
1036
    """.format(env.env.synnefo_public_network_subnet,
1037
               env.env.synnefo_public_network_gateway,
1038
               env.env.common_bridge, env.env.public_iface)
1039
    try_run(cmd)
1040

    
1041
@roles("cyclades")
1042
def cyclades_loaddata():
1043
    debug(env.host, " * Loading initial data for cyclades...")
1044
    tmpl = "/tmp/flavor.json"
1045
    replace = {}
1046
    custom = customize_settings_from_tmpl(tmpl, replace)
1047
    put(custom, tmpl)
1048
    try_run("snf-manage loaddata " + tmpl)
1049
    #run("snf-manage loaddata flavors")
1050

    
1051

    
1052
@roles("cyclades")
1053
def setup_cyclades():
1054
    debug(env.host, "Setting up snf-cyclades-app...")
1055
    with settings(hide("everything")):
1056
        try_run("ping -c1 accounts." + env.env.domain)
1057
        try_run("ping -c1 " + env.env.db.ip)
1058
        try_run("ping -c1 " + env.env.mq.ip)
1059
    setup_gunicorn()
1060
    setup_apache()
1061
    setup_webproject()
1062
    install_package("memcached")
1063
    install_package("python-memcache")
1064
    install_package("snf-pithos-backend")
1065
    install_package("kamaki")
1066
    install_package("snf-cyclades-app")
1067
    install_package("python-django-south")
1068
    tmpl = "/etc/synnefo/cyclades.conf"
1069

    
1070
    with settings(host_string=env.env.accounts.ip):
1071
        service_id, service_token = get_service_details("cyclades")
1072

    
1073
    replace = {
1074
        "ACCOUNTS": env.env.accounts.fqdn,
1075
        "CYCLADES": env.env.cyclades.fqdn,
1076
        "mq_node": env.env.mq.ip,
1077
        "db_node": env.env.db.ip,
1078
        "synnefo_user": env.env.synnefo_user,
1079
        "synnefo_db_passwd": env.env.synnefo_db_passwd,
1080
        "synnefo_rabbitmq_passwd": env.env.synnefo_rabbitmq_passwd,
1081
        "pithos_dir": env.env.pithos_dir,
1082
        "common_bridge": env.env.common_bridge,
1083
        "HOST": env.env.cyclades.ip,
1084
        "domain": env.env.domain,
1085
        "CYCLADES_SERVICE_TOKEN": service_token,
1086
        "proxy": env.env.cyclades.hostname == env.env.accounts.hostname
1087
        }
1088
    custom = customize_settings_from_tmpl(tmpl, replace)
1089
    put(custom, tmpl, mode=0644)
1090
    try_run("/etc/init.d/gunicorn restart")
1091

    
1092
    cmd = """
1093
    sed -i 's/false/true/' /etc/default/snf-dispatcher
1094
    /etc/init.d/snf-dispatcher start
1095
    """
1096
    try_run(cmd)
1097

    
1098
    try_run("snf-manage syncdb")
1099
    try_run("snf-manage migrate --delete-ghost-migrations")
1100

    
1101

    
1102
@roles("cyclades")
1103
def get_backend_id(cluster_name="ganeti1.synnefo.deploy.local"):
1104
    backend_id = try_run("snf-manage backend-list 2>/dev/null | grep %s | awk '{print $1}'" % cluster_name)
1105
    return backend_id
1106

    
1107

    
1108
@roles("cyclades")
1109
def add_backend():
1110
    debug(env.host, "adding %s ganeti backend to cyclades..." % env.env.cluster.fqdn)
1111
    with settings(hide("everything")):
1112
        try_run("ping -c1 " + env.env.cluster.fqdn)
1113
    cmd = """
1114
    snf-manage backend-add --clustername={0} --user={1} --pass={2}
1115
    """.format(env.env.cluster.fqdn, env.env.synnefo_user,
1116
               env.env.synnefo_rapi_passwd)
1117
    try_run(cmd)
1118
    backend_id = get_backend_id(env.env.cluster.fqdn)
1119
    try_run("snf-manage backend-modify --drained=False " + backend_id)
1120

    
1121
@roles("cyclades")
1122
def pin_user_to_backend(user_email):
1123
    backend_id = get_backend_id(env.env.cluster.fqdn)
1124
    # pin user to backend
1125
    cmd = """
1126
cat <<EOF >> /etc/synnefo/cyclades.conf
1127

1128
BACKEND_PER_USER = {
1129
  '%s': %s,
1130
}
1131

1132
EOF
1133
/etc/init.d/gunicorn restart
1134
    """  % (user_email, backend_id)
1135
    try_run(cmd)
1136

    
1137
@roles("cyclades")
1138
def add_pools():
1139
    debug(env.host, " * Creating pools of resources (brigdes, mac prefixes) in cyclades...")
1140
    try_run("snf-manage pool-create --type=mac-prefix --base=aa:00:0 --size=65536")
1141
    try_run("snf-manage pool-create --type=bridge --base=prv --size=20")
1142

    
1143

    
1144
@roles("cyclades")
1145
def add_network():
1146
    debug(env.host, " * Adding public network in cyclades...")
1147
    backend_id = get_backend_id(env.env.cluster.fqdn)
1148
    cmd = """
1149
    snf-manage network-create --subnet={0} --gateway={1} --public --dhcp --flavor={2} --mode=bridged --link={3} --name=Internet --backend-id={4}
1150
    """.format(env.env.synnefo_public_network_subnet,
1151
               env.env.synnefo_public_network_gateway,
1152
               env.env.synnefo_public_network_type,
1153
               env.env.common_bridge, backend_id)
1154
    try_run(cmd)
1155

    
1156

    
1157
@roles("cyclades")
1158
def setup_vncauthproxy():
1159
    debug(env.host, " * Setting up vncauthproxy...")
1160
    install_package("snf-vncauthproxy")
1161
    cmd = """
1162
    echo CHUID="www-data:nogroup" >> /etc/default/vncauthproxy
1163
    rm /var/log/vncauthproxy/vncauthproxy.log
1164
    """
1165
    try_run(cmd)
1166
    try_run("/etc/init.d/vncauthproxy restart")
1167

    
1168
@roles("client")
1169
def setup_kamaki():
1170
    debug(env.host, "Setting up kamaki client...")
1171
    with settings(hide("everything")):
1172
        try_run("ping -c1 accounts." + env.env.domain)
1173
        try_run("ping -c1 cyclades." + env.env.domain)
1174
        try_run("ping -c1 pithos." + env.env.domain)
1175

    
1176
    with settings(host_string=env.env.db.ip):
1177
        uid, user_auth_token, user_uuid = get_auth_token_from_db(env.env.user_email)
1178

    
1179
    install_package("python-progress")
1180
    install_package("kamaki")
1181
    cmd = """
1182
    kamaki config set cloud.default.url "https://{0}/astakos/identity/v2.0/"
1183
    kamaki config set cloud.default.token {1}
1184
    """.format(env.env.accounts.fqdn, user_auth_token)
1185
    try_run(cmd)
1186
    try_run("kamaki file create images")
1187

    
1188
@roles("client")
1189
def upload_image(image="debian_base.diskdump"):
1190
    debug(env.host, " * Uploading initial image to pithos...")
1191
    image = "debian_base.diskdump"
1192
    try_run("wget {0} -O /tmp/{1}".format(env.env.debian_base_url, image))
1193
    try_run("kamaki file upload --container images /tmp/{0} {0}".format(image))
1194

    
1195
@roles("client")
1196
def register_image(image="debian_base.diskdump"):
1197
    debug(env.host, " * Register image to plankton...")
1198
    with settings(host_string=env.env.db.ip):
1199
        uid, user_auth_token, user_uuid = get_auth_token_from_db(env.env.user_email)
1200

    
1201
    pithos_url = "pithos://{0}/images/{1}".format(user_uuid, image)
1202
    cmd = """
1203
    sleep 5
1204
    kamaki image register "Debian Base" {0} --public --disk-format=diskdump --property OSFAMILY=linux --property ROOT_PARTITION=1 --property description="Debian Squeeze Base System" --property size=450M --property kernel=2.6.32 --property GUI="No GUI" --property sortorder=1 --property USERS=root --property OS=debian
1205
    """.format(pithos_url)
1206
    try_run(cmd)
1207

    
1208
@roles("client")
1209
def setup_burnin():
1210
    debug(env.host, "Setting up burnin testing tool...")
1211
    install_package("kamaki")
1212
    install_package("snf-tools")
1213

    
1214
@roles("pithos")
1215
def add_image_locally():
1216
    debug(env.host, " * Getting image locally in order snf-image to use it directly..")
1217
    image = "debian_base.diskdump"
1218
    try_run("wget {0} -O /srv/okeanos/{1}".format(env.env.debian_base_url, image))
1219

    
1220

    
1221
@roles("master")
1222
def gnt_instance_add(name="test"):
1223
    debug(env.host, " * Adding test instance to Ganeti...")
1224
    osp="""img_passwd=gamwtosecurity,img_format=diskdump,img_id=debian_base,img_properties='{"OSFAMILY":"linux"\,"ROOT_PARTITION":"1"}'"""
1225
    cmd = """
1226
    gnt-instance add  -o snf-image+default --os-parameters {0} -t plain --disk 0:size=1G --no-name-check --no-ip-check --net 0:ip=pool,network=test --no-install --hypervisor-parameters kvm:machine_version=pc-1.0 {1}
1227
    """.format(osp, name)
1228
    try_run(cmd)
1229

    
1230
@roles("master")
1231
def gnt_network_add(name="test", subnet="10.0.0.0/26", gw="10.0.0.1", mode="bridged", link="br0"):
1232
    debug(env.host, " * Adding test network to Ganeti...")
1233
    cmd = """
1234
    gnt-network add --network={1} --gateway={2} {0}
1235
    gnt-network connect {0} {3} {4}
1236
    """.format(name, subnet, gw, mode, link)
1237
    try_run(cmd)
1238

    
1239
@roles("ips")
1240
def test():
1241
    debug(env.host, "Testing...")
1242
    try_run("hostname && date")