feat(controller): add LimitRanges support

Author: duanhongyi

charts/controller/templates/controller-clusterrole.yaml

@@ -38,6 +38,9 @@ rules:
 - apiGroups: [""]
   resources: ["resourcequotas"]
   verbs: ["get", "create"]
+- apiGroups: [""]
+  resources: ["limitranges"]
+  verbs: ["get", "create"]
 - apiGroups: ["extensions"]
   resources: ["replicasets"]
   verbs: ["get", "list", "delete", "update"]

rootfs/api/models/app.py

@@ -14,7 +14,6 @@
 import time
 from itertools import groupby
 from urllib.parse import urljoin
-from collections import defaultdict
 
 from django.conf import settings
 from django.db import models
@@ -270,7 +269,7 @@ def create(self, *args, **kwargs):  # noqa
             )
 
         # create required minimum resources in k8s for the application
-        namespace = quota_name = service = self.id
+        namespace = limits_name = quota_name = service = self.id
         try:
             self.log('creating Namespace {} and services'.format(namespace), level=logging.DEBUG)
             # Create essential resources
@@ -290,7 +289,14 @@ def create(self, *args, **kwargs):  # noqa
                     self._scheduler.quota.get(namespace, quota_name)
                 except KubeException:
                     self._scheduler.quota.create(namespace, quota_name, spec=quota_spec)
-
+            if settings.KUBERNETES_NAMESPACE_DEFAULT_LIMIT_RANGES_SPEC != '':
+                limits_spec = json.loads(settings.KUBERNETES_NAMESPACE_DEFAULT_LIMIT_RANGES_SPEC)
+                self.log('creating LimitRanges {} for namespace {}'.format(limits_name, namespace),
+                         level=logging.DEBUG)
+                try:
+                    self._scheduler.limits.get(namespace, limits_name)
+                except KubeException:
+                    self._scheduler.limits.create(namespace, limits_name, spec=limits_spec)
             try:
                 self._scheduler.svc.get(namespace, service)
             except KubeException:
@@ -1096,7 +1102,7 @@ def _get_cpu_allocation(size):
             )
         )
         return "{num}{unit}".format(
-            num=math.ceil(int(num) / cpu_allocation_ratio),
+            num=math.floor(int(num) / cpu_allocation_ratio),
             unit=unit
         )
 
@@ -1109,24 +1115,10 @@ def _get_ram_allocation(size):
             )
         )
         return "{num}{unit}".format(
-            num=math.ceil(int(num) / ram_allocation_ratio),
+            num=math.floor(int(num) / ram_allocation_ratio),
             unit=unit
         )
 
-    def _get_default_resources(self):
-        resources = defaultdict(dict)
-        resources.update(
-            json.loads(settings.KUBERNETES_POD_DEFAULT_RESOURCES))
-        if "cpu" in resources["limits"]:
-            if "cpu" not in resources["requests"]:
-                resources["requests"]["cpu"] = self._get_cpu_allocation(
-                    resources["limits"]["cpu"])
-        if "memory" in resources["limits"]:
-            if "memory" not in resources["requests"]:
-                resources["requests"]["memory"] = self._get_ram_allocation(
-                    resources["limits"]["memory"])
-        return resources
-
     def _gather_app_settings(self, release, app_settings, process_type, replicas, volumes=None):
         """
         Gathers all required information needed in one easy place for passing into
@@ -1187,7 +1179,7 @@ def _gather_app_settings(self, release, app_settings, process_type, replicas, vo
             'replicas': replicas,
             'version': 'v{}'.format(release.version),
             'app_type': process_type,
-            'resources': self._get_default_resources(),
+            'resources': json.loads(settings.KUBERNETES_POD_DEFAULT_RESOURCES),
             'build_type': release.build.type,
             'healthcheck': healthcheck,
             'lifecycle_post_start': config.lifecycle_post_start,

rootfs/api/settings/production.py

@@ -337,35 +337,61 @@
 
 KUBERNETES_CPU_ALLOCATION_RATIO = int(os.environ.get('KUBERNETES_CPU_ALLOCATION_RATIO', '10'))
 KUBERNETES_RAM_ALLOCATION_RATIO = int(os.environ.get('KUBERNETES_RAM_ALLOCATION_RATIO', '2'))
+
 # Default pod spec for application.
-# Please do not set requests.cpu and requests.memory.
-# If set, they will not be dynamically computed when the first resource is allocated;
-# unless in the future through `drycc limits:set` manual setting
 KUBERNETES_POD_DEFAULT_RESOURCES = os.environ.get(
     'KUBERNETES_POD_DEFAULT_RESOURCES',
     json.dumps({
         "requests": {
-            "ephemeral-storage": "256Mi"
+            "cpu": "100m",
+            "memory": "128M",
+            "ephemeral-storage": "256Mi",
         },
         "limits": {
-            "cpu": "500m",
-            "memory": "512Mi",
-            "ephemeral-storage": "1Gi"
+            "cpu": "1",
+            "memory": "256M",
+            "ephemeral-storage": "512Mi",
         }
     })
 )
 # Default quota spec for application namespace
 KUBERNETES_NAMESPACE_DEFAULT_QUOTA_SPEC = os.environ.get(
-    'KUBERNETES_NAMESPACE_DEFAULT_QUOTA_SPEC',
+    'KUBERNETES_NAMESPACE_DEFAULT_QUOTA_SPEC', ''
+)
+# Default limit range spec for application namespace
+KUBERNETES_NAMESPACE_DEFAULT_LIMIT_RANGES_SPEC = os.environ.get(
+    'KUBERNETES_NAMESPACE_DEFAULT_LIMIT_RANGES_SPEC',
     json.dumps({
-        "hard": {
-            "cpu": "64",
-            "pods": "64",
-            "memory": "128Gi",
-            "ephemeral-storage": "64Gi",
-            "requests.storage": "256Gi",
-            "persistentvolumeclaims": 8,
-        }
+        "limits": [
+            {
+                "default": {
+                    "cpu": "100m",
+                    "memory": "128Mi"
+                },
+                "defaultRequest": {
+                    "cpu": "100m",
+                    "memory": "128Mi"
+                },
+                "max": {
+                    "cpu": "32",
+                    "memory": "128Gi"
+                },
+                "min": {
+                    "cpu": "100m",
+                    "memory": "128Mi"
+                },
+                "type": "Container"
+            },
+            {
+                "max": {
+                    "storage": "100Gi"
+                },
+                "min": {
+                    "storage": "100Mi"
+                },
+                "type": "PersistentVolumeClaim"
+            }
+        ]
     })
 )
 

rootfs/scheduler/mock.py

@@ -81,7 +81,8 @@ def _acquire(self):
     'namespaces', 'nodes', 'pods', 'replicationcontrollers',
     'secrets', 'services', 'events', 'deployments', 'replicasets',
     'horizontalpodautoscalers', 'scale', 'resourcequotas', 'ingresses',
-    'persistentvolumeclaims', "serviceinstances", "servicebindings"
+    'persistentvolumeclaims', 'serviceinstances', 'servicebindings',
+    'limitranges'
 ]
 
 

rootfs/scheduler/resources/limits.py

@@ -0,0 +1,44 @@
+from scheduler.exceptions import KubeHTTPException
+from scheduler.resources import Resource
+
+
+class LimitRanges(Resource):
+    short_name = 'limits'
+
+    def get(self, namespace_name, name):
+        """
+        Fetch a single LimitRanges
+        """
+        url = '/namespaces/{}/limitranges/{}'.format(namespace_name, name)
+        message = 'get LimitRanges {} for namespace {}'.format(name, namespace_name)
+        url = self.api(url)
+        response = self.http_get(url)
+        if self.unhealthy(response.status_code):
+            raise KubeHTTPException(response, message)
+
+        return response
+
+    def create(self, namespace_name, name, **kwargs):
+        """
+        Create resource LimitRanges for namespace
+        """
+        url = self.api("/namespaces/{}/limitranges".format(namespace_name))
+        manifest = {
+            "apiVersion": "v1",
+            "kind": "LimitRange",
+            "metadata": {
+                "namespace": namespace_name,
+                "name": name,
+                'labels': {
+                    'app': namespace_name,
+                    'heritage': 'drycc'
+                },
+            },
+            'spec': kwargs.get('spec', {})
+        }
+        response = self.http_post(url, json=manifest)
+        if not response.status_code == 201:
+            raise KubeHTTPException(response,
+                                    "create LimitRanges {} for namespace {}".format(
+                                        name, namespace_name))
+        return response

rootfs/scheduler/tests/test_limits.py

@@ -0,0 +1,49 @@
+"""
+Unit tests for the Drycc scheduler module.
+
+Run the tests with './manage.py test scheduler'
+"""
+from scheduler.tests import TestCase
+from scheduler import KubeHTTPException
+
+
+class LimitRangesTest(TestCase):
+
+    def test_create_quota(self):
+        namespace_name = self.create_namespace()
+        spec = {
+            "limits": [
+                {
+                    "type": "Container",
+                    "max": {
+                        "cpu": "32",
+                        "memory": "128Gi"
+                    },
+                    "min": {
+                        "cpu": "100m",
+                        "memory": "128Mi"
+                    }
+                },
+                {
+                    "type": "PersistentVolumeClaim",
+                    "max": {
+                        "storage": "100Gi"
+                    },
+                    "min": {
+                        "storage": "100Mi"
+                    }
+                }
+            ]
+        }
+        self.scheduler.limits.create(namespace_name, 'test-1', spec=spec)
+        response = self.scheduler.limits.get(namespace_name, 'test-1')
+        data = response.json()
+        self.assertEqual(data.get('spec', {}), spec)
+        self.assertEqual(data['metadata']['namespace'], namespace_name)
+
+    def test_create_with_nonexistent_namespace(self):
+        with self.assertRaises(
+            KubeHTTPException,
+            msg='failed to create LimitRanges test-1 for namespace ghost-namespace: 404 Not Found'
+        ):
+            self.scheduler.quota.create('ghost-namespace', 'test-1', data={})