feat(client-go): add limits endpoint

Author: Joshua Anderson

client-go/cmd/limits.go

@@ -0,0 +1,158 @@
+package cmd
+
+import (
+	"fmt"
+	"regexp"
+	"strconv"
+
+	"github.com/deis/deis/pkg/prettyprint"
+
+	"github.com/deis/deis/client-go/controller/api"
+	"github.com/deis/deis/client-go/controller/models/config"
+)
+
+// LimitsList lists an app's limits.
+func LimitsList(appID string) error {
+	c, appID, err := load(appID)
+
+	if err != nil {
+		return err
+	}
+
+	config, err := config.List(c, appID)
+
+	fmt.Printf("=== %s Limits\n\n", appID)
+
+	fmt.Println("--- Memory")
+	if len(config.Memory) == 0 {
+		fmt.Println("Unlimited")
+	} else {
+		memoryMap := make(map[string]string)
+
+		for key, value := range config.Memory {
+			memoryMap[key] = value.(string)
+		}
+
+		fmt.Print(prettyprint.PrettyTabs(memoryMap, 5))
+	}
+
+	fmt.Println("\n--- CPU")
+	if len(config.CPU) == 0 {
+		fmt.Println("Unlimited")
+	} else {
+		cpuMap := make(map[string]string)
+
+		for key, value := range config.CPU {
+			cpuMap[key] = strconv.Itoa(int(value.(float64)))
+		}
+
+		fmt.Print(prettyprint.PrettyTabs(cpuMap, 5))
+	}
+
+	return nil
+}
+
+// LimitsSet sets an app's limits.
+func LimitsSet(appID string, limits []string, limitType string) error {
+	c, appID, err := load(appID)
+
+	if err != nil {
+		return err
+	}
+
+	limitsMap := parseLimits(limits)
+
+	fmt.Print("Applying limits... ")
+
+	quit := progress()
+	configObj := api.Config{}
+
+	if limitType == "cpu" {
+		configObj.CPU = limitsMap
+	} else {
+		configObj.Memory = limitsMap
+	}
+
+	_, err = config.Set(c, appID, configObj)
+
+	quit <- true
+	<-quit
+
+	if err != nil {
+		return err
+	}
+
+	fmt.Print("done\n\n")
+
+	return LimitsList(appID)
+}
+
+// LimitsUnset removes an app's limits.
+func LimitsUnset(appID string, limits []string, limitType string) error {
+	c, appID, err := load(appID)
+
+	if err != nil {
+		return err
+	}
+
+	fmt.Print("Applying limits... ")
+
+	quit := progress()
+
+	configObj := api.Config{}
+
+	valuesMap := make(map[string]interface{})
+
+	for _, limit := range limits {
+		valuesMap[limit] = nil
+	}
+
+	if limitType == "cpu" {
+		configObj.CPU = valuesMap
+	} else {
+		configObj.Memory = valuesMap
+	}
+
+	_, err = config.Set(c, appID, configObj)
+
+	quit <- true
+	<-quit
+
+	if err != nil {
+		return err
+	}
+
+	fmt.Print("done\n\n")
+
+	return LimitsList(appID)
+}
+
+func parseLimits(limits []string) map[string]interface{} {
+	limitsMap := make(map[string]interface{})
+
+	for _, limit := range limits {
+		key, value, err := parseLimit(limit)
+
+		if err != nil {
+			fmt.Println(err)
+			continue
+		}
+
+		limitsMap[key] = value
+	}
+
+	return limitsMap
+}
+
+func parseLimit(limit string) (string, string, error) {
+	regex := regexp.MustCompile("^([A-z]+)=([0-9]+[BKMG]{1}|[0-9]{1,4})$")
+
+	if !regex.MatchString(limit) {
+		return "", "", fmt.Errorf(`%s doesn't fit format type=#unit or type=#
+Examples: web=2G worker=500M web=300`, limit)
+	}
+
+	capture := regex.FindStringSubmatch(limit)
+
+	return capture[1], capture[2], nil
+}

client-go/deis.go

@@ -89,6 +89,8 @@ Use 'git push deis master' to deploy to an application.
 		err = parser.Domains(argv)
 	case "builds":
 		err = parser.Builds(argv)
+	case "limits":
+		err = parser.Limits(argv)
 	case "tags":
 		err = parser.Tags(argv)
 	case "keys":

client-go/parser/limits.go

@@ -0,0 +1,149 @@
+package parser
+
+import (
+	"fmt"
+
+	"github.com/deis/deis/client-go/cmd"
+	docopt "github.com/docopt/docopt-go"
+)
+
+// Limits routes limits commands to their specific function
+func Limits(argv []string) error {
+	usage := `
+Valid commands for limits:
+
+limits:list        list resource limits for an app
+limits:set         set resource limits for an app
+limits:unset       unset resource limits for an app
+
+Use 'deis help [command]' to learn more.
+`
+	if len(argv) < 2 {
+		return limitsList([]string{"limits:list"})
+	}
+
+	switch argv[1] {
+	case "list":
+		return limitsList(combineCommand(argv))
+	case "set":
+		return limitSet(combineCommand(argv))
+	case "unset":
+		return limitUnset(combineCommand(argv))
+	case "--help":
+		fmt.Print(usage)
+		return nil
+	default:
+		PrintUsage()
+		return nil
+	}
+}
+
+func limitsList(argv []string) error {
+	usage := `
+Lists resource limits for an application.
+
+Usage: deis limits:list [options]
+
+Options:
+  -a --app=<app>
+    the uniquely identifiable name of the application.
+`
+
+	args, err := docopt.Parse(usage, argv, true, "", false, true)
+
+	if err != nil {
+		return err
+	}
+
+	return cmd.LimitsList(safeGetValue(args, "--app"))
+}
+
+func limitSet(argv []string) error {
+	usage := `
+Sets resource limits for an application.
+
+A resource limit is a finite resource within a container which we can apply
+restrictions to either through the scheduler or through the Docker API. This limit
+is applied to each individual container, so setting a memory limit of 1G for an
+application means that each container gets 1G of memory.
+
+Usage: deis limits:set [options] <type>=<limit>...
+
+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.
+    You can only set one type of limit per call.
+
+    With --memory, units are represented in Bytes (B), Kilobytes (K), Megabytes
+    (M), or Gigabytes (G). For example, 'deis limit:set cmd=1G' will restrict all
+    "cmd" processes to a maximum of 1 Gigabyte of memory each.
+
+    With --cpu, units are represented in the number of cpu shares. For example,
+    'deis limit:set --cpu cmd=1024' will restrict all "cmd" processes to a
+    maximum of 1024 cpu shares.
+
+Options:
+  -a --app=<app>
+    the uniquely identifiable name for the application.
+  -c --cpu
+    limits cpu shares.
+  -m --memory
+    limits memory. [default: true]
+`
+
+	args, err := docopt.Parse(usage, argv, true, "", false, true)
+
+	if err != nil {
+		return err
+	}
+
+	app := safeGetValue(args, "--app")
+	limits := args["<type>=<limit>"].([]string)
+	limitType := "memory"
+
+	if args["--cpu"].(bool) {
+		limitType = "cpu"
+	}
+
+	return cmd.LimitsSet(app, limits, limitType)
+}
+
+func limitUnset(argv []string) error {
+	usage := `
+Unsets resource limits for an application.
+
+Usage: deis limits:unset [options] [--memory | --cpu] <type>...
+
+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.
+
+Options:
+  -a --app=<app>
+    the uniquely identifiable name for the application.
+  -c --cpu
+    limits cpu shares.
+  -m --memory
+    limits memory. [default: true]
+`
+
+	args, err := docopt.Parse(usage, argv, true, "", false, true)
+
+	if err != nil {
+		return err
+	}
+
+	app := safeGetValue(args, "--app")
+	limits := args["<type>"].([]string)
+	limitType := "memory"
+
+	if args["--cpu"].(bool) {
+		limitType = "cpu"
+	}
+
+	return cmd.LimitsUnset(app, limits, limitType)
+}