Merge pull request softlayer#249 from CrackerJackMack/wait

sudorandom · sudorandom · commit b81961b967fa · 2013-12-17T17:29:09.000-08:00
Fixes CCI wait_for_transaction
diff --git a/SoftLayer/CLI/modules/cci.py b/SoftLayer/CLI/modules/cci.py
@@ -463,7 +463,7 @@ def execute(self, args):
                 output.append(t)
 
                 if args.get('--wait'):
-                    ready = cci.wait_for_transaction(
+                    ready = cci.wait_for_ready(
                         result['id'], int(args.get('--wait') or 1))
                     t.add_row(['ready', ready])
             else:
@@ -648,7 +648,7 @@ def execute(self, args):
         cci = CCIManager(self.client)
 
         cci_id = resolve_id(cci.resolve_ids, args.get('<identifier>'), 'CCI')
-        ready = cci.wait_for_transaction(cci_id, int(args.get('--wait') or 0))
+        ready = cci.wait_for_ready(cci_id, int(args.get('--wait') or 0))
 
         if ready:
             return "READY"
diff --git a/SoftLayer/managers/cci.py b/SoftLayer/managers/cci.py
@@ -10,7 +10,7 @@
 from time import sleep
 from itertools import repeat
 
-from SoftLayer.utils import NestedDict, query_filter, IdentifierMixin
+from SoftLayer.utils import NestedDict, query_filter, IdentifierMixin, lookup
 
 
 class CCIManager(IdentifierMixin, object):
@@ -165,6 +165,7 @@ def get_instance(self, instance_id, **kwargs):
                 'maxMemory',
                 'datacenter',
                 'activeTransaction[id, transactionStatus[friendlyName,name]]',
+                'lastOperatingSystemReload.id',
                 'blockDevices',
                 'blockDeviceTemplateGroup[id, name, globalIdentifier]',
                 'postInstallScriptUri',
@@ -337,16 +338,55 @@ def _generate_create_dict(
 
     def wait_for_transaction(self, instance_id, limit, delay=1):
         """ Waits on a CCI transaction for the specified amount of time.
+        is really just a wrapper for wait_for_ready(pending=True).
+        Provided for backwards compatibility.
+
+
+        :param int instance_id: The instance ID with the pending transaction
+        :param int limit: The maximum amount of time to wait.
+        :param int delay: The number of seconds to sleep before checks.
+                          Defaults to 1.
+        """
+
+        return self.wait_for_ready(instance_id, limit, delay=delay,
+                                   pending=True)
+
+    def wait_for_ready(self, instance_id, limit, delay=1, pending=False):
+        """ Determine if a CCI is ready and available.  In some cases
+        though, that can mean that no transactions are running. The default
+        arguments imply a CCI is operational and ready for use by having
+        network connectivity and remote access is available.  Setting
+        ``pending=True`` will ensure future API calls
+        against this instance will not error due to pending
+        transactions such as OS Reloads and cancellations.
 
         :param int instance_id: The instance ID with the pending transaction
         :param int limit: The maximum amount of time to wait.
         :param int delay: The number of seconds to sleep before checks.
                           Defaults to 1.
+        :param bool pending: Wait for pending transactions not related to
+                             provisioning or reloads such as monitoring.
         """
-        for count, new_instance in enumerate(repeat(instance_id)):
+        for count, new_instance in enumerate(repeat(instance_id), start=1):
             instance = self.get_instance(new_instance)
-            if not instance.get('activeTransaction', {}).get('id') and \
-                    instance.get('provisionDate'):
+            last_reload = lookup(instance, 'lastOperatingSystemReload', 'id')
+            active_transaction = lookup(instance, 'activeTransaction', 'id')
+
+            reloading = all((
+                active_transaction,
+                last_reload,
+                last_reload == active_transaction
+            ))
+
+            # only check for outstanding transactions if requested
+            outstanding = False
+            if pending:
+                outstanding = active_transaction
+
+            # return True if the instance has only if the instance has
+            # finished provisioning and isn't currently reloading the OS.
+            if instance.get('provisionDate') \
+                    and not reloading and not outstanding:
                 return True
 
             if count >= limit:
diff --git a/SoftLayer/tests/managers/cci_tests.py b/SoftLayer/tests/managers/cci_tests.py
@@ -502,50 +502,182 @@ def test_generate_multi_disk(self):
         self.assertTrue(data.get('blockDevices'))
         self.assertEqual(data['blockDevices'], assert_data['blockDevices'])
 
+    def test_change_port_speed_public(self):
+        cci_id = 1
+        speed = 100
+        self.cci.change_port_speed(cci_id, True, speed)
+
+        service = self.client['Virtual_Guest']
+        f = service.setPublicNetworkInterfaceSpeed
+        f.assert_called_once_with(speed, id=cci_id)
+
+    def test_change_port_speed_private(self):
+        cci_id = 2
+        speed = 10
+        self.cci.change_port_speed(cci_id, False, speed)
+
+        service = self.client['Virtual_Guest']
+        f = service.setPrivateNetworkInterfaceSpeed
+        f.assert_called_once_with(speed, id=cci_id)
+
+    def test_edit(self):
+        # Test editing user data
+        service = self.client['Virtual_Guest']
+
+        self.cci.edit(100, userdata='my data')
+
+        service.setUserMetadata.assert_called_once_with(['my data'], id=100)
+
+        # Now test a blank edit
+        self.assertTrue(self.cci.edit, 100)
+
+        # Finally, test a full edit
+        args = {
+            'hostname': 'new-host',
+            'domain': 'new.sftlyr.ws',
+            'notes': 'random notes',
+        }
+
+        self.cci.edit(100, **args)
+        service.editObject.assert_called_once_with(args, id=100)
+
+
+class CCIWaitReadyGoTests(unittest.TestCase):
+
+    def setUp(self):
+        self.client = MagicMock()
+        self.cci = CCIManager(self.client)
+        self.guestObject = self.client['Virtual_Guest'].getObject
+
+    @patch('SoftLayer.managers.cci.CCIManager.wait_for_ready')
+    def test_wait_interface(self, ready):
+        # verify interface to wait_for_ready is intact
+        self.cci.wait_for_transaction(1, 1)
+        ready.assert_called_once_with(1, 1, delay=1, pending=True)
+
+    def test_active_not_provisioned(self):
+        # active transaction and no provision date should be false
+        self.guestObject.side_effect = [
+            {'activeTransaction': {'id': 1}},
+        ]
+        value = self.cci.wait_for_ready(1, 1)
+        self.assertFalse(value)
+
+    def test_active_and_provisiondate(self):
+        # active transaction and provision date should be True
+        self.guestObject.side_effect = [
+            {'activeTransaction': {'id': 1},
+             'provisionDate': 'aaa'},
+        ]
+        value = self.cci.wait_for_ready(1, 1)
+        self.assertTrue(value)
+
+    def test_active_provision_pending(self):
+        # active transaction and provision date
+        # and pending should be false
+        self.guestObject.side_effect = [
+            {'activeTransaction': {'id': 1},
+             'provisionDate': 'aaa'},
+        ]
+        value = self.cci.wait_for_ready(1, 1, pending=True)
+        self.assertFalse(value)
+
+    def test_active_reload(self):
+        # actively running reload
+        self.guestObject.side_effect = [
+            {
+                'activeTransaction': {'id': 1},
+                'provisionDate': 'aaa',
+                'lastOperatingSystemReload': {'id': 1},
+            },
+        ]
+        value = self.cci.wait_for_ready(1, 1)
+        self.assertFalse(value)
+
+    def test_reload_no_pending(self):
+        # reload complete, maintance transactions
+        self.guestObject.side_effect = [
+            {
+                'activeTransaction': {'id': 2},
+                'provisionDate': 'aaa',
+                'lastOperatingSystemReload': {'id': 1},
+            },
+        ]
+        value = self.cci.wait_for_ready(1, 1)
+        self.assertTrue(value)
+
+    def test_reload_pending(self):
+        # reload complete, pending maintance transactions
+        self.guestObject.side_effect = [
+            {
+                'activeTransaction': {'id': 2},
+                'provisionDate': 'aaa',
+                'lastOperatingSystemReload': {'id': 1},
+            },
+        ]
+        value = self.cci.wait_for_ready(1, 1, pending=True)
+        self.assertFalse(value)
+
     @patch('SoftLayer.managers.cci.sleep')
-    def test_wait(self, _sleep):
-        guestObject = self.client['Virtual_Guest'].getObject
+    def test_ready_iter_once_incomplete(self, _sleep):
+        self.guestObject = self.client['Virtual_Guest'].getObject
 
+        # no iteration, false
+        self.guestObject.side_effect = [
+            {'activeTransaction': {'id': 1}},
+        ]
+        value = self.cci.wait_for_ready(1, 1)
+        self.assertFalse(value)
+        self.assertFalse(_sleep.called)
+
+    @patch('SoftLayer.managers.cci.sleep')
+    def test_iter_once_complete(self, _sleep):
+        # no iteration, true
+        self.guestObject.side_effect = [
+            {'provisionDate': 'aaa'},
+        ]
+        value = self.cci.wait_for_ready(1, 1)
+        self.assertTrue(value)
+        self.assertFalse(_sleep.called)
+
+    @patch('SoftLayer.managers.cci.sleep')
+    def test_iter_four_complete(self, _sleep):
         # test 4 iterations with positive match
-        guestObject.side_effect = [
+        self.guestObject.side_effect = [
             {'activeTransaction': {'id': 1}},
             {'activeTransaction': {'id': 1}},
             {'activeTransaction': {'id': 1}},
             {'provisionDate': 'aaa'},
-            {'provisionDate': 'aaa'}
         ]
 
-        value = self.cci.wait_for_transaction(1, 4)
+        value = self.cci.wait_for_ready(1, 4)
         self.assertTrue(value)
         _sleep.assert_has_calls([call(1), call(1), call(1)])
-        guestObject.assert_has_calls([
+        self.guestObject.assert_has_calls([
             call(id=1, mask=ANY), call(id=1, mask=ANY),
             call(id=1, mask=ANY), call(id=1, mask=ANY),
         ])
 
+    @patch('SoftLayer.managers.cci.sleep')
+    def test_iter_two_incomplete(self, _sleep):
         # test 2 iterations, with no matches
-        _sleep.reset_mock()
-        guestObject.reset_mock()
-
-        guestObject.side_effect = [
-            {'activeTransaction': {'id': 1}},
+        self.guestObject.side_effect = [
             {'activeTransaction': {'id': 1}},
             {'activeTransaction': {'id': 1}},
             {'provisionDate': 'aaa'}
         ]
-        value = self.cci.wait_for_transaction(1, 2)
+        value = self.cci.wait_for_ready(1, 2)
         self.assertFalse(value)
-        _sleep.assert_has_calls([call(1), call(1)])
-        guestObject.assert_has_calls([
+        _sleep.assert_called_once_with(1)
+        self.guestObject.assert_has_calls([
             call(id=1, mask=ANY), call(id=1, mask=ANY),
-            call(id=1, mask=ANY)
         ])
 
+    @patch('SoftLayer.managers.cci.sleep')
+    def test_iter_ten_incomplete(self, _sleep):
         # 10 iterations at 10 second sleeps with no
         # matching values.
-        _sleep.reset_mock()
-        guestObject.reset_mock()
-        guestObject.side_effect = [
+        self.guestObject.side_effect = [
             {},
             {'activeTransaction': {'id': 1}},
             {'activeTransaction': {'id': 1}},
@@ -556,57 +688,18 @@ def test_wait(self, _sleep):
             {'activeTransaction': {'id': 1}},
             {'activeTransaction': {'id': 1}},
             {'activeTransaction': {'id': 1}},
-            {'activeTransaction': {'id': 1}}
         ]
-        value = self.cci.wait_for_transaction(1, 10, 10)
+        value = self.cci.wait_for_ready(1, 10, 10)
         self.assertFalse(value)
-        guestObject.assert_has_calls([
+        self.guestObject.assert_has_calls([
             call(id=1, mask=ANY), call(id=1, mask=ANY),
             call(id=1, mask=ANY), call(id=1, mask=ANY),
             call(id=1, mask=ANY), call(id=1, mask=ANY),
             call(id=1, mask=ANY), call(id=1, mask=ANY),
             call(id=1, mask=ANY), call(id=1, mask=ANY),
-            call(id=1, mask=ANY)
         ])
+        # should only be 9 calls to sleep, last iteration
+        # should return a value and skip the sleep
         _sleep.assert_has_calls([
             call(10), call(10), call(10), call(10), call(10),
-            call(10), call(10), call(10), call(10), call(10)])
-
-    def test_change_port_speed_public(self):
-        cci_id = 1
-        speed = 100
-        self.cci.change_port_speed(cci_id, True, speed)
-
-        service = self.client['Virtual_Guest']
-        f = service.setPublicNetworkInterfaceSpeed
-        f.assert_called_once_with(speed, id=cci_id)
-
-    def test_change_port_speed_private(self):
-        cci_id = 2
-        speed = 10
-        self.cci.change_port_speed(cci_id, False, speed)
-
-        service = self.client['Virtual_Guest']
-        f = service.setPrivateNetworkInterfaceSpeed
-        f.assert_called_once_with(speed, id=cci_id)
-
-    def test_edit(self):
-        # Test editing user data
-        service = self.client['Virtual_Guest']
-
-        self.cci.edit(100, userdata='my data')
-
-        service.setUserMetadata.assert_called_once_with(['my data'], id=100)
-
-        # Now test a blank edit
-        self.assertTrue(self.cci.edit, 100)
-
-        # Finally, test a full edit
-        args = {
-            'hostname': 'new-host',
-            'domain': 'new.sftlyr.ws',
-            'notes': 'random notes',
-        }
-
-        self.cci.edit(100, **args)
-        service.editObject.assert_called_once_with(args, id=100)
+            call(10), call(10), call(10), call(10)])
