feat(release): add deploy release

Author: duanhongyi

rootfs/api/models/app.py

@@ -220,30 +220,35 @@ def scale(self, user, structure):
         app_settings = self.appsettings_set.latest()
         self._scale(user, structure, release, app_settings)
 
-    def pipeline(self, release, force_deploy=False, rollback_on_failure=True):
+    def prepare(self, release):
+        prefix = f"[pipeline] prepare {release.version_name}"
+        if release.build.dryccfile:
+            if 'run' in release.build.dryccfile and release.get_run_trigger():
+                self.log(f"{prefix} starts running pipeline.run")
+                job_name = self.run(
+                    self.owner, release.get_run_image(), command=release.get_run_command(),
+                    args=release.get_run_args(), timeout=release.get_run_timeout(),
+                    expires=release.get_run_timeout())
+                state, labels = 'initializing', {'job-name': job_name}
+                for count, state in enumerate(self.scheduler().pod.watch(
+                        self.id, labels, settings.DRYCC_PILELINE_RUN_TIMEOUT)):
+                    self.log(f"{prefix} waiting for pipeline.run: {state} * {count}")
+                if state != 'down':
+                    raise DryccException(f'pipeline run state error: {state}')
+                return True
+        return False
+
+    def pipeline(self, release, force_deploy=False):
         prefix = f"[pipeline] release {release.version_name}"
         try:
             self.log(f"{prefix} starts running...")
             procfile_types = release.diff_procfile_types()
-            if release.build.dryccfile:
-                if 'run' in release.build.dryccfile and release.get_run_trigger():
-                    self.log(f"{prefix} starts running pipeline.run")
-                    job_name = self.run(
-                        self.owner, release.get_run_image(), command=release.get_run_command(),
-                        args=release.get_run_args(), timeout=release.get_run_timeout(),
-                        expires=release.get_run_timeout())
-                    state, labels = 'initializing', {'job-name': job_name}
-                    for count, state in enumerate(self.scheduler().pod.watch(
-                            self.id, labels, settings.DRYCC_PILELINE_RUN_TIMEOUT)):
-                        self.log(f"{prefix} waiting for pipeline.run: {state} * {count}")
-                    if state != 'down':
-                        raise DryccException(f'pipeline run state error: {state}')
+            self.prepare(release)
             if procfile_types is None or len(procfile_types) > 0:
                 self.log(f"{prefix} starts running pipeline.deploy")
-                app_settings = self.appsettings_set.latest()
-                if app_settings.autorollback is False:
+                rollback_on_failure = self.appsettings_set.latest().autorollback
+                if not rollback_on_failure:
                     self.log(f"{prefix} deploy do not rollback on failure")
-                    rollback_on_failure = False
                 self.deploy(release, procfile_types, force_deploy, rollback_on_failure)
             else:
                 self.log(f"{prefix} no changes, skip executing pipeline.deploy")
@@ -617,7 +622,7 @@ def state_to_k8s(self):
         if len(procfile_types) == 0:
             self.log('the cluster status is the latest, skipping deployment...')
             return
-        self.deploy(release, procfile_types)
+        self.deploy(release, procfile_types, False, False)
 
     def set_application_config(self, release, procfile_type):
         """
@@ -750,8 +755,7 @@ def _deploy(self, deploys, procfile_types, prev_release,
                     # This goes in the log before the rollback starts
                     self.log(err, logging.ERROR)
                     # revert all process types to old release
-                    self.deploy(prev_release, procfile_types,
-                                force_deploy=True, rollback_on_failure=False)
+                    self.deploy(prev_release, procfile_types, True, False)
                     # let it bubble up
                     raise DryccException('{}\n{}'.format(err, str(e))) from e
 

rootfs/api/models/build.py

@@ -79,7 +79,7 @@ def create_release(self, user, *args, **kwargs):
                 build=self,
                 config=latest_release.config,
             )
-            run_pipeline.delay(new_release)
+            run_pipeline.delay(new_release, force_deploy=False)
             return new_release
         except Exception as e:
             # check if the exception is during create or publish

rootfs/api/models/release.py

@@ -47,6 +47,10 @@ class Meta:
     def __str__(self):
         return "{0}-{1}".format(self.app.id, self.version_name)
 
+    @property
+    def deploying(self):
+        return self.build is not None and self.state == "created"
+
     @property
     def procfile_types(self):
         if self.build is not None:
@@ -222,19 +226,16 @@ def rollback(self, user, version=None):
                 raise DryccException('version cannot be below 0')
             elif version == 1:
                 raise DryccException('Cannot roll back to initial release.')
-
             prev = self.app.release_set.get(version=version)
             if prev.failed:
                 raise DryccException('Cannot roll back to failed release.')
-            app_settings = self.app.appsettings_set.latest()
             latest_version = self.app.release_set.latest().version
             new_release = self.new(
                 user,
                 build=prev.build,
                 config=prev.config,
                 summary="{} rolled back to v{}".format(user, version),
             )
-
             if self.build is not None:
                 run_pipeline.delay(new_release, force_deploy=True)
             return new_release

rootfs/api/tasks.py

@@ -66,19 +66,12 @@ def run_pipeline(release, *args, **kwargs):
     autoretry_for=(ServiceUnavailable, ),
     retry_kwargs={'max_retries': None}
 )
-def run_deploy(release, config):
+def run_deploy(release, *args, **kwargs):
     task_id = uuid.uuid4().hex
     signals.request_started.send(sender=task_id)
     try:
         if release.build is not None:
-            procfile_types = set()
-            for field, diff in config.diff().items():
-                if field in config.procfile_fields:
-                    for value in diff.values():
-                        procfile_types.update(value.keys())
-            # all_diff_fields changed, deploy all.
-            procfile_types = procfile_types if procfile_types else None
-            config.app.deploy(release, procfile_types)
+            release.app.deploy(release, *args, **kwargs)
         release.state = "succeed"
         release.save()
     except Exception as e:

rootfs/api/tests/test_release.py

@@ -199,6 +199,35 @@ def test_response_data(self, mock_requests):
         }
         self.assertEqual(response.data, response.data | expected)
 
+    def test_release_deploy(self, mock_requests):
+        app_id = self.create_app()
+        # try to rollback with only 1 release extant, expecting 400
+        url = f"/v2/apps/{app_id}/releases/deploy/"
+        # app.deploy
+        with mock.patch('api.models.app.App.deploy') as mock_deploy:
+            mock_deploy.return_value = None
+            response = self.client.post(url, {"types": "web"})
+            self.assertEqual(response.status_code, 400)
+
+        # post a new build
+        build_url = f"/v2/apps/{app_id}/builds"
+        body = {
+            'image': 'autotest/example',
+            'stack': 'heroku-18',
+            'sha': 'a'*40,
+            'procfile': {
+                'web': 'node server.js',
+                'worker': 'node worker.js'
+            }
+        }
+        response = self.client.post(build_url, body)
+        self.assertEqual(response.status_code, 201)
+        # app.deploy
+        with mock.patch('api.models.app.App.deploy') as mock_deploy:
+            mock_deploy.return_value = None
+            response = self.client.post(url, {"types": "web"})
+            self.assertEqual(response.status_code, 204)
+
     def test_release_rollback(self, mock_requests):
         app_id = self.create_app()
         app = App.objects.get(id=app_id)
@@ -887,7 +916,7 @@ def test_diff_procfile_types(self, mock_requests):
         with mock.patch('scheduler.resources.pod.Pod.watch') as mock_kube:
             with mock.patch('api.models.app.logger') as mock_logger:
                 mock_kube.return_value = ['up', 'down']
-                app.pipeline(release, False, True)
+                app.pipeline(release, False)
                 self.assertEqual(release.state, "succeed")
                 prefix = f"[{release.app.id}]: [pipeline] release v{release.version}"
                 exp_msg = f"{prefix} no changes, skip executing pipeline.deploy"

rootfs/api/urls.py

@@ -39,6 +39,9 @@
     re_path(
         r"^apps/(?P<id>{})/releases/v(?P<version>[0-9]+)/?$".format(settings.APP_URL_REGEX),
         views.ReleaseViewSet.as_view({'get': 'retrieve'})),
+    re_path(
+        r"^apps/(?P<id>{})/releases/deploy/?$".format(settings.APP_URL_REGEX),
+        views.ReleaseViewSet.as_view({'post': 'deploy'})),
     re_path(
         r"^apps/(?P<id>{})/releases/rollback/?$".format(settings.APP_URL_REGEX),
         views.ReleaseViewSet.as_view({'post': 'rollback'})),

rootfs/api/views.py

@@ -387,13 +387,21 @@ class ConfigViewSet(ReleasableViewSet):
 
     def post_save(self, config):
         latest_release = config.app.release_set.filter(failed=False).latest()
-        if latest_release.build is not None and latest_release.state == "created":
+        if latest_release.deploying:
             config.delete()
             raise DryccException('There is an executing pipeline, please wait')
         try:
             release = latest_release.new(
                 self.request.user, config=config, build=latest_release.build)
-            run_deploy.delay(release, config)
+            procfile_types = set()
+            for field, diff in config.diff().items():
+                if field in config.procfile_fields:
+                    for value in diff.values():
+                        procfile_types.update(value.keys())
+            # all_diff_fields changed, deploy all.
+            procfile_types = procfile_types if procfile_types else None
+            rollback_on_failure = config.app.appsettings_set.latest().autorollback
+            run_deploy.delay(release, procfile_types, False, rollback_on_failure)
         except Exception as e:
             config.delete()
             if isinstance(e, AlreadyExists):
@@ -451,15 +459,11 @@ def describe(self, *args, **kwargs):
 
     def restart(self, request, *args, **kwargs):
         app = self.get_app()
-        ptypes = []
-        types = request.data.get("types", "").split(",")
-        types = [ptype for ptype in set(types) if ptype != ""]
-        if not types:
-            # all ptypes need to restart
-            ptypes = app.structure.keys()
+        ptypes = set([ptype for ptype in request.data.get("types", "").split(",") if ptype])
+        if not ptypes:
+            ptypes = app.structure.keys()  # all ptypes need to restart
         else:
-            ptypes = [ptype for ptype in types if ptype in app.structure]
-            invalid_ptypes = set(types) - set(ptypes)
+            invalid_ptypes = ptypes.difference(app.structure)
             if len(invalid_ptypes) != 0:
                 raise DryccException("process type {} is not included in procfile".
                                      format(','.join(invalid_ptypes)))
@@ -470,7 +474,7 @@ def restart(self, request, *args, **kwargs):
     def scale(self, request, **kwargs):
         app = self.get_app()
         latest_release = app.release_set.filter(failed=False).latest()
-        if latest_release.build is not None and latest_release.state == "created":
+        if latest_release.deploying:
             raise DryccException('There is an executing pipeline, please wait')
         scale_app.delay(app, request.user, request.data)
         return Response(status=status.HTTP_204_NO_CONTENT)
@@ -629,12 +633,32 @@ def get_object(self, **kwargs):
         qs = self.get_queryset(**kwargs)
         return get_object_or_404(qs, version=self.kwargs['version'])
 
+    def deploy(self, request, **kwargs):
+        """Deploy the latest release"""
+        release = self.get_app().release_set.latest()
+        if release.deploying:
+            raise DryccException('There is an executing pipeline, please wait')
+        procfile_types = set(
+            [ptype for ptype in request.data.get("types", "").split(",") if ptype])
+        if not procfile_types:
+            procfile_types = release.app.structure.keys()  # all procfile_types need to deploy
+        else:
+            invalid_procfile_types = procfile_types.difference(release.app.structure)
+            if len(invalid_procfile_types) != 0:
+                raise DryccException("process type {} is not included in procfile".
+                                     format(','.join(invalid_procfile_types)))
+        rollback_on_failure = release.app.appsettings_set.latest().autorollback
+        run_deploy.delay(release, procfile_types, False, rollback_on_failure)
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
     def rollback(self, request, **kwargs):
         """
         Create a new release as a copy of the state of the compiled slug and config vars of a
         previous release.
         """
         latest_release = self.get_app().release_set.filter(failed=False).latest()
+        if latest_release.deploying:
+            raise DryccException('There is an executing pipeline, please wait')
         new_release = latest_release.rollback(request.user, request.data.get('version', None))
         response = {'version': new_release.version}
         return Response(response, status=status.HTTP_201_CREATED)