chore(maintenance): remove maintenance support

Author: duanhongyi

rootfs/api/migrations/0001_initial.py

@@ -46,7 +46,6 @@ class Migration(migrations.Migration):
                 ('uuid', models.UUIDField(auto_created=True, default=uuid.uuid4, editable=False, primary_key=True, serialize=False, unique=True, verbose_name='UUID')),
                 ('created', models.DateTimeField(auto_now_add=True)),
                 ('updated', models.DateTimeField(auto_now=True)),
-                ('maintenance', models.NullBooleanField(default=None)),
                 ('routable', models.NullBooleanField(default=None)),
                 ('whitelist', django.contrib.postgres.fields.ArrayField(base_field=models.CharField(max_length=50), default=None, size=None)),
                 ('autoscale', jsonfield.fields.JSONField(blank=True, default={})),

rootfs/api/models/app.py

@@ -208,6 +208,9 @@ def _refresh_ingress(self, hosts, tls_map, ssl_redirect):
     def refresh_ingress_and_tls(self):
         if not getattr(self, 'refresh_ingress_and_tls_enabled', True):
             return
+        app_settings = self.appsettings_set.latest()
+        if not app_settings.routable:
+            return
         ingress = self.id
         hosts, tls_map = [], {}
 
@@ -298,21 +301,23 @@ def create(self, *args, **kwargs):  # noqa
                 raise ServiceUnavailable('Could not delete the Namespace in Kubernetes') from e
 
             raise ServiceUnavailable('Kubernetes resources could not be created') from e
-        setattr(self, 'refresh_ingress_and_tls_enabled', False)  # do not refresh
         try:
-            self.appsettings_set.latest()
-        except AppSettings.DoesNotExist:
-            AppSettings.objects.create(owner=self.owner, app=self)
-        try:
-            self.tls_set.latest()
-        except TLS.DoesNotExist:
-            TLS.objects.create(owner=self.owner, app=self)
-        # Attach the platform specific application sub domain to the k8s service
-        # Only attach it on first release in case a customer has remove the app domain
-        if rel.version == 1 and not Domain.objects.filter(domain=self.id).exists():
-            Domain.objects.create(owner=self.owner, app=self, domain=self.id)
-        # The default routable is true, so refresh ingress and tls
-        setattr(self, 'refresh_ingress_and_tls_enabled', True)
+            setattr(self, 'refresh_ingress_and_tls_enabled', False)  # do not refresh
+            try:
+                self.appsettings_set.latest()
+            except AppSettings.DoesNotExist:
+                AppSettings.objects.create(owner=self.owner, app=self)
+            try:
+                self.tls_set.latest()
+            except TLS.DoesNotExist:
+                TLS.objects.create(owner=self.owner, app=self)
+            # Attach the platform specific application sub domain to the k8s service
+            # Only attach it on first release in case a customer has remove the app domain
+            if rel.version == 1 and not Domain.objects.filter(domain=self.id).exists():
+                Domain.objects.create(owner=self.owner, app=self, domain=self.id)
+            # The default routable is true, so refresh ingress and tls
+        finally:
+            setattr(self, 'refresh_ingress_and_tls_enabled', True)
         self.refresh_ingress_and_tls()  # refresh
 
     def delete(self, *args, **kwargs):
@@ -660,7 +665,8 @@ def _check_deployment_in_progress(self, deploys, force_deploy=False):
             if in_progress and not deploy_okay:
                 raise AlreadyExists('Deployment for {} is already in progress'.format(name))
 
-    def _default_structure(self, release):
+    @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:
@@ -940,23 +946,6 @@ def _build_env_vars(self, release):
         default_env.update(release.config.values)
         return default_env
 
-    def maintenance_mode(self, mode):
-        """
-        Turn application maintenance mode on/off
-        """
-        if mode:
-            namespace = ingress = self.id
-            try:
-                data = self._scheduler.ingress.get(namespace, ingress).json()
-                for rule in data["spec"]["rules"]:
-                    for path in rule["http"]["paths"]:
-                        path["backend"]["serviceName"] = "drycc-maintenance-proxy"
-                self._scheduler.ingress.patch(ingress, namespace, data)
-            except KubeException:
-                self.log("creating Ingress {}".format(namespace), level=logging.INFO)
-        else:
-            self.refresh_ingress_and_tls()
-
     def routable(self, routable):
         """
         Turn on/off if an application is publically routable

rootfs/api/models/appsettings.py

@@ -18,7 +18,6 @@ class AppSettings(UuidAuditedModel):
 
     owner = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.PROTECT)
     app = models.ForeignKey('App', on_delete=models.CASCADE)
-    maintenance = models.NullBooleanField(default=None)
     routable = models.NullBooleanField(default=None)
     # the default values is None to differentiate from user sending an empty whitelist
     # and user just updating other fields meaning the values needs to be copied from prev release
@@ -49,20 +48,6 @@ def new(self, user, whitelist):
 
         return app_settings
 
-    def _update_maintenance(self, previous_settings):
-        old = getattr(previous_settings, 'maintenance', None)
-        new = getattr(self, 'maintenance', None)
-        # If no previous settings then assume it is the first record and default to true
-        if not previous_settings:
-            setattr(self, 'maintenance', False)
-            self.app.maintenance_mode(False)
-        # if nothing changed copy the settings from previous
-        elif new is None and old is not None:
-            setattr(self, 'maintenance', old)
-        elif old != new:
-            self.app.maintenance_mode(new)
-            self.summary += ["{} changed maintenance mode from {} to {}".format(self.owner, old, new)]  # noqa
-
     def _update_routable(self, previous_settings):
         old = getattr(previous_settings, 'routable', None)
         new = getattr(self, 'routable', None)
@@ -179,7 +164,6 @@ def save(self, *args, **kwargs):
             pass
 
         try:
-            self._update_maintenance(previous_settings)
             self._update_routable(previous_settings)
             self._update_whitelist(previous_settings)
             self._update_autoscale(previous_settings)

rootfs/api/tests/test_app_settings.py

@@ -25,48 +25,6 @@ def tearDown(self):
         # make sure every test has a clean slate for k8s mocking
         cache.clear()
 
-    def test_settings_maintenance(self, mock_requests):
-        """
-        Test that maintenance can be applied
-        """
-        app_id = self.create_app()
-        app = App.objects.get(id=app_id)
-
-        settings = {'maintenance': True}
-        response = self.client.post(
-            '/v2/apps/{app_id}/settings'.format(**locals()),
-            settings)
-        self.assertEqual(response.status_code, 201, response.data)
-        self.assertTrue(response.data['maintenance'])
-        self.assertTrue(app.appsettings_set.latest().maintenance)
-
-        settings = {'routable': False}
-        response = self.client.post(
-            '/v2/apps/{app_id}/settings'.format(**locals()),
-            settings)
-        self.assertEqual(response.status_code, 201, response.data)
-        self.assertTrue(app.appsettings_set.latest().maintenance)
-
-        settings['maintenance'] = False
-        response = self.client.post(
-            '/v2/apps/{app_id}/settings'.format(**locals()),
-            settings)
-        self.assertEqual(response.status_code, 201, response.data)
-        self.assertFalse(response.data['maintenance'])
-        self.assertFalse(app.appsettings_set.latest().maintenance)
-
-        response = self.client.post(
-            '/v2/apps/{app_id}/settings'.format(**locals()),
-            settings)
-        self.assertEqual(response.status_code, 409, response.data)
-        self.assertFalse(app.appsettings_set.latest().maintenance)
-
-        settings['maintenance'] = "test"
-        response = self.client.post(
-            '/v2/apps/{app_id}/settings'.format(**locals()),
-            settings)
-        self.assertEqual(response.status_code, 400, response.data)
-
     def test_settings_routable(self, mock_requests):
         """
         Create an application with the routable flag turned on or off
@@ -83,13 +41,6 @@ def test_settings_routable(self, mock_requests):
         self.assertEqual(response.status_code, 201, response.data)
         self.assertFalse(app.appsettings_set.latest().routable)
 
-        settings = {'maintenance': True}
-        response = self.client.post(
-            '/v2/apps/{app.id}/settings'.format(**locals()),
-            settings)
-        self.assertEqual(response.status_code, 201, response.data)
-        self.assertFalse(app.appsettings_set.latest().routable)
-
     def test_settings_whitelist(self, mock_requests):
         """
         Test that addresses can be added/deleted to whitelist
@@ -163,7 +114,7 @@ def test_settings_whitelist(self, mock_requests):
             whitelist)
         self.assertEqual(response.status_code, 400, response.data)
         # update other appsettings and whitelist should be retained
-        settings = {'maintenance': True}
+        settings = {'routable': False}
         response = self.client.post(
             '/v2/apps/{app.id}/settings'.format(**locals()),
             settings)

rootfs/api/tests/test_build.py

@@ -220,7 +220,7 @@ def test_build_default_containers(self, mock_requests):
         self.assertEqual(container['type'], 'web')
         self.assertEqual(container['release'], 'v2')
         # pod name is auto generated so use regex
-        self.assertRegex(container['name'], app_id + '-web-[0-9]{8,10}-[a-z0-9]{5}')
+        self.assertRegex(container['name'], app_id + '-web-[0-9]{7,10}-[a-z0-9]{5}')
 
         # start with a new app
         app_id = self.create_app()

rootfs/api/tests/test_services.py

@@ -2,7 +2,6 @@
 from django.core.cache import cache
 from rest_framework.authtoken.models import Token
 
-from api.models import App
 
 from api.tests import DryccTransactionTestCase
 
@@ -22,50 +21,6 @@ def tearDown(self):
         # make sure every test has a clean slate for k8s mocking
         cache.clear()
 
-    def test_settings_maintenance(self):
-        """
-        Test that maintenance can be applied
-        """
-        app_id = self.create_app()
-        app = App.objects.get(id=app_id)
-
-        # create service
-        response = self.client.post(
-            '/v2/apps/{}/services'.format(app_id),
-            {'procfile_type': 'test', 'path_pattern': '/testep/notify'}
-        )
-        self.assertEqual(response.status_code, 201, response.data)
-
-        # maintenance mode  & routable sequence
-        settings = {'maintenance': True}
-        response = self.client.post(
-            '/v2/apps/{app_id}/settings'.format(**locals()),
-            settings)
-        self.assertEqual(response.status_code, 201, response.data)
-        self.assertTrue(response.data['maintenance'])
-        self.assertTrue(app.appsettings_set.latest().maintenance)
-
-        settings = {'routable': False}
-        response = self.client.post(
-            '/v2/apps/{app_id}/settings'.format(**locals()),
-            settings)
-        self.assertEqual(response.status_code, 201, response.data)
-        self.assertTrue(app.appsettings_set.latest().maintenance)
-
-        settings['maintenance'] = False
-        response = self.client.post(
-            '/v2/apps/{app_id}/settings'.format(**locals()),
-            settings)
-        self.assertEqual(response.status_code, 201, response.data)
-        self.assertFalse(response.data['maintenance'])
-        self.assertFalse(app.appsettings_set.latest().maintenance)
-
-        response = self.client.post(
-            '/v2/apps/{app_id}/settings'.format(**locals()),
-            settings)
-        self.assertEqual(response.status_code, 409, response.data)
-        self.assertFalse(app.appsettings_set.latest().maintenance)
-
     def test_service_basic_ops(self):
         """Test basic service operations."""
         app_id = self.create_app()