Remove check for managed cloud role

Rackspace Public Cloud now runs managed cloud
automation on all cloud servers. Therefore, we must
check for managed cloud related statuses on all
cloud servers on the Rackspace Public Cloud.

Co-Authored-By: Randall Burt <randall.burt@rackpsace.com>
Change-Id: I07cf756005b37a3a94f86f550b11658e77f2ba27
Closes-Bug: #1526052

2 files changed, 58 insertions, 41 deletions

diff --git a/contrib/rackspace/rackspace/resources/cloud_server.py b/contrib/rackspace/rackspace/resources/cloud_server.py
index d6879d6bf..e4e2aafc8 100644
--- a/contrib/rackspace/rackspace/resources/cloud_server.py
+++ b/contrib/rackspace/rackspace/resources/cloud_server.py
@@ -44,10 +44,10 @@ class CloudServer(server.Server):
         status=support.UNSUPPORTED,
         message=_('This resource is not supported, use at your own risk.'))
 
-    # Managed Cloud automation statuses
-    MC_STATUS_IN_PROGRESS = 'In Progress'
-    MC_STATUS_COMPLETE = 'Complete'
-    MC_STATUS_BUILD_ERROR = 'Build Error'
+    # Rackspace Cloud automation statuses
+    SM_STATUS_IN_PROGRESS = 'In Progress'
+    SM_STATUS_COMPLETE = 'Complete'
+    SM_STATUS_BUILD_ERROR = 'Build Error'
 
     # RackConnect automation statuses
     RC_STATUS_DEPLOYING = 'DEPLOYING'
@@ -89,33 +89,33 @@ class CloudServer(server.Server):
         else:
             return False
 
-    def _check_managed_cloud_complete(self, server):
+    def _check_rax_automation_complete(self, server):
         if not self._managed_cloud_started_event_sent:
-            msg = _("Waiting for Managed Cloud automation to complete")
+            msg = _("Waiting for Rackspace Cloud automation to complete")
             self._add_event(self.action, self.status, msg)
             self._managed_cloud_started_event_sent = True
 
         if 'rax_service_level_automation' not in server.metadata:
-            LOG.debug("Managed Cloud server does not have the "
+            LOG.debug("Cloud server does not have the "
                       "rax_service_level_automation metadata tag yet")
             return False
 
         mc_status = server.metadata['rax_service_level_automation']
-        LOG.debug("Managed Cloud automation status: %s" % mc_status)
+        LOG.debug("Rackspace Cloud automation status: %s" % mc_status)
 
-        if mc_status == self.MC_STATUS_IN_PROGRESS:
+        if mc_status == self.SM_STATUS_IN_PROGRESS:
             return False
 
-        elif mc_status == self.MC_STATUS_COMPLETE:
-            msg = _("Managed Cloud automation has completed")
+        elif mc_status == self.SM_STATUS_COMPLETE:
+            msg = _("Rackspace Cloud automation has completed")
             self._add_event(self.action, self.status, msg)
             return True
 
-        elif mc_status == self.MC_STATUS_BUILD_ERROR:
-            raise exception.Error(_("Managed Cloud automation failed"))
+        elif mc_status == self.SM_STATUS_BUILD_ERROR:
+            raise exception.Error(_("Rackspace Cloud automation failed"))
 
         else:
-            raise exception.Error(_("Unknown Managed Cloud automation "
+            raise exception.Error(_("Unknown Rackspace Cloud automation "
                                     "status: %s") % mc_status)
 
     def _check_rack_connect_complete(self, server):
@@ -173,8 +173,7 @@ class CloudServer(server.Server):
                 self._check_rack_connect_complete(server)):
             return False
 
-        if ('rax_managed' in self.context.roles and not
-                self._check_managed_cloud_complete(server)):
+        if not self._check_rax_automation_complete(server):
             return False
 
         return True
diff --git a/contrib/rackspace/rackspace/tests/test_rackspace_cloud_server.py b/contrib/rackspace/rackspace/tests/test_rackspace_cloud_server.py
index 258555945..6bdfe4fdd 100644
--- a/contrib/rackspace/rackspace/tests/test_rackspace_cloud_server.py
+++ b/contrib/rackspace/rackspace/tests/test_rackspace_cloud_server.py
@@ -158,7 +158,10 @@ class CloudServersTest(common.HeatTestCase):
 
     def test_rackconnect_deployed(self):
         return_server = self.fc.servers.list()[1]
-        return_server.metadata = {'rackconnect_automation_status': 'DEPLOYED'}
+        return_server.metadata = {
+            'rackconnect_automation_status': 'DEPLOYED',
+            'rax_service_level_automation': 'Complete',
+        }
         server = self._setup_test_server(return_server,
                                          'test_rackconnect_deployed')
         server.context.roles = ['rack_connect']
@@ -173,7 +176,10 @@ class CloudServersTest(common.HeatTestCase):
 
     def test_rackconnect_failed(self):
         return_server = self.fc.servers.list()[1]
-        return_server.metadata = {'rackconnect_automation_status': 'FAILED'}
+        return_server.metadata = {
+            'rackconnect_automation_status': 'FAILED',
+            'rax_service_level_automation': 'Complete',
+        }
         self.m.StubOutWithMock(self.fc.servers, 'get')
         self.fc.servers.get(return_server.id).MultipleTimes(
         ).AndReturn(return_server)
@@ -189,10 +195,11 @@ class CloudServersTest(common.HeatTestCase):
 
     def test_rackconnect_unprocessable(self):
         return_server = self.fc.servers.list()[1]
-        return_server.metadata = {'rackconnect_automation_status':
-                                  'UNPROCESSABLE',
-                                  'rackconnect_unprocessable_reason':
-                                  'Fake reason'}
+        return_server.metadata = {
+            'rackconnect_automation_status': 'UNPROCESSABLE',
+            'rackconnect_unprocessable_reason': 'Fake reason',
+            'rax_service_level_automation': 'Complete',
+        }
         self.m.StubOutWithMock(self.fc.servers, 'get')
         self.fc.servers.get(return_server.id).MultipleTimes(
         ).AndReturn(return_server)
@@ -207,7 +214,10 @@ class CloudServersTest(common.HeatTestCase):
 
     def test_rackconnect_unknown(self):
         return_server = self.fc.servers.list()[1]
-        return_server.metadata = {'rackconnect_automation_status': 'FOO'}
+        return_server.metadata = {
+            'rackconnect_automation_status': 'FOO',
+            'rax_service_level_automation': 'Complete',
+        }
         self.m.StubOutWithMock(self.fc.servers, 'get')
         self.fc.servers.get(return_server.id).MultipleTimes(
         ).AndReturn(return_server)
@@ -227,20 +237,22 @@ class CloudServersTest(common.HeatTestCase):
                                          'srv_sts_bld')
         server.resource_id = 1234
         server.context.roles = ['rack_connect']
-
         check_iterations = [0]
 
         # Bind fake get method which check_create_complete will call
         def activate_status(server):
             check_iterations[0] += 1
             if check_iterations[0] == 1:
-                return_server.metadata[
-                    'rackconnect_automation_status'] = 'DEPLOYING'
+                return_server.metadata.update({
+                    'rackconnect_automation_status': 'DEPLOYING',
+                    'rax_service_level_automation': 'Complete',
+                    })
             if check_iterations[0] == 2:
                 return_server.status = 'ACTIVE'
             if check_iterations[0] > 3:
-                return_server.metadata[
-                    'rackconnect_automation_status'] = 'DEPLOYED'
+                return_server.metadata.update({
+                    'rackconnect_automation_status': 'DEPLOYED',
+                })
             return return_server
         self.patchobject(self.fc.servers, 'get',
                          side_effect=activate_status)
@@ -255,6 +267,7 @@ class CloudServersTest(common.HeatTestCase):
         return_server = self.fc.servers.list()[0]
         server = self._setup_test_server(return_server,
                                          'srv_sts_bld')
+
         server.resource_id = 1234
         server.context.roles = ['rack_connect']
 
@@ -265,11 +278,11 @@ class CloudServersTest(common.HeatTestCase):
             check_iterations[0] += 1
             if check_iterations[0] == 1:
                 return_server.status = 'ACTIVE'
-            if check_iterations[0] == 2:
-                return_server.metadata = {}
             if check_iterations[0] > 2:
-                return_server.metadata[
-                    'rackconnect_automation_status'] = 'DEPLOYED'
+                return_server.metadata.update({
+                    'rackconnect_automation_status': 'DEPLOYED',
+                    'rax_service_level_automation': 'Complete'})
+
             return return_server
         self.patchobject(self.fc.servers, 'get',
                          side_effect=activate_status)
@@ -280,13 +293,13 @@ class CloudServersTest(common.HeatTestCase):
 
         self.m.VerifyAll()
 
-    def test_managed_cloud_lifecycle(self):
+    def test_rax_automation_lifecycle(self):
         return_server = self.fc.servers.list()[0]
         server = self._setup_test_server(return_server,
                                          'srv_sts_bld')
         server.resource_id = 1234
-        server.context.roles = ['rack_connect', 'rax_managed']
-
+        server.context.roles = ['rack_connect']
+        server.metadata = {}
         check_iterations = [0]
 
         # Bind fake get method which check_create_complete will call
@@ -317,6 +330,7 @@ class CloudServersTest(common.HeatTestCase):
 
     def test_add_port_for_addresses(self):
         return_server = self.fc.servers.list()[1]
+        return_server.metadata = {'rax_service_level_automation': 'Complete'}
         stack_name = 'test_stack'
         (tmpl, stack) = self._setup_test_stack(stack_name)
         resource_defns = tmpl.resource_definitions(stack)
@@ -411,13 +425,12 @@ class CloudServersTest(common.HeatTestCase):
         resp = server._add_port_for_address(return_server)
         self.assertEqual(expected, resp)
 
-    def test_managed_cloud_build_error(self):
+    def test_rax_automation_build_error(self):
         return_server = self.fc.servers.list()[1]
         return_server.metadata = {'rax_service_level_automation':
                                   'Build Error'}
         server = self._setup_test_server(return_server,
                                          'test_managed_cloud_build_error')
-        server.context.roles = ['rax_managed']
         self.m.StubOutWithMock(self.fc.servers, 'get')
         self.fc.servers.get(return_server.id).MultipleTimes(
         ).AndReturn(return_server)
@@ -425,15 +438,14 @@ class CloudServersTest(common.HeatTestCase):
         create = scheduler.TaskRunner(server.create)
         exc = self.assertRaises(exception.ResourceFailure, create)
         self.assertEqual('Error: resources.test_managed_cloud_build_error: '
-                         'Managed Cloud automation failed',
+                         'Rackspace Cloud automation failed',
                          six.text_type(exc))
 
-    def test_managed_cloud_unknown(self):
+    def test_rax_automation_unknown(self):
         return_server = self.fc.servers.list()[1]
         return_server.metadata = {'rax_service_level_automation': 'FOO'}
         server = self._setup_test_server(return_server,
                                          'test_managed_cloud_unknown')
-        server.context.roles = ['rax_managed']
         self.m.StubOutWithMock(self.fc.servers, 'get')
         self.fc.servers.get(return_server.id).MultipleTimes(
         ).AndReturn(return_server)
@@ -441,11 +453,12 @@ class CloudServersTest(common.HeatTestCase):
         create = scheduler.TaskRunner(server.create)
         exc = self.assertRaises(exception.ResourceFailure, create)
         self.assertEqual('Error: resources.test_managed_cloud_unknown: '
-                         'Unknown Managed Cloud automation status: FOO',
+                         'Unknown Rackspace Cloud automation status: FOO',
                          six.text_type(exc))
 
     def _test_server_config_drive(self, user_data, config_drive, result):
         return_server = self.fc.servers.list()[1]
+        return_server.metadata = {'rax_service_level_automation': 'Complete'}
         stack_name = 'no_user_data'
         (tmpl, stack) = self._setup_test_stack(stack_name)
         properties = tmpl.t['Resources']['WebServer']['Properties']
@@ -454,11 +467,16 @@ class CloudServersTest(common.HeatTestCase):
         resource_defns = tmpl.resource_definitions(stack)
         server = cloud_server.CloudServer('WebServer',
                                           resource_defns['WebServer'], stack)
+        server.metadata = {'rax_service_level_automation': 'Complete'}
         self.patchobject(server, 'store_external_ports')
         mock_servers_create = mock.Mock(return_value=return_server)
         self.fc.servers.create = mock_servers_create
         image_id = mock.ANY
         self._mock_get_image_id_success(image_id)
+        self.m.StubOutWithMock(self.fc.servers, 'get')
+        self.fc.servers.get(return_server.id).MultipleTimes(
+        ).AndReturn(return_server)
+        self.m.ReplayAll()
         scheduler.TaskRunner(server.create)()
         mock_servers_create.assert_called_with(
             image=image_id,