Synnefo

"""Perform integration testing on a running Synnefo deployment"""

import datetime

import inspect

import logging

from kamaki.clients.image import ImageClient

from kamaki.clients import ClientError

from vncauthproxy.d3des import generate_response as d3des_generate_response

        raise Exception("The unittest2 package is required for Python < 2.7")

    import unittest

class BurninTestResult(unittest.TextTestResult):

    def addSuccess(self, test):

        super(BurninTestResult, self).addSuccess(test)

        elif self.dots:

            self.stream.write('.')

    def addError(self, test, err):

        super(BurninTestResult, self).addError(test, err)

        if self.showAll:

            self.stream.flush()

class burninFormatter(logging.Formatter):

    err_fmt = red + "ERROR: %(msg)s" + normal

    dbg_fmt = green + "* %(msg)s" + normal

    info_fmt = "%(msg)s"

        logging.Formatter.__init__(self, fmt)

    def format(self, record):

        format_orig = self._fmt

        # Replace the original format with one customized by logging level

        if record.levelno == 10:    # DEBUG

            self._fmt = burninFormatter.dbg_fmt

        elif record.levelno == 20:  # INFO

            self._fmt = burninFormatter.info_fmt

        elif record.levelno == 40:  # ERROR

            self._fmt = burninFormatter.err_fmt

        result = logging.Formatter.format(self, record)

        self._fmt = format_orig

        return result

log = logging.getLogger("burnin")

log.addHandler(handler)

class UnauthorizedTestCase(unittest.TestCase):

    @classmethod

    def setUpClass(cls):

        cls.result_dict = dict()

    def test_unauthorized_access(self):

        """Test access without a valid token fails"""

        log.info("Authentication test")

        falseToken = '12345'

        c = ComputeClient(API, falseToken)

            self.assertEqual(cm.exception.status, 401)

class ImagesTestCase(unittest.TestCase):

    """Test image lists for consistency"""

    @classmethod

    def setUpClass(cls):

        """Initialize kamaki, get (detailed) list of images"""

        log.info("Getting simple and detailed list of images")

        cls.client = ComputeClient(API, TOKEN)

        cls.plankton = ImageClient(PLANKTON, TOKEN)

        cls.images = cls.plankton.list_public()

            self.assertTrue(keys.issubset(i["metadata"]["values"].keys()))

class FlavorsTestCase(unittest.TestCase):

    """Test flavor lists for consistency"""

    @classmethod

    def setUpClass(cls):

        """Initialize kamaki, get (detailed) list of flavors"""

        log.info("Getting simple and detailed list of flavors")

        cls.client = ComputeClient(API, TOKEN)

        cls.flavors = cls.client.list_flavors()

        cls.dflavors = cls.client.list_flavors(detail=True)

    def test_005_well_formed_flavor_names(self):

        """Test flavors have names of the form CxxRyyDzz

        Where xx is vCPU count, yy is RAM in MiB, zz is Disk in GiB

        """

        for f in self.dflavors:

            self.assertEqual("C%dR%dD%d" % (f["cpu"], f["ram"], f["disk"]),

                             "Flavor %s does not match its specs." % f["name"])

class ServersTestCase(unittest.TestCase):

    """Test server lists for consistency"""

    @classmethod

    @classmethod

    def setUpClass(cls):

        """Initialize a kamaki instance"""

        cls.client = ComputeClient(API, TOKEN)

        cls.cyclades = CycladesClient(API, TOKEN)

        cls.result_dict = dict()

        for nic in nics:

            net_id = nic["network_id"]

                public_addrs = nic["ipv4"]

        return public_addrs

        for nic in nics:

            net_id = nic["network_id"]

                public_addrs = nic["ipv6"]

        """Return the login name for connections based on the server OS"""

            return "user"

            return "Administrator"

        else:

            return "root"

            af, socktype, proto, canonname, sa = res

            try:

                sock = socket.socket(af, socktype, proto)

                sock = None

                continue

            try:

                sock.connect(sa)

                sock.close()

                sock = None

                continue

        msg = "connect over %s to %s:%s" % \

              (familystr.get(family, "Unknown"), host, port)

        sock = self._try_until_timeout_expires(

        return sock

    def _insist_on_status_transition(self, current_status, new_status,

        msg = "Server %d: `%s', waiting for %s -> %s" % \

              (self.serverid, self.servername, current_status, new_status)

        if warn_timeout is None:

    def _insist_on_ssh_hostname(self, hostip, username, password):

        msg = "SSH to %s, as %s/%s" % (hostip, username, password)

        hostname = self._try_until_timeout_expires(

        # The hostname must be of the form 'prefix-id'

        self.assertTrue(hostname.endswith("-%d\n" % self.serverid))

        log.info("Creating server metadata")

        image = self.client.get_image_details(self.imageid)

        users = image["metadata"]["values"].get("users", None)

        userlist = users.split()

        if "root" in userlist:

            cls.username = "root"

        else:

            cls.username = choice(userlist)

        log.info("Waiting for server to become ACTIVE")

    def test_003a_get_server_oob_console(self):

        """Test getting OOB server console over VNC

        """

        console = self.cyclades.get_server_console(self.serverid)

        self.assertEquals(console['type'], "vnc")

        # Step 1. ProtocolVersion message (par. 6.1.1)

        version = sock.recv(1024)

        log.info("Validate server's IPv4")

        server = self.client.get_server_details(self.serverid)

        ipv4 = self._get_ipv4(server)

        """Test server becomes STOPPED"""

        log.info("Waiting until server becomes STOPPED")

    def test_010_submit_start_request(self):

        """Test submit start server request"""

        """Test server becomes ACTIVE again"""

        log.info("Waiting until server becomes ACTIVE")

    def test_011a_server_responds_to_ping_IPv4(self):

        """Test server OS is actually up and running again"""

        self._skipIf(not self.is_windows, "only valid for Windows servers")

        server = self.client.get_server_details(self.serverid)

        ipv4 = self._get_ipv4(server)

        # No actual RDP processing done. We assume the RDP server is there

        # if the connection to the RDP port is successful.

        server = self.client.get_server_details(self.serverid)

        ipv6 = self._get_ipv6(server)

        # No actual RDP processing done. We assume the RDP server is there

        # if the connection to the RDP port is successful.

    def test_016_personality_is_enforced(self):

        """Test file injection for personality enforcement"""

        self._skipIf(self.is_windows, "only implemented for Linux servers")

        log.info("Trying to inject file for personality enforcement")

        log.info("Testing if server becomes DELETED")

    def test_019_server_no_longer_in_server_list(self):

        """Test server is no longer in server list"""

        for nic in nics:

            net_id = nic["network_id"]

                public_addrs = nic["ipv4"]

        """Return the login name for connections based on the server OS"""

            return "user"

            return "Administrator"

        else:

            return "root"

        self.result_dict["Server A ID"] = str(serverA["id"])

        self.result_dict["Server A password"] = serverA["adminPass"]

    def test_00001b_serverA_becomes_active(self):

        """Test server becomes ACTIVE"""

        """Test submit create server request"""

        log.info("Creating test server B")

        serverB = self.client.create_server(self.servername, self.flavorid,

                                            self.imageid, personality=None)

        log.info("Submit new network request")

        self.result_dict.clear()

        name = SNF_TEST_PREFIX + TEST_RUN_ID

        #Test if right name is assigned

        self.assertEqual(network['name'], name)

        # Update class attributes

        cls = type(self)

        cls.networkid = network['id']

        fail_tmout = time.time() + self.action_timeout

        while True:

            if (self.networkid in netsA) and (self.networkid in netsB):

                conn_exists = True

                self.assertLess(time.time(), fail_tmout)

            else:

                time.sleep(self.query_interval)

        #Adding private IPs to class attributes

        cls = type(self)

        cls.priv_ip = dict()

        if conn_exists:

            for nic in nicsA:

        fail_tmout = time.time() + self.action_timeout

        s = False

        self.result_dict["Server A public IP"] = str(ip)

        while True:

        log.info("Testing if server B responds to IPv4 pings")

        self.result_dict.clear()

        server = self.client.get_server_details(self.serverid['B'])

        ip = self._get_ipv4(server)

        server = self.client.get_server_details(self.serverid['A'])

        image = self.client.get_image_details(self.imageid)

        users = image["metadata"]["values"].get("users", None)

        userlist = users.split()

        if "root" in userlist:

            loginname = "root"

        else:

            loginname = choice(userlist)

        res = False

        if loginname != "root":

                    res = True

        else:

                    res = True

        self.assertTrue(res)

        server = self.client.get_server_details(self.serverid['B'])

        image = self.client.get_image_details(self.imageid)

        users = image["metadata"]["values"].get("users", None)

        userlist = users.split()

        if "root" in userlist:

            loginname = "root"

        else:

            loginname = choice(userlist)

        res = False

        if loginname != "root":

                    res = True

        else:

                    res = True

        self.assertTrue(res)

        server = self.client.get_server_details(self.serverid['A'])

        image = self.client.get_image_details(self.imageid)

        hostip = self._get_ipv4(server)

        users = image["metadata"]["values"].get("users", None)

        if "root" in userlist:

            loginname = "root"

        else:

            loginname = choice(userlist)

        prev_state = self.client.get_network_details(self.networkid)

        prev_nics = prev_state['attachments']['values']

        for nic in prev_nics:

            if nic in nicsA:

            if nic in nicsB:

                self.client.disconnect_server(self.serverid['B'], nic)

        #Insist on deleting until action timeout

        fail_tmout = time.time() + self.action_timeout

        while True:

            if (self.networkid not in netsA) and (self.networkid not in netsB):

                conn_exists = False

                break

            else:

                time.sleep(self.query_interval)

    def test_006_cleanup_servers(self):

        """Cleanup servers created for this test"""

        while True:

            multi.debug("I am process %d, GETting from queue is %s" %

            msg = self.testq.get()

            multi.debug("Dequeued msg: %s" % msg)

                                          TEST_RUN_ID + '.log')

                f = open(log_file, 'w')

                error = open(error_file, 'w')

                log.info(yellow + '* Starting testcase: %s' % msg + normal)

                suite = unittest.TestLoader().loadTestsFromTestCase(msg)

                result = runner.run(suite)

                for res in result.errors:

                    log.error("See log for details")

                    error.write(str(res[0]) + '\n')

                    error.write(str(res[0].shortDescription()) + '\n')

                    error.write('\n')

                for res in result.failures:

                    log.error("See log for details")

                    fail.write(str(res[0]) + '\n')

                    fail.write(str(res[0].shortDescription()) + '\n')

                    fail.write('\n')

                        sys.exit()

                if (len(result.failures) == 0) and (len(result.errors) == 0):

                f.close()

                fail.close()

                error.close()

            else:

                raise Exception("Cannot handle msg: %s" % msg)

    """Run instances of TestCase in series"""

    for case in cases:

        test = case.__name__

        log_file = os.path.join(image_folder, 'details_' +

                                (case.__name__) + "_" +

                                TEST_RUN_ID + '.log')

        error = open(error_file, "w")

        suite = unittest.TestLoader().loadTestsFromTestCase(case)

        result = runner.run(suite)

        for res in result.errors:

            log.error("See log for details")

            error.write(str(res[0]) + '\n')

            error.write(str(res[0].shortDescription()) + '\n')

            error.write('\n')

        for res in result.failures:

            log.error("See log for details")

            fail.write(str(res[0]) + '\n')

            fail.write(str(res[0].shortDescription()) + '\n')

            fail.write('\n')

                sys.exit()

        if (len(result.failures) == 0) and (len(result.errors) == 0):

def _run_cases_in_parallel(cases, fanout, image_folder):

    """Run instances of TestCase in parallel, in a number of distinct processes

    worker_folder = []

    runners = []

        testq.append(Queue())

        worker_folder.append(os.path.join(image_folder, 'process'+str(i)))

        os.mkdir(worker_folder[i])

        kwargs = dict(testq=testq[i], worker_folder=worker_folder[i])

        runners.append(TestRunnerProcess(kwargs=kwargs))

    for p in runners:

        p.start()

        testq[i].put("TEST_RUNNER_TERMINATE")

    multi.debug("Spawned %d test runners, PIDs are %s" %

    multi.debug("Joining %d processes" % len(runners))

    # Patch extra parameters into test names by manipulating method docstrings

    for (mname, m) in \

        if hasattr(m, __doc__):

    # Make sure the class can be pickled, by listing it among

    # the attributes of __main__. A PicklingError is raised otherwise.

    # Show staled servers

    print >>sys.stderr, yellow + \

    print >>sys.stderr, "    " + \

    # Delete staled servers

    if delete_stale:

        # Wait for all servers to be deleted

        while True:

            servers = c.list_servers()

                print >> sys.stderr, green + "    ...done" + normal

                break

            elif time.time() > fail_tmout:

                print >> sys.stderr, red + \

            else:

                time.sleep(query_interval)

    else:

    # Show staled networks

    print >> sys.stderr, yellow + \

    print "    " + \

    # Delete staled networks

    if delete_stale:

        # Wait for all networks to be deleted

        while True:

            networks = c.list_networks()

                print >> sys.stderr, green + "    ...done" + normal

                break

            elif time.time() > fail_tmout:

                print >> sys.stderr, red + \

            else:

                time.sleep(query_interval)

    else:

# Parse arguments functions

def parse_comma(option, opt, value, parser):

    tests = set(['all', 'auth', 'images', 'flavors',

    parse_input = value.split(',')

    if not (set(parse_input)).issubset(tests):

                      help="The token to use for authentication to the API")

    parser.add_option("--nofailfast",

                      action="store_true", dest="nofailfast",

                           "fails (EXPERIMENTAL)",

                      default=False)

    parser.add_option("--no-ipv6",

    parser.add_option("--action-timeout",

                      action="store", type="int", dest="action_timeout",

                      metavar="TIMEOUT",

                           "complete, then the test is considered failed",

                      default=100)

    parser.add_option("--build-warning",

                      action="store", type="int", dest="build_warning",

                      metavar="TIMEOUT",

                           "build operation is still pending",

                      default=600)

    parser.add_option("--build-fail",

                      action="store", type="int", dest="build_fail",

                      metavar="BUILD_TIMEOUT",

                           "and a build operation is still incomplete",

                      default=900)

    parser.add_option("--query-interval",

                      action="store", type="int", dest="query_interval",

                      metavar="INTERVAL",

                           "every INTERVAL seconds",

                      default=3)

    parser.add_option("--fanout",

                      action="store", type="int", dest="fanout",

                      metavar="COUNT",

                           "server build requests outstanding (EXPERIMENTAL)",

                      default=1)

    parser.add_option("--force-flavor",

                      action="store", type="int", dest="force_flavorid",

                      metavar="FLAVOR ID",

                           "useful if disk space is scarce",

                      default=None)

    parser.add_option("--image-id",

                      action="store", type="string", dest="force_imageid",

                      metavar="IMAGE ID",

                           "all available images (mandatory argument)",

                      default=None)

    parser.add_option("--show-stale",

                      action="store_true", dest="show_stale",

                           "name starts with `%s'" % SNF_TEST_PREFIX,

                      default=False)

    parser.add_option("--delete-stale",

                      action="store_true", dest="delete_stale",

                           "name starts with `%s'" % SNF_TEST_PREFIX,

                      default=False)

    parser.add_option("--force-personality",

                      default="/var/log/burnin/")

    parser.add_option("--verbose", "-V",

                      action="store_true", dest="verbose",

                           "processes spawning",

                      default=False)

    parser.add_option("--set-tests",

    if not opts.show_stale:

        if not opts.force_imageid:

            print >>sys.stderr, red + \

            parser.print_help()

            sys.exit(1)

        if opts.force_imageid != 'all':

                opts.force_imageid = str(opts.force_imageid)

            except ValueError:

                print >>sys.stderr, red + \

                sys.exit(1)

    # `token' is mandatory

    if not opts.token:

        print >>sys.stderr, red + \

        parser.print_help()

        sys.exit(1)

    # Initialize a kamaki instance, get flavors, images

    c = ComputeClient(API, TOKEN)

    DIMAGES = c.list_images(detail=True)

    DFLAVORS = c.list_flavors(detail=True)

    # Run them: FIXME: In parallel, FAILEARLY, catchbreak?

    #unittest.main(verbosity=2, catchbreak=True)

    if opts.force_imageid == 'all':

        test_images = DIMAGES

    else:

        test_images = filter(lambda x: x["id"] == opts.force_imageid, DIMAGES)

    if not os.path.exists(opts.log_folder):

        os.mkdir(opts.log_folder)

    test_folder = os.path.join(opts.log_folder, TEST_RUN_ID)

    os.mkdir(test_folder)

    for image in test_images:

        imageid = str(image["id"])

        if opts.force_flavorid:

            flavorid = opts.force_flavorid

        else:

            flavorid = choice([f["id"] for f in DFLAVORS if f["disk"] >= 20])

            f = open(opts.personality_path)

            content = b64encode(f.read())

            personality = []

            st = os.stat(opts.personality_path)

            personality.append({

        else:

            personality = None

        servername = "%s%s for %s" % (SNF_TEST_PREFIX, TEST_RUN_ID, imagename)

        is_windows = imagename.lower().find("windows") >= 0

        ServerTestCase = _spawn_server_test_case(

            imageid=imageid,

            flavorid=flavorid,

            action_timeout=opts.action_timeout,

            build_warning=opts.build_warning,

            build_fail=opts.build_fail,

        NetworkTestCase = _spawn_network_test_case(

            action_timeout=opts.action_timeout,

            imageid=imageid,

            flavorid=flavorid,

            imagename=imagename,

        test_dict = {'auth': UnauthorizedTestCase,

                     'images': ImagesTestCase,

                     'flavors': FlavorsTestCase,

                     'servers': ServersTestCase,

                     'server_spawn': ServerTestCase,

                     'network_spawn': NetworkTestCase}

        seq_cases = []

        if 'all' in opts.tests:

            seq_cases = [UnauthorizedTestCase, ImagesTestCase, FlavorsTestCase,

            for test in opts.tests:

                seq_cases.append(test_dict[test])

        image_folder = os.path.join(test_folder, imageid)

        os.mkdir(image_folder)

            _run_cases_in_parallel(seq_cases, opts.fanout, image_folder)

        else:

if __name__ == "__main__":

    sys.exit(main())