chore(controller): remove default proc cmd

Author: duanhongyi

rootfs/api/models/app.py

@@ -290,8 +290,8 @@ def deploy(self, release, force_deploy=False, rollback_on_failure=True):  # noqa
                 if prev_release.build.type != release.build.type:
                     structure = self.structure.copy()
                     # zero out canonical pod counts
-                    for proctype in ['cmd', 'web']:
-                        if proctype in structure:
+                    for proctype in structure.keys():
+                        if proctype == "web":
                             structure[proctype] = 0
                     # update with the default process type.
                     structure.update(self._default_structure(release))
@@ -365,15 +365,15 @@ def deploy(self, release, force_deploy=False, rollback_on_failure=True):  # noqa
             self.log(err, logging.ERROR)
             raise ServiceUnavailable(err) from e
         for procfile_type, value in deploys.items():
-            if procfile_type in ("web", "cmd"):  # http
+            if procfile_type == "web":  # http
                 target_port = int(value.get('envs', {}).get('PORT', 5000))
                 self._create_default_ingress(procfile_type, target_port)
             service = self.service_set.filter(procfile_type=procfile_type).first()
             if not service:
                 continue
             if prev_release and prev_release.build:
                 continue
-            if procfile_type in ("web", "cmd"):
+            if procfile_type == "web":
                 self._verify_http_health(service, **deploys[procfile_type])
             else:
                 self._verify_tcp_health(service, **deploys[procfile_type])
@@ -659,13 +659,13 @@ def _get_command(self, container_type):
             if release.build.dockerfile or not release.build.sha:
                 # has profile
                 if release.build.procfile and container_type in release.build.procfile:
-                    cmd = release.build.procfile[container_type]
+                    command = release.build.procfile[container_type]
                     # if the entrypoint is `/bin/bash -c`, we want to supply the list
                     # as a script. Otherwise, we want to send it as a list of arguments.
                     if self._get_entrypoint(container_type) == ['/bin/sh', '-c']:
-                        return [cmd]
+                        return [command]
                     else:
-                        return cmd.split()
+                        return command.split()
         return []
 
     def _get_stack(self, release):
@@ -764,9 +764,8 @@ def _scale(self, user, structure, release, app_settings):  # noqa
         # test for available process types
         available_process_types = release.build.procfile or {}
         for container_type in structure:
-            if container_type == 'cmd':
-                continue  # allow docker cmd types in case we don't have the image source
-
+            if self._get_stack(release) == "container":
+                continue  # allow container types in case we don't have the image source
             if container_type not in available_process_types:
                 raise NotFound(
                     'Container type {} does not exist in application'.format(container_type))
@@ -957,28 +956,12 @@ def _check_deployment_in_progress(self, deploys, release, force_deploy=False):
     @staticmethod
     def _default_structure(release):
         """Scale to default structure based on release type"""
-        # If web in procfile then honor it
-        if release.build.procfile and 'web' in release.build.procfile:
-            structure = {'web': 1}
-
-        # if there is no SHA, assume a docker image is being promoted
-        elif not release.build.sha:
-            structure = {'cmd': 1}
-
-        # if a dockerfile, assume docker workflow
-        elif release.build.dockerfile:
-            structure = {'cmd': 1}
-
-        # if a procfile exists without a web entry and dockerfile, assume heroku workflow
-        # and return empty structure as only web type needs to be created by default and
-        # other types have to be manually scaled
-        elif release.build.procfile and 'web' not in release.build.procfile:
+        if release.build.sha and not release.build.dockerfile and \
+                (release.build.procfile and 'web' not in release.build.procfile):
             structure = {}
-
         # default to heroku workflow
         else:
             structure = {'web': 1}
-
         return structure
 
     def _scheduler_filter(self, **kwargs):
@@ -1132,13 +1115,13 @@ def _gather_app_settings(self, release, app_settings, process_type, replicas, vo
         # create image pull secret if needed
         image_pull_secret_name = self.image_pull_secret(self.id, config.registry, release.image)
 
-        # only web / cmd are routable
-        # http://docs.drycc.cc/en/latest/using_drycc/process-types/#web-vs-cmd-process-types
-        routable = True if process_type in ['web', 'cmd'] and app_settings.routable else False
+        # only web is routable
+        # https://www.drycc.cc/applications/managing-app-processes/#default-process-types
+        routable = True if process_type == 'web' and app_settings.routable else False
 
         healthcheck = config.get_healthcheck().get(process_type, {})
-        if not healthcheck and process_type in ['web', 'cmd']:
-            healthcheck = config.get_healthcheck().get('web/cmd', {})
+        if not healthcheck and process_type == 'web':
+            healthcheck = config.get_healthcheck().get('web', {})
         volumes_info = [{
             "name": _.name,
             "claimName": _.name,

rootfs/api/models/config.py

@@ -55,8 +55,8 @@ def _migrate_legacy_healthcheck(self):
         success_threshold = int(self.values.get('HEALTHCHECK_SUCCESS_THRESHOLD', 1))
         failure_threshold = int(self.values.get('HEALTHCHECK_FAILURE_THRESHOLD', 3))
 
-        self.healthcheck['web/cmd'] = {}
-        self.healthcheck['web/cmd']['livenessProbe'] = {
+        self.healthcheck['web'] = {}
+        self.healthcheck['web']['livenessProbe'] = {
             'initialDelaySeconds': delay,
             'timeoutSeconds': timeout,
             'periodSeconds': period_seconds,
@@ -67,7 +67,7 @@ def _migrate_legacy_healthcheck(self):
             }
         }
 
-        self.healthcheck['web/cmd']['readinessProbe'] = {
+        self.healthcheck['web']['readinessProbe'] = {
             'initialDelaySeconds': delay,
             'timeoutSeconds': timeout,
             'periodSeconds': period_seconds,
@@ -86,7 +86,7 @@ def get_healthcheck(self):
             'livenessProbe' in self.healthcheck.keys() or
             'readinessProbe' in self.healthcheck.keys()
         ):
-            return {'web/cmd': self.healthcheck}
+            return {'web': self.healthcheck}
         return self.healthcheck
 
     def _set_cpu_memory(self):
@@ -205,9 +205,9 @@ def set_healthcheck(self, previous_config):
         # TODO: This is required for backward compatibility and can be
         # removed in next major version change.
         if 'livenessProbe' in data.keys() or 'readinessProbe' in data.keys():
-            data = {'web/cmd': data.copy()}
+            data = {'web': data.copy()}
         if 'livenessProbe' in new_data.keys() or 'readinessProbe' in new_data.keys():  # noqa
-            new_data = {'web/cmd': new_data.copy()}
+            new_data = {'web': new_data.copy()}
 
         # remove config keys if a null value is provided
         for key, value in new_data.items():

rootfs/api/models/service.py

@@ -85,7 +85,7 @@ def _namespace(self):
         return self.app.id
 
     def _svc_name(self, canary):
-        if self.procfile_type in ("web", "cmd"):
+        if self.procfile_type == 'web':
             svc_name = self.app.id
         else:
             svc_name = "{}-{}".format(self.app.id, self.procfile_type)

rootfs/api/tests/test_build.py

@@ -113,15 +113,15 @@ def test_build_default_containers(self, mock_requests):
         response = self.client.post(url, body)
         self.assertEqual(response.status_code, 201, response.data)
 
-        url = "/v2/apps/{app_id}/pods/cmd".format(**locals())
+        url = "/v2/apps/{app_id}/pods/web".format(**locals())
         response = self.client.get(url)
         self.assertEqual(response.status_code, 200, response.data)
         self.assertEqual(len(response.data['results']), 1)
         container = response.data['results'][0]
-        self.assertEqual(container['type'], 'cmd')
+        self.assertEqual(container['type'], 'web')
         self.assertEqual(container['release'], 'v2')
         # pod name is auto generated so use regex
-        self.assertRegex(container['name'], app_id + '-cmd-[0-9]{1,10}-[a-z0-9]{5}')
+        self.assertRegex(container['name'], app_id + '-web-[0-9]{1,10}-[a-z0-9]{5}')
 
         # post an image as a build with a procfile
         app_id = self.create_app()
@@ -160,15 +160,15 @@ def test_build_default_containers(self, mock_requests):
         response = self.client.post(url, body)
         self.assertEqual(response.status_code, 201, response.data)
 
-        url = "/v2/apps/{app_id}/pods/cmd".format(**locals())
+        url = "/v2/apps/{app_id}/pods/web".format(**locals())
         response = self.client.get(url)
         self.assertEqual(response.status_code, 200, response.data)
         self.assertEqual(len(response.data['results']), 1)
         container = response.data['results'][0]
-        self.assertEqual(container['type'], 'cmd')
+        self.assertEqual(container['type'], 'web')
         self.assertEqual(container['release'], 'v2')
         # pod name is auto generated so use regex
-        self.assertRegex(container['name'], app_id + '-cmd-[0-9]{1,10}-[a-z0-9]{5}')
+        self.assertRegex(container['name'], app_id + '-web-[0-9]{1,10}-[a-z0-9]{5}')
 
         # start with a new app
         app_id = self.create_app()
@@ -187,15 +187,15 @@ def test_build_default_containers(self, mock_requests):
         response = self.client.post(url, body)
         self.assertEqual(response.status_code, 201, response.data)
 
-        url = "/v2/apps/{app_id}/pods/cmd".format(**locals())
+        url = "/v2/apps/{app_id}/pods/web".format(**locals())
         response = self.client.get(url)
         self.assertEqual(response.status_code, 200, response.data)
         self.assertEqual(len(response.data['results']), 1)
         container = response.data['results'][0]
-        self.assertEqual(container['type'], 'cmd')
+        self.assertEqual(container['type'], 'web')
         self.assertEqual(container['release'], 'v2')
         # pod name is auto generated so use regex
-        self.assertRegex(container['name'], app_id + '-cmd-[0-9]{1,10}-[a-z0-9]{5}')
+        self.assertRegex(container['name'], app_id + '-web-[0-9]{1,10}-[a-z0-9]{5}')
 
         # start with a new app
         app_id = self.create_app()
@@ -298,19 +298,13 @@ def test_build_forgotten_procfile(self, mock_requests):
         url = "/v2/apps/{app_id}/pods/web".format(**locals())
         response = self.client.get(url)
         self.assertEqual(response.status_code, 200, response.data)
-        self.assertEqual(len(response.data['results']), 0)
-
-        # verify cmd is there
-        url = "/v2/apps/{app_id}/pods/cmd".format(**locals())
-        response = self.client.get(url)
-        self.assertEqual(response.status_code, 200, response.data)
         self.assertEqual(len(response.data['results']), 1)
 
         # look at the app structure
         url = "/v2/apps/{app_id}".format(**locals())
         response = self.client.get(url)
         self.assertEqual(response.status_code, 200, response.data)
-        self.assertEqual(response.json()['structure'], {'cmd': 1, 'web': 0, 'worker': 0})
+        self.assertEqual(response.json()['structure'], {'web': 1, 'worker': 0})
 
     @override_settings(DRYCC_DEPLOY_PROCFILE_MISSING_REMOVE=False)
     def test_build_no_remove_process(self, mock_requests):

rootfs/api/tests/test_canary.py

@@ -53,7 +53,7 @@ def pre_data(self):
         # add canary
         self.client.post(
             f'/v2/apps/{app_id}/settings',
-            {'canaries': ["cmd"]}
+            {'canaries': ["web"]}
         )
         # add v3 release
         url = f'/v2/apps/{app_id}/builds'

rootfs/api/tests/test_healthchecks.py

@@ -75,32 +75,32 @@ def test_config_healthchecks(self, mock_requests):
         Test that healthchecks can be applied
         """
         app_id = self.create_app()
-        readiness_probe = {'healthcheck': {'web/cmd': {'readinessProbe':
-                                                       {'httpGet': {'port': 5000}}}}}
-
+        readiness_probe = {
+            'healthcheck': {'web': {'readinessProbe': {'httpGet': {'port': 5000}}}}
+        }
         response = self.client.post(
             '/v2/apps/{app_id}/config'.format(**locals()),
             readiness_probe)
         self.assertEqual(response.status_code, 201, response.data)
-        self.assertIn('readinessProbe', response.data['healthcheck']['web/cmd'])
+        self.assertIn('readinessProbe', response.data['healthcheck']['web'])
         self.assertEqual(response.data['healthcheck'], readiness_probe['healthcheck'])
 
-        liveness_probe = {'healthcheck': {'web/cmd': {'livenessProbe':
+        liveness_probe = {'healthcheck': {'web': {'livenessProbe':
                                           {'httpGet': {'port': 5000},
                                            'successThreshold': 1}}}}
         response = self.client.post(
             '/v2/apps/{app_id}/config'.format(**locals()),
             liveness_probe)
         self.assertEqual(response.status_code, 201, response.data)
-        self.assertIn('livenessProbe', response.data['healthcheck']['web/cmd'])
+        self.assertIn('livenessProbe', response.data['healthcheck']['web'])
         self.assertEqual(
-            response.data['healthcheck']['web/cmd']['livenessProbe'],
-            liveness_probe['healthcheck']['web/cmd']['livenessProbe'])
+            response.data['healthcheck']['web']['livenessProbe'],
+            liveness_probe['healthcheck']['web']['livenessProbe'])
         # check that the readiness probe is still there too!
-        self.assertIn('readinessProbe', response.data['healthcheck']['web/cmd'])
+        self.assertIn('readinessProbe', response.data['healthcheck']['web'])
         self.assertEqual(
-            response.data['healthcheck']['web/cmd']['readinessProbe'],
-            readiness_probe['healthcheck']['web/cmd']['readinessProbe'])
+            response.data['healthcheck']['web']['readinessProbe'],
+            readiness_probe['healthcheck']['web']['readinessProbe'])
 
         # check that config fails if trying to unset non-existing healthcheck
         response = self.client.post(
@@ -111,15 +111,15 @@ def test_config_healthchecks(self, mock_requests):
         # remove a probeType
         response = self.client.post(
             '/v2/apps/{app_id}/config'.format(**locals()),
-            {'healthcheck': {'web/cmd': {'livenessProbe': None}}})
+            {'healthcheck': {'web': {'livenessProbe': None}}})
         self.assertEqual(response.status_code, 201, response.data)
-        self.assertNotIn('livenessProbe', response.data['healthcheck']['web/cmd'])
-        self.assertIn('readinessProbe', response.data['healthcheck']['web/cmd'])
+        self.assertNotIn('livenessProbe', response.data['healthcheck']['web'])
+        self.assertIn('readinessProbe', response.data['healthcheck']['web'])
 
         # check that config fails if trying to unset non-existing probeType
         response = self.client.post(
             '/v2/apps/{app_id}/config'.format(**locals()),
-            {'healthcheck': {'web/cmd': {'livenessProbe': None}}})
+            {'healthcheck': {'web': {'livenessProbe': None}}})
         self.assertEqual(response.status_code, 422, response.data)
 
         # check that config fails if trying to unset non-existing probeType
@@ -131,9 +131,9 @@ def test_config_healthchecks(self, mock_requests):
         # check that config fails if trying to unset non-existing probeType
         response = self.client.post(
             '/v2/apps/{app_id}/config'.format(**locals()),
-            {'healthcheck': {'web/cmd': None}})
+            {'healthcheck': {'web': None}})
         self.assertEqual(response.status_code, 201, response.data)
-        self.assertNotIn('web/cmd', response.data['healthcheck'])
+        self.assertNotIn('web', response.data['healthcheck'])
 
         # post a new build
         response = self.client.post(
@@ -151,23 +151,23 @@ def test_config_healthchecks_validations(self, mock_requests):
         # Set a probe different from liveness/readiness
         response = self.client.post(
             '/v2/apps/{app_id}/config'.format(**locals()),
-            {'healthcheck': json.dumps({'web/cmd': {'testProbe':
+            {'healthcheck': json.dumps({'web': {'testProbe':
                                         {'httpGet': {'port': '50'}, 'initialDelaySeconds': "1"}}})}
         )
         self.assertEqual(response.status_code, 400, response.data)
 
         # Set one of the values that require a numeric value to a string
         response = self.client.post(
             '/v2/apps/{app_id}/config'.format(**locals()),
-            {'healthcheck': json.dumps({'web/cmd': {'livenessProbe':
+            {'healthcheck': json.dumps({'web': {'livenessProbe':
                                         {'httpGet': {'port': '50'}, 'initialDelaySeconds': "t"}}})}
         )
         self.assertEqual(response.status_code, 400, response.data)
 
         # Don't set one of the mandatory value
         response = self.client.post(
             '/v2/apps/{app_id}/config'.format(**locals()),
-            {'healthcheck': json.dumps({'web/cmd': {'livenessProbe':
+            {'healthcheck': json.dumps({'web': {'livenessProbe':
                                         {'httpGet': {'path': '/'}, 'initialDelaySeconds': 1}}})}
         )
         self.assertEqual(response.status_code, 400, response.data)
@@ -176,7 +176,7 @@ def test_config_healthchecks_validations(self, mock_requests):
         # Don't set one of the mandatory value
         response = self.client.post(
             '/v2/apps/{app_id}/config'.format(**locals()),
-            {'healthcheck': {'web/cmd': {'livenessProbe':
+            {'healthcheck': {'web': {'livenessProbe':
                              {'httpGet': {'path': '/', 'port': 5000},
                               'successThreshold': 5}}}}
         )
@@ -199,7 +199,7 @@ def test_config_healthchecks_legacy(self, mock_requests):
         # this gets migrated to the new healtcheck format
         self.assertNotIn('HEALTHCHECK_URL', response.data['values'])
         # legacy defaults
-        expected = {'web/cmd': {
+        expected = {'web': {
             'livenessProbe': {
                 'initialDelaySeconds': 50,
                 'timeoutSeconds': 50,
@@ -240,7 +240,7 @@ def test_config_healthchecks_legacy(self, mock_requests):
         self.assertEqual(response.status_code, 201, response.data)
         # this gets migrated to the new healtcheck format
         self.assertNotIn('HEALTHCHECK_INITIAL_DELAY', response.data['values'])
-        expected['web/cmd']['livenessProbe'] = {
+        expected['web']['livenessProbe'] = {
             'initialDelaySeconds': 25,
             'timeoutSeconds': 10,
             'periodSeconds': 5,
@@ -250,6 +250,6 @@ def test_config_healthchecks_legacy(self, mock_requests):
                 'path': '/health'
             }
         }
-        expected['web/cmd']['readinessProbe'] = expected['web/cmd']['livenessProbe']
+        expected['web']['readinessProbe'] = expected['web']['livenessProbe']
         actual = app.config_set.latest().healthcheck
         self.assertEqual(expected, actual)