source: old/trunk/vtest/nservers.py @ 2647

#!/usr/bin/python
# -*- coding: utf-8 -*-
# Copyright © 2009 by Karl Ramm
#
# All rights reserved.
#
# Permission to use, copy, modify, and distribute this software and
# its documentation for any purpose and without fee is hereby granted,
# provided that the above copyright notice appear in all copies and
# that both that copyright notice and this permission notice appear in
# supporting documentation, and that the name of Karl Ramm not be used
# in advertising or publicity pertaining to distribution of the
# software without specific, written prior permission.
#
# KARL RAMM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
# INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
# NO EVENT SHALL KARL RAMM BE LIABLE FOR ANY SPECIAL, INDIRECT OR
# CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
# OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
# NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
# WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

import sys
import os
import time
import traceback
import logging
import errno
import subprocess
import fcntl
import itertools


import cluster
import ztest

class BaseTest(object):
    def __init__(self):
        self.log = logging.getLogger(self.__class__.__name__)
    def setup(self):
        self.log.info('starting setup')
    def teardown(self):
        self.log.info('starting teardown')
    def test(self):
        self.log.info('starting test')
    def run(self):
        failed = False
        try:
            self.setup()
        except:
            self.handle(sys.exc_info())
            failed = 'setup'
        if not failed:
            try:
                self.test()
            except:
                self.handle(sys.exc_info())
                failed = 'test'
        try:
            self.teardown()
        except:
            self.handle(sys.exc_info())
            if not failed:
                failed = 'teardown'
        if not failed:
            self.log.info('success')
        else:
            self.log.error(failed + ' failed')
            sys.exit(1)

    def handle(self, failure):
        self.log.error('exception:', exc_info=failure)
        if '--no-wait' not in sys.argv:
            print 'waiting for acknowledgement'
            raw_input()

class TestMultipleServers(BaseTest):
    def setup(self):
        super(TestMultipleServers, self).setup()

        self.nservers = 3

        self.cluster = cluster.cluster(spec=[ztest.kdc] + [cluster.host]*(self.nservers+1)) # client + n servers
        self.cluster.setup()

        self.hosts = [testmachine for (testmachine, prototype) in self.cluster.machines[cluster.host]]
        self.servers = self.hosts[1:]
        self.client = self.hosts[0]
        self.kdc = self.cluster.machines[ztest.kdc][0][1]

        for h in self.hosts:
            h.putstr('/etc/krb5.conf', self.kdc.krb5_conf)
            h.script('mkdir /etc/zephyr')
            h.putstr('/etc/zephyr/server.list', '\n'.join(t.params['hostname'] for t in self.servers) + '\n')

        ktname = self.kdc.keytab('zephyr/zephyr')

        for t in self.servers:
            t.putstr('/etc/rsyslog.d/zephyrlog.conf', 'local6.* /var/log/zephyr.log\n')
            t.script('/etc/init.d/rsyslog restart')
            t.putfile(ktname, '/etc/zephyr/krb5.keytab')
            t.script('touch /etc/zephyr/srvtab') # sigh, packaging bug

        #XXX need to cons up an apt repository
        packagepath = '/home/kcr/src'
        packageversion = '3.0.1~rc.HEAD'
        arch = 'i386'
        serverpackages = ['libzephyr4-krb5', 'zephyr-server-krb5', 'zephyr-clients']
        clientpackages = ['libzephyr4-krb5', 'zephyr-clients']
        serverdebs = [package + '_' + packageversion + '_' + arch + '.deb'
                      for package in serverpackages]
        clientdebs = [package + '_' + packageversion + '_' + arch + '.deb'
                      for package in clientpackages]

        for t in self.servers:
            for deb in serverdebs:
                t.putfile(os.path.join(packagepath, deb), '/tmp')
                t.script('DEBIAN_FRONTEND=noninteractive dpkg -i ' + os.path.join('/tmp', deb))
        time.sleep(1) # let things settle

        for deb in clientdebs:
            self.client.putfile(os.path.join(packagepath, deb), '/tmp')
            self.client.script('DEBIAN_FRONTEND=noninteractive dpkg -i ' + os.path.join('/tmp', deb))

        self.serverwait(30)
    def test(self):
        super(TestMultipleServers, self).test()
        self.verify_client()

    def teardown(self):
        super(TestMultipleServers, self).teardown()
        if self.servers:
            for t in self.servers:
                if t.alive:
                    t.getfile('/var/log/zephyr.log', t.params['hostname'] + '.zephyr.log')
        self.cluster.teardown()

    def verify_client(self):
        self.client.script(['echo test2 | kinit test2',
                       'zwgc -ttymode > /tmp/zwgcout',
                       'zwrite test2 -m FROTNITZ',
                       'zctl wg_exit',])

        ret, stdout, stderr = self.client.run('cat /tmp/zwgcout')

        assert 'FROTNITZ' in stdout, 'not receiving zephyrgrams'
        assert 'Authentic' in stdout, 'zephyrgram not authentic'

        ret, stdout, stderr = self.client.run('ps gax | grep -v grep | grep zwgc')

        assert 'zwgc' not in stdout, 'zwgc still running'

    def serverwait(self, delay=120):
        for i in range(delay / 5):
            time.sleep(5)
            ret, stdout, stderr = self.client.run('zstat')
            if stdout.count('SERV_UP') == self.nservers:
                break
            self.log.info('servers not up yet')
        else:
            assert False, 'server failed to restart in a timely fashion'


    class Zwgc(object):
        def __init__(self, other):
            self.counter = itertools.count().next
            self.client = other.client
            self.log = other.log
            self.nservers = other.nservers
            self.wgfile = '/tmp/wg.test.%d' % self.counter()
            self.z = subprocess.Popen(self.client.params['ssh'].split() +
                                      ['env', 'WGFILE=' + self.wgfile, 'zwgc', '-ttymode', '-nofork'],
                                      stdin=open('/dev/null'), stdout=subprocess.PIPE, stderr=subprocess.PIPE)
            fcntl.fcntl(self.z.stdout.fileno(), fcntl.F_SETFL, os.O_NONBLOCK)
            fcntl.fcntl(self.z.stderr.fileno(), fcntl.F_SETFL, os.O_NONBLOCK)
            time.sleep(1)
        def read(self):
            try:
                return self.z.stdout.read()
            except IOError, e:
                if e.errno != errno.EAGAIN:
                    raise
                return None
        def receivetest(self):
            for i in xrange(self.nservers+1):
                message = 'foobly%d' % self.counter()
                self.client.script('zwrite test2 -m '+message)
                time.sleep(.25)
                received = self.read()
                self.log.info('received %s', repr(received))
                assert message in received
                self.client.run('zctl new_server')
                time.sleep(.5)
        def ret(self):
            'not robust'
            retval, stdout, stderr = self.client.run('env WGFILE=%s zctl ret' % self.wgfile)
            return [tuple(l.split(' ')[1::2]) for l in stdout.splitlines()]
        def sub(self, class_, instance='*', recipient='*'):
            self.client.script('env WGFILE=%s zctl sub %s %s %s' %
                               (self.wgfile, class_, instance, recipient))
            return (class_, instance, recipient) in self.ret()
        def subclasses(self, classlist):
            self.client.putstr('/tmp/subs', ''.join('%s,*,*\n' % (class_,) for class_ in classlist))
            self.client.script('env WGFILE=%s zctl load /tmp/subs' % (self.wgfile,))
        def shutdown(self):
            self.client.script('env WGFILE=%s zctl wg_exit' % self.wgfile)
    def zwgc(self):
        return self.Zwgc(self)

if __name__ == '__main__':
    TestMultipleServers().run()