Synnefo

# --------------------------------------------------------------------

# Global Variables

TOKEN = None

PLANKTON_USER = None

NO_IPV6 = None

DEFAULT_PLANKTON_USER = "images@okeanos.grnet.gr"

NOFAILFAST = None

def _get_user_id():

    """Authenticate to astakos and get unique users id"""

    authenticate = astakos.authenticate()

# --------------------------------------------------------------------

    """Test unauthorized access"""

    @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'

        with self.assertRaises(ClientError) as cm:

            c.list_servers()

    def setUpClass(cls):

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

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

        cls.images = \

            filter(lambda x: not x['name'].startswith(SNF_TEST_PREFIX),

        cls.dimages = \

            filter(lambda x: not x['name'].startswith(SNF_TEST_PREFIX),

        cls.result_dict = dict()

        # Get uniq user id

        cls.uuid = _get_user_id()

        dnames = sorted(map(lambda x: x["name"], self.dimages))

        self.assertEqual(names, dnames)

    def test_005_image_metadata(self):

        """Test every image has specific metadata defined"""

        keys = frozenset(["osfamily", "root_partition"])

        for i in details:

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

            image['location'].replace("://", " ").replace("/", " ").split()

        log.info("Download image, with owner %s\n\tcontainer %s, and name %s"

                 % (image_location[1], image_location[2], image_location[3]))

        temp_file = os.path.join(self.temp_dir, self.temp_image_name)

        with open(temp_file, "wb+") as f:

    def test_007_upload_image(self):

        """Upload and register image"""

        temp_file = os.path.join(self.temp_dir, self.temp_image_name)

        log.info("Upload image to pithos+")

        # Create container `images'

        with open(temp_file, "rb+") as f:

        log.info("Register image to plankton")

        location = "pithos://" + self.uuid + \

            "/images/" + self.temp_image_name

        params = {'is_public': True}

        properties = {'OSFAMILY': "linux", 'ROOT_PARTITION': 1}

        # Get image id

        detail = filter(lambda x: x['location'] == location, details)

        self.assertEqual(len(detail), 1)

        cls = type(self)

        """Cleanup image test"""

        log.info("Cleanup image test")

        # Remove image from pithos+

# --------------------------------------------------------------------

    def setUpClass(cls):

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

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

        cls.result_dict = dict()

    def test_001_list_flavors(self):

        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%s" % flavor,

                             f["name"],

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

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

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

        cls.result_dict = dict()

    # def test_001_list_servers(self):

        cls.uuid = _get_user_id()

        log.info("Uniq user id = %s" % cls.uuid)

        log.info("Getting list of containers")

        cls.result_dict = dict()

    def test_001_list_containers(self):

            rand_num = randint(1000, 9999)

            rand_name = "%s%s" % (SNF_TEST_PREFIX, rand_num)

        # Create container

        # Get list of containers

        new_container_names = [n['name'] for n in new_containers]

        self.assertIn(rand_name, new_container_names)

            f.write("This is a temp file")

            f.seek(0, 0)

            # Where to save file

    def test_005_download(self):

        """Test download something from pithos+"""

        tmp_dir = tempfile.mkdtemp()

        tmp_file = os.path.join(tmp_dir, "test.txt")

        with open(tmp_file, "wb+") as f:

            # Read file

            f.seek(0, 0)

            content = f.read()

    def test_006_remove(self):

        """Test removing files and containers"""

        # List containers

        cont_names = [n['name'] for n in containers]

        self.assertNotIn(cont_name, cont_names)

    def setUpClass(cls):

        """Initialize a kamaki instance"""

        log.info("Spawning server for image `%s'" % cls.imagename)

        cls.result_dict = dict()

    def _get_ipv4(self, server):

        for nic in nics:

            net_id = nic["network_id"]

                public_addrs = nic["ipv4"]

        self.assertTrue(public_addrs is not None)

        for nic in nics:

            net_id = nic["network_id"]

                public_addrs = nic["ipv6"]

        self.assertTrue(public_addrs is not None)

    def _verify_server_status(self, current_status, new_status):

        """Verify a server has switched to a specified status"""

        if server["status"] not in (current_status, new_status):

            return None  # Do not raise exception, return so the test fails

        self.assertEquals(server["status"], new_status)

                                        msg, self._verify_server_status,

                                        current_status, new_status)

        # Ensure the status is actually the expected one

        self.assertEquals(server["status"], new_status)

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

        """Test submit create server request"""

        log.info("Submit new server request")

        log.info("Server id: " + str(server["id"]))

        log.info("Server password: " + server["adminPass"])

        self.result_dict.clear()

        servers = filter(lambda x: x["name"] == self.servername, servers)

        server = servers[0]

        log.info("Server in BUILD state in details")

        self.assertEqual(server["name"], self.servername)

        self.assertEqual(server["flavor"], self.flavorid)

        self.assertEqual(server["image"], self.imageid)

        log.info("Creating server metadata")

        os_value = image["metadata"]["os"]

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

        userlist = users.split()

        log.info("Verifying image metadata")

        self.assertEqual(servermeta["OS"], imagemeta["os"])

        http://www.realvnc.com/docs/rfbproto.pdf.

        """

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

        sock = self._insist_on_tcp_connection(

            socket.AF_INET, console["host"], console["port"])

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

        ipv4 = self._get_ipv4(server)

        self.result_dict.clear()

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

        ipv6 = self._get_ipv6(server)

        self.result_dict.clear()

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

        self.result_dict.clear()

        ip = self._get_ipv4(server)

        self._try_until_timeout_expires(self.action_timeout,

                                        self.action_timeout,

        self._skipIf(NO_IPV6, "--no-ipv6 flag enabled")

        log.info("Testing if server responds to pings in IPv6")

        ip = self._get_ipv6(server)

        self._try_until_timeout_expires(self.action_timeout,

                                        self.action_timeout,

        log.info("Shutting down server")

    def test_009_server_becomes_stopped(self):

        """Test server becomes STOPPED"""

        log.info("Starting server")

    def test_011_server_becomes_active(self):

        """Test server becomes ACTIVE again"""

        """Test SSH to server public IPv4 works, verify hostname"""

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

        self._insist_on_ssh_hostname(self._get_ipv4(server),

                                     self.username, self.passwd)

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

        self._skipIf(NO_IPV6, "--no-ipv6 flag enabled")

        self._insist_on_ssh_hostname(self._get_ipv6(server),

                                     self.username, self.passwd)

    def test_014_rdp_to_server_IPv4(self):

        "Test RDP connection to server public IPv4 works"""

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

        ipv4 = self._get_ipv4(server)

        sock = self._insist_on_tcp_connection(socket.AF_INET, ipv4, 3389)

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

        self._skipIf(NO_IPV6, "--no-ipv6 flag enabled")

        ipv6 = self._get_ipv6(server)

        sock = self._get_tcp_connection(socket.AF_INET6, ipv6, 3389)

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

        for inj_file in self.personality:

            equal_files = self._check_file_through_ssh(self._get_ipv4(server),

        log.info("Deleting server")

    def test_018_server_becomes_deleted(self):

        """Test server becomes DELETED"""

        log.info("Test if server is no longer listed")

        self.assertNotIn(self.serverid, [s["id"] for s in servers])

    def setUpClass(cls):

        "Initialize kamaki, get list of current networks"

        cls.servername = "%s%s for %s" % (SNF_TEST_PREFIX,

                                          TEST_RUN_ID,

        for nic in nics:

            net_id = nic["network_id"]

                public_addrs = nic["ipv4"]

        self.assertTrue(public_addrs is not None)

        log.info("Creating test server A")

        self.assertEqual(serverA["name"], self.servername)

        self.assertEqual(serverA["flavor"], self.flavorid)

        fail_tmout = time.time() + self.action_timeout

        while True:

            status = d['status']

            if status == 'ACTIVE':

                active = True

        log.info("Creating test server B")

        self.assertEqual(serverB["name"], self.servername)

        self.assertEqual(serverB["flavor"], self.flavorid)

        fail_tmout = time.time() + self.action_timeout

        while True:

            status = d['status']

            if status == 'ACTIVE':

                active = True

        name = SNF_TEST_PREFIX + TEST_RUN_ID

        #previous_num = len(self.client.list_networks())

        #Test if right name is assigned

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

        #Test if new network is created

        while True:

            if d['status'] == 'ACTIVE':

                connected = True

                break

        log.info("Connect VMs to private network")

        self.result_dict.clear()

        #Insist on connecting until action timeout

        fail_tmout = time.time() + self.action_timeout

        while True:

            netsA = [x['network_id']

                         self.serverid['A'])['attachments']]

            netsB = [x['network_id']

                         self.serverid['B'])['attachments']]

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

        cls = type(self)

        cls.priv_ip = dict()

            self.serverid['A'])['attachments']

            self.serverid['B'])['attachments']

        if conn_exists:

        log.info("Rebooting server A")

        fail_tmout = time.time() + self.action_timeout

        while True:

            status = d['status']

            if status == 'STOPPED':

                break

            else:

                time.sleep(self.query_interval)

        while True:

            status = d['status']

            if status == 'ACTIVE':

                active = True

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

        self.result_dict.clear()

        ip = self._get_ipv4(server)

        fail_tmout = time.time() + self.action_timeout

        log.info("Rebooting server B")

        self.result_dict.clear()

        fail_tmout = time.time() + self.action_timeout

        while True:

            status = d['status']

            if status == 'STOPPED':

                break

            else:

                time.sleep(self.query_interval)

        while True:

            status = d['status']

            if status == 'ACTIVE':

                active = True

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

        self.result_dict.clear()

        ip = self._get_ipv4(server)

        fail_tmout = time.time() + self.action_timeout

        log.info("Setting up interface eth1 for server A")

        self.result_dict.clear()

        os_value = image['metadata']['os']

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

        log.info("Setting up interface eth1 for server B")

        os_value = image['metadata']['os']

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

        log.info("Testing if server A is actually connected to server B")

        os_value = image['metadata']['os']

        hostip = self._get_ipv4(server)

        log.info("Disconnecting servers from private network")

        prev_nics = prev_state['attachments']

        #prev_conn = len(prev_nics)

        nicsA = [x['id']

                     self.serverid['A'])['attachments']]

        nicsB = [x['id']

                     self.serverid['B'])['attachments']]

        for nic in prev_nics:

            if nic in nicsA:

            if nic in nicsB:

        #Insist on deleting until action timeout

        fail_tmout = time.time() + self.action_timeout

        while True:

            netsA = [x['network_id']

                         self.serverid['A'])['attachments']]

            netsB = [x['network_id']

                         self.serverid['B'])['attachments']]

            #connected = (self.client.get_network_details(self.networkid))

        log.info("Submitting delete network request")

        fail_tmout = time.time() + self.action_timeout

        while True:

            curr_net = []

            for net in networks:

                curr_net.append(net['id'])

        log.info("Delete servers created for this test")

        fail_tmout = time.time() + self.action_timeout

        status = dict()

        while True:

            status['A'] = details['status']

            status['B'] = details['status']

            if (status['A'] == 'DELETED') and (status['B'] == 'DELETED'):

                deleted = True

# Clean up servers/networks functions

def cleanup_servers(timeout, query_interval, delete_stale=False):

    stale = [s for s in servers if s["name"].startswith(SNF_TEST_PREFIX)]

    if len(stale) == 0:

        print >> sys.stderr, "Deleting %d stale servers:" % len(stale)

        fail_tmout = time.time() + timeout

        for s in stale:

        # Wait for all servers to be deleted

        while True:

            stale = [s for s in servers

                     if s["name"].startswith(SNF_TEST_PREFIX)]

            if len(stale) == 0:

def cleanup_networks(action_timeout, query_interval, delete_stale=False):

    stale = [n for n in networks if n["name"].startswith(SNF_TEST_PREFIX)]

    if len(stale) == 0:

        print >> sys.stderr, "Deleting %d stale networks:" % len(stale)

        fail_tmout = time.time() + action_timeout

        for n in stale:

        # Wait for all networks to be deleted

        while True:

            stale = [n for n in networks

                     if n["name"].startswith(SNF_TEST_PREFIX)]

            if len(stale) == 0:

    parser = OptionParser(**kw)

    parser.disable_interspersed_args()

                      default=None)

    parser.add_option("--plankton-user",

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

                      help="Owner of system images",

                      default=DEFAULT_PLANKTON_USER)

    parser.add_option("--token",

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

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

    # `token' is mandatory

    _mandatory_argument(opts.token, "--token")

    if not opts.show_stale:

        # `image-id' is mandatory

                    "--image-id. Use a valid id, or `all'." + \

                    normal

                sys.exit(1)

    return (opts, args)

def _mandatory_argument(Arg, Str):

        print >>sys.stderr, red + \

            "The " + Str + " argument is mandatory.\n" + \

            normal

    (opts, args) = parse_arguments(sys.argv[1:])

    # Some global variables

    TOKEN = opts.token

    PLANKTON_USER = opts.plankton_user

    NO_IPV6 = opts.no_ipv6

    VERBOSE = opts.verbose

    NOFAILFAST = opts.nofailfast

        return 0

    # Initialize a kamaki instance, get flavors, images

    # FIXME: logging, log, LOG PID, TEST_RUN_ID, arguments

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