Merge lp:~zulcss/uec-testing-scripts/uec-testing-scripts into lp:uec-testing-scripts

[Chuck Short]

This branch breaks up openstack and uec.

[C de-Avillez (hggdh2)]

approved.

review: Approve

=== added directory 'openstack'
=== added directory 'openstack/bin'
=== added file 'openstack/config.yaml'
--- openstack/config.yaml	1970-01-01 00:00:00 +0000
+++ openstack/config.yaml	2011-01-13 00:51:02 +0000
@@ -0,0 +1,5 @@
+conf:
+ kernel_image: ~/tmp/natty-server-uec-i386-vmlinuz-virtual
+ kernel_name: natty-server-uec-i386-vmlinuz-virtual
+ image: ~/tmp/natty-server-uec-i386.img
+ image_name: natty-server-uec-i386.img

=== added file 'openstack/uec_testing.py'
--- openstack/uec_testing.py	1970-01-01 00:00:00 +0000
+++ openstack/uec_testing.py	2011-01-13 00:51:02 +0000
@@ -0,0 +1,22 @@
+#!/usr/bin/python
+
+import optparse
+import yaml
+import sys
+import unittest
+
+from uectesting.utils import options
+from uectesting.testing import UECImageTest, UECInstanceTest, UECVolumeTest
+
+def main():
+    if options.config_file:
+            suite = unittest.TestSuite()
+            suite.addTest(unittest.makeSuite(UECImageTest))
+            suite.addTest(unittest.makeSuite(UECInstanceTest))
+            suite.addTest(unittest.makeSuite(UECVolumeTest))
+
+            unittest.TextTestRunner(verbosity=2).run(suite)
+
+
+if __name__ == "__main__":
+    main()

=== added directory 'openstack/uectesting'
=== added file 'openstack/uectesting/__init__.py'
=== added file 'openstack/uectesting/base.py'
--- openstack/uectesting/base.py	1970-01-01 00:00:00 +0000
+++ openstack/uectesting/base.py	2011-01-13 00:51:02 +0000
@@ -0,0 +1,116 @@
+import boto
+import commands
+import httplib
+import os
+import paramiko
+import random
+import sys
+import unittest
+import yaml
+
+from boto.ec2.regioninfo import RegionInfo
+from uectesting.utils import options
+
+class UECTestCase(unittest.TestCase):
+    def connect_ssh(self, ip, key_name):
+        # TODO(devcamcar): set a more reasonable connection timeout time
+        key = paramiko.RSAKey.from_private_key_file('/tmp/%s.pem' % key_name)
+        client = paramiko.SSHClient()
+        client.set_missing_host_key_policy(paramiko.WarningPolicy())
+        client.connect(ip, username='root', pkey=key)
+        stdin, stdout, stderr = client.exec_command('uptime')
+        print 'uptime: ', stdout.read()
+        return client
+
+    def can_ping(self, ip):
+        """ Attempt to ping the specified IP, and give up after 1 second. """
+
+        # NOTE(devcamcar): ping timeout flag is different in OSX.
+        if sys.platform == 'darwin':
+            timeout_flag = 't'
+        else:
+            timeout_flag = 'w'
+
+        status, output = commands.getstatusoutput('ping -c1 -%s1 %s' %
+                                                  (timeout_flag, ip))
+        return status == 0
+
+    def get_connection(self, **kwargs):
+        """
+        Returns a boto ec2 connection for the current environment.
+        """
+        access_key = os.getenv('EC2_ACCESS_KEY')
+        secret_key = os.getenv('EC2_SECRET_KEY')
+        clc_url = os.getenv('EC2_URL')
+
+        if not access_key or not secret_key or not clc_url:
+            raise Exception('Missing EC2 environment variables. Please source '
+                            'the appropriate novarc file before running this '
+                            'test.')
+
+        parts = self.split_clc_url(clc_url)
+        return boto.connect_ec2(aws_access_key_id=access_key,
+                                aws_secret_access_key=secret_key,
+                                is_secure=parts['is_secure'],
+                                region=RegionInfo(None,
+                                                  'nova',
+                                                  parts['ip']),
+                                port=parts['port'],
+                                path='/services/Cloud',
+                                **kwargs)
+
+    def split_clc_url(self, clc_url):
+        """
+        Splits a cloud controller endpoint url.
+        """
+        parts = httplib.urlsplit(clc_url)
+        is_secure = parts.scheme == 'https'
+        ip, port = parts.netloc.split(':')
+        return {'ip': ip, 'port': int(port), 'is_secure': is_secure}
+
+    def create_key_pair(self, conn, key_name):
+        try:
+            os.remove('/tmp/%s.pem' % key_name)
+        except:
+            pass
+        key = conn.create_key_pair(key_name)
+        key.save('/tmp/')
+        return key
+
+    def delete_key_pair(self, conn, key_name):
+        conn.delete_key_pair(key_name)
+        try:
+            os.remove('/tmp/%s.pem' % key_name)
+        except:
+            pass
+
+    def bundle_image(self, image, kernel=False):
+        cmd = 'euca-bundle-image -i %s' % image
+        if kernel:
+            cmd += ' --kernel true'
+        status, output = commands.getstatusoutput(cmd)
+        if status != 0:
+            print '%s -> \n %s' % (cmd, output)
+            raise Exception(output)
+        return True
+
+    def upload_image(self, bucket_name, image):
+        cmd = 'euca-upload-bundle -b %s -m /tmp/%s.manifest.xml' % (bucket_name, image)
+        status, output = commands.getstatusoutput(cmd)
+        if status != 0:
+            print '%s -> \n %s' % (cmd, output)
+            raise Exception(output)
+        return True
+
+    def delete_bundle_bucket(self, bucket_name):
+        cmd = 'euca-delete-bundle --clear -b %s' % (bucket_name)
+        status, output = commands.getstatusoutput(cmd)
+        if status != 0:
+            print '%s -> \n%s' % (cmd, output)
+            raise Exception(output)
+        return True
+          
+    def load_config(self):
+        conf = open(options.config_file, "r")
+        config = yaml.load(conf)
+        return config

=== added file 'openstack/uectesting/testing.py'
--- openstack/uectesting/testing.py	1970-01-01 00:00:00 +0000
+++ openstack/uectesting/testing.py	2011-01-13 00:51:02 +0000
@@ -0,0 +1,312 @@
+import commands
+import os
+import random
+import socket
+import sys
+import time
+import unittest
+
+from uectesting import base
+
+TEST_PREFIX = 'test%s' % int (random.random()*1000000)
+TEST_BUCKET = '%s_bucket' % TEST_PREFIX
+TEST_KEY = '%s_key' % TEST_PREFIX
+TEST_DATA = {}
+
+class UECTestingCase(base.UECTestCase):
+    def setUp(self):   
+        self.config = self.load_config()
+        self.conn = self.get_connection()
+
+        self.image = self.config['conf']['image']
+        self.image_name = self.config['conf']['image_name']
+
+        self.kernel_image = self.config['conf']['kernel_image']
+        self.kernel_name = self.config['conf']['kernel_name']
+
+        self.ramdisk_image = self.config['conf']['ramdisk_image']
+        self.ramdisk_name = self.config['conf']['ramdisk_name']
+
+        self.bucket_name = self.config['conf']['bucket']
+	
+	global TEST_DATA
+	self.data = TEST_DATA
+
+class UECImageTest(UECTestingCase):
+    def setUp(self):
+	global TEST_DATA
+	self.data = TEST_DATA
+
+    def test_001_can_bundle_image(self):
+        self.assertTrue(self.bundle_image(self.image))
+
+    def test_002_can_upload_image(self):
+        self.assertTrue(self.upload_image(TEST_BUCKET, self.image_name))
+
+    def test_003_can_register_image(self):
+        image_id = self.conn.register_image('%s/%s.manifest.xml' %
+                                            (TEST_BUCKET, self.image_name))
+        self.assert_(image_id is not None)
+        self.data['image_id'] = image_id
+
+    def test_004_can_bundle_kernel(self):
+        self.assertTrue(self.bundle_image(self.kernel_image, kernel=True))
+
+    def test_005_can_upload_kernel(self):
+        self.assertTrue(self.upload_image(TEST_BUCKET, self.kernel_name))
+
+    def test_006_can_register_kernel(self):
+        kernel_id = self.conn.register_image('%s/%s.manifest.xml' %
+                                             (TEST_BUCKET, self.kernel_name))
+        self.assert_(kernel_id is not None)
+        self.data['kernel_id'] = kernel_id
+
+    def test_007_images_are_available_within_10_seconds(self):
+        for i in xrange(10):
+            image = self.conn.get_image(self.data['image_id'])
+            if image and image.state == 'available':
+                break
+            time.sleep(1)
+        else:
+            print image.state
+            self.assert_(False) # wasn't available within 10 seconds
+        self.assert_(image.type == 'machine')
+
+        for i in xrange(10):
+            kernel = self.conn.get_image(self.data['kernel_id'])
+            if kernel and kernel.state == 'available':
+                break
+            time.sleep(1)
+        else:
+            self.assert_(False) # wasn't available within 10 seconds
+        self.assert_(kernel.type == 'kernel')
+
+    def test_008_can_describe_image_attribute(self):
+        attrs = self.conn.get_image_attribute(self.data['image_id'],
+                                               'launchPermission')
+        self.assert_(attrs.name, 'launch_permission')
+
+    def test_009_can_modify_image_launch_permission(self):
+        self.conn.modify_image_attribute(image_id=self.data['image_id'],
+                                         operation='add',
+                                         attribute='launchPermission',
+                                         groups='all')
+        image = self.conn.get_image(self.data['image_id'])
+        self.assertEqual(image.id, self.data['image_id'])
+
+    def test_010_can_see_launch_permission(self):
+        attrs = self.conn.get_image_attribute(self.data['image_id'],
+                                              'launchPermission')
+        self.assert_(attrs.name, 'launch_permission')
+        self.assert_(attrs.attrs['groups'][0], 'all')
+
+    def test_011_user_can_deregister_kernel(self):
+        self.assertTrue(self.conn.deregister_image(self.data['kernel_id']))
+
+    def test_012_can_deregister_image(self):
+        self.assertTrue(self.conn.deregister_image(self.data['image_id']))
+
+    def test_013_can_delete_bundle(self):
+        self.assertTrue(self.delete_bundle_bucket(TEST_BUCKET))
+
+class UECInstanceTest(UECTestingCase):
+    def setUp(self):
+	global TEST_DATA
+	self.data = TEST_DATA
+
+    def test_001_can_create_keypair(self):
+        key = self.create_key_pair(self.conn, TEST_KEY)
+        self.assertEqual(key.name, TEST_KEY)
+
+    def test_002_can_create_instance_with_keypair(self):
+        reservation = self.conn.run_instances(self.image_name,
+                                              key_name=TEST_KEY,
+                                              instance_type='m1.tiny')
+        self.assertEqual(len(reservation.instances), 1)
+        self.data['instance_id'] = reservation.instances[0].id
+
+    def test_003_instance_runs_within_60_seconds(self):
+        reservations = self.conn.get_all_instances([data['instance_id']])
+        instance = reservations[0].instances[0]
+        # allow 60 seconds to exit pending with IP
+        for x in xrange(60):
+            instance.update()
+            if instance.state == u'running':
+                 break
+            time.sleep(1)
+        else:
+            self.fail('instance failed to start')
+        ip = reservations[0].instances[0].private_dns_name
+        self.failIf(ip == '0.0.0.0')
+        self.data['private_ip'] = ip
+        print self.data['private_ip']
+
+    def test_004_can_ping_private_ip(self):
+        for x in xrange(120):
+            # ping waits for 1 second
+            status, output = commands.getstatusoutput(
+                'ping -c1 %s' % self.data['private_ip'])
+            if status == 0:
+                break
+        else:
+            self.fail('could not ping instance')
+
+    def test_005_can_ssh_to_private_ip(self):
+        for x in xrange(30):
+            try:
+                conn = self.connect_ssh(self.data['private_ip'], TEST_KEY)
+                conn.close()
+            except Exception:
+                time.sleep(1)
+            else:
+                break
+        else:
+            self.fail('could not ssh to instance')
+
+    def test_006_can_allocate_elastic_ip(self):
+        result = self.conn.allocate_address()
+        self.assertTrue(hasattr(result, 'public_ip'))
+        self.data['public_ip'] = result.public_ip
+
+    def test_007_can_associate_ip_with_instance(self):
+        result = self.conn.associate_address(self.data['instance_id'],
+                                             self.data['public_ip'])
+        self.assertTrue(result)
+
+    def test_008_can_ssh_with_public_ip(self):
+        for x in xrange(30):
+            try:
+                conn = self.connect_ssh(self.data['public_ip'], TEST_KEY)
+                conn.close()
+            except socket.error:
+                time.sleep(1)
+            else:
+                break
+        else:
+            self.fail('could not ssh to instance')
+
+    def test_009_can_disassociate_ip_from_instance(self):
+        result = self.conn.disassociate_address(self.data['public_ip'])
+        self.assertTrue(result)
+
+    def test_010_can_deallocate_elastic_ip(self):
+        result = self.conn.release_address(self.data['public_ip'])
+        self.assertTrue(result)
+
+    def test_999_tearDown(self):
+        self.delete_key_pair(self.conn, TEST_KEY)
+        if self.data.has_key('instance_id'):
+            self.conn.terminate_instances([data['instance_id']])
+
+
+class UECVolumeTest(UECTestingCase):
+    def setUp(self):
+        super(UECVolumeTest, self).setUp()
+        self.device = '/dev/vdb'
+
+	global TEST_DATA
+	self.data = TEST_DATA
+
+    def test_000_setUp(self):
+        self.create_key_pair(self.conn, TEST_KEY)
+        reservation = self.conn.run_instances(self.image_name,
+                                              instance_type='m1.tiny',
+                                              key_name=TEST_KEY)
+        instance = reservation.instances[0]
+        self.data['instance'] = instance
+        for x in xrange(120):
+            if self.can_ping(instance.private_dns_name):
+                break
+        else:
+            self.fail('unable to start instance')
+
+    def test_001_can_create_volume(self):
+        volume = self.conn.create_volume(1, 'nova')
+        self.assertEqual(volume.size, 1)
+        self.data['volume'] = volume
+        # Give network time to find volume.
+        time.sleep(5)
+
+    def test_002_can_attach_volume(self):
+        volume = self.data['volume']
+
+        for x in xrange(10):
+            if volume.status == u'available':
+                break
+            time.sleep(5)
+            volume.update()
+        else:
+            self.fail('cannot attach volume with state %s' % volume.status)
+
+        volume.attach(self.data['instance'].id, self.device)
+
+        # Volumes seems to report "available" too soon.
+        for x in xrange(10):
+            if volume.status == u'in-use':
+                break
+            time.sleep(5)
+            volume.update()
+
+        self.assertEqual(volume.status, u'in-use')
+
+        # Give instance time to recognize volume.
+        time.sleep(5)
+
+    def test_003_can_mount_volume(self):
+        ip = self.data['instance'].private_dns_name
+        conn = self.connect_ssh(ip, TEST_KEY)
+        commands = []
+        commands.append('mkdir -p /mnt/vol')
+        commands.append('mkfs.ext2 %s' % self.device)
+        commands.append('mount %s /mnt/vol' % self.device)
+        commands.append('echo success')
+        stdin, stdout, stderr = conn.exec_command(' && '.join(commands))
+        out = stdout.read()
+        conn.close()
+        if not out.strip().endswith('success'):
+            self.fail('Unable to mount: %s %s' % (out, stderr.read()))
+
+    def test_004_can_write_to_volume(self):
+        ip = self.data['instance'].private_dns_name
+        conn = self.connect_ssh(ip, TEST_KEY)
+        # FIXME(devcamcar): This doesn't fail if the volume hasn't been mounted
+        stdin, stdout, stderr = conn.exec_command(
+            'echo hello > /mnt/vol/test.txt')
+        err = stderr.read()
+        conn.close()
+        if len(err) > 0:
+            self.fail('Unable to write to mount: %s' % (err))
+
+    def test_005_volume_is_correct_size(self):
+        ip = self.data['instance'].private_dns_name
+        conn = self.connect_ssh(ip, TEST_KEY)
+        stdin, stdout, stderr = conn.exec_command(
+            "df -h | grep %s | awk {'print $2'}" % self.device)
+        out = stdout.read()
+        conn.close()
+        if not out.strip() == '1008M':
+            self.fail('Volume is not the right size: %s %s' %
+                      (out, stderr.read()))
+
+    def test_006_me_can_umount_volume(self):
+        ip = self.data['instance'].private_dns_name
+        conn = self.connect_ssh(ip, TEST_KEY)
+        stdin, stdout, stderr = conn.exec_command('umount /mnt/vol')
+        err = stderr.read()
+        conn.close()
+        if len(err) > 0:
+            self.fail('Unable to unmount: %s' % (err))
+
+    def test_007_me_can_detach_volume(self):
+        result = self.conn.detach_volume(volume_id=self.data['volume'].id)
+        self.assertTrue(result)
+        time.sleep(5)
+
+    def test_008_me_can_delete_volume(self):
+        result = self.conn.delete_volume(self.data['volume'].id)
+        self.assertTrue(result)
+
+    def test_999_tearDown(self):
+        self.conn.terminate_instances([self.data['instance'].id])
+        self.conn.delete_key_pair(TEST_KEY)
+

=== added file 'openstack/uectesting/utils.py'
--- openstack/uectesting/utils.py	1970-01-01 00:00:00 +0000
+++ openstack/uectesting/utils.py	2011-01-13 00:51:02 +0000
@@ -0,0 +1,6 @@
+import optparse
+
+
+optparser = optparse.OptionParser()
+optparser.add_option('-c', dest='config_file', help='Config file to use')
+(options, args) = optparser.parse_args()

=== added directory 'uec'
=== renamed file 'README' => 'uec/README'
=== renamed file 'apt-upgrade.sh' => 'uec/apt-upgrade.sh'
=== renamed file 'config_multi.yaml' => 'uec/config_multi.yaml'
=== renamed file 'config_single.yaml' => 'uec/config_single.yaml'
=== renamed file 'get-logs-ebs.sh' => 'uec/get-logs-ebs.sh'
=== renamed file 'get-logs.sh' => 'uec/get-logs.sh'
=== renamed file 'helper.sh' => 'uec/helper.sh'
=== renamed directory 'images' => 'uec/images'
=== renamed file 'myutils.py' => 'uec/myutils.py'
=== renamed file 'reboot.sh' => 'uec/reboot.sh'
=== renamed directory 'results' => 'uec/results'
=== renamed file 'scp-uec.sh' => 'uec/scp-uec.sh'
=== renamed file 'set-ssh.sh' => 'uec/set-ssh.sh'
=== renamed file 'uec_ebs.py' => 'uec/uec_ebs.py'
=== renamed file 'uec_instances.py' => 'uec/uec_instances.py'
=== renamed file 'uec_test.py' => 'uec/uec_test.py'
=== renamed file 'uec_utils.py' => 'uec/uec_utils.py'
=== renamed directory 'users' => 'uec/users'
=== renamed file 'vol-max-alloc.sh' => 'uec/vol-max-alloc.sh'