merge fixes from anso branch

3 files changed, 77 insertions, 101 deletions

diff --git a/smoketests/base.py b/smoketests/base.py
index 89ee92840..afc618074 100644
--- a/smoketests/base.py
+++ b/smoketests/base.py
@@ -22,6 +22,7 @@ import httplib
 import os
 import paramiko
 import sys
+import time
 import unittest
 from boto.ec2.regioninfo import RegionInfo
 
@@ -31,7 +32,6 @@ FLAGS = flags.FLAGS
 boto_v6 = None
 
 
-
 class SmokeTestCase(unittest.TestCase):
     def connect_ssh(self, ip, key_name):
         # TODO(devcamcar): set a more reasonable connection timeout time
@@ -39,12 +39,10 @@ class SmokeTestCase(unittest.TestCase):
         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. """
+    def can_ping(self, ip, command="ping"):
+        """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':
@@ -52,10 +50,41 @@ class SmokeTestCase(unittest.TestCase):
         else:
             timeout_flag = 'w'
 
-        status, output = commands.getstatusoutput('ping -c1 -%s1 %s' %
-                                                  (timeout_flag, ip))
+        status, output = commands.getstatusoutput('%s -c1 -%s1 %s' %
+                                                  (command, timeout_flag, ip))
         return status == 0
 
+    def wait_for_running(self, instance, tries=60, wait=1):
+        """Wait for instance to be running"""
+        for x in xrange(tries):
+            instance.update()
+            if instance.state.startswith('running'):
+                return True
+            time.sleep(wait)
+        else:
+            return False
+
+    def wait_for_ping(self, ip, command="ping", tries=120):
+        """Wait for ip to be pingable"""
+        for x in xrange(tries):
+            if self.can_ping(ip, command):
+                return True
+        else:
+            return False
+
+    def wait_for_ssh(self, ip, key_name, tries=30, wait=5):
+        """Wait for ip to be sshable"""
+        for x in xrange(tries):
+            try:
+                conn = self.connect_ssh(ip, key_name)
+                conn.close()
+            except Exception, e:
+                time.sleep(wait)
+            else:
+                return True
+        else:
+            return False
+
     def connection_for_env(self, **kwargs):
         """
         Returns a boto ec2 connection for the current environment.
diff --git a/smoketests/flags.py b/smoketests/flags.py
index dc756347b..5f3c8505e 100644
--- a/smoketests/flags.py
+++ b/smoketests/flags.py
@@ -36,4 +36,4 @@ DEFINE_bool = DEFINE_bool
 
 DEFINE_string('region', 'nova', 'Region to use')
 DEFINE_string('test_image', 'ami-tty', 'Image to use for launch tests')
-DEFINE_bool('use_ipv6', True, 'use the ipv6 or not')
+DEFINE_bool('use_ipv6', False, 'use the ipv6 or not')
diff --git a/smoketests/user_smoketests.py b/smoketests/user_smoketests.py
index e5bc98ede..26f6344f7 100644
--- a/smoketests/user_smoketests.py
+++ b/smoketests/user_smoketests.py
@@ -19,7 +19,6 @@
 import commands
 import os
 import random
-import socket
 import sys
 import time
 import unittest
@@ -91,7 +90,6 @@ class ImageTests(UserSmokeTestCase):
                 break
             time.sleep(1)
         else:
-            print image.state
             self.assert_(False)  # wasn't available within 10 seconds
         self.assert_(image.type == 'machine')
 
@@ -143,70 +141,36 @@ class InstanceTests(UserSmokeTestCase):
                                               key_name=TEST_KEY,
                                               instance_type='m1.tiny')
         self.assertEqual(len(reservation.instances), 1)
-        self.data['instance_id'] = reservation.instances[0].id
+        self.data['instance'] = reservation.instances[0]
 
     def test_003_instance_runs_within_60_seconds(self):
-        reservations = self.conn.get_all_instances([self.data['instance_id']])
-        instance = reservations[0].instances[0]
+        instance = self.data['instance']
         # 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:
+        if not self.wait_for_running(self.data['instance']):
             self.fail('instance failed to start')
-        ip = reservations[0].instances[0].private_dns_name
+        self.data['instance'].update()
+        ip = self.data['instance'].private_dns_name
         self.failIf(ip == '0.0.0.0')
-        self.data['private_ip'] = ip
         if FLAGS.use_ipv6:
-            ipv6 = reservations[0].instances[0].dns_name_v6
+            ipv6 = self.data['instance'].dns_name_v6
             self.failIf(ipv6 is None)
-            self.data['ip_v6'] = ipv6
 
     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:
+        if not self.wait_for_ping(self.data['instance'].private_dns_name):
             self.fail('could not ping instance')
 
         if FLAGS.use_ipv6:
-            for x in xrange(120):
-            # ping waits for 1 second
-                status, output = commands.getstatusoutput(
-                    'ping6 -c1 %s' % self.data['ip_v6'])
-                if status == 0:
-                    break
-            else:
-                self.fail('could not ping instance')
+            if not self.wait_for_ping(self.data['instance'].ip_v6, "ping6"):
+                self.fail('could not ping instance v6')
 
     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, e:
-                time.sleep(5)
-            else:
-                break
-        else:
+        if not self.wait_for_ssh(self.data['instance'].private_dns_name,
+                                 TEST_KEY):
             self.fail('could not ssh to instance')
 
         if FLAGS.use_ipv6:
-            for x in xrange(30):
-                try:
-                    conn = self.connect_ssh(
-                                        self.data['ip_v6'], TEST_KEY)
-                    conn.close()
-                except Exception:
-                    time.sleep(1)
-                else:
-                    break
-            else:
+            if not self.wait_for_ssh(self.data['instance'].ip_v6,
+                                     TEST_KEY):
                 self.fail('could not ssh to instance v6')
 
     def test_006_can_allocate_elastic_ip(self):
@@ -215,21 +179,13 @@ class InstanceTests(UserSmokeTestCase):
         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'],
+        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 Exception:
-                time.sleep(1)
-            else:
-                break
-        else:
-            self.fail('could not ssh to instance')
+        if not self.wait_for_ssh(self.data['public_ip'], TEST_KEY):
+            self.fail('could not ssh to public ip')
 
     def test_009_can_disassociate_ip_from_instance(self):
         result = self.conn.disassociate_address(self.data['public_ip'])
@@ -241,8 +197,7 @@ class InstanceTests(UserSmokeTestCase):
 
     def test_999_tearDown(self):
         self.delete_key_pair(self.conn, TEST_KEY)
-        if self.data.has_key('instance_id'):
-            self.conn.terminate_instances([self.data['instance_id']])
+        self.conn.terminate_instances([self.data['instance'].id])
 
 
 class VolumeTests(UserSmokeTestCase):
@@ -255,24 +210,14 @@ class VolumeTests(UserSmokeTestCase):
         reservation = self.conn.run_instances(FLAGS.test_image,
                                               instance_type='m1.tiny',
                                               key_name=TEST_KEY)
-        instance = reservation.instances[0]
-        for x in xrange(120):
-            time.sleep(1)
-            instance.update()
-            if self.can_ping(instance.private_dns_name):
-                break
-        else:
-            self.fail('unable to start instance')
-        self.data['instance'] = instance
-        for x in xrange(30):
-            try:
-                conn = self.connect_ssh(instance.private_dns_name, TEST_KEY)
-                conn.close()
-            except Exception:
-                time.sleep(5)
-            else:
-                break
-        else:
+        self.data['instance'] = reservation.instances[0]
+        if not self.wait_for_running(self.data['instance']):
+            self.fail('instance failed to start')
+        self.data['instance'].update()
+        if not self.wait_for_ping(self.data['instance'].private_dns_name):
+            self.fail('could not ping instance')
+        if not self.wait_for_ssh(self.data['instance'].private_dns_name,
+                                 TEST_KEY):
             self.fail('could not ssh to instance')
 
     def test_001_can_create_volume(self):
@@ -280,32 +225,34 @@ class VolumeTests(UserSmokeTestCase):
         self.assertEqual(volume.size, 1)
         self.data['volume'] = volume
         # Give network time to find volume.
-        time.sleep(5)
+        time.sleep(10)
 
     def test_002_can_attach_volume(self):
         volume = self.data['volume']
 
-        for x in xrange(30):
+        for x in xrange(10):
+            volume.update()
             if volume.status.startswith('available'):
                 break
             time.sleep(1)
-            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.
+        # wait
         for x in xrange(10):
+            volume.update()
             if volume.status.startswith('in-use'):
                 break
-            time.sleep(5)
-            volume.update()
+            time.sleep(1)
+        else:
+            self.fail('volume never got to in use')
 
         self.assertTrue(volume.status.startswith('in-use'))
 
         # Give instance time to recognize volume.
-        time.sleep(5)
+        time.sleep(10)
 
     def test_003_can_mount_volume(self):
         ip = self.data['instance'].private_dns_name
@@ -316,12 +263,12 @@ class VolumeTests(UserSmokeTestCase):
                 'grep %s /proc/partitions | '
                 '`awk \'{print "mknod /dev/"\\$4" b "\\$1" "\\$2}\'`'
                 % self.device.rpartition('/')[2])
-        commands = []
-        commands.append('mkdir -p /mnt/vol')
-        commands.append('/sbin/mke2fs %s' % self.device)
-        commands.append('mount %s /mnt/vol' % self.device)
-        commands.append('echo success')
-        stdin, stdout, stderr = conn.exec_command(' && '.join(commands))
+        exec_list = []
+        exec_list.append('mkdir -p /mnt/vol')
+        exec_list.append('/sbin/mke2fs %s' % self.device)
+        exec_list.append('mount %s /mnt/vol' % self.device)
+        exec_list.append('echo success')
+        stdin, stdout, stderr = conn.exec_command(' && '.join(exec_list))
         out = stdout.read()
         conn.close()
         if not out.strip().endswith('success'):