Merge pull request #263 from zinuzoid/limitsset-support-new-format

feat(limits-cmd): accept new limits:set value type

Author: kmala

cmd/limits.go

@@ -145,11 +145,11 @@ func parseLimits(limits []string) (map[string]interface{}, error) {
 }
 
 func parseLimit(limit string) (string, string, error) {
-	regex := regexp.MustCompile("^([A-z]+)=([0-9]+[bkmgBKMG]{1,2}|[0-9.]{1,5}|[0-9.]{1,5}[m]{0,1})$")
+	regex := regexp.MustCompile("^([A-z]+)=(([0-9]+[bkmgBKMG]{1,2}|[0-9.]{1,5}|[0-9.]{1,5}m?)(/([0-9]+[bkmgBKMG]{1,2}|[0-9.]{1,5}|[0-9.]{1,5}m?}))?)$")
 
 	if !regex.MatchString(limit) {
-		return "", "", fmt.Errorf(`%s doesn't fit format type=#unit or type=#
-Examples: web=2G worker=500M web=300`, limit)
+		return "", "", fmt.Errorf(`%s doesn't fit format type=#unit or type=# or type=#/#
+Examples: web=2G worker=500M db=1G/2G`, limit)
 	}
 
 	capture := regex.FindStringSubmatch(limit)

cmd/limits_test.go

@@ -22,16 +22,26 @@ type parseLimitCase struct {
 func TestParseLimit(t *testing.T) {
 	t.Parallel()
 
+	var errorHint = ` doesn't fit format type=#unit or type=# or type=#/#
+Examples: web=2G worker=500M db=1G/2G`
+
 	cases := []parseLimitCase{
 		{"web=2G", "web", "2G", false, ""},
-		{"=1", "", "", true, `=1 doesn't fit format type=#unit or type=#
-Examples: web=2G worker=500M web=300`},
-		{"web=", "", "", true, `web= doesn't fit format type=#unit or type=#
-Examples: web=2G worker=500M web=300`},
-		{"1=", "", "", true, `1= doesn't fit format type=#unit or type=#
-Examples: web=2G worker=500M web=300`},
-		{"web=G", "", "", true, `web=G doesn't fit format type=#unit or type=#
-Examples: web=2G worker=500M web=300`},
+		{"web=2", "web", "2", false, ""},
+		{"web=100m", "web", "100m", false, ""},
+		{"web=0.1", "web", "0.1", false, ""},
+		{"web=.123", "web", ".123", false, ""},
+		{"web=2G/4G", "web", "2G/4G", false, ""},
+		{"web=2/4", "web", "2/4", false, ""},
+		{"web=200m/400m", "web", "200m/400m", false, ""},
+		{"web=0.2/0.4", "web", "0.2/0.4", false, ""},
+		{"web=.2/.4", "web", ".2/.4", false, ""},
+		{"=1", "", "", true, "=1" + errorHint},
+		{"web=", "", "", true, "web=" + errorHint},
+		{"1=", "", "", true, "1=" + errorHint},
+		{"web=G", "", "", true, "web=G" + errorHint},
+		{"web=/", "", "", true, "web=/" + errorHint},
+		{"web=/1", "", "", true, "web=/1" + errorHint},
 	}
 
 	for _, check := range cases {
@@ -58,8 +68,8 @@ func TestLimitTags(t *testing.T) {
 
 	cases := []parseLimitsCase{
 		{[]string{"web=1G", "worker=2"}, map[string]interface{}{"web": "1G", "worker": "2"}, false, ""},
-		{[]string{"foo=", "web=1G"}, nil, true, `foo= doesn't fit format type=#unit or type=#
-Examples: web=2G worker=500M web=300`},
+		{[]string{"foo=", "web=1G"}, nil, true, `foo= doesn't fit format type=#unit or type=# or type=#/#
+Examples: web=2G worker=500M db=1G/2G`},
 	}
 
 	for _, check := range cases {
@@ -88,11 +98,13 @@ func TestLimitsList(t *testing.T) {
 			"app": "enterprise",
 			"values": {},
 			"memory": {
-				"web": "2G"
+				"web": "2G",
+				"db": "1000M/1500M"
 			},
 			"cpu": {
 				"web": "2",
-				"worker": "1"
+				"worker": "1",
+				"db": "500m/2000m"
 			},
 			"tags": {},
 			"registry": {},
@@ -110,9 +122,11 @@ func TestLimitsList(t *testing.T) {
 	assert.Equal(t, b.String(), `=== enterprise Limits
 
 --- Memory
+db      1000M/1500M
 web     2G
 
 --- CPU
+db         500m/2000m
 web        2
 worker     1
 `, "output")
@@ -236,6 +250,102 @@ web     1G
 
 --- CPU
 Unlimited
+`, "output")
+
+	// with requests/limit parameter
+	server.Mux.HandleFunc("/v2/apps/jim/config/", func(w http.ResponseWriter, r *http.Request) {
+		testutil.SetHeaders(w)
+		if r.Method == "POST" {
+			testutil.AssertBody(t, api.Config{
+				Memory: map[string]interface{}{
+					"web":    "2000M",
+					"worker": "0/3G",
+					"db":     "4G/5G",
+				},
+			}, r)
+		}
+
+		fmt.Fprintf(w, `{
+			"owner": "foo",
+			"app": "jim",
+			"values": {},
+			"memory": {
+				"web": "2000M",
+				"worker": "0/3G",
+				"db": "4G/5G"
+			},
+			"cpu": {},
+			"tags": {},
+			"registry": {},
+			"created": "2014-01-01T00:00:00UTC",
+			"updated": "2014-01-01T00:00:00UTC",
+			"uuid": "de1bf5b5-4a72-4f94-a10c-d2a3741cdf75"
+		}`)
+	})
+	b.Reset()
+
+	err = cmdr.LimitsSet("jim", []string{"web=2000M", "worker=0/3G", "db=4G/5G"}, "memory")
+	assert.NoErr(t, err)
+
+	assert.Equal(t, testutil.StripProgress(b.String()), `Applying limits... done
+
+=== jim Limits
+
+--- Memory
+db         4G/5G
+web        2000M
+worker     0/3G
+
+--- CPU
+Unlimited
+`, "output")
+
+	// with requests/limit parameter
+	server.Mux.HandleFunc("/v2/apps/phew/config/", func(w http.ResponseWriter, r *http.Request) {
+		testutil.SetHeaders(w)
+		if r.Method == "POST" {
+			testutil.AssertBody(t, api.Config{
+				CPU: map[string]interface{}{
+					"web":    "2",
+					"worker": "0/300m",
+					"db":     "4/5.6",
+				},
+			}, r)
+		}
+
+		fmt.Fprintf(w, `{
+			"owner": "foo",
+			"app": "jim",
+			"values": {},
+			"cpu": {
+				"web": "2",
+				"worker": "0/300m",
+				"db": "4/5.6"
+			},
+			"cpu": {},
+			"tags": {},
+			"registry": {},
+			"created": "2014-01-01T00:00:00UTC",
+			"updated": "2014-01-01T00:00:00UTC",
+			"uuid": "de1bf5b5-4a72-4f94-a10c-d2a3741cdf75"
+		}`)
+	})
+	b.Reset()
+
+	err = cmdr.LimitsSet("phew", []string{"web=2", "worker=0/300m", "db=4/5.6"}, "cpu")
+	assert.NoErr(t, err)
+
+	assert.Equal(t, testutil.StripProgress(b.String()), `Applying limits... done
+
+=== phew Limits
+
+--- Memory
+Unlimited
+
+--- CPU
+db         4/5.6
+web        2
+worker     0/300m
 `, "output")
 }
 

parser/limits.go

@@ -61,21 +61,24 @@ Options:
 
 func limitSet(argv []string, cmdr cmd.Commander) error {
 	usage := `
-Sets resource limits for an application.
+Sets resource requests and limits for an application.
 
 A resource limit is a finite resource within a pod which we can apply
-restrictions through Kubernetes. This limit is applied to each individual
-pod, so setting a memory limit of 1G for an application means that each
-pod gets 1G of memory.
+restrictions through Kubernetes. A resource request is used by Kubernetes scheduler
+to select a node that can guarantee requested resource. If provided only one value,
+it'll be default by Kubernetes as both request and limit. These request and limit
+are applied to each individual pod, so setting a memory limit of 1G for an application
+means that each pod gets 1G of memory. Value needs to be within 0 <= request <= limit
 
-Usage: deis limits:set [options] <type>=<limit>...
+Usage: deis limits:set [options] <type>=<value>...
 
 Arguments:
   <type>
     the process type as defined in your Procfile, such as 'web' or 'worker'.
     Note that Dockerfile apps have a default 'cmd' process type.
-  <limit>
-    The limit to apply to the process type. By default, this is set to --memory.
+  <value>
+    The value to apply to the process type. By default, this is set to --memory.
+    Can be in <limit> or <request>/<limit> format eg. web=2G db=1G/2G
     You can only set one type of limit per call.
 
     With --memory, units are represented in Bytes (B), Kilobytes (K), Megabytes
@@ -92,9 +95,9 @@ Options:
   -a --app=<app>
     the uniquely identifiable name for the application.
   --cpu
-    limits CPU.
+    value apply to CPU.
   -m --memory
-    limits memory. [default: true]
+    value apply to memory. [default: true]
 `
 
 	args, err := docopt.Parse(usage, argv, true, "", false, true)
@@ -104,7 +107,7 @@ Options:
 	}
 
 	app := safeGetValue(args, "--app")
-	limits := args["<type>=<limit>"].([]string)
+	limits := args["<type>=<value>"].([]string)
 	limitType := "memory"
 
 	if args["--cpu"].(bool) {

parser/limits_test.go

@@ -49,6 +49,14 @@ func TestLimits(t *testing.T) {
 			args:     []string{"limits:set", "web=1G"},
 			expected: "",
 		},
+		{
+			args:     []string{"limits:set", "web=1G worker=2G"},
+			expected: "",
+		},
+		{
+			args:     []string{"limits:set", "web=1G/2G worker=2G/4G"},
+			expected: "",
+		},
 		{
 			args:     []string{"limits:set", "--cpu", "web=1"},
 			expected: "",