set resources limits

api/types/client.go

@@ -46,6 +46,8 @@ type Tuning struct {
 	AntiAffinity string
 	Cpu          string
 	Memory       string
+	CpuLimit     string
+	MemoryLimit  string
 }
 
 type RouterOptions struct {

api/types/types.go

@@ -274,6 +274,63 @@ type DeploymentSpec struct {
 	NodeSelector    map[string]string        `json:"nodeSelector,omitempty"`
 	CpuRequest      *resource.Quantity       `json:"cpuRequest,omitempty"`
 	MemoryRequest   *resource.Quantity       `json:"memoryRequest,omitempty"`
+	CpuLimit        *resource.Quantity       `json:"cpuLimit,omitempty"`
+	MemoryLimit     *resource.Quantity       `json:"memoryLimit,omitempty"`
+}
+
+func (s *DeploymentSpec) GetCpuRequest() resource.Quantity {
+	if s.CpuRequest == nil {
+		return resource.Quantity{}
+	}
+	return *s.CpuRequest
+}
+
+func (s *DeploymentSpec) GetMemoryRequest() resource.Quantity {
+	if s.MemoryRequest == nil {
+		return resource.Quantity{}
+	}
+	return *s.MemoryRequest
+}
+
+func (s *DeploymentSpec) GetCpuLimit() resource.Quantity {
+	if s.CpuLimit == nil {
+		return s.GetCpuRequest()
+	}
+	return *s.CpuLimit
+}
+
+func (s *DeploymentSpec) GetMemoryLimit() resource.Quantity {
+	if s.MemoryLimit == nil {
+		return s.GetMemoryRequest()
+	}
+	return *s.MemoryLimit
+}
+
+func (s *DeploymentSpec) HasCpuRequest() bool {
+	return s.CpuRequest != nil
+}
+
+func (s *DeploymentSpec) HasMemoryRequest() bool {
+	return s.MemoryRequest != nil
+}
+
+func (s *DeploymentSpec) HasCpuLimit() bool {
+	return s.CpuLimit != nil || s.HasCpuRequest()
+}
+
+func (s *DeploymentSpec) HasMemoryLimit() bool {
+	return s.MemoryLimit != nil || s.HasMemoryRequest()
+}
+
+type Resources interface {
+	GetCpuRequest() resource.Quantity
+	GetMemoryRequest() resource.Quantity
+	GetCpuLimit() resource.Quantity
+	GetMemoryLimit() resource.Quantity
+	HasCpuRequest() bool
+	HasMemoryRequest() bool
+	HasCpuLimit() bool
+	HasMemoryLimit() bool
 }
 
 // AssemblySpec for the links and connectors that form the VAN topology
@@ -471,6 +528,52 @@ type Headless struct {
 	NodeSelector  map[string]string  `json:"nodeSelector,omitempty" yaml:"nodeSelector,omitempty"`
 	CpuRequest    *resource.Quantity `json:"cpuRequest,omitempty" yaml:"cpuRequest,omitempty"`
 	MemoryRequest *resource.Quantity `json:"memoryRequest,omitempty" yaml:"memoryRequest,omitempty"`
+	CpuLimit      *resource.Quantity `json:"cpuLimit,omitempty" yaml:"cpuLimit,omitempty"`
+	MemoryLimit   *resource.Quantity `json:"memoryLimit,omitempty" yaml:"memoryLimit,omitempty"`
+}
+
+func (s *Headless) GetCpuRequest() resource.Quantity {
+	if s.CpuRequest == nil {
+		return resource.Quantity{}
+	}
+	return *s.CpuRequest
+}
+
+func (s *Headless) GetMemoryRequest() resource.Quantity {
+	if s.MemoryRequest == nil {
+		return resource.Quantity{}
+	}
+	return *s.MemoryRequest
+}
+
+func (s *Headless) GetCpuLimit() resource.Quantity {
+	if s.CpuLimit == nil {
+		return s.GetCpuRequest()
+	}
+	return *s.CpuLimit
+}
+
+func (s *Headless) GetMemoryLimit() resource.Quantity {
+	if s.MemoryLimit == nil {
+		return s.GetMemoryRequest()
+	}
+	return *s.MemoryLimit
+}
+
+func (s *Headless) HasCpuRequest() bool {
+	return s.CpuRequest != nil
+}
+
+func (s *Headless) HasMemoryRequest() bool {
+	return s.MemoryRequest != nil
+}
+
+func (s *Headless) HasCpuLimit() bool {
+	return s.CpuLimit != nil || s.HasCpuRequest()
+}
+
+func (s *Headless) HasMemoryLimit() bool {
+	return s.MemoryLimit != nil || s.HasMemoryRequest()
 }
 
 type HeadlessV1 struct {

client/router_create.go

@@ -349,6 +349,22 @@ func configureDeployment(spec *types.DeploymentSpec, options *types.Tuning) erro
 			errs = append(errs, fmt.Sprintf("Invalid value for memory: %s", err))
 		}
 	}
+	if options.CpuLimit != "" {
+		cpu, err := resource.ParseQuantity(options.CpuLimit)
+		if err == nil {
+			spec.CpuLimit = &cpu
+		} else {
+			errs = append(errs, fmt.Sprintf("Invalid value for cpu: %s", err))
+		}
+	}
+	if options.MemoryLimit != "" {
+		memory, err := resource.ParseQuantity(options.MemoryLimit)
+		if err == nil {
+			spec.MemoryLimit = &memory
+		} else {
+			errs = append(errs, fmt.Sprintf("Invalid value for memory: %s", err))
+		}
+	}
 	if len(errs) > 0 {
 		return fmt.Errorf(strings.Join(errs, ", "))
 	} else {

client/site_config_create.go

@@ -35,6 +35,8 @@ const (
 	SiteConfigRouterDebugModeKey        string = "router-debug-mode"
 	SiteConfigRouterCpuKey              string = "router-cpu"
 	SiteConfigRouterMemoryKey           string = "router-memory"
+	SiteConfigRouterCpuLimitKey         string = "router-cpu-limit"
+	SiteConfigRouterMemoryLimitKey      string = "router-memory-limit"
 	SiteConfigRouterAffinityKey         string = "router-pod-affinity"
 	SiteConfigRouterAntiAffinityKey     string = "router-pod-antiaffinity"
 	SiteConfigRouterNodeSelectorKey     string = "router-node-selector"
@@ -47,6 +49,8 @@ const (
 	SiteConfigServiceSyncKey            string = "service-sync"
 	SiteConfigControllerCpuKey          string = "controller-cpu"
 	SiteConfigControllerMemoryKey       string = "controller-memory"
+	SiteConfigControllerCpuLimitKey     string = "controller-cpu-limit"
+	SiteConfigControllerMemoryLimitKey  string = "controller-memory-limit"
 	SiteConfigControllerAffinityKey     string = "controller-pod-affinity"
 	SiteConfigControllerAntiAffinityKey string = "controller-pod-antiaffinity"
 	SiteConfigControllerNodeSelectorKey string = "controller-node-selector"
@@ -135,6 +139,18 @@ func (cli *VanClient) SiteConfigCreate(ctx context.Context, spec types.SiteConfi
 		}
 		siteConfig.Data[SiteConfigRouterMemoryKey] = spec.Router.Memory
 	}
+	if spec.Router.CpuLimit != "" {
+		if _, err := resource.ParseQuantity(spec.Router.CpuLimit); err != nil {
+			return nil, fmt.Errorf("Invalid value for %s %q: %s", SiteConfigRouterCpuLimitKey, spec.Router.CpuLimit, err)
+		}
+		siteConfig.Data[SiteConfigRouterCpuLimitKey] = spec.Router.CpuLimit
+	}
+	if spec.Router.MemoryLimit != "" {
+		if _, err := resource.ParseQuantity(spec.Router.MemoryLimit); err != nil {
+			return nil, fmt.Errorf("Invalid value for %s %q: %s", SiteConfigRouterMemoryLimitKey, spec.Router.MemoryLimit, err)
+		}
+		siteConfig.Data[SiteConfigRouterMemoryLimitKey] = spec.Router.MemoryLimit
+	}
 	if spec.Router.Affinity != "" {
 		siteConfig.Data[SiteConfigRouterAffinityKey] = spec.Router.Affinity
 	}
@@ -165,6 +181,18 @@ func (cli *VanClient) SiteConfigCreate(ctx context.Context, spec types.SiteConfi
 		}
 		siteConfig.Data[SiteConfigControllerMemoryKey] = spec.Controller.Memory
 	}
+	if spec.Controller.CpuLimit != "" {
+		if _, err := resource.ParseQuantity(spec.Controller.CpuLimit); err != nil {
+			return nil, fmt.Errorf("Invalid value for %s %q: %s", SiteConfigControllerCpuLimitKey, spec.Controller.CpuLimit, err)
+		}
+		siteConfig.Data[SiteConfigControllerCpuLimitKey] = spec.Controller.CpuLimit
+	}
+	if spec.Controller.MemoryLimit != "" {
+		if _, err := resource.ParseQuantity(spec.Controller.MemoryLimit); err != nil {
+			return nil, fmt.Errorf("Invalid value for %s %q: %s", SiteConfigControllerMemoryLimitKey, spec.Controller.MemoryLimit, err)
+		}
+		siteConfig.Data[SiteConfigControllerMemoryLimitKey] = spec.Controller.MemoryLimit
+	}
 	if spec.Controller.Affinity != "" {
 		siteConfig.Data[SiteConfigControllerAffinityKey] = spec.Controller.Affinity
 	}

client/site_config_inspect.go

@@ -147,6 +147,12 @@ func (cli *VanClient) SiteConfigInspectInNamespace(ctx context.Context, input *c
 	if routerMemory, ok := siteConfig.Data[SiteConfigRouterMemoryKey]; ok && routerMemory != "" {
 		result.Spec.Router.Memory = routerMemory
 	}
+	if routerCpuLimit, ok := siteConfig.Data[SiteConfigRouterCpuLimitKey]; ok && routerCpuLimit != "" {
+		result.Spec.Router.CpuLimit = routerCpuLimit
+	}
+	if routerMemoryLimit, ok := siteConfig.Data[SiteConfigRouterMemoryLimitKey]; ok && routerMemoryLimit != "" {
+		result.Spec.Router.MemoryLimit = routerMemoryLimit
+	}
 	if routerNodeSelector, ok := siteConfig.Data[SiteConfigRouterNodeSelectorKey]; ok && routerNodeSelector != "" {
 		result.Spec.Router.NodeSelector = routerNodeSelector
 	}
@@ -185,6 +191,12 @@ func (cli *VanClient) SiteConfigInspectInNamespace(ctx context.Context, input *c
 	if controllerMemory, ok := siteConfig.Data[SiteConfigControllerMemoryKey]; ok && controllerMemory != "" {
 		result.Spec.Controller.Memory = controllerMemory
 	}
+	if controllerCpuLimit, ok := siteConfig.Data[SiteConfigControllerCpuLimitKey]; ok && controllerCpuLimit != "" {
+		result.Spec.Controller.CpuLimit = controllerCpuLimit
+	}
+	if controllerMemoryLimit, ok := siteConfig.Data[SiteConfigControllerMemoryLimitKey]; ok && controllerMemoryLimit != "" {
+		result.Spec.Controller.MemoryLimit = controllerMemoryLimit
+	}
 	if controllerNodeSelector, ok := siteConfig.Data[SiteConfigControllerNodeSelectorKey]; ok && controllerNodeSelector != "" {
 		result.Spec.Controller.NodeSelector = controllerNodeSelector
 	}

cmd/skupper/skupper.go

@@ -78,6 +78,22 @@ func configureHeadlessProxy(spec *types.Headless, options *types.Tuning) error {
 			err = fmt.Errorf("Invalid value for memory: %s", err)
 		}
 	}
+	if options.CpuLimit != "" {
+		cpuQuantity, err := resource.ParseQuantity(options.CpuLimit)
+		if err == nil {
+			spec.CpuLimit = &cpuQuantity
+		} else {
+			err = fmt.Errorf("Invalid value for cpu: %s", err)
+		}
+	}
+	if options.MemoryLimit != "" {
+		memoryQuantity, err := resource.ParseQuantity(options.MemoryLimit)
+		if err == nil {
+			spec.MemoryLimit = &memoryQuantity
+		} else {
+			err = fmt.Errorf("Invalid value for memory: %s", err)
+		}
+	}
 	return err
 }
 
@@ -393,13 +409,17 @@ installation that can then be connected to other skupper installations`,
 
 	cmd.Flags().StringVar(&routerCreateOpts.Router.Cpu, "router-cpu", "", "CPU request for router pods")
 	cmd.Flags().StringVar(&routerCreateOpts.Router.Memory, "router-memory", "", "Memory request for router pods")
+	cmd.Flags().StringVar(&routerCreateOpts.Router.CpuLimit, "router-cpu-limit", "", "CPU limit for router pods")
+	cmd.Flags().StringVar(&routerCreateOpts.Router.MemoryLimit, "router-memory-limit", "", "Memory limit for router pods")
 	cmd.Flags().StringVar(&routerCreateOpts.Router.NodeSelector, "router-node-selector", "", "Node selector to control placement of router pods")
 	cmd.Flags().StringVar(&routerCreateOpts.Router.Affinity, "router-pod-affinity", "", "Pod affinity label matches to control placement of router pods")
 	cmd.Flags().StringVar(&routerCreateOpts.Router.AntiAffinity, "router-pod-antiaffinity", "", "Pod antiaffinity label matches to control placement of router pods")
 	cmd.Flags().StringVar(&routerCreateOpts.Router.IngressHost, "router-ingress-host", "", "Host through which node is accessible when using nodeport as ingress.")
 
 	cmd.Flags().StringVar(&routerCreateOpts.Controller.Cpu, "controller-cpu", "", "CPU request for controller pods")
 	cmd.Flags().StringVar(&routerCreateOpts.Controller.Memory, "controller-memory", "", "Memory request for controller pods")
+	cmd.Flags().StringVar(&routerCreateOpts.Controller.CpuLimit, "controller-cpu-limit", "", "CPU limit for controller pods")
+	cmd.Flags().StringVar(&routerCreateOpts.Controller.MemoryLimit, "controller-memory-limit", "", "Memory limit for controller pods")
 	cmd.Flags().StringVar(&routerCreateOpts.Controller.NodeSelector, "controller-node-selector", "", "Node selector to control placement of controller pods")
 	cmd.Flags().StringVar(&routerCreateOpts.Controller.Affinity, "controller-pod-affinity", "", "Pod affinity label matches to control placement of controller pods")
 	cmd.Flags().StringVar(&routerCreateOpts.Controller.AntiAffinity, "controller-pod-antiaffinity", "", "Pod antiaffinity label matches to control placement of controller pods")
@@ -644,6 +664,12 @@ func NewCmdExpose(newClient cobraFunc) *cobra.Command {
 				if exposeOpts.ProxyTuning.Memory != "" {
 					return fmt.Errorf("--proxy-memory option is only valid for headless services")
 				}
+				if exposeOpts.ProxyTuning.CpuLimit != "" {
+					return fmt.Errorf("--proxy-cpu-limit option is only valid for headless services")
+				}
+				if exposeOpts.ProxyTuning.MemoryLimit != "" {
+					return fmt.Errorf("--proxy-memory-limit option is only valid for headless services")
+				}
 				if exposeOpts.ProxyTuning.Affinity != "" {
 					return fmt.Errorf("--proxy-pod-affinity option is only valid for headless services")
 				}
@@ -668,6 +694,8 @@ func NewCmdExpose(newClient cobraFunc) *cobra.Command {
 	cmd.Flags().BoolVar(&(exposeOpts.Headless), "headless", false, "Expose through a headless service (valid only for a statefulset target)")
 	cmd.Flags().StringVar(&exposeOpts.ProxyTuning.Cpu, "proxy-cpu", "", "CPU request for router pods")
 	cmd.Flags().StringVar(&exposeOpts.ProxyTuning.Memory, "proxy-memory", "", "Memory request for router pods")
+	cmd.Flags().StringVar(&exposeOpts.ProxyTuning.CpuLimit, "proxy-cpu-limit", "", "CPU limit for router pods")
+	cmd.Flags().StringVar(&exposeOpts.ProxyTuning.MemoryLimit, "proxy-memory-limit", "", "Memory limit for router pods")
 	cmd.Flags().StringVar(&exposeOpts.ProxyTuning.NodeSelector, "proxy-node-selector", "", "Node selector to control placement of router pods")
 	cmd.Flags().StringVar(&exposeOpts.ProxyTuning.Affinity, "proxy-pod-affinity", "", "Pod affinity label matches to control placement of router pods")
 	cmd.Flags().StringVar(&exposeOpts.ProxyTuning.AntiAffinity, "proxy-pod-antiaffinity", "", "Pod antiaffinity label matches to control placement of router pods")

pkg/kube/containers.go

@@ -6,16 +6,25 @@ import (
 	"k8s.io/apimachinery/pkg/util/intstr"
 )
 
-func setResourceRequests(container *corev1.Container, ds *types.DeploymentSpec) {
-	if ds.CpuRequest != nil || ds.MemoryRequest != nil {
+func setResourceRequests(container *corev1.Container, resources types.Resources) {
+	requests := corev1.ResourceList{}
+	if resources.HasCpuRequest() {
+		requests[corev1.ResourceCPU] = resources.GetCpuRequest()
+	}
+	if resources.HasMemoryRequest() {
+		requests[corev1.ResourceMemory] = resources.GetMemoryRequest()
+	}
+	limits := corev1.ResourceList{}
+	if resources.HasCpuLimit() {
+		limits[corev1.ResourceCPU] = resources.GetCpuLimit()
+	}
+	if resources.HasMemoryLimit() {
+		limits[corev1.ResourceMemory] = resources.GetMemoryLimit()
+	}
+	if len(requests) > 0 || len(limits) > 0 {
 		container.Resources = corev1.ResourceRequirements{
-			Requests: corev1.ResourceList{},
-		}
-		if ds.CpuRequest != nil {
-			container.Resources.Requests[corev1.ResourceCPU] = *ds.CpuRequest
-		}
-		if ds.MemoryRequest != nil {
-			container.Resources.Requests[corev1.ResourceMemory] = *ds.MemoryRequest
+			Requests: requests,
+			Limits:   limits,
 		}
 	}
 }

pkg/kube/deployments.go

@@ -236,18 +236,7 @@ func NewProxyStatefulSet(image types.ImageDetails, serviceInterface types.Servic
 			}
 		}
 	}
-	if serviceInterface.Headless.CpuRequest != nil || serviceInterface.Headless.MemoryRequest != nil {
-		container := &podspec.Containers[0]
-		container.Resources = corev1.ResourceRequirements{
-			Requests: corev1.ResourceList{},
-		}
-		if serviceInterface.Headless.CpuRequest != nil {
-			container.Resources.Requests[corev1.ResourceCPU] = *serviceInterface.Headless.CpuRequest
-		}
-		if serviceInterface.Headless.MemoryRequest != nil {
-			container.Resources.Requests[corev1.ResourceMemory] = *serviceInterface.Headless.MemoryRequest
-		}
-	}
+	setResourceRequests(&podspec.Containers[0], serviceInterface.Headless)
 
 	created, err := statefulSets.Create(proxyStatefulSet)
 

test/integration/examples/custom/helloworld/helloworld_test.go

@@ -108,20 +108,24 @@ func TestHelloWorldCLI(t *testing.T) {
 				{Ctx: prv, Commands: []cli.SkupperCommandTester{
 					// skupper init - edge mode, no console and unsecured
 					&cli.InitTester{
-						ConsoleAuth:         "unsecured",
-						ConsoleUser:         "admin",
-						ConsolePassword:     "admin",
-						Ingress:             "none",
-						RouterDebugMode:     "gdb",
-						RouterLogging:       "trace",
-						RouterMode:          "edge",
-						SiteName:            "private",
-						EnableConsole:       false,
-						EnableRouterConsole: false,
-						RouterCPU:           "100m",
-						RouterMemory:        "32Mi",
-						ControllerCPU:       "50m",
-						ControllerMemory:    "16Mi",
+						ConsoleAuth:           "unsecured",
+						ConsoleUser:           "admin",
+						ConsolePassword:       "admin",
+						Ingress:               "none",
+						RouterDebugMode:       "gdb",
+						RouterLogging:         "trace",
+						RouterMode:            "edge",
+						SiteName:              "private",
+						EnableConsole:         false,
+						EnableRouterConsole:   false,
+						RouterCPU:             "100m",
+						RouterMemory:          "32Mi",
+						ControllerCPU:         "50m",
+						ControllerMemory:      "16Mi",
+						RouterCPULimit:        "600m",
+						RouterMemoryLimit:     "500Mi",
+						ControllerCPULimit:    "600m",
+						ControllerMemoryLimit: "500Mi",
 						//ConsoleIngress:      "none",
 					},
 					// skupper status - verify initialized as edge