Use ansible playbook for plan deploy

Depends-On: https://review.opendev.org/713641
Depends-On: https://review.opendev.org/714280
Change-Id: I9b9488672293558747c6dc41eb6d41c18bdc9e05

tripleoclient/tests/v1/overcloud_deploy/test_overcloud_deploy.py

@@ -531,7 +531,7 @@ class TestDeployOvercloud(fakes.TestDeployOvercloud):
                 clients.tripleoclient.object_store, mock.ANY, 'overcloud')
 
         workflow_client.action_executions.create.assert_called()
-        workflow_client.executions.create.assert_called()
+        # workflow_client.executions.create.assert_called()
 
         mock_open_context.assert_has_calls(
             [mock.call('the-plan-environment.yaml')])

tripleoclient/tests/v1/test_overcloud_plan.py

@@ -250,56 +250,44 @@ class TestOvercloudDeployPlan(utils.TestCommand):
         app_args.verbose_level = 1
         self.cmd = overcloud_plan.DeployPlan(self.app, app_args)
 
-        self.workflow = self.app.client_manager.workflow_engine = mock.Mock()
-        execution = mock.Mock()
-        execution.id = "IDID"
-        self.workflow.executions.create.return_value = execution
-        self.orch = self.app.client_manager.orchestration = mock.Mock()
-
-        self.websocket = mock.Mock()
-        self.websocket.__enter__ = lambda s: self.websocket
-        self.websocket.__exit__ = lambda s, *exc: None
-        self.tripleoclient = mock.Mock()
-        self.tripleoclient.messaging_websocket.return_value = self.websocket
-        self.app.client_manager.tripleoclient = self.tripleoclient
-
         sleep_patch = mock.patch('time.sleep')
         self.addCleanup(sleep_patch.stop)
         sleep_patch.start()
 
+    @mock.patch("tripleoclient.utils.run_ansible_playbook", autospec=True)
     @mock.patch('tripleoclient.utils.wait_for_stack_ready', autospec=True)
-    def test_overcloud_deploy_plan(self, mock_for_stack_ready):
+    def test_overcloud_deploy_plan(self, mock_for_stack_ready,
+                                   mock_run_playbook):
 
         # Setup
         arglist = ['--run-validations', 'overcast']
         verifylist = [
             ('name', 'overcast'),
             ('run_validations', True),
+            ('timeout', 240)
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
+        self.orch = self.app.client_manager.orchestration = mock.Mock()
         # No existing stack, this is a new deploy.
         self.orch.stacks.get.return_value = None
 
-        self.websocket.wait_for_messages.return_value = iter([{
-            'execution_id': 'IDID',
-            'status': 'SUCCESS'
-        }])
-
         mock_for_stack_ready.return_value = True
 
         # Run
         self.cmd.take_action(parsed_args)
 
-        # Verify
+        mock_run_playbook.assert_called_once_with(
-        self.workflow.executions.create.assert_called_once_with(
+            'cli-deploy-deployment-plan.yaml',
-            'tripleo.deployment.v1.deploy_plan',
+            'undercloud,',
-            workflow_input={
+            constants.ANSIBLE_TRIPLEO_PLAYBOOKS,
-                'container': 'overcast',
+            extra_vars={
-                'run_validations': True,
+                "container": "overcast",
-                'skip_deploy_identifier': False,
+                "run_validations": True,
-                'deployment_options': {},
+                "skip_deploy_identifier": False,
-            }
+                "timeout_mins": 240
+            },
+            verbosity=3,
         )
 
 

tripleoclient/tests/workflows/test_deployment.py

@@ -150,27 +150,16 @@ class TestDeploymentWorkflows(utils.TestCommand):
 
     @mock.patch('tripleoclient.utils.run_ansible_playbook',
                 autospec=True)
-    @mock.patch('tripleoclient.workflows.deployment.base')
     def test_config_download_already_in_progress_for_diff_stack(
-            self, mock_base, mock_playbook):
+            self, mock_playbook):
         log = mock.Mock()
         stack = mock.Mock()
         stack.stack_name = 'stacktest'
         stack.output_show.return_value = {'output': {'output_value': []}}
         clients = mock.Mock()
-        mock_execution = mock.Mock()
-        mock_execution.input = '{"plan_name": "someotherstack"}'
-        mock_return = mock.Mock(return_value=[mock_execution])
-        clients.workflow_engine.executions.find = mock_return
-        mock_exit = mock.Mock()
-        mock_exit.__exit__ = mock.Mock()
-        mock_exit.__enter__ = mock.Mock()
-        clients.tripleoclient.messaging_websocket = mock.Mock(
-            return_value=mock_exit)
-        mock_base.wait_for_messages = mock.Mock(
-            return_value=[dict(status='SUCCESS')])
-
         deployment.config_download(
             log, clients, stack, 'templates', 'ssh_user',
             'ssh_key', 'ssh_networks', 'output_dir', False,
             'timeout')
+
+        self.assertEqual(2, mock_playbook.call_count)

tripleoclient/v1/overcloud_plan.py

@@ -146,7 +146,7 @@ class DeployPlan(command.Command):
         parser = super(DeployPlan, self).get_parser(prog_name)
         parser.add_argument('name', help=_('The name of the plan to deploy.'))
         parser.add_argument('--timeout', '-t', metavar='<TIMEOUT>',
-                            type=int,
+                            type=int, default=240,
                             help=_('Deployment timeout in minutes.'))
         parser.add_argument('--run-validations', action='store_true',
                             default=False,

tripleoclient/workflows/deployment.py

@@ -14,7 +14,6 @@ from __future__ import print_function
 import copy
 import getpass
 import os
-import pprint
 import time
 
 import six
@@ -31,39 +30,25 @@ from tripleoclient.constants import DEFAULT_WORK_DIR
 from tripleoclient import exceptions
 from tripleoclient import utils
 
-from tripleoclient.workflows import base
-
 
 _WORKFLOW_TIMEOUT = 360  # 6 * 60 seconds
 
 
 def deploy(log, clients, **workflow_input):
-
+    utils.run_ansible_playbook(
-    workflow_client = clients.workflow_engine
+        "cli-deploy-deployment-plan.yaml",
-    tripleoclients = clients.tripleoclient
+        'undercloud,',
-    wf_name = 'tripleo.deployment.v1.deploy_plan'
+        ANSIBLE_TRIPLEO_PLAYBOOKS,
-
+        extra_vars={
-    with tripleoclients.messaging_websocket() as ws:
+            "container": workflow_input['container'],
-        execution = base.start_workflow(
+            "run_validations": workflow_input['run_validations'],
-            workflow_client,
+            "skip_deploy_identifier": workflow_input['skip_deploy_identifier'],
-            wf_name,
+            "timeout_mins": workflow_input['timeout'],
-            workflow_input=workflow_input
+        },
+        verbosity=3
     )
 
-        # The deploy workflow ends once the Heat create/update starts. This
+    print("Success.")
-        # means that is shouldn't take very long. Wait for 10 minutes for
-        # messages from the workflow.
-        for payload in base.wait_for_messages(workflow_client, ws, execution,
-                                              600):
-            status = payload.get('status', 'RUNNING')
-            message = payload.get('message')
-            if message and status == "RUNNING":
-                print(message)
-            elif payload['status'] != "SUCCESS":
-                log.info(pprint.pformat(payload))
-                print(payload['message'])
-                raise ValueError("Unexpected status %s for %s"
-                                 % (payload['status'], wf_name))
 
 
 def deploy_and_wait(log, clients, stack, plan_name, verbose_level,
@@ -75,7 +60,7 @@ def deploy_and_wait(log, clients, stack, plan_name, verbose_level,
         "container": plan_name,
         "run_validations": run_validations,
         "skip_deploy_identifier": skip_deploy_identifier,
-        "deployment_options": deployment_options,
+        "timeout": timeout
     }
 
     if timeout is not None:
@@ -83,6 +68,7 @@ def deploy_and_wait(log, clients, stack, plan_name, verbose_level,
 
     deploy(log, clients, **workflow_input)
 
+    # need to move this to the playbook I guess
     orchestration_client = clients.orchestration
 
     if stack is None: