From b42b3f797237e515db372d5ded7ff88cc88665a1 Mon Sep 17 00:00:00 2001 From: william-wang Date: Thu, 10 Oct 2024 15:04:59 +0800 Subject: [PATCH 1/3] Add volcano agent framework Signed-off-by: william-wang --- cmd/agent/app/agent.go | 95 ++++ cmd/agent/app/app.go | 91 ++++ cmd/agent/app/options/options.go | 105 ++++ cmd/agent/app/options/options_test.go | 53 ++ cmd/agent/main.go | 40 ++ cmd/network-qos/cni/cni.go | 179 +++++++ cmd/network-qos/cni/cni_test.go | 221 +++++++++ cmd/network-qos/main.go | 33 ++ cmd/network-qos/tools/get.go | 85 ++++ cmd/network-qos/tools/get_test.go | 115 +++++ cmd/network-qos/tools/options/options.go | 43 ++ cmd/network-qos/tools/options/options_test.go | 57 +++ cmd/network-qos/tools/prepare.go | 133 +++++ cmd/network-qos/tools/prepare_test.go | 198 ++++++++ cmd/network-qos/tools/reset.go | 85 ++++ cmd/network-qos/tools/reset_test.go | 162 ++++++ cmd/network-qos/tools/root.go | 65 +++ cmd/network-qos/tools/set.go | 74 +++ cmd/network-qos/tools/set_test.go | 140 ++++++ cmd/network-qos/tools/status.go | 76 +++ cmd/network-qos/tools/status_test.go | 131 +++++ cmd/network-qos/tools/version.go | 36 ++ go.mod | 43 +- go.sum | 100 +++- pkg/agent/apis/extension/qos.go | 62 +++ pkg/agent/apis/extension/qos_test.go | 80 +++ pkg/agent/apis/types.go | 83 ++++ pkg/agent/config/api/types.go | 113 +++++ pkg/agent/config/api/validate.go | 146 ++++++ pkg/agent/config/api/validate_test.go | 149 ++++++ pkg/agent/config/configmgr.go | 241 +++++++++ pkg/agent/config/configmgr_test.go | 307 ++++++++++++ pkg/agent/config/source/configmap_source.go | 155 ++++++ pkg/agent/config/source/fake_source.go | 54 ++ pkg/agent/config/source/file_source.go | 44 ++ pkg/agent/config/source/interface.go | 31 ++ pkg/agent/config/utils/utils.go | 178 +++++++ pkg/agent/config/utils/utils_test.go | 255 ++++++++++ pkg/agent/events/eventsmgr.go | 77 +++ pkg/agent/events/framework/events.go | 106 ++++ pkg/agent/events/framework/factory.go | 96 ++++ pkg/agent/events/framework/interface.go | 43 ++ pkg/agent/events/framework/types.go | 55 +++ pkg/agent/events/handlers/registry.go | 42 ++ pkg/agent/events/probes/registry.go | 43 ++ pkg/agent/features/feature.go | 29 ++ pkg/agent/features/feature_gate.go | 138 ++++++ pkg/agent/features/feature_gate_test.go | 384 +++++++++++++++ pkg/agent/healthcheck/healthcheck.go | 57 +++ pkg/agent/metrics/metrics.go | 44 ++ pkg/agent/utils/cgroup/cgroup.go | 176 +++++++ pkg/agent/utils/eviction/eviction.go | 94 ++++ pkg/agent/utils/exec/exec.go | 62 +++ pkg/agent/utils/exec/mocks/mock_exec.go | 66 +++ pkg/agent/utils/file/file.go | 59 +++ pkg/agent/utils/node/annotation.go | 56 +++ pkg/agent/utils/node/label.go | 55 +++ pkg/agent/utils/node/node.go | 143 ++++++ pkg/agent/utils/node/node_test.go | 204 ++++++++ pkg/agent/utils/node/patcher.go | 158 ++++++ pkg/agent/utils/node/patcher_test.go | 84 ++++ pkg/agent/utils/node/resource.go | 154 ++++++ pkg/agent/utils/node/taints.go | 45 ++ pkg/agent/utils/pod/pod.go | 189 +++++++ pkg/agent/utils/pod/resources.go | 150 ++++++ pkg/agent/utils/pod/resources_test.go | 126 +++++ pkg/agent/utils/testing/pod.go | 106 ++++ pkg/agent/utils/utils.go | 154 ++++++ pkg/agent/utils/utils_test.go | 198 ++++++++ pkg/agent/utils/version/compare.go | 82 +++ pkg/agent/utils/version/compare_test.go | 72 +++ pkg/config/config.go | 144 ++++++ pkg/config/config_test.go | 91 ++++ pkg/config/generic.go | 77 +++ pkg/config/informerfactory.go | 26 + pkg/metriccollect/collectmgr.go | 58 +++ pkg/metriccollect/framework/interface.go | 36 ++ pkg/metriccollect/framework/registry.go | 39 ++ pkg/metriccollect/local/cpu.go | 176 +++++++ pkg/metriccollect/local/local_collector.go | 101 ++++ pkg/metriccollect/local/memory.go | 152 ++++++ .../testing/fake_local_collector.go | 72 +++ .../testing/fake_sub_collector_cpu.go | 47 ++ .../testing/fake_sub_collector_memory.go | 47 ++ pkg/networkqos/api/cni.go | 57 +++ pkg/networkqos/api/ebpf_map.go | 72 +++ pkg/networkqos/cni/config.go | 158 ++++++ pkg/networkqos/cni/config_test.go | 465 ++++++++++++++++++ pkg/networkqos/cni/mocks/mock_config.go | 78 +++ pkg/networkqos/networkqos.go | 233 +++++++++ pkg/networkqos/networkqos_test.go | 297 +++++++++++ pkg/networkqos/tc/mocks/mock_tc.go | 93 ++++ pkg/networkqos/tc/tc.go | 52 ++ pkg/networkqos/tc/tc_linux.go | 184 +++++++ pkg/networkqos/tc/tc_unspecified.go | 36 ++ .../throttling/mocks/mock_throttling.go | 125 +++++ pkg/networkqos/throttling/throttling.go | 232 +++++++++ pkg/networkqos/throttling/throttling_test.go | 444 +++++++++++++++++ pkg/networkqos/utils/ebpf/map.go | 147 ++++++ pkg/networkqos/utils/ebpf/map_test.go | 79 +++ pkg/networkqos/utils/ebpf/mocks/mock_map.go | 107 ++++ pkg/networkqos/utils/utils.go | 147 ++++++ pkg/networkqos/utils/utils_test.go | 106 ++++ .../fake_resource_usage_getter.go | 49 ++ pkg/resourceusage/resource_usage_getter.go | 121 +++++ .../resource_usage_getter_test.go | 118 +++++ 106 files changed, 12244 insertions(+), 27 deletions(-) create mode 100644 cmd/agent/app/agent.go create mode 100644 cmd/agent/app/app.go create mode 100644 cmd/agent/app/options/options.go create mode 100644 cmd/agent/app/options/options_test.go create mode 100644 cmd/agent/main.go create mode 100644 cmd/network-qos/cni/cni.go create mode 100644 cmd/network-qos/cni/cni_test.go create mode 100644 cmd/network-qos/main.go create mode 100644 cmd/network-qos/tools/get.go create mode 100644 cmd/network-qos/tools/get_test.go create mode 100644 cmd/network-qos/tools/options/options.go create mode 100644 cmd/network-qos/tools/options/options_test.go create mode 100644 cmd/network-qos/tools/prepare.go create mode 100644 cmd/network-qos/tools/prepare_test.go create mode 100644 cmd/network-qos/tools/reset.go create mode 100644 cmd/network-qos/tools/reset_test.go create mode 100644 cmd/network-qos/tools/root.go create mode 100644 cmd/network-qos/tools/set.go create mode 100644 cmd/network-qos/tools/set_test.go create mode 100644 cmd/network-qos/tools/status.go create mode 100644 cmd/network-qos/tools/status_test.go create mode 100644 cmd/network-qos/tools/version.go create mode 100644 pkg/agent/apis/extension/qos.go create mode 100644 pkg/agent/apis/extension/qos_test.go create mode 100644 pkg/agent/apis/types.go create mode 100644 pkg/agent/config/api/types.go create mode 100644 pkg/agent/config/api/validate.go create mode 100644 pkg/agent/config/api/validate_test.go create mode 100644 pkg/agent/config/configmgr.go create mode 100644 pkg/agent/config/configmgr_test.go create mode 100644 pkg/agent/config/source/configmap_source.go create mode 100644 pkg/agent/config/source/fake_source.go create mode 100644 pkg/agent/config/source/file_source.go create mode 100644 pkg/agent/config/source/interface.go create mode 100644 pkg/agent/config/utils/utils.go create mode 100644 pkg/agent/config/utils/utils_test.go create mode 100644 pkg/agent/events/eventsmgr.go create mode 100644 pkg/agent/events/framework/events.go create mode 100644 pkg/agent/events/framework/factory.go create mode 100644 pkg/agent/events/framework/interface.go create mode 100644 pkg/agent/events/framework/types.go create mode 100644 pkg/agent/events/handlers/registry.go create mode 100644 pkg/agent/events/probes/registry.go create mode 100644 pkg/agent/features/feature.go create mode 100644 pkg/agent/features/feature_gate.go create mode 100644 pkg/agent/features/feature_gate_test.go create mode 100644 pkg/agent/healthcheck/healthcheck.go create mode 100644 pkg/agent/metrics/metrics.go create mode 100644 pkg/agent/utils/cgroup/cgroup.go create mode 100644 pkg/agent/utils/eviction/eviction.go create mode 100644 pkg/agent/utils/exec/exec.go create mode 100644 pkg/agent/utils/exec/mocks/mock_exec.go create mode 100644 pkg/agent/utils/file/file.go create mode 100644 pkg/agent/utils/node/annotation.go create mode 100644 pkg/agent/utils/node/label.go create mode 100644 pkg/agent/utils/node/node.go create mode 100644 pkg/agent/utils/node/node_test.go create mode 100644 pkg/agent/utils/node/patcher.go create mode 100644 pkg/agent/utils/node/patcher_test.go create mode 100644 pkg/agent/utils/node/resource.go create mode 100644 pkg/agent/utils/node/taints.go create mode 100644 pkg/agent/utils/pod/pod.go create mode 100644 pkg/agent/utils/pod/resources.go create mode 100644 pkg/agent/utils/pod/resources_test.go create mode 100644 pkg/agent/utils/testing/pod.go create mode 100644 pkg/agent/utils/utils.go create mode 100644 pkg/agent/utils/utils_test.go create mode 100644 pkg/agent/utils/version/compare.go create mode 100644 pkg/agent/utils/version/compare_test.go create mode 100644 pkg/config/config.go create mode 100644 pkg/config/config_test.go create mode 100644 pkg/config/generic.go create mode 100644 pkg/config/informerfactory.go create mode 100644 pkg/metriccollect/collectmgr.go create mode 100644 pkg/metriccollect/framework/interface.go create mode 100644 pkg/metriccollect/framework/registry.go create mode 100644 pkg/metriccollect/local/cpu.go create mode 100644 pkg/metriccollect/local/local_collector.go create mode 100644 pkg/metriccollect/local/memory.go create mode 100644 pkg/metriccollect/testing/fake_local_collector.go create mode 100644 pkg/metriccollect/testing/fake_sub_collector_cpu.go create mode 100644 pkg/metriccollect/testing/fake_sub_collector_memory.go create mode 100644 pkg/networkqos/api/cni.go create mode 100644 pkg/networkqos/api/ebpf_map.go create mode 100644 pkg/networkqos/cni/config.go create mode 100644 pkg/networkqos/cni/config_test.go create mode 100644 pkg/networkqos/cni/mocks/mock_config.go create mode 100644 pkg/networkqos/networkqos.go create mode 100644 pkg/networkqos/networkqos_test.go create mode 100644 pkg/networkqos/tc/mocks/mock_tc.go create mode 100644 pkg/networkqos/tc/tc.go create mode 100644 pkg/networkqos/tc/tc_linux.go create mode 100644 pkg/networkqos/tc/tc_unspecified.go create mode 100644 pkg/networkqos/throttling/mocks/mock_throttling.go create mode 100644 pkg/networkqos/throttling/throttling.go create mode 100644 pkg/networkqos/throttling/throttling_test.go create mode 100644 pkg/networkqos/utils/ebpf/map.go create mode 100644 pkg/networkqos/utils/ebpf/map_test.go create mode 100644 pkg/networkqos/utils/ebpf/mocks/mock_map.go create mode 100644 pkg/networkqos/utils/utils.go create mode 100644 pkg/networkqos/utils/utils_test.go create mode 100644 pkg/resourceusage/fake_resource_usage_getter.go create mode 100644 pkg/resourceusage/resource_usage_getter.go create mode 100644 pkg/resourceusage/resource_usage_getter_test.go diff --git a/cmd/agent/app/agent.go b/cmd/agent/app/agent.go new file mode 100644 index 000000000..5abd210a4 --- /dev/null +++ b/cmd/agent/app/agent.go @@ -0,0 +1,95 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package app + +import ( + "context" + "fmt" + "os" + "path" + "strings" + + "github.com/spf13/cobra" + cliflag "k8s.io/component-base/cli/flag" + "k8s.io/component-base/cli/globalflag" + "k8s.io/klog/v2" + + "volcano.sh/volcano/cmd/agent/app/options" + "volcano.sh/volcano/pkg/agent/events" + "volcano.sh/volcano/pkg/agent/healthcheck" + "volcano.sh/volcano/pkg/agent/utils" + "volcano.sh/volcano/pkg/agent/utils/cgroup" + "volcano.sh/volcano/pkg/metriccollect" + "volcano.sh/volcano/pkg/networkqos" +) + +func NewVolcanoAgentCommand(ctx context.Context) *cobra.Command { + opts := options.NewVolcanoAgentOptions() + cmd := &cobra.Command{ + Use: "volcano-agent", + Long: `volcano-agent.`, + Run: func(cmd *cobra.Command, args []string) { + cliflag.PrintFlags(cmd.Flags()) + if err := Run(ctx, opts); err != nil { + _, _ = fmt.Fprintf(os.Stderr, "%v\n", err) + os.Exit(1) + } + }, + } + + opts.AddFlags(cmd) + globalflag.AddGlobalFlags(cmd.Flags(), cmd.Name()) + return cmd +} + +func Run(ctx context.Context, opts *options.VolcanoAgentOptions) error { + klog.InfoS("Start volcano agent") + conf, err := NewConfiguration(opts) + if err != nil { + return fmt.Errorf("failed to create volcano-agent configuration: %v", err) + } + + // TODO: get cgroup driver dynamically + sfsFsPath := strings.TrimSpace(os.Getenv(utils.SysFsPathEnv)) + if sfsFsPath == "" { + sfsFsPath = utils.DefaultSysFsPath + } + cgroupManager := cgroup.NewCgroupManager("cgroupfs", path.Join(sfsFsPath, "cgroup"), conf.GenericConfiguration.KubeCgroupRoot) + metricCollectorManager, err := metriccollect.NewMetricCollectorManager(conf, cgroupManager) + if err != nil { + return fmt.Errorf("failed to create metric collector manager: %v", err) + } + + networkQoSMgr := networkqos.NewNetworkQoSManager(conf) + err = networkQoSMgr.Init() + if err != nil { + return fmt.Errorf("failed to init network qos: %v", err) + } + + eventManager := events.NewEventManager(conf, metricCollectorManager, cgroupManager) + err = eventManager.Run(ctx) + if err != nil { + return fmt.Errorf("failed to run event manager: %v", err) + } + + conf.InformerFactory.K8SInformerFactory.Start(ctx.Done()) + RunServer(healthcheck.NewHealthChecker(networkQoSMgr), conf.GenericConfiguration.HealthzAddress, conf.GenericConfiguration.HealthzPort) + klog.InfoS("Volcano volcano-agent started") + <-ctx.Done() + klog.InfoS("Volcano volcano-agent stopped") + return nil +} diff --git a/cmd/agent/app/app.go b/cmd/agent/app/app.go new file mode 100644 index 000000000..c2982a778 --- /dev/null +++ b/cmd/agent/app/app.go @@ -0,0 +1,91 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package app + +import ( + "fmt" + "net" + "net/http" + "strconv" + + "github.com/prometheus/client_golang/prometheus/promhttp" + corev1 "k8s.io/api/core/v1" + clientset "k8s.io/client-go/kubernetes" + "k8s.io/client-go/kubernetes/scheme" + typedv1 "k8s.io/client-go/kubernetes/typed/core/v1" + restclient "k8s.io/client-go/rest" + "k8s.io/client-go/tools/record" + "k8s.io/controller-manager/pkg/clientbuilder" + "k8s.io/klog/v2" + + "volcano.sh/volcano/cmd/agent/app/options" + "volcano.sh/volcano/pkg/agent/healthcheck" + "volcano.sh/volcano/pkg/agent/utils" + "volcano.sh/volcano/pkg/config" +) + +func NewConfiguration(opts *options.VolcanoAgentOptions) (*config.Configuration, error) { + conf := config.NewConfiguration() + if err := opts.Validate(); err != nil { + return conf, err + } + if err := opts.ApplyTo(conf); err != nil { + return conf, err + } + + kubeConfig, err := restclient.InClusterConfig() + if err != nil { + return conf, fmt.Errorf("failed to create kubeconfig: %v", err) + } + + kubeClient, err := clientset.NewForConfig(restclient.AddUserAgent(kubeConfig, utils.Component)) + if err != nil { + return conf, fmt.Errorf("failed to create kubeclient: %v", err) + } + conf.GenericConfiguration.KubeClient = kubeClient + + broadcaster := record.NewBroadcaster() + broadcaster.StartLogging(klog.Infof) + broadcaster.StartStructuredLogging(2) + broadcaster.StartRecordingToSink(&typedv1.EventSinkImpl{Interface: kubeClient.CoreV1().Events("")}) + recorder := broadcaster.NewRecorder(scheme.Scheme, corev1.EventSource{Component: "volcano-agent"}) + conf.GenericConfiguration.Recorder = recorder + + rootClientBuilder := clientbuilder.SimpleControllerClientBuilder{ + ClientConfig: kubeConfig, + } + versionedClient := rootClientBuilder.ClientOrDie("shared-informers") + conf.Complete(versionedClient) + return conf, nil +} + +// RunServer will run both health check and metrics server. +func RunServer(checker healthcheck.HealthChecker, address string, port int) { + go func() { + klog.InfoS("Start http health check server") + mux := http.NewServeMux() + mux.HandleFunc("/healthz", checker.HealthCheck) + mux.Handle("/metrics", promhttp.Handler()) + s := &http.Server{ + Addr: net.JoinHostPort(address, strconv.Itoa(port)), + Handler: mux, + } + if err := s.ListenAndServe(); err != nil { + klog.Fatalf("failed to start health check server: %v", err) + } + }() +} diff --git a/cmd/agent/app/options/options.go b/cmd/agent/app/options/options.go new file mode 100644 index 000000000..051a9a1de --- /dev/null +++ b/cmd/agent/app/options/options.go @@ -0,0 +1,105 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package options + +import ( + "fmt" + "os" + + "github.com/spf13/cobra" + + "volcano.sh/volcano/pkg/config" +) + +const ( + serverPort = 3300 + + defaultOverSubscriptionRatio = 60 +) + +type VolcanoAgentOptions struct { + // HealthzAddress is the health check server address + HealthzAddress string + + //HealthzPort is the health check server port + HealthzPort int + + // KubeCgroupRoot is the root cgroup to use for pods. + // If CgroupsPerQOS is enabled, this is the root of the QoS cgroup hierarchy. + KubeCgroupRoot string + + // KubeNodeName is the name of the node which controller is running. + KubeNodeName string + + // List of supported features, '*' supports all on-by-default features. + SupportedFeatures []string + + // KubePodName is the name of the pod. + KubePodName string + + // KubePodName is the namespace of the pod. + KubePodNamespace string + + // OverSubscriptionPolicy defines overSubscription policy. + OverSubscriptionPolicy string + + // OverSubscriptionRatio is the over subscription ratio of idle resources, default to 60, which means 60%. + OverSubscriptionRatio int + + // IncludeSystemUsage determines whether considering system usage when calculate overSubscription resource and evict. + IncludeSystemUsage bool +} + +func NewVolcanoAgentOptions() *VolcanoAgentOptions { + return &VolcanoAgentOptions{} +} + +func (options *VolcanoAgentOptions) AddFlags(c *cobra.Command) { + c.Flags().StringSliceVar(&options.SupportedFeatures, "supported-features", []string{"*"}, "List of supported features. '*' supports all on-by-default features, 'foo' feature named 'foo' is supported"+ + "'-foo' feature named 'foo' is not supported.") + c.Flags().StringVar(&options.HealthzAddress, "healthz-address", "", "defines the health check address") + c.Flags().IntVar(&options.HealthzPort, "healthz-port", serverPort, "defines the health check port") + c.Flags().StringVar(&options.KubeCgroupRoot, "kube-cgroup-root", options.KubeCgroupRoot, "kube cgroup root") + c.Flags().StringVar(&options.KubeNodeName, "kube-node-name", os.Getenv("KUBE_NODE_NAME"), "the related kube-node name of the host, where the pod run in") + c.Flags().StringVar(&options.KubePodName, "kube-pod-name", os.Getenv("KUBE_POD_NAME"), "the name of the pod") + c.Flags().StringVar(&options.KubePodNamespace, "kube-pod-namespace", os.Getenv("KUBE_POD_NAMESPACE"), "the namespace of the pod") + c.Flags().StringVar(&options.OverSubscriptionPolicy, "oversubscription-policy", "extend", "The oversubscription policy determines where oversubscription resources to report and how to use, default to extend means report to extend resources") + // TODO: put in configMap. + c.Flags().IntVar(&options.OverSubscriptionRatio, "oversubscription-ratio", defaultOverSubscriptionRatio, "The oversubscription ratio determines how many idle resources can be oversold") + c.Flags().BoolVar(&options.IncludeSystemUsage, "include-system-usage", false, "It determines whether considering system usage when calculate overSubscription resource and evict.") +} + +func (options *VolcanoAgentOptions) Validate() error { + if options.OverSubscriptionRatio <= 0 { + return fmt.Errorf("over subscription ratio must be greater than 0") + } + return nil +} + +func (options *VolcanoAgentOptions) ApplyTo(cfg *config.Configuration) error { + cfg.GenericConfiguration.HealthzAddress = options.HealthzAddress + cfg.GenericConfiguration.HealthzPort = options.HealthzPort + cfg.GenericConfiguration.KubeCgroupRoot = options.KubeCgroupRoot + cfg.GenericConfiguration.KubeNodeName = options.KubeNodeName + cfg.GenericConfiguration.SupportedFeatures = options.SupportedFeatures + cfg.GenericConfiguration.KubePodName = options.KubePodName + cfg.GenericConfiguration.KubePodNamespace = options.KubePodNamespace + cfg.GenericConfiguration.OverSubscriptionPolicy = options.OverSubscriptionPolicy + cfg.GenericConfiguration.OverSubscriptionRatio = options.OverSubscriptionRatio + cfg.GenericConfiguration.IncludeSystemUsage = options.IncludeSystemUsage + return nil +} diff --git a/cmd/agent/app/options/options_test.go b/cmd/agent/app/options/options_test.go new file mode 100644 index 000000000..c270de162 --- /dev/null +++ b/cmd/agent/app/options/options_test.go @@ -0,0 +1,53 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package options + +import "testing" + +func TestVolcanoAgentOptions_Validate(t *testing.T) { + tests := []struct { + name string + OverSubscriptionRatio int + wantErr bool + }{ + { + name: "over subscription ratio lower than 0", + OverSubscriptionRatio: -1, + wantErr: true, + }, + { + name: "over subscription ratio greater than 100", + OverSubscriptionRatio: 110, + wantErr: false, + }, + { + name: "valid over subscription ratio", + OverSubscriptionRatio: 80, + wantErr: false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + options := &VolcanoAgentOptions{ + OverSubscriptionRatio: tt.OverSubscriptionRatio, + } + if err := options.Validate(); (err != nil) != tt.wantErr { + t.Errorf("Validate() error = %v, wantErr %v", err, tt.wantErr) + } + }) + } +} diff --git a/cmd/agent/main.go b/cmd/agent/main.go new file mode 100644 index 000000000..24ece124a --- /dev/null +++ b/cmd/agent/main.go @@ -0,0 +1,40 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package main + +import ( + "fmt" + "os" + + "k8s.io/component-base/logs" + "sigs.k8s.io/controller-runtime/pkg/manager/signals" + + "volcano.sh/volcano/cmd/agent/app" +) + +func main() { + stopCtx := signals.SetupSignalHandler() + command := app.NewVolcanoAgentCommand(stopCtx) + + logs.InitLogs() + defer logs.FlushLogs() + + if err := command.Execute(); err != nil { + _, _ = fmt.Fprintf(os.Stderr, "%v\n", err) + os.Exit(1) + } +} diff --git a/cmd/network-qos/cni/cni.go b/cmd/network-qos/cni/cni.go new file mode 100644 index 000000000..813145c89 --- /dev/null +++ b/cmd/network-qos/cni/cni.go @@ -0,0 +1,179 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package cni + +import ( + "encoding/json" + "errors" + "fmt" + "os" + + cilliumbpf "github.com/cilium/ebpf" + "github.com/containernetworking/cni/pkg/skel" + cnitypes "github.com/containernetworking/cni/pkg/types" + cnitypesver "github.com/containernetworking/cni/pkg/types/100" + cniversion "github.com/containernetworking/cni/pkg/version" + "k8s.io/klog/v2" + + "volcano.sh/volcano/pkg/networkqos/api" + "volcano.sh/volcano/pkg/networkqos/tc" + "volcano.sh/volcano/pkg/networkqos/throttling" + "volcano.sh/volcano/pkg/networkqos/utils" +) + +func Execute() { + err := utils.InitLog(utils.CNILogFilePath) + if err != nil { + fmt.Printf("failed fo init log: %v\n", err) + } + + err = PluginMain() + if err != nil { + klog.Flush() + os.Exit(1) + } + + klog.Flush() + os.Exit(0) +} + +func PluginMain() error { + e := skel.PluginMainWithError( + func(args *skel.CmdArgs) error { + addErr := cmdAdd(args) + if addErr != nil { + return fmt.Errorf("CNI add request failed, ContainerID(%s) Netns(%s) IfName(%s) err: %v", args.ContainerID, args.Netns, args.IfName, addErr) + } + return nil + }, + func(args *skel.CmdArgs) error { + return nil + }, + func(args *skel.CmdArgs) error { + delErr := cmdDel(args) + if delErr != nil { + return fmt.Errorf("CNI delete request failed, ContainerID(%s) Netns(%s) IfName(%s) err: %v", args.ContainerID, args.Netns, args.IfName, delErr) + } + return nil + }, + cniversion.All, "CNI network-qos plugin") + + if e != nil { + klog.ErrorS(e, "Failed CNI request") + if err := e.Print(); err != nil { + klog.ErrorS(err, "Error writing error JSON to stdout: ", err) + } + return e + } + + return nil +} + +func cmdAdd(args *skel.CmdArgs) (err error) { + klog.InfoS("CNI add request received", "containerID", args.ContainerID, + "netns", args.Netns, "ifName", args.IfName, "args", args.Args, "path", args.Path, "stdinData", args.StdinData) + + k8sArgs := &api.K8sArgs{} + err = cnitypes.LoadArgs(args.Args, k8sArgs) + if err != nil { + return fmt.Errorf("failed to load k8s config from args: %v", err) + } + + confRequest := &api.NetConf{} + err = json.Unmarshal(args.StdinData, confRequest) + if err != nil { + return fmt.Errorf("failed to load net config from stdin data: %v", err) + } + + if err := cniversion.ParsePrevResult(&confRequest.NetConf); err != nil { + return fmt.Errorf("could not parse prevResult: %v", err) + } + + if confRequest.PrevResult == nil { + return fmt.Errorf("must be called as chained plugin") + } + + prevResult, err := cnitypesver.NewResultFromResult(confRequest.PrevResult) + if err != nil { + return fmt.Errorf("failed to convert prevResult: %v", err) + } + result := prevResult + + addErr := add(confRequest, args) + if addErr != nil { + return fmt.Errorf("failed to add cni: %v", addErr) + } + + err = cnitypes.PrintResult(result, confRequest.CNIVersion) + if err != nil { + return err + } + + klog.InfoS("CNI add request successfully", "containerID", args.ContainerID, + "netns", args.Netns, "ifName", args.IfName, "args", args.Args, "path", args.Path, "stdinData", args.StdinData) + return nil +} + +func add(confRequest *api.NetConf, args *skel.CmdArgs) error { + _, err := throttling.GetNetworkThrottlingConfig().GetThrottlingConfig() + if err != nil { + // restart the node ebpf map will be lost + if errors.Is(err, cilliumbpf.ErrKeyNotExist) || os.IsNotExist(err) { + if confRequest.Args[utils.NodeColocationEnable] == "true" { + _, err = throttling.GetNetworkThrottlingConfig().CreateThrottlingConfig(confRequest.Args[utils.OnlineBandwidthWatermarkKey], confRequest.Args[utils.OfflineLowBandwidthKey], + confRequest.Args[utils.OfflineHighBandwidthKey], confRequest.Args[utils.NetWorkQoSCheckInterval]) + if err != nil { + return err + } + } + } else { + return fmt.Errorf("failed to get throttling config: %v", err) + } + } + + support, err := tc.GetTCCmd().PreAddFilter(args.Netns, args.IfName) + if err != nil { + return fmt.Errorf("failed to set tc: %v", err) + } + if support { + err = tc.GetTCCmd().AddFilter(args.Netns, args.IfName) + if err != nil { + return fmt.Errorf("failed to set tc: %v", err) + } + } + return nil +} + +func cmdDel(args *skel.CmdArgs) error { + klog.InfoS("CNI delete request received", "containerID", args.ContainerID, + "netns", args.Netns, "ifName", args.IfName, "args", args.Args, "path", args.Path, "stdinData", args.StdinData) + + k8sArgs := &api.K8sArgs{} + err := cnitypes.LoadArgs(args.Args, k8sArgs) + if err != nil { + return fmt.Errorf("failed to load k8s config from args: %v", err) + } + + err = tc.GetTCCmd().RemoveFilter(args.Netns, args.IfName) + if err != nil { + return fmt.Errorf("failed to delete tc: %v", err) + } + + klog.InfoS("CNI delete request successfully", "containerID", args.ContainerID, + "netns", args.Netns, "ifName", args.IfName, "args", args.Args, "path", args.Path, "stdinData", args.StdinData) + return nil +} diff --git a/cmd/network-qos/cni/cni_test.go b/cmd/network-qos/cni/cni_test.go new file mode 100644 index 000000000..d9f24d53f --- /dev/null +++ b/cmd/network-qos/cni/cni_test.go @@ -0,0 +1,221 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package cni + +import ( + "fmt" + "os" + "testing" + + cilliumbpf "github.com/cilium/ebpf" + "github.com/containernetworking/cni/pkg/skel" + "github.com/golang/mock/gomock" + "github.com/stretchr/testify/assert" + + "volcano.sh/volcano/pkg/networkqos/api" + "volcano.sh/volcano/pkg/networkqos/tc" + mocktc "volcano.sh/volcano/pkg/networkqos/tc/mocks" + "volcano.sh/volcano/pkg/networkqos/throttling" + mockthrottling "volcano.sh/volcano/pkg/networkqos/throttling/mocks" +) + +var fileWithoutNetworkQos = `{ + "cniVersion": "0.3.1", + "name": "default-network", + "args": { + "check-interval": "10000000", + "offline-high-bandwidth": "50MB", + "offline-low-bandwidth": "20MB", + "colocation": "true", + "online-bandwidth-watermark": "50MB" + }, + "name": "network-qos", + "type": "network-qos", + "prevResult": { + "cniVersion":"0.3.1", + "ips":[{"version":"4","address":"10.3.3.190/17"}], + "dns":{} + } +}` + +func TestCmdAdd(t *testing.T) { + mockController := gomock.NewController(t) + defer mockController.Finish() + + mockTc := mocktc.NewMockTC(mockController) + tc.SetTcCmd(mockTc) + mockThr := mockthrottling.NewMockThrottlingConfig(mockController) + throttling.SetNetworkThrottlingConfig(mockThr) + + testCases := []struct { + name string + args *skel.CmdArgs + apiCall []*gomock.Call + expectedError bool + }{ + { + name: "add dev successful", + args: &skel.CmdArgs{ + Netns: "test-ns", + IfName: "eth0", + StdinData: []byte(fileWithoutNetworkQos), + }, + apiCall: []*gomock.Call{ + mockThr.EXPECT().GetThrottlingConfig().Return(&api.EbpfNetThrottlingConfig{ + Interval: 10000000, + WaterLine: 1000, + LowRate: 1000, + HighRate: 1000, + }, nil), + mockTc.EXPECT().PreAddFilter("test-ns", "eth0").Return(true, nil), + mockTc.EXPECT().AddFilter("test-ns", "eth0").Return(nil), + }, + expectedError: false, + }, + + { + name: "throttling conf map not exists && throttling enabled", + args: &skel.CmdArgs{ + Netns: "test-ns2", + IfName: "eth0", + StdinData: []byte(fileWithoutNetworkQos), + }, + apiCall: []*gomock.Call{ + mockThr.EXPECT().GetThrottlingConfig().Return(nil, cilliumbpf.ErrKeyNotExist), + mockThr.EXPECT().CreateThrottlingConfig("50MB", "20MB", "50MB", "10000000").Return(&api.EbpfNetThrottlingConfig{ + WaterLine: 1000, + LowRate: 1000, + HighRate: 1000, + Interval: 10000000, + }, nil), + mockTc.EXPECT().PreAddFilter("test-ns2", "eth0").Return(true, nil), + mockTc.EXPECT().AddFilter("test-ns2", "eth0").Return(nil), + }, + expectedError: false, + }, + + { + name: "throttling conf map pinned file not exists && throttling enabled", + args: &skel.CmdArgs{ + Netns: "test-ns3", + IfName: "eth0", + StdinData: []byte(fileWithoutNetworkQos), + }, + apiCall: []*gomock.Call{ + mockThr.EXPECT().GetThrottlingConfig().Return(nil, os.ErrNotExist), + mockThr.EXPECT().CreateThrottlingConfig("50MB", "20MB", "50MB", "10000000").Return(&api.EbpfNetThrottlingConfig{ + WaterLine: 1000, + LowRate: 1000, + HighRate: 1000, + Interval: 10000000, + }, nil), + mockTc.EXPECT().PreAddFilter("test-ns3", "eth0").Return(true, nil), + mockTc.EXPECT().AddFilter("test-ns3", "eth0").Return(nil), + }, + expectedError: false, + }, + + { + name: "throttling conf map pinned file not exists && throttling enabled && create conf map failed", + args: &skel.CmdArgs{ + Netns: "test-ns4", + IfName: "eth0", + StdinData: []byte(fileWithoutNetworkQos), + }, + apiCall: []*gomock.Call{ + mockThr.EXPECT().GetThrottlingConfig().Return(nil, os.ErrNotExist), + mockThr.EXPECT().CreateThrottlingConfig("50MB", "20MB", "50MB", "10000000").Return(nil, fmt.Errorf("create failed")), + }, + expectedError: true, + }, + + { + name: "add tc filter failed", + args: &skel.CmdArgs{ + Netns: "test-ns5", + IfName: "eth0", + StdinData: []byte(fileWithoutNetworkQos), + }, + apiCall: []*gomock.Call{ + mockThr.EXPECT().GetThrottlingConfig().Return(nil, os.ErrNotExist), + mockThr.EXPECT().CreateThrottlingConfig("50MB", "20MB", "50MB", "10000000").Return(&api.EbpfNetThrottlingConfig{ + WaterLine: 1000, + LowRate: 1000, + HighRate: 1000, + Interval: 10000000, + }, nil), + mockTc.EXPECT().PreAddFilter("test-ns5", "eth0").Return(true, nil), + mockTc.EXPECT().AddFilter("test-ns5", "eth0").Return(fmt.Errorf("add failed")), + }, + expectedError: true, + }, + } + + for _, tc := range testCases { + gomock.InOrder(tc.apiCall...) + actualErr := cmdAdd(tc.args) + assert.Equal(t, tc.expectedError, actualErr != nil, tc.name, actualErr) + } +} + +func TestCmdDel(t *testing.T) { + mockController := gomock.NewController(t) + defer mockController.Finish() + + mockTc := mocktc.NewMockTC(mockController) + tc.SetTcCmd(mockTc) + + testCases := []struct { + name string + args *skel.CmdArgs + apiCall []*gomock.Call + expectedError bool + }{ + + { + name: "delete dev successful", + args: &skel.CmdArgs{ + Netns: "test-ns", + IfName: "eth0", + StdinData: []byte(fileWithoutNetworkQos), + }, + apiCall: []*gomock.Call{ + mockTc.EXPECT().RemoveFilter("test-ns", "eth0").Return(nil), + }, + expectedError: false, + }, + + { + name: "delete tc filter failed", + args: &skel.CmdArgs{ + Netns: "test-ns2", + IfName: "eth0", + StdinData: []byte(fileWithoutNetworkQos), + }, + apiCall: []*gomock.Call{ + mockTc.EXPECT().RemoveFilter("test-ns2", "eth0").Return(fmt.Errorf("delete failed")), + }, + expectedError: true, + }, + } + + for _, tc := range testCases { + gomock.InOrder(tc.apiCall...) + actualErr := cmdDel(tc.args) + assert.Equal(t, tc.expectedError, actualErr != nil, tc.name, actualErr) + } +} diff --git a/cmd/network-qos/main.go b/cmd/network-qos/main.go new file mode 100644 index 000000000..5fe563698 --- /dev/null +++ b/cmd/network-qos/main.go @@ -0,0 +1,33 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package main + +import ( + "os" + + "volcano.sh/volcano/cmd/network-qos/cni" + "volcano.sh/volcano/cmd/network-qos/tools" +) + +func main() { + switch os.Getenv("CNI_COMMAND") { + case "": + tools.Execute() + default: + cni.Execute() + } +} diff --git a/cmd/network-qos/tools/get.go b/cmd/network-qos/tools/get.go new file mode 100644 index 000000000..6a2163c38 --- /dev/null +++ b/cmd/network-qos/tools/get.go @@ -0,0 +1,85 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package tools + +import ( + "encoding/json" + "errors" + "fmt" + "io" + "os" + "strconv" + + cilliumbpf "github.com/cilium/ebpf" + "github.com/spf13/cobra" + "k8s.io/klog/v2" + + "volcano.sh/volcano/pkg/networkqos/api" + "volcano.sh/volcano/pkg/networkqos/throttling" + "volcano.sh/volcano/pkg/networkqos/utils" +) + +type getCmd struct { + out io.Writer + errOut io.Writer +} + +func newGetCmd(out io.Writer, errOut io.Writer) *cobra.Command { + get := &getCmd{ + out: out, + errOut: errOut, + } + + return &cobra.Command{ + Use: "show", + Short: "Show online-bandwidth-watermark/offline-low-bandwidth/offline-high-bandwidth config values in ebpf map", + Long: `Show online-bandwidth-watermark/offline-low-bandwidth/offline-high-bandwidth config values in ebpf map`, + Run: func(cmd *cobra.Command, args []string) { + klog.InfoS("Network QoS command called", "command", "show") + err := get.run() + if err != nil { + utils.Error(get.errOut, cmd, err) + } + }, + } +} + +func (c *getCmd) run() (err error) { + config, err := throttling.GetNetworkThrottlingConfig().GetThrottlingConfig() + if err != nil { + if errors.Is(err, cilliumbpf.ErrKeyNotExist) || os.IsNotExist(err) { + return fmt.Errorf("failed to get throttling config: %v, network qos has not been initialized, please enable network qos first", err) + } + return fmt.Errorf("failed to get throttling config: %v", err) + } + + configResult := &api.EbpfNetThrottlingConfGetResult{ + WaterLine: strconv.FormatUint(config.WaterLine*8, 10) + "bps", + Interval: config.Interval, + LowRate: strconv.FormatUint(config.LowRate*8, 10) + "bps", + HighRate: strconv.FormatUint(config.HighRate*8, 10) + "bps", + } + + throttlingConfig, err := json.Marshal(configResult) + if err != nil { + return fmt.Errorf("failed to marshal throttling config %v to json: %v", config, err) + } + + fmt.Fprintf(c.out, "%s: %s\n", "network-qos config", throttlingConfig) + klog.InfoS("Network QoS command called successfully", "command", "show", "throttling-config", throttlingConfig) + return nil +} diff --git a/cmd/network-qos/tools/get_test.go b/cmd/network-qos/tools/get_test.go new file mode 100644 index 000000000..575dcd5b2 --- /dev/null +++ b/cmd/network-qos/tools/get_test.go @@ -0,0 +1,115 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package tools + +import ( + "bytes" + "encoding/json" + "fmt" + "os" + "testing" + + "github.com/agiledragon/gomonkey/v2" + "github.com/golang/mock/gomock" + "github.com/stretchr/testify/assert" + + "volcano.sh/volcano/pkg/networkqos/api" + "volcano.sh/volcano/pkg/networkqos/throttling" + mockthrottling "volcano.sh/volcano/pkg/networkqos/throttling/mocks" +) + +func TestGetCmdExecute(t *testing.T) { + mockController := gomock.NewController(t) + defer mockController.Finish() + + mockThr := mockthrottling.NewMockThrottlingConfig(mockController) + throttling.SetNetworkThrottlingConfig(mockThr) + + testCases := []struct { + name string + apiCall []*gomock.Call + jsonMarshalErr error + expectedOut string + expectedErrOut string + expectedOsExitCalled bool + }{ + { + name: "[show] json Marshal failed", + apiCall: []*gomock.Call{ + mockThr.EXPECT().GetThrottlingConfig().Return(&api.EbpfNetThrottlingConfig{ + Interval: 10000000, + WaterLine: 2000, + LowRate: 3000, + HighRate: 4000, + }, nil), + }, + jsonMarshalErr: fmt.Errorf("json marshal failed"), + expectedErrOut: `execute command[show] failed, error:failed to marshal throttling config &{2000 10000000 3000 4000} to json: json marshal failed` + "\n", + expectedOsExitCalled: true, + }, + + { + name: "[show] get conf successfully", + apiCall: []*gomock.Call{ + mockThr.EXPECT().GetThrottlingConfig().Return(&api.EbpfNetThrottlingConfig{ + Interval: 10000000, + WaterLine: 1500, + LowRate: 2500, + HighRate: 3500, + }, nil), + }, + expectedOut: `network-qos config: {"online_bandwidth_watermark":"12000bps","interval":10000000,"offline_low_bandwidth":"20000bps","offline_high_bandwidth":"28000bps"}` + "\n", + }, + + { + name: "[show] get conf failed", + apiCall: []*gomock.Call{ + mockThr.EXPECT().GetThrottlingConfig().Return(nil, fmt.Errorf("request failed")), + }, + expectedErrOut: `execute command[show] failed, error:failed to get throttling config: request failed` + "\n", + expectedOsExitCalled: true, + }, + } + + exitCalled := false + getPatch := gomonkey.NewPatches() + getPatch.ApplyFunc(os.Exit, func(code int) { + exitCalled = true + }) + defer getPatch.Reset() + + for _, tc := range testCases { + exitCalled = false + var jsonMarshalPatch *gomonkey.Patches + if tc.jsonMarshalErr != nil { + jsonMarshalPatch = gomonkey.NewPatches() + jsonMarshalPatch.ApplyFunc(json.Marshal, func(v interface{}) ([]byte, error) { + return nil, tc.jsonMarshalErr + }) + } + out := &bytes.Buffer{} + errOut := &bytes.Buffer{} + cmd := newGetCmd(out, errOut) + cmd.Execute() + if jsonMarshalPatch != nil { + jsonMarshalPatch.Reset() + } + assert.Equal(t, tc.expectedOsExitCalled, exitCalled, tc.name) + assert.Equal(t, tc.expectedOut, out.String(), tc.name) + assert.Equal(t, tc.expectedErrOut, errOut.String(), tc.name) + } +} diff --git a/cmd/network-qos/tools/options/options.go b/cmd/network-qos/tools/options/options.go new file mode 100644 index 000000000..1400a9adc --- /dev/null +++ b/cmd/network-qos/tools/options/options.go @@ -0,0 +1,43 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package options + +import ( + "github.com/spf13/cobra" + + "volcano.sh/volcano/pkg/networkqos/utils" +) + +type Options struct { + CheckoutInterval string + OnlineBandwidthWatermark string + OfflineLowBandwidth string + OfflineHighBandwidth string + EnableNetworkQoS bool +} + +// AddFlags is responsible for add flags from the given FlagSet instance for current GenericOptions. +func (o *Options) AddFlags(c *cobra.Command) { + c.Flags().StringVar(&o.CheckoutInterval, utils.NetWorkQoSCheckInterval, o.CheckoutInterval, "check interval is the interval of checking and updating the offline jobs bandwidth limit") + c.Flags().StringVar(&o.OnlineBandwidthWatermark, utils.OnlineBandwidthWatermarkKey, o.OnlineBandwidthWatermark, "online-bandwidth-watermark is is the bandwidth threshold of online jobs, "+ + "is the sum of bandwidth of all online pods") + c.Flags().StringVar(&o.OfflineLowBandwidth, utils.OfflineLowBandwidthKey, o.OfflineLowBandwidth, "offline-low-bandwidth is the maximum amount of network bandwidth that can be used by offline jobs when the"+ + "bandwidth usage of online jobs exceeds the defined threshold(online-bandwidth-watermark)") + c.Flags().StringVar(&o.OfflineHighBandwidth, utils.OfflineHighBandwidthKey, o.OfflineHighBandwidth, "offline-high-bandwidth is the maximum amount of network bandwidth that can be used by offline jobs when the"+ + "bandwidth usage of online jobs not reach to the defined threshold(online-bandwidth-watermark)") + c.Flags().BoolVar(&o.EnableNetworkQoS, utils.EnableNetworkQoS, o.EnableNetworkQoS, "enbale networkqos") +} diff --git a/cmd/network-qos/tools/options/options_test.go b/cmd/network-qos/tools/options/options_test.go new file mode 100644 index 000000000..d3ec26fde --- /dev/null +++ b/cmd/network-qos/tools/options/options_test.go @@ -0,0 +1,57 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package options + +import ( + "testing" + + "github.com/spf13/cobra" + "github.com/stretchr/testify/assert" +) + +func TestAddFlags(t *testing.T) { + testCases := []struct { + name string + args []string + opts *Options + expectedOptions *Options + expectedErr bool + }{ + { + name: "test set flags", + args: []string{"--check-interval=20000", "--online-bandwidth-watermark=500Mbps", "--offline-low-bandwidth=300Mbps", "--offline-high-bandwidth=700Mbps"}, + opts: &Options{}, + expectedOptions: &Options{ + CheckoutInterval: "20000", + OnlineBandwidthWatermark: "500Mbps", + OfflineLowBandwidth: "300Mbps", + OfflineHighBandwidth: "700Mbps", + }, + expectedErr: false, + }, + } + + for _, tc := range testCases { + cmds := &cobra.Command{} + tc.opts.AddFlags(cmds) + parseErr := cmds.Flags().Parse(tc.args) + if parseErr != nil { + t.Errorf("unexpected parse err: %v", parseErr) + } + assert.Equal(t, tc.expectedOptions, tc.opts, tc.name) + } +} diff --git a/cmd/network-qos/tools/prepare.go b/cmd/network-qos/tools/prepare.go new file mode 100644 index 000000000..9b40b67fe --- /dev/null +++ b/cmd/network-qos/tools/prepare.go @@ -0,0 +1,133 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package tools + +import ( + "context" + "fmt" + "io" + "os" + "strings" + "time" + + "github.com/spf13/cobra" + "k8s.io/klog/v2" + + "volcano.sh/volcano/pkg/agent/utils/exec" + "volcano.sh/volcano/pkg/networkqos/cni" + "volcano.sh/volcano/pkg/networkqos/utils" +) + +type prepareCmd struct { + out io.Writer + errOut io.Writer +} + +func newPrepareCmd(out io.Writer, errOut io.Writer) *cobra.Command { + prepare := &prepareCmd{ + out: out, + errOut: errOut, + } + + cmd := &cobra.Command{ + Use: "prepare", + Short: "prepare online-bandwidth-watermark/offline-low-bandwidth/offline-high-bandwidth values", + Long: "prepare online-bandwidth-watermark/offline-low-bandwidth/offline-high-bandwidth values", + Run: func(cmd *cobra.Command, args []string) { + klog.InfoS("Network QoS command called", "command", "prepare") + err := prepare.run() + if err != nil { + utils.Error(prepare.errOut, cmd, err) + return + } + }, + } + (&opt).AddFlags(cmd) + return cmd +} + +func (c *prepareCmd) run() (err error) { + enableNetworkQoS := opt.EnableNetworkQoS + onlineBandwidthWatermark, offlineLowBandwidth, offlineHighBandwidth, interval := opt.OnlineBandwidthWatermark, + opt.OfflineLowBandwidth, opt.OfflineHighBandwidth, opt.CheckoutInterval + + if !enableNetworkQoS { + return c.unInstall() + } + + return c.install(onlineBandwidthWatermark, offlineLowBandwidth, offlineHighBandwidth, interval) +} + +func (c *prepareCmd) unInstall() error { + ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + cmd := fmt.Sprintf(utils.NetWorkCmdFile + " reset") + output, err := exec.GetExecutor().CommandContext(ctx, cmd) + if err != nil { + return fmt.Errorf("failed to reset network qos:%v, output:%s", err, output) + } + + cniConfFile := strings.TrimSpace(os.Getenv(utils.CNIConfFilePathEnv)) + if cniConfFile == "" { + cniConfFile = utils.DefaultCNIConfFile + } + err = cni.GetCNIPluginConfHandler().DeleteCniPluginFromConfList(cniConfFile, utils.CNIPluginName) + if err != nil { + return fmt.Errorf("failed to reset cni config: %v", err) + } + klog.InfoS("Network QoS command called successfully", "command", "prepare[uninstall]") + return nil +} + +func (c *prepareCmd) install(onlineBandwidthWatermark, offlineLowBandwidth, offlineHighBandwidth, interval string) error { + if len(interval) == 0 { + interval = utils.DefaultInterval + } + + ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + cmd := fmt.Sprintf(utils.NetWorkCmdFile+" set --%s=%s --%s=%s --%s=%s --%s=%s", utils.OnlineBandwidthWatermarkKey, onlineBandwidthWatermark, + utils.OfflineLowBandwidthKey, offlineLowBandwidth, + utils.OfflineHighBandwidthKey, offlineHighBandwidth, + utils.NetWorkQoSCheckInterval, interval) + output, err := exec.GetExecutor().CommandContext(ctx, cmd) + if err != nil { + return fmt.Errorf("failed to set network qos:%v, output:%s", err, output) + } + + cniConf := make(map[string]interface{}) + cniConf["name"] = utils.CNIPluginName + cniConf["type"] = utils.CNIPluginName + cniConf["args"] = map[string]string{ + utils.NodeColocationEnable: "true", + utils.NetWorkQoSCheckInterval: interval, + utils.OnlineBandwidthWatermarkKey: onlineBandwidthWatermark, + utils.OfflineLowBandwidthKey: offlineLowBandwidth, + utils.OfflineHighBandwidthKey: offlineHighBandwidth, + } + + cniConfFile := strings.TrimSpace(os.Getenv(utils.CNIConfFilePathEnv)) + if cniConfFile == "" { + cniConfFile = utils.DefaultCNIConfFile + } + err = cni.GetCNIPluginConfHandler().AddOrUpdateCniPluginToConfList(cniConfFile, utils.CNIPluginName, cniConf) + if err != nil { + return fmt.Errorf("failed to add/update cni plugin to configlist: %v", err) + } + klog.InfoS("Network QoS command called successfully", "command", "prepare[install]", "cni-conf", cniConf) + return nil +} diff --git a/cmd/network-qos/tools/prepare_test.go b/cmd/network-qos/tools/prepare_test.go new file mode 100644 index 000000000..1e717f66a --- /dev/null +++ b/cmd/network-qos/tools/prepare_test.go @@ -0,0 +1,198 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package tools + +import ( + "bytes" + "fmt" + "testing" + + "github.com/golang/mock/gomock" + "github.com/stretchr/testify/assert" + + "volcano.sh/volcano/pkg/agent/utils/exec" + mockexec "volcano.sh/volcano/pkg/agent/utils/exec/mocks" + "volcano.sh/volcano/pkg/networkqos/cni" + mockcni "volcano.sh/volcano/pkg/networkqos/cni/mocks" + "volcano.sh/volcano/pkg/networkqos/utils" +) + +func TestUnInstall(t *testing.T) { + mockController := gomock.NewController(t) + defer mockController.Finish() + + mockExec := mockexec.NewMockExecInterface(mockController) + exec.SetExecutor(mockExec) + mockCniConf := mockcni.NewMockCNIPluginsConfHandler(mockController) + cni.SetCNIPluginConfHandler(mockCniConf) + + out := &bytes.Buffer{} + errOut := &bytes.Buffer{} + cmd := &prepareCmd{ + out: out, + errOut: errOut, + } + + testCases := []struct { + name string + apiCall []*gomock.Call + expectedError bool + }{ + { + name: "[prepare uninstall] network-qos reset failed", + apiCall: []*gomock.Call{ + mockExec.EXPECT().CommandContext(gomock.Any(), utils.NetWorkCmdFile+" reset").Return("", fmt.Errorf("fake error")), + }, + expectedError: true, + }, + + { + name: "[prepare uninstall] update cni plugin conf failed", + apiCall: []*gomock.Call{ + mockExec.EXPECT().CommandContext(gomock.Any(), utils.NetWorkCmdFile+" reset").Return("", nil), + mockCniConf.EXPECT().DeleteCniPluginFromConfList(utils.DefaultCNIConfFile, utils.CNIPluginName).Return(fmt.Errorf("fake error")), + }, + expectedError: true, + }, + { + name: "[prepare uninstall] uninstall successfully", + apiCall: []*gomock.Call{ + mockExec.EXPECT().CommandContext(gomock.Any(), utils.NetWorkCmdFile+" reset").Return("", nil), + mockCniConf.EXPECT().DeleteCniPluginFromConfList(utils.DefaultCNIConfFile, utils.CNIPluginName).Return(nil), + }, + expectedError: false, + }, + } + + for _, tc := range testCases { + actualErr := cmd.unInstall() + assert.Equal(t, tc.expectedError, actualErr != nil, tc.name) + } +} + +func TestInstall(t *testing.T) { + mockController := gomock.NewController(t) + defer mockController.Finish() + + mockExec := mockexec.NewMockExecInterface(mockController) + exec.SetExecutor(mockExec) + mockCniConf := mockcni.NewMockCNIPluginsConfHandler(mockController) + cni.SetCNIPluginConfHandler(mockCniConf) + + cmd := &prepareCmd{} + + testCases := []struct { + name string + onlineBandwidthWatermark string + offlineLowBandwidth string + offlineHighBandwidth string + interval string + apiCall []*gomock.Call + expectedError bool + }{ + { + name: "[prepare install] network QoS enable && empty check-interval", + interval: "", + onlineBandwidthWatermark: "5000Mbps", + offlineLowBandwidth: "2500Mbps", + offlineHighBandwidth: "3500Mbps", + apiCall: []*gomock.Call{ + mockExec.EXPECT().CommandContext(gomock.Any(), utils.NetWorkCmdFile+" set --online-bandwidth-watermark=5000Mbps "+ + "--offline-low-bandwidth=2500Mbps --offline-high-bandwidth=3500Mbps --check-interval=10000000").Return("", nil), + mockCniConf.EXPECT().AddOrUpdateCniPluginToConfList(utils.DefaultCNIConfFile, utils.CNIPluginName, map[string]interface{}{ + "name": "network-qos", + "type": "network-qos", + "args": map[string]string{ + utils.NetWorkQoSCheckInterval: "10000000", + utils.NodeColocationEnable: "true", + utils.OnlineBandwidthWatermarkKey: "5000Mbps", + utils.OfflineLowBandwidthKey: "2500Mbps", + utils.OfflineHighBandwidthKey: "3500Mbps", + }, + }).Return(nil), + }, + expectedError: false, + }, + + { + name: "[prepare install] network QoS enable", + interval: "20000000", + onlineBandwidthWatermark: "10000Mbps", + offlineLowBandwidth: "2000Mbps", + offlineHighBandwidth: "5000Mbps", + + apiCall: []*gomock.Call{ + mockExec.EXPECT().CommandContext(gomock.Any(), utils.NetWorkCmdFile+" set --online-bandwidth-watermark=10000Mbps "+ + "--offline-low-bandwidth=2000Mbps --offline-high-bandwidth=5000Mbps --check-interval=20000000").Return("", nil), + mockCniConf.EXPECT().AddOrUpdateCniPluginToConfList(utils.DefaultCNIConfFile, utils.CNIPluginName, map[string]interface{}{ + "name": "network-qos", + "type": "network-qos", + "args": map[string]string{ + utils.NetWorkQoSCheckInterval: "20000000", + utils.NodeColocationEnable: "true", + utils.OnlineBandwidthWatermarkKey: "10000Mbps", + utils.OfflineLowBandwidthKey: "2000Mbps", + utils.OfflineHighBandwidthKey: "5000Mbps", + }, + }).Return(nil), + }, + expectedError: false, + }, + + { + name: "[prepare install] colocation set failed", + interval: "", + onlineBandwidthWatermark: "900Mbps", + offlineLowBandwidth: "550Mbps", + offlineHighBandwidth: "750Mbps", + apiCall: []*gomock.Call{ + mockExec.EXPECT().CommandContext(gomock.Any(), utils.NetWorkCmdFile+" set --online-bandwidth-watermark=900Mbps "+ + "--offline-low-bandwidth=550Mbps --offline-high-bandwidth=750Mbps --check-interval=10000000").Return("", fmt.Errorf("fake error")), + }, + expectedError: true, + }, + + { + name: "[prepare install] update cni config failed", + interval: "30000000", + onlineBandwidthWatermark: "30000Mbps", + offlineLowBandwidth: "5500Mbps", + offlineHighBandwidth: "7500Mbps", + apiCall: []*gomock.Call{ + mockExec.EXPECT().CommandContext(gomock.Any(), utils.NetWorkCmdFile+" set --online-bandwidth-watermark=30000Mbps "+ + "--offline-low-bandwidth=5500Mbps --offline-high-bandwidth=7500Mbps --check-interval=30000000").Return("", nil), + mockCniConf.EXPECT().AddOrUpdateCniPluginToConfList(utils.DefaultCNIConfFile, utils.CNIPluginName, map[string]interface{}{ + "name": "network-qos", + "type": "network-qos", + "args": map[string]string{ + utils.NetWorkQoSCheckInterval: "30000000", + utils.NodeColocationEnable: "true", + utils.OnlineBandwidthWatermarkKey: "30000Mbps", + utils.OfflineLowBandwidthKey: "5500Mbps", + utils.OfflineHighBandwidthKey: "7500Mbps", + }, + }).Return(fmt.Errorf("fake error")), + }, + expectedError: true, + }, + } + + for _, tc := range testCases { + actualErr := cmd.install(tc.onlineBandwidthWatermark, tc.offlineLowBandwidth, tc.offlineHighBandwidth, tc.interval) + assert.Equal(t, tc.expectedError, actualErr != nil, tc.name, actualErr) + } +} diff --git a/cmd/network-qos/tools/reset.go b/cmd/network-qos/tools/reset.go new file mode 100644 index 000000000..e05c91cb4 --- /dev/null +++ b/cmd/network-qos/tools/reset.go @@ -0,0 +1,85 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package tools + +import ( + "encoding/json" + "errors" + "fmt" + "io" + "os" + "strconv" + + cilliumbpf "github.com/cilium/ebpf" + "github.com/spf13/cobra" + "k8s.io/klog/v2" + + "volcano.sh/volcano/pkg/networkqos/throttling" + "volcano.sh/volcano/pkg/networkqos/utils" +) + +type resetCmd struct { + out io.Writer + errOut io.Writer +} + +func newResetCmd(out io.Writer, errOut io.Writer) *cobra.Command { + reset := &resetCmd{ + out: out, + errOut: errOut, + } + + return &cobra.Command{ + Use: "reset", + Short: "Reset online-bandwidth-watermark/offline-low-bandwidth/offline-high-bandwidth values", + Long: "Reset online-bandwidth-watermark/offline-low-bandwidth/offline-high-bandwidth values", + Run: func(cmd *cobra.Command, args []string) { + klog.InfoS("Network QoS command called", "command", "reset") + err := reset.run() + if err != nil { + utils.Error(reset.errOut, cmd, err) + } + }, + } +} + +func (c *resetCmd) run() (err error) { + throttlingConf, err := throttling.GetNetworkThrottlingConfig().GetThrottlingConfig() + if err != nil { + if errors.Is(err, cilliumbpf.ErrKeyNotExist) || os.IsNotExist(err) { + fmt.Fprintf(c.out, "throttling config does not exist, reset successfully") + klog.InfoS("Network QoS command called successfully, throttling config does not exist") + return nil + } + return fmt.Errorf("failed to get throttling config: %v", err) + } + + throttlingConf, err = throttling.GetNetworkThrottlingConfig().CreateOrUpdateThrottlingConfig("", "1024Tibps", "1024Tibps", + strconv.FormatUint(throttlingConf.Interval, 10)) + if err != nil { + return fmt.Errorf("failed to update throttling config: %v", err) + } + + throttlingConfigBytes, err := json.Marshal(throttlingConf) + if err != nil { + return fmt.Errorf("failed to marshal throttling conf: %v to json %v", throttlingConf, err) + } + + fmt.Fprintf(c.out, "throttling config reset: %s\n", throttlingConfigBytes) + klog.InfoS("Network QoS command called successfully", "command", "reset", "throttling-conf", throttlingConfigBytes) + return nil +} diff --git a/cmd/network-qos/tools/reset_test.go b/cmd/network-qos/tools/reset_test.go new file mode 100644 index 000000000..60a5ae8be --- /dev/null +++ b/cmd/network-qos/tools/reset_test.go @@ -0,0 +1,162 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package tools + +import ( + "bytes" + "encoding/json" + "fmt" + "math" + "os" + "testing" + + "github.com/agiledragon/gomonkey/v2" + cilliumbpf "github.com/cilium/ebpf" + "github.com/golang/mock/gomock" + "github.com/stretchr/testify/assert" + + "volcano.sh/volcano/pkg/networkqos/api" + "volcano.sh/volcano/pkg/networkqos/throttling" + mockthrottling "volcano.sh/volcano/pkg/networkqos/throttling/mocks" +) + +func TestResetCmdRun(t *testing.T) { + mockController := gomock.NewController(t) + defer mockController.Finish() + + mockThr := mockthrottling.NewMockThrottlingConfig(mockController) + throttling.SetNetworkThrottlingConfig(mockThr) + + testCases := []struct { + name string + apiCall []*gomock.Call + jsonMarshalErr error + expectedOut string + expectedErrOut string + expectedOsExitCalled bool + }{ + { + name: "[reset] json Marshal failed", + apiCall: []*gomock.Call{ + mockThr.EXPECT().GetThrottlingConfig().Return(&api.EbpfNetThrottlingConfig{ + Interval: 10000000, + WaterLine: 1000, + LowRate: 200, + HighRate: 500, + }, nil), + mockThr.EXPECT().CreateOrUpdateThrottlingConfig("", "1024Tibps", "1024Tibps", "10000000").Return(&api.EbpfNetThrottlingConfig{ + Interval: 10000000, + WaterLine: math.MaxUint64, + LowRate: math.MaxUint64, + HighRate: math.MaxUint64, + }, + nil), + }, + jsonMarshalErr: fmt.Errorf("json marshal failed"), + expectedErrOut: `execute command[reset] failed, error:failed to marshal throttling conf: &{18446744073709551615 10000000 18446744073709551615 18446744073709551615} to json json marshal failed` + "\n", + expectedOsExitCalled: true, + }, + + { + name: "[reset] reset existed conf successfully", + apiCall: []*gomock.Call{ + mockThr.EXPECT().GetThrottlingConfig().Return(&api.EbpfNetThrottlingConfig{ + Interval: 10000000, + WaterLine: 2000, + LowRate: 800, + HighRate: 1200, + }, nil), + mockThr.EXPECT().CreateOrUpdateThrottlingConfig("", "1024Tibps", "1024Tibps", "10000000").Return(&api.EbpfNetThrottlingConfig{ + Interval: 10000000, + WaterLine: math.MaxUint64, + LowRate: math.MaxUint64, + HighRate: math.MaxUint64, + }, + nil), + }, + expectedOut: `throttling config reset: {"online_bandwidth_watermark":18446744073709551615,"interval":10000000,"offline_low_bandwidth":18446744073709551615,"offline_high_bandwidth":18446744073709551615}` + "\n", + }, + + { + name: "[reset] cni conf ebpf map not exists", + apiCall: []*gomock.Call{ + mockThr.EXPECT().GetThrottlingConfig().Return(nil, cilliumbpf.ErrKeyNotExist), + }, + expectedOut: `throttling config does not exist, reset successfully`, + }, + + { + name: "[reset] cni conf ebpf map pinned file not exists", + apiCall: []*gomock.Call{ + mockThr.EXPECT().GetThrottlingConfig().Return(nil, os.ErrNotExist), + }, + expectedOut: `throttling config does not exist, reset successfully`, + }, + + { + name: "[reset] get cni conf map failed", + apiCall: []*gomock.Call{ + mockThr.EXPECT().GetThrottlingConfig().Return(nil, fmt.Errorf("failed to get ebpf map")), + }, + expectedErrOut: `execute command[reset] failed, error:failed to get throttling config: failed to get ebpf map` + "\n", + expectedOsExitCalled: true, + }, + + { + name: "[reset] update cni conf map failed", + apiCall: []*gomock.Call{ + mockThr.EXPECT().GetThrottlingConfig().Return(&api.EbpfNetThrottlingConfig{ + Interval: 10000000, + WaterLine: 5000, + LowRate: 1000, + HighRate: 3000, + }, nil), + mockThr.EXPECT().CreateOrUpdateThrottlingConfig("", "1024Tibps", "1024Tibps", "10000000").Return(nil, fmt.Errorf("update failed")), + }, + expectedErrOut: `execute command[reset] failed, error:failed to update throttling config: update failed` + "\n", + expectedOsExitCalled: true, + }, + } + + exitCalled := false + resetPatch := gomonkey.NewPatches() + resetPatch.ApplyFunc(os.Exit, func(code int) { + exitCalled = true + }) + + for _, tc := range testCases { + exitCalled = false + var jsonMarPatch *gomonkey.Patches + if tc.jsonMarshalErr != nil { + jsonMarPatch = gomonkey.NewPatches() + jsonMarPatch.ApplyFunc(json.Marshal, func(v interface{}) ([]byte, error) { + return nil, tc.jsonMarshalErr + }) + } + + out := &bytes.Buffer{} + errOut := &bytes.Buffer{} + cmd := newResetCmd(out, errOut) + cmd.Execute() + if jsonMarPatch != nil { + jsonMarPatch.Reset() + } + assert.Equal(t, tc.expectedOsExitCalled, exitCalled, tc.name) + assert.Equal(t, tc.expectedOut, out.String(), tc.name) + assert.Equal(t, tc.expectedErrOut, errOut.String(), tc.name) + } +} diff --git a/cmd/network-qos/tools/root.go b/cmd/network-qos/tools/root.go new file mode 100644 index 000000000..dc437ca20 --- /dev/null +++ b/cmd/network-qos/tools/root.go @@ -0,0 +1,65 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package tools + +import ( + "fmt" + "os" + + "github.com/spf13/cobra" + "k8s.io/klog/v2" + + "volcano.sh/volcano/cmd/network-qos/tools/options" + "volcano.sh/volcano/pkg/networkqos/utils" +) + +var opt options.Options + +// Execute adds all child commands to the root command and sets flags appropriately. +// This is called by main.main(). It only needs to happen once to the rootCmd. +func Execute() { + err := utils.InitLog(utils.ToolCmdLogFilePath) + if err != nil { + fmt.Printf("failed fo init log: %v\n", err) + } + + err = NewRootCmd().Execute() + if err != nil { + klog.Flush() + fmt.Fprintf(os.Stderr, "execute command failed, error:%v\n", err) + os.Exit(1) + } + + klog.Flush() + os.Exit(0) +} + +func NewRootCmd() *cobra.Command { + cmd := &cobra.Command{ + Use: "network-qos", + Short: "Network QoS", + Long: "Network QoS", + } + + cmd.AddCommand(newSetCmd(os.Stdout, os.Stderr)) + cmd.AddCommand(newGetCmd(os.Stdout, os.Stderr)) + cmd.AddCommand(newResetCmd(os.Stdout, os.Stderr)) + cmd.AddCommand(newStatusCmd(os.Stdout, os.Stderr)) + cmd.AddCommand(newPrepareCmd(os.Stdout, os.Stderr)) + cmd.AddCommand(newVersionCmd(os.Stdout, os.Stderr)) + return cmd +} diff --git a/cmd/network-qos/tools/set.go b/cmd/network-qos/tools/set.go new file mode 100644 index 000000000..8ab378b6a --- /dev/null +++ b/cmd/network-qos/tools/set.go @@ -0,0 +1,74 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package tools + +import ( + "encoding/json" + "fmt" + "io" + + "github.com/spf13/cobra" + "k8s.io/klog/v2" + + "volcano.sh/volcano/cmd/network-qos/tools/options" + "volcano.sh/volcano/pkg/networkqos/throttling" + "volcano.sh/volcano/pkg/networkqos/utils" +) + +type setCmd struct { + out io.Writer + errOut io.Writer +} + +func newSetCmd(out io.Writer, errOut io.Writer) *cobra.Command { + set := &setCmd{ + out: out, + errOut: errOut, + } + + cmd := &cobra.Command{ + Use: "set", + Short: "Add/Update online-bandwidth-watermark/offline-low-bandwidth/offline-high-bandwidth/check-interval values", + Long: "Add/Update online-bandwidth-watermark/offline-low-bandwidth/offline-high-bandwidth/check-interval values", + Run: func(cmd *cobra.Command, args []string) { + klog.InfoS("Network QoS command called", "command", "set") + err := set.run(opt) + if err != nil { + utils.Error(set.errOut, cmd, err) + } + }, + } + (&opt).AddFlags(cmd) + return cmd +} + +func (c *setCmd) run(opt options.Options) (err error) { + throttlingConf, err := throttling.GetNetworkThrottlingConfig().CreateOrUpdateThrottlingConfig(opt.OnlineBandwidthWatermark, + opt.OfflineLowBandwidth, opt.OfflineHighBandwidth, opt.CheckoutInterval) + if err != nil { + return fmt.Errorf("failed to create/update throttling config: %v", err) + } + + throttlingConfigBytes, err := json.Marshal(throttlingConf) + if err != nil { + return fmt.Errorf("failed to create/update throttling config: %v", err) + } + + fmt.Fprintf(c.out, "throttling config set: %s\n", throttlingConfigBytes) + klog.InfoS("Network QoS command called successfully", "command", "set", "throttling-conf", throttlingConfigBytes) + return nil +} diff --git a/cmd/network-qos/tools/set_test.go b/cmd/network-qos/tools/set_test.go new file mode 100644 index 000000000..aea778dae --- /dev/null +++ b/cmd/network-qos/tools/set_test.go @@ -0,0 +1,140 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package tools + +import ( + "bytes" + "encoding/json" + "fmt" + "os" + "testing" + + "github.com/agiledragon/gomonkey/v2" + "github.com/golang/mock/gomock" + "github.com/stretchr/testify/assert" + + "volcano.sh/volcano/cmd/network-qos/tools/options" + "volcano.sh/volcano/pkg/networkqos/api" + "volcano.sh/volcano/pkg/networkqos/throttling" + mockthrottling "volcano.sh/volcano/pkg/networkqos/throttling/mocks" +) + +func TestSetCmdRun(t *testing.T) { + mockController := gomock.NewController(t) + defer mockController.Finish() + + mockThr := mockthrottling.NewMockThrottlingConfig(mockController) + throttling.SetNetworkThrottlingConfig(mockThr) + + testCases := []struct { + name string + opt options.Options + apiCall []*gomock.Call + jsonMarshalErr error + expectedOut string + expectedErrOut string + expectedOsExitCalled bool + }{ + { + name: "[set] json Marshal failed", + opt: options.Options{ + CheckoutInterval: "100", + OnlineBandwidthWatermark: "100MB", + OfflineLowBandwidth: "30MB", + OfflineHighBandwidth: "50MB", + }, + apiCall: []*gomock.Call{ + mockThr.EXPECT().CreateOrUpdateThrottlingConfig("100MB", "30MB", "50MB", "100").Return(&api.EbpfNetThrottlingConfig{ + Interval: 10000000, + WaterLine: 100 * 1024 * 1024, + LowRate: 30 * 1024 * 1024, + HighRate: 50 * 1024 * 1024, + }, + nil), + }, + jsonMarshalErr: fmt.Errorf("json marshal failed"), + expectedErrOut: `execute command[set] failed, error:failed to create/update throttling config: json marshal failed` + "\n", + expectedOsExitCalled: true, + }, + + { + name: "[set] set throttling conf map successfully", + opt: options.Options{ + CheckoutInterval: "200", + OnlineBandwidthWatermark: "1000MB", + OfflineLowBandwidth: "200MB", + OfflineHighBandwidth: "500MB", + }, + apiCall: []*gomock.Call{ + mockThr.EXPECT().CreateOrUpdateThrottlingConfig("1000MB", "200MB", "500MB", "200").Return(&api.EbpfNetThrottlingConfig{ + Interval: 20000000, + WaterLine: 1000 * 1024 * 1024, + LowRate: 200 * 1024 * 1024, + HighRate: 500 * 1024 * 1024, + }, + nil), + }, + expectedOut: `throttling config set: {"online_bandwidth_watermark":1048576000,"interval":20000000,"offline_low_bandwidth":209715200,"offline_high_bandwidth":524288000}` + "\n", + }, + + { + name: "[set] set throttling conf map failed", + opt: options.Options{ + CheckoutInterval: "300", + OnlineBandwidthWatermark: "800MB", + OfflineLowBandwidth: "250MB", + OfflineHighBandwidth: "350MB", + }, + apiCall: []*gomock.Call{ + mockThr.EXPECT().CreateOrUpdateThrottlingConfig("800MB", "250MB", "350MB", "300").Return(nil, + fmt.Errorf("failed to update conf map")), + }, + expectedErrOut: `execute command[set] failed, error:failed to create/update throttling config: failed to update conf map` + "\n", + expectedOsExitCalled: true, + }, + } + + exitCalled := false + setPatch := gomonkey.NewPatches() + setPatch.ApplyFunc(os.Exit, func(code int) { + exitCalled = true + }) + defer setPatch.Reset() + + for _, tc := range testCases { + exitCalled = false + var jsonMarshalPatch *gomonkey.Patches + if tc.jsonMarshalErr != nil { + jsonMarshalPatch = gomonkey.NewPatches() + jsonMarshalPatch.ApplyFunc(json.Marshal, func(v interface{}) ([]byte, error) { + return nil, tc.jsonMarshalErr + }) + } + + out := &bytes.Buffer{} + errOut := &bytes.Buffer{} + opt = tc.opt + cmd := newSetCmd(out, errOut) + cmd.Execute() + if jsonMarshalPatch != nil { + jsonMarshalPatch.Reset() + } + assert.Equal(t, tc.expectedOsExitCalled, exitCalled, tc.name) + assert.Equal(t, tc.expectedOut, out.String(), tc.name) + assert.Equal(t, tc.expectedErrOut, errOut.String(), tc.name) + } +} diff --git a/cmd/network-qos/tools/status.go b/cmd/network-qos/tools/status.go new file mode 100644 index 000000000..2373201e7 --- /dev/null +++ b/cmd/network-qos/tools/status.go @@ -0,0 +1,76 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package tools + +import ( + "encoding/json" + "errors" + "fmt" + "io" + "os" + + cilliumbpf "github.com/cilium/ebpf" + "github.com/spf13/cobra" + "k8s.io/klog/v2" + + "volcano.sh/volcano/pkg/networkqos/throttling" + "volcano.sh/volcano/pkg/networkqos/utils" +) + +type statusCmd struct { + out io.Writer + errOut io.Writer +} + +func newStatusCmd(out io.Writer, errOut io.Writer) *cobra.Command { + status := &statusCmd{ + out: out, + errOut: errOut, + } + + return &cobra.Command{ + Use: "status", + Short: "Print network QoS status", + Long: "Print network QoS status", + Run: func(cmd *cobra.Command, args []string) { + klog.InfoS("Network QoS command called", "command", "status") + err := status.run() + if err != nil { + utils.Error(status.errOut, cmd, err) + } + }, + } +} + +func (c *statusCmd) run() (err error) { + throttlingStatus, err := throttling.GetNetworkThrottlingConfig().GetThrottlingStatus() + if err != nil { + if errors.Is(err, cilliumbpf.ErrKeyNotExist) || os.IsNotExist(err) { + return fmt.Errorf("failed to get throttling status: %v, network qos has not been initialized, please enable network qos first", err) + } + return fmt.Errorf("failed to get throttling status: %v", err) + } + + throttlingStatusBytes, err := json.Marshal(throttlingStatus) + if err != nil { + return fmt.Errorf("failed to marshal throttling status %v to json: %v", throttlingStatus, err) + } + + fmt.Fprintf(c.out, "%s: %s\n", "throttling status", throttlingStatusBytes) + klog.InfoS("Network QoS command called successfully", "command", "status", "status", throttlingStatusBytes) + return nil +} diff --git a/cmd/network-qos/tools/status_test.go b/cmd/network-qos/tools/status_test.go new file mode 100644 index 000000000..24ef6a8c3 --- /dev/null +++ b/cmd/network-qos/tools/status_test.go @@ -0,0 +1,131 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package tools + +import ( + "bytes" + "encoding/json" + "fmt" + "os" + "testing" + + "github.com/agiledragon/gomonkey/v2" + "github.com/golang/mock/gomock" + "github.com/stretchr/testify/assert" + + "volcano.sh/volcano/pkg/networkqos/api" + "volcano.sh/volcano/pkg/networkqos/throttling" + mockthrottling "volcano.sh/volcano/pkg/networkqos/throttling/mocks" +) + +func TestStatusCmdExecute(t *testing.T) { + mockController := gomock.NewController(t) + defer mockController.Finish() + + mockThr := mockthrottling.NewMockThrottlingConfig(mockController) + throttling.SetNetworkThrottlingConfig(mockThr) + + testCases := []struct { + name string + apiCall []*gomock.Call + jsonMarshalErr error + expectedOut string + expectedErrOut string + expectedOsExitCalled bool + }{ + { + name: "[status] json Marshal failed", + apiCall: []*gomock.Call{ + mockThr.EXPECT().GetThrottlingStatus().Return(&api.EbpfNetThrottling{ + TLast: 65923918434500, + Rate: 50000000, + TXBytes: 20000, + OnlineTXBytes: 20000, + TStart: 88736282681743, + EbpfNetThrottlingStatus: api.EbpfNetThrottlingStatus{ + CheckTimes: 300, + HighTimes: 100, + LowTimes: 200, + OnlinePKTs: 100, + OfflinePKTs: 100, + }, + }, nil), + }, + jsonMarshalErr: fmt.Errorf("json marshal failed"), + expectedErrOut: `execute command[status] failed, error:failed to marshal throttling status &{65923918434500 50000000 20000 20000 88736282681743 {300 100 200 100 100 0 0 0}} to json: json marshal failed` + "\n", + expectedOsExitCalled: true, + }, + { + name: "[status] get conf successfully", + apiCall: []*gomock.Call{ + mockThr.EXPECT().GetThrottlingStatus().Return(&api.EbpfNetThrottling{ + TLast: 65923918434483, + Rate: 60000000, + TXBytes: 10000, + OnlineTXBytes: 10000, + TStart: 88736282681743, + EbpfNetThrottlingStatus: api.EbpfNetThrottlingStatus{ + CheckTimes: 1000, + HighTimes: 500, + LowTimes: 500, + OnlinePKTs: 500, + OfflinePKTs: 500, + }, + }, nil), + }, + expectedOut: `throttling status: {"latest_offline_packet_send_time":65923918434483,"offline_bandwidth_limit":60000000,"offline_tx_bytes":10000,"online_tx_bytes":10000,"latest_check_time":88736282681743,"check_times":1000,"high_times":500,"low_times":500,"online_tx_packages":500,"offline_tx_packages":500,"offline_prio":0,"latest_online_bandwidth":0,"latest_offline_bandwidth":0}` + "\n", + }, + + { + name: "[status] get conf failed", + apiCall: []*gomock.Call{ + mockThr.EXPECT().GetThrottlingStatus().Return(nil, fmt.Errorf("request failed")), + }, + expectedErrOut: `execute command[status] failed, error:failed to get throttling status: request failed` + "\n", + expectedOsExitCalled: true, + }, + } + + exitCalled := false + statusPatch := gomonkey.NewPatches() + statusPatch.ApplyFunc(os.Exit, func(code int) { + exitCalled = true + }) + defer statusPatch.Reset() + + for _, tc := range testCases { + exitCalled = false + var jsonMarPatch *gomonkey.Patches + if tc.jsonMarshalErr != nil { + jsonMarPatch = gomonkey.NewPatches() + jsonMarPatch.ApplyFunc(json.Marshal, func(v interface{}) ([]byte, error) { + return nil, tc.jsonMarshalErr + }) + } + + out := &bytes.Buffer{} + errOut := &bytes.Buffer{} + cmd := newStatusCmd(out, errOut) + cmd.Execute() + if jsonMarPatch != nil { + jsonMarPatch.Reset() + } + assert.Equal(t, tc.expectedOsExitCalled, exitCalled, tc.name) + assert.Equal(t, tc.expectedOut, out.String(), tc.name) + assert.Equal(t, tc.expectedErrOut, errOut.String(), tc.name) + } +} diff --git a/cmd/network-qos/tools/version.go b/cmd/network-qos/tools/version.go new file mode 100644 index 000000000..cf30ca2f0 --- /dev/null +++ b/cmd/network-qos/tools/version.go @@ -0,0 +1,36 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package tools + +import ( + "io" + + "github.com/spf13/cobra" + + "volcano.sh/volcano/pkg/version" +) + +func newVersionCmd(out io.Writer, errOut io.Writer) *cobra.Command { + return &cobra.Command{ + Use: "version", + Short: "Print version information", + Long: "Print version information", + Run: func(cmd *cobra.Command, args []string) { + version.PrintVersionAndExit() + }, + } +} diff --git a/go.mod b/go.mod index 79b9740b9..6c76acf6b 100644 --- a/go.mod +++ b/go.mod @@ -4,23 +4,29 @@ go 1.22.0 require ( github.com/agiledragon/gomonkey/v2 v2.11.0 + github.com/cilium/ebpf v0.9.3 + github.com/containernetworking/cni v1.1.2 + github.com/containernetworking/plugins v1.1.1 github.com/elastic/go-elasticsearch/v7 v7.17.7 github.com/fsnotify/fsnotify v1.7.0 github.com/golang/mock v1.6.0 github.com/google/go-cmp v0.6.0 github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 - github.com/hashicorp/go-multierror v1.0.0 - github.com/imdario/mergo v0.3.12 + github.com/hashicorp/go-multierror v1.1.1 + github.com/imdario/mergo v0.3.16 github.com/mitchellh/mapstructure v1.5.0 github.com/onsi/ginkgo/v2 v2.19.0 github.com/onsi/gomega v1.33.1 + github.com/opencontainers/runc v1.1.13 github.com/pkg/errors v0.9.1 github.com/prometheus/client_golang v1.19.1 github.com/prometheus/common v0.55.0 + github.com/prometheus/prometheus v0.39.1 github.com/spf13/cobra v1.8.1 github.com/spf13/pflag v1.0.5 github.com/stretchr/testify v1.9.0 - go.uber.org/automaxprocs v1.4.0 + github.com/vishvananda/netlink v1.1.1-0.20210330154013-f5de75959ad5 + go.uber.org/automaxprocs v1.5.1 golang.org/x/crypto v0.24.0 golang.org/x/sys v0.21.0 golang.org/x/time v0.3.0 @@ -44,9 +50,24 @@ require ( ) require ( - github.com/NYTimes/gziphandler v1.1.1 // indirect + github.com/Microsoft/go-winio v0.6.0 // indirect github.com/antlr4-go/antlr/v4 v4.13.0 // indirect - github.com/asaskevich/govalidator v0.0.0-20190424111038-f61b66f89f4a // indirect + github.com/bits-and-blooms/bitset v1.2.0 // indirect + github.com/cyphar/filepath-securejoin v0.2.4 // indirect + github.com/go-task/slim-sprig/v3 v3.0.0 // indirect + github.com/godbus/dbus/v5 v5.1.0 // indirect + github.com/opencontainers/runtime-spec v1.0.3-0.20220909204839-494a5a6aca78 // indirect + github.com/sirupsen/logrus v1.9.3 // indirect + github.com/vishvananda/netns v0.0.4 // indirect + go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.53.0 // indirect + k8s.io/cri-api v0.31.1 // indirect + k8s.io/cri-client v0.0.0 // indirect + k8s.io/gengo/v2 v2.0.0-20240228010128-51d4e06bde70 // indirect +) + +require ( + github.com/NYTimes/gziphandler v1.1.1 // indirect + github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 // indirect github.com/beorn7/perks v1.0.1 // indirect github.com/blang/semver/v4 v4.0.0 // indirect github.com/cenkalti/backoff/v4 v4.3.0 // indirect @@ -64,7 +85,6 @@ require ( github.com/go-openapi/jsonpointer v0.19.6 // indirect github.com/go-openapi/jsonreference v0.20.2 // indirect github.com/go-openapi/swag v0.22.4 // indirect - github.com/go-task/slim-sprig/v3 v3.0.0 // indirect github.com/gogo/protobuf v1.3.2 // indirect github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect github.com/golang/protobuf v1.5.4 // indirect @@ -76,7 +96,7 @@ require ( github.com/google/uuid v1.6.0 // indirect github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0 // indirect github.com/grpc-ecosystem/grpc-gateway/v2 v2.20.0 // indirect - github.com/hashicorp/errwrap v1.0.0 // indirect + github.com/hashicorp/errwrap v1.1.0 // indirect github.com/inconshreveable/mousetrap v1.1.0 // indirect github.com/josharian/intern v1.0.0 // indirect github.com/json-iterator/go v1.1.12 // indirect @@ -86,7 +106,6 @@ require ( github.com/modern-go/reflect2 v1.0.2 // indirect github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect github.com/opencontainers/go-digest v1.0.0 // indirect - github.com/opencontainers/runc v1.1.13 // indirect github.com/opencontainers/selinux v1.11.0 // indirect github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect github.com/prometheus/client_model v0.6.1 // indirect @@ -96,7 +115,6 @@ require ( go.etcd.io/etcd/api/v3 v3.5.14 // indirect go.etcd.io/etcd/client/pkg/v3 v3.5.14 // indirect go.etcd.io/etcd/client/v3 v3.5.14 // indirect - go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.53.0 // indirect go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.53.0 // indirect go.opentelemetry.io/otel v1.28.0 // indirect go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.28.0 // indirect @@ -125,8 +143,7 @@ require ( gopkg.in/yaml.v3 v3.0.1 // indirect k8s.io/apiextensions-apiserver v0.25.0 // indirect k8s.io/cloud-provider v0.0.0 // indirect - k8s.io/controller-manager v0.31.1 // indirect - k8s.io/gengo/v2 v2.0.0-20240228010128-51d4e06bde70 // indirect + k8s.io/controller-manager v0.31.1 k8s.io/kms v0.31.1 // indirect k8s.io/kube-openapi v0.0.0-20240228011516-70dd3763d340 // indirect k8s.io/kube-scheduler v0.0.0 // indirect @@ -138,7 +155,10 @@ require ( ) replace ( + cloud.google.com/go => cloud.google.com/go v0.100.2 github.com/opencontainers/runc => github.com/opencontainers/runc v1.0.3 + go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc => go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.19.0 + google.golang.org/grpc => google.golang.org/grpc v1.57.0 k8s.io/api => k8s.io/api v0.31.1 k8s.io/apiextensions-apiserver => k8s.io/apiextensions-apiserver v0.31.1 k8s.io/apimachinery => k8s.io/apimachinery v0.31.1 @@ -152,6 +172,7 @@ replace ( k8s.io/component-helpers => k8s.io/component-helpers v0.31.1 k8s.io/controller-manager => k8s.io/controller-manager v0.31.1 k8s.io/cri-api => k8s.io/cri-api v0.31.1 + k8s.io/cri-client => k8s.io/cri-client v0.31.1 k8s.io/csi-translation-lib => k8s.io/csi-translation-lib v0.31.1 k8s.io/dynamic-resource-allocation => k8s.io/dynamic-resource-allocation v0.31.1 k8s.io/endpointslice => k8s.io/endpointslice v0.31.1 diff --git a/go.sum b/go.sum index a141a0707..b8b18be17 100644 --- a/go.sum +++ b/go.sum @@ -7,10 +7,11 @@ github.com/agiledragon/gomonkey/v2 v2.11.0 h1:5oxSgA+tC1xuGsrIorR+sYiziYltmJyEZ9 github.com/agiledragon/gomonkey/v2 v2.11.0/go.mod h1:ap1AmDzcVOAz1YpeJ3TCzIgstoaWLA6jbbgxfB4w2iY= github.com/antlr4-go/antlr/v4 v4.13.0 h1:lxCg3LAv+EUK6t1i0y1V6/SLeUi0eKEKdhQAlS8TVTI= github.com/antlr4-go/antlr/v4 v4.13.0/go.mod h1:pfChB/xh/Unjila75QW7+VU4TSnWnnk9UTnmpPaOR2g= -github.com/asaskevich/govalidator v0.0.0-20190424111038-f61b66f89f4a h1:idn718Q4B6AGu/h5Sxe66HYVdqdGu2l9Iebqhi/AEoA= -github.com/asaskevich/govalidator v0.0.0-20190424111038-f61b66f89f4a/go.mod h1:lB+ZfQJz7igIIfQNfa7Ml4HSf2uFQQRzpGGRXenZAgY= +github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 h1:DklsrG3dyBCFEj5IhUbnKptjxatkF07cF2ak3yi77so= +github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2/go.mod h1:WaHUgvxTVq04UNunO+XhnAqY/wQc+bxr74GqbsZ/Jqw= github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= +github.com/bits-and-blooms/bitset v1.2.0 h1:Kn4yilvwNtMACtf1eYDlG8H77R07mZSPbMjLyS07ChA= github.com/bits-and-blooms/bitset v1.2.0/go.mod h1:gIdJ4wp64HaoK2YrL1Q5/N7Y16edYb8uY+O0FJTyyDA= github.com/blang/semver/v4 v4.0.0 h1:1PFHFE6yCCTv8C1TeyNNarDzntLi7wMI5i/pzqYIsAM= github.com/blang/semver/v4 v4.0.0/go.mod h1:IbckMUScFkM3pff0VJDNKRiT6TG/YpiHIM2yvyW5YoQ= @@ -19,8 +20,17 @@ github.com/cenkalti/backoff/v4 v4.3.0/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyY github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= github.com/checkpoint-restore/go-criu/v5 v5.0.0/go.mod h1:cfwC0EG7HMUenopBsUf9d89JlCLQIfgVcNsNN0t6T2M= +github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI= +github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI= +github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU= github.com/cilium/ebpf v0.6.2/go.mod h1:4tRaxcgiL706VnOzHOdBlY8IEAIdxINsQBcU4xJJXRs= +github.com/cilium/ebpf v0.9.3 h1:5KtxXZU+scyERvkJMEm16TbScVvuuMrlhPly78ZMbSc= +github.com/cilium/ebpf v0.9.3/go.mod h1:w27N4UjpaQ9X/DGrSugxUG+H+NhgntDuPb5lCzxCn8A= github.com/containerd/console v1.0.2/go.mod h1:ytZPjGgY2oeTkAONYafi2kSj0aYggsf8acV1PGKCbzQ= +github.com/containernetworking/cni v1.1.2 h1:wtRGZVv7olUHMOqouPpn3cXJWpJgM6+EUl31EQbXALQ= +github.com/containernetworking/cni v1.1.2/go.mod h1:sDpYKmGVENF3s6uvMvGgldDWeG8dMxakj/u+i9ht9vw= +github.com/containernetworking/plugins v1.1.1 h1:+AGfFigZ5TiQH00vhR8qPeSatj53eNGz0C1d3wVYlHE= +github.com/containernetworking/plugins v1.1.1/go.mod h1:Sr5TH/eBsGLXK/h71HeLfX19sZPp3ry5uHSkI4LPxV8= github.com/coreos/go-semver v0.3.1 h1:yi21YpKnrx1gt5R+la8n5WgS0kCrsPp33dmEyHReZr4= github.com/coreos/go-semver v0.3.1/go.mod h1:irMmmIw/7yzSRPWryHsK7EYSg09caPQL03VsM8rvUec= github.com/coreos/go-systemd/v22 v22.3.2/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc= @@ -30,6 +40,8 @@ github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:ma github.com/cpuguy83/go-md2man/v2 v2.0.4/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= github.com/cyphar/filepath-securejoin v0.2.2/go.mod h1:FpkQEhXnPnOthhzymB7CGsFk2G9VLXONKD9G7QGMM+4= +github.com/cyphar/filepath-securejoin v0.2.4 h1:Ugdm7cg7i6ZK6x3xDF1oEu1nfkyfH53EtKeQYTC3kyg= +github.com/cyphar/filepath-securejoin v0.2.4/go.mod h1:aPGpWjXOXUn2NCNjFvBE6aRxGGx79pTxQpKOJNYHHl4= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= @@ -48,6 +60,10 @@ github.com/evanphx/json-patch/v5 v5.6.0/go.mod h1:G79N1coSVB93tBe7j6PhzjmR3/2Vvl github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg= github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= github.com/frankban/quicktest v1.11.3/go.mod h1:wRf/ReqHper53s+kmmSZizM8NamnL3IM0I9ntUbOk+k= +github.com/frankban/quicktest v1.14.0 h1:+cqqvzZV87b4adx/5ayVOaYZ2CrvM4ejQvUdBzPPUss= +github.com/frankban/quicktest v1.14.0/go.mod h1:NeW+ay9A/U67EYXNFA1nPE8e/tnQv/09mUdL/ijj8og= +github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= +github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ= github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA= github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM= github.com/fxamacker/cbor/v2 v2.7.0 h1:iM5WgngdRBanHcxugY4JySA0nk1wZorNOpTgCMedv5E= @@ -66,9 +82,12 @@ github.com/go-openapi/jsonreference v0.20.2/go.mod h1:Bl1zwGIM8/wsvqjsOQLJ/SH+En github.com/go-openapi/swag v0.22.3/go.mod h1:UzaqsxGiab7freDnrUUra0MwWfN/q7tE4j+VcZ0yl14= github.com/go-openapi/swag v0.22.4 h1:QLMzNJnMGPRNDCbySlcj1x01tzU8/9LTTL9hZZZogBU= github.com/go-openapi/swag v0.22.4/go.mod h1:UzaqsxGiab7freDnrUUra0MwWfN/q7tE4j+VcZ0yl14= +github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE= github.com/go-task/slim-sprig/v3 v3.0.0 h1:sUs3vkvUymDpBKi3qH1YSqBQk9+9D/8M2mN1vB6EwHI= github.com/go-task/slim-sprig/v3 v3.0.0/go.mod h1:W848ghGpv3Qj3dhTPRyJypKRiqCdHZiAzKg9hl15HA8= github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= +github.com/godbus/dbus/v5 v5.1.0 h1:4KLkAxT3aOY8Li4FRJe/KvhoNFFxo0m6fNuFUO8QJUk= +github.com/godbus/dbus/v5 v5.1.0/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= github.com/golang-jwt/jwt/v4 v4.5.0 h1:7cYmW1XlMY7h7ii7UhUyChSgS5wUJEnm9uZVTGqOWzg= @@ -77,13 +96,16 @@ github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da h1:oI5xCqsCo564l github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc= github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs= +github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8= github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA= github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs= github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w= github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0= +github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= +github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek= github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= github.com/google/btree v1.0.1 h1:gK4Kx5IaGY9CD5sPJ36FHiBJ6ZXl0kilRiiCj+jdYp4= @@ -105,6 +127,7 @@ github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeN github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0= github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= +github.com/google/pprof v0.0.0-20210407192527-94a9f03dee38/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/pprof v0.0.0-20240525223248-4bfdf5a9a2af h1:kmjWCqn2qkEml422C2Rrd27c3VGxi6a/6HNq8QmHRKM= github.com/google/pprof v0.0.0-20240525223248-4bfdf5a9a2af/go.mod h1:K1liHPHnj73Fdn/EKuT8nrFqBihUSKXoLYU0BuatOYo= github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 h1:El6M4kTTCOh6aBiKaUGG7oYTSPP8MxqL4YI3kZKwcP4= @@ -122,12 +145,15 @@ github.com/grpc-ecosystem/grpc-gateway v1.16.0 h1:gmcG1KaJ57LophUzW0Hy8NmPhnMZb4 github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw= github.com/grpc-ecosystem/grpc-gateway/v2 v2.20.0 h1:bkypFPDjIYGfCYD5mRBvpqxfYX1YCS1PXdKYWi8FsN0= github.com/grpc-ecosystem/grpc-gateway/v2 v2.20.0/go.mod h1:P+Lt/0by1T8bfcF3z737NnSbmxQAppXMRziHUxPOC8k= -github.com/hashicorp/errwrap v1.0.0 h1:hLrqtEDnRye3+sgx6z4qVLNuviH3MR5aQ0ykNJa/UYA= github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= -github.com/hashicorp/go-multierror v1.0.0 h1:iVjPR7a6H0tWELX5NxNe7bYopibicUzc7uPribsnS6o= -github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHhCYQXV3UM06sGGrk= -github.com/imdario/mergo v0.3.12 h1:b6R2BslTbIEToALKP7LxUvijTsNI9TAe80pLWN2g/HU= -github.com/imdario/mergo v0.3.12/go.mod h1:jmQim1M+e3UYxmgPu/WyfjB3N3VflVyUjjjwH0dnCYA= +github.com/hashicorp/errwrap v1.1.0 h1:OxrOeh75EUXMY8TBjag2fzXGZ40LB6IKw45YeGUDY2I= +github.com/hashicorp/errwrap v1.1.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= +github.com/hashicorp/go-multierror v1.1.1 h1:H5DkEtf6CXdFp0N0Em5UCwQpXMWke8IA0+lD48awMYo= +github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM= +github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= +github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= +github.com/imdario/mergo v0.3.16 h1:wwQJbIsHYGMUyLSPrEq1CT16AhnhNJQ51+4fdHUnCl4= +github.com/imdario/mergo v0.3.16/go.mod h1:WBLT9ZmE3lPoWsEzCh9LPo3TiwVN+ZKEjmz+hD27ysY= github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8= github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI= @@ -142,7 +168,6 @@ github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHm github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU= github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= -github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= @@ -167,12 +192,20 @@ github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f h1:KUppIJq7/+SVif2QVs3tOP0zanoHgBEVAwHxUSIzRqU= github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U= +github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A= github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE= github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU= +github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= +github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk= +github.com/onsi/ginkgo v1.16.4/go.mod h1:dX+/inL/fNMqNlz0e9LfyB9TswhZpCVdJM/Z6Vvnwo0= github.com/onsi/ginkgo v1.16.5 h1:8xi0RTUf59SOSfEtZMvwTvXYMzG4gV23XVHOZiXNtnE= github.com/onsi/ginkgo v1.16.5/go.mod h1:+E8gABHa3K6zRBolWtd+ROzc/U5bkGt0FwiG042wbpU= +github.com/onsi/ginkgo/v2 v2.1.3/go.mod h1:vw5CSIxN1JObi/U8gcbwft7ZxR2dgaR70JSE3/PpL4c= github.com/onsi/ginkgo/v2 v2.19.0 h1:9Cnnf7UHo57Hy3k6/m5k3dRfGTMXGvxhHFvkDTCTpvA= github.com/onsi/ginkgo/v2 v2.19.0/go.mod h1:rlwLi9PilAFJ8jCg9UE1QP6VBpd6/xj3SRC0d6TU0To= +github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY= +github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo= +github.com/onsi/gomega v1.17.0/go.mod h1:HnhC7FXeEQY45zxNK3PPoIUhzk/80Xly9PcubAlGdZY= github.com/onsi/gomega v1.33.1 h1:dsYjIxxSR755MDmKVsaFQTE22ChNBcuuTWgkUDSubOk= github.com/onsi/gomega v1.33.1/go.mod h1:U4R44UsT+9eLIaYRB2a5qajjtQYn0hauxvRm16AVYg0= github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U= @@ -180,6 +213,8 @@ github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3I github.com/opencontainers/runc v1.0.3 h1:1hbqejyQWCJBvtKAfdO0b1FmaEf2z/bxnjqbARass5k= github.com/opencontainers/runc v1.0.3/go.mod h1:aTaHFFwQXuA71CiyxOdFFIorAoemI04suvGRQFzWTD0= github.com/opencontainers/runtime-spec v1.0.3-0.20210326190908-1c3f411f0417/go.mod h1:jwyrGlmzljRJv/Fgzds9SsS/C5hL+LL3ko9hs6T5lQ0= +github.com/opencontainers/runtime-spec v1.0.3-0.20220909204839-494a5a6aca78 h1:R5M2qXZiK/mWPMT4VldCOiSL9HIAMuxQZWdG0CSM5+4= +github.com/opencontainers/runtime-spec v1.0.3-0.20220909204839-494a5a6aca78/go.mod h1:jwyrGlmzljRJv/Fgzds9SsS/C5hL+LL3ko9hs6T5lQ0= github.com/opencontainers/selinux v1.8.2/go.mod h1:MUIHuUEvKB1wtJjQdOyYRgOnLD2xAPP8dBsCoU0KuF8= github.com/opencontainers/selinux v1.11.0 h1:+5Zbo97w3Lbmb3PeqQtpmTkMwsW5nRI3YaLpt7tQ7oU= github.com/opencontainers/selinux v1.11.0/go.mod h1:E5dMC3VPuVvVHDYmi78qvhJp8+M586T4DlDRYpFkyec= @@ -189,6 +224,8 @@ github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINE github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/prashantv/gostub v1.1.0 h1:BTyx3RfQjRHnUWaGF9oQos79AlQ5k8WNktv7VGvVH4g= +github.com/prashantv/gostub v1.1.0/go.mod h1:A5zLQHz7ieHGG7is6LLXLz7I8+3LZzsrV0P1IAHhP5U= github.com/prometheus/client_golang v1.19.1 h1:wZWJDwK+NameRJuPGDhlnFgx8e8HN3XHQeLaYJFJBOE= github.com/prometheus/client_golang v1.19.1/go.mod h1:mP78NwGzrVks5S2H6ab8+ZZGJLZUq1hoULYBAYBw1Ho= github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E= @@ -197,11 +234,15 @@ github.com/prometheus/common v0.55.0 h1:KEi6DK7lXW/m7Ig5i47x0vRzuBsHuvJdi5ee6Y3G github.com/prometheus/common v0.55.0/go.mod h1:2SECS4xJG1kd8XF9IcM1gMX6510RAEL65zxzNImwdc8= github.com/prometheus/procfs v0.15.1 h1:YagwOFzUgYfKKHX6Dr+sHT7km/hxC76UB0learggepc= github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoGhij/e3PBqk= +github.com/prometheus/prometheus v0.39.1 h1:abZM6A+sKAv2eKTbRIaHq4amM/nT07MuxRm0+QTaTj0= +github.com/prometheus/prometheus v0.39.1/go.mod h1:GjQjgLhHMc0oo4Ko7qt/yBSJMY4hUoiAZwsYQgjaePA= github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8= github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4= github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= github.com/seccomp/libseccomp-golang v0.9.1/go.mod h1:GbW5+tmTXfcxTToHLXlScSlAvWlF4P2Ca7zGrPiEpWo= +github.com/seccomp/libseccomp-golang v0.10.0 h1:aA4bp+/Zzi0BnWZ2F1wgNBs5gTpm+na2rWM6M9YjLpY= +github.com/seccomp/libseccomp-golang v0.10.0/go.mod h1:JA8cRccbGaA1s33RQf7Y1+q9gHmZX1yB/z9WDN1C6fg= github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc= github.com/sirupsen/logrus v1.8.1/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0= github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ= @@ -221,8 +262,8 @@ github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSS github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= -github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= @@ -233,7 +274,12 @@ github.com/tmc/grpc-websocket-proxy v0.0.0-20220101234140-673ab2c3ae75 h1:6fotK7 github.com/tmc/grpc-websocket-proxy v0.0.0-20220101234140-673ab2c3ae75/go.mod h1:KO6IkyS8Y3j8OdNO85qEYBsRPuteD+YciPomcXdrMnk= github.com/urfave/cli v1.22.1/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0= github.com/vishvananda/netlink v1.1.0/go.mod h1:cTgwzPIzzgDAYoQrMm0EdrjRUBkTqKYppBueQtXaqoE= +github.com/vishvananda/netlink v1.1.1-0.20210330154013-f5de75959ad5 h1:+UB2BJA852UkGH42H+Oee69djmxS3ANzl2b/JtT1YiA= +github.com/vishvananda/netlink v1.1.1-0.20210330154013-f5de75959ad5/go.mod h1:twkDnbuQxJYemMlGd4JFIcuhgX83tXhKS2B/PRMpOho= github.com/vishvananda/netns v0.0.0-20191106174202-0a2b9b5464df/go.mod h1:JP3t17pCcGlemwknint6hfoeCVQrEMVwxRLRjXpq+BU= +github.com/vishvananda/netns v0.0.0-20200728191858-db3c7e526aae/go.mod h1:DD4vA1DwXk04H54A1oHXtwZmA0grkVMdPxx/VGLCah0= +github.com/vishvananda/netns v0.0.4 h1:Oeaw1EM2JMxD51g9uhtC0D7erkIjgmj8+JZc26m1YX8= +github.com/vishvananda/netns v0.0.4/go.mod h1:SpkAiCQRtJ6TvvxPnOSyH3BMl6unz3xZlaprSwhNNJM= github.com/x448/float16 v0.8.4 h1:qLwI1I70+NjRFUR3zs1JPUCgaCXSh3SW62uAKT1mSBM= github.com/x448/float16 v0.8.4/go.mod h1:14CWIYCyZA/cWjXOioeEpHeN/83MdbZDRQHoFcYsOfg= github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2 h1:eY9dn8+vbi4tKz5Qo6v2eYzo7kUS51QINcR5jNpbZS8= @@ -265,8 +311,8 @@ go.opentelemetry.io/otel v1.28.0 h1:/SqNcYk+idO0CxKEUOtKQClMK/MimZihKYMruSMViUo= go.opentelemetry.io/otel v1.28.0/go.mod h1:q68ijF8Fc8CnMHKyzqL6akLO46ePnjkgfIMIjUIX9z4= go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.28.0 h1:3Q/xZUyC1BBkualc9ROb4G8qkH90LXEIICcs5zv1OYY= go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.28.0/go.mod h1:s75jGIWA9OfCMzF0xr+ZgfrB5FEbbV7UuYo32ahUiFI= -go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.27.0 h1:qFffATk0X+HD+f1Z8lswGiOQYKHRlzfmdJm0wEaVrFA= -go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.27.0/go.mod h1:MOiCmryaYtc+V0Ei+Tx9o5S1ZjA7kzLucuVuyzBZloQ= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.19.0 h1:3d+S281UTjM+AbF31XSOYn1qXn3BgIdWl8HNEpx08Jk= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.19.0/go.mod h1:0+KuTDyKL4gjKCF75pHOX4wuzYDUZYfAQdSu43o+Z2I= go.opentelemetry.io/otel/metric v1.28.0 h1:f0HGvSl1KRAU1DLgLGFjrwVyismPlnuU6JD6bOeuA5Q= go.opentelemetry.io/otel/metric v1.28.0/go.mod h1:Fb1eVBFZmLVTMb6PPohq3TO9IIhUisDsbJoL/+uQW4s= go.opentelemetry.io/otel/sdk v1.28.0 h1:b9d7hIry8yZsgtbmM0DKyPWMMUMlK9NEKuIG4aBqWyE= @@ -275,8 +321,8 @@ go.opentelemetry.io/otel/trace v1.28.0 h1:GhQ9cUuQGmNDd5BTCP2dAvv75RdMxEfTmYejp+ go.opentelemetry.io/otel/trace v1.28.0/go.mod h1:jPyXzNPg6da9+38HEwElrQiHlVMTnVfM3/yv2OlIHaI= go.opentelemetry.io/proto/otlp v1.3.1 h1:TrMUixzpM0yuc/znrFTP9MMRh8trP93mkCiDVeXrui0= go.opentelemetry.io/proto/otlp v1.3.1/go.mod h1:0X1WI4de4ZsLrrJNLAQbFeLCm3T7yBkR0XqQ7niQU+8= -go.uber.org/automaxprocs v1.4.0 h1:CpDZl6aOlLhReez+8S3eEotD7Jx0Os++lemPlMULQP0= -go.uber.org/automaxprocs v1.4.0/go.mod h1:/mTEdr7LvHhs0v7mjdxDreTz1OG5zdZGqgOnhWiR/+Q= +go.uber.org/automaxprocs v1.5.1 h1:e1YG66Lrk73dn4qhg8WFSvhF0JuFQF0ERIp4rpuV8Qk= +go.uber.org/automaxprocs v1.5.1/go.mod h1:BF4eumQw0P9GtnuxxovUd06vwm1o18oMzFtK66vU6XU= go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= @@ -295,36 +341,51 @@ golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.17.0 h1:zY54UmvipHiNd+pm+m0x9KhZ9hl1/7QNMyxXbc6ICqA= golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= +golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20201224014010-6772e930b67b/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= +golang.org/x/net v0.0.0-20210428140749-89ef3d95e781/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk= golang.org/x/net v0.26.0 h1:soB7SVo0PWrY4vPW/+ay0jKDNScG2X9wFeYlXIvJsOQ= golang.org/x/net v0.26.0/go.mod h1:5YKkiSynbBIh3p6iOc/vibscux0x38BZDkn8sCUPxHE= golang.org/x/oauth2 v0.21.0 h1:tsimM75w1tF/uws5rbeHzIWxEqElMehnc+iW793zsZs= golang.org/x/oauth2 v0.21.0/go.mod h1:XYTD2NtWslqkgxebSiOHnXEap4TF09sJSc7H1sXbhtI= +golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M= golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= +golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190606203320-7fc4e5ec1444/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191115151921-52ab43148777/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200217220822-9197077df867/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200728102440-3e129f6d46b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200909081042-eff7692f9009/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210112080510-489259a85091/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210426230700-d19ff857e887/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.21.0 h1:rF+pYz3DAGSQAxAu1CbC7catZg4ebC4UIeIhKxBZvws= golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= @@ -332,6 +393,7 @@ golang.org/x/term v0.21.0 h1:WVXCp+/EBEHOj53Rvu+7KiT/iElMrO8ACK16SMZ3jaA= golang.org/x/term v0.21.0/go.mod h1:ooXLefLobQVslOqselCNF4SxFAaoS6KujMbsGzSDmX0= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4= golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI= golang.org/x/time v0.3.0 h1:rg5rLMjNzMS1RkNLzCG38eapWhnYLFYXDXj2gOlr8j4= @@ -340,6 +402,7 @@ golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGm golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20201224043029-2b0845dc783e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d h1:vU5i/LfpvrRCpgM/VPfJLg5KjxD3E+hfT1SH+d9zLwg= @@ -356,8 +419,8 @@ google.golang.org/genproto/googleapis/api v0.0.0-20240528184218-531527333157 h1: google.golang.org/genproto/googleapis/api v0.0.0-20240528184218-531527333157/go.mod h1:99sLkeliLXfdj2J75X3Ho+rrVCaJze0uwN7zDDkjPVU= google.golang.org/genproto/googleapis/rpc v0.0.0-20240701130421-f6361c86f094 h1:BwIjyKYGsK9dMCBOorzRri8MQwmi7mT9rGHsCEinZkA= google.golang.org/genproto/googleapis/rpc v0.0.0-20240701130421-f6361c86f094/go.mod h1:Ue6ibwXGpU+dqIcODieyLOcgj7z8+IcskoNIgZxtrFY= -google.golang.org/grpc v1.65.0 h1:bs/cUb4lp1G5iImFFd3u5ixQzweKizoZJAwBNLR42lc= -google.golang.org/grpc v1.65.0/go.mod h1:WgYC2ypjlB0EiQi6wdKixMqukr6lBc0Vo+oOgjrM5ZQ= +google.golang.org/grpc v1.57.0 h1:kfzNeI/klCGD2YPMUlaGNT3pxvYfga7smW3Vth8Zsiw= +google.golang.org/grpc v1.57.0/go.mod h1:Sd+9RMTACXwmub0zcNY2c4arhtrbBYD1AUHI/dt16Mo= google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= @@ -369,11 +432,11 @@ google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQ google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg= google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= gopkg.in/evanphx/json-patch.v4 v4.12.0 h1:n6jtcsulIzXPJaxegRbvFNNrZDjbij7ny3gmSPG+6V4= gopkg.in/evanphx/json-patch.v4 v4.12.0/go.mod h1:p8EYWUEYMpynmqDbY58zCKCFZw8pRWMG4EsWvDvM72M= +gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys= gopkg.in/inf.v0 v0.9.1 h1:73M5CoZyi3ZLMOyDlQh031Cx6N9NDJ2Vvfl76EDAgDc= gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw= gopkg.in/natefinch/lumberjack.v2 v2.2.1 h1:bBRl1b0OH9s/DuPhuXpNl+VtCaJXFZ5/uEFST95x9zc= @@ -381,6 +444,7 @@ gopkg.in/natefinch/lumberjack.v2 v2.2.1/go.mod h1:YD8tP3GAjkrDg1eZH7EGmyESg/lsYs gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ= gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw= gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= @@ -408,6 +472,10 @@ k8s.io/component-helpers v0.31.1 h1:5hZUf3747atdgtR3gPntrG35rC2CkK7rYq2KUraz6Os= k8s.io/component-helpers v0.31.1/go.mod h1:ye0Gi8KzFNTfpIuzvVDtxJQMP/0Owkukf1vGf22Hl6U= k8s.io/controller-manager v0.31.1 h1:bwiy8y//EG5lJL2mdbOvZWrOgw2EXXIvwp95VYgoIis= k8s.io/controller-manager v0.31.1/go.mod h1:O440MSE6EI1AEVhB2Fc8FYqv6r8BHrSXjm5aj3886No= +k8s.io/cri-api v0.31.1 h1:x0aI8yTI7Ho4c8tpuig8NwI/MRe+VhjiYyyebC2xphQ= +k8s.io/cri-api v0.31.1/go.mod h1:Po3TMAYH/+KrZabi7QiwQI4a692oZcUOUThd/rqwxrI= +k8s.io/cri-client v0.31.1 h1:w5D7BAhiaSVVDZqHs7YUZPpuUCybx8tCxfdBuDBw7zo= +k8s.io/cri-client v0.31.1/go.mod h1:voVfZexZQwvlf/JD8w30sGN0k22LRcHRfCj7+m4kAXE= k8s.io/csi-translation-lib v0.31.1 h1:ps9kya8+ih0CVL59JO2B4AYH8U/e3WLQxl9sx19NjjM= k8s.io/csi-translation-lib v0.31.1/go.mod h1:VeYSucPZJbAt6RT25AzfG7WjyxCcmqxtr4V/CaDdNZc= k8s.io/gengo/v2 v2.0.0-20240228010128-51d4e06bde70 h1:NGrVE502P0s0/1hudf8zjgwki1X/TByhmAoILTarmzo= diff --git a/pkg/agent/apis/extension/qos.go b/pkg/agent/apis/extension/qos.go new file mode 100644 index 000000000..42304340a --- /dev/null +++ b/pkg/agent/apis/extension/qos.go @@ -0,0 +1,62 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package extension + +import ( + corev1 "k8s.io/api/core/v1" + + "volcano.sh/volcano/pkg/agent/apis" +) + +type QosLevel string + +const ( + // QosLevelLC means the qos level Latency Critical. + QosLevelLC QosLevel = "LC" + // QosLevelHLS means the qos level Highly Latency Sensitive. + QosLevelHLS QosLevel = "HLS" + // QosLevelLS means the qos level Latency Sensitive. + QosLevelLS QosLevel = "LS" + // QosLevelBE means the qos level Best Effort. + QosLevelBE QosLevel = "BE" +) + +var qosLevelMap = map[QosLevel]int{ + QosLevelLC: 2, + QosLevelHLS: 2, + QosLevelLS: 1, + QosLevelBE: -1, +} + +// GetQosLevel return OS qos level by QosLevel. +// If not specified, zero will be returned. +func GetQosLevel(pod *corev1.Pod) int { + if pod == nil { + return 0 + } + + qosLevel := pod.GetAnnotations()[apis.PodQosLevelKey] + return qosLevelMap[QosLevel(qosLevel)] +} + +// NormalizeQosLevel normalizes qos level, for memory and network qos, only 0 and -1 are supported now. +func NormalizeQosLevel(qosLevel int64) int64 { + if qosLevel < 0 { + return -1 + } + return 0 +} diff --git a/pkg/agent/apis/extension/qos_test.go b/pkg/agent/apis/extension/qos_test.go new file mode 100644 index 000000000..a70304d09 --- /dev/null +++ b/pkg/agent/apis/extension/qos_test.go @@ -0,0 +1,80 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package extension + +import ( + "testing" + + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) + +func TestGetQosLevel(t *testing.T) { + tests := []struct { + name string + pod *corev1.Pod + want int + }{ + { + name: "no qos level specified", + pod: makePod(""), + want: 0, + }, + { + name: "invalid qos level", + pod: makePod("invalid"), + want: 0, + }, + { + name: "qos LC", + pod: makePod("LC"), + want: 2, + }, + { + name: "qos HLS", + pod: makePod("HLS"), + want: 2, + }, + { + name: "qos LS", + pod: makePod("LS"), + want: 1, + }, + { + name: "qos BE", + pod: makePod("BE"), + want: -1, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := GetQosLevel(tt.pod); got != tt.want { + t.Errorf("GetQosLevel() = %v, want %v", got, tt.want) + } + }) + } +} + +func makePod(qosLevel string) *corev1.Pod { + return &corev1.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Annotations: map[string]string{ + "volcano.sh/qos-level": qosLevel, + }, + }, + } +} diff --git a/pkg/agent/apis/types.go b/pkg/agent/apis/types.go new file mode 100644 index 000000000..15f5754d5 --- /dev/null +++ b/pkg/agent/apis/types.go @@ -0,0 +1,83 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package apis + +import corev1 "k8s.io/api/core/v1" + +const ( + // OverSubscriptionTypesKey define the overSubscription resource types + OverSubscriptionTypesKey = "volcano.sh/oversubscription-types" + + // NodeOverSubscriptionCPUKey define the oversubscription cpu resource on the node + NodeOverSubscriptionCPUKey = "volcano.sh/oversubscription-cpu" + // NodeOverSubscriptionMemoryKey define the oversubscription memory resource on the node + NodeOverSubscriptionMemoryKey = "volcano.sh/oversubscription-memory" + + // PodQosLevelKey define pod qos level, see pkg/agent/apis/extension/qos.go for specific values. + PodQosLevelKey = "volcano.sh/qos-level" + // PodEvictingKey define if the offline job is evicting + PodEvictingKey = "volcano.sh/offline-job-evicting" + // ColocationEnableNodeLabelKey is the label name for colocation, + // indicates whether the node enable colocation, set "true" or "false", default is "false" + ColocationEnableNodeLabelKey = "volcano.sh/colocation" + // OverSubscriptionNodeLabelKey define whether a node is oversubscription node. + OverSubscriptionNodeLabelKey = "volcano.sh/oversubscription" + + // NetworkBandwidthRateAnnotationKey is the annotation key of network bandwidth rate, unit Mbps. + NetworkBandwidthRateAnnotationKey = "volcano.sh/network-bandwidth-rate" + + // Deprecated:This is used to be compatible with old api. + // PodEvictedOverSubscriptionCPUHighWaterMarkKey define the high watermark of cpu usage when evicting offline pods + PodEvictedOverSubscriptionCPUHighWaterMarkKey = "volcano.sh/oversubscription-evicting-cpu-high-watermark" + // Deprecated:This is used to be compatible with old api. + // PodEvictedOverSubscriptionMemoryHighWaterMarkKey define the high watermark of memory usage when evicting offline pods + PodEvictedOverSubscriptionMemoryHighWaterMarkKey = "volcano.sh/oversubscription-evicting-memory-high-watermark" + // Deprecated:This is used to be compatible with old api. + // PodEvictedOverSubscriptionCPULowWaterMarkKey define the low watermark of cpu usage when the node could overSubscription resources + PodEvictedOverSubscriptionCPULowWaterMarkKey = "volcano.sh/oversubscription-evicting-cpu-low-watermark" + // Deprecated:This is used to be compatible with old api. + // PodEvictedOverSubscriptionMemoryLowWaterMarkKey define the low watermark of memory usage when the node could overSubscription resources + PodEvictedOverSubscriptionMemoryLowWaterMarkKey = "volcano.sh/oversubscription-evicting-memory-low-watermark" + + // PodEvictedCPUHighWaterMarkKey define the high watermark of cpu usage when evicting offline pods + PodEvictedCPUHighWaterMarkKey = "volcano.sh/evicting-cpu-high-watermark" + // PodEvictedMemoryHighWaterMarkKey define the high watermark of memory usage when evicting offline pods + PodEvictedMemoryHighWaterMarkKey = "volcano.sh/evicting-memory-high-watermark" + // PodEvictedCPULowWaterMarkKey define the low watermark of cpu usage when the node could overSubscription resources + PodEvictedCPULowWaterMarkKey = "volcano.sh/evicting-cpu-low-watermark" + // PodEvictedMemoryLowWaterMarkKey define the low watermark of memory usage when the node could overSubscription resources + PodEvictedMemoryLowWaterMarkKey = "volcano.sh/evicting-memory-low-watermark" + + // ResourceDefaultPrefix is the extended resource prefix. + ResourceDefaultPrefix = "kubernetes.io/" + + ExtendResourceCPU = ResourceDefaultPrefix + "batch-cpu" + ExtendResourceMemory = ResourceDefaultPrefix + "batch-memory" + + // ColocationPolicyKey is the label key of node custom colocation policy. + ColocationPolicyKey = "colocation-policy" +) + +var OverSubscriptionResourceTypes = []corev1.ResourceName{corev1.ResourceCPU, corev1.ResourceMemory} + +var OverSubscriptionResourceTypesIncludeExtendResources = []corev1.ResourceName{corev1.ResourceCPU, corev1.ResourceMemory, ExtendResourceCPU, ExtendResourceMemory} + +// Resource mapping resource type and usage. +type Resource map[corev1.ResourceName]int64 + +// Watermark defines resource eviction watermark. +type Watermark map[corev1.ResourceName]int diff --git a/pkg/agent/config/api/types.go b/pkg/agent/config/api/types.go new file mode 100644 index 000000000..7bc85bb2a --- /dev/null +++ b/pkg/agent/config/api/types.go @@ -0,0 +1,113 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package api + +import ( + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) + +// VolcanoAgentConfig include global and node colocation config. +type VolcanoAgentConfig struct { + // GlobalConfig is a global config for all nodes. + GlobalConfig *ColocationConfig `json:"globalConfig,omitempty"` + + // NodesConfig will overwrite GlobalConfig for selector matched nodes, which is usually nodePool level. + NodesConfig []NodesConfig `json:"nodesConfig,omitempty"` +} + +// NodeLabelConfig does not support getting from configmap +type NodeLabelConfig struct { + // NodeColocationEnable enables node colocation or not. + NodeColocationEnable *bool + // NodeColocationEnable enables node oversubscription or not. + NodeOverSubscriptionEnable *bool +} + +type NodesConfig struct { + // nodes that match label selector will apply current configuration + Selector *metav1.LabelSelector `json:"selector,omitempty"` + ColocationConfig `json:",inline"` +} + +type ColocationConfig struct { + // got from node labels + NodeLabelConfig *NodeLabelConfig `json:"-"` + + // cpu qos related config. + CPUQosConfig *CPUQos `json:"cpuQosConfig,omitempty" configKey:"CPUQoS"` + + // cpu burst related config. + CPUBurstConfig *CPUBurst `json:"cpuBurstConfig,omitempty" configKey:"CPUBurst"` + + // memory qos related config. + MemoryQosConfig *MemoryQos `json:"memoryQosConfig,omitempty" configKey:"MemoryQoS"` + + // network qos related config. + NetworkQosConfig *NetworkQos `json:"networkQosConfig,omitempty" configKey:"NetworkQoS"` + + // overSubscription related config. + OverSubscriptionConfig *OverSubscription `json:"overSubscriptionConfig,omitempty" configKey:"OverSubscription"` + + // Evicting related config. + EvictingConfig *Evicting `json:"evictingConfig,omitempty" configKey:"Evicting"` +} + +type CPUQos struct { + // Enable CPUQos or not. + Enable *bool `json:"enable,omitempty"` +} + +type CPUBurst struct { + // Enable CPUBurst or not. + Enable *bool `json:"enable,omitempty"` +} + +type MemoryQos struct { + // Enable MemoryQos or not. + Enable *bool `json:"enable,omitempty"` +} + +type NetworkQos struct { + // Enable NetworkQos or not. + Enable *bool `json:"enable,omitempty"` + // OnlineBandwidthWatermarkPercent presents the online bandwidth threshold percent. + OnlineBandwidthWatermarkPercent *int `json:"onlineBandwidthWatermarkPercent,omitempty"` + // OfflineLowBandwidthPercent presents the offline low bandwidth threshold percent. + OfflineLowBandwidthPercent *int `json:"offlineLowBandwidthPercent,omitempty"` + // OfflineHighBandwidthPercent presents the offline high bandwidth threshold percent. + OfflineHighBandwidthPercent *int `json:"offlineHighBandwidthPercent,omitempty"` + // QoSCheckInterval presents the network Qos checkout interval + QoSCheckInterval *int `json:"qosCheckInterval,omitempty"` +} + +type OverSubscription struct { + // Enable OverSubscription or not. + Enable *bool `json:"enable,omitempty"` + // OverSubscriptionTypes defines over subscription types, such as cpu,memory. + OverSubscriptionTypes *string `json:"overSubscriptionTypes,omitempty"` +} + +type Evicting struct { + // EvictingCPUHighWatermark defines the high watermark percent of cpu usage when evicting offline pods. + EvictingCPUHighWatermark *int `json:"evictingCPUHighWatermark,omitempty"` + // EvictingMemoryHighWatermark defines the high watermark percent of memory usage when evicting offline pods. + EvictingMemoryHighWatermark *int `json:"evictingMemoryHighWatermark,omitempty"` + // EvictingCPULowWatermark defines the low watermark percent of cpu usage when the node recover schedule pods. + EvictingCPULowWatermark *int `json:"evictingCPULowWatermark,omitempty"` + // EvictingMemoryLowWatermark defines the low watermark percent of memory usage when the node could recover schedule pods. + EvictingMemoryLowWatermark *int `json:"evictingMemoryLowWatermark,omitempty"` +} diff --git a/pkg/agent/config/api/validate.go b/pkg/agent/config/api/validate.go new file mode 100644 index 000000000..fb6d5e6cd --- /dev/null +++ b/pkg/agent/config/api/validate.go @@ -0,0 +1,146 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package api + +import ( + "errors" + "fmt" + "strings" +) + +var ( + IllegalQoSCheckIntervalMsg = "qosCheckInterval must be a positive number" + IllegalOnlineBandwidthWatermarkPercentMsg = "onlineBandwidthWatermarkPercent must be a positive number between 1 and 1000" + IllegalOfflineHighBandwidthPercentMsg = "offlineHighBandwidthPercent must be a positive number between 1 and 1000" + IllegalOfflineLowBandwidthPercentMsg = "offlineLowBandwidthPercent must be a positive number between 1 and 1000" + OfflineHighBandwidthPercentLessOfflineLowBandwidthPercentMsg = "offlineHighBandwidthPercent cannot be less than offlineLowBandwidthPercent" + IllegalEvictingCPUHighWatermark = "evictingCPUHighWatermark must be a positive number" + IllegalEvictingMemoryHighWatermark = "evictingMemoryHighWatermark must be a positive number" + IllegalEvictingCPULowWatermark = "evictingCPULowWatermark must be a positive number" + IllegalEvictingMemoryLowWatermark = "evictingMemoryLowWatermark must be a positive number" + EvictingCPULowWatermarkHigherThanHighWatermark = "cpu evicting low watermark is higher than high watermark" + EvictingMemoryLowWatermarkHigherThanHighWatermark = "memory evicting low watermark is higher than high watermark" + IllegalOverSubscriptionTypes = "overSubscriptionType(%s) is not supported, only supports cpu/memory" +) + +type Validate interface { + Validate() []error +} + +func (n *NodeLabelConfig) Validate() []error { + return nil +} + +func (c *CPUQos) Validate() []error { + return nil +} + +func (c *CPUBurst) Validate() []error { + return nil +} + +func (m *MemoryQos) Validate() []error { + return nil +} + +func (n *NetworkQos) Validate() []error { + if n == nil { + return nil + } + + var errs []error + if n.QoSCheckInterval != nil && *n.QoSCheckInterval <= 0 { + errs = append(errs, errors.New(IllegalQoSCheckIntervalMsg)) + } + + // Maximum Bandwidth may be several times the Baseline Bandwidth. + // Use 1000 ( 10 times the Baseline Bandwidth ) as the upper limit. + if n.OnlineBandwidthWatermarkPercent != nil && (*n.OnlineBandwidthWatermarkPercent <= 0 || *n.OnlineBandwidthWatermarkPercent > 1000) { + errs = append(errs, errors.New(IllegalOnlineBandwidthWatermarkPercentMsg)) + } + if n.OfflineHighBandwidthPercent != nil && (*n.OfflineHighBandwidthPercent <= 0 || *n.OfflineHighBandwidthPercent > 1000) { + errs = append(errs, errors.New(IllegalOfflineHighBandwidthPercentMsg)) + } + if n.OfflineLowBandwidthPercent != nil && (*n.OfflineLowBandwidthPercent <= 0 || *n.OfflineLowBandwidthPercent > 1000) { + errs = append(errs, errors.New(IllegalOfflineLowBandwidthPercentMsg)) + } + if n.OfflineLowBandwidthPercent != nil && n.OfflineHighBandwidthPercent != nil && (*n.OfflineLowBandwidthPercent > *n.OfflineHighBandwidthPercent) { + errs = append(errs, errors.New(OfflineHighBandwidthPercentLessOfflineLowBandwidthPercentMsg)) + } + return errs +} + +func (o *OverSubscription) Validate() []error { + if o == nil { + return nil + } + if o.OverSubscriptionTypes == nil || len(*o.OverSubscriptionTypes) == 0 { + return nil + } + + var errs []error + types := strings.Split(*o.OverSubscriptionTypes, ",") + for _, t := range types { + if t != "cpu" && t != "memory" { + errs = append(errs, fmt.Errorf(IllegalOverSubscriptionTypes, t)) + } + } + return errs +} + +func (e *Evicting) Validate() []error { + if e == nil { + return nil + } + + var errs []error + if e.EvictingCPUHighWatermark != nil && *e.EvictingCPUHighWatermark <= 0 { + errs = append(errs, errors.New(IllegalEvictingCPUHighWatermark)) + } + if e.EvictingMemoryHighWatermark != nil && *e.EvictingMemoryHighWatermark <= 0 { + errs = append(errs, errors.New(IllegalEvictingMemoryHighWatermark)) + } + if e.EvictingCPULowWatermark != nil && *e.EvictingCPULowWatermark <= 0 { + errs = append(errs, errors.New(IllegalEvictingCPULowWatermark)) + } + if e.EvictingMemoryLowWatermark != nil && *e.EvictingMemoryLowWatermark <= 0 { + errs = append(errs, errors.New(IllegalEvictingMemoryLowWatermark)) + } + if e.EvictingCPULowWatermark != nil && e.EvictingCPUHighWatermark != nil && (*e.EvictingCPULowWatermark > *e.EvictingCPUHighWatermark) { + errs = append(errs, errors.New(EvictingCPULowWatermarkHigherThanHighWatermark)) + } + if e.EvictingMemoryLowWatermark != nil && e.EvictingMemoryHighWatermark != nil && (*e.EvictingMemoryLowWatermark > *e.EvictingMemoryHighWatermark) { + errs = append(errs, errors.New(EvictingMemoryLowWatermarkHigherThanHighWatermark)) + } + return errs +} + +func (c *ColocationConfig) Validate() []error { + if c == nil { + return nil + } + var errs []error + + errs = append(errs, c.NodeLabelConfig.Validate()...) + errs = append(errs, c.CPUQosConfig.Validate()...) + errs = append(errs, c.CPUBurstConfig.Validate()...) + errs = append(errs, c.MemoryQosConfig.Validate()...) + errs = append(errs, c.NetworkQosConfig.Validate()...) + errs = append(errs, c.OverSubscriptionConfig.Validate()...) + errs = append(errs, c.EvictingConfig.Validate()...) + return errs +} diff --git a/pkg/agent/config/api/validate_test.go b/pkg/agent/config/api/validate_test.go new file mode 100644 index 000000000..edfa4573e --- /dev/null +++ b/pkg/agent/config/api/validate_test.go @@ -0,0 +1,149 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package api + +import ( + "errors" + "fmt" + "testing" + + "github.com/stretchr/testify/assert" + utilpointer "k8s.io/utils/pointer" +) + +func TestColocationConfigValidate(t *testing.T) { + testCases := []struct { + name string + colocationCfg *ColocationConfig + expectedErr []error + }{ + { + name: "legal configuration", + colocationCfg: &ColocationConfig{ + NodeLabelConfig: &NodeLabelConfig{ + NodeColocationEnable: utilpointer.Bool(false), + NodeOverSubscriptionEnable: utilpointer.Bool(false), + }, + CPUQosConfig: &CPUQos{Enable: utilpointer.Bool(true)}, + CPUBurstConfig: &CPUBurst{Enable: utilpointer.Bool(true)}, + MemoryQosConfig: &MemoryQos{Enable: utilpointer.Bool(true)}, + NetworkQosConfig: &NetworkQos{ + Enable: utilpointer.Bool(true), + OnlineBandwidthWatermarkPercent: utilpointer.Int(10), + OfflineLowBandwidthPercent: utilpointer.Int(10), + OfflineHighBandwidthPercent: utilpointer.Int(20), + QoSCheckInterval: utilpointer.Int(100), + }, + OverSubscriptionConfig: &OverSubscription{ + Enable: utilpointer.Bool(true), + OverSubscriptionTypes: utilpointer.String("cpu"), + }, + EvictingConfig: &Evicting{ + EvictingCPUHighWatermark: utilpointer.Int(20), + EvictingMemoryHighWatermark: utilpointer.Int(20), + EvictingCPULowWatermark: utilpointer.Int(10), + EvictingMemoryLowWatermark: utilpointer.Int(10), + }, + }, + }, + + { + name: "illegal NetworkQosConfig && negative parameters", + colocationCfg: &ColocationConfig{ + NetworkQosConfig: &NetworkQos{ + Enable: utilpointer.Bool(true), + OnlineBandwidthWatermarkPercent: utilpointer.Int(-10), + OfflineLowBandwidthPercent: utilpointer.Int(-20), + OfflineHighBandwidthPercent: utilpointer.Int(-20), + QoSCheckInterval: utilpointer.Int(-100), + }, + }, + expectedErr: []error{errors.New(IllegalQoSCheckIntervalMsg), errors.New(IllegalOnlineBandwidthWatermarkPercentMsg), + errors.New(IllegalOfflineHighBandwidthPercentMsg), errors.New(IllegalOfflineLowBandwidthPercentMsg)}, + }, + + { + name: "illegal NetworkQosConfig && OfflineLowBandwidthPercent higher than OfflineHighBandwidthPercent", + colocationCfg: &ColocationConfig{ + NetworkQosConfig: &NetworkQos{ + Enable: utilpointer.Bool(true), + OnlineBandwidthWatermarkPercent: utilpointer.Int(10), + OfflineLowBandwidthPercent: utilpointer.Int(20), + OfflineHighBandwidthPercent: utilpointer.Int(10), + QoSCheckInterval: utilpointer.Int(100), + }, + }, + expectedErr: []error{errors.New(OfflineHighBandwidthPercentLessOfflineLowBandwidthPercentMsg)}, + }, + + { + name: "illegal NetworkQosConfig && OfflineLowBandwidthPercent higher than OfflineHighBandwidthPercent", + colocationCfg: &ColocationConfig{ + NetworkQosConfig: &NetworkQos{ + Enable: utilpointer.Bool(true), + OnlineBandwidthWatermarkPercent: utilpointer.Int(10), + OfflineLowBandwidthPercent: utilpointer.Int(20), + OfflineHighBandwidthPercent: utilpointer.Int(10), + QoSCheckInterval: utilpointer.Int(100), + }, + }, + expectedErr: []error{errors.New(OfflineHighBandwidthPercentLessOfflineLowBandwidthPercentMsg)}, + }, + + { + name: "illegal EvictingConfig && negative parameters", + colocationCfg: &ColocationConfig{ + EvictingConfig: &Evicting{ + EvictingCPUHighWatermark: utilpointer.Int(-10), + EvictingMemoryHighWatermark: utilpointer.Int(-10), + EvictingCPULowWatermark: utilpointer.Int(-20), + EvictingMemoryLowWatermark: utilpointer.Int(-20), + }, + }, + expectedErr: []error{errors.New(IllegalEvictingCPUHighWatermark), errors.New(IllegalEvictingMemoryHighWatermark), + errors.New(IllegalEvictingCPULowWatermark), errors.New(IllegalEvictingMemoryLowWatermark)}, + }, + + { + name: "illegal OverSubscriptionConfig", + colocationCfg: &ColocationConfig{ + OverSubscriptionConfig: &OverSubscription{ + Enable: utilpointer.Bool(true), + OverSubscriptionTypes: utilpointer.String("fake"), + }, + }, + expectedErr: []error{fmt.Errorf(IllegalOverSubscriptionTypes, "fake")}, + }, + { + name: "cpu evicting low watermark higher high watermark", + colocationCfg: &ColocationConfig{ + EvictingConfig: &Evicting{ + EvictingCPUHighWatermark: utilpointer.Int(20), + EvictingMemoryHighWatermark: utilpointer.Int(30), + EvictingCPULowWatermark: utilpointer.Int(50), + EvictingMemoryLowWatermark: utilpointer.Int(80), + }, + }, + expectedErr: []error{errors.New(EvictingCPULowWatermarkHigherThanHighWatermark), errors.New(EvictingMemoryLowWatermarkHigherThanHighWatermark)}, + }, + } + + for _, tc := range testCases { + actualErrs := tc.colocationCfg.Validate() + assert.Equal(t, tc.expectedErr, actualErrs) + } +} diff --git a/pkg/agent/config/configmgr.go b/pkg/agent/config/configmgr.go new file mode 100644 index 000000000..3db53eef8 --- /dev/null +++ b/pkg/agent/config/configmgr.go @@ -0,0 +1,241 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package config + +import ( + "context" + "encoding/json" + "fmt" + "time" + + corev1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/errors" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + utilerrors "k8s.io/apimachinery/pkg/util/errors" + "k8s.io/apimachinery/pkg/util/wait" + clientset "k8s.io/client-go/kubernetes" + listersv1 "k8s.io/client-go/listers/core/v1" + "k8s.io/client-go/tools/record" + "k8s.io/client-go/util/workqueue" + "k8s.io/klog/v2" + utilpointer "k8s.io/utils/pointer" + + "volcano.sh/volcano/pkg/agent/config/api" + "volcano.sh/volcano/pkg/agent/config/source" + "volcano.sh/volcano/pkg/agent/config/utils" + "volcano.sh/volcano/pkg/config" +) + +type Listener interface { + SyncConfig(cfg *api.ColocationConfig) error +} + +type ConfigManager struct { + kubeClient clientset.Interface + configmapNamespace string + configmapName string + agentPodNamespace string + agentPodName string + source source.ConfigEventSource + listeners []Listener + podLister listersv1.PodLister + recorder record.EventRecorder +} + +func NewManager(config *config.Configuration, listeners []Listener) *ConfigManager { + return &ConfigManager{ + kubeClient: config.GenericConfiguration.KubeClient, + configmapNamespace: config.GenericConfiguration.KubePodNamespace, + configmapName: utils.ConfigMapName, + agentPodNamespace: config.GenericConfiguration.KubePodNamespace, + agentPodName: config.GenericConfiguration.KubePodName, + source: source.NewConfigMapSource(config.GenericConfiguration.KubeClient, config.GenericConfiguration.KubeNodeName, config.GenericConfiguration.KubePodNamespace), + listeners: listeners, + podLister: config.GenericConfiguration.PodLister, + recorder: config.GenericConfiguration.Recorder, + } +} + +func (m *ConfigManager) PrepareConfigmap() error { + getCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + + cm, getErr := m.kubeClient.CoreV1().ConfigMaps(m.configmapNamespace).Get(getCtx, m.configmapName, metav1.GetOptions{}) + if getErr == nil { + klog.InfoS("Configmap already exists", "name", m.configmapName, "namespace", m.configmapNamespace) + return m.updateConfigMap(cm) + } + + if !errors.IsNotFound(getErr) { + klog.ErrorS(getErr, "Failed to get configMap", "name", m.configmapName, "namespace", m.configmapNamespace) + return getErr + } + + klog.InfoS("configMap not found, will create a new one") + var lastCreateErr error + waitErr := wait.PollImmediate(200*time.Millisecond, time.Minute, func() (done bool, err error) { + _, createErr := m.kubeClient.CoreV1().ConfigMaps(m.configmapNamespace).Create(context.TODO(), &corev1.ConfigMap{ + ObjectMeta: metav1.ObjectMeta{ + Name: m.configmapName, + Namespace: m.configmapNamespace}, + Data: map[string]string{ + utils.ColocationConfigKey: utils.DefaultCfg, + }}, metav1.CreateOptions{}) + if errors.IsAlreadyExists(createErr) { + return true, nil + } + lastCreateErr = createErr + return createErr == nil, nil + }) + if waitErr != nil { + klog.ErrorS(waitErr, "Failed to wait for creating configMap") + return fmt.Errorf("failed to create configmap(%s:%s), waitting error: %v, latest creation error: %v", + m.agentPodNamespace, utils.ConfigMapName, waitErr, lastCreateErr) + } + return nil +} + +func (m *ConfigManager) updateConfigMap(cm *corev1.ConfigMap) error { + oldData := cm.Data[utils.ColocationConfigKey] + c := &api.VolcanoAgentConfig{} + if err := json.Unmarshal([]byte(oldData), c); err != nil { + return fmt.Errorf("failed to unmarshal old configMap data: %v", err) + } + + changed := false + if c.GlobalConfig == nil { + return fmt.Errorf("empty glaobal config") + } + if c.GlobalConfig.OverSubscriptionConfig == nil { + changed = true + c.GlobalConfig.OverSubscriptionConfig = &api.OverSubscription{ + Enable: utilpointer.Bool(true), + OverSubscriptionTypes: utilpointer.String(utils.DefaultOverSubscriptionTypes), + } + } + if c.GlobalConfig.EvictingConfig == nil { + changed = true + c.GlobalConfig.EvictingConfig = &api.Evicting{ + EvictingCPUHighWatermark: utilpointer.Int(utils.DefaultEvictingCPUHighWatermark), + EvictingMemoryHighWatermark: utilpointer.Int(utils.DefaultEvictingMemoryHighWatermark), + EvictingCPULowWatermark: utilpointer.Int(utils.DefaultEvictingCPULowWatermark), + EvictingMemoryLowWatermark: utilpointer.Int(utils.DefaultEvictingMemoryLowWatermark), + } + } + if !changed { + return nil + } + + newData, err := json.MarshalIndent(c, "", " ") + if err != nil { + return fmt.Errorf("failed to marshal configMap: %v", err) + } + cm.Data[utils.ColocationConfigKey] = string(newData) + _, err = m.kubeClient.CoreV1().ConfigMaps(m.configmapNamespace).Update(context.TODO(), cm, metav1.UpdateOptions{}) + if err == nil { + klog.InfoS("Successfully updated volcano agent configMap") + return nil + } + return err +} + +func (m *ConfigManager) Start(ctx context.Context) error { + klog.InfoS("Start configuration manager") + if err := m.PrepareConfigmap(); err != nil { + return err + } + + changesQueue, err := m.source.Source(ctx.Done()) + if err != nil { + return err + } + if err = m.notifyListeners(); err != nil { + klog.ErrorS(err, "Failed to notify all listeners, retry by process chanagesQueue") + } + + go func() { + for { + select { + case <-ctx.Done(): + return + default: + if !m.process(changesQueue) { + return + } + } + } + }() + klog.InfoS("Successfully started configuration manager") + return nil +} + +func (m *ConfigManager) process(changedQueue workqueue.RateLimitingInterface) bool { + key, quit := changedQueue.Get() + if quit { + return false + } + defer changedQueue.Done(key) + + pod, getErr := m.getAgentPod() + if getErr != nil { + klog.ErrorS(getErr, "Failed to get agent pod", "namespace", m.agentPodNamespace, "name", m.agentPodName) + } + + err := m.notifyListeners() + if err != nil { + if pod != nil { + m.recorder.Event(pod, corev1.EventTypeWarning, "ConfigApplyFailed", fmt.Sprintf("Failed to apply config(%v)", err)) + } + klog.ErrorS(err, "Failed to notify listeners") + changedQueue.AddRateLimited(key) + return true + } + + if pod != nil { + m.recorder.Event(pod, corev1.EventTypeNormal, "ConfigApplySuccess", "Successfully applied config") + } + klog.InfoS("Successfully notified listeners") + changedQueue.Forget(key) + return true +} + +func (m *ConfigManager) notifyListeners() error { + config, err := m.source.GetLatestConfig() + if err != nil { + return err + } + + var errs []error + for _, listener := range m.listeners { + if syncErr := listener.SyncConfig(config); syncErr != nil { + errs = append(errs, syncErr) + } + } + return utilerrors.NewAggregate(errs) +} + +func (m *ConfigManager) getAgentPod() (*corev1.Pod, error) { + pod, err := m.podLister.Pods(m.agentPodNamespace).Get(m.agentPodName) + if err == nil { + return pod, nil + } + + if !errors.IsNotFound(err) { + return nil, err + } + return m.kubeClient.CoreV1().Pods(m.agentPodNamespace).Get(context.TODO(), m.agentPodName, metav1.GetOptions{}) +} diff --git a/pkg/agent/config/configmgr_test.go b/pkg/agent/config/configmgr_test.go new file mode 100644 index 000000000..70a16b8b8 --- /dev/null +++ b/pkg/agent/config/configmgr_test.go @@ -0,0 +1,307 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package config + +import ( + "context" + "encoding/json" + "errors" + "testing" + "time" + + "github.com/stretchr/testify/assert" + "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/client-go/informers" + "k8s.io/client-go/kubernetes/fake" + "k8s.io/client-go/tools/cache" + "k8s.io/client-go/tools/record" + "k8s.io/client-go/util/workqueue" + utilpointer "k8s.io/utils/pointer" + + "volcano.sh/volcano/pkg/agent/config/api" + "volcano.sh/volcano/pkg/agent/config/source" + "volcano.sh/volcano/pkg/agent/config/utils" +) + +var oldCfg = ` +{ + "globalConfig":{ + "cpuBurstConfig":{ + "enable":true + }, + "networkQosConfig":{ + "enable":true, + "onlineBandwidthWatermarkPercent":80, + "offlineLowBandwidthPercent":10, + "offlineHighBandwidthPercent":40, + "qosCheckInterval": 10000000 + } + } +} +` + +var oldCfgWithSelector = ` +{ + "globalConfig":{ + "cpuBurstConfig":{ + "enable":true + }, + "networkQosConfig":{ + "enable":true, + "onlineBandwidthWatermarkPercent":80, + "offlineLowBandwidthPercent":10, + "offlineHighBandwidthPercent":40, + "qosCheckInterval": 10000000 + }, + "overSubscriptionConfig":{ + "enable":true, + "overSubscriptionTypes":"cpu,memory" + }, + "evictingConfig":{ + "evictingCPUHighWatermark":80, + "evictingMemoryHighWatermark":60, + "evictingCPULowWatermark":30, + "evictingMemoryLowWatermark":30 + } + }, + "nodesConfig": [ + { + "selector": { + "matchLabels": { + "label-key": "label-value" + } + }, + "evictingConfig": { + "evictingCPUHighWatermark": 60 + } + } + ] +} +` + +func makeConfigMap(data string) *v1.ConfigMap { + return &v1.ConfigMap{ + ObjectMeta: metav1.ObjectMeta{ + Namespace: "kube-system", + Name: "volcano-agent-configuration"}, + Data: map[string]string{ + utils.ColocationConfigKey: data, + }, + } +} + +var agentPod = &v1.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Namespace: "kube-system", + Name: "volcano-agent-pod"}, +} + +func defaultCfg() *api.VolcanoAgentConfig { + return &api.VolcanoAgentConfig{GlobalConfig: &api.ColocationConfig{ + CPUBurstConfig: &api.CPUBurst{Enable: utilpointer.Bool(true)}, + NetworkQosConfig: &api.NetworkQos{ + Enable: utilpointer.Bool(true), + OnlineBandwidthWatermarkPercent: utilpointer.Int(utils.DefaultOnlineBandwidthWatermarkPercent), + OfflineLowBandwidthPercent: utilpointer.Int(utils.DefaultOfflineLowBandwidthPercent), + OfflineHighBandwidthPercent: utilpointer.Int(utils.DefaultOfflineHighBandwidthPercent), + QoSCheckInterval: utilpointer.Int(utils.DefaultNetworkQoSInterval), + }, + OverSubscriptionConfig: &api.OverSubscription{ + Enable: utilpointer.Bool(true), + OverSubscriptionTypes: utilpointer.String(utils.DefaultOverSubscriptionTypes), + }, + EvictingConfig: &api.Evicting{ + EvictingCPUHighWatermark: utilpointer.Int(utils.DefaultEvictingCPUHighWatermark), + EvictingMemoryHighWatermark: utilpointer.Int(utils.DefaultEvictingMemoryHighWatermark), + EvictingCPULowWatermark: utilpointer.Int(utils.DefaultEvictingCPULowWatermark), + EvictingMemoryLowWatermark: utilpointer.Int(utils.DefaultEvictingMemoryLowWatermark), + }, + }} +} + +func TestPrepareConfigmap(t *testing.T) { + tests := []struct { + name string + initialObjects []runtime.Object + expectedErrIsNil bool + expectedConfig *api.VolcanoAgentConfig + }{ + { + name: "configmap-existed and update", + initialObjects: []runtime.Object{makeConfigMap(oldCfg)}, + expectedErrIsNil: true, + expectedConfig: defaultCfg(), + }, + { + name: "configmap-existed and no update", + initialObjects: []runtime.Object{makeConfigMap(oldCfgWithSelector)}, + expectedErrIsNil: true, + expectedConfig: &api.VolcanoAgentConfig{GlobalConfig: &api.ColocationConfig{ + CPUBurstConfig: &api.CPUBurst{Enable: utilpointer.Bool(true)}, + NetworkQosConfig: &api.NetworkQos{ + Enable: utilpointer.Bool(true), + OnlineBandwidthWatermarkPercent: utilpointer.Int(utils.DefaultOnlineBandwidthWatermarkPercent), + OfflineLowBandwidthPercent: utilpointer.Int(utils.DefaultOfflineLowBandwidthPercent), + OfflineHighBandwidthPercent: utilpointer.Int(utils.DefaultOfflineHighBandwidthPercent), + QoSCheckInterval: utilpointer.Int(utils.DefaultNetworkQoSInterval), + }, + OverSubscriptionConfig: &api.OverSubscription{ + Enable: utilpointer.Bool(true), + OverSubscriptionTypes: utilpointer.String(utils.DefaultOverSubscriptionTypes), + }, + EvictingConfig: &api.Evicting{ + EvictingCPUHighWatermark: utilpointer.Int(utils.DefaultEvictingCPUHighWatermark), + EvictingMemoryHighWatermark: utilpointer.Int(utils.DefaultEvictingMemoryHighWatermark), + EvictingCPULowWatermark: utilpointer.Int(utils.DefaultEvictingCPULowWatermark), + EvictingMemoryLowWatermark: utilpointer.Int(utils.DefaultEvictingMemoryLowWatermark), + }, + }, + NodesConfig: []api.NodesConfig{ + { + Selector: &metav1.LabelSelector{ + MatchLabels: map[string]string{ + "label-key": "label-value", + }, + }, + ColocationConfig: api.ColocationConfig{EvictingConfig: &api.Evicting{ + EvictingCPUHighWatermark: utilpointer.Int(60), + }}, + }, + }}, + }, + { + name: "configmap-not-existed", + initialObjects: []runtime.Object{}, + expectedErrIsNil: true, + expectedConfig: defaultCfg(), + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + client := fake.NewSimpleClientset(tc.initialObjects...) + mgr := &ConfigManager{ + kubeClient: client, + configmapNamespace: "kube-system", + configmapName: "volcano-agent-configuration", + } + actualErr := mgr.PrepareConfigmap() + assert.Equal(t, tc.expectedErrIsNil, actualErr == nil) + cm, err := client.CoreV1().ConfigMaps("kube-system").Get(context.TODO(), "volcano-agent-configuration", metav1.GetOptions{}) + assert.NoError(t, err) + c := &api.VolcanoAgentConfig{} + err = json.Unmarshal([]byte(cm.Data[utils.ColocationConfigKey]), c) + assert.NoError(t, err) + assert.Equal(t, tc.expectedConfig, c) + }) + + } +} + +type FakeListener struct { + called int + initial bool + errors int +} + +func (l *FakeListener) SyncConfig(cfg *api.ColocationConfig) error { + l.called++ + if !l.initial { + l.initial = true + return nil + } + if l.errors == 0 { + return nil + } + l.errors-- + return errors.New("error") +} + +type FakeRateLimiter struct{} + +func (r *FakeRateLimiter) When(item interface{}) time.Duration { + return 0 +} + +func (r *FakeRateLimiter) NumRequeues(item interface{}) int { + return 0 +} + +func (r *FakeRateLimiter) Forget(item interface{}) {} + +func TestStart(t *testing.T) { + tests := []struct { + name string + initialObjects []runtime.Object + sourceQueueObjects []interface{} + ListerSyncErrTimes int + expectedNotifyCalled int + expectedErrIsNil bool + }{ + { + name: "without-sync-retry", + initialObjects: []runtime.Object{makeConfigMap(utils.DefaultCfg)}, + sourceQueueObjects: []interface{}{"node", "configmap"}, + ListerSyncErrTimes: 0, + expectedNotifyCalled: 3, + expectedErrIsNil: true, + }, + { + name: "with-sync-retry", + initialObjects: []runtime.Object{makeConfigMap(utils.DefaultCfg)}, + sourceQueueObjects: []interface{}{"node", "configmap"}, + ListerSyncErrTimes: 2, + expectedNotifyCalled: 5, + expectedErrIsNil: true, + }, + } + + fakeClient := fake.NewSimpleClientset(agentPod) + informerFactory := informers.NewSharedInformerFactory(fakeClient, 0) + informerFactory.Core().V1().Pods().Informer() + informerFactory.Start(context.TODO().Done()) + cache.WaitForNamedCacheSync("", context.TODO().Done(), informerFactory.Core().V1().Pods().Informer().HasSynced) + + for _, tc := range tests { + l := &FakeListener{ + errors: tc.ListerSyncErrTimes, + } + queue := workqueue.NewNamedRateLimitingQueue(&FakeRateLimiter{}, "configmap-resource") + for _, ob := range tc.sourceQueueObjects { + queue.Add(ob) + } + s := source.NewFakeSource(queue) + client := fake.NewSimpleClientset(tc.initialObjects...) + mgr := &ConfigManager{ + kubeClient: client, + configmapNamespace: "kube-system", + configmapName: "volcano-agent-configuration", + agentPodNamespace: "kube-system", + agentPodName: "volcano-agent-pod", + source: s, + listeners: []Listener{l}, + podLister: informerFactory.Core().V1().Pods().Lister(), + recorder: &record.FakeRecorder{}, + } + actualErr := mgr.Start(context.TODO()) + s.Stop() + assert.Equal(t, tc.expectedErrIsNil, actualErr == nil) + assert.Equal(t, tc.expectedNotifyCalled, l.called) + } +} diff --git a/pkg/agent/config/source/configmap_source.go b/pkg/agent/config/source/configmap_source.go new file mode 100644 index 000000000..7f337a607 --- /dev/null +++ b/pkg/agent/config/source/configmap_source.go @@ -0,0 +1,155 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package source + +import ( + "encoding/json" + "fmt" + "time" + + "golang.org/x/time/rate" + corev1 "k8s.io/api/core/v1" + v1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/fields" + "k8s.io/client-go/informers" + coreinformers "k8s.io/client-go/informers/core/v1" + clientset "k8s.io/client-go/kubernetes" + "k8s.io/client-go/tools/cache" + "k8s.io/client-go/util/workqueue" + "k8s.io/klog/v2" + + "volcano.sh/volcano/pkg/agent/apis" + "volcano.sh/volcano/pkg/agent/config/api" + "volcano.sh/volcano/pkg/agent/config/utils" +) + +type configMapSource struct { + kubeClient clientset.Interface + informerFactory informers.SharedInformerFactory + configMapListerSynced cache.InformerSynced + nodeListerSynced cache.InformerSynced + queue workqueue.RateLimitingInterface + nodeName string + configmapNamespace string + configmapName string +} + +func NewConfigMapSource(client clientset.Interface, nodeName, namespace string) ConfigEventSource { + tweakListOptions := func(options *metav1.ListOptions) { + options.FieldSelector = fields.OneTermEqualSelector(utils.ObjectNameField, utils.ConfigMapName).String() + } + informerFactory := informers.NewSharedInformerFactory(client, 0) + configMapInformer := informerFactory.InformerFor(&v1.ConfigMap{}, + func(client clientset.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return coreinformers.NewFilteredConfigMapInformer(client, namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, tweakListOptions) + }) + nodeInformer := informerFactory.InformerFor(&corev1.Node{}, + func(client clientset.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + tweakListOptions := func(options *metav1.ListOptions) { + options.FieldSelector = fields.OneTermEqualSelector(metav1.ObjectNameField, nodeName).String() + } + return coreinformers.NewFilteredNodeInformer(client, resyncPeriod, cache.Indexers{}, tweakListOptions) + }) + cs := &configMapSource{ + informerFactory: informerFactory, + configMapListerSynced: configMapInformer.HasSynced, + nodeListerSynced: nodeInformer.HasSynced, + kubeClient: client, + queue: workqueue.NewNamedRateLimitingQueue(workqueue.NewMaxOfRateLimiter( + workqueue.NewItemExponentialFailureRateLimiter(500*time.Millisecond, 1000*time.Second), + &workqueue.BucketRateLimiter{Limiter: rate.NewLimiter(rate.Limit(10), 100)}), "configmap-resource"), + nodeName: nodeName, + configmapNamespace: namespace, + configmapName: utils.ConfigMapName, + } + configMapInformer.AddEventHandler(cache.ResourceEventHandlerFuncs{ + AddFunc: func(obj interface{}) { cs.queue.Add("configmap") }, + UpdateFunc: func(oldObj, newObj interface{}) { cs.queue.Add("configmap") }, + }) + nodeInformer.AddEventHandler(cache.ResourceEventHandlerFuncs{ + AddFunc: func(obj interface{}) { cs.nodeAdd(obj) }, + UpdateFunc: func(oldObj, newObj interface{}) { cs.nodeUpdate(oldObj, newObj) }, + }) + + return cs +} + +func (cs *configMapSource) nodeAdd(obj interface{}) { + cs.queue.Add("node") +} + +func (cs *configMapSource) nodeUpdate(oldObj, newObj interface{}) { + oldNode, ok := oldObj.(*corev1.Node) + if !ok { + klog.ErrorS(nil, "can not covert interface object to Node", "oldobj", oldObj) + cs.queue.Add("node") + return + } + + newNode, ok := newObj.(*corev1.Node) + if !ok { + klog.ErrorS(nil, "can not covert interface object to Node", "newobj", newObj) + cs.queue.Add("node") + return + } + + if oldNode.Labels[apis.ColocationEnableNodeLabelKey] == newNode.Labels[apis.ColocationEnableNodeLabelKey] && + oldNode.Labels[apis.OverSubscriptionNodeLabelKey] == newNode.Labels[apis.OverSubscriptionNodeLabelKey] && + oldNode.Labels[apis.ColocationPolicyKey] == newNode.Labels[apis.ColocationPolicyKey] { + return + } + cs.queue.Add("node") +} + +func (cs *configMapSource) GetLatestConfig() (cfg *api.ColocationConfig, err error) { + node, err := cs.informerFactory.Core().V1().Nodes().Lister().Get(cs.nodeName) + if err != nil { + klog.ErrorS(err, "Failed to get node", "node", cs.nodeName) + return nil, err + } + + configmap, err := cs.informerFactory.Core().V1().ConfigMaps().Lister().ConfigMaps(cs.configmapNamespace).Get(cs.configmapName) + if err != nil { + klog.ErrorS(err, "Failed to get configmap", "name", cs.configmapName) + return nil, err + } + + config := &api.VolcanoAgentConfig{} + data, ok := configmap.Data[utils.ColocationConfigKey] + if !ok || len(data) == 0 { + return nil, fmt.Errorf("configMap data(%s) is empty", utils.ColocationConfigKey) + } + if err = json.Unmarshal([]byte(data), config); err != nil { + return nil, err + } + return utils.MergerCfg(config, node) +} + +func (cs *configMapSource) Source(stopCh <-chan struct{}) (change workqueue.RateLimitingInterface, err error) { + cs.informerFactory.Start(stopCh) + if !cache.WaitForCacheSync(stopCh, cs.configMapListerSynced, cs.nodeListerSynced) { + return nil, fmt.Errorf("timed out waiting for mapfigmap source caches to sync") + } + + go func() { + <-stopCh + cs.queue.ShutDown() + }() + + return cs.queue, nil +} diff --git a/pkg/agent/config/source/fake_source.go b/pkg/agent/config/source/fake_source.go new file mode 100644 index 000000000..1a85cfe23 --- /dev/null +++ b/pkg/agent/config/source/fake_source.go @@ -0,0 +1,54 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package source + +import ( + "time" + + "k8s.io/client-go/util/workqueue" + + "volcano.sh/volcano/pkg/agent/config/api" +) + +type fakeSource struct { + queue workqueue.RateLimitingInterface + cfg *api.ColocationConfig +} + +func NewFakeSource(queue workqueue.RateLimitingInterface) *fakeSource { + return &fakeSource{ + queue: queue, + } +} + +func (f *fakeSource) Source(stopCh <-chan struct{}) (change workqueue.RateLimitingInterface, err error) { + return f.queue, nil +} + +func (f *fakeSource) GetLatestConfig() (cfg *api.ColocationConfig, err error) { + return f.cfg, nil +} + +func (f *fakeSource) Stop() { + for { + if f.queue.Len() == 0 { + f.queue.ShutDown() + return + } + time.Sleep(1 * time.Second) + } +} diff --git a/pkg/agent/config/source/file_source.go b/pkg/agent/config/source/file_source.go new file mode 100644 index 000000000..25b12f040 --- /dev/null +++ b/pkg/agent/config/source/file_source.go @@ -0,0 +1,44 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package source + +import ( + "os" + + "k8s.io/client-go/util/workqueue" + + "volcano.sh/volcano/pkg/agent/config/api" +) + +// TODO: implement file source. +type fileSource struct { + filePath string + queue workqueue.RateLimitingInterface +} + +func NewFileSource(filePath string) ConfigEventSource { + return &fileSource{} +} + +func (f *fileSource) Source(stopCh <-chan struct{}) (change workqueue.RateLimitingInterface, err error) { + return f.queue, nil +} + +func (f *fileSource) GetLatestConfig() (cfg *api.ColocationConfig, err error) { + _, err = os.ReadFile(f.filePath) + return nil, err +} diff --git a/pkg/agent/config/source/interface.go b/pkg/agent/config/source/interface.go new file mode 100644 index 000000000..3dffc98fc --- /dev/null +++ b/pkg/agent/config/source/interface.go @@ -0,0 +1,31 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package source + +import ( + "k8s.io/client-go/util/workqueue" + + "volcano.sh/volcano/pkg/agent/config/api" +) + +// ConfigEventSource is the source of config. +type ConfigEventSource interface { + // Source returns the queue with rateLimited, + Source(stopCh <-chan struct{}) (change workqueue.RateLimitingInterface, err error) + // GetLatestConfig returns the latest colocation configuration from source + GetLatestConfig() (cfg *api.ColocationConfig, err error) +} diff --git a/pkg/agent/config/utils/utils.go b/pkg/agent/config/utils/utils.go new file mode 100644 index 000000000..ae156fa05 --- /dev/null +++ b/pkg/agent/config/utils/utils.go @@ -0,0 +1,178 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package utils + +import ( + "reflect" + + "github.com/imdario/mergo" + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/labels" + utilerrors "k8s.io/apimachinery/pkg/util/errors" + "k8s.io/klog/v2" + utilpointer "k8s.io/utils/pointer" + + "volcano.sh/volcano/pkg/agent/config/api" + utilnode "volcano.sh/volcano/pkg/agent/utils/node" +) + +const ( + ConfigMapName = "volcano-agent-configuration" + ColocationConfigKey = "colocation-config" + ObjectNameField = "metadata.name" +) + +const ( + // Network Qos config + DefaultOnlineBandwidthWatermarkPercent = 80 + DefaultOfflineLowBandwidthPercent = 10 + DefaultOfflineHighBandwidthPercent = 40 + DefaultNetworkQoSInterval = 10000000 // 1000000 纳秒 = 10 毫秒 + + // OverSubscription config + DefaultOverSubscriptionTypes = "cpu,memory" + + // Evicting config + DefaultEvictingCPUHighWatermark = 80 + DefaultEvictingMemoryHighWatermark = 60 + DefaultEvictingCPULowWatermark = 30 + DefaultEvictingMemoryLowWatermark = 30 +) + +const ( + DefaultCfg = ` +{ + "globalConfig":{ + "cpuBurstConfig":{ + "enable":true + }, + "networkQosConfig":{ + "enable":true, + "onlineBandwidthWatermarkPercent":80, + "offlineLowBandwidthPercent":10, + "offlineHighBandwidthPercent":40, + "qosCheckInterval": 10000000 + }, + "overSubscriptionConfig":{ + "enable":true, + "overSubscriptionTypes":"cpu,memory" + }, + "evictingConfig":{ + "evictingCPUHighWatermark":80, + "evictingMemoryHighWatermark":60, + "evictingCPULowWatermark":30, + "evictingMemoryLowWatermark":30 + } + } +} +` +) + +// DefaultColocationConfig is the default colocation config. +func DefaultColocationConfig() *api.ColocationConfig { + return &api.ColocationConfig{ + NodeLabelConfig: &api.NodeLabelConfig{ + NodeColocationEnable: utilpointer.Bool(false), + NodeOverSubscriptionEnable: utilpointer.Bool(false), + }, + CPUQosConfig: &api.CPUQos{Enable: utilpointer.Bool(true)}, + CPUBurstConfig: &api.CPUBurst{Enable: utilpointer.Bool(true)}, + MemoryQosConfig: &api.MemoryQos{Enable: utilpointer.Bool(true)}, + NetworkQosConfig: &api.NetworkQos{ + Enable: utilpointer.Bool(true), + OnlineBandwidthWatermarkPercent: utilpointer.Int(DefaultOnlineBandwidthWatermarkPercent), + OfflineLowBandwidthPercent: utilpointer.Int(DefaultOfflineLowBandwidthPercent), + OfflineHighBandwidthPercent: utilpointer.Int(DefaultOfflineHighBandwidthPercent), + QoSCheckInterval: utilpointer.Int(DefaultNetworkQoSInterval), + }, + OverSubscriptionConfig: &api.OverSubscription{ + Enable: utilpointer.Bool(true), + OverSubscriptionTypes: utilpointer.String(DefaultOverSubscriptionTypes), + }, + EvictingConfig: &api.Evicting{ + EvictingCPUHighWatermark: utilpointer.Int(DefaultEvictingCPUHighWatermark), + EvictingMemoryHighWatermark: utilpointer.Int(DefaultEvictingMemoryHighWatermark), + EvictingCPULowWatermark: utilpointer.Int(DefaultEvictingCPULowWatermark), + EvictingMemoryLowWatermark: utilpointer.Int(DefaultEvictingMemoryLowWatermark), + }, + } +} + +// DefaultVolcanoAgentConfig returns default volcano agent config. +func DefaultVolcanoAgentConfig() *api.VolcanoAgentConfig { + return &api.VolcanoAgentConfig{ + GlobalConfig: DefaultColocationConfig(), + } +} + +type nullTransformer struct { +} + +// Transformer temporary solution, waiting https://github.com/imdario/mergo/issues/131 to be fixed. +func (t *nullTransformer) Transformer(typ reflect.Type) func(dst, src reflect.Value) error { + if typ.Kind() == reflect.Pointer && typ.Elem().Kind() != reflect.Struct { + return func(dst, src reflect.Value) error { + if dst.CanSet() && !src.IsNil() { + dst.Set(src) + } + return nil + } + } + return nil +} + +func MergerCfg(fullConfig *api.VolcanoAgentConfig, node *corev1.Node) (*api.ColocationConfig, error) { + mergedCfg := DefaultColocationConfig() + defaultCfg := DefaultColocationConfig() + if fullConfig == nil || fullConfig.GlobalConfig == nil { + klog.InfoS("full or global config is nil, use default config") + return defaultCfg, nil + } + + if err := mergo.Merge(mergedCfg, fullConfig.GlobalConfig, mergo.WithOverride, mergo.WithTransformers(&nullTransformer{})); err != nil { + klog.ErrorS(err, "Failed to merge default and global config, use default config") + return defaultCfg, nil + } + + nodeCfg := &api.ColocationConfig{} + for idx := range fullConfig.NodesConfig { + selector, err := metav1.LabelSelectorAsSelector(fullConfig.NodesConfig[idx].Selector) + if err != nil || !selector.Matches(labels.Set(node.Labels)) { + continue + } + // choose the last config if multi labels matched. + nodeCfg = &fullConfig.NodesConfig[idx].ColocationConfig + } + + if err := mergo.Merge(mergedCfg, nodeCfg, mergo.WithOverride, mergo.WithTransformers(&nullTransformer{})); err != nil { + klog.ErrorS(err, "Failed to merge node config") + return mergedCfg, err + } + + enableOverSubscription := utilpointer.Bool(utilnode.IsNodeSupportOverSubscription(node)) + mergedCfg.NodeLabelConfig.NodeColocationEnable = utilpointer.Bool(utilnode.IsNodeSupportColocation(node) || *enableOverSubscription) + mergedCfg.NodeLabelConfig.NodeOverSubscriptionEnable = enableOverSubscription + + validateErr := utilerrors.NewAggregate(mergedCfg.Validate()) + if validateErr != nil { + klog.ErrorS(validateErr, "Config is invalid, keep original config") + return mergedCfg, validateErr + } + + return mergedCfg, nil +} diff --git a/pkg/agent/config/utils/utils_test.go b/pkg/agent/config/utils/utils_test.go new file mode 100644 index 000000000..b9e98b113 --- /dev/null +++ b/pkg/agent/config/utils/utils_test.go @@ -0,0 +1,255 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package utils + +import ( + "testing" + + "github.com/stretchr/testify/assert" + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + utilpointer "k8s.io/utils/pointer" + + "volcano.sh/volcano/pkg/agent/apis" + "volcano.sh/volcano/pkg/agent/config/api" +) + +func TestMergerCfg(t *testing.T) { + tests := []struct { + name string + volcanoCfg *api.VolcanoAgentConfig + node *corev1.Node + wantCfg *api.ColocationConfig + wantErr bool + }{ + { + name: "disable cpu qos && disable cpu burst", + volcanoCfg: &api.VolcanoAgentConfig{ + GlobalConfig: &api.ColocationConfig{ + CPUQosConfig: &api.CPUQos{Enable: utilpointer.Bool(false)}, + CPUBurstConfig: &api.CPUBurst{Enable: utilpointer.Bool(false)}, + }, + }, + node: &corev1.Node{ + ObjectMeta: metav1.ObjectMeta{}, + }, + wantCfg: disableCPUBurst(disableCPUBurst(disableCPUQos(DefaultColocationConfig()))), + wantErr: false, + }, + + { + name: "disable memory qos && disable overSubscription", + volcanoCfg: &api.VolcanoAgentConfig{ + GlobalConfig: &api.ColocationConfig{ + MemoryQosConfig: &api.MemoryQos{Enable: utilpointer.Bool(false)}, + OverSubscriptionConfig: &api.OverSubscription{Enable: utilpointer.Bool(false)}, + }, + }, + node: &corev1.Node{ + ObjectMeta: metav1.ObjectMeta{ + Labels: map[string]string{ + apis.ColocationEnableNodeLabelKey: "true", + apis.OverSubscriptionNodeLabelKey: "true", + }, + }, + }, + wantCfg: disableOverSubscription(disableMemoryQos(enableNodeOverSubscription(enableNodeColocation(DefaultColocationConfig())))), + wantErr: false, + }, + + { + name: "disable network qos", + volcanoCfg: &api.VolcanoAgentConfig{ + GlobalConfig: &api.ColocationConfig{ + NetworkQosConfig: &api.NetworkQos{Enable: utilpointer.Bool(false)}, + }, + }, + node: &corev1.Node{ + ObjectMeta: metav1.ObjectMeta{ + Labels: map[string]string{ + apis.ColocationEnableNodeLabelKey: "true", + }, + }, + }, + wantCfg: disableNetworkQos(enableNodeColocation(DefaultColocationConfig())), + wantErr: false, + }, + + { + name: "modify network qos", + volcanoCfg: &api.VolcanoAgentConfig{ + GlobalConfig: &api.ColocationConfig{ + NetworkQosConfig: &api.NetworkQos{ + OnlineBandwidthWatermarkPercent: utilpointer.Int(15), + OfflineLowBandwidthPercent: utilpointer.Int(16), + OfflineHighBandwidthPercent: utilpointer.Int(17), + }, + }, + }, + node: &corev1.Node{ + ObjectMeta: metav1.ObjectMeta{ + Labels: map[string]string{ + apis.OverSubscriptionNodeLabelKey: "true", + }, + }, + }, + wantCfg: withNewNetworkQoS(enableNodeOverSubscription(enableNodeColocation(DefaultColocationConfig())), &api.NetworkQos{ + Enable: utilpointer.Bool(true), + QoSCheckInterval: utilpointer.Int(10000000), + OnlineBandwidthWatermarkPercent: utilpointer.Int(15), + OfflineLowBandwidthPercent: utilpointer.Int(16), + OfflineHighBandwidthPercent: utilpointer.Int(17), + }), + wantErr: false, + }, + + { + name: "modify network qos && OnlineBandwidthWatermarkPercent=0", + volcanoCfg: &api.VolcanoAgentConfig{ + GlobalConfig: &api.ColocationConfig{ + NetworkQosConfig: &api.NetworkQos{ + OnlineBandwidthWatermarkPercent: utilpointer.Int(0), + OfflineLowBandwidthPercent: utilpointer.Int(18), + OfflineHighBandwidthPercent: utilpointer.Int(19), + }, + }, + }, + node: &corev1.Node{ + ObjectMeta: metav1.ObjectMeta{ + Labels: map[string]string{ + apis.OverSubscriptionNodeLabelKey: "true", + }, + }, + }, + wantCfg: withNewNetworkQoS(enableNodeOverSubscription(enableNodeColocation(DefaultColocationConfig())), &api.NetworkQos{ + Enable: utilpointer.Bool(true), + QoSCheckInterval: utilpointer.Int(10000000), + OnlineBandwidthWatermarkPercent: utilpointer.Int(0), + OfflineLowBandwidthPercent: utilpointer.Int(18), + OfflineHighBandwidthPercent: utilpointer.Int(19), + }), + wantErr: true, + }, + + { + name: "modify OverSubscription && OverSubscriptionTypes=\"\"", + volcanoCfg: &api.VolcanoAgentConfig{ + GlobalConfig: &api.ColocationConfig{ + OverSubscriptionConfig: &api.OverSubscription{ + Enable: utilpointer.Bool(true), + OverSubscriptionTypes: utilpointer.String(""), + }, + }, + }, + node: &corev1.Node{ + ObjectMeta: metav1.ObjectMeta{ + Labels: map[string]string{ + apis.OverSubscriptionNodeLabelKey: "true", + }, + }, + }, + wantCfg: withNewOverSubscription(enableNodeOverSubscription(enableNodeColocation(DefaultColocationConfig())), &api.OverSubscription{ + Enable: utilpointer.Bool(true), + OverSubscriptionTypes: utilpointer.String(""), + }), + wantErr: false, + }, + { + name: "overwrite default config label selector", + volcanoCfg: &api.VolcanoAgentConfig{ + GlobalConfig: DefaultColocationConfig(), + NodesConfig: []api.NodesConfig{ + { + Selector: &metav1.LabelSelector{MatchLabels: map[string]string{ + "label-key": "label-value", + }}, + ColocationConfig: api.ColocationConfig{EvictingConfig: &api.Evicting{ + EvictingCPUHighWatermark: utilpointer.Int(10), + }}, + }, + }, + }, + node: &corev1.Node{ + ObjectMeta: metav1.ObjectMeta{ + Labels: map[string]string{ + "label-key": "label-value", + }, + }, + }, + wantCfg: withLabelSelector(DefaultColocationConfig()), + wantErr: true, + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + actualCfg, actualErr := MergerCfg(tc.volcanoCfg, tc.node) + assert.Equal(t, tc.wantCfg, actualCfg, tc.name) + assert.Equal(t, tc.wantErr, actualErr != nil, tc.name) + }) + } +} + +func withNewOverSubscription(config *api.ColocationConfig, overSubscription *api.OverSubscription) *api.ColocationConfig { + config.OverSubscriptionConfig = overSubscription + return config +} + +func withNewNetworkQoS(config *api.ColocationConfig, networkqos *api.NetworkQos) *api.ColocationConfig { + config.NetworkQosConfig = networkqos + return config +} + +func enableNodeColocation(config *api.ColocationConfig) *api.ColocationConfig { + config.NodeLabelConfig.NodeColocationEnable = utilpointer.Bool(true) + return config +} + +func enableNodeOverSubscription(config *api.ColocationConfig) *api.ColocationConfig { + config.NodeLabelConfig.NodeOverSubscriptionEnable = utilpointer.Bool(true) + return config +} + +func disableCPUQos(config *api.ColocationConfig) *api.ColocationConfig { + config.CPUQosConfig.Enable = utilpointer.Bool(false) + return config +} + +func disableOverSubscription(config *api.ColocationConfig) *api.ColocationConfig { + config.OverSubscriptionConfig.Enable = utilpointer.Bool(false) + return config +} + +func disableNetworkQos(config *api.ColocationConfig) *api.ColocationConfig { + config.NetworkQosConfig.Enable = utilpointer.Bool(false) + return config +} + +func disableMemoryQos(config *api.ColocationConfig) *api.ColocationConfig { + config.MemoryQosConfig.Enable = utilpointer.Bool(false) + return config +} + +func disableCPUBurst(config *api.ColocationConfig) *api.ColocationConfig { + config.CPUBurstConfig.Enable = utilpointer.Bool(false) + return config +} + +func withLabelSelector(config *api.ColocationConfig) *api.ColocationConfig { + config.EvictingConfig.EvictingCPUHighWatermark = utilpointer.Int(10) + return config +} diff --git a/pkg/agent/events/eventsmgr.go b/pkg/agent/events/eventsmgr.go new file mode 100644 index 000000000..4d97bb082 --- /dev/null +++ b/pkg/agent/events/eventsmgr.go @@ -0,0 +1,77 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package events + +import ( + "context" + + "k8s.io/klog/v2" + + coloconfig "volcano.sh/volcano/pkg/agent/config" + "volcano.sh/volcano/pkg/agent/events/framework" + "volcano.sh/volcano/pkg/agent/events/handlers" + "volcano.sh/volcano/pkg/agent/events/probes" + "volcano.sh/volcano/pkg/agent/utils/cgroup" + "volcano.sh/volcano/pkg/config" + "volcano.sh/volcano/pkg/metriccollect" +) + +type EventManager struct { + eventQueueFactory *framework.EventQueueFactory + config *config.Configuration + metricCollectManager *metriccollect.MetricCollectorManager + configMgr *coloconfig.ConfigManager +} + +func NewEventManager(config *config.Configuration, metricCollectManager *metriccollect.MetricCollectorManager, cgroupMgr cgroup.CgroupManager) *EventManager { + factory := &framework.EventQueueFactory{} + factory.Queues = make(map[string]*framework.EventQueue) + mgr := &EventManager{ + config: config, + metricCollectManager: metricCollectManager, + eventQueueFactory: factory, + configMgr: coloconfig.NewManager(config, []coloconfig.Listener{factory}), + } + + for eventName, newProbeFuncs := range probes.GetEventProbeFuncs() { + eventQueue := mgr.eventQueueFactory.EventQueue(eventName) + for _, newProbeFunc := range newProbeFuncs { + prob := newProbeFunc(config, metricCollectManager, eventQueue.GetQueue()) + mgr.eventQueueFactory.RegistryEventProbe(eventName, prob) + } + } + + for eventName, newHandleFuncs := range handlers.GetEventHandlerFuncs() { + for _, newHandleFunc := range newHandleFuncs { + handle := newHandleFunc(config, metricCollectManager, cgroupMgr) + mgr.eventQueueFactory.RegistryEventHandler(eventName, handle) + } + } + return mgr +} + +func (m *EventManager) Run(ctx context.Context) error { + klog.InfoS("Start event manager") + if err := m.configMgr.Start(ctx); err != nil { + return err + } + if err := m.eventQueueFactory.Start(ctx); err != nil { + return err + } + klog.InfoS("Successfully started event manager") + return nil +} diff --git a/pkg/agent/events/framework/events.go b/pkg/agent/events/framework/events.go new file mode 100644 index 000000000..89927a994 --- /dev/null +++ b/pkg/agent/events/framework/events.go @@ -0,0 +1,106 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package framework + +import ( + "context" + "time" + + "golang.org/x/time/rate" + "k8s.io/client-go/util/workqueue" + "k8s.io/klog/v2" +) + +type EventQueue struct { + // Name is the name of event. + Name string + // Workers is the number of handle workers that are allowed to sync concurrently. + Workers int + // Queue for caching events + Queue workqueue.RateLimitingInterface + // List of handlers that need to handle this event. + Handlers []Handle + // List of event detectors. + // Generate an event and put the event in the queue + Probes []Probe +} + +func NewEventQueue(name string) *EventQueue { + rateLimiter := workqueue.NewMaxOfRateLimiter( + workqueue.NewItemExponentialFailureRateLimiter(1*time.Second, 100*time.Second), + &workqueue.BucketRateLimiter{Limiter: rate.NewLimiter(rate.Limit(10), 100)}, + ) + return &EventQueue{ + Name: name, + Workers: 30, + Queue: workqueue.NewNamedRateLimitingQueue(rateLimiter, name), + } +} + +func (eq *EventQueue) SetWorkers(workers int) { + eq.Workers = workers +} + +func (eq *EventQueue) AddHandler(handle ...Handle) { + eq.Handlers = append(eq.Handlers, handle...) +} + +func (eq *EventQueue) AddProbe(p ...Probe) { + eq.Probes = append(eq.Probes, p...) +} + +func (eq *EventQueue) GetQueue() workqueue.RateLimitingInterface { + return eq.Queue +} + +func (eq *EventQueue) ProcessEvent(ctx context.Context) { + for { + if !eq.processNextWorkItem(ctx) { + klog.ErrorS(nil, "Event queue shut down") + break + } + } +} + +func (eq *EventQueue) processNextWorkItem(ctx context.Context) bool { + key, quit := eq.Queue.Get() + if quit { + return false + } + defer eq.Queue.Done(key) + + visitErr := false + defer func() { + if visitErr { + eq.Queue.AddRateLimited(key) + } else { + eq.Queue.Forget(key) + } + }() + + for _, handler := range eq.Handlers { + if !handler.IsActive() { + continue + } + err := handler.Handle(key) + if err != nil { + klog.ErrorS(err, "Handle process failed", "handler", handler.HandleName()) + visitErr = true + } + } + return true +} diff --git a/pkg/agent/events/framework/factory.go b/pkg/agent/events/framework/factory.go new file mode 100644 index 000000000..bf6f4a9ba --- /dev/null +++ b/pkg/agent/events/framework/factory.go @@ -0,0 +1,96 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package framework + +import ( + "context" + "sync" + "time" + + utilerrors "k8s.io/apimachinery/pkg/util/errors" + "k8s.io/apimachinery/pkg/util/wait" + "k8s.io/klog/v2" + + "volcano.sh/volcano/pkg/agent/config/api" +) + +type EventQueueFactory struct { + Mutex sync.RWMutex + Queues map[string]*EventQueue +} + +func (f *EventQueueFactory) EventQueue(name string) *EventQueue { + f.Mutex.Lock() + defer f.Mutex.Unlock() + + if queue, ok := f.Queues[name]; ok { + return queue + } + + eventQueue := NewEventQueue(name) + f.Queues[name] = eventQueue + return eventQueue +} + +func (f *EventQueueFactory) RegistryEventHandler(name string, handle Handle) Handle { + f.EventQueue(name).AddHandler(handle) + klog.InfoS("Successfully registry event handler", "event", name, "handler", handle.HandleName()) + return handle +} + +func (f *EventQueueFactory) RegistryEventProbe(name string, probe Probe) Probe { + f.EventQueue(name).AddProbe(probe) + klog.InfoS("Successfully registry event probe", "name", name, "probe", probe.ProbeName()) + return probe +} + +func (f *EventQueueFactory) SyncConfig(cfg *api.ColocationConfig) error { + f.Mutex.Lock() + defer f.Mutex.Unlock() + + var errs []error + for _, queue := range f.Queues { + for _, handler := range queue.Handlers { + if syncErr := handler.RefreshCfg(cfg); syncErr != nil { + errs = append(errs, syncErr) + } + } + for _, probe := range queue.Probes { + if syncErr := probe.RefreshCfg(cfg); syncErr != nil { + errs = append(errs, syncErr) + } + } + } + return utilerrors.NewAggregate(errs) +} + +func (f *EventQueueFactory) Start(ctx context.Context) error { + klog.InfoS("Start event queue factory") + for _, event := range f.Queues { + for _, probe := range event.Probes { + go probe.Run(ctx.Done()) + } + } + + for _, event := range f.Queues { + for i := 0; i < event.Workers; i++ { + go wait.UntilWithContext(ctx, event.ProcessEvent, time.Second) + } + } + klog.InfoS("Successfully started event queue factory") + return nil +} diff --git a/pkg/agent/events/framework/interface.go b/pkg/agent/events/framework/interface.go new file mode 100644 index 000000000..b03e1a172 --- /dev/null +++ b/pkg/agent/events/framework/interface.go @@ -0,0 +1,43 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package framework + +import ( + "volcano.sh/volcano/pkg/agent/config/api" +) + +type Probe interface { + // ProbeName returns name of the probe + ProbeName() string + // Run runs the probe + Run(stop <-chan struct{}) + // RefreshCfg hot update probe's cfg. + RefreshCfg(cfg *api.ColocationConfig) error +} + +type Handle interface { + // HandleName returns name of the handler + HandleName() string + // Handle handles the given event + // Return an error only if the event needs to be re-enqueued to be processed + // Need to avoid returning errors that cannot be resolved by retrying + Handle(event interface{}) error + // IsActive returns true if the handler is enabled + IsActive() bool + // RefreshCfg hot update handler's cfg. + RefreshCfg(cfg *api.ColocationConfig) error +} diff --git a/pkg/agent/events/framework/types.go b/pkg/agent/events/framework/types.go new file mode 100644 index 000000000..7c7d7556c --- /dev/null +++ b/pkg/agent/events/framework/types.go @@ -0,0 +1,55 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package framework + +import ( + "time" + + corev1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/types" +) + +type EventName string + +const ( + PodEventName EventName = "PodsSync" + + NodeResourcesEventName EventName = "NodeResourcesSync" + + NodeMonitorEventName EventName = "NodeUtilizationSync" +) + +type PodEvent struct { + UID types.UID + QoSLevel int64 + QoSClass corev1.PodQOSClass + Pod *corev1.Pod +} + +// NodeResourceEvent defines node resource event, overSubscription resource recently. +type NodeResourceEvent struct { + MillCPU int64 + MemoryBytes int64 +} + +// NodeMonitorEvent defines node pressure event. +type NodeMonitorEvent struct { + // TimeStamp is the time when event occur. + TimeStamp time.Time + // Resource represents which resource is under pressure. + Resource corev1.ResourceName +} diff --git a/pkg/agent/events/handlers/registry.go b/pkg/agent/events/handlers/registry.go new file mode 100644 index 000000000..0e0430b43 --- /dev/null +++ b/pkg/agent/events/handlers/registry.go @@ -0,0 +1,42 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package handlers + +import ( + "sync" + + "volcano.sh/volcano/pkg/agent/events/framework" + "volcano.sh/volcano/pkg/agent/utils/cgroup" + "volcano.sh/volcano/pkg/config" + "volcano.sh/volcano/pkg/metriccollect" +) + +var handlerFuncs = map[string][]NewEventHandleFunc{} +var mutex sync.Mutex + +type NewEventHandleFunc = func(config *config.Configuration, mgr *metriccollect.MetricCollectorManager, cgroupMgr cgroup.CgroupManager) framework.Handle + +func RegisterEventHandleFunc(eventName string, f NewEventHandleFunc) { + mutex.Lock() + defer mutex.Unlock() + + handlerFuncs[eventName] = append(handlerFuncs[eventName], f) +} + +func GetEventHandlerFuncs() map[string][]NewEventHandleFunc { + return handlerFuncs +} diff --git a/pkg/agent/events/probes/registry.go b/pkg/agent/events/probes/registry.go new file mode 100644 index 000000000..10838120c --- /dev/null +++ b/pkg/agent/events/probes/registry.go @@ -0,0 +1,43 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package probes + +import ( + "sync" + + "k8s.io/client-go/util/workqueue" + + "volcano.sh/volcano/pkg/agent/events/framework" + "volcano.sh/volcano/pkg/config" + "volcano.sh/volcano/pkg/metriccollect" +) + +var probeFuncs = map[string][]NewEventProbeFunc{} +var mutex sync.Mutex + +type NewEventProbeFunc = func(config *config.Configuration, mgr *metriccollect.MetricCollectorManager, queue workqueue.RateLimitingInterface) framework.Probe + +func RegisterEventProbeFunc(eventName string, f NewEventProbeFunc) { + mutex.Lock() + defer mutex.Unlock() + + probeFuncs[eventName] = append(probeFuncs[eventName], f) +} + +func GetEventProbeFuncs() map[string][]NewEventProbeFunc { + return probeFuncs +} diff --git a/pkg/agent/features/feature.go b/pkg/agent/features/feature.go new file mode 100644 index 000000000..a94c0d8f0 --- /dev/null +++ b/pkg/agent/features/feature.go @@ -0,0 +1,29 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package features + +type Feature string + +const ( + CPUQoSFeature Feature = "CPUQoS" + CPUBurstFeature Feature = "CPUBurst" + MemoryQoSFeature Feature = "MemoryQoS" + NetworkQoSFeature Feature = "NetworkQoS" + OverSubscriptionFeature Feature = "OverSubscription" + EvictionFeature Feature = "Eviction" + ResourcesFeature Feature = "Resources" +) diff --git a/pkg/agent/features/feature_gate.go b/pkg/agent/features/feature_gate.go new file mode 100644 index 000000000..f907e2276 --- /dev/null +++ b/pkg/agent/features/feature_gate.go @@ -0,0 +1,138 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package features + +import ( + "fmt" + "os" + "strings" + + "k8s.io/klog/v2" + + "volcano.sh/volcano/pkg/agent/config/api" + agentutils "volcano.sh/volcano/pkg/agent/utils" + "volcano.sh/volcano/pkg/agent/utils/version" + "volcano.sh/volcano/pkg/config" + "volcano.sh/volcano/pkg/networkqos/utils" +) + +var ( + // DefaultFeatureGate is a shared global FeatureGate. + DefaultFeatureGate FeatureGate = &featureGate{} +) + +// FeatureGate indicates whether a given feature is enabled or not +type FeatureGate interface { + // Enabled returns true if the key is enabled. + Enabled(key Feature, c *api.ColocationConfig) (bool, error) + // Supported returns nil if the key is supported, return error with the reason why not supported + Supported(key Feature, cfg *config.Configuration) error +} + +type featureGate struct{} + +func (f *featureGate) Enabled(key Feature, c *api.ColocationConfig) (bool, error) { + if c.NodeLabelConfig == nil { + return false, fmt.Errorf("nil node label config") + } + nodeColocationEnabled := c.NodeLabelConfig.NodeColocationEnable != nil && *c.NodeLabelConfig.NodeColocationEnable + nodeOverSubscriptionEnabled := c.NodeLabelConfig.NodeOverSubscriptionEnable != nil && *c.NodeLabelConfig.NodeOverSubscriptionEnable + + switch key { + case CPUQoSFeature: + if c.CPUQosConfig == nil || c.CPUQosConfig.Enable == nil { + return false, fmt.Errorf("nil cpu qos config") + } + return (nodeColocationEnabled || nodeOverSubscriptionEnabled) && *c.CPUQosConfig.Enable, nil + + case CPUBurstFeature: + if c.CPUBurstConfig == nil || c.CPUBurstConfig.Enable == nil { + return false, fmt.Errorf("nil cpu burst config") + } + return (nodeColocationEnabled || nodeOverSubscriptionEnabled) && *c.CPUBurstConfig.Enable, nil + + case MemoryQoSFeature: + if c.MemoryQosConfig == nil || c.MemoryQosConfig.Enable == nil { + return false, fmt.Errorf("nil memory qos config") + } + return (nodeColocationEnabled || nodeOverSubscriptionEnabled) && *c.MemoryQosConfig.Enable, nil + + case NetworkQoSFeature: + if c.NetworkQosConfig == nil || c.NetworkQosConfig.Enable == nil { + return false, fmt.Errorf("nil memory qos config") + } + return (nodeColocationEnabled || nodeOverSubscriptionEnabled) && *c.NetworkQosConfig.Enable, nil + + case OverSubscriptionFeature: + if c.OverSubscriptionConfig == nil || c.OverSubscriptionConfig.Enable == nil { + return false, fmt.Errorf("nil overSubscription config") + } + return nodeOverSubscriptionEnabled && *c.OverSubscriptionConfig.Enable, nil + case EvictionFeature, ResourcesFeature: + // Always return true because eviction manager need take care of all nodes. + return true, nil + default: + return false, fmt.Errorf("unsupported feature %s", string(key)) + } +} + +type UnsupportedError string + +func (s UnsupportedError) Error() string { + return "unsupported feature: " + string(s) +} + +func IsUnsupportedError(err error) bool { + _, ok := err.(UnsupportedError) + return ok +} + +func (f *featureGate) Supported(feature Feature, cfg *config.Configuration) error { + if !cfg.IsFeatureSupported(string(feature)) { + return UnsupportedError(fmt.Sprintf("feature(%s) is not supprted by volcano-agent", string(feature))) + } + + switch feature { + case NetworkQoSFeature: + if err := CheckNodeSupportNetworkQoS(); err != nil { + return err + } + return nil + default: + return nil + } +} + +func CheckNodeSupportNetworkQoS() error { + return checkNodeOSSupportNetworkQoS() +} + +func checkNodeOSSupportNetworkQoS() error { + osReleaseFile := strings.TrimSpace(os.Getenv(utils.HostOSReleasePathEnv)) + if osReleaseFile == "" { + osReleaseFile = utils.DefaultNodeOSReleasePath + } + osRelease, err := agentutils.GetOSReleaseFromFile(osReleaseFile) + if err != nil { + return err + } + if osRelease.Name == utils.OpenEulerOSReleaseName && version.HigherOrEqual(osRelease.Version, utils.OpenEulerOSReleaseVersion) { + return nil + } + klog.V(4).InfoS("os does not support network qos", "os-name", osRelease.Name, "os-version", osRelease.Version) + return UnsupportedError(fmt.Sprintf("os(%s:%s) does not support network qos", osRelease.Name, osRelease.Version)) +} diff --git a/pkg/agent/features/feature_gate_test.go b/pkg/agent/features/feature_gate_test.go new file mode 100644 index 000000000..70154acde --- /dev/null +++ b/pkg/agent/features/feature_gate_test.go @@ -0,0 +1,384 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package features + +import ( + "os" + "path" + "testing" + + "github.com/stretchr/testify/assert" + utilpointer "k8s.io/utils/pointer" + + "volcano.sh/volcano/pkg/agent/config/api" + "volcano.sh/volcano/pkg/config" + "volcano.sh/volcano/pkg/networkqos/utils" +) + +func TestFeatureEnable(t *testing.T) { + tests := []struct { + name string + cfg *api.ColocationConfig + expectedFeatures map[Feature]bool + expectedErrors map[Feature]bool + }{ + { + name: "all-features-enabled", + cfg: &api.ColocationConfig{ + NodeLabelConfig: &api.NodeLabelConfig{ + NodeColocationEnable: utilpointer.Bool(true), + NodeOverSubscriptionEnable: utilpointer.Bool(true), + }, + CPUQosConfig: &api.CPUQos{Enable: utilpointer.Bool(true)}, + CPUBurstConfig: &api.CPUBurst{Enable: utilpointer.Bool(true)}, + MemoryQosConfig: &api.MemoryQos{Enable: utilpointer.Bool(true)}, + NetworkQosConfig: &api.NetworkQos{ + Enable: utilpointer.Bool(true), + }, + OverSubscriptionConfig: &api.OverSubscription{ + Enable: utilpointer.Bool(true), + }, + }, + expectedFeatures: map[Feature]bool{ + CPUQoSFeature: true, + CPUBurstFeature: true, + MemoryQoSFeature: true, + NetworkQoSFeature: true, + OverSubscriptionFeature: true, + }, + expectedErrors: map[Feature]bool{ + CPUQoSFeature: false, + CPUBurstFeature: false, + MemoryQoSFeature: false, + NetworkQoSFeature: false, + OverSubscriptionFeature: false, + }, + }, + + { + name: "node-colocation-disabled && node-OverSubscription-disabled", + cfg: &api.ColocationConfig{ + NodeLabelConfig: &api.NodeLabelConfig{ + NodeColocationEnable: utilpointer.Bool(false), + NodeOverSubscriptionEnable: utilpointer.Bool(false), + }, + CPUQosConfig: &api.CPUQos{Enable: utilpointer.Bool(true)}, + CPUBurstConfig: &api.CPUBurst{Enable: utilpointer.Bool(true)}, + MemoryQosConfig: &api.MemoryQos{Enable: utilpointer.Bool(true)}, + NetworkQosConfig: &api.NetworkQos{ + Enable: utilpointer.Bool(true), + }, + OverSubscriptionConfig: &api.OverSubscription{ + Enable: utilpointer.Bool(true), + }, + }, + expectedFeatures: map[Feature]bool{ + CPUQoSFeature: false, + CPUBurstFeature: false, + MemoryQoSFeature: false, + NetworkQoSFeature: false, + OverSubscriptionFeature: false, + }, + expectedErrors: map[Feature]bool{ + CPUQoSFeature: false, + CPUBurstFeature: false, + MemoryQoSFeature: false, + NetworkQoSFeature: false, + OverSubscriptionFeature: false, + }, + }, + + { + name: "node-colocation-enabled && node-OverSubscription-disabled", + cfg: &api.ColocationConfig{ + NodeLabelConfig: &api.NodeLabelConfig{ + NodeColocationEnable: utilpointer.Bool(true), + NodeOverSubscriptionEnable: utilpointer.Bool(false), + }, + CPUQosConfig: &api.CPUQos{Enable: utilpointer.Bool(true)}, + CPUBurstConfig: &api.CPUBurst{Enable: utilpointer.Bool(true)}, + MemoryQosConfig: &api.MemoryQos{Enable: utilpointer.Bool(true)}, + NetworkQosConfig: &api.NetworkQos{ + Enable: utilpointer.Bool(true), + }, + OverSubscriptionConfig: &api.OverSubscription{ + Enable: utilpointer.Bool(true), + }, + }, + expectedFeatures: map[Feature]bool{ + CPUQoSFeature: true, + CPUBurstFeature: true, + MemoryQoSFeature: true, + NetworkQoSFeature: true, + OverSubscriptionFeature: false, + }, + expectedErrors: map[Feature]bool{ + CPUQoSFeature: false, + CPUBurstFeature: false, + MemoryQoSFeature: false, + NetworkQoSFeature: false, + OverSubscriptionFeature: false, + }, + }, + + { + name: "node-colocation-disabled && node-OverSubscription-enabled", + cfg: &api.ColocationConfig{ + NodeLabelConfig: &api.NodeLabelConfig{ + NodeColocationEnable: utilpointer.Bool(false), + NodeOverSubscriptionEnable: utilpointer.Bool(true), + }, + CPUQosConfig: &api.CPUQos{Enable: utilpointer.Bool(true)}, + CPUBurstConfig: &api.CPUBurst{Enable: utilpointer.Bool(true)}, + MemoryQosConfig: &api.MemoryQos{Enable: utilpointer.Bool(true)}, + NetworkQosConfig: &api.NetworkQos{ + Enable: utilpointer.Bool(true), + }, + OverSubscriptionConfig: &api.OverSubscription{ + Enable: utilpointer.Bool(true), + }, + }, + expectedFeatures: map[Feature]bool{ + CPUQoSFeature: true, + CPUBurstFeature: true, + MemoryQoSFeature: true, + NetworkQoSFeature: true, + OverSubscriptionFeature: true, + }, + expectedErrors: map[Feature]bool{ + CPUQoSFeature: false, + CPUBurstFeature: false, + MemoryQoSFeature: false, + NetworkQoSFeature: false, + OverSubscriptionFeature: false, + }, + }, + + { + name: "cpu-qos-disabled && memory-qos-disabled && network-qos-disabled", + cfg: &api.ColocationConfig{ + NodeLabelConfig: &api.NodeLabelConfig{ + NodeColocationEnable: utilpointer.Bool(true), + NodeOverSubscriptionEnable: utilpointer.Bool(false), + }, + CPUQosConfig: &api.CPUQos{Enable: utilpointer.Bool(false)}, + CPUBurstConfig: &api.CPUBurst{Enable: utilpointer.Bool(true)}, + MemoryQosConfig: &api.MemoryQos{Enable: utilpointer.Bool(false)}, + NetworkQosConfig: &api.NetworkQos{ + Enable: utilpointer.Bool(false), + }, + OverSubscriptionConfig: &api.OverSubscription{ + Enable: utilpointer.Bool(true), + }, + }, + expectedFeatures: map[Feature]bool{ + CPUQoSFeature: false, + CPUBurstFeature: true, + MemoryQoSFeature: false, + NetworkQoSFeature: false, + OverSubscriptionFeature: false, + }, + expectedErrors: map[Feature]bool{ + CPUQoSFeature: false, + CPUBurstFeature: false, + MemoryQoSFeature: false, + NetworkQoSFeature: false, + OverSubscriptionFeature: false, + }, + }, + + { + name: "cpu-burst-disabled && overSubscription-disabled", + cfg: &api.ColocationConfig{ + NodeLabelConfig: &api.NodeLabelConfig{ + NodeColocationEnable: utilpointer.Bool(false), + NodeOverSubscriptionEnable: utilpointer.Bool(true), + }, + CPUQosConfig: &api.CPUQos{Enable: utilpointer.Bool(true)}, + CPUBurstConfig: &api.CPUBurst{Enable: utilpointer.Bool(false)}, + MemoryQosConfig: &api.MemoryQos{Enable: utilpointer.Bool(true)}, + NetworkQosConfig: &api.NetworkQos{ + Enable: utilpointer.Bool(true), + }, + OverSubscriptionConfig: &api.OverSubscription{ + Enable: utilpointer.Bool(false), + }, + }, + expectedFeatures: map[Feature]bool{ + CPUQoSFeature: true, + CPUBurstFeature: false, + MemoryQoSFeature: true, + NetworkQoSFeature: true, + OverSubscriptionFeature: false, + }, + expectedErrors: map[Feature]bool{ + CPUQoSFeature: false, + CPUBurstFeature: false, + MemoryQoSFeature: false, + NetworkQoSFeature: false, + OverSubscriptionFeature: false, + }, + }, + } + + for _, tt := range tests { + for feature, expectedEnabled := range tt.expectedFeatures { + actualEnabled, actualErr := DefaultFeatureGate.Enabled(feature, tt.cfg) + assert.Equal(t, expectedEnabled, actualEnabled, tt.name, feature) + assert.Equal(t, tt.expectedErrors[feature], actualErr != nil, tt.name, feature) + } + } +} + +func TestFeatureSupport(t *testing.T) { + dir, err := os.MkdirTemp("/tmp", "MkdirTemp") + defer func() { + err = os.RemoveAll(dir) + if err != nil { + t.Errorf("remove dir(%s) failed: %v", dir, err) + } + assert.Equal(t, err == nil, true) + }() + assert.Equal(t, err == nil, true) + + tests := []struct { + name string + configuration *config.Configuration + expectedErrors map[Feature]bool + }{ + { + name: "all-features-enabled", + configuration: &config.Configuration{ + GenericConfiguration: &config.VolcanoAgentConfiguration{ + SupportedFeatures: []string{"*"}, + }, + }, + expectedErrors: map[Feature]bool{ + CPUQoSFeature: false, + CPUBurstFeature: false, + MemoryQoSFeature: false, + NetworkQoSFeature: false, + OverSubscriptionFeature: false, + }, + }, + + { + name: "all-features-enabled && support networkqos && support memoryqos", + configuration: &config.Configuration{ + GenericConfiguration: &config.VolcanoAgentConfiguration{ + SupportedFeatures: []string{"NetworkQoS", "MemoryQoS"}, + }, + }, + expectedErrors: map[Feature]bool{ + CPUQoSFeature: true, + CPUBurstFeature: true, + MemoryQoSFeature: false, + NetworkQoSFeature: false, + OverSubscriptionFeature: true, + }, + }, + + { + name: "all-features-enabled && not support memoryqos", + configuration: &config.Configuration{ + GenericConfiguration: &config.VolcanoAgentConfiguration{ + SupportedFeatures: []string{"*", "-MemoryQoS"}, + }, + }, + expectedErrors: map[Feature]bool{ + CPUQoSFeature: false, + CPUBurstFeature: false, + MemoryQoSFeature: true, + NetworkQoSFeature: false, + OverSubscriptionFeature: false, + }, + }, + } + + tmpFile := path.Join(dir, "os-release") + if err = os.WriteFile(tmpFile, []byte(openEulerOS), 0660); err != nil { + assert.Equal(t, nil, err) + } + if err = os.Setenv(utils.HostOSReleasePathEnv, tmpFile); err != nil { + assert.Equal(t, nil, err) + } + + for _, tt := range tests { + for feature, expectedErr := range tt.expectedErrors { + actualErr := DefaultFeatureGate.Supported(feature, tt.configuration) + assert.Equal(t, expectedErr, actualErr != nil, tt.name, feature) + } + } +} + +var openEulerOS = ` +NAME="openEuler" +VERSION="22.03 (LTS-SP2)" +ID="openEuler" +VERSION_ID="22.03" +PRETTY_NAME="openEuler 22.03 (LTS-SP2)" +ANSI_COLOR="0;31" +` + +var ubuntuOS = ` +NAME="Ubuntu" +VERSION="16.04.5 LTS (Xenial Xerus)" +ID=ubuntu +ID_LIKE=debian +PRETTY_NAME="Ubuntu 16.04.5 LTS" +VERSION_ID="16.04" +` + +func TestCheckNodeSupportNetworkQoS(t *testing.T) { + dir, err := os.MkdirTemp("/tmp", "MkdirTemp") + defer func() { + err = os.RemoveAll(dir) + if err != nil { + t.Errorf("remove dir(%s) failed: %v", dir, err) + } + assert.Equal(t, err == nil, true) + }() + assert.Equal(t, err == nil, true) + + testCases := []struct { + name string + releaseContent string + expectedError bool + }{ + { + name: "openEuler 22.03 SP2", + releaseContent: openEulerOS, + expectedError: false, + }, + { + name: "ubuntu && x86", + releaseContent: ubuntuOS, + expectedError: true, + }, + } + for _, tc := range testCases { + tmpFile := path.Join(dir, "os-release") + if err = os.WriteFile(tmpFile, []byte(tc.releaseContent), 0660); err != nil { + assert.Equal(t, nil, err) + } + if err = os.Setenv(utils.HostOSReleasePathEnv, tmpFile); err != nil { + assert.Equal(t, nil, err) + } + actualErr := CheckNodeSupportNetworkQoS() + assert.Equal(t, tc.expectedError, actualErr != nil, tc.name) + } +} diff --git a/pkg/agent/healthcheck/healthcheck.go b/pkg/agent/healthcheck/healthcheck.go new file mode 100644 index 000000000..fc8d85d8b --- /dev/null +++ b/pkg/agent/healthcheck/healthcheck.go @@ -0,0 +1,57 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package healthcheck + +import ( + "net/http" + + "k8s.io/klog/v2" + + "volcano.sh/volcano/pkg/networkqos" +) + +type HealthChecker interface { + HealthCheck(w http.ResponseWriter, r *http.Request) +} + +type healthChecker struct { + networkQoSMgr networkqos.NetworkQoSManager +} + +func NewHealthChecker(networkQoSMgr networkqos.NetworkQoSManager) HealthChecker { + return &healthChecker{ + networkQoSMgr: networkQoSMgr, + } +} + +func (c *healthChecker) HealthCheck(w http.ResponseWriter, r *http.Request) { + if err := c.networkQoSMgr.HealthCheck(); err != nil { + w.WriteHeader(http.StatusInternalServerError) + if _, writeErr := w.Write([]byte(err.Error())); writeErr != nil { + klog.ErrorS(writeErr, "Failed to check network qos") + } + klog.ErrorS(err, "Failed to check volcano-agent") + return + } + + w.WriteHeader(http.StatusOK) + if _, writeErr := w.Write([]byte(`ok`)); writeErr != nil { + klog.ErrorS(writeErr, "Failed to write ok to response") + } else { + klog.V(3).InfoS("successfully checking health of volcano-agent ") + } +} diff --git a/pkg/agent/metrics/metrics.go b/pkg/agent/metrics/metrics.go new file mode 100644 index 000000000..663d4b935 --- /dev/null +++ b/pkg/agent/metrics/metrics.go @@ -0,0 +1,44 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package metrics + +import ( + "github.com/prometheus/client_golang/prometheus" + "github.com/prometheus/client_golang/prometheus/promauto" + + "volcano.sh/volcano/pkg/agent/apis" +) + +const ( + subSystem = "volcano_agent" +) + +var overSubscriptionResourceQuantity = promauto.NewGaugeVec( + prometheus.GaugeOpts{ + Subsystem: subSystem, + Name: "oversubscription_resource_quantity", + Help: "The reported overSubscription resource quantity", + }, + []string{"node", "resource"}, +) + +// UpdateOverSubscriptionResourceQuantity update node overSubscription resource by resource name. +func UpdateOverSubscriptionResourceQuantity(nodeName string, resources apis.Resource) { + for resName, quantity := range resources { + overSubscriptionResourceQuantity.WithLabelValues(nodeName, string(resName)).Set(float64(quantity)) + } +} diff --git a/pkg/agent/utils/cgroup/cgroup.go b/pkg/agent/utils/cgroup/cgroup.go new file mode 100644 index 000000000..dbd4652e7 --- /dev/null +++ b/pkg/agent/utils/cgroup/cgroup.go @@ -0,0 +1,176 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package cgroup + +import ( + "fmt" + "path" + "path/filepath" + "strings" + + cgroupsystemd "github.com/opencontainers/runc/libcontainer/cgroups/systemd" + corev1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/types" +) + +type CgroupSubsystem string + +const ( + CgroupMemorySubsystem CgroupSubsystem = "memory" + CgroupCpuSubsystem CgroupSubsystem = "cpu" + CgroupNetCLSSubsystem CgroupSubsystem = "net_cls" + + CgroupKubeRoot string = "kubepods" + + SystemdSuffix string = ".slice" + PodCgroupNamePrefix string = "pod" + + CPUQoSLevelFile string = "cpu.qos_level" + CPUUsageFile string = "cpuacct.usage" + + CPUQuotaBurstFile string = "cpu.cfs_burst_us" + CPUQuotaTotalFile string = "cpu.cfs_quota_us" + + MemoryUsageFile string = "memory.stat" + MemoryQoSLevelFile string = "memory.qos_level" + MemoryLimitFile string = "memory.limit_in_bytes" + + NetCLSFileName string = "net_cls.classid" + + CPUShareFileName string = "cpu.shares" +) + +type CgroupManager interface { + GetRootCgroupPath(cgroupSubsystem CgroupSubsystem) (string, error) + GetQoSCgroupPath(qos corev1.PodQOSClass, cgroupSubsystem CgroupSubsystem) (string, error) + GetPodCgroupPath(qos corev1.PodQOSClass, cgroupSubsystem CgroupSubsystem, podUID types.UID) (string, error) +} + +type CgroupManagerImpl struct { + // cgroupDriver is the driver that the kubelet uses to manipulate cgroups on the host (cgroupfs or systemd) + cgroupDriver string + + // cgroupRoot is the root cgroup to use for pods. + cgroupRoot string + + // kubeCgroupRoot sames with kubelet configuration "cgroup-root" + kubeCgroupRoot string +} + +func NewCgroupManager(cgroupDriver, cgroupRoot, kubeCgroupRoot string) CgroupManager { + return &CgroupManagerImpl{ + cgroupDriver: cgroupDriver, + cgroupRoot: cgroupRoot, + kubeCgroupRoot: kubeCgroupRoot, + } +} + +func (c *CgroupManagerImpl) GetRootCgroupPath(cgroupSubsystem CgroupSubsystem) (string, error) { + cgroupName := []string{CgroupKubeRoot} + if c.kubeCgroupRoot != "" { + cgroupName = append([]string{c.kubeCgroupRoot}, cgroupName...) + } + + cgroupPath, err := c.CgroupNameToCgroupPath(cgroupName) + if err != nil { + return "", err + } + return filepath.Join(c.cgroupRoot, string(cgroupSubsystem), cgroupPath), err +} + +func (c *CgroupManagerImpl) GetQoSCgroupPath(qos corev1.PodQOSClass, cgroupSubsystem CgroupSubsystem) (string, error) { + cgroupName := []string{CgroupKubeRoot} + if c.kubeCgroupRoot != "" { + cgroupName = append([]string{c.kubeCgroupRoot}, cgroupName...) + } + switch qos { + case corev1.PodQOSBurstable: + cgroupName = append(cgroupName, "burstable") + case corev1.PodQOSBestEffort: + cgroupName = append(cgroupName, "besteffort") + } + + cgroupPath, err := c.CgroupNameToCgroupPath(cgroupName) + if err != nil { + return "", err + } + return filepath.Join(c.cgroupRoot, string(cgroupSubsystem), cgroupPath), err +} + +func (c *CgroupManagerImpl) GetPodCgroupPath(qos corev1.PodQOSClass, cgroupSubsystem CgroupSubsystem, podUID types.UID) (string, error) { + cgroupName := []string{CgroupKubeRoot} + if c.kubeCgroupRoot != "" { + cgroupName = append([]string{c.kubeCgroupRoot}, cgroupName...) + } + switch qos { + case corev1.PodQOSBurstable: + cgroupName = append(cgroupName, "burstable") + case corev1.PodQOSBestEffort: + cgroupName = append(cgroupName, "besteffort") + } + cgroupName = append(cgroupName, getPodCgroupNameSuffix(podUID)) + + cgroupPath, err := c.CgroupNameToCgroupPath(cgroupName) + if err != nil { + return "", err + } + return filepath.Join(c.cgroupRoot, string(cgroupSubsystem), cgroupPath), err +} + +func (c *CgroupManagerImpl) CgroupNameToCgroupPath(cgroupName []string) (string, error) { + switch c.cgroupDriver { + case "cgroupfs": + return CgroupName(cgroupName).ToCgroupfs() + case "systemd": + return CgroupName(cgroupName).ToSystemd() + default: + return "", fmt.Errorf("unsupported cgroup driver: %s", c.cgroupDriver) + } +} + +type CgroupName []string + +func (cgroupName CgroupName) ToSystemd() (string, error) { + if len(cgroupName) == 0 || (len(cgroupName) == 1 && cgroupName[0] == "") { + return "/", nil + } + + newparts := []string{} + for _, part := range cgroupName { + part = escapeSystemdCgroupName(part) + newparts = append(newparts, part) + } + + result, err := cgroupsystemd.ExpandSlice(strings.Join(newparts, "-") + SystemdSuffix) + if err != nil { + return "", fmt.Errorf("error converting cgroup name [%v] to systemd format: %v", cgroupName, err) + } + return result, nil +} + +func (cgroupName CgroupName) ToCgroupfs() (string, error) { + return "/" + path.Join(cgroupName...), nil +} + +func escapeSystemdCgroupName(part string) string { + return strings.Replace(part, "-", "_", -1) +} + +// getPodCgroupNameSuffix returns the last element of the pod CgroupName identifier +func getPodCgroupNameSuffix(podUID types.UID) string { + return PodCgroupNamePrefix + string(podUID) +} diff --git a/pkg/agent/utils/eviction/eviction.go b/pkg/agent/utils/eviction/eviction.go new file mode 100644 index 000000000..90a92ec43 --- /dev/null +++ b/pkg/agent/utils/eviction/eviction.go @@ -0,0 +1,94 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package eviction + +import ( + "context" + + corev1 "k8s.io/api/core/v1" + policyv1 "k8s.io/api/policy/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + clientset "k8s.io/client-go/kubernetes" + "k8s.io/client-go/tools/record" + "k8s.io/klog/v2" + "k8s.io/kubernetes/pkg/kubelet/types" + + utilpod "volcano.sh/volcano/pkg/agent/utils/pod" +) + +const ( + // Default Evicting config + DefaultEvictingCPUHighWatermark = 80 + DefaultEvictingMemoryHighWatermark = 60 + DefaultEvictingCPULowWatermark = 30 + DefaultEvictingMemoryLowWatermark = 30 + + // Reason is the reason reported back in status. + Reason = "Evicted" +) + +func evictPod(ctx context.Context, client clientset.Interface, gracePeriodSeconds *int64, pod *corev1.Pod) error { + if *gracePeriodSeconds < int64(0) { + *gracePeriodSeconds = int64(0) + } + eviction := &policyv1.Eviction{ + ObjectMeta: metav1.ObjectMeta{ + Name: pod.Name, + Namespace: pod.Namespace, + }, + DeleteOptions: &metav1.DeleteOptions{ + GracePeriodSeconds: gracePeriodSeconds, + }, + } + // TODO: get policy version dynamically using discovery client. + return client.PolicyV1().Evictions(pod.Namespace).Evict(ctx, eviction) +} + +type Eviction interface { + Evict(ctx context.Context, pod *corev1.Pod, eventRecorder record.EventRecorder, gracePeriodSeconds int64, evictMsg string) bool +} + +type eviction struct { + kubeClient clientset.Interface + nodeName string + killPodFunc utilpod.KillPod +} + +func NewEviction(client clientset.Interface, nodeName string) Eviction { + return &eviction{ + kubeClient: client, + nodeName: nodeName, + killPodFunc: evictPod, + } +} + +func (e *eviction) Evict(ctx context.Context, pod *corev1.Pod, eventRecorder record.EventRecorder, gracePeriodSeconds int64, evictMsg string) bool { + if types.IsCriticalPod(pod) { + klog.ErrorS(nil, "Cannot evict a critical pod", "pod", klog.KObj(pod)) + return false + } + + eventRecorder.Eventf(pod, corev1.EventTypeWarning, Reason, evictMsg) + err := e.killPodFunc(ctx, e.kubeClient, &gracePeriodSeconds, pod) + if err != nil { + klog.ErrorS(err, "Failed to evict pod", "pod", klog.KObj(pod)) + return false + } + + klog.InfoS("Successfully evicted pod", "pod", klog.KObj(pod)) + return true +} diff --git a/pkg/agent/utils/exec/exec.go b/pkg/agent/utils/exec/exec.go new file mode 100644 index 000000000..11a89c80a --- /dev/null +++ b/pkg/agent/utils/exec/exec.go @@ -0,0 +1,62 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package exec + +import ( + "context" + "fmt" + "os/exec" +) + +//go:generate mockgen -destination ./mocks/mock_exec.go -package mocks -source exec.go + +// ExecInterface is an interface of os/exec API. +type ExecInterface interface { + // CommandContext runs command + CommandContext(ctx context.Context, cmd string) (string, error) +} + +var _ ExecInterface = &Executor{} + +type Executor struct{} + +var executor ExecInterface + +func GetExecutor() ExecInterface { + if executor == nil { + executor = &Executor{} + } + return executor +} + +func SetExecutor(e ExecInterface) { + executor = e +} + +func (e *Executor) CommandContext(ctx context.Context, cmd string) (string, error) { + if ctx == nil { + return "", fmt.Errorf("command failed, nil Context") + } + var outBytes []byte + var err error + outBytes, err = exec.CommandContext(ctx, "sh", "-c", cmd).CombinedOutput() + outputStr := "" + if len(outBytes) != 0 { + outputStr = string(outBytes) + } + return outputStr, err +} diff --git a/pkg/agent/utils/exec/mocks/mock_exec.go b/pkg/agent/utils/exec/mocks/mock_exec.go new file mode 100644 index 000000000..d45c2321e --- /dev/null +++ b/pkg/agent/utils/exec/mocks/mock_exec.go @@ -0,0 +1,66 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by MockGen. DO NOT EDIT. +// Source: exec.go + +// Package mocks is a generated GoMock package. +package mocks + +import ( + context "context" + reflect "reflect" + + gomock "github.com/golang/mock/gomock" +) + +// MockExecInterface is a mock of ExecInterface interface. +type MockExecInterface struct { + ctrl *gomock.Controller + recorder *MockExecInterfaceMockRecorder +} + +// MockExecInterfaceMockRecorder is the mock recorder for MockExecInterface. +type MockExecInterfaceMockRecorder struct { + mock *MockExecInterface +} + +// NewMockExecInterface creates a new mock instance. +func NewMockExecInterface(ctrl *gomock.Controller) *MockExecInterface { + mock := &MockExecInterface{ctrl: ctrl} + mock.recorder = &MockExecInterfaceMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockExecInterface) EXPECT() *MockExecInterfaceMockRecorder { + return m.recorder +} + +// CommandContext mocks base method. +func (m *MockExecInterface) CommandContext(ctx context.Context, cmd string) (string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CommandContext", ctx, cmd) + ret0, _ := ret[0].(string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CommandContext indicates an expected call of CommandContext. +func (mr *MockExecInterfaceMockRecorder) CommandContext(ctx, cmd interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommandContext", reflect.TypeOf((*MockExecInterface)(nil).CommandContext), ctx, cmd) +} diff --git a/pkg/agent/utils/file/file.go b/pkg/agent/utils/file/file.go new file mode 100644 index 000000000..1220b8f4a --- /dev/null +++ b/pkg/agent/utils/file/file.go @@ -0,0 +1,59 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package file + +import ( + "os" + "strconv" + "strings" + + "k8s.io/klog/v2" +) + +func ReadIntFromFile(file string) (int64, error) { + data, err := os.ReadFile(file) + if err != nil { + return 0, err + } + value, err := strconv.Atoi(strings.TrimRight(string(data), "\n")) + if err != nil { + return 0, err + } + return int64(value), nil +} + +func ReadByteFromFile(file string) ([]byte, error) { + return os.ReadFile(file) +} + +// ReadBatchFromFile read files and return file name mapping value. +func ReadBatchFromFile(files []string) map[string]string { + res := make(map[string]string) + for _, file := range files { + val, err := os.ReadFile(file) + if err != nil { + klog.ErrorS(err, "Failed to read file", "name", file) + continue + } + res[file] = string(val) + } + return res +} + +func WriteByteToFile(file string, content []byte) error { + return os.WriteFile(file, content, 0644) +} diff --git a/pkg/agent/utils/node/annotation.go b/pkg/agent/utils/node/annotation.go new file mode 100644 index 000000000..b25513946 --- /dev/null +++ b/pkg/agent/utils/node/annotation.go @@ -0,0 +1,56 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package node + +import ( + v1 "k8s.io/api/core/v1" + + "volcano.sh/volcano/pkg/agent/apis" + "volcano.sh/volcano/pkg/config" +) + +func RemoveEvictionAnnotation(config *config.Configuration) error { + return update(config, []Modifier{removeEvictionAnnotation()}) +} + +func AddEvictionAnnotation(config *config.Configuration) error { + return update(config, []Modifier{updateAnnotation(map[string]string{ + apis.PodEvictingKey: "true", + })}) +} + +func updateAnnotation(annotations map[string]string) Modifier { + return func(node *v1.Node) { + if node.Annotations == nil { + node.Annotations = make(map[string]string) + } + for k, v := range annotations { + node.Annotations[k] = v + } + } +} + +func removeEvictionAnnotation() Modifier { + return func(node *v1.Node) { + if _, ok := node.Annotations[apis.PodEvictingKey]; !ok { + return + } + updateAnnotation(map[string]string{ + apis.PodEvictingKey: "false", + })(node) + } +} diff --git a/pkg/agent/utils/node/label.go b/pkg/agent/utils/node/label.go new file mode 100644 index 000000000..9d16d18a2 --- /dev/null +++ b/pkg/agent/utils/node/label.go @@ -0,0 +1,55 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package node + +import ( + v1 "k8s.io/api/core/v1" + + "volcano.sh/volcano/pkg/agent/apis" + "volcano.sh/volcano/pkg/config" +) + +func updateLabel(labels map[string]string) Modifier { + return func(node *v1.Node) { + if node.Labels == nil { + node.Labels = make(map[string]string) + } + for k, v := range labels { + node.Labels[k] = v + } + } +} + +// SetOverSubscriptionLabel set node label "volcano.sh/oversubscription"=true +func SetOverSubscriptionLabel(config *config.Configuration) error { + return update(config, []Modifier{ + updateLabel(map[string]string{ + apis.OverSubscriptionNodeLabelKey: "true", + }), + }) +} + +func ResetOverSubscriptionLabel() Modifier { + return func(node *v1.Node) { + if _, ok := node.Labels[apis.OverSubscriptionNodeLabelKey]; !ok { + return + } + updateLabel(map[string]string{ + apis.OverSubscriptionNodeLabelKey: "false", + })(node) + } +} diff --git a/pkg/agent/utils/node/node.go b/pkg/agent/utils/node/node.go new file mode 100644 index 000000000..fe191b680 --- /dev/null +++ b/pkg/agent/utils/node/node.go @@ -0,0 +1,143 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package node + +import ( + "fmt" + "strconv" + "strings" + + corev1 "k8s.io/api/core/v1" + "k8s.io/klog/v2" + + "volcano.sh/volcano/pkg/agent/apis" + "volcano.sh/volcano/pkg/agent/utils/eviction" +) + +// ActiveNode returns node which is managed by kubelet +type ActiveNode func() (*corev1.Node, error) + +type ResourceList struct { + TotalPodsRequest corev1.ResourceList + TotalNodeRes corev1.ResourceList +} + +func IsNodeSupportColocation(node *corev1.Node) bool { + b, err := strconv.ParseBool(node.Labels[apis.ColocationEnableNodeLabelKey]) + return err == nil && b +} + +// IsNodeSupportOverSubscription return whether a node is over subscription node. +// IMPORTANT!!! When node has a overSubscription label, it indicates that node is a colocation node too, +// because overSubscription resources are used by low priority workloads, it must be used in colocation case. +func IsNodeSupportOverSubscription(node *corev1.Node) bool { + b, err := strconv.ParseBool(node.Labels[apis.OverSubscriptionNodeLabelKey]) + return err == nil && b +} + +// WatermarkAnnotationSetting return watermark setting in annotation. +// return params lowWatermark, highWatermark, whether annotation exits and error +func WatermarkAnnotationSetting(node *corev1.Node) (apis.Resource, apis.Resource, bool, error) { + waterMarks := apis.Resource{ + apis.PodEvictedCPUHighWaterMarkKey: 0, + apis.PodEvictedCPULowWaterMarkKey: 0, + apis.PodEvictedMemoryHighWaterMarkKey: 0, + apis.PodEvictedMemoryLowWaterMarkKey: 0, + } + + annotationExist := false + for key := range waterMarks { + value, exist, err := GetIntValueWaterMark(node.Annotations, string(key)) + if err != nil { + klog.ErrorS(err, "Failed to get watermark", "key", key) + return nil, nil, true, err + } + if exist { + annotationExist = true + } + waterMarks[key] = value + } + if !annotationExist { + return nil, nil, false, nil + } + + if waterMarks[apis.PodEvictedCPUHighWaterMarkKey] <= waterMarks[apis.PodEvictedCPULowWaterMarkKey] { + return nil, nil, true, fmt.Errorf("cpu low watermark is higher than high watermark, low: %v, high: %v", waterMarks[apis.PodEvictedCPULowWaterMarkKey], waterMarks[apis.PodEvictedCPUHighWaterMarkKey]) + } + + if waterMarks[apis.PodEvictedMemoryHighWaterMarkKey] <= waterMarks[apis.PodEvictedMemoryLowWaterMarkKey] { + return nil, nil, true, fmt.Errorf("memory low watermark is higher than high watermark, low: %v, high: %v", waterMarks[apis.PodEvictedMemoryLowWaterMarkKey], waterMarks[apis.PodEvictedMemoryHighWaterMarkKey]) + } + + lowWatermark := apis.Resource{ + corev1.ResourceCPU: waterMarks[apis.PodEvictedCPULowWaterMarkKey], + corev1.ResourceMemory: waterMarks[apis.PodEvictedMemoryLowWaterMarkKey], + } + + highWatermark := apis.Resource{ + corev1.ResourceCPU: waterMarks[apis.PodEvictedCPUHighWaterMarkKey], + corev1.ResourceMemory: waterMarks[apis.PodEvictedMemoryHighWaterMarkKey], + } + return lowWatermark, highWatermark, true, nil +} + +func GetIntValueWaterMark(annotations map[string]string, annotationKey string) (intValue int64, exist bool, err error) { + realKey := getRealAnnotationKey(annotations, annotationKey) + if strValue, found := annotations[realKey]; found { + intValue, err = strconv.ParseInt(strValue, 10, 32) + if err == nil { + if intValue >= 0 { + return intValue, true, nil + } + err = fmt.Errorf("value(%d) of %s is negative, must be non-negative integer", intValue, realKey) + } + } + + switch realKey { + case apis.PodEvictedCPULowWaterMarkKey, apis.PodEvictedOverSubscriptionCPULowWaterMarkKey: + return eviction.DefaultEvictingCPULowWatermark, false, err + case apis.PodEvictedCPUHighWaterMarkKey, apis.PodEvictedOverSubscriptionCPUHighWaterMarkKey: + return eviction.DefaultEvictingCPUHighWatermark, false, err + case apis.PodEvictedMemoryHighWaterMarkKey, apis.PodEvictedOverSubscriptionMemoryHighWaterMarkKey: + return eviction.DefaultEvictingMemoryHighWatermark, false, err + case apis.PodEvictedMemoryLowWaterMarkKey, apis.PodEvictedOverSubscriptionMemoryLowWaterMarkKey: + return eviction.DefaultEvictingMemoryLowWatermark, false, err + default: + return 0, false, fmt.Errorf("unknown annotation key: %s", annotationKey) + } +} + +// getRealAnnotationKey used to get real annotation key to be compatible with old api. +func getRealAnnotationKey(annotations map[string]string, annotationKey string) string { + oldKey := getOldAnnotationKey(annotationKey) + _, oldKeyExists := annotations[oldKey] + _, newKeyExists := annotations[annotationKey] + // Old annotation exists and new annotation not exist, use the old one. + if oldKeyExists && !newKeyExists { + return oldKey + } + // Other case, always return the new one. + return annotationKey +} + +func getOldAnnotationKey(annotationKey string) string { + parts := strings.Split(annotationKey, "/") + if len(parts) != 2 { + return annotationKey + } + return parts[0] + "/oversubscription-" + parts[1] +} diff --git a/pkg/agent/utils/node/node_test.go b/pkg/agent/utils/node/node_test.go new file mode 100644 index 000000000..1490ca5bb --- /dev/null +++ b/pkg/agent/utils/node/node_test.go @@ -0,0 +1,204 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package node + +import ( + "fmt" + "testing" + + "github.com/stretchr/testify/assert" + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + + "volcano.sh/volcano/pkg/agent/apis" +) + +func TestWatermarkAnnotationSetting(t *testing.T) { + tests := []struct { + name string + node *corev1.Node + lowWatermark apis.Resource + highWatermark apis.Resource + exists bool + wantErr assert.ErrorAssertionFunc + }{ + { + name: "not exists", + node: &corev1.Node{ + ObjectMeta: metav1.ObjectMeta{ + Annotations: map[string]string{}, + }, + }, + lowWatermark: nil, + highWatermark: nil, + exists: false, + wantErr: assert.NoError, + }, + { + name: "negative watermark", + node: &corev1.Node{ + ObjectMeta: metav1.ObjectMeta{ + Annotations: map[string]string{ + apis.PodEvictedMemoryLowWaterMarkKey: "-1", + }, + }, + }, + lowWatermark: nil, + highWatermark: nil, + exists: true, + wantErr: assert.Error, + }, + { + name: "invalid watermark, setting one annotation", + node: &corev1.Node{ + ObjectMeta: metav1.ObjectMeta{ + Annotations: map[string]string{ + apis.PodEvictedCPULowWaterMarkKey: "90", + }, + }, + }, + lowWatermark: nil, + highWatermark: nil, + exists: true, + wantErr: assert.Error, + }, + { + name: "invalid watermark, setting two annotations", + node: &corev1.Node{ + ObjectMeta: metav1.ObjectMeta{ + Annotations: map[string]string{ + apis.PodEvictedOverSubscriptionMemoryHighWaterMarkKey: "10", + apis.PodEvictedMemoryLowWaterMarkKey: "20", + }, + }, + }, + lowWatermark: nil, + highWatermark: nil, + exists: true, + wantErr: assert.Error, + }, + { + name: "valid watermark", + node: &corev1.Node{ + ObjectMeta: metav1.ObjectMeta{ + Annotations: map[string]string{ + apis.PodEvictedCPULowWaterMarkKey: "10", + apis.PodEvictedOverSubscriptionCPUHighWaterMarkKey: "80", + apis.PodEvictedOverSubscriptionMemoryLowWaterMarkKey: "20", + apis.PodEvictedMemoryHighWaterMarkKey: "30", + }, + }, + }, + lowWatermark: apis.Resource{ + corev1.ResourceCPU: 10, + corev1.ResourceMemory: 20, + }, + highWatermark: apis.Resource{ + corev1.ResourceCPU: 80, + corev1.ResourceMemory: 30, + }, + exists: true, + wantErr: assert.NoError, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, got1, got2, err := WatermarkAnnotationSetting(tt.node) + if !tt.wantErr(t, err, fmt.Sprintf("WatermarkAnnotationSetting(%v)", tt.node)) { + return + } + assert.Equalf(t, tt.lowWatermark, got, "WatermarkAnnotationSetting(%v)", tt.node) + assert.Equalf(t, tt.highWatermark, got1, "WatermarkAnnotationSetting(%v)", tt.node) + assert.Equalf(t, tt.exists, got2, "WatermarkAnnotationSetting(%v)", tt.node) + }) + } +} + +func TestIsNodeSupportColocation(t *testing.T) { + testCases := []struct { + name string + node *corev1.Node + expectedResult bool + }{ + { + name: "missing colocation label && missing oversubscription label", + node: &corev1.Node{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test", + }, + }, + expectedResult: false, + }, + + { + name: "colocation label set false", + node: &corev1.Node{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test", + Labels: map[string]string{ + apis.ColocationEnableNodeLabelKey: "false", + }, + }, + }, + expectedResult: false, + }, + + { + name: "colocation label set true", + node: &corev1.Node{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test", + Labels: map[string]string{ + apis.ColocationEnableNodeLabelKey: "true", + }, + }, + }, + expectedResult: true, + }, + + { + name: "oversubscription label set true", + node: &corev1.Node{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test", + Labels: map[string]string{ + apis.OverSubscriptionNodeLabelKey: "true", + }, + }, + }, + expectedResult: true, + }, + + { + name: "oversubscription label set false", + node: &corev1.Node{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test", + Labels: map[string]string{ + apis.OverSubscriptionNodeLabelKey: "false", + }, + }, + }, + expectedResult: false, + }, + } + + for _, tc := range testCases { + actualResult := IsNodeSupportColocation(tc.node) || IsNodeSupportOverSubscription(tc.node) + assert.Equal(t, actualResult, tc.expectedResult, tc.name) + } +} diff --git a/pkg/agent/utils/node/patcher.go b/pkg/agent/utils/node/patcher.go new file mode 100644 index 000000000..4a1be3f36 --- /dev/null +++ b/pkg/agent/utils/node/patcher.go @@ -0,0 +1,158 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package node + +import ( + "context" + "fmt" + "time" + + v1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/equality" + "k8s.io/apimachinery/pkg/api/resource" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/util/wait" + clientretry "k8s.io/client-go/util/retry" + "k8s.io/klog/v2" + + "volcano.sh/volcano/pkg/agent/apis" + "volcano.sh/volcano/pkg/config" +) + +var updateNodeBackoff = wait.Backoff{ + Steps: 20, + Duration: 50 * time.Millisecond, + Jitter: 1.0, +} + +type Modifier func(*v1.Node) + +func update(config *config.Configuration, nodeModifiers []Modifier) error { + err := clientretry.RetryOnConflict(updateNodeBackoff, func() error { + curNode, err := config.GetNode() + if err != nil { + return err + } + + newNode := curNode.DeepCopy() + for _, modify := range nodeModifiers { + if modify == nil { + continue + } + modify(newNode) + } + if needUpdate(curNode, newNode) { + _, err := config.GenericConfiguration.KubeClient.CoreV1().Nodes().UpdateStatus(context.TODO(), newNode, metav1.UpdateOptions{}) + if err != nil { + return err + } + } + return nil + }) + return err +} + +func updateNodeOverSoldStatus(res apis.Resource) Modifier { + return func(node *v1.Node) { + if node.Status.Allocatable == nil { + node.Status.Allocatable = make(v1.ResourceList) + } + if node.Status.Capacity == nil { + node.Status.Capacity = make(v1.ResourceList) + } + for k, v := range res { + switch k { + case v1.ResourceCPU: + node.Status.Allocatable[apis.ExtendResourceCPU] = *resource.NewQuantity(v, resource.DecimalSI) + node.Status.Capacity[apis.ExtendResourceCPU] = *resource.NewQuantity(v, resource.DecimalSI) + case v1.ResourceMemory: + node.Status.Allocatable[apis.ExtendResourceMemory] = *resource.NewQuantity(v, resource.BinarySI) + node.Status.Capacity[apis.ExtendResourceMemory] = *resource.NewQuantity(v, resource.BinarySI) + default: + klog.ErrorS(nil, "Unsupported resource", "resType", k) + } + } + } +} + +func deleteNodeOverSoldStatus() Modifier { + return func(node *v1.Node) { + delete(node.Status.Capacity, apis.ExtendResourceCPU) + delete(node.Status.Capacity, apis.ExtendResourceMemory) + delete(node.Status.Allocatable, apis.ExtendResourceCPU) + delete(node.Status.Allocatable, apis.ExtendResourceMemory) + } +} + +func resetOverSubscriptionInfo() []Modifier { + var resetAnnotation Modifier = func(node *v1.Node) { + for _, at := range []string{apis.NodeOverSubscriptionCPUKey, apis.NodeOverSubscriptionMemoryKey} { + if _, ok := node.Annotations[at]; !ok { + continue + } + updateAnnotation(map[string]string{ + at: "0", + })(node) + } + } + + return []Modifier{resetAnnotation, ResetOverSubscriptionLabel()} +} + +func DeleteNodeOverSoldStatus(config *config.Configuration) error { + return update(config, []Modifier{ + ResetOverSubscriptionLabel(), + deleteNodeOverSoldStatus(), + }) +} + +// ResetOverSubNativeResource do following things: +// 1.set overSubscription label=false to disable NodeResourcesProbe and handler(IMPORTANT!) +// 2.set oversold resources = 0 on annotation +func ResetOverSubNativeResource(config *config.Configuration) error { + return update(config, resetOverSubscriptionInfo()) +} + +// ResetOverSubscriptionInfoAndRemoveEvictionAnnotation reset overSubscription info and remove eviction annotation. +func ResetOverSubscriptionInfoAndRemoveEvictionAnnotation(config *config.Configuration) error { + return update(config, append(resetOverSubscriptionInfo(), removeEvictionAnnotation())) +} + +// UpdateNodeResourceToAnnotation update oversold resources on annotation. +func UpdateNodeResourceToAnnotation(config *config.Configuration, res apis.Resource) error { + klog.InfoS("Try to update overSubscription resource on annotation", "resource", res) + return update(config, []Modifier{ + updateAnnotation(map[string]string{ + apis.NodeOverSubscriptionCPUKey: fmt.Sprintf("%d", res[v1.ResourceCPU]), + apis.NodeOverSubscriptionMemoryKey: fmt.Sprintf("%d", res[v1.ResourceMemory]), + }), + }) +} + +// UpdateNodeExtendResource update node extend resource in node status. +func UpdateNodeExtendResource(config *config.Configuration, res apis.Resource) error { + klog.InfoS("Try to update overSubscription resource on node status", "resource", res) + return update(config, []Modifier{updateNodeOverSoldStatus(res)}) +} + +func needUpdate(curNode, newNode *v1.Node) bool { + return !equality.Semantic.DeepEqual(curNode.Annotations, newNode.Annotations) || + !equality.Semantic.DeepEqual(curNode.Labels, newNode.Labels) || + !equality.Semantic.DeepEqual(curNode.Status.Allocatable[apis.ExtendResourceCPU], newNode.Status.Allocatable[apis.ExtendResourceCPU]) || + !equality.Semantic.DeepEqual(curNode.Status.Capacity[apis.ExtendResourceMemory], newNode.Status.Capacity[apis.ExtendResourceMemory]) || + !equality.Semantic.DeepEqual(curNode.Spec.Taints, newNode.Spec.Taints) +} diff --git a/pkg/agent/utils/node/patcher_test.go b/pkg/agent/utils/node/patcher_test.go new file mode 100644 index 000000000..52ae1849b --- /dev/null +++ b/pkg/agent/utils/node/patcher_test.go @@ -0,0 +1,84 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package node + +import ( + "context" + "testing" + + "github.com/stretchr/testify/assert" + v1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/resource" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + fakeclientset "k8s.io/client-go/kubernetes/fake" + + "volcano.sh/volcano/pkg/agent/apis" + "volcano.sh/volcano/pkg/config" +) + +func makeNode() (*v1.Node, error) { + return &v1.Node{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test-node", + }, + }, nil +} + +func Test_updater_Update(t *testing.T) { + fakeNode, err := makeNode() + assert.NoError(t, err) + fakeClient := fakeclientset.NewSimpleClientset(fakeNode) + + tests := []struct { + name string + config *config.Configuration + nodeModifiers []Modifier + expectedNode *v1.Node + }{ + { + name: "update node status", + config: &config.Configuration{GenericConfiguration: &config.VolcanoAgentConfiguration{ + KubeClient: fakeClient, + KubeNodeName: "test-node", + NodeHasSynced: func() bool { + return false + }, + }}, + expectedNode: &v1.Node{ + ObjectMeta: metav1.ObjectMeta{Name: "test-node"}, + Status: v1.NodeStatus{Allocatable: map[v1.ResourceName]resource.Quantity{ + apis.ExtendResourceCPU: *resource.NewQuantity(100, resource.DecimalSI), + apis.ExtendResourceMemory: *resource.NewQuantity(100, resource.BinarySI), + }, Capacity: map[v1.ResourceName]resource.Quantity{ + apis.ExtendResourceCPU: *resource.NewQuantity(100, resource.DecimalSI), + apis.ExtendResourceMemory: *resource.NewQuantity(100, resource.BinarySI), + }}}, + nodeModifiers: []Modifier{updateNodeOverSoldStatus(apis.Resource{ + v1.ResourceCPU: 100, + v1.ResourceMemory: 100, + })}, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assert.NoError(t, update(tt.config, tt.nodeModifiers)) + node, err := tt.config.GenericConfiguration.KubeClient.CoreV1().Nodes().Get(context.TODO(), "test-node", metav1.GetOptions{}) + assert.NoError(t, err) + assert.Equalf(t, tt.expectedNode, node, "update") + }) + } +} diff --git a/pkg/agent/utils/node/resource.go b/pkg/agent/utils/node/resource.go new file mode 100644 index 000000000..c9c22bfc6 --- /dev/null +++ b/pkg/agent/utils/node/resource.go @@ -0,0 +1,154 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package node + +import ( + "fmt" + "sort" + "strconv" + + v1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/resource" + "k8s.io/klog/v2" + + "volcano.sh/volcano/pkg/agent/apis" + utilpod "volcano.sh/volcano/pkg/agent/utils/pod" +) + +func IsOverused(resName v1.ResourceName, resList *ResourceList) bool { + podsRes, e1 := resList.TotalPodsRequest[resName] + nodeRes, e2 := resList.TotalNodeRes[resName] + + if !e1 || !e2 { + return false + } + + return podsRes.MilliValue() > nodeRes.MilliValue() +} + +func UseExtendResource(resName v1.ResourceName, resList *ResourceList) bool { + if resName == v1.ResourceCPU { + cpuReq, cpuExists := (*resList).TotalPodsRequest[apis.ExtendResourceCPU] + return cpuExists && !cpuReq.IsZero() + } + if resName == v1.ResourceMemory { + memReq, memoryExists := (*resList).TotalPodsRequest[apis.ExtendResourceMemory] + return memoryExists && !memReq.IsZero() + } + return false +} + +// GetAnnotationOverSubscription get current overSubscription resources on annotation. +func GetAnnotationOverSubscription(node *v1.Node) apis.Resource { + resources := make(apis.Resource) + resources[v1.ResourceCPU] = 0 + resources[v1.ResourceMemory] = 0 + if len(node.Annotations) == 0 { + return resources + } + + if value, found := node.Annotations[apis.NodeOverSubscriptionCPUKey]; found { + b, err := strconv.ParseInt(value, 10, 64) + if err == nil { + resources[v1.ResourceCPU] = b + } else { + klog.InfoS("Invalid annotation "+apis.NodeOverSubscriptionCPUKey, "value", value) + } + } + + if value, found := node.Annotations[apis.NodeOverSubscriptionMemoryKey]; found { + b, err := strconv.ParseInt(value, 10, 64) + if err == nil { + resources[v1.ResourceMemory] = b + } else { + klog.InfoS("Invalid annotation "+apis.NodeOverSubscriptionMemoryKey, "value", value) + } + } + return resources +} + +// GetNodeStatusOverSubscription get node status's overSubscription extend resources. +func GetNodeStatusOverSubscription(node *v1.Node) apis.Resource { + resources := make(apis.Resource) + resources[v1.ResourceCPU] = 0 + resources[v1.ResourceMemory] = 0 + if node.Status.Capacity == nil { + return resources + } + + if value, found := node.Status.Capacity[apis.ExtendResourceCPU]; found { + resources[v1.ResourceCPU] = value.Value() + } + + if value, found := node.Status.Capacity[apis.ExtendResourceMemory]; found { + resources[v1.ResourceMemory] = value.Value() + } + return resources +} + +// GetTotalNodeResource return total allocatable resource on the node, include overSubscription resource if include OverSubscription=true +func GetTotalNodeResource(node *v1.Node, includeOverSubscription bool) v1.ResourceList { + total := make(v1.ResourceList) + + cpu := node.Status.Allocatable[v1.ResourceCPU] + memory := node.Status.Allocatable[v1.ResourceMemory] + + if includeOverSubscription { + overSubscriptionCPU := resource.MustParse("0") + overSubscriptionMemory := resource.MustParse("0") + if node.Annotations != nil { + if node.Annotations[apis.NodeOverSubscriptionCPUKey] != "" { + overSubscriptionCPU = resource.MustParse(fmt.Sprintf("%sm", node.Annotations[apis.NodeOverSubscriptionCPUKey])) + } + if node.Annotations[apis.NodeOverSubscriptionMemoryKey] != "" { + overSubscriptionMemory = resource.MustParse(node.Annotations[apis.NodeOverSubscriptionMemoryKey]) + } + } + + cpu.Add(overSubscriptionCPU) + memory.Add(overSubscriptionMemory) + } + + total[v1.ResourceCPU] = cpu + total[v1.ResourceMemory] = memory + + return total +} + +func GetLatestPodsAndResList(node *v1.Node, getPodFunc utilpod.ActivePods, resType v1.ResourceName) ([]*v1.Pod, *ResourceList, error) { + pods, err := getPodFunc() + if err != nil { + return nil, nil, err + } + _, preemptablePods := utilpod.FilterOutPreemptablePods(pods) + // TODO: Add more pods eviction sort policy. + if resType == v1.ResourceCPU { + sort.Sort(utilpod.SortedPodsByRequestCPU(preemptablePods)) + } else { + sort.Sort(utilpod.SortedPodsByRequestMemory(preemptablePods)) + } + resList := getResourceList(node, pods) + return preemptablePods, resList, nil +} + +func getResourceList(node *v1.Node, pods []*v1.Pod) *ResourceList { + resList := new(ResourceList) + fns := []utilpod.FilterPodsFunc{utilpod.IncludeOversoldPodFn(true), utilpod.IncludeGuaranteedPodsFn(true)} + resList.TotalPodsRequest = utilpod.GetTotalRequest(pods, fns, apis.OverSubscriptionResourceTypesIncludeExtendResources) + resList.TotalNodeRes = GetTotalNodeResource(node, false) + return resList +} diff --git a/pkg/agent/utils/node/taints.go b/pkg/agent/utils/node/taints.go new file mode 100644 index 000000000..ad49e1270 --- /dev/null +++ b/pkg/agent/utils/node/taints.go @@ -0,0 +1,45 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package node + +import ( + "context" + "fmt" + + v1 "k8s.io/api/core/v1" + "k8s.io/kubernetes/pkg/controller" + + "volcano.sh/volcano/pkg/agent/apis" + "volcano.sh/volcano/pkg/config" +) + +var taint = &v1.Taint{ + Key: apis.PodEvictingKey, + Effect: v1.TaintEffectNoSchedule, +} + +func DisableSchedule(config *config.Configuration) error { + return controller.AddOrUpdateTaintOnNode(context.TODO(), config.GenericConfiguration.KubeClient, config.GenericConfiguration.KubeNodeName, taint) +} + +func RecoverSchedule(config *config.Configuration) error { + node, err := config.GetNode() + if err != nil { + return fmt.Errorf("failed to get node, err: %v", err) + } + return controller.RemoveTaintOffNode(context.TODO(), config.GenericConfiguration.KubeClient, config.GenericConfiguration.KubeNodeName, node, taint) +} diff --git a/pkg/agent/utils/pod/pod.go b/pkg/agent/utils/pod/pod.go new file mode 100644 index 000000000..6621029b8 --- /dev/null +++ b/pkg/agent/utils/pod/pod.go @@ -0,0 +1,189 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package pod + +import ( + "context" + + v1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/resource" + clientset "k8s.io/client-go/kubernetes" + v1qos "k8s.io/kubernetes/pkg/apis/core/v1/helper/qos" + + "volcano.sh/volcano/pkg/agent/apis/extension" + "volcano.sh/volcano/pkg/agent/utils" +) + +// ActivePods returns pods bound to the kubelet that are active (i.e. non-terminal state) +type ActivePods func() ([]*v1.Pod, error) + +type KillPod func(ctx context.Context, client clientset.Interface, gracePeriodSeconds *int64, pod *v1.Pod) error + +type FilterPodsFunc func(*v1.Pod, v1.ResourceName) bool + +type filterPodsFunc func(bool) FilterPodsFunc + +var IncludeOversoldPodFn filterPodsFunc = func(b bool) FilterPodsFunc { + f := func(pod *v1.Pod, resType v1.ResourceName) bool { + return !b && IsPreemptablePod(pod) + } + return f +} + +var IncludeGuaranteedPodsFn filterPodsFunc = func(b bool) FilterPodsFunc { + f := func(pod *v1.Pod, resType v1.ResourceName) bool { + return !b && resType == v1.ResourceCPU && IsGuaranteedAndNonPreemptablePods(pod) + } + return f +} + +// SortedPodsByRequestCPU sort pods by cpu request value. +type SortedPodsByRequestCPU []*v1.Pod + +func (s SortedPodsByRequestCPU) Len() int { return len(s) } +func (s SortedPodsByRequestCPU) Swap(i, j int) { s[i], s[j] = s[j], s[i] } +func (s SortedPodsByRequestCPU) Less(i, j int) bool { + r1, r2 := int64(0), int64(0) + for _, c := range s[i].Spec.Containers { + r1 += c.Resources.Requests.Cpu().Value() + } + for _, c := range s[j].Spec.Containers { + r2 += c.Resources.Requests.Cpu().Value() + } + return r1 > r2 +} + +// SortedPodsByRequestMemory sort pods by memory request value. +type SortedPodsByRequestMemory []*v1.Pod + +func (s SortedPodsByRequestMemory) Len() int { return len(s) } +func (s SortedPodsByRequestMemory) Swap(i, j int) { s[i], s[j] = s[j], s[i] } +func (s SortedPodsByRequestMemory) Less(i, j int) bool { + r1, r2 := int64(0), int64(0) + for _, c := range s[i].Spec.Containers { + r1 += c.Resources.Requests.Memory().Value() + } + for _, c := range s[j].Spec.Containers { + r2 += c.Resources.Requests.Memory().Value() + } + return r1 > r2 +} + +// GetTotalRequest return the total resource of pods +func GetTotalRequest(pods []*v1.Pod, fns []FilterPodsFunc, resTypes []v1.ResourceName) v1.ResourceList { + total := make(v1.ResourceList) + for _, resType := range resTypes { + total[resType] = getTotalRequestByType(pods, fns, resType) + } + return total +} + +// IsGuaranteedAndNonPreemptablePods return whether pod is guaranteed, but preemptable guaranteed pods are excluded. +func IsGuaranteedAndNonPreemptablePods(pod *v1.Pod) bool { + return v1qos.GetPodQOS(pod) == v1.PodQOSGuaranteed && !IsPreemptablePod(pod) +} + +// IsPreemptablePod check if a pod an offline pod. +func IsPreemptablePod(pod *v1.Pod) bool { + return extension.GetQosLevel(pod) < 0 +} + +func IncludeGuaranteedPods() bool { + policy := utils.GetCPUManagerPolicy() + return policy == "" || policy == "none" +} + +func GuaranteedPodsCPURequest(pods []*v1.Pod) int64 { + if IncludeGuaranteedPods() { + return 0 + } + guaranteedPods := []*v1.Pod{} + for idx := range pods { + if IsGuaranteedAndNonPreemptablePods(pods[idx]) { + guaranteedPods = append(guaranteedPods, pods[idx]) + } + } + + fns := []FilterPodsFunc{IncludeOversoldPodFn(true), IncludeGuaranteedPodsFn(true)} + quantity := GetTotalRequest(guaranteedPods, fns, []v1.ResourceName{v1.ResourceCPU})[v1.ResourceCPU] + return quantity.MilliValue() +} + +// FilterOutPreemptablePods return pods those are not preemptable +func FilterOutPreemptablePods(pods []*v1.Pod) ([]*v1.Pod, []*v1.Pod) { + normalPods := make([]*v1.Pod, 0) + preemptablePods := make([]*v1.Pod, 0) + for _, pod := range pods { + if IsPreemptablePod(pod) { + preemptablePods = append(preemptablePods, pod) + } else { + normalPods = append(normalPods, pod) + } + } + return normalPods, preemptablePods +} + +// CPU resource will be ignored for guaranteed and non preemptable pods if cpu manager policy not none. +func getTotalRequestByType(pods []*v1.Pod, fns []FilterPodsFunc, resType v1.ResourceName) resource.Quantity { + totalRes := resource.MustParse("0") + for _, pod := range pods { + skip := false + for _, fn := range fns { + if fn(pod, resType) { + skip = true + break + } + } + if skip { + continue + } + + podRes := resource.Quantity{} + for _, container := range pod.Spec.Containers { + resValue, found := container.Resources.Requests[resType] + if !found { + continue + } + podRes.Add(resValue) + } + + // init containers define the minimum of any resource + for _, container := range pod.Spec.InitContainers { + resValue, found := container.Resources.Requests[resType] + if !found { + continue + } + podRes = maxResourceReq(podRes, resValue) + } + totalRes.Add(podRes) + } + + return totalRes +} + +// maxResourceReq return the greater one of res/newRes. +func maxResourceReq(res, newRes resource.Quantity) resource.Quantity { + if res.Cmp(newRes) > 0 { + return res + } + return newRes +} + +// IsPodTerminated return true if pod is terminated. +func IsPodTerminated(pod *v1.Pod) bool { + return pod.DeletionTimestamp != nil || pod.Status.Phase == v1.PodSucceeded || pod.Status.Phase == v1.PodFailed +} diff --git a/pkg/agent/utils/pod/resources.go b/pkg/agent/utils/pod/resources.go new file mode 100644 index 000000000..8ce215bac --- /dev/null +++ b/pkg/agent/utils/pod/resources.go @@ -0,0 +1,150 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package pod + +import ( + "strings" + + v1 "k8s.io/api/core/v1" + "k8s.io/klog/v2" + + "volcano.sh/volcano/pkg/agent/apis" + "volcano.sh/volcano/pkg/agent/utils/cgroup" +) + +const ( + // These limits are defined in the kernel: + // https://github.com/torvalds/linux/blob/0bddd227f3dc55975e2b8dfa7fc6f959b062a2c7/kernel/sched/sched.h#L427-L428 + minShares = 2 + maxShares = 262144 + + sharesPerCPU = 1024 + milliCPUToCPU = 1000 + + // 100000 is equivalent to 100ms + quotaPeriod = 100000 + minQuotaPeriod = 1000 +) + +// Resources represents container level resources. +type Resources struct { + CgroupSubSystem cgroup.CgroupSubsystem + ContainerID string + SubPath string + Value int64 +} + +// CalculateExtendResources calculates pod and container that use extend resource level cgroup resource, include cpu and memory +func CalculateExtendResources(pod *v1.Pod) []Resources { + containerRes := []Resources{} + cpuSharesTotal, cpuLimitsTotal, memoryLimitsTotal := int64(0), int64(0), int64(0) + // track if limits were applied for each resource. + cpuLimitsDeclared := true + memoryLimitsDeclared := true + // TODO: support init containers. + for _, c := range pod.Spec.Containers { + id := findContainerIDByName(pod, c.Name) + // set cpu share. + cpuReq, ok := c.Resources.Requests[apis.ExtendResourceCPU] + if ok && !cpuReq.IsZero() { + cpuShares := int64(milliCPUToShares(cpuReq.Value())) + containerRes = append(containerRes, Resources{CgroupSubSystem: cgroup.CgroupCpuSubsystem, ContainerID: id, SubPath: cgroup.CPUShareFileName, Value: cpuShares}) + cpuSharesTotal += cpuShares + } + + // set cpu quota. + cpuLimits, ok := c.Resources.Limits[apis.ExtendResourceCPU] + if ok && !cpuLimits.IsZero() { + cpuQuota := milliCPUToQuota(cpuLimits.Value(), quotaPeriod) + containerRes = append(containerRes, Resources{CgroupSubSystem: cgroup.CgroupCpuSubsystem, ContainerID: id, SubPath: cgroup.CPUQuotaTotalFile, Value: cpuQuota}) + cpuLimitsTotal += cpuQuota + } else { + cpuLimitsDeclared = false + } + + // set memory limit. + memoryLimit, ok := c.Resources.Limits[apis.ExtendResourceMemory] + if ok && !memoryLimit.IsZero() { + containerRes = append(containerRes, Resources{CgroupSubSystem: cgroup.CgroupMemorySubsystem, ContainerID: id, SubPath: cgroup.MemoryLimitFile, Value: memoryLimit.Value()}) + memoryLimitsTotal += memoryLimit.Value() + } else { + memoryLimitsDeclared = false + } + } + + // set pod level cgroup, container id="". + if cpuSharesTotal == 0 { + cpuSharesTotal = minShares + } + containerRes = append(containerRes, Resources{CgroupSubSystem: cgroup.CgroupCpuSubsystem, SubPath: cgroup.CPUShareFileName, Value: cpuSharesTotal}) + + // pod level should not set limit when exits one container has no cpu limit. + if cpuLimitsDeclared { + containerRes = append(containerRes, Resources{CgroupSubSystem: cgroup.CgroupCpuSubsystem, SubPath: cgroup.CPUQuotaTotalFile, Value: cpuLimitsTotal}) + } + // pod level should not set limit when exits one container has no memory limit. + if memoryLimitsDeclared { + containerRes = append(containerRes, Resources{CgroupSubSystem: cgroup.CgroupMemorySubsystem, SubPath: cgroup.MemoryLimitFile, Value: memoryLimitsTotal}) + } + return containerRes +} + +func findContainerIDByName(pod *v1.Pod, name string) string { + for _, status := range pod.Status.ContainerStatuses { + if status.Name == name { + parts := strings.Split(status.ContainerID, "://") + if len(parts) != 2 { + klog.ErrorS(nil, "Failed to get container id", "name", name) + return "" + } + return parts[1] + } + } + return "" +} + +// milliCPUToQuota converts milliCPU to CFS quota and period values +func milliCPUToQuota(milliCPU int64, period int64) (quota int64) { + // we then convert your milliCPU to a value normalized over a period + quota = (milliCPU * period) / milliCPUToCPU + + // quota needs to be a minimum of 1ms. + if quota < minQuotaPeriod { + quota = minQuotaPeriod + } + + return +} + +// milliCPUToShares converts the milliCPU to CFS shares. +func milliCPUToShares(milliCPU int64) uint64 { + if milliCPU == 0 { + // Docker converts zero milliCPU to unset, which maps to kernel default + // for unset: 1024. Return 2 here to really match kernel default for + // zero milliCPU. + return minShares + } + // Conceptually (milliCPU / milliCPUToCPU) * sharesPerCPU, but factored to improve rounding. + shares := (milliCPU * sharesPerCPU) / milliCPUToCPU + if shares < minShares { + return minShares + } + if shares > maxShares { + return maxShares + } + return uint64(shares) +} diff --git a/pkg/agent/utils/pod/resources_test.go b/pkg/agent/utils/pod/resources_test.go new file mode 100644 index 000000000..862027efd --- /dev/null +++ b/pkg/agent/utils/pod/resources_test.go @@ -0,0 +1,126 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package pod + +import ( + "fmt" + "reflect" + "testing" + + v1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/resource" +) + +func TestCalculateExtendResources(t *testing.T) { + tests := []struct { + name string + pod *v1.Pod + want []Resources + }{ + { + name: "one container without cpu request, one container without memory limit", + pod: &v1.Pod{ + Spec: v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "container-1", + Resources: v1.ResourceRequirements{ + Limits: map[v1.ResourceName]resource.Quantity{ + "kubernetes.io/batch-cpu": *resource.NewQuantity(5, resource.DecimalSI), + }, + Requests: map[v1.ResourceName]resource.Quantity{ + "kubernetes.io/batch-cpu": *resource.NewQuantity(500, resource.DecimalSI), + "kubernetes.io/batch-memory": *resource.NewQuantity(100, resource.BinarySI), + }, + }, + }, + { + Name: "container-2", + Resources: v1.ResourceRequirements{ + Limits: map[v1.ResourceName]resource.Quantity{ + "kubernetes.io/batch-cpu": *resource.NewQuantity(1000, resource.DecimalSI), + "kubernetes.io/batch-memory": *resource.NewQuantity(200, resource.BinarySI), + }, + Requests: map[v1.ResourceName]resource.Quantity{ + "kubernetes.io/batch-memory": *resource.NewQuantity(100, resource.BinarySI), + }, + }, + }, + }, + }, + Status: v1.PodStatus{ContainerStatuses: []v1.ContainerStatus{ + { + Name: "container-1", + ContainerID: fmt.Sprintf("containerd://%s", "111"), + }, + { + Name: "container-2", + ContainerID: fmt.Sprintf("docker://%s", "222"), + }, + }}, + }, + want: []Resources{ + // container-1 + { + CgroupSubSystem: "cpu", + ContainerID: "111", + SubPath: "cpu.shares", + Value: 512, + }, + { + CgroupSubSystem: "cpu", + ContainerID: "111", + SubPath: "cpu.cfs_quota_us", + Value: 1000, + }, + + // container-2 + { + CgroupSubSystem: "cpu", + ContainerID: "222", + SubPath: "cpu.cfs_quota_us", + Value: 100000, + }, + { + CgroupSubSystem: "memory", + ContainerID: "222", + SubPath: "memory.limit_in_bytes", + Value: 200, + }, + + // pod + { + CgroupSubSystem: "cpu", + SubPath: "cpu.shares", + Value: 512, + }, + { + CgroupSubSystem: "cpu", + SubPath: "cpu.cfs_quota_us", + Value: 101000, + }, + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := CalculateExtendResources(tt.pod); !reflect.DeepEqual(got, tt.want) { + t.Errorf("CalculateExtendResources() = %v, want %v", got, tt.want) + } + }) + } +} diff --git a/pkg/agent/utils/testing/pod.go b/pkg/agent/utils/testing/pod.go new file mode 100644 index 000000000..111255aff --- /dev/null +++ b/pkg/agent/utils/testing/pod.go @@ -0,0 +1,106 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package testing + +import ( + "context" + + "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/resource" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/client-go/tools/record" + + "volcano.sh/volcano/pkg/agent/apis" +) + +// PodProvider is used to get pods and evicted pods, just for testing. +type PodProvider struct { + pods []*v1.Pod + evictedPods []*v1.Pod +} + +func NewPodProvider(pods ...*v1.Pod) *PodProvider { + pp := &PodProvider{pods: pods} + return pp +} + +func (m *PodProvider) Evict(ctx context.Context, pod *v1.Pod, eventRecorder record.EventRecorder, gracePeriodSeconds int64, evictMsg string) bool { + m.evictedPods = append(m.evictedPods, pod) + idx := -1 + for i := range m.pods { + if m.pods[i].Name == pod.Name { + idx = i + } + } + if idx == -1 { + return false + } + m.pods = append(m.pods[:idx], m.pods[idx+1:]...) + return true +} + +func (m *PodProvider) GetPodsFunc() ([]*v1.Pod, error) { + return m.pods, nil +} + +func (m *PodProvider) GetEvictedPods() []*v1.Pod { + return m.evictedPods +} + +func MakePod(name string, cpuRequest, memoryRequest int64, qosLevel string) *v1.Pod { + return &v1.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Annotations: map[string]string{apis.PodQosLevelKey: qosLevel}, + Name: name, + }, + Spec: v1.PodSpec{ + Containers: []v1.Container{{ + Resources: v1.ResourceRequirements{ + Limits: v1.ResourceList{ + v1.ResourceCPU: *resource.NewQuantity(cpuRequest, resource.DecimalSI), + v1.ResourceMemory: *resource.NewQuantity(memoryRequest, resource.DecimalSI), + }, + Requests: v1.ResourceList{ + v1.ResourceCPU: *resource.NewQuantity(cpuRequest, resource.DecimalSI), + v1.ResourceMemory: *resource.NewQuantity(memoryRequest, resource.DecimalSI), + }, + }}, + }}, + } +} + +func MakePodWithExtendResources(name string, cpuRequest, memoryRequest int64, qosLevel string) *v1.Pod { + return &v1.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Annotations: map[string]string{apis.PodQosLevelKey: qosLevel}, + Name: name, + }, + Spec: v1.PodSpec{ + Containers: []v1.Container{{ + Resources: v1.ResourceRequirements{ + Limits: v1.ResourceList{ + apis.ExtendResourceCPU: *resource.NewQuantity(cpuRequest, resource.DecimalSI), + apis.ExtendResourceMemory: *resource.NewQuantity(memoryRequest, resource.DecimalSI), + }, + Requests: v1.ResourceList{ + apis.ExtendResourceCPU: *resource.NewQuantity(cpuRequest, resource.DecimalSI), + apis.ExtendResourceMemory: *resource.NewQuantity(memoryRequest, resource.DecimalSI), + }, + }}, + }}, + } +} diff --git a/pkg/agent/utils/utils.go b/pkg/agent/utils/utils.go new file mode 100644 index 000000000..9b9dbfac0 --- /dev/null +++ b/pkg/agent/utils/utils.go @@ -0,0 +1,154 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package utils + +import ( + "encoding/json" + "fmt" + "os" + "path" + "path/filepath" + "strings" + + v1 "k8s.io/api/core/v1" + "k8s.io/klog/v2" + "k8s.io/kubernetes/pkg/kubelet/cm/cpumanager/state" + + "volcano.sh/volcano/pkg/agent/apis" + "volcano.sh/volcano/pkg/agent/config/api" + "volcano.sh/volcano/pkg/agent/utils/file" +) + +var ( + SysFsPathEnv = "SYS_FS_PATH" + DefaultSysFsPath = "/sys/fs" +) + +const ( + // Component is volcano agent component name + Component = "volcano-agent" + + kubeletRootDirEnv = "KUBELET_ROOT_DIR" + + defaultKubeletRootDir = "/var/lib/kubelet" + + cpuManagerState = "cpu_manager_state" +) + +func UpdateFile(path string, content []byte) error { + oldValue, err := file.ReadByteFromFile(path) + if err != nil { + return fmt.Errorf("failed to get value from file(%s): %w", path, err) + } + + if strings.Compare(strings.TrimRight(string(oldValue), "\n"), string(content)) == 0 { + return nil + } + + err = file.WriteByteToFile(path, content) + if err != nil { + return fmt.Errorf("failed to write content(%s) to file(%s): %w", content, path, err) + } + + klog.InfoS("Successfully update content to file", "content", content, "file", path) + return nil +} + +func UpdatePodCgroup(cgroupFile string, content []byte) error { + dir, file := path.Split(cgroupFile) + err := filepath.WalkDir(dir, func(p string, d os.DirEntry, iErr error) error { + if iErr != nil { + return iErr + } + if d != nil && !d.IsDir() { + return nil + } + if updateErr := UpdateFile(path.Join(p, file), content); updateErr != nil { + return fmt.Errorf("failed to update file(%s): %w", path.Join(dir, file), updateErr) + } + return nil + }) + return err +} + +type OSRelease struct { + Name string + Version string + ID string + VersionID string +} + +func GetOSReleaseFromFile(releaseFile string) (*OSRelease, error) { + var release OSRelease + content, err := file.ReadByteFromFile(releaseFile) + if err != nil { + klog.ErrorS(err, "Failed to read release path", "path", releaseFile) + return nil, err + } + + lineContents := strings.Split(string(content), "\n") + for index := range lineContents { + pairs := strings.Split(lineContents[index], "=") + if len(pairs) != 2 { + continue + } + switch strings.Trim(pairs[0], "\"") { + case "NAME": + release.Name = strings.Trim(pairs[1], "\"") + case "VERSION": + release.Version = strings.Trim(pairs[1], "\"") + case "ID": + release.ID = strings.Trim(pairs[1], "\"") + case "VERSION_ID": + release.VersionID = strings.Trim(pairs[1], "\"") + default: + } + } + return &release, nil +} + +// SetEvictionWatermark set eviction watermark. +func SetEvictionWatermark(cfg *api.ColocationConfig, lowWatermark apis.Watermark, highWatermark apis.Watermark) { + lowWatermark[v1.ResourceCPU] = *cfg.EvictingConfig.EvictingCPULowWatermark + lowWatermark[v1.ResourceMemory] = *cfg.EvictingConfig.EvictingMemoryLowWatermark + highWatermark[v1.ResourceCPU] = *cfg.EvictingConfig.EvictingCPUHighWatermark + highWatermark[v1.ResourceMemory] = *cfg.EvictingConfig.EvictingMemoryHighWatermark + klog.InfoS("Successfully set watermark", + "cpuLowWatermark", *cfg.EvictingConfig.EvictingCPULowWatermark, + "cpuHighWatermark", *cfg.EvictingConfig.EvictingCPUHighWatermark, + "memoryLowWatermark", *cfg.EvictingConfig.EvictingMemoryLowWatermark, + "memoryHighWatermark", *cfg.EvictingConfig.EvictingMemoryHighWatermark) +} + +func GetCPUManagerPolicy() string { + kubeletDir := strings.TrimSpace(os.Getenv(kubeletRootDirEnv)) + if kubeletDir == "" { + kubeletDir = defaultKubeletRootDir + } + + b, err := os.ReadFile(path.Join(kubeletDir, cpuManagerState)) + if err != nil { + klog.ErrorS(err, "Failed to read cpu manager state file") + return "" + } + s := &state.CPUManagerCheckpoint{} + if err = json.Unmarshal(b, s); err != nil { + klog.ErrorS(err, "Failed to unmarshal cpu manager state") + return "" + } + return s.PolicyName +} diff --git a/pkg/agent/utils/utils_test.go b/pkg/agent/utils/utils_test.go new file mode 100644 index 000000000..187b9983a --- /dev/null +++ b/pkg/agent/utils/utils_test.go @@ -0,0 +1,198 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package utils + +import ( + "os" + "path" + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestUpdatePodCgroup(t *testing.T) { + tmp, err := os.MkdirTemp("", "cgroup") + if err != nil { + t.Fatal(err) + } + defer func() { + err = os.RemoveAll(tmp) + if err != nil { + t.Errorf("remove dir(%s) failed: %v", tmp, err) + } + assert.Equal(t, err == nil, true) + }() + assert.Equal(t, err == nil, true) + + testCases := []struct { + name string + files []string + content []byte + expectedErr bool + }{ + { + name: "memory-qos", + files: []string{ + "pod00000000-1111-2222-3333-000000000001/memory.qos_level", + "pod00000000-1111-2222-3333-000000000001/c0000000000000000000000000001/memory.qos_level", + "pod00000000-1111-2222-3333-000000000001/c0000000000000000000000000002/memory.qos_level", + "pod00000000-1111-2222-3333-000000000001/c0000000000000000000000000003/memory.qos_level", + }, + content: []byte("-1"), + expectedErr: false, + }, + + { + name: "cpu-qos", + files: []string{ + "pod00000000-1111-2222-3333-000000000001/cpu.qos_level", + "pod00000000-1111-2222-3333-000000000001/c0000000000000000000000000001/cpu.qos_level", + "pod00000000-1111-2222-3333-000000000001/c0000000000000000000000000002/cpu.qos_level", + "pod00000000-1111-2222-3333-000000000001/c0000000000000000000000000003/cpu.qos_level", + }, + content: []byte("-1"), + expectedErr: false, + }, + + { + name: "network-qos", + files: []string{ + "pod00000000-1111-2222-3333-000000000001/net_cls.classid", + "pod00000000-1111-2222-3333-000000000001/c0000000000000000000000000001/net_cls.classid", + "pod00000000-1111-2222-3333-000000000001/c0000000000000000000000000002/net_cls.classid", + "pod00000000-1111-2222-3333-000000000001/c0000000000000000000000000003/net_cls.classid", + }, + content: []byte("4294967295"), + expectedErr: false, + }, + } + for _, tc := range testCases { + for _, f := range tc.files { + mkErr := os.MkdirAll(path.Join(tmp, path.Dir(f)), 0750) + if mkErr != nil { + assert.Equal(t, nil, mkErr, tc.name) + } + writeErr := os.WriteFile(path.Join(tmp, f), []byte("0"), 0660) + if writeErr != nil { + assert.Equal(t, nil, writeErr, tc.name) + } + } + + actualErr := UpdatePodCgroup(path.Join(tmp, tc.files[0]), tc.content) + assert.Equal(t, tc.expectedErr, actualErr != nil, tc.name) + + for _, f := range tc.files { + actualContent, readErr := os.ReadFile(path.Join(path.Join(tmp, f))) + assert.Equal(t, nil, readErr, tc.name) + assert.Equal(t, tc.content, actualContent, tc.name) + } + } +} + +func TestGetOSReleaseFromFile(t *testing.T) { + dir, err := os.MkdirTemp("/tmp", "MkdirTemp") + defer func() { + err = os.RemoveAll(dir) + if err != nil { + t.Errorf("remove dir(%s) failed: %v", dir, err) + } + assert.Equal(t, err == nil, true) + }() + assert.Equal(t, err == nil, true) + + testCases := []struct { + name string + content string + expectedOSRelease *OSRelease + expectedErr bool + }{ + { + name: "openEuler && x86", + content: ` +NAME="openEuler" +VERSION="22.03 (LTS-SP2)" +ID="openEuler" +VERSION_ID="22.03" +PRETTY_NAME="openEuler 22.03 (LTS-SP2)" +ANSI_COLOR="0;31" + `, + expectedErr: false, + expectedOSRelease: &OSRelease{ + Name: "openEuler", + Version: "22.03 (LTS-SP2)", + ID: "openEuler", + VersionID: "22.03", + }, + }, + } + + for _, tc := range testCases { + tmpFile := path.Join(dir, "os-release") + if err = os.WriteFile(tmpFile, []byte(tc.content), 0660); err != nil { + assert.Equal(t, nil, err) + } + actualOSRelease, actualErr := GetOSReleaseFromFile(tmpFile) + assert.Equal(t, tc.expectedErr, actualErr != nil, tc.name) + assert.Equal(t, tc.expectedOSRelease, actualOSRelease, tc.name) + } + +} + +func TestGetCPUManagerPolicy(t *testing.T) { + dir, err := os.MkdirTemp("", "cpuManagerPolicy") + assert.NoError(t, err) + defer func() { + err = os.RemoveAll(dir) + assert.NoError(t, err) + }() + + tests := []struct { + name string + want string + prepare func() + }{ + { + name: "file not exist", + want: "", + prepare: func() { + err = os.Setenv(kubeletRootDirEnv, dir) + assert.NoError(t, err) + }, + }, + { + name: "read correctly", + want: "static", + prepare: func() { + err = os.Setenv(kubeletRootDirEnv, dir) + assert.NoError(t, err) + b := []byte(`{"policyName":"static","defaultCpuSet":"0-1","checksum":1636926438}`) + err = os.WriteFile(path.Join(dir, cpuManagerState), b, 0600) + assert.NoError(t, err) + }, + }, + } + for _, tt := range tests { + if tt.prepare != nil { + tt.prepare() + } + t.Run(tt.name, func(t *testing.T) { + if got := GetCPUManagerPolicy(); got != tt.want { + t.Errorf("GetCPUManagerPolicy() = %v, want %v", got, tt.want) + } + }) + } +} diff --git a/pkg/agent/utils/version/compare.go b/pkg/agent/utils/version/compare.go new file mode 100644 index 000000000..074a1ed54 --- /dev/null +++ b/pkg/agent/utils/version/compare.go @@ -0,0 +1,82 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package version + +import ( + "regexp" + "strconv" + "strings" +) + +// HigherOrEqual return whether version1 >= version2. +// example: +// 23.03 (LTS-SP2) > 22.03 (LTS-SP2) => true +// 21.04 (LTS-SP2) < 22.03 (LTS-SP2) => false +// 22.03 (LTS-SP1) < 22.03 (LTS-SP2) => false +// 22.03 (LTS-SP2) = 22.03 (LTS-SP2) => true +func HigherOrEqual(version1, version2 string) bool { + v1 := strings.Split(version1, " ") + if len(v1) <= 1 { + return false + } + v2 := strings.Split(version2, " ") + if len(v2) <= 1 { + return false + } + return compareVersion(v1[0], v2[0]) > 0 || (compareVersion(v1[0], v2[0]) == 0) && compareSP(v1[1], v2[1]) >= 0 +} + +func compareVersion(version1, version2 string) int { + v1 := strings.Split(version1, ".") + v2 := strings.Split(version2, ".") + var err error + for i := 0; i < len(v1) || i < len(v2); i++ { + x, y := 0, 0 + if i < len(v1) { + x, err = strconv.Atoi(v1[i]) + if err != nil { + return -1 + } + } + if i < len(v2) { + y, err = strconv.Atoi(v2[i]) + if err != nil { + return -1 + } + } + if x > y { + return 1 + } + if x < y { + return -1 + } + } + return 0 +} + +func compareSP(s1, s2 string) int { + re := regexp.MustCompile(`SP(\d)\)`) + sub1 := re.FindStringSubmatch(s1) + if len(sub1) <= 1 { + return -1 + } + sub2 := re.FindStringSubmatch(s2) + if len(sub2) <= 1 { + return -1 + } + return strings.Compare(sub1[1], sub2[1]) +} diff --git a/pkg/agent/utils/version/compare_test.go b/pkg/agent/utils/version/compare_test.go new file mode 100644 index 000000000..33e609cae --- /dev/null +++ b/pkg/agent/utils/version/compare_test.go @@ -0,0 +1,72 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package version + +import "testing" + +func TestHigherOrEqual(t *testing.T) { + tests := []struct { + name string + version1 string + version2 string + want bool + }{ + { + name: "v1 > v2", + version1: "23.03 (LTS-SP1)", + version2: "22.03 (LTS-SP2)", + want: true, + }, + { + name: "v1 > v2", + version1: "23.03 (LTS-SP2)", + version2: "22.03 (LTS-SP2)", + want: true, + }, + { + name: "v1 = v2", + version1: "22.03 (LTS-SP2)", + version2: "22.03 (LTS-SP2)", + want: true, + }, + { + name: "v1 < v2", + version1: "21.03 (LTS-SP2)", + version2: "22.03 (LTS-SP2)", + want: false, + }, + { + name: "v1 < v2", + version1: "22.03 (LTS-SP1)", + version2: "22.03 (LTS-SP2)", + want: false, + }, + { + name: "invalid version", + version1: "22.03LTS-SP2", + version2: "22.03 (LTS-SP2)", + want: false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := HigherOrEqual(tt.version1, tt.version2); got != tt.want { + t.Errorf("HigherOrEqual() = %v, want %v", got, tt.want) + } + }) + } +} diff --git a/pkg/config/config.go b/pkg/config/config.go new file mode 100644 index 000000000..2259482a5 --- /dev/null +++ b/pkg/config/config.go @@ -0,0 +1,144 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package config + +import ( + "context" + "time" + + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/fields" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/client-go/informers" + coreinformers "k8s.io/client-go/informers/core/v1" + clientset "k8s.io/client-go/kubernetes" + "k8s.io/client-go/tools/cache" + + utilpod "volcano.sh/volcano/pkg/agent/utils/pod" +) + +const ( + specNodeNameField = "spec.nodeName" + defaultPodReSyncPeriod = 15 * time.Minute +) + +type Configuration struct { + GenericConfiguration *VolcanoAgentConfiguration + InformerFactory *InformerFactory +} + +func NewConfiguration() *Configuration { + return &Configuration{ + GenericConfiguration: &VolcanoAgentConfiguration{}, + InformerFactory: &InformerFactory{}, + } +} + +func (c *Configuration) Complete(client clientset.Interface) { + // only pod needs to be re-synced. + sharedFactory := informers.NewSharedInformerFactoryWithOptions(client, 0, informers.WithCustomResyncConfig(map[metav1.Object]time.Duration{ + &corev1.Pod{}: defaultPodReSyncPeriod, + })) + nodeInformer := sharedFactory.InformerFor(&corev1.Node{}, + func(client clientset.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + tweakListOptions := func(options *metav1.ListOptions) { + options.FieldSelector = fields.OneTermEqualSelector(metav1.ObjectNameField, c.GenericConfiguration.KubeNodeName).String() + } + return coreinformers.NewFilteredNodeInformer(client, resyncPeriod, cache.Indexers{}, tweakListOptions) + }) + + podInformer := sharedFactory.InformerFor(&corev1.Pod{}, + func(client clientset.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + tweakListOptions := func(options *metav1.ListOptions) { + options.FieldSelector = fields.OneTermEqualSelector(specNodeNameField, c.GenericConfiguration.KubeNodeName).String() + } + return coreinformers.NewFilteredPodInformer(client, metav1.NamespaceAll, resyncPeriod, cache.Indexers{}, tweakListOptions) + }) + + nodeLister := sharedFactory.Core().V1().Nodes().Lister() + podLister := sharedFactory.Core().V1().Pods().Lister() + c.GenericConfiguration.NodeLister = nodeLister + c.GenericConfiguration.PodLister = podLister + c.GenericConfiguration.NodeHasSynced = func() bool { + return nodeInformer.HasSynced() + } + c.GenericConfiguration.PodsHasSynced = func() bool { + return podInformer.HasSynced() + } + c.InformerFactory.K8SInformerFactory = sharedFactory +} + +func (c *Configuration) GetNode() (*corev1.Node, error) { + // if we have a valid kube client, we wait for initial lister to sync + if !c.GenericConfiguration.NodeHasSynced() { + node, err := c.GenericConfiguration.KubeClient.CoreV1().Nodes().Get(context.TODO(), c.GenericConfiguration.KubeNodeName, metav1.GetOptions{}) + if err != nil { + return nil, err + } + return node, nil + } + return c.GenericConfiguration.NodeLister.Get(c.GenericConfiguration.KubeNodeName) +} + +func (c *Configuration) IsFeatureSupported(name string) bool { + visitStar := false + for _, feature := range c.GenericConfiguration.SupportedFeatures { + switch feature { + case "-" + name: + return false + case name: + return true + case "*": + visitStar = true + } + } + return visitStar +} + +func (c *Configuration) GetActivePods() ([]*corev1.Pod, error) { + allPods := []*corev1.Pod{} + var err error + if !c.GenericConfiguration.PodsHasSynced() { + selector := fields.OneTermEqualSelector("spec.nodeName", c.GenericConfiguration.KubeNodeName) + pods, err := c.GenericConfiguration.KubeClient.CoreV1().Pods(corev1.NamespaceAll).List(context.TODO(), metav1.ListOptions{ + FieldSelector: selector.String(), + LabelSelector: labels.Everything().String(), + }) + if err != nil { + return nil, err + } + for i := range pods.Items { + allPods = append(allPods, &pods.Items[i]) + } + } else { + allPods, err = c.InformerFactory.K8SInformerFactory.Core().V1().Pods().Lister().List(labels.Everything()) + if err != nil { + return nil, err + } + } + + // Filter out terminated pods. + rPods := []*corev1.Pod{} + for i := range allPods { + if utilpod.IsPodTerminated(allPods[i]) { + continue + } + rPods = append(rPods, allPods[i]) + } + return rPods, nil +} diff --git a/pkg/config/config_test.go b/pkg/config/config_test.go new file mode 100644 index 000000000..a121875af --- /dev/null +++ b/pkg/config/config_test.go @@ -0,0 +1,91 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package config + +import ( + "testing" + "time" + + "github.com/stretchr/testify/assert" + v1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/client-go/informers" + fakeclientset "k8s.io/client-go/kubernetes/fake" +) + +func makePods() []*v1.Pod { + return []*v1.Pod{ + {ObjectMeta: metav1.ObjectMeta{Name: "test-1", Namespace: "default"}}, + {ObjectMeta: metav1.ObjectMeta{Name: "test-2", Namespace: "kube-system"}}, + {ObjectMeta: metav1.ObjectMeta{Name: "test-3", Namespace: "default"}, Status: v1.PodStatus{Phase: v1.PodSucceeded}}, + {ObjectMeta: metav1.ObjectMeta{Name: "test-4", Namespace: "kube-system"}, Status: v1.PodStatus{Phase: v1.PodFailed}}, + {ObjectMeta: metav1.ObjectMeta{Name: "test-5", Namespace: "kube-system", DeletionTimestamp: &metav1.Time{Time: time.Now()}}}, + } +} + +func TestConfiguration_GetActivePods(t *testing.T) { + informerFactory := informers.NewSharedInformerFactory(fakeclientset.NewSimpleClientset(), 0) + objs := []runtime.Object{} + for _, obj := range makePods() { + assert.NoError(t, informerFactory.Core().V1().Pods().Informer().GetStore().Add(obj)) + objs = append(objs, obj) + } + fakeClient := fakeclientset.NewSimpleClientset(objs...) + tests := []struct { + name string + GenericConfiguration *Configuration + InformerFactory *InformerFactory + want map[string]struct{} + wantErr bool + }{ + { + name: "pod informer not synced", + GenericConfiguration: &Configuration{ + GenericConfiguration: &VolcanoAgentConfiguration{ + KubeClient: fakeClient, + PodsHasSynced: func() bool { return false }}, + }, + want: map[string]struct{}{"test-1": {}, "test-2": {}}, + wantErr: false, + }, + { + name: "pod informer synced", + GenericConfiguration: &Configuration{ + GenericConfiguration: &VolcanoAgentConfiguration{ + PodsHasSynced: func() bool { return true }}, + InformerFactory: &InformerFactory{K8SInformerFactory: informerFactory}, + }, + want: map[string]struct{}{"test-1": {}, "test-2": {}}, + wantErr: false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := tt.GenericConfiguration.GetActivePods() + if (err != nil) != tt.wantErr { + t.Errorf("GetActivePods() error = %v, wantErr %v", err, tt.wantErr) + return + } + pods := make(map[string]struct{}) + for _, pod := range got { + pods[pod.Name] = struct{}{} + } + assert.Equalf(t, tt.want, pods, "GetActivePods()") + }) + } +} diff --git a/pkg/config/generic.go b/pkg/config/generic.go new file mode 100644 index 000000000..3259e2e79 --- /dev/null +++ b/pkg/config/generic.go @@ -0,0 +1,77 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package config + +import ( + clientset "k8s.io/client-go/kubernetes" + v1 "k8s.io/client-go/listers/core/v1" + "k8s.io/client-go/tools/cache" + "k8s.io/client-go/tools/record" +) + +type VolcanoAgentConfiguration struct { + // HealthzAddress is the health check server address + HealthzAddress string + + //HealthzPort is the health check server port + HealthzPort int + + // KubeCgroupRoot is the root cgroup to use for pods. + // same with kubelet configuration "cgroup-root" + KubeCgroupRoot string + + // KubeClient is the client to visit k8s + KubeClient clientset.Interface + + // KubeNodeName is the name of the node which pod is running. + KubeNodeName string + + // KubePodName is the name of the pod. + KubePodName string + + // KubePodName is the namespace of the pod. + KubePodNamespace string + + // NodeLister list current node. + NodeLister v1.NodeLister + + // PodLister list pods belong to current node. + PodLister v1.PodLister + + // NodeHasSynced indicates whether nodes have been sync'd at least once. + // Check this before trusting a response from the node lister. + NodeHasSynced cache.InformerSynced + + // PodsHasSynced indicates whether pods have been sync'd at least once. + // Check this before trusting a response from the pod lister. + PodsHasSynced cache.InformerSynced + + // EventRecorder is the event sink + Recorder record.EventRecorder + + // List of supported features, '*' supports all on-by-default features. + SupportedFeatures []string + + // OverSubscriptionPolicy defines overSubscription policy. + OverSubscriptionPolicy string + + // OverSubscriptionRatio is the over subscription ratio of idle resources, default to 60, which means 60%. + OverSubscriptionRatio int + + // IncludeSystemUsage determines whether considering system usage when calculate overSubscription resource and evict. + IncludeSystemUsage bool +} diff --git a/pkg/config/informerfactory.go b/pkg/config/informerfactory.go new file mode 100644 index 000000000..055b0d458 --- /dev/null +++ b/pkg/config/informerfactory.go @@ -0,0 +1,26 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package config + +import ( + "k8s.io/client-go/informers" +) + +type InformerFactory struct { + // K8SInformerFactory gives access to informers of k8s core resource for the controller. + K8SInformerFactory informers.SharedInformerFactory +} diff --git a/pkg/metriccollect/collectmgr.go b/pkg/metriccollect/collectmgr.go new file mode 100644 index 000000000..804f4b598 --- /dev/null +++ b/pkg/metriccollect/collectmgr.go @@ -0,0 +1,58 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package metriccollect + +import ( + "fmt" + + "volcano.sh/volcano/pkg/agent/utils/cgroup" + "volcano.sh/volcano/pkg/config" + "volcano.sh/volcano/pkg/metriccollect/framework" + _ "volcano.sh/volcano/pkg/metriccollect/local" +) + +type MetricCollectorManager struct { + plugins map[string]framework.MetricCollect + cgroupManager cgroup.CgroupManager + Config *config.Configuration +} + +func NewMetricCollectorManager(config *config.Configuration, cgroupManager cgroup.CgroupManager) (*MetricCollectorManager, error) { + mgr := &MetricCollectorManager{ + plugins: make(map[string]framework.MetricCollect), + cgroupManager: cgroupManager, + Config: config, + } + + for _, pluginFunc := range framework.GetMetricCollectFunc() { + plugin := pluginFunc(config, cgroupManager) + pluginName := plugin.MetricCollectorName() + if err := plugin.Run(); err != nil { + return nil, err + } + mgr.plugins[pluginName] = plugin + } + + return mgr, nil +} + +func (cm *MetricCollectorManager) GetPluginByName(name string) (collector framework.MetricCollect, err error) { + if plugin, ok := cm.plugins[name]; ok { + return plugin, nil + } + return nil, fmt.Errorf("unsupported metric collector plugin %s", name) +} diff --git a/pkg/metriccollect/framework/interface.go b/pkg/metriccollect/framework/interface.go new file mode 100644 index 000000000..02bacc926 --- /dev/null +++ b/pkg/metriccollect/framework/interface.go @@ -0,0 +1,36 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package framework + +import ( + "time" + + "github.com/prometheus/prometheus/prompb" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) + +type MetricCollect interface { + // MetricCollectorName returns the name of metric collector + MetricCollectorName() string + + // Run starts/initializes the metric collector + Run() error + + // CollectMetrics collects metrics from collector. + // If window == 0, return the latest data, otherwise return the time series data + CollectMetrics(metricInfo interface{}, start time.Time, window metav1.Duration) ([]*prompb.TimeSeries, error) +} diff --git a/pkg/metriccollect/framework/registry.go b/pkg/metriccollect/framework/registry.go new file mode 100644 index 000000000..3063b20ed --- /dev/null +++ b/pkg/metriccollect/framework/registry.go @@ -0,0 +1,39 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package framework + +import ( + "sync" + + "volcano.sh/volcano/pkg/agent/utils/cgroup" + "volcano.sh/volcano/pkg/config" +) + +var metricCollectorFuncs = []NewMetricCollectFunc{} +var mutex sync.Mutex + +type NewMetricCollectFunc = func(config *config.Configuration, cgroupManager cgroup.CgroupManager) MetricCollect + +func RegisterMetricCollectFunc(f NewMetricCollectFunc) { + mutex.Lock() + defer mutex.Unlock() + metricCollectorFuncs = append(metricCollectorFuncs, f) +} + +func GetMetricCollectFunc() []NewMetricCollectFunc { + return metricCollectorFuncs +} diff --git a/pkg/metriccollect/local/cpu.go b/pkg/metriccollect/local/cpu.go new file mode 100644 index 000000000..05dd73179 --- /dev/null +++ b/pkg/metriccollect/local/cpu.go @@ -0,0 +1,176 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package local + +import ( + "fmt" + "os" + "path/filepath" + "strconv" + "strings" + "time" + + "github.com/prometheus/prometheus/model/timestamp" + "github.com/prometheus/prometheus/prompb" + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/klog/v2" + + "volcano.sh/volcano/pkg/agent/utils/cgroup" + "volcano.sh/volcano/pkg/agent/utils/file" +) + +const ( + defaultProcPath = "/host/proc/stat" + procStatPathEnv = "PROC_STAT_PATH" + + // jiffies is the kernel tick unit. + jiffies = float64(10 * time.Millisecond) +) + +type CPUResourceCollector struct { + cgroupManager cgroup.CgroupManager +} + +func NewCPUResourceCollector(cgroupManager cgroup.CgroupManager) (SubCollector, error) { + return &CPUResourceCollector{ + cgroupManager: cgroupManager, + }, nil +} + +func (c *CPUResourceCollector) Run() {} + +func (c *CPUResourceCollector) CollectLocalMetrics(metricInfo *LocalMetricInfo, start time.Time, window metav1.Duration) ([]*prompb.TimeSeries, error) { + cgroupPath, err := c.cgroupManager.GetRootCgroupPath(cgroup.CgroupCpuSubsystem) + if err != nil { + return nil, err + } + + podAllUsage, err := getMilliCPUUsage(cgroupPath) + if err != nil { + return nil, err + } + + finalUsage := int64(0) + if !metricInfo.IncludeGuaranteedPods { + for _, qos := range []corev1.PodQOSClass{corev1.PodQOSBurstable, corev1.PodQOSBestEffort} { + cgroupPath, err = c.cgroupManager.GetQoSCgroupPath(qos, cgroup.CgroupCpuSubsystem) + if err != nil { + return nil, err + } + + count, err := getMilliCPUUsage(cgroupPath) + if err != nil { + return nil, err + } + finalUsage += count + } + } else { + finalUsage = podAllUsage + } + + if metricInfo.IncludeSystemUsed { + nodeUsage, err := nodeCPUUsage() + if err != nil { + return nil, fmt.Errorf("failed to get node usage, err: %v", err) + } + systemUsage := nodeUsage - podAllUsage + finalUsage += systemUsage + } + sample := prompb.TimeSeries{ + Samples: []prompb.Sample{ + { + Timestamp: timestamp.FromTime(time.Now()), + Value: float64(finalUsage), + }, + }, + } + return []*prompb.TimeSeries{&sample}, nil +} + +func getMilliCPUUsage(cgroupRoot string) (int64, error) { + startTime := time.Now().UnixNano() + cgroupsCPU := filepath.Join(cgroupRoot, cgroup.CPUUsageFile) + startUsage, err := file.ReadIntFromFile(cgroupsCPU) + if err != nil { + return 0, err + } + time.Sleep(1 * time.Second) + endTime := time.Now().UnixNano() + endUsage, err := file.ReadIntFromFile(cgroupsCPU) + if err != nil { + return 0, err + } + if endTime-startTime == 0 { + return 0, fmt.Errorf("statistic time is zero") + } + return (endUsage - startUsage) * 1000 / (endTime - startTime), nil +} + +func nodeCPUState() (uint64, error) { + procStatFile := os.Getenv(procStatPathEnv) + if procStatFile == "" { + procStatFile = defaultProcPath + } + contents, err := os.ReadFile(procStatFile) + if err != nil { + return 0, fmt.Errorf("failed to read proc state file: %v", err) + } + for _, line := range strings.Split(string(contents), "\n") { + fields := strings.Fields(line) + if len(fields) == 0 || fields[0] != "cpu" { + continue + } + total := uint64(0) + // sum cpu time = $user+$nice+$system+$idle+$iowait+$irq+$softirq + for i := 1; i < len(fields); i++ { + val, err := strconv.ParseUint(fields[i], 10, 64) + if err != nil { + return 0, fmt.Errorf("failed to parse state filed: %v, err: %v", fields[i], err) + } + // exclude $idle $iowait time. + if i == 4 || i == 5 { + continue + } + total += val + } + return total, nil + } + return 0, fmt.Errorf("invalid proc stat file: %s", procStatFile) +} + +func nodeCPUUsage() (int64, error) { + startTime := time.Now().UnixNano() + total0, err := nodeCPUState() + if err != nil { + return 0, err + } + time.Sleep(time.Second) + endTime := time.Now().UnixNano() + total1, err := nodeCPUState() + if err != nil { + return 0, err + } + + totalTicks := float64(total1 - total0) + if totalTicks <= 0 { + return 0, fmt.Errorf("negative total tick: %v", totalTicks) + } + cpuUsage := int64((totalTicks / (float64(endTime-startTime) / jiffies)) * 1000) + klog.V(4).InfoS("Node cpu usage", "value", cpuUsage) + return cpuUsage, nil +} diff --git a/pkg/metriccollect/local/local_collector.go b/pkg/metriccollect/local/local_collector.go new file mode 100644 index 000000000..32f1825b1 --- /dev/null +++ b/pkg/metriccollect/local/local_collector.go @@ -0,0 +1,101 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package local + +import ( + "fmt" + "time" + + "github.com/prometheus/prometheus/prompb" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/klog/v2" + + "volcano.sh/volcano/pkg/agent/utils/cgroup" + "volcano.sh/volcano/pkg/config" + "volcano.sh/volcano/pkg/metriccollect/framework" +) + +const CollectorName = "LocalCollector" + +type LocalMetricInfo struct { + ResourceType string + IncludeGuaranteedPods bool + IncludeSystemUsed bool +} + +type SubCollector interface { + // Run runs sub collector + Run() + // CollectLocalMetrics returns local metric from sub collector + CollectLocalMetrics(metricInfo *LocalMetricInfo, start time.Time, window metav1.Duration) ([]*prompb.TimeSeries, error) +} + +func getSubLocalCollectors() map[string]func(cgroupManager cgroup.CgroupManager) (SubCollector, error) { + initiatedCollectorFuncs := make(map[string]func(cgroupManager cgroup.CgroupManager) (SubCollector, error)) + initiatedCollectorFuncs["cpu"] = NewCPUResourceCollector + initiatedCollectorFuncs["memory"] = NewMemoryResourceCollector + return initiatedCollectorFuncs +} + +func init() { + framework.RegisterMetricCollectFunc(NewLocalCollector) +} + +type LocalCollector struct { + CgroupManager cgroup.CgroupManager + InitiatedSubCollectors map[string]SubCollector +} + +func NewLocalCollector(config *config.Configuration, cgroupManager cgroup.CgroupManager) framework.MetricCollect { + return &LocalCollector{ + CgroupManager: cgroupManager, + } +} + +func (c *LocalCollector) MetricCollectorName() string { + return CollectorName +} + +func (c *LocalCollector) Run() error { + if c.InitiatedSubCollectors == nil { + c.InitiatedSubCollectors = make(map[string]SubCollector) + } + for collectorName, collectorFunc := range getSubLocalCollectors() { + klog.InfoS("Init local sub collector", "collectorName", collectorName) + if collector, err := collectorFunc(c.CgroupManager); err != nil { + return err + } else { + c.InitiatedSubCollectors[collectorName] = collector + collector.Run() + } + } + return nil +} + +func (c *LocalCollector) CollectMetrics(metricInfo interface{}, start time.Time, window metav1.Duration) ([]*prompb.TimeSeries, error) { + metric, ok := metricInfo.(*LocalMetricInfo) + if !ok { + return nil, fmt.Errorf("metricInfo phase invoked with an invalid data struct %s", metricInfo) + } + + subCollector, ok := c.InitiatedSubCollectors[metric.ResourceType] + if !ok { + return nil, fmt.Errorf("unsupported local sub collector %s", metric.ResourceType) + } + + return subCollector.CollectLocalMetrics(metric, start, window) +} diff --git a/pkg/metriccollect/local/memory.go b/pkg/metriccollect/local/memory.go new file mode 100644 index 000000000..95a37ccdb --- /dev/null +++ b/pkg/metriccollect/local/memory.go @@ -0,0 +1,152 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package local + +import ( + "fmt" + "io/ioutil" + "os" + "path/filepath" + "strconv" + "strings" + "time" + + "github.com/prometheus/prometheus/model/timestamp" + "github.com/prometheus/prometheus/prompb" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/klog/v2" + + "volcano.sh/volcano/pkg/agent/utils/cgroup" +) + +var memoryStatMetrics = map[string]bool{ + "total_cache": true, + "total_rss": true, + "total_swap": true, +} + +const ( + defaultMemInfoPath = "/host/proc/meminfo" + memInfoPathEnv = "MEM_INFO_PATH_ENV" +) + +type MemoryResourceCollector struct { + cgroupManager cgroup.CgroupManager +} + +func NewMemoryResourceCollector(cgroupManager cgroup.CgroupManager) (SubCollector, error) { + return &MemoryResourceCollector{ + cgroupManager: cgroupManager, + }, nil +} + +func (c *MemoryResourceCollector) Run() {} + +func (c *MemoryResourceCollector) CollectLocalMetrics(metricInfo *LocalMetricInfo, start time.Time, window metav1.Duration) ([]*prompb.TimeSeries, error) { + var ( + count int64 + err error + ) + cgroupPath, err := c.cgroupManager.GetRootCgroupPath(cgroup.CgroupMemorySubsystem) + if err != nil { + return nil, err + } + + count, err = getMemoryUsage(cgroupPath) + if err != nil { + return nil, err + } + + if metricInfo.IncludeSystemUsed { + count, err = nodeMemoryUsage() + if err != nil { + return nil, err + } + } + sample := prompb.TimeSeries{ + Samples: []prompb.Sample{ + { + Timestamp: timestamp.FromTime(time.Now()), + Value: float64(count), + }, + }, + } + return []*prompb.TimeSeries{&sample}, nil +} + +func getMemoryUsage(cgroupRoot string) (int64, error) { + usage := int64(0) + cgroupMemory := filepath.Join(cgroupRoot, cgroup.MemoryUsageFile) + date, err := ioutil.ReadFile(cgroupMemory) + if err != nil { + return 0, err + } + lines := strings.Split(string(date), "\n") + for _, line := range lines { + slices := strings.Split(line, " ") + if len(slices) != 2 { + continue + } + + if memoryStatMetrics[slices[0]] { + value, err := strconv.Atoi(slices[1]) + if err != nil { + continue + } + + usage = usage + int64(value) + } + } + return usage, nil +} + +func nodeMemoryUsage() (int64, error) { + memInfoFile := os.Getenv(memInfoPathEnv) + if memInfoFile == "" { + memInfoFile = defaultMemInfoPath + } + content, err := os.ReadFile(memInfoFile) + if err != nil { + return 0, fmt.Errorf("failed to read mem info, err: %v", err) + } + + total, available := int64(0), int64(0) + for _, line := range strings.Split(string(content), "\n") { + fields := strings.SplitN(line, ":", 2) + if len(fields) < 2 { + continue + } + if fields[0] == "MemTotal" { + total, err = strconv.ParseInt(strings.Fields(fields[1])[0], 10, 64) + if err != nil { + return 0, fmt.Errorf("failed to get mem total, err: %v", err) + } + } + if fields[0] == "MemAvailable" { + available, err = strconv.ParseInt(strings.Fields(fields[1])[0], 10, 64) + if err != nil { + return 0, fmt.Errorf("failed to get mem available, err: %v", err) + } + break + } + } + + // mem info unit KB. + systemUsed := (total - available) * 1024 + klog.V(4).InfoS("System used memory", "value", systemUsed) + return systemUsed, nil +} diff --git a/pkg/metriccollect/testing/fake_local_collector.go b/pkg/metriccollect/testing/fake_local_collector.go new file mode 100644 index 000000000..8538d2f9a --- /dev/null +++ b/pkg/metriccollect/testing/fake_local_collector.go @@ -0,0 +1,72 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package testing + +import ( + "fmt" + "time" + + "github.com/prometheus/prometheus/prompb" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + + "volcano.sh/volcano/pkg/agent/utils/cgroup" + "volcano.sh/volcano/pkg/config" + "volcano.sh/volcano/pkg/metriccollect/framework" + "volcano.sh/volcano/pkg/metriccollect/local" +) + +const CollectorName = "FakeLocalCollector" + +func init() { + framework.RegisterMetricCollectFunc(NewFakeLocalCollector) +} + +type FakeLocalCollector struct { + CgroupManager cgroup.CgroupManager + InitiatedSubCollectors map[string]local.SubCollector +} + +func NewFakeLocalCollector(config *config.Configuration, cgroupManager cgroup.CgroupManager) framework.MetricCollect { + return &FakeLocalCollector{ + CgroupManager: cgroupManager, + InitiatedSubCollectors: map[string]local.SubCollector{ + "cpu": &FakeSubCollectorCPU{}, + "memory": &FakeSubCollectorMemory{}, + }, + } +} +func (f *FakeLocalCollector) Run() error { + return nil +} + +func (f *FakeLocalCollector) MetricCollectorName() string { + return CollectorName +} + +func (f *FakeLocalCollector) CollectMetrics(metricInfo interface{}, start time.Time, window metav1.Duration) ([]*prompb.TimeSeries, error) { + metric, ok := metricInfo.(*local.LocalMetricInfo) + if !ok { + return nil, fmt.Errorf("metricInfo phase invoked with an invalid data struct %s", metricInfo) + } + + subCollector, ok := f.InitiatedSubCollectors[metric.ResourceType] + if !ok { + return nil, fmt.Errorf("unsupported local sub collector %s", metric.ResourceType) + } + + return subCollector.CollectLocalMetrics(metric, start, window) +} diff --git a/pkg/metriccollect/testing/fake_sub_collector_cpu.go b/pkg/metriccollect/testing/fake_sub_collector_cpu.go new file mode 100644 index 000000000..d0c7f6de8 --- /dev/null +++ b/pkg/metriccollect/testing/fake_sub_collector_cpu.go @@ -0,0 +1,47 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package testing + +import ( + "time" + + "github.com/prometheus/prometheus/model/timestamp" + "github.com/prometheus/prometheus/prompb" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + + "volcano.sh/volcano/pkg/metriccollect/local" +) + +type FakeSubCollectorCPU struct { +} + +func (s *FakeSubCollectorCPU) Run() { + +} + +func (s *FakeSubCollectorCPU) CollectLocalMetrics(metricInfo *local.LocalMetricInfo, start time.Time, window metav1.Duration) ([]*prompb.TimeSeries, error) { + return []*prompb.TimeSeries{ + { + Samples: []prompb.Sample{ + { + Timestamp: timestamp.FromTime(time.Now()), + Value: 1000, + }, + }, + }, + }, nil +} diff --git a/pkg/metriccollect/testing/fake_sub_collector_memory.go b/pkg/metriccollect/testing/fake_sub_collector_memory.go new file mode 100644 index 000000000..9b6206a49 --- /dev/null +++ b/pkg/metriccollect/testing/fake_sub_collector_memory.go @@ -0,0 +1,47 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package testing + +import ( + "time" + + "github.com/prometheus/prometheus/model/timestamp" + "github.com/prometheus/prometheus/prompb" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + + "volcano.sh/volcano/pkg/metriccollect/local" +) + +type FakeSubCollectorMemory struct { +} + +func (s *FakeSubCollectorMemory) Run() { + +} + +func (s *FakeSubCollectorMemory) CollectLocalMetrics(metricInfo *local.LocalMetricInfo, start time.Time, window metav1.Duration) ([]*prompb.TimeSeries, error) { + return []*prompb.TimeSeries{ + { + Samples: []prompb.Sample{ + { + Timestamp: timestamp.FromTime(time.Now()), + Value: 2000, + }, + }, + }, + }, nil +} diff --git a/pkg/networkqos/api/cni.go b/pkg/networkqos/api/cni.go new file mode 100644 index 000000000..bc9cac210 --- /dev/null +++ b/pkg/networkqos/api/cni.go @@ -0,0 +1,57 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package api + +import ( + "net" + + "github.com/containernetworking/cni/pkg/types" +) + +// K8sArgs is the valid CNI_ARGS used for Kubernetes +type K8sArgs struct { + types.CommonArgs + + // IP is pod's ip address + IP net.IP + + // K8S_POD_NAME is pod's name + K8S_POD_NAME types.UnmarshallableString + + // K8S_POD_NAMESPACE is pod's namespace + K8S_POD_NAMESPACE types.UnmarshallableString + + // K8S_POD_INFRA_CONTAINER_ID is pod's container id + K8S_POD_INFRA_CONTAINER_ID types.UnmarshallableString + + // internal + // K8S_POD_UID is pod's UID + K8S_POD_UID types.UnmarshallableString + + // K8S_POD_RUNTIME is pod's runtime type + K8S_POD_RUNTIME types.UnmarshallableString + + // SECURE_CONTAINER is pod's runtime type + // Deprecated: Use K8S_POD_RUNTIME instead + SECURE_CONTAINER types.UnmarshallableString +} + +// NetConf for cni config file written in json +type NetConf struct { + types.NetConf `json:",inline"` + Args map[string]string `json:"args,omitempty"` +} diff --git a/pkg/networkqos/api/ebpf_map.go b/pkg/networkqos/api/ebpf_map.go new file mode 100644 index 000000000..e0061506e --- /dev/null +++ b/pkg/networkqos/api/ebpf_map.go @@ -0,0 +1,72 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package api + +type EbpfNetThrottlingConfGetResult struct { + WaterLine string `json:"online_bandwidth_watermark"` + Interval uint64 `json:"interval"` + LowRate string `json:"offline_low_bandwidth"` + HighRate string `json:"offline_high_bandwidth"` +} + +type EbpfNetThrottlingConfig struct { + // WaterLine is the bandwidth threshold of online jobs, is the sum of bandwidth of all online pods + // If the bandwidth usage of the online jobs exceeds this value, + // the total network bandwidth usage of offline jobs will not exceed the value defined by LowRate. + // Otherwise, the total bandwidth usage of offline jobs will not be allowed to exceed the value defined by HighRate. + WaterLine uint64 `json:"online_bandwidth_watermark"` + // Interval is the check period of statistical network bandwidth usage + Interval uint64 `json:"interval"` + // LowRate is the maximum amount of network bandwidth that can be used by offline jobs when the + // bandwidth usage of online jobs exceeds the defined threshold(waterline) + LowRate uint64 `json:"offline_low_bandwidth"` + // HighRate is the maximum amount of network bandwidth that can be used by offline jobs when the + // bandwidth usage of online jobs not reach to the defined threshold(waterline) + HighRate uint64 `json:"offline_high_bandwidth"` +} + +type EbpfNetThrottlingStatus struct { + // CheckTimes is the total number of times the checking occurred + CheckTimes uint64 `json:"check_times"` + // HighTimes is the total number of checking times that the bandwidth usage of online jobs exceeds the threshold + HighTimes uint64 `json:"high_times"` + // LowTimes is the total number of checking times that the bandwidth usage of online jobs not reach to the threshold + LowTimes uint64 `json:"low_times"` + // OnlinePKTs is the total number of bytes in the network packet for online jobs + OnlinePKTs uint64 `json:"online_tx_packages"` + // OfflinePKTs is the total number of bytes in the network packet for offline jobs + OfflinePKTs uint64 `json:"offline_tx_packages"` + OfflinePrio uint64 `json:"offline_prio"` + // RatePast is the network bandwidth of offline jobs in the latest check + RatePast uint64 `json:"latest_online_bandwidth"` + // OfflineRatePast is the network bandwidth of online jobs in the latest check + OfflineRatePast uint64 `json:"latest_offline_bandwidth"` +} + +type EbpfNetThrottling struct { + // TLast is the latest time an offline job's network packet is issued + TLast uint64 `json:"latest_offline_packet_send_time"` + // Rate is the maximum amount of network bandwidth that can be used by offline jobs + Rate uint64 `json:"offline_bandwidth_limit"` + // TXBytes is the total number of bytes of network packets of offline jobs + TXBytes uint64 `json:"offline_tx_bytes"` + // OnlineTXBytes is the total number of bytes of network packets of online jobs + OnlineTXBytes uint64 `json:"online_tx_bytes"` + // TStart is the last check time + TStart uint64 `json:"latest_check_time"` + EbpfNetThrottlingStatus +} diff --git a/pkg/networkqos/cni/config.go b/pkg/networkqos/cni/config.go new file mode 100644 index 000000000..6b58d5e5f --- /dev/null +++ b/pkg/networkqos/cni/config.go @@ -0,0 +1,158 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package cni + +import ( + "encoding/json" + "fmt" + "os" + + "k8s.io/klog/v2" +) + +//go:generate mockgen -destination ./mocks/mock_config.go -package mocks -source config.go + +type CNIPluginsConfHandler interface { + // AddOrUpdateCniPluginToConfList adds new cni conf to the file(cni.conflist) + // If the cni plugin existed, update the configuration + AddOrUpdateCniPluginToConfList(configPath, name string, plugin map[string]interface{}) (err error) + // DeleteCniPluginFromConfList removes cni conf to the file(cni.conflist) + DeleteCniPluginFromConfList(configPath, name string) (err error) +} + +type ConfHandler struct{} + +var _ CNIPluginsConfHandler = &ConfHandler{} + +var confHandler CNIPluginsConfHandler + +func GetCNIPluginConfHandler() CNIPluginsConfHandler { + if confHandler == nil { + confHandler = &ConfHandler{} + } + return confHandler +} + +func SetCNIPluginConfHandler(c CNIPluginsConfHandler) { + confHandler = c +} + +func (p *ConfHandler) AddOrUpdateCniPluginToConfList(configPath, name string, plugin map[string]interface{}) (err error) { + content, err := os.ReadFile(configPath) + if err != nil { + return err + } + var list map[string]interface{} + err = json.Unmarshal(content, &list) + if err != nil { + return err + } + + klog.InfoS("Add/Update cni plugin", "cni-conf", string(content)) + plugins, ok := list["plugins"].([]interface{}) + if !ok { + return fmt.Errorf("failed to get plugins from file") + } + + var index int + var existedPlugin map[string]interface{} + for index = 0; index < len(plugins); index++ { + existedPlugin, ok = plugins[index].(map[string]interface{}) + if !ok { + return fmt.Errorf("failed to get cni from cni conflist") + } + + pluginName, ok := existedPlugin["name"] + if !ok { + continue + } + + pluginNameInStr, ok := pluginName.(string) + if !ok { + continue + } + + if pluginNameInStr == name { + break + } + } + + if index >= len(plugins) { + plugins = append(plugins, plugin) + } else { + plugins[index] = plugin + } + + list["plugins"] = plugins + + newCniConf, err := json.MarshalIndent(list, "", " ") + if err != nil { + return err + } + err = os.WriteFile(configPath, newCniConf, 0750) + klog.InfoS("Add/Update cni plugin successfully", "cni-conf", string(newCniConf)) + return err +} + +func (p *ConfHandler) DeleteCniPluginFromConfList(configPath, name string) (err error) { + content, err := os.ReadFile(configPath) + if err != nil { + return err + } + var list map[string]interface{} + err = json.Unmarshal(content, &list) + if err != nil { + return err + } + + klog.InfoS("Delete cni plugin", "cni-conf", string(content)) + plugins, ok := list["plugins"].([]interface{}) + if !ok { + return fmt.Errorf("failed to get plugins from file") + } + + var index int + for index = 0; index < len(plugins); index++ { + pl, ok := plugins[index].(map[string]interface{}) + if !ok { + return fmt.Errorf("failed to get cni from cni conflist") + } + pluginName, ok := pl["name"].(string) + if !ok { + continue + } + + if pluginName == name { + break + } + } + + if index >= len(plugins) { + return + } + plugins = append(plugins[:index], plugins[index+1:]...) + + list["plugins"] = plugins + + newCniConf, err := json.MarshalIndent(list, "", " ") + if err != nil { + return err + } + err = os.WriteFile(configPath, newCniConf, 0750) + klog.InfoS("Delete cni plugin successfully", "cni-conf", string(newCniConf)) + return err +} diff --git a/pkg/networkqos/cni/config_test.go b/pkg/networkqos/cni/config_test.go new file mode 100644 index 000000000..4a66fb848 --- /dev/null +++ b/pkg/networkqos/cni/config_test.go @@ -0,0 +1,465 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package cni + +import ( + "encoding/json" + "fmt" + "os" + "path/filepath" + "testing" + + "github.com/agiledragon/gomonkey/v2" + "github.com/stretchr/testify/assert" + + "volcano.sh/volcano/pkg/networkqos/utils" +) + +var fileWithoutNetworkQoS = `{ + "cniVersion": "0.3.1", + "name": "default-network", + "plugins": [ + { + "args": { + "phynet": "phy_net1", + "secret_name": "canal-secret", + "tenant_id": "", + "vpc_id": "00a6a77c-83c8-405f-b7e8-d8648adfafa7" + }, + "capabilities": { + "bandwidth": true + }, + "ipam": { + "subnet": "172.16.0.0/16" + }, + "name": "default-network", + "type": "vpc-router" + }, + { + "capabilities": { + "portMappings": true + }, + "externalSetMarkChain": "KUBE-MARK-MASQ", + "type": "portmap" + } + ] +}` + +var fileWithNetworkQoS = `{ + "cniVersion": "0.3.1", + "name": "default-network", + "plugins": [ + { + "args": { + "phynet": "phy_net1", + "secret_name": "canal-secret", + "tenant_id": "", + "vpc_id": "00a6a77c-83c8-405f-b7e8-d8648adfafa7" + }, + "capabilities": { + "bandwidth": true + }, + "ipam": { + "subnet": "172.16.0.0/16" + }, + "name": "default-network", + "type": "vpc-router" + }, + { + "capabilities": { + "portMappings": true + }, + "externalSetMarkChain": "KUBE-MARK-MASQ", + "type": "portmap" + }, + { + "args": { + "colocation": "true", + "offline-high-bandwidth": "50MB", + "offline-low-bandwidth": "20MB", + "online-bandwidth-watermark": "50MB" + }, + "name": "network-qos", + "type": "network-qos" + } + ] +}` + +var fileWithNewNetworkQoS = `{ + "cniVersion": "0.3.1", + "name": "default-network", + "plugins": [ + { + "args": { + "phynet": "phy_net1", + "secret_name": "canal-secret", + "tenant_id": "", + "vpc_id": "00a6a77c-83c8-405f-b7e8-d8648adfafa7" + }, + "capabilities": { + "bandwidth": true + }, + "ipam": { + "subnet": "172.16.0.0/16" + }, + "name": "default-network", + "type": "vpc-router" + }, + { + "capabilities": { + "portMappings": true + }, + "externalSetMarkChain": "KUBE-MARK-MASQ", + "type": "portmap" + }, + { + "args": { + "colocation": "true", + "offline-high-bandwidth": "100MB", + "offline-low-bandwidth": "20MB", + "online-bandwidth-watermark": "100MB" + }, + "name": "network-qos", + "type": "network-qos" + } + ] +}` + +var fileWithoutPlugins = `{ + "cniVersion": "0.3.1", + "name": "default-network" +}` + +var fileWithIllegalJson = `{ + "cniVersion": "0.3.1", + "name": "default-network", + "plugins": [ + { + "args": { + "phynet": "phy_net1", + "secret_name": "canal-secret", + "tenant_id": "", + "vpc_id": "00a6a77c-83c8-405f-b7e8-d8648adfafa7" + }, + "capabilities": { + "bandwidth": true + }, + "ipam": { + "subnet": "172.16.0.0/16" + }, + "name": "default-network", + "type": "vpc-router" + },,,, + ] +}` + +func TestAddOrUpdateCniPluginToConfList(t *testing.T) { + testCases := []struct { + name string + plugin map[string]interface{} + fileContent string + jsonMarshalErr error + jsonMarshalIndentErr error + expectedFileContent string + expectedError bool + }{ + + { + name: "cni-plugin-add", + plugin: map[string]interface{}{ + "name": "network-qos", + "type": "network-qos", + "args": map[string]string{ + utils.NodeColocationEnable: "true", + utils.OnlineBandwidthWatermarkKey: "50MB", + utils.OfflineLowBandwidthKey: "20MB", + utils.OfflineHighBandwidthKey: "50MB", + }, + }, + fileContent: fileWithoutNetworkQoS, + expectedFileContent: fileWithNetworkQoS, + expectedError: false, + }, + + { + name: "cni-plugin-update", + plugin: map[string]interface{}{ + "name": "network-qos", + "type": "network-qos", + "args": map[string]string{ + utils.NodeColocationEnable: "true", + utils.OnlineBandwidthWatermarkKey: "100MB", + utils.OfflineLowBandwidthKey: "20MB", + utils.OfflineHighBandwidthKey: "100MB", + }, + }, + fileContent: fileWithNetworkQoS, + expectedFileContent: fileWithNewNetworkQoS, + expectedError: false, + }, + + { + name: "empty-cni-config", + plugin: map[string]interface{}{ + "name": "network-qos", + "type": "network-qos", + "args": map[string]string{ + utils.NodeColocationEnable: "true", + utils.OnlineBandwidthWatermarkKey: "500MB", + utils.OfflineLowBandwidthKey: "200MB", + utils.OfflineHighBandwidthKey: "300MB", + }, + }, + fileContent: "", + expectedFileContent: "", + expectedError: true, + }, + + { + name: "cni-config-without-plugins", + plugin: map[string]interface{}{ + "name": "network-qos", + "type": "network-qos", + "args": map[string]string{ + utils.NodeColocationEnable: "true", + utils.OnlineBandwidthWatermarkKey: "1000MB", + utils.OfflineLowBandwidthKey: "300MB", + utils.OfflineHighBandwidthKey: "500MB", + }, + }, + fileContent: fileWithoutPlugins, + expectedFileContent: "", + expectedError: true, + }, + + { + name: "cni-config-with-illegal-json", + plugin: map[string]interface{}{ + "name": "network-qos", + "type": "network-qos", + "args": map[string]string{ + utils.NodeColocationEnable: "true", + utils.OnlineBandwidthWatermarkKey: "2500MB", + utils.OfflineLowBandwidthKey: "500MB", + utils.OfflineHighBandwidthKey: "800MB", + }, + }, + fileContent: fileWithIllegalJson, + expectedFileContent: "", + expectedError: true, + }, + + { + name: "json Marshal failed", + plugin: map[string]interface{}{ + "name": "network-qos", + "type": "network-qos", + "args": map[string]string{ + utils.NodeColocationEnable: "true", + utils.OnlineBandwidthWatermarkKey: "1200MB", + utils.OfflineLowBandwidthKey: "260MB", + utils.OfflineHighBandwidthKey: "560MB", + }, + }, + fileContent: fileWithoutNetworkQoS, + jsonMarshalErr: fmt.Errorf("json Marshal failed"), + expectedFileContent: "", + expectedError: true, + }, + + { + name: "json MarshalIndent failed", + plugin: map[string]interface{}{ + "name": "network-qos", + "type": "network-qos", + "args": map[string]string{ + utils.NodeColocationEnable: "true", + utils.OnlineBandwidthWatermarkKey: "1050MB", + utils.OfflineLowBandwidthKey: "320MB", + utils.OfflineHighBandwidthKey: "650MB", + }, + }, + fileContent: fileWithoutNetworkQoS, + jsonMarshalIndentErr: fmt.Errorf("json MarshalIndent failed"), + expectedFileContent: "", + expectedError: true, + }, + } + + tmp, err := os.MkdirTemp("", "test-cni") + if err != nil { + t.Fatal(err) + } + defer os.Remove(tmp) + + conflistFile := filepath.Join(tmp, "cni.conflist") + defer os.Remove(conflistFile) + + for _, tc := range testCases { + if err = os.WriteFile(conflistFile, []byte(tc.fileContent), os.FileMode(0644)); err != nil { + t.Fatal(err) + } + + var jsonMarshalPatch, jsonMarshalIndentPatch *gomonkey.Patches + if tc.jsonMarshalErr != nil { + jsonMarshalPatch = gomonkey.NewPatches() + jsonMarshalPatch.ApplyFunc(json.Marshal, func(v interface{}) ([]byte, error) { + return nil, tc.jsonMarshalErr + }) + } + + if tc.jsonMarshalIndentErr != nil { + jsonMarshalIndentPatch = gomonkey.NewPatches() + jsonMarshalIndentPatch.ApplyFunc(json.Marshal, func(v interface{}) ([]byte, error) { + return nil, tc.jsonMarshalErr + }) + } + + actualErr := GetCNIPluginConfHandler().AddOrUpdateCniPluginToConfList(conflistFile, "network-qos", tc.plugin) + + if jsonMarshalPatch != nil { + jsonMarshalPatch.Reset() + } + + if jsonMarshalIndentPatch != nil { + jsonMarshalIndentPatch.Reset() + } + + assert.Equal(t, tc.expectedError, actualErr != nil, tc.name) + + if actualErr != nil { + continue + } + + actualFileContent, err := os.ReadFile(conflistFile) + if err != nil { + t.Fatal(err) + } + + assert.Equal(t, tc.expectedFileContent, string(actualFileContent), tc.name) + } +} + +func TestDeleteCniPluginFromConfList(t *testing.T) { + testCases := []struct { + name string + fileContent string + jsonMarshalErr error + jsonMarshalIndentErr error + expectedFileContent string + expectedError bool + }{ + { + name: "cni-plugin-delete", + fileContent: fileWithNetworkQoS, + expectedFileContent: fileWithoutNetworkQoS, + expectedError: false, + }, + + { + name: "cni-plugin-not-exists", + fileContent: fileWithoutNetworkQoS, + expectedFileContent: fileWithoutNetworkQoS, + expectedError: false, + }, + + { + name: "empty-cni-config", + expectedError: true, + }, + + { + name: "cni-config-without-plugins", + fileContent: fileWithoutPlugins, + expectedError: true, + }, + + { + name: "cni-config-with-illegal-json", + fileContent: fileWithIllegalJson, + expectedError: true, + }, + + { + name: "json Marshal failed", + fileContent: fileWithNetworkQoS, + jsonMarshalErr: fmt.Errorf("json Marshal failed"), + expectedError: true, + }, + + { + name: "json MarshalIndent failed", + + fileContent: fileWithNetworkQoS, + jsonMarshalIndentErr: fmt.Errorf("json MarshalIndent failed"), + expectedError: true, + }, + } + + tmp, err := os.MkdirTemp("", "test-cni") + if err != nil { + t.Fatal(err) + } + defer os.Remove(tmp) + + conflistFile := filepath.Join(tmp, "cni.conflist") + defer os.Remove(conflistFile) + + for _, tc := range testCases { + if err = os.WriteFile(conflistFile, []byte(tc.fileContent), os.FileMode(0644)); err != nil { + t.Fatal(err) + } + + var jsonMarshalPatch, jsonMarshalIndentPatch *gomonkey.Patches + if tc.jsonMarshalErr != nil { + jsonMarshalPatch = gomonkey.NewPatches() + jsonMarshalPatch.ApplyFunc(json.Marshal, func(v interface{}) ([]byte, error) { + return nil, tc.jsonMarshalErr + }) + } + + if tc.jsonMarshalIndentErr != nil { + jsonMarshalIndentPatch = gomonkey.NewPatches() + jsonMarshalIndentPatch.ApplyFunc(json.Marshal, func(v interface{}) ([]byte, error) { + return nil, tc.jsonMarshalErr + }) + } + + cniConf := GetCNIPluginConfHandler() + actualErr := cniConf.DeleteCniPluginFromConfList(conflistFile, "network-qos") + + if jsonMarshalPatch != nil { + jsonMarshalPatch.Reset() + } + + if jsonMarshalIndentPatch != nil { + jsonMarshalIndentPatch.Reset() + } + + assert.Equal(t, tc.expectedError, actualErr != nil, tc.name) + + if actualErr != nil { + continue + } + + content, err := os.ReadFile(conflistFile) + if err != nil { + t.Fatal(err) + } + assert.Equal(t, tc.expectedFileContent, string(content), tc.name) + } +} diff --git a/pkg/networkqos/cni/mocks/mock_config.go b/pkg/networkqos/cni/mocks/mock_config.go new file mode 100644 index 000000000..349a7c4c5 --- /dev/null +++ b/pkg/networkqos/cni/mocks/mock_config.go @@ -0,0 +1,78 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by MockGen. DO NOT EDIT. +// Source: config.go + +// Package mocks is a generated GoMock package. +package mocks + +import ( + reflect "reflect" + + gomock "github.com/golang/mock/gomock" +) + +// MockCNIPluginsConfHandler is a mock of CNIPluginsConfHandler interface. +type MockCNIPluginsConfHandler struct { + ctrl *gomock.Controller + recorder *MockCNIPluginsConfHandlerMockRecorder +} + +// MockCNIPluginsConfHandlerMockRecorder is the mock recorder for MockCNIPluginsConfHandler. +type MockCNIPluginsConfHandlerMockRecorder struct { + mock *MockCNIPluginsConfHandler +} + +// NewMockCNIPluginsConfHandler creates a new mock instance. +func NewMockCNIPluginsConfHandler(ctrl *gomock.Controller) *MockCNIPluginsConfHandler { + mock := &MockCNIPluginsConfHandler{ctrl: ctrl} + mock.recorder = &MockCNIPluginsConfHandlerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockCNIPluginsConfHandler) EXPECT() *MockCNIPluginsConfHandlerMockRecorder { + return m.recorder +} + +// AddOrUpdateCniPluginToConfList mocks base method. +func (m *MockCNIPluginsConfHandler) AddOrUpdateCniPluginToConfList(configPath, name string, plugin map[string]interface{}) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AddOrUpdateCniPluginToConfList", configPath, name, plugin) + ret0, _ := ret[0].(error) + return ret0 +} + +// AddOrUpdateCniPluginToConfList indicates an expected call of AddOrUpdateCniPluginToConfList. +func (mr *MockCNIPluginsConfHandlerMockRecorder) AddOrUpdateCniPluginToConfList(configPath, name, plugin interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddOrUpdateCniPluginToConfList", reflect.TypeOf((*MockCNIPluginsConfHandler)(nil).AddOrUpdateCniPluginToConfList), configPath, name, plugin) +} + +// DeleteCniPluginFromConfList mocks base method. +func (m *MockCNIPluginsConfHandler) DeleteCniPluginFromConfList(configPath, name string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteCniPluginFromConfList", configPath, name) + ret0, _ := ret[0].(error) + return ret0 +} + +// DeleteCniPluginFromConfList indicates an expected call of DeleteCniPluginFromConfList. +func (mr *MockCNIPluginsConfHandlerMockRecorder) DeleteCniPluginFromConfList(configPath, name interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCniPluginFromConfList", reflect.TypeOf((*MockCNIPluginsConfHandler)(nil).DeleteCniPluginFromConfList), configPath, name) +} diff --git a/pkg/networkqos/networkqos.go b/pkg/networkqos/networkqos.go new file mode 100644 index 000000000..f8a2958a5 --- /dev/null +++ b/pkg/networkqos/networkqos.go @@ -0,0 +1,233 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package networkqos + +import ( + "context" + "fmt" + "os" + "strconv" + "time" + + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/klog/v2" + + "volcano.sh/volcano/pkg/agent/apis" + "volcano.sh/volcano/pkg/agent/config/api" + "volcano.sh/volcano/pkg/agent/features" + "volcano.sh/volcano/pkg/agent/utils/exec" + "volcano.sh/volcano/pkg/config" + "volcano.sh/volcano/pkg/networkqos/utils" +) + +type NetworkQoSManager interface { + Init() error + HealthCheck() error + EnableNetworkQoS(qosConf *api.NetworkQos) error + DisableNetworkQoS() error +} + +var networkQoSManager NetworkQoSManager + +type NetworkQoSManagerImp struct { + config *config.Configuration + flavorQuotaMinRate int64 +} + +func NewNetworkQoSManager(config *config.Configuration) NetworkQoSManager { + networkQoSManager = &NetworkQoSManagerImp{ + config: config, + } + return networkQoSManager +} + +func GetNetworkQoSManager(config *config.Configuration) NetworkQoSManager { + if networkQoSManager == nil { + return NewNetworkQoSManager(config) + } + return networkQoSManager +} + +func (m *NetworkQoSManagerImp) Init() error { + return InstallNetworkQoS() +} + +func (m *NetworkQoSManagerImp) HealthCheck() error { + return CheckNetworkQoSStatus() +} + +func (m *NetworkQoSManagerImp) EnableNetworkQoS(qosConf *api.NetworkQos) error { + onlineBandwidthWatermark, offlineLowBandwidth, offlineHighBandwidth, err := m.GetBandwidthConfigs(qosConf) + if err != nil { + return fmt.Errorf("failed to get bandwidth configs: %v", err) + } + + var checkInterval string + if qosConf != nil && qosConf.QoSCheckInterval != nil { + checkInterval = strconv.Itoa(*qosConf.QoSCheckInterval) + } + + cmdCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + cmd := fmt.Sprintf(utils.NetWorkCmdFile+" prepare --%s=%s --%s=%s --%s=%s --%s=%s --%s=%s", + utils.EnableNetworkQoS, "true", + utils.OnlineBandwidthWatermarkKey, onlineBandwidthWatermark, + utils.OfflineLowBandwidthKey, offlineLowBandwidth, + utils.OfflineHighBandwidthKey, offlineHighBandwidth, + utils.NetWorkQoSCheckInterval, checkInterval) + output, err := exec.GetExecutor().CommandContext(cmdCtx, cmd) + if err != nil { + return fmt.Errorf("failed to set network qos:%v, output:%s", err, output) + } + return nil +} + +func (m *NetworkQoSManagerImp) DisableNetworkQoS() error { + cmdCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + cmd := fmt.Sprintf(utils.NetWorkCmdFile+" prepare --%s=%s", utils.EnableNetworkQoS, "false") + output, err := exec.GetExecutor().CommandContext(cmdCtx, cmd) + if err != nil { + return fmt.Errorf("failed to reset network qos:%v, output:%s", err, output) + } + return nil +} + +func (m *NetworkQoSManagerImp) GetBandwidthConfigs(qosConf *api.NetworkQos) (onlineBandwidthWatermark, offlineLowBandwidth, offlineHighBandwidth string, err error) { + if m.flavorQuotaMinRate == 0 { + nodeName := m.config.GenericConfiguration.KubeNodeName + getCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + node, err := m.config.GenericConfiguration.KubeClient.CoreV1().Nodes().Get(getCtx, nodeName, metav1.GetOptions{}) + if err != nil { + return "", "", "0", fmt.Errorf("failed to get k8s node(%s): %v", nodeName, err) + } + m.flavorQuotaMinRate, err = GetFlavorQuotaMinRate(node) + if err != nil { + return "", "", "", fmt.Errorf("failed to get flavor quota min rate, err: %v", err) + } + } + + onlineBandwidthWatermark, err = GetOnlineBandwidthWatermark(m.flavorQuotaMinRate, qosConf) + if err != nil { + return "", "", "", fmt.Errorf("failed to get onlineBandwidthWatermark, err: %v", err) + } + + offlineLowBandwidth, err = GetOfflineLowBandwidthPercent(m.flavorQuotaMinRate, qosConf) + if err != nil { + return "", "", "", fmt.Errorf("failed to get offlineLowBandwidth, err: %v", err) + } + + offlineHighBandwidth, err = GetOfflineHighBandwidthPercent(m.flavorQuotaMinRate, qosConf) + if err != nil { + return "", "", "", fmt.Errorf("failed to get offlineHighBandwidth, err: %v", err) + } + + return onlineBandwidthWatermark, offlineLowBandwidth, offlineHighBandwidth, nil +} + +func GetFlavorQuotaMinRate(node *corev1.Node) (int64, error) { + minRate, ok := node.Annotations[apis.NetworkBandwidthRateAnnotationKey] + if !ok { + return 0, fmt.Errorf("node %s network bandwidth rate not exists, annotion %s", node.Name, apis.NetworkBandwidthRateAnnotationKey) + } + + minRateInt, err := strconv.ParseInt(minRate, 10, 64) + if err != nil { + return 0, fmt.Errorf("failed to cover net rate spec(%s) to int, err: %v", minRate, err) + } + return minRateInt, nil +} + +func GetOnlineBandwidthWatermark(serverRateQuota int64, qosConf *api.NetworkQos) (string, error) { + var onlineBandwidthWatermarkPercent int + if qosConf != nil && qosConf.OnlineBandwidthWatermarkPercent != nil { + onlineBandwidthWatermarkPercent = *qosConf.OnlineBandwidthWatermarkPercent + } else { + return "", fmt.Errorf("illegal network config, parameter OnlineBandwidthWatermarkPercent missing") + } + + return strconv.FormatInt(serverRateQuota*int64(onlineBandwidthWatermarkPercent)/100, 10) + "Mbps", nil +} + +func GetOfflineLowBandwidthPercent(serverRateQuota int64, qosConf *api.NetworkQos) (string, error) { + var offlineLowBandwidthPercent int + if qosConf != nil && qosConf.OfflineLowBandwidthPercent != nil { + offlineLowBandwidthPercent = *qosConf.OfflineLowBandwidthPercent + } else { + return "", fmt.Errorf("illegal network config, parameter OfflineLowBandwidthPercent missing") + } + + return strconv.FormatInt(serverRateQuota*int64(offlineLowBandwidthPercent)/100, 10) + "Mbps", nil +} + +func GetOfflineHighBandwidthPercent(serverRateQuota int64, qosConf *api.NetworkQos) (string, error) { + var offlineHighBandwidthPercent int + if qosConf != nil && qosConf.OfflineHighBandwidthPercent != nil { + offlineHighBandwidthPercent = *qosConf.OfflineHighBandwidthPercent + } else { + return "", fmt.Errorf("illegal network config, parameter OfflineHighBandwidthPercent missing") + } + + return strconv.FormatInt(serverRateQuota*int64(offlineHighBandwidthPercent)/100, 10) + "Mbps", nil +} + +func InstallNetworkQoS() error { + checkErr := features.CheckNodeSupportNetworkQoS() + if checkErr != nil { + if features.IsUnsupportedError(checkErr) { + klog.InfoS("Skip installing network-qos, os/network-mode not supported") + return nil + } + return checkErr + } + + klog.InfoS("Start to install network-qos") + ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) + defer cancel() + cmd := "sudo /bin/cp -f /usr/local/bin/bwm_tc.o /usr/share/bwmcli" + output, err := exec.GetExecutor().CommandContext(ctx, cmd) + if err != nil { + klog.ErrorS(err, "Failed to install bwm_tc.o to /usr/share/bwmcli", "output", output) + return err + } + + cmd = "sudo /bin/cp -f /usr/local/bin/network-qos /opt/cni/bin" + output, err = exec.GetExecutor().CommandContext(ctx, cmd) + if err != nil { + klog.ErrorS(err, "Failed to install network-qos to /opt/cni/bin; %s", "output", output) + return err + } + klog.InfoS("Successfully installed network-qos") + return nil +} + +func CheckNetworkQoSStatus() error { + _, err := os.Stat(utils.TCPROGPath) + if err != nil { + klog.ErrorS(err, "Failed to check the existence of bwm_tc.o", "path", utils.TCPROGPath) + return err + } + + _, err = os.Stat(utils.NetworkQoSPath) + if err != nil { + klog.ErrorS(err, "Failed to check the existence of network-qos", "path", utils.NetworkQoSPath) + return err + } + return nil +} diff --git a/pkg/networkqos/networkqos_test.go b/pkg/networkqos/networkqos_test.go new file mode 100644 index 000000000..8978aaee2 --- /dev/null +++ b/pkg/networkqos/networkqos_test.go @@ -0,0 +1,297 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package networkqos + +import ( + "fmt" + "os" + "path" + "testing" + + "github.com/golang/mock/gomock" + "github.com/stretchr/testify/assert" + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/client-go/kubernetes/fake" + utilpointer "k8s.io/utils/pointer" + + coloConf "volcano.sh/volcano/pkg/agent/config/api" + "volcano.sh/volcano/pkg/agent/utils/exec" + mockexec "volcano.sh/volcano/pkg/agent/utils/exec/mocks" + "volcano.sh/volcano/pkg/config" + "volcano.sh/volcano/pkg/networkqos/utils" +) + +func TestGetOnlineBandwidthWatermark(t *testing.T) { + testCases := []struct { + name string + qosConf *coloConf.NetworkQos + serverRateQuota int64 + expectedResult string + expectedErr bool + }{ + { + name: "get value from conf", + serverRateQuota: 10000, + qosConf: &coloConf.NetworkQos{ + OnlineBandwidthWatermarkPercent: utilpointer.Int(50), + }, + expectedResult: "5000Mbps", + expectedErr: false, + }, + { + name: "nil network qos conf", + serverRateQuota: 5000, + expectedResult: "", + expectedErr: true, + }, + + { + name: "nil OfflineHighBandwidthPercent", + serverRateQuota: 6000, + qosConf: &coloConf.NetworkQos{}, + expectedResult: "", + expectedErr: true, + }, + } + + for _, tc := range testCases { + actualResult, actualErr := GetOnlineBandwidthWatermark(tc.serverRateQuota, tc.qosConf) + assert.Equal(t, tc.expectedResult, actualResult, tc.name) + assert.Equal(t, tc.expectedErr, actualErr != nil, tc.name) + } +} + +func TestGetOfflineLowBandwidthPercent(t *testing.T) { + testCases := []struct { + name string + qosConf *coloConf.NetworkQos + serverRateQuota int64 + expectedResult string + expectedErr bool + }{ + { + name: "get value from conf", + qosConf: &coloConf.NetworkQos{ + OfflineLowBandwidthPercent: utilpointer.Int(25), + }, + serverRateQuota: 10000, + expectedResult: "2500Mbps", + expectedErr: false, + }, + { + name: "nil network qos conf", + serverRateQuota: 5000, + expectedResult: "", + expectedErr: true, + }, + + { + name: "nil OfflineLowBandwidthPercent", + serverRateQuota: 6000, + qosConf: &coloConf.NetworkQos{}, + expectedResult: "", + expectedErr: true, + }, + } + + for _, tc := range testCases { + actualResult, actualErr := GetOfflineLowBandwidthPercent(tc.serverRateQuota, tc.qosConf) + assert.Equal(t, tc.expectedResult, actualResult, tc.name) + assert.Equal(t, tc.expectedErr, actualErr != nil, tc.name) + } +} + +func TestGetOfflineHighBandwidthPercent(t *testing.T) { + testCases := []struct { + name string + qosConf *coloConf.NetworkQos + serverRateQuota int64 + expectedResult string + expectedErr bool + }{ + + { + name: "get value from conf", + qosConf: &coloConf.NetworkQos{ + OfflineHighBandwidthPercent: utilpointer.Int(30), + }, + serverRateQuota: 20000, + expectedResult: "6000Mbps", + expectedErr: false, + }, + { + name: "nil network qos conf", + serverRateQuota: 5000, + expectedResult: "", + expectedErr: true, + }, + + { + name: "nil OfflineHighBandwidthPercent", + serverRateQuota: 6000, + qosConf: &coloConf.NetworkQos{}, + expectedResult: "", + expectedErr: true, + }, + } + + for _, tc := range testCases { + actualResult, actualErr := GetOfflineHighBandwidthPercent(tc.serverRateQuota, tc.qosConf) + assert.Equal(t, tc.expectedResult, actualResult, tc.name) + assert.Equal(t, tc.expectedErr, actualErr != nil, tc.name) + } +} + +func TestEnableNetworkQoS(t *testing.T) { + mockController := gomock.NewController(t) + defer mockController.Finish() + mockExec := mockexec.NewMockExecInterface(mockController) + exec.SetExecutor(mockExec) + + testCases := []struct { + name string + config *config.Configuration + node *corev1.Node + apiCall []*gomock.Call + qosConf *coloConf.NetworkQos + expectedErr bool + }{ + { + name: "enable NetworkQoS succeed", + config: &config.Configuration{ + GenericConfiguration: &config.VolcanoAgentConfiguration{ + KubeNodeName: "test-node-1", + }, + }, + node: &corev1.Node{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test-node-1", + Annotations: map[string]string{ + "volcano.sh/network-bandwidth-rate": "100", + }, + }, + }, + qosConf: &coloConf.NetworkQos{ + OnlineBandwidthWatermarkPercent: utilpointer.Int(80), + OfflineHighBandwidthPercent: utilpointer.Int(40), + OfflineLowBandwidthPercent: utilpointer.Int(10), + }, + apiCall: []*gomock.Call{ + mockExec.EXPECT().CommandContext(gomock.Any(), "/usr/local/bin/network-qos prepare "+ + "--enable-network-qos=true --online-bandwidth-watermark=80Mbps --offline-low-bandwidth=10Mbps "+ + "--offline-high-bandwidth=40Mbps --check-interval=").Return("", nil), + }, + }, + } + + for _, tc := range testCases { + fakeClient := fake.NewSimpleClientset(tc.node) + mgr := &NetworkQoSManagerImp{ + config: &config.Configuration{ + GenericConfiguration: &config.VolcanoAgentConfiguration{ + KubeClient: fakeClient, + KubeNodeName: tc.node.Name, + }, + }, + } + mgr.config.GenericConfiguration.KubeClient = fake.NewSimpleClientset(tc.node) + actualErr := mgr.EnableNetworkQoS(tc.qosConf) + gomock.InOrder(tc.apiCall...) + assert.Equal(t, tc.expectedErr, actualErr != nil, tc.name) + } +} + +var openEulerOS = ` +NAME="openEuler" +VERSION="22.03 (LTS-SP2)" +ID="openEuler" +VERSION_ID="22.03" +PRETTY_NAME="openEuler 22.03 (LTS-SP2)" +ANSI_COLOR="0;31" + +` + +var ubuntuOS = ` +NAME="Ubuntu" +VERSION="16.04.5 LTS (Xenial Xerus)" +ID=ubuntu +ID_LIKE=debian +PRETTY_NAME="Ubuntu 16.04.5 LTS" +VERSION_ID="16.04" +` + +func TestInstallNetworkQoS(t *testing.T) { + dir, err := os.MkdirTemp("/tmp", "MkdirTemp") + defer func() { + err = os.RemoveAll(dir) + if err != nil { + t.Errorf("remove dir(%s) failed: %v", dir, err) + } + assert.Equal(t, err == nil, true) + }() + assert.Equal(t, err == nil, true) + tmpFile := path.Join(dir, "os-release") + if err = os.WriteFile(tmpFile, []byte(openEulerOS), 0660); err != nil { + assert.Equal(t, nil, err) + } + if err = os.Setenv(utils.HostOSReleasePathEnv, tmpFile); err != nil { + assert.Equal(t, nil, err) + } + + mockController := gomock.NewController(t) + defer mockController.Finish() + mockExec := mockexec.NewMockExecInterface(mockController) + exec.SetExecutor(mockExec) + + testCases := []struct { + name string + apiCall []*gomock.Call + expectedError bool + }{ + { + name: "install network-qos successfully && existed old bwm_tc.o && existed old network-qos", + apiCall: []*gomock.Call{ + mockExec.EXPECT().CommandContext(gomock.Any(), "sudo /bin/cp -f /usr/local/bin/bwm_tc.o /usr/share/bwmcli").Return("", nil), + mockExec.EXPECT().CommandContext(gomock.Any(), "sudo /bin/cp -f /usr/local/bin/network-qos /opt/cni/bin").Return("", nil), + }, + expectedError: false, + }, + + { + name: "install bwm_tc.o failed", + apiCall: []*gomock.Call{ + mockExec.EXPECT().CommandContext(gomock.Any(), "sudo /bin/cp -f /usr/local/bin/bwm_tc.o /usr/share/bwmcli").Return("", fmt.Errorf("errors")), + }, + expectedError: true, + }, + + { + name: "install network-qos failed", + apiCall: []*gomock.Call{ + mockExec.EXPECT().CommandContext(gomock.Any(), "sudo /bin/cp -f /usr/local/bin/bwm_tc.o /usr/share/bwmcli").Return("", nil), + mockExec.EXPECT().CommandContext(gomock.Any(), "sudo /bin/cp -f /usr/local/bin/network-qos /opt/cni/bin").Return("", fmt.Errorf("errors")), + }, + expectedError: true, + }, + } + + for _, tc := range testCases { + actualErr := InstallNetworkQoS() + assert.Equal(t, tc.expectedError, actualErr != nil, tc.name) + } +} diff --git a/pkg/networkqos/tc/mocks/mock_tc.go b/pkg/networkqos/tc/mocks/mock_tc.go new file mode 100644 index 000000000..2e2188084 --- /dev/null +++ b/pkg/networkqos/tc/mocks/mock_tc.go @@ -0,0 +1,93 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by MockGen. DO NOT EDIT. +// Source: tc.go + +// Package mocks is a generated GoMock package. +package mocks + +import ( + reflect "reflect" + + gomock "github.com/golang/mock/gomock" +) + +// MockTC is a mock of TC interface. +type MockTC struct { + ctrl *gomock.Controller + recorder *MockTCMockRecorder +} + +// MockTCMockRecorder is the mock recorder for MockTC. +type MockTCMockRecorder struct { + mock *MockTC +} + +// NewMockTC creates a new mock instance. +func NewMockTC(ctrl *gomock.Controller) *MockTC { + mock := &MockTC{ctrl: ctrl} + mock.recorder = &MockTCMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockTC) EXPECT() *MockTCMockRecorder { + return m.recorder +} + +// AddFilter mocks base method. +func (m *MockTC) AddFilter(netns, ifName string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AddFilter", netns, ifName) + ret0, _ := ret[0].(error) + return ret0 +} + +// AddFilter indicates an expected call of AddFilter. +func (mr *MockTCMockRecorder) AddFilter(netns, ifName interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddFilter", reflect.TypeOf((*MockTC)(nil).AddFilter), netns, ifName) +} + +// PreAddFilter mocks base method. +func (m *MockTC) PreAddFilter(netns, ifName string) (bool, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PreAddFilter", netns, ifName) + ret0, _ := ret[0].(bool) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PreAddFilter indicates an expected call of PreAddFilter. +func (mr *MockTCMockRecorder) PreAddFilter(netns, ifName interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreAddFilter", reflect.TypeOf((*MockTC)(nil).PreAddFilter), netns, ifName) +} + +// RemoveFilter mocks base method. +func (m *MockTC) RemoveFilter(netns, ifName string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RemoveFilter", netns, ifName) + ret0, _ := ret[0].(error) + return ret0 +} + +// RemoveFilter indicates an expected call of RemoveFilter. +func (mr *MockTCMockRecorder) RemoveFilter(netns, ifName interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveFilter", reflect.TypeOf((*MockTC)(nil).RemoveFilter), netns, ifName) +} diff --git a/pkg/networkqos/tc/tc.go b/pkg/networkqos/tc/tc.go new file mode 100644 index 000000000..45902261d --- /dev/null +++ b/pkg/networkqos/tc/tc.go @@ -0,0 +1,52 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package tc + +import ( + "time" +) + +const ( + CmdTimeout = 5 * time.Second +) + +//go:generate mockgen -destination ./mocks/mock_tc.go -package mocks -source tc.go + +// just support linux, related bug: https://github.com/vishvananda/netns/issues/23 + +type TC interface { + PreAddFilter(netns, ifName string) (bool, error) + AddFilter(netns, ifName string) error + RemoveFilter(netns, ifName string) error +} + +var _ TC = &TCCmd{} + +type TCCmd struct{} + +var tcCmd TC + +func GetTCCmd() TC { + if tcCmd == nil { + tcCmd = &TCCmd{} + } + return tcCmd +} + +func SetTcCmd(tc TC) { + tcCmd = tc +} diff --git a/pkg/networkqos/tc/tc_linux.go b/pkg/networkqos/tc/tc_linux.go new file mode 100644 index 000000000..d664a4828 --- /dev/null +++ b/pkg/networkqos/tc/tc_linux.go @@ -0,0 +1,184 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package tc + +import ( + "context" + "fmt" + + "github.com/containernetworking/plugins/pkg/ns" + "github.com/vishvananda/netlink" + "k8s.io/klog/v2" + + "volcano.sh/volcano/pkg/agent/utils/exec" + "volcano.sh/volcano/pkg/networkqos/utils" +) + +const ( + QdiscTypeClsact = "clsact" + QdiscTypeFq = "fq" + FilterTypeBpf = "bpf" + QdiscTypeNoQueue = "noqueue" +) + +func (t *TCCmd) PreAddFilter(netns, ifName string) (bool, error) { + netNs, err := ns.GetNS(netns) + if err != nil { + err = fmt.Errorf("failed to open netns %s: %v", netns, err) + return false, err + } + defer netNs.Close() + + supportAddFilter := true + checkErr := netNs.Do(func(_ ns.NetNS) error { + link, err := netlink.LinkByName(ifName) + if err != nil { + return fmt.Errorf("failed to lookup device on ns:ifName(%s:%s): %v", netns, ifName, err) + } + + qdiscs, err := netlink.QdiscList(link) + if err != nil { + return fmt.Errorf("failed to list clsact qdiscs on on ns:ifName(%s:%s): %v", netns, ifName, err) + } + + for _, qdisc := range qdiscs { + if qdisc.Attrs().Parent == netlink.HANDLE_INGRESS && qdisc.Type() != QdiscTypeClsact { + klog.InfoS("the Ingress qdisc already existed, can not create new one, skip add network qos qdisc to this device", + "namespace", netns, "ifName", ifName, "existed-ingress-qdisc", qdisc.Type()) + supportAddFilter = false + break + } + + if qdisc.Attrs().Parent == netlink.HANDLE_ROOT && qdisc.Type() != QdiscTypeFq && qdisc.Type() != QdiscTypeNoQueue { + klog.InfoS("the root handle qdisc already existed, can not create new one, skip add network qos qdisc to this device", + "namespace", netns, "ifName", ifName, "existed-root-qdisc", qdisc.Type()) + supportAddFilter = false + break + } + } + return nil + }) + return supportAddFilter, checkErr +} + +func (t *TCCmd) AddFilter(netns, ifName string) error { + netNs, err := ns.GetNS(netns) + if err != nil { + err = fmt.Errorf("failed to open netns %s: %v", netns, err) + return err + } + defer netNs.Close() + + addErr := netNs.Do(func(_ ns.NetNS) error { + link, err := netlink.LinkByName(ifName) + if err != nil { + return fmt.Errorf("failed to lookup device on ns:ifName(%s:%s): %v", netns, ifName, err) + } + + fq := &netlink.Fq{ + QdiscAttrs: netlink.QdiscAttrs{ + LinkIndex: link.Attrs().Index, + Parent: netlink.HANDLE_ROOT, + }, + Pacing: 1, + } + if err = netlink.QdiscAdd(fq); err != nil { + return fmt.Errorf("failed to create fq qdisc ns:ifName(%s:%s): %v", netns, ifName, err) + } + klog.InfoS("Successfully added qdisc", "type", QdiscTypeFq, "netns", netns, "ifName", ifName) + + clsact := &netlink.GenericQdisc{ + QdiscAttrs: netlink.QdiscAttrs{ + LinkIndex: link.Attrs().Index, + Parent: netlink.HANDLE_CLSACT, + }, + QdiscType: QdiscTypeClsact, + } + if err = netlink.QdiscAdd(clsact); err != nil { + return fmt.Errorf("failed to create clsact qdisc on on ns:ifName(%s:%s): %v", netns, ifName, err) + } + klog.InfoS("Successfully added qdisc", "type", QdiscTypeClsact, "netns", netns, "ifName", ifName) + + filterCmd := fmt.Sprintf("tc filter add dev %s egress bpf direct-action obj %s sec tc", ifName, utils.TCPROGPath) + ctx, cancel := context.WithTimeout(context.Background(), CmdTimeout) + defer cancel() + output, err := exec.GetExecutor().CommandContext(ctx, filterCmd) + if err != nil { + return fmt.Errorf("add dev on ns:ifName(%s:%s) failed : %v, %s, %s", netns, ifName, err, output, filterCmd) + } + klog.InfoS("Successfully added filter", "ebpf-obj", utils.TCPROGPath, "netns", netns, "ifName", ifName) + return nil + }) + + return addErr +} + +func (t *TCCmd) RemoveFilter(netns, ifName string) error { + netNs, err := ns.GetNS(netns) + if err != nil { + _, ok := err.(ns.NSPathNotExistErr) + if ok { + return nil + } + err = fmt.Errorf("failed to open netns %s: %v", netns, err) + return err + } + defer netNs.Close() + + removeErr := netNs.Do(func(_ ns.NetNS) error { + link, err := netlink.LinkByName(ifName) + if err != nil { + _, ok := err.(netlink.LinkNotFoundError) + if ok { + return nil + } + return fmt.Errorf("failed to lookup device on ns:ifName(%s:%s): %v", netns, ifName, err) + } + + filters, err := netlink.FilterList(link, netlink.HANDLE_MIN_EGRESS) + if err != nil { + return fmt.Errorf("failed to list engress filters on ns:ifName(%s:%s): %v", netns, ifName, err) + } + + for _, f := range filters { + if f.Type() == FilterTypeBpf { + if err = netlink.FilterDel(f); err != nil { + return fmt.Errorf("failed to delete egress filters on ns:ifName(%s:%s): %v", netns, ifName, err) + } + klog.InfoS("Successfully deleted egress filter", "netns", netns, "ifName", ifName) + break + } + } + + qdiscs, err := netlink.QdiscList(link) + if err != nil { + return fmt.Errorf("failed to list qdiscs %s: %v", ifName, err) + } + + for _, qdisc := range qdiscs { + if qdisc.Type() == QdiscTypeClsact || qdisc.Type() == QdiscTypeFq { + if err = netlink.QdiscDel(qdisc); err != nil { + return fmt.Errorf("failed to delete %s qdisc on ns:ifName(%s:%s): %v", qdisc.Type(), netns, ifName, err) + } + klog.InfoS("Successfully deleted qdisc", "type", qdisc.Type(), "netns", netns, "ifName", ifName) + } + } + return nil + }) + + return removeErr +} diff --git a/pkg/networkqos/tc/tc_unspecified.go b/pkg/networkqos/tc/tc_unspecified.go new file mode 100644 index 000000000..43f4e27f6 --- /dev/null +++ b/pkg/networkqos/tc/tc_unspecified.go @@ -0,0 +1,36 @@ +//go:build !linux +// +build !linux + +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package tc + +import ( + "errors" +) + +func (t *TCCmd) PreAddFilter(netns, ifName string) error { + return errors.New("not implemented") +} + +func (t *TCCmd) AddFilter(netns, ifName string) error { + return errors.New("not implemented") +} + +func (t *TCCmd) RemoveFilter(netns, ifName string) error { + return errors.New("not implemented") +} diff --git a/pkg/networkqos/throttling/mocks/mock_throttling.go b/pkg/networkqos/throttling/mocks/mock_throttling.go new file mode 100644 index 000000000..853e415e3 --- /dev/null +++ b/pkg/networkqos/throttling/mocks/mock_throttling.go @@ -0,0 +1,125 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by MockGen. DO NOT EDIT. +// Source: throttling.go + +// Package mocks is a generated GoMock package. +package mocks + +import ( + reflect "reflect" + + gomock "github.com/golang/mock/gomock" + api "volcano.sh/volcano/pkg/networkqos/api" +) + +// MockThrottlingConfig is a mock of ThrottlingConfig interface. +type MockThrottlingConfig struct { + ctrl *gomock.Controller + recorder *MockThrottlingConfigMockRecorder +} + +// MockThrottlingConfigMockRecorder is the mock recorder for MockThrottlingConfig. +type MockThrottlingConfigMockRecorder struct { + mock *MockThrottlingConfig +} + +// NewMockThrottlingConfig creates a new mock instance. +func NewMockThrottlingConfig(ctrl *gomock.Controller) *MockThrottlingConfig { + mock := &MockThrottlingConfig{ctrl: ctrl} + mock.recorder = &MockThrottlingConfigMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockThrottlingConfig) EXPECT() *MockThrottlingConfigMockRecorder { + return m.recorder +} + +// CreateOrUpdateThrottlingConfig mocks base method. +func (m *MockThrottlingConfig) CreateOrUpdateThrottlingConfig(onlineBandwidthWatermark, offlineLowBandwidth, offlineHighBandwidth, checkInterval string) (*api.EbpfNetThrottlingConfig, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateOrUpdateThrottlingConfig", onlineBandwidthWatermark, offlineLowBandwidth, offlineHighBandwidth, checkInterval) + ret0, _ := ret[0].(*api.EbpfNetThrottlingConfig) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateOrUpdateThrottlingConfig indicates an expected call of CreateOrUpdateThrottlingConfig. +func (mr *MockThrottlingConfigMockRecorder) CreateOrUpdateThrottlingConfig(onlineBandwidthWatermark, offlineLowBandwidth, offlineHighBandwidth, checkInterval interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdateThrottlingConfig", reflect.TypeOf((*MockThrottlingConfig)(nil).CreateOrUpdateThrottlingConfig), onlineBandwidthWatermark, offlineLowBandwidth, offlineHighBandwidth, checkInterval) +} + +// CreateThrottlingConfig mocks base method. +func (m *MockThrottlingConfig) CreateThrottlingConfig(onlineBandwidthWatermark, offlineLowBandwidth, offlineHighBandwidth, checkInterval string) (*api.EbpfNetThrottlingConfig, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateThrottlingConfig", onlineBandwidthWatermark, offlineLowBandwidth, offlineHighBandwidth, checkInterval) + ret0, _ := ret[0].(*api.EbpfNetThrottlingConfig) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateThrottlingConfig indicates an expected call of CreateThrottlingConfig. +func (mr *MockThrottlingConfigMockRecorder) CreateThrottlingConfig(onlineBandwidthWatermark, offlineLowBandwidth, offlineHighBandwidth, checkInterval interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateThrottlingConfig", reflect.TypeOf((*MockThrottlingConfig)(nil).CreateThrottlingConfig), onlineBandwidthWatermark, offlineLowBandwidth, offlineHighBandwidth, checkInterval) +} + +// DeleteThrottlingConfig mocks base method. +func (m *MockThrottlingConfig) DeleteThrottlingConfig() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteThrottlingConfig") + ret0, _ := ret[0].(error) + return ret0 +} + +// DeleteThrottlingConfig indicates an expected call of DeleteThrottlingConfig. +func (mr *MockThrottlingConfigMockRecorder) DeleteThrottlingConfig() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteThrottlingConfig", reflect.TypeOf((*MockThrottlingConfig)(nil).DeleteThrottlingConfig)) +} + +// GetThrottlingConfig mocks base method. +func (m *MockThrottlingConfig) GetThrottlingConfig() (*api.EbpfNetThrottlingConfig, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetThrottlingConfig") + ret0, _ := ret[0].(*api.EbpfNetThrottlingConfig) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetThrottlingConfig indicates an expected call of GetThrottlingConfig. +func (mr *MockThrottlingConfigMockRecorder) GetThrottlingConfig() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThrottlingConfig", reflect.TypeOf((*MockThrottlingConfig)(nil).GetThrottlingConfig)) +} + +// GetThrottlingStatus mocks base method. +func (m *MockThrottlingConfig) GetThrottlingStatus() (*api.EbpfNetThrottling, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetThrottlingStatus") + ret0, _ := ret[0].(*api.EbpfNetThrottling) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetThrottlingStatus indicates an expected call of GetThrottlingStatus. +func (mr *MockThrottlingConfigMockRecorder) GetThrottlingStatus() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThrottlingStatus", reflect.TypeOf((*MockThrottlingConfig)(nil).GetThrottlingStatus)) +} diff --git a/pkg/networkqos/throttling/throttling.go b/pkg/networkqos/throttling/throttling.go new file mode 100644 index 000000000..f5d641d94 --- /dev/null +++ b/pkg/networkqos/throttling/throttling.go @@ -0,0 +1,232 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package throttling + +import ( + "errors" + "fmt" + "os" + "path" + "strconv" + "strings" + "unsafe" + + cilliumbpf "github.com/cilium/ebpf" + + agentutils "volcano.sh/volcano/pkg/agent/utils" + "volcano.sh/volcano/pkg/networkqos/api" + "volcano.sh/volcano/pkg/networkqos/utils" + "volcano.sh/volcano/pkg/networkqos/utils/ebpf" +) + +const ( + TCEbpfPath = "/bpf/tc/globals/" + ThrottleConfigMapName = "throttle_cfg" + ThrottleStatusMapName = "throttle_map" + ThrottleConfigMapPinPath = TCEbpfPath + ThrottleConfigMapName + ThrottleStatusMapPinPath = TCEbpfPath + ThrottleStatusMapName +) + +type sliceStr struct { + addr uintptr + len int + cap int +} + +//go:generate mockgen -destination ./mocks/mock_throttling.go -package mocks -source throttling.go + +type ThrottlingConfig interface { + // CreateThrottlingConfig inits the throttling config values, if no initial value is given, the default value will be used + CreateThrottlingConfig(onlineBandwidthWatermark, offlineLowBandwidth, offlineHighBandwidth, checkInterval string) (*api.EbpfNetThrottlingConfig, error) + // CreateOrUpdateThrottlingConfig updates the throttling config values + CreateOrUpdateThrottlingConfig(onlineBandwidthWatermark, offlineLowBandwidth, offlineHighBandwidth, checkInterval string) (*api.EbpfNetThrottlingConfig, error) + // DeleteThrottlingConfig deletes the throttling config map + DeleteThrottlingConfig() (err error) + // GetThrottlingConfig gets the throttling config values + GetThrottlingConfig() (*api.EbpfNetThrottlingConfig, error) + // GetThrottlingStatus returns the status of network throttling + GetThrottlingStatus() (*api.EbpfNetThrottling, error) +} + +var _ ThrottlingConfig = &NetworkThrottlingConfig{} + +type NetworkThrottlingConfig struct { + sysFsDir string +} + +var networkThrottlingConfig ThrottlingConfig + +func GetNetworkThrottlingConfig() ThrottlingConfig { + if networkThrottlingConfig == nil { + sfsFsPath := strings.TrimSpace(os.Getenv(agentutils.SysFsPathEnv)) + if sfsFsPath == "" { + sfsFsPath = agentutils.DefaultSysFsPath + } + networkThrottlingConfig = &NetworkThrottlingConfig{ + sysFsDir: sfsFsPath, + } + } + return networkThrottlingConfig +} + +func SetNetworkThrottlingConfig(throttlingConfig ThrottlingConfig) { + networkThrottlingConfig = throttlingConfig +} + +func (w *NetworkThrottlingConfig) CreateThrottlingConfig(onlineBandwidthWatermark, offlineLowBandwidth, offlineHighBandwidth, checkInterval string) (*api.EbpfNetThrottlingConfig, error) { + var onlineBandwidthWatermarkBytes, offlineLowBandwidthBytes, offlineHighBandwidthBytes, intervalUInt uint64 + var err error + + onlineBandwidthWatermarkBytes, err = utils.SizeStrConvertToByteSize(onlineBandwidthWatermark) + if err != nil { + return nil, err + } + + offlineLowBandwidthBytes, err = utils.SizeStrConvertToByteSize(offlineLowBandwidth) + if err != nil { + return nil, err + } + + offlineHighBandwidthBytes, err = utils.SizeStrConvertToByteSize(offlineHighBandwidth) + if err != nil { + return nil, err + } + + intervalUInt, err = strconv.ParseUint(checkInterval, 10, 0) + if err != nil { + return nil, err + } + + config := &api.EbpfNetThrottlingConfig{ + Interval: intervalUInt, + WaterLine: onlineBandwidthWatermarkBytes, + LowRate: offlineLowBandwidthBytes, + HighRate: offlineHighBandwidthBytes, + } + + Len := unsafe.Sizeof(*config) / unsafe.Sizeof(uint64(0)) + testBytes := &sliceStr{ + addr: uintptr(unsafe.Pointer(config)), + cap: int(Len), + len: int(Len), + } + data := *(*[]uint64)(unsafe.Pointer(testBytes)) + err = ebpf.GetEbpfMap().CreateAndPinArrayMap(path.Join(w.sysFsDir, TCEbpfPath), ThrottleConfigMapName, []cilliumbpf.MapKV{ + { + Key: uint32(0), + Value: &data, + }, + }) + + if err != nil { + return nil, err + } + return config, nil +} + +func (w *NetworkThrottlingConfig) CreateOrUpdateThrottlingConfig(onlineBandwidthWatermark, offlineLowBandwidth, offlineHighBandwidth, checkInterval string) (*api.EbpfNetThrottlingConfig, error) { + config, err := w.GetThrottlingConfig() + if err != nil { + if errors.Is(err, cilliumbpf.ErrKeyNotExist) || os.IsNotExist(err) { + return w.CreateThrottlingConfig(onlineBandwidthWatermark, offlineLowBandwidth, offlineHighBandwidth, checkInterval) + } + return nil, err + } + + var onlineBandwidthWatermarkBytes, offlineLowBandwidthBytes, offlineHighBandwidthBytes, intervalUInt uint64 + if onlineBandwidthWatermark != "" { + onlineBandwidthWatermarkBytes, err = utils.SizeStrConvertToByteSize(onlineBandwidthWatermark) + if err != nil { + return nil, err + } + config.WaterLine = onlineBandwidthWatermarkBytes + } + + if offlineLowBandwidth != "" { + offlineLowBandwidthBytes, err = utils.SizeStrConvertToByteSize(offlineLowBandwidth) + if err != nil { + return nil, err + } + config.LowRate = offlineLowBandwidthBytes + } + + if offlineHighBandwidth != "" { + offlineHighBandwidthBytes, err = utils.SizeStrConvertToByteSize(offlineHighBandwidth) + if err != nil { + return nil, err + } + config.HighRate = offlineHighBandwidthBytes + } + + if checkInterval != "" { + intervalUInt, err = strconv.ParseUint(checkInterval, 10, 0) + if err != nil { + return nil, err + } + config.Interval = intervalUInt + } + + Len := unsafe.Sizeof(*config) / unsafe.Sizeof(uint64(0)) + testBytes := &sliceStr{ + addr: uintptr(unsafe.Pointer(config)), + cap: int(Len), + len: int(Len), + } + data := *(*[]uint64)(unsafe.Pointer(testBytes)) + err = ebpf.GetEbpfMap().UpdateMapValue(path.Join(w.sysFsDir, ThrottleConfigMapPinPath), uint32(0), data) + if err != nil { + return nil, err + } + return config, err +} + +func (w *NetworkThrottlingConfig) DeleteThrottlingConfig() (err error) { + err = ebpf.GetEbpfMap().UnpinArrayMap(path.Join(w.sysFsDir, ThrottleConfigMapPinPath)) + if err != nil { + return err + } + _, err = w.GetThrottlingConfig() + if err != nil { + if errors.Is(err, cilliumbpf.ErrKeyNotExist) || os.IsNotExist(err) { + return nil + } + return err + } + return fmt.Errorf("failed to unpin map, config map still existed") +} + +func (w *NetworkThrottlingConfig) GetThrottlingConfig() (*api.EbpfNetThrottlingConfig, error) { + throttlingConfig := make([]uint64, unsafe.Sizeof(api.EbpfNetThrottlingConfig{})/unsafe.Sizeof(uint64(0))) + err := ebpf.GetEbpfMap().LookUpMapValue(path.Join(w.sysFsDir, ThrottleConfigMapPinPath), uint32(0), &throttlingConfig) + if err != nil { + return nil, err + } + + var config *api.EbpfNetThrottlingConfig = *(**api.EbpfNetThrottlingConfig)(unsafe.Pointer(&throttlingConfig)) + return config, nil +} + +func (w *NetworkThrottlingConfig) GetThrottlingStatus() (*api.EbpfNetThrottling, error) { + throttling := make([]uint64, unsafe.Sizeof(api.EbpfNetThrottling{})/unsafe.Sizeof(uint64(0))) + err := ebpf.GetEbpfMap().LookUpMapValue(path.Join(w.sysFsDir, ThrottleStatusMapPinPath), uint32(0), &throttling) + if err != nil { + return nil, err + } + + var edtThrottling *api.EbpfNetThrottling = *(**api.EbpfNetThrottling)(unsafe.Pointer(&throttling)) + return edtThrottling, nil +} diff --git a/pkg/networkqos/throttling/throttling_test.go b/pkg/networkqos/throttling/throttling_test.go new file mode 100644 index 000000000..a4f316793 --- /dev/null +++ b/pkg/networkqos/throttling/throttling_test.go @@ -0,0 +1,444 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package throttling + +import ( + "fmt" + "os" + "path" + "testing" + + cilliumbpf "github.com/cilium/ebpf" + "github.com/golang/mock/gomock" + "github.com/stretchr/testify/assert" + + "volcano.sh/volcano/pkg/networkqos/api" + networkqosbpf "volcano.sh/volcano/pkg/networkqos/utils/ebpf" + mockmap "volcano.sh/volcano/pkg/networkqos/utils/ebpf/mocks" +) + +func TestCreateThrottlingConfig(t *testing.T) { + mockController := gomock.NewController(t) + defer mockController.Finish() + mockEbpfMap := mockmap.NewMockEbpfMap(mockController) + networkqosbpf.SetEbpfMap(mockEbpfMap) + + testCases := []struct { + name string + onlineBandwidthWatermark string + offlineLowBandwidth string + offlineHighBandwidth string + checkInterval string + apiCall []*gomock.Call + expectedThrottlingConfig *api.EbpfNetThrottlingConfig + expectedError bool + }{ + { + name: "case-1", + onlineBandwidthWatermark: "100Mbps", + offlineLowBandwidth: "21Mbps", + offlineHighBandwidth: "55Mbps", + checkInterval: "50000", + apiCall: []*gomock.Call{ + mockEbpfMap.EXPECT().CreateAndPinArrayMap(path.Dir(TCEbpfPath), ThrottleConfigMapName, gomock.Any()).Return(nil), + }, + expectedThrottlingConfig: &api.EbpfNetThrottlingConfig{ + Interval: 50000, + WaterLine: 100 * 1000 * 1000 / 8, + LowRate: 21 * 1000 * 1000 / 8, + HighRate: 55 * 1000 * 1000 / 8, + }, + expectedError: false, + }, + + { + name: "illegal onlineBandwidthWatermark", + onlineBandwidthWatermark: "890M", + offlineLowBandwidth: "456Mbps", + offlineHighBandwidth: "600Mbps", + checkInterval: "5000", + expectedThrottlingConfig: nil, + expectedError: true, + }, + + { + name: "illegal lowBandwidth", + onlineBandwidthWatermark: "580Mbps", + offlineLowBandwidth: "280M", + offlineHighBandwidth: "300Mbps", + checkInterval: "800000", + expectedThrottlingConfig: nil, + expectedError: true, + }, + + { + name: "illegal highBandwidth", + onlineBandwidthWatermark: "50Mbps", + offlineLowBandwidth: "20Mbps", + offlineHighBandwidth: "50M", + checkInterval: "10000000", + expectedThrottlingConfig: nil, + expectedError: true, + }, + + { + name: "illegal intervalUInt", + onlineBandwidthWatermark: "700Mbps", + offlineLowBandwidth: "350Mbps", + offlineHighBandwidth: "400Mbps", + checkInterval: "10000000.0", + expectedThrottlingConfig: nil, + expectedError: true, + }, + + { + name: "create-map-failed", + onlineBandwidthWatermark: "9000Mbps", + offlineLowBandwidth: "3000Mbps", + offlineHighBandwidth: "6000Mbps", + checkInterval: "10000000", + apiCall: []*gomock.Call{ + mockEbpfMap.EXPECT().CreateAndPinArrayMap(path.Dir(TCEbpfPath), ThrottleConfigMapName, gomock.Any()).Return(fmt.Errorf("create map failed")), + }, + expectedThrottlingConfig: nil, + expectedError: true, + }, + } + + for _, tc := range testCases { + throttling := &NetworkThrottlingConfig{} + gomock.InOrder(tc.apiCall...) + actualThrottlingConfig, actualErr := throttling.CreateThrottlingConfig(tc.onlineBandwidthWatermark, tc.offlineLowBandwidth, tc.offlineHighBandwidth, tc.checkInterval) + assert.Equal(t, tc.expectedError, actualErr != nil, tc.name) + assert.Equal(t, tc.expectedThrottlingConfig, actualThrottlingConfig, tc.name) + } +} + +func TestCreateOrUpdateThrottlingConfig(t *testing.T) { + mockController := gomock.NewController(t) + defer mockController.Finish() + mockEbpfMap := mockmap.NewMockEbpfMap(mockController) + networkqosbpf.SetEbpfMap(mockEbpfMap) + throttling := &NetworkThrottlingConfig{} + + testCases := []struct { + name string + onlineBandwidthWatermark string + offlineLowBandwidth string + offlineHighBandwidth string + checkInterval string + apiCall []*gomock.Call + expectedThrottlingConfig *api.EbpfNetThrottlingConfig + expectedError bool + }{ + { + name: "map not exists", + onlineBandwidthWatermark: "50Mbps", + offlineLowBandwidth: "20Mbps", + offlineHighBandwidth: "50Mbps", + checkInterval: "10000000", + apiCall: []*gomock.Call{ + mockEbpfMap.EXPECT().LookUpMapValue(ThrottleConfigMapPinPath, uint32(0), gomock.Any()).Return(cilliumbpf.ErrKeyNotExist), + mockEbpfMap.EXPECT().CreateAndPinArrayMap(path.Dir(TCEbpfPath), ThrottleConfigMapName, gomock.Any()).Return(nil), + }, + expectedThrottlingConfig: &api.EbpfNetThrottlingConfig{ + Interval: 10000000, + WaterLine: 50 * 1000 * 1000 / 8, + LowRate: 20 * 1000 * 1000 / 8, + HighRate: 50 * 1000 * 1000 / 8, + }, + expectedError: false, + }, + + { + name: "pin file not exists", + onlineBandwidthWatermark: "100Mbps", + offlineLowBandwidth: "30Mbps", + offlineHighBandwidth: "60Mbps", + checkInterval: "20000000", + apiCall: []*gomock.Call{ + mockEbpfMap.EXPECT().LookUpMapValue(ThrottleConfigMapPinPath, uint32(0), gomock.Any()).Return(os.ErrNotExist), + mockEbpfMap.EXPECT().CreateAndPinArrayMap(path.Dir(TCEbpfPath), ThrottleConfigMapName, gomock.Any()).Return(nil), + }, + expectedThrottlingConfig: &api.EbpfNetThrottlingConfig{ + Interval: 20000000, + WaterLine: 100 * 1000 * 1000 / 8, + LowRate: 30 * 1000 * 1000 / 8, + HighRate: 60 * 1000 * 1000 / 8, + }, + expectedError: false, + }, + + { + name: "update lowBandwidth value", + offlineLowBandwidth: "150Mbps", + checkInterval: "25000000", + apiCall: []*gomock.Call{ + mockEbpfMap.EXPECT().LookUpMapValue(ThrottleConfigMapPinPath, uint32(0), gomock.Any()).Return(nil), + mockEbpfMap.EXPECT().UpdateMapValue(ThrottleConfigMapPinPath, uint32(0), gomock.Any()).Return(nil), + }, + expectedThrottlingConfig: &api.EbpfNetThrottlingConfig{ + Interval: 25000000, + WaterLine: 0, + LowRate: 150 * 1000 * 1000 / 8, + HighRate: 0, + }, + expectedError: false, + }, + + { + name: "update onlineBandwidthWatermark value", + onlineBandwidthWatermark: "350Mbps", + checkInterval: "30000000", + apiCall: []*gomock.Call{ + // LookUpMapValue returns config map with 0 values + mockEbpfMap.EXPECT().LookUpMapValue(ThrottleConfigMapPinPath, uint32(0), gomock.Any()).Return(nil), + mockEbpfMap.EXPECT().UpdateMapValue(ThrottleConfigMapPinPath, uint32(0), gomock.Any()).Return(nil), + }, + expectedThrottlingConfig: &api.EbpfNetThrottlingConfig{ + Interval: 30000000, + WaterLine: 350 * 1000 * 1000 / 8, + LowRate: 0, + HighRate: 0, + }, + expectedError: false, + }, + + { + name: "update map values", + onlineBandwidthWatermark: "2300Mbps", + offlineLowBandwidth: "800Mbps", + offlineHighBandwidth: "1200Mbps", + checkInterval: "80000000", + apiCall: []*gomock.Call{ + // LookUpMapValue returns config map with 0 values + mockEbpfMap.EXPECT().LookUpMapValue(ThrottleConfigMapPinPath, uint32(0), gomock.Any()).Return(nil), + mockEbpfMap.EXPECT().UpdateMapValue(ThrottleConfigMapPinPath, uint32(0), gomock.Any()).Return(nil), + }, + expectedThrottlingConfig: &api.EbpfNetThrottlingConfig{ + Interval: 80000000, + WaterLine: 2300 * 1000 * 1000 / 8, + LowRate: 800 * 1000 * 1000 / 8, + HighRate: 1200 * 1000 * 1000 / 8, + }, + expectedError: false, + }, + + { + name: "illegal onlineBandwidthWatermark", + onlineBandwidthWatermark: "50M", + offlineLowBandwidth: "330Mbps", + offlineHighBandwidth: "550Mbps", + checkInterval: "70000000", + apiCall: []*gomock.Call{ + // LookUpMapValue returns config map with 0 values + mockEbpfMap.EXPECT().LookUpMapValue(ThrottleConfigMapPinPath, uint32(0), gomock.Any()).Return(nil), + }, + expectedThrottlingConfig: nil, + expectedError: true, + }, + + { + name: "illegal lowBandwidth", + onlineBandwidthWatermark: "200Mbps", + offlineLowBandwidth: "70M", + offlineHighBandwidth: "150Mbps", + checkInterval: "10000000", + apiCall: []*gomock.Call{ + // LookUpMapValue returns config map with 0 values + mockEbpfMap.EXPECT().LookUpMapValue(ThrottleConfigMapPinPath, uint32(0), gomock.Any()).Return(nil), + }, + expectedThrottlingConfig: nil, + expectedError: true, + }, + + { + name: "illegal highBandwidth", + onlineBandwidthWatermark: "50Mbps", + offlineLowBandwidth: "30Mbps", + offlineHighBandwidth: "70M", + checkInterval: "10000000", + apiCall: []*gomock.Call{ + // LookUpMapValue returns config map with 0 values + mockEbpfMap.EXPECT().LookUpMapValue(ThrottleConfigMapPinPath, uint32(0), gomock.Any()).Return(nil), + }, + expectedThrottlingConfig: nil, + expectedError: true, + }, + + { + name: "illegal intervalUInt", + onlineBandwidthWatermark: "2000Mbps", + offlineLowBandwidth: "1000Mbps", + offlineHighBandwidth: "1500Mbps", + checkInterval: "50000000.0", + apiCall: []*gomock.Call{ + // LookUpMapValue returns config map with 0 values + mockEbpfMap.EXPECT().LookUpMapValue(ThrottleConfigMapPinPath, uint32(0), gomock.Any()).Return(nil), + }, + expectedThrottlingConfig: nil, + expectedError: true, + }, + } + + for _, tc := range testCases { + gomock.InOrder(tc.apiCall...) + actualThrottlingConfig, actualErr := throttling.CreateOrUpdateThrottlingConfig(tc.onlineBandwidthWatermark, tc.offlineLowBandwidth, tc.offlineHighBandwidth, tc.checkInterval) + assert.Equal(t, tc.expectedError, actualErr != nil, tc.name) + assert.Equal(t, tc.expectedThrottlingConfig, actualThrottlingConfig, tc.name) + } +} + +func TestDeleteThrottlingConfig(t *testing.T) { + mockController := gomock.NewController(t) + defer mockController.Finish() + ebpfMap := mockmap.NewMockEbpfMap(mockController) + networkqosbpf.SetEbpfMap(ebpfMap) + throttling := &NetworkThrottlingConfig{} + + testCases := []struct { + name string + apiCall []*gomock.Call + expectedError bool + }{ + { + name: "unpin successfully", + apiCall: []*gomock.Call{ + ebpfMap.EXPECT().UnpinArrayMap(ThrottleConfigMapPinPath).Return(nil), + ebpfMap.EXPECT().LookUpMapValue(ThrottleConfigMapPinPath, uint32(0), gomock.Any()).Return(cilliumbpf.ErrKeyNotExist), + }, + expectedError: false, + }, + + { + name: "unpin failed", + apiCall: []*gomock.Call{ + ebpfMap.EXPECT().UnpinArrayMap(ThrottleConfigMapPinPath).Return(fmt.Errorf("unpin failed")), + }, + expectedError: true, + }, + + { + name: "delete failed 1", + apiCall: []*gomock.Call{ + ebpfMap.EXPECT().UnpinArrayMap(ThrottleConfigMapPinPath).Return(nil), + ebpfMap.EXPECT().LookUpMapValue(ThrottleConfigMapPinPath, uint32(0), gomock.Any()).Return(nil), + }, + expectedError: true, + }, + + { + name: "delete failed 2", + apiCall: []*gomock.Call{ + ebpfMap.EXPECT().UnpinArrayMap(ThrottleConfigMapPinPath).Return(nil), + ebpfMap.EXPECT().LookUpMapValue(ThrottleConfigMapPinPath, uint32(0), gomock.Any()).Return(fmt.Errorf("fake error")), + }, + expectedError: true, + }, + } + + for _, tc := range testCases { + gomock.InOrder(tc.apiCall...) + actualErr := throttling.DeleteThrottlingConfig() + assert.Equal(t, tc.expectedError, actualErr != nil, tc.name) + } +} + +func TestGetThrottlingConfig(t *testing.T) { + mockController := gomock.NewController(t) + defer mockController.Finish() + ebpfMap := mockmap.NewMockEbpfMap(mockController) + networkqosbpf.SetEbpfMap(ebpfMap) + throttling := &NetworkThrottlingConfig{} + + testCases := []struct { + name string + apiCall []*gomock.Call + expectedThrottlingConfig *api.EbpfNetThrottlingConfig + expectedError bool + }{ + { + name: "map not exists", + apiCall: []*gomock.Call{ + ebpfMap.EXPECT().LookUpMapValue(ThrottleConfigMapPinPath, uint32(0), gomock.Any()).Return(cilliumbpf.ErrKeyNotExist), + }, + expectedThrottlingConfig: nil, + expectedError: true, + }, + + { + name: "map exists", + apiCall: []*gomock.Call{ + ebpfMap.EXPECT().LookUpMapValue(ThrottleConfigMapPinPath, uint32(0), gomock.Any()).Return(nil), + }, + expectedThrottlingConfig: &api.EbpfNetThrottlingConfig{ + Interval: 0, + WaterLine: 0, + LowRate: 0, + HighRate: 0, + }, + expectedError: false, + }, + } + + for _, tc := range testCases { + gomock.InOrder(tc.apiCall...) + actualThrottlingConfig, actualErr := throttling.GetThrottlingConfig() + assert.Equal(t, tc.expectedError, actualErr != nil, tc.name) + assert.Equal(t, tc.expectedThrottlingConfig, actualThrottlingConfig, tc.name) + } +} + +func TestGetThrottlingStatus(t *testing.T) { + mockController := gomock.NewController(t) + defer mockController.Finish() + ebpfMap := mockmap.NewMockEbpfMap(mockController) + networkqosbpf.SetEbpfMap(ebpfMap) + throttling := &NetworkThrottlingConfig{} + + testCases := []struct { + name string + apiCall []*gomock.Call + expectedThrottlingStatus *api.EbpfNetThrottling + expectedError bool + }{ + { + name: "map not exists", + apiCall: []*gomock.Call{ + ebpfMap.EXPECT().LookUpMapValue(ThrottleStatusMapPinPath, uint32(0), gomock.Any()).Return(cilliumbpf.ErrKeyNotExist), + }, + expectedThrottlingStatus: nil, + expectedError: true, + }, + + { + name: "map exists", + apiCall: []*gomock.Call{ + ebpfMap.EXPECT().LookUpMapValue(ThrottleStatusMapPinPath, uint32(0), gomock.Any()).Return(nil), + }, + expectedThrottlingStatus: &api.EbpfNetThrottling{}, + expectedError: false, + }, + } + + for _, tc := range testCases { + gomock.InOrder(tc.apiCall...) + actualThrottlingStatus, actualErr := throttling.GetThrottlingStatus() + assert.Equal(t, tc.expectedError, actualErr != nil, tc.name) + assert.Equal(t, tc.expectedThrottlingStatus, actualThrottlingStatus, tc.name) + } +} diff --git a/pkg/networkqos/utils/ebpf/map.go b/pkg/networkqos/utils/ebpf/map.go new file mode 100644 index 000000000..6b1f8aa40 --- /dev/null +++ b/pkg/networkqos/utils/ebpf/map.go @@ -0,0 +1,147 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package ebpf + +import ( + "fmt" + "os" + "unsafe" + + "github.com/cilium/ebpf" + + "volcano.sh/volcano/pkg/networkqos/api" +) + +//go:generate mockgen -destination ./mocks/mock_map.go -package mocks -source map.go + +// EbpfMap is an interface of ebpf map options. +type EbpfMap interface { + // CreateAndPinArrayMap create map with default set of key/value data + // only supports map of "array" type, pinning of "pingByName" type + // dir is the base path to pin map + // $dir/$name is the path to pin map + // If the map already existed, + CreateAndPinArrayMap(dir, name string, defaultKV []ebpf.MapKV) (err error) + // UnpinArrayMap removes the persisted state for the map from the BPF virtual filesystem + UnpinArrayMap(pinPath string) (err error) + // LookUpMapValue looks up the value of the key + LookUpMapValue(pinPath string, key, value interface{}) (err error) + // UpdateMapValue updates the value of the key + UpdateMapValue(pinPath string, key, value interface{}) (err error) +} + +type Map struct{} + +var _ EbpfMap = &Map{} + +var ebpfMap EbpfMap + +func GetEbpfMap() EbpfMap { + if ebpfMap == nil { + ebpfMap = &Map{} + } + return ebpfMap +} + +func SetEbpfMap(m EbpfMap) { + ebpfMap = m +} + +func (m *Map) CreateAndPinArrayMap(dir, name string, defaultKV []ebpf.MapKV) (err error) { + err = os.MkdirAll(dir, 0755) + if err != nil { + return err + } + + eMap, err := ebpf.NewMapWithOptions(&ebpf.MapSpec{ + Name: name, + Type: ebpf.Array, + KeySize: uint32(unsafe.Sizeof(uint32(0))), + ValueSize: uint32(unsafe.Sizeof(api.EbpfNetThrottlingConfig{})), + Pinning: ebpf.PinByName, + MaxEntries: 1, + Contents: defaultKV, + }, ebpf.MapOptions{ + PinPath: dir, + }) + if err != nil { + return err + } + defer eMap.Close() + + return nil +} + +func (m *Map) UnpinArrayMap(pinPath string) (err error) { + _, err = os.Stat(pinPath) + if err != nil { + if os.IsNotExist(err) { + return nil + } + return err + } + + eMap, err := ebpf.LoadPinnedMap(pinPath, nil) + if err != nil { + return fmt.Errorf("failed to load pinned map(%s), error %v", pinPath, err) + } + defer eMap.Close() + + if err = eMap.Unpin(); err != nil { + return fmt.Errorf("cannot unpin map %s: %w", pinPath, err) + } + + return nil +} + +func (m *Map) LookUpMapValue(pinPath string, key, value interface{}) (err error) { + _, err = os.Stat(pinPath) + if err != nil { + return err + } + + eMap, err := ebpf.LoadPinnedMap(pinPath, nil) + if err != nil { + return fmt.Errorf("failed to load pinned map(%s), error %v", pinPath, err) + } + defer eMap.Close() + + err = eMap.Lookup(key, value) + if err != nil { + return fmt.Errorf("failed to look up map(%s), error %v, value %+v", pinPath, err, value) + } + return nil +} + +func (m *Map) UpdateMapValue(pinPath string, key, value interface{}) (err error) { + _, err = os.Stat(pinPath) + if err != nil { + return err + } + + eMap, err := ebpf.LoadPinnedMap(pinPath, nil) + if err != nil { + return fmt.Errorf("failed to load pinned map(%s), error %v", pinPath, err) + } + defer eMap.Close() + + err = eMap.Put(key, value) + if err != nil { + return fmt.Errorf("failed to look up map(%s), error %v", pinPath, err) + } + return nil +} diff --git a/pkg/networkqos/utils/ebpf/map_test.go b/pkg/networkqos/utils/ebpf/map_test.go new file mode 100644 index 000000000..95b99e960 --- /dev/null +++ b/pkg/networkqos/utils/ebpf/map_test.go @@ -0,0 +1,79 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package ebpf + +import ( + "fmt" + "os" + "testing" + + "github.com/agiledragon/gomonkey/v2" + "github.com/cilium/ebpf" + "github.com/stretchr/testify/assert" +) + +func TestCreateAndPinArrayMap(t *testing.T) { + createdMap, _ := ebpf.NewMap(&ebpf.MapSpec{}) + testCases := []struct { + name string + dir string + mapName string + mkdirErr error + createdMap *ebpf.Map + createMapErr error + defaultKV []ebpf.MapKV + expectedError error + }{ + { + name: "create map successfully", + dir: "/tmp/test", + mapName: "throttle_cfg", + createdMap: createdMap, + }, + + { + name: "make dir failed", + dir: "/tmp/test", + mapName: "throttle_cfg", + mkdirErr: fmt.Errorf("mkdir failed"), + expectedError: fmt.Errorf("mkdir failed"), + }, + + { + name: "new map failed", + dir: "/tmp/test", + mapName: "throttle_cfg", + createMapErr: fmt.Errorf("new map failed"), + expectedError: fmt.Errorf("new map failed"), + }, + } + + for _, tc := range testCases { + patch := gomonkey.NewPatches() + + patch.ApplyFunc(os.MkdirAll, func(path string, perm os.FileMode) error { + return tc.mkdirErr + }) + patch.ApplyFunc(ebpf.NewMapWithOptions, func(spec *ebpf.MapSpec, opts ebpf.MapOptions) (*ebpf.Map, error) { + return tc.createdMap, tc.createMapErr + }) + + actualErr := GetEbpfMap().CreateAndPinArrayMap(tc.dir, tc.mapName, tc.defaultKV) + patch.Reset() + assert.Equal(t, tc.expectedError, actualErr, tc.name, actualErr) + } +} diff --git a/pkg/networkqos/utils/ebpf/mocks/mock_map.go b/pkg/networkqos/utils/ebpf/mocks/mock_map.go new file mode 100644 index 000000000..ee072972d --- /dev/null +++ b/pkg/networkqos/utils/ebpf/mocks/mock_map.go @@ -0,0 +1,107 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by MockGen. DO NOT EDIT. +// Source: map.go + +// Package mocks is a generated GoMock package. +package mocks + +import ( + reflect "reflect" + + ebpf "github.com/cilium/ebpf" + gomock "github.com/golang/mock/gomock" +) + +// MockEbpfMap is a mock of EbpfMap interface. +type MockEbpfMap struct { + ctrl *gomock.Controller + recorder *MockEbpfMapMockRecorder +} + +// MockEbpfMapMockRecorder is the mock recorder for MockEbpfMap. +type MockEbpfMapMockRecorder struct { + mock *MockEbpfMap +} + +// NewMockEbpfMap creates a new mock instance. +func NewMockEbpfMap(ctrl *gomock.Controller) *MockEbpfMap { + mock := &MockEbpfMap{ctrl: ctrl} + mock.recorder = &MockEbpfMapMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockEbpfMap) EXPECT() *MockEbpfMapMockRecorder { + return m.recorder +} + +// CreateAndPinArrayMap mocks base method. +func (m *MockEbpfMap) CreateAndPinArrayMap(dir, name string, defaultKV []ebpf.MapKV) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateAndPinArrayMap", dir, name, defaultKV) + ret0, _ := ret[0].(error) + return ret0 +} + +// CreateAndPinArrayMap indicates an expected call of CreateAndPinArrayMap. +func (mr *MockEbpfMapMockRecorder) CreateAndPinArrayMap(dir, name, defaultKV interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAndPinArrayMap", reflect.TypeOf((*MockEbpfMap)(nil).CreateAndPinArrayMap), dir, name, defaultKV) +} + +// LookUpMapValue mocks base method. +func (m *MockEbpfMap) LookUpMapValue(pinPath string, key, value interface{}) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LookUpMapValue", pinPath, key, value) + ret0, _ := ret[0].(error) + return ret0 +} + +// LookUpMapValue indicates an expected call of LookUpMapValue. +func (mr *MockEbpfMapMockRecorder) LookUpMapValue(pinPath, key, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LookUpMapValue", reflect.TypeOf((*MockEbpfMap)(nil).LookUpMapValue), pinPath, key, value) +} + +// UnpinArrayMap mocks base method. +func (m *MockEbpfMap) UnpinArrayMap(pinPath string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UnpinArrayMap", pinPath) + ret0, _ := ret[0].(error) + return ret0 +} + +// UnpinArrayMap indicates an expected call of UnpinArrayMap. +func (mr *MockEbpfMapMockRecorder) UnpinArrayMap(pinPath interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnpinArrayMap", reflect.TypeOf((*MockEbpfMap)(nil).UnpinArrayMap), pinPath) +} + +// UpdateMapValue mocks base method. +func (m *MockEbpfMap) UpdateMapValue(pinPath string, key, value interface{}) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateMapValue", pinPath, key, value) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpdateMapValue indicates an expected call of UpdateMapValue. +func (mr *MockEbpfMapMockRecorder) UpdateMapValue(pinPath, key, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMapValue", reflect.TypeOf((*MockEbpfMap)(nil).UpdateMapValue), pinPath, key, value) +} diff --git a/pkg/networkqos/utils/utils.go b/pkg/networkqos/utils/utils.go new file mode 100644 index 000000000..5b81efc46 --- /dev/null +++ b/pkg/networkqos/utils/utils.go @@ -0,0 +1,147 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package utils + +import ( + "flag" + "fmt" + "io" + "os" + "strconv" + "strings" + "unicode" + + "github.com/spf13/cobra" + "k8s.io/klog/v2" +) + +const ( + Kbps = 1000 + Mbps = 1000 * 1000 + Gbps = 1000 * 1000 * 1000 + Tbps = 1000 * 1000 * 1000 * 1000 + + Kibps = 1024 + Mibps = 1024 * 1024 + Gibps = 1024 * 1024 * 1024 + Tibps = 1024 * 1024 * 1024 * 1024 +) + +const ( + TCPROGPath = "/usr/share/bwmcli/bwm_tc.o" + CNILogFilePath = "/var/log/volcano/agent/network-qos.log" + ToolCmdLogFilePath = "/var/log/volcano/agent/network-qos-tools.log" + NetWorkCmdFile = "/usr/local/bin/network-qos" + DefaultCNIConfFile = "/etc/cni/net.d/cni.conflist" +) + +const ( + OnlineBandwidthWatermarkKey = "online-bandwidth-watermark" + OfflineLowBandwidthKey = "offline-low-bandwidth" + OfflineHighBandwidthKey = "offline-high-bandwidth" + NetWorkQoSCheckInterval = "check-interval" + NodeColocationEnable = "colocation" + EnableNetworkQoS = "enable-network-qos" + CNIPluginName = "network-qos" +) + +const ( + OpenEulerOSReleaseName = "openEuler" + OpenEulerOSReleaseVersion = "22.03 (LTS-SP2)" + + // HostOSReleasePathEnv presents the key for env of host os release file + HostOSReleasePathEnv = "HOST_OS_RELEASE" + + DefaultNodeOSReleasePath = "/host/etc/os-release" + NetworkQoSPath = "/opt/cni/bin/network-qos" +) + +const ( + DefaultInterval = "10000000" // 1000000 纳秒 = 10 毫秒 +) + +const ( + // CNIConfFilePathEnv presents the key for env of cni con file + CNIConfFilePathEnv = "CNI_CONF_FILE_PATH" +) + +func InitLog(logPath string) error { + klog.InitFlags(nil) + if err := flag.Set("log_file", logPath); err != nil { + return fmt.Errorf("failed fo set flag(log_file): %v\n", err) + } + if err := flag.Set("logtostderr", "false"); err != nil { + return fmt.Errorf("failed fo set flag(logtostderr): %v\n", err) + } + if err := flag.Set("alsologtostderr", "false"); err != nil { + return fmt.Errorf("failed fo set flag(alsologtostderr): %v\n", err) + } + if err := flag.Set("skip_log_headers", "true"); err != nil { + return fmt.Errorf("failed fo set flag(skip_log_headers): %v\n", err) + } + if err := flag.Set("stderrthreshold", "3"); err != nil { + return fmt.Errorf("failed fo set flag(stderrthreshold): %v\n", err) + } + if err := flag.Set("v", "4"); err != nil { + return fmt.Errorf("failed fo set flag(v): %v\n", err) + } + flag.Parse() + return nil +} + +func SizeStrConvertToByteSize(sizeStr string) (uint64, error) { + sizeStr = strings.TrimSpace(sizeStr) + index := strings.IndexFunc(sizeStr, unicode.IsLetter) + if index == -1 { + index = len(sizeStr) + } + + unit := sizeStr[index:] + num := sizeStr[:index] + numInt, err := strconv.ParseUint(num, 10, 0) + if err != nil { + return 0, fmt.Errorf("size string %s is illegal, only supprt positive integer with unit like Kbps, Mbps, Gbps, Tbps: %v", sizeStr, err) + } + + switch unit { + case "Kbps", "": + return numInt * Kbps / 8, nil + case "Mbps": + return numInt * Mbps / 8, nil + case "Gbps": + return numInt * Gbps / 8, nil + case "Tbps": + return numInt * Tbps / 8, nil + case "Kibps": + return numInt * Kibps / 8, nil + case "Mibps": + return numInt * Mibps / 8, nil + case "Gibps": + return numInt * Gibps / 8, nil + case "Tibps": + return numInt * Tibps / 8, nil + default: + return 0, fmt.Errorf("size %s is illegal, only supprt positive integer with unit like Kbps, Mbps, Gbps, Tbps", sizeStr) + } +} + +func Error(errOut io.Writer, cmd *cobra.Command, err error) { + fmt.Fprintf(errOut, "execute command[%s] failed, error:%v\n", cmd.Name(), err) + klog.ErrorS(err, "Network QoS command called failed", "command", cmd.Name()) + klog.Flush() + os.Exit(1) +} diff --git a/pkg/networkqos/utils/utils_test.go b/pkg/networkqos/utils/utils_test.go new file mode 100644 index 000000000..d7245f79b --- /dev/null +++ b/pkg/networkqos/utils/utils_test.go @@ -0,0 +1,106 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package utils + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestSizeStrConvertToByteSize(t *testing.T) { + testCases := []struct { + name string + sizeStr string + + expectedSize uint64 + expectedError bool + }{ + + { + name: "Kbps", + sizeStr: "10Kbps", + expectedSize: 10 * 1000 / 8, + expectedError: false, + }, + { + name: "Kibps", + sizeStr: "100Kibps", + expectedSize: 100 * 1024 / 8, + expectedError: false, + }, + + { + name: "Mbps", + sizeStr: "100Mbps", + expectedSize: 100 * 1000 * 1000 / 8, + expectedError: false, + }, + { + name: "Mibps", + sizeStr: "1000Mibps", + expectedSize: 1000 * 1024 * 1024 / 8, + expectedError: false, + }, + + { + name: "Gbps", + sizeStr: "20Gbps", + expectedSize: 20 * 1000 * 1000 * 1000 / 8, + expectedError: false, + }, + { + name: "Gibps", + sizeStr: "200Gibps", + expectedSize: 200 * 1024 * 1024 * 1024 / 8, + expectedError: false, + }, + + { + name: "Tbps", + sizeStr: "20Tbps", + expectedSize: 20 * 1000 * 1000 * 1000 * 1000 / 8, + expectedError: false, + }, + + { + name: "Tibps", + sizeStr: "200Tibps", + expectedSize: 200 * 1024 * 1024 * 1024 * 1024 / 8, + expectedError: false, + }, + + { + name: "illegal unit", + sizeStr: "100000FAKE", + expectedSize: 0, + expectedError: true, + }, + + { + name: "illegal numbers", + sizeStr: "100000.23Mbps", + expectedSize: 0, + expectedError: true, + }, + } + for _, tc := range testCases { + actualSize, actualErr := SizeStrConvertToByteSize(tc.sizeStr) + assert.Equal(t, tc.expectedSize, actualSize, tc.name) + assert.Equal(t, tc.expectedError, actualErr != nil, tc.name) + } +} diff --git a/pkg/resourceusage/fake_resource_usage_getter.go b/pkg/resourceusage/fake_resource_usage_getter.go new file mode 100644 index 000000000..530ab9f57 --- /dev/null +++ b/pkg/resourceusage/fake_resource_usage_getter.go @@ -0,0 +1,49 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package resourceusage + +import v1 "k8s.io/api/core/v1" + +type fakeResourceGetter struct { + cpuUsageByValue int64 + memoryUsageByValue int64 + cpuUsageByPercent int64 + memoryUsageByPercent int64 +} + +func NewFakeResourceGetter(cpuUsageByValue, memoryUsageByValue, cpuUsageByPercent, memoryUsageByPercent int64) Getter { + return &fakeResourceGetter{ + cpuUsageByValue: cpuUsageByValue, + memoryUsageByValue: memoryUsageByValue, + cpuUsageByPercent: cpuUsageByPercent, + memoryUsageByPercent: memoryUsageByPercent, + } +} + +func (f *fakeResourceGetter) UsagesByValue(_ bool) Resource { + return map[v1.ResourceName]int64{ + v1.ResourceCPU: f.cpuUsageByValue, + v1.ResourceMemory: f.memoryUsageByValue, + } +} + +func (f *fakeResourceGetter) UsagesByPercentage(node *v1.Node) Resource { + return map[v1.ResourceName]int64{ + v1.ResourceCPU: f.cpuUsageByPercent, + v1.ResourceMemory: f.memoryUsageByPercent, + } +} diff --git a/pkg/resourceusage/resource_usage_getter.go b/pkg/resourceusage/resource_usage_getter.go new file mode 100644 index 000000000..65d58fcc4 --- /dev/null +++ b/pkg/resourceusage/resource_usage_getter.go @@ -0,0 +1,121 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package resourceusage + +import ( + "time" + + "github.com/prometheus/prometheus/prompb" + v1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/klog/v2" + + "volcano.sh/volcano/pkg/metriccollect" + "volcano.sh/volcano/pkg/metriccollect/local" +) + +// Resource include the overSubscription resource on this node +type Resource map[v1.ResourceName]int64 + +// Getter is used to get cpu/memory usage of current node. +type Getter interface { + // UsagesByValue return absolute resource usage of node + UsagesByValue(includeGuaranteedPods bool) Resource + // UsagesByPercentage return resource usage percentage of node + UsagesByPercentage(node *v1.Node) Resource +} + +// getter implements Getter. +type getter struct { + collectorName string + collector *metriccollect.MetricCollectorManager +} + +// NewUsageGetter create a usage getter +func NewUsageGetter(mgr *metriccollect.MetricCollectorManager, collectorName string) Getter { + g := &getter{ + collectorName: collectorName, + collector: mgr, + } + return g +} + +// UsagesByValue return absolute resource usage of node +func (g *getter) UsagesByValue(includeGuaranteedPods bool) Resource { + return g.commonUsage(includeGuaranteedPods) +} + +// UsagesByPercentage return resource usage percentage of node +func (g *getter) UsagesByPercentage(node *v1.Node) Resource { + res := make(Resource) + usage := g.commonUsage(true) + + cpuAllocatable := node.Status.Allocatable[v1.ResourceCPU] + memoryAllocatable := node.Status.Allocatable[v1.ResourceMemory] + cpuTotal := cpuAllocatable.MilliValue() + memoryTotal := memoryAllocatable.Value() + + if cpuTotal == 0 || memoryTotal == 0 { + klog.ErrorS(nil, "Failed to get total resource of cpu or memory") + return res + } + + res[v1.ResourceCPU] = usage[v1.ResourceCPU] * 100 / cpuTotal + res[v1.ResourceMemory] = usage[v1.ResourceMemory] * 100 / memoryTotal + + return res +} + +func (g *getter) convertMetric(metric []*prompb.TimeSeries) int64 { + ret := int64(0) + if len(metric) == 0 { + return ret + } + for _, ts := range metric { + for _, value := range ts.Samples { + ret += int64(value.Value) + } + } + return ret +} + +func (g *getter) commonUsage(includeGuaranteedPods bool) Resource { + res := make(Resource) + c, err := g.collector.GetPluginByName(g.collectorName) + if err != nil { + klog.ErrorS(err, "Failed to collector plugin", "name", local.CollectorName) + return res + } + + includeSystemUsed := g.collector.Config.GenericConfiguration.IncludeSystemUsage + metricInfos := map[v1.ResourceName]*local.LocalMetricInfo{ + v1.ResourceCPU: {ResourceType: "cpu", IncludeGuaranteedPods: includeGuaranteedPods, IncludeSystemUsed: includeSystemUsed}, + v1.ResourceMemory: {ResourceType: "memory", IncludeSystemUsed: includeSystemUsed}, + } + + for resType, metricInfo := range metricInfos { + metric, err := c.CollectMetrics(metricInfo, time.Time{}, metav1.Duration{}) + if err != nil { + klog.ErrorS(err, "Failed to collector cpu metric", "resType", resType) + continue + } + sumUsage := g.convertMetric(metric) + res[resType] = sumUsage + } + + return res +} diff --git a/pkg/resourceusage/resource_usage_getter_test.go b/pkg/resourceusage/resource_usage_getter_test.go new file mode 100644 index 000000000..6f7e3a02b --- /dev/null +++ b/pkg/resourceusage/resource_usage_getter_test.go @@ -0,0 +1,118 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package resourceusage + +import ( + "reflect" + "testing" + + "github.com/stretchr/testify/assert" + v1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/resource" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + + "volcano.sh/volcano/pkg/agent/utils/cgroup" + "volcano.sh/volcano/pkg/config" + "volcano.sh/volcano/pkg/metriccollect" + fakecollector "volcano.sh/volcano/pkg/metriccollect/testing" +) + +func Test_getter_UsagesByValue(t *testing.T) { + cfg := &config.Configuration{GenericConfiguration: &config.VolcanoAgentConfiguration{IncludeSystemUsage: false}} + collector, err := metriccollect.NewMetricCollectorManager(cfg, &cgroup.CgroupManagerImpl{}) + assert.NoError(t, err) + tests := []struct { + name string + collector *metriccollect.MetricCollectorManager + includeGuaranteedPods bool + want Resource + }{ + { + name: "include guaranteed pods", + includeGuaranteedPods: true, + collector: collector, + want: map[v1.ResourceName]int64{ + v1.ResourceCPU: int64(1000), + v1.ResourceMemory: int64(2000), + }, + }, + { + name: "not include guaranteed pods", + includeGuaranteedPods: false, + collector: collector, + want: map[v1.ResourceName]int64{ + v1.ResourceCPU: int64(1000), + v1.ResourceMemory: int64(2000), + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + g := &getter{ + collectorName: fakecollector.CollectorName, + collector: tt.collector, + } + if got := g.UsagesByValue(tt.includeGuaranteedPods); !reflect.DeepEqual(got, tt.want) { + t.Errorf("UsagesByValue() = %v, want %v", got, tt.want) + } + }) + } +} + +func Test_getter_UsagesByPercentage(t *testing.T) { + cfg := &config.Configuration{GenericConfiguration: &config.VolcanoAgentConfiguration{IncludeSystemUsage: false}} + collector, err := metriccollect.NewMetricCollectorManager(cfg, &cgroup.CgroupManagerImpl{}) + assert.NoError(t, err) + tests := []struct { + name string + node *v1.Node + collector *metriccollect.MetricCollectorManager + want Resource + }{ + { + name: "get usage percent correctly", + collector: collector, + node: makeNode(), + want: map[v1.ResourceName]int64{ + v1.ResourceCPU: 20, + v1.ResourceMemory: 40, + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + g := &getter{ + collectorName: fakecollector.CollectorName, + collector: tt.collector, + } + assert.Equalf(t, tt.want, g.UsagesByPercentage(tt.node), "UsagesByPercentage(%v)", tt.node) + }) + } +} + +func makeNode() *v1.Node { + return &v1.Node{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test-node", + }, + Status: v1.NodeStatus{Allocatable: v1.ResourceList{ + v1.ResourceCPU: *resource.NewMilliQuantity(5000, resource.DecimalSI), + v1.ResourceMemory: *resource.NewQuantity(5000, resource.DecimalSI), + }}, + } +} From 5c60bf80627297e46cb51300e7cb60e89f2dee2c Mon Sep 17 00:00:00 2001 From: william-wang Date: Thu, 10 Oct 2024 16:06:36 +0800 Subject: [PATCH 2/3] Add volcano agent handle&probe Signed-off-by: william-wang --- cmd/agent/app/agent.go | 2 + pkg/agent/events/eventsmgr.go | 11 + pkg/agent/events/handlers/base/base.go | 72 +++++ .../handlers/cpuburst/cpu_burst_linux.go | 177 +++++++++++ .../handlers/cpuburst/cpu_burst_linux_test.go | 264 ++++++++++++++++ pkg/agent/events/handlers/cpuburst/types.go | 24 ++ .../events/handlers/cpuqos/cpuqos_linux.go | 80 +++++ .../handlers/cpuqos/cpuqos_linux_test.go | 87 ++++++ .../events/handlers/eviction/eviction.go | 115 +++++++ .../events/handlers/eviction/eviction_test.go | 135 ++++++++ .../handlers/memoryqos/memoryqos_linux.go | 81 +++++ .../memoryqos/memoryqos_linux_test.go | 131 ++++++++ .../handlers/networkqos/networkqos_linux.go | 135 ++++++++ .../networkqos/networkqos_linux_test.go | 154 ++++++++++ .../oversubscription/resource_reporter.go | 151 +++++++++ .../resource_reporter_test.go | 254 +++++++++++++++ .../events/handlers/resources/resources.go | 100 ++++++ .../handlers/resources/resources_test.go | 184 +++++++++++ .../events/probes/nodemonitor/node_monitor.go | 202 ++++++++++++ .../probes/nodemonitor/node_monitor_test.go | 151 +++++++++ .../noderesources/resource_calculator.go | 169 ++++++++++ .../noderesources/resource_calculator_test.go | 288 ++++++++++++++++++ pkg/agent/events/probes/pods/pods.go | 86 ++++++ .../oversubscription/policy/extend/extend.go | 152 +++++++++ pkg/agent/oversubscription/policy/policy.go | 159 ++++++++++ .../oversubscription/queue/internal_queue.go | 57 ++++ pkg/agent/utils/eviction/eviction.go | 60 ++-- pkg/agent/utils/pod/pod.go | 2 +- pkg/agent/utils/pod/resources.go | 6 + pkg/agent/utils/pod/resources_test.go | 44 +++ pkg/agent/utils/utils.go | 18 ++ 31 files changed, 3533 insertions(+), 18 deletions(-) create mode 100644 pkg/agent/events/handlers/base/base.go create mode 100644 pkg/agent/events/handlers/cpuburst/cpu_burst_linux.go create mode 100644 pkg/agent/events/handlers/cpuburst/cpu_burst_linux_test.go create mode 100644 pkg/agent/events/handlers/cpuburst/types.go create mode 100644 pkg/agent/events/handlers/cpuqos/cpuqos_linux.go create mode 100644 pkg/agent/events/handlers/cpuqos/cpuqos_linux_test.go create mode 100644 pkg/agent/events/handlers/eviction/eviction.go create mode 100644 pkg/agent/events/handlers/eviction/eviction_test.go create mode 100644 pkg/agent/events/handlers/memoryqos/memoryqos_linux.go create mode 100644 pkg/agent/events/handlers/memoryqos/memoryqos_linux_test.go create mode 100644 pkg/agent/events/handlers/networkqos/networkqos_linux.go create mode 100644 pkg/agent/events/handlers/networkqos/networkqos_linux_test.go create mode 100644 pkg/agent/events/handlers/oversubscription/resource_reporter.go create mode 100644 pkg/agent/events/handlers/oversubscription/resource_reporter_test.go create mode 100644 pkg/agent/events/handlers/resources/resources.go create mode 100644 pkg/agent/events/handlers/resources/resources_test.go create mode 100644 pkg/agent/events/probes/nodemonitor/node_monitor.go create mode 100644 pkg/agent/events/probes/nodemonitor/node_monitor_test.go create mode 100644 pkg/agent/events/probes/noderesources/resource_calculator.go create mode 100644 pkg/agent/events/probes/noderesources/resource_calculator_test.go create mode 100644 pkg/agent/events/probes/pods/pods.go create mode 100644 pkg/agent/oversubscription/policy/extend/extend.go create mode 100644 pkg/agent/oversubscription/policy/policy.go create mode 100644 pkg/agent/oversubscription/queue/internal_queue.go diff --git a/cmd/agent/app/agent.go b/cmd/agent/app/agent.go index 5abd210a4..d9fbc1244 100644 --- a/cmd/agent/app/agent.go +++ b/cmd/agent/app/agent.go @@ -35,6 +35,8 @@ import ( "volcano.sh/volcano/pkg/agent/utils/cgroup" "volcano.sh/volcano/pkg/metriccollect" "volcano.sh/volcano/pkg/networkqos" + + _ "volcano.sh/volcano/pkg/agent/oversubscription/policy/extend" ) func NewVolcanoAgentCommand(ctx context.Context) *cobra.Command { diff --git a/pkg/agent/events/eventsmgr.go b/pkg/agent/events/eventsmgr.go index 4d97bb082..3ac0f93f6 100644 --- a/pkg/agent/events/eventsmgr.go +++ b/pkg/agent/events/eventsmgr.go @@ -28,6 +28,17 @@ import ( "volcano.sh/volcano/pkg/agent/utils/cgroup" "volcano.sh/volcano/pkg/config" "volcano.sh/volcano/pkg/metriccollect" + + _ "volcano.sh/volcano/pkg/agent/events/handlers/cpuburst" + _ "volcano.sh/volcano/pkg/agent/events/handlers/cpuqos" + _ "volcano.sh/volcano/pkg/agent/events/handlers/eviction" + _ "volcano.sh/volcano/pkg/agent/events/handlers/memoryqos" + _ "volcano.sh/volcano/pkg/agent/events/handlers/networkqos" + _ "volcano.sh/volcano/pkg/agent/events/handlers/oversubscription" + _ "volcano.sh/volcano/pkg/agent/events/handlers/resources" + _ "volcano.sh/volcano/pkg/agent/events/probes/nodemonitor" + _ "volcano.sh/volcano/pkg/agent/events/probes/noderesources" + _ "volcano.sh/volcano/pkg/agent/events/probes/pods" ) type EventManager struct { diff --git a/pkg/agent/events/handlers/base/base.go b/pkg/agent/events/handlers/base/base.go new file mode 100644 index 000000000..4ecf8f1c6 --- /dev/null +++ b/pkg/agent/events/handlers/base/base.go @@ -0,0 +1,72 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package base + +import ( + "errors" + "sync" + + "k8s.io/klog/v2" + + "volcano.sh/volcano/pkg/agent/config/api" + "volcano.sh/volcano/pkg/agent/features" + "volcano.sh/volcano/pkg/config" +) + +type BaseHandle struct { + Name string + Lock sync.RWMutex + Config *config.Configuration + Active bool +} + +func (h *BaseHandle) HandleName() string { + return h.Name +} + +func (h *BaseHandle) IsActive() bool { + h.Lock.Lock() + defer h.Lock.Unlock() + return h.Active +} + +func (h *BaseHandle) Handle(event interface{}) error { + return errors.New("unimplemented") +} + +func (h *BaseHandle) RefreshCfg(cfg *api.ColocationConfig) error { + h.Lock.Lock() + defer h.Lock.Unlock() + + isActive, err := features.DefaultFeatureGate.Enabled(features.Feature(h.HandleName()), cfg) + if err != nil { + return err + } + + if isActive { + if supportErr := features.DefaultFeatureGate.Supported(features.Feature(h.HandleName()), h.Config); supportErr != nil { + return supportErr + } + } + + if h.Active != isActive { + klog.InfoS("Event handler config changes", "handle", h.HandleName(), "nodeColocation", *cfg.NodeLabelConfig.NodeColocationEnable, + "nodeOverSubscription", *cfg.NodeLabelConfig.NodeOverSubscriptionEnable, "old", h.Active, "new", isActive) + } + h.Active = isActive + return nil +} diff --git a/pkg/agent/events/handlers/cpuburst/cpu_burst_linux.go b/pkg/agent/events/handlers/cpuburst/cpu_burst_linux.go new file mode 100644 index 000000000..06acce4d3 --- /dev/null +++ b/pkg/agent/events/handlers/cpuburst/cpu_burst_linux.go @@ -0,0 +1,177 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package cpuburst + +import ( + "errors" + "fmt" + "io/fs" + "os" + "path/filepath" + "strconv" + + corev1 "k8s.io/api/core/v1" + v1 "k8s.io/client-go/informers/core/v1" + "k8s.io/klog/v2" + + "volcano.sh/volcano/pkg/agent/events/framework" + "volcano.sh/volcano/pkg/agent/events/handlers" + "volcano.sh/volcano/pkg/agent/events/handlers/base" + "volcano.sh/volcano/pkg/agent/features" + "volcano.sh/volcano/pkg/agent/utils" + "volcano.sh/volcano/pkg/agent/utils/cgroup" + "volcano.sh/volcano/pkg/agent/utils/file" + "volcano.sh/volcano/pkg/config" + "volcano.sh/volcano/pkg/metriccollect" +) + +func init() { + handlers.RegisterEventHandleFunc(string(framework.PodEventName), NewCPUBurst) +} + +type CPUBurstHandle struct { + *base.BaseHandle + cgroupMgr cgroup.CgroupManager + podInformer v1.PodInformer +} + +func NewCPUBurst(config *config.Configuration, mgr *metriccollect.MetricCollectorManager, cgroupMgr cgroup.CgroupManager) framework.Handle { + return &CPUBurstHandle{ + BaseHandle: &base.BaseHandle{ + Name: string(features.CPUBurstFeature), + Config: config, + }, + cgroupMgr: cgroupMgr, + podInformer: config.InformerFactory.K8SInformerFactory.Core().V1().Pods(), + } +} + +func (c *CPUBurstHandle) Handle(event interface{}) error { + podEvent, ok := event.(framework.PodEvent) + if !ok { + return fmt.Errorf("illegal pod event") + } + pod := podEvent.Pod + latestPod, err := c.podInformer.Lister().Pods(pod.Namespace).Get(pod.Name) + if err != nil { + klog.ErrorS(err, "Failed to get pod from lister") + } else { + pod = latestPod + } + str, exists := pod.Annotations[EnabledKey] + if !exists { + return nil + } + enable, err := strconv.ParseBool(str) + if err != nil || !enable { + return nil + } + + cgroupPath, err := c.cgroupMgr.GetPodCgroupPath(podEvent.QoSClass, cgroup.CgroupCpuSubsystem, podEvent.UID) + if err != nil { + return fmt.Errorf("failed to get pod cgroup file(%s), error: %v", podEvent.UID, err) + } + + quotaBurstTime := getCPUBurstTime(pod) + podBurstTime := int64(0) + err = filepath.WalkDir(cgroupPath, walkFunc(cgroupPath, quotaBurstTime, &podBurstTime)) + if err != nil { + return fmt.Errorf("failed to set container cpu quota burst time, err: %v", err) + } + + // last set pod cgroup cpu quota burst. + podQuotaTotalFile := filepath.Join(cgroupPath, cgroup.CPUQuotaTotalFile) + value, err := file.ReadIntFromFile(podQuotaTotalFile) + if err != nil { + return fmt.Errorf("failed to get pod cpu total quota time, err: %v,path: %s", err, podQuotaTotalFile) + } + if value == fixedQuotaValue { + return nil + } + podQuotaBurstFile := filepath.Join(cgroupPath, cgroup.CPUQuotaBurstFile) + err = utils.UpdateFile(podQuotaBurstFile, []byte(strconv.FormatInt(podBurstTime, 10))) + if err != nil { + if errors.Is(err, os.ErrNotExist) { + klog.ErrorS(nil, "CPU Burst is not supported", "cgroupFile", podQuotaBurstFile) + return nil + } + return err + } + + klog.InfoS("Successfully set pod cpu quota burst time", "path", podQuotaBurstFile, "quotaBurst", podBurstTime, "pod", klog.KObj(pod)) + return nil +} + +func walkFunc(cgroupPath string, quotaBurstTime int64, podBurstTime *int64) fs.WalkDirFunc { + return func(path string, d fs.DirEntry, err error) error { + if err != nil { + return err + } + // We will set pod cgroup later. + if path == cgroupPath { + return nil + } + if d == nil || !d.IsDir() { + return nil + } + quotaTotalFile := filepath.Join(path, cgroup.CPUQuotaTotalFile) + quotaTotal, err := file.ReadIntFromFile(quotaTotalFile) + if err != nil { + return fmt.Errorf("failed to get container cpu total quota time, err: %v, path: %s", err, quotaTotalFile) + } + if quotaTotal == fixedQuotaValue { + return nil + } + + actualBurst := quotaBurstTime + if quotaBurstTime > quotaTotal { + klog.ErrorS(nil, "The quota burst time is greater than quota total, use quota total as burst time", "quotaBurst", quotaBurstTime, "quoTotal", quotaTotal) + actualBurst = quotaTotal + } + if quotaBurstTime == 0 { + actualBurst = quotaTotal + } + *podBurstTime += actualBurst + quotaBurstFile := filepath.Join(path, cgroup.CPUQuotaBurstFile) + err = utils.UpdateFile(quotaBurstFile, []byte(strconv.FormatInt(actualBurst, 10))) + if err != nil { + if errors.Is(err, os.ErrNotExist) { + klog.ErrorS(nil, "CPU Burst is not supported", "cgroupFile", quotaBurstFile) + return nil + } + return err + } + + klog.InfoS("Successfully set container cpu burst time", "path", quotaBurstFile, "quotaTotal", quotaTotal, "quotaBurst", actualBurst) + return nil + } +} + +func getCPUBurstTime(pod *corev1.Pod) int64 { + var quotaBurstTime int64 + str, exists := pod.Annotations[QuotaTimeKey] + if !exists { + return quotaBurstTime + } + value, err := strconv.ParseInt(str, 10, 64) + if err != nil || value <= 0 { + klog.ErrorS(err, "Invalid quota burst time, use default containers' quota time", "value", str) + return quotaBurstTime + } + quotaBurstTime = int64(value) + return quotaBurstTime +} diff --git a/pkg/agent/events/handlers/cpuburst/cpu_burst_linux_test.go b/pkg/agent/events/handlers/cpuburst/cpu_burst_linux_test.go new file mode 100644 index 000000000..18bc2178b --- /dev/null +++ b/pkg/agent/events/handlers/cpuburst/cpu_burst_linux_test.go @@ -0,0 +1,264 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package cpuburst + +import ( + "os" + "path" + "testing" + + "github.com/stretchr/testify/assert" + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/client-go/informers" + "k8s.io/client-go/kubernetes/fake" + "volcano.sh/volcano/pkg/agent/events/framework" + "volcano.sh/volcano/pkg/agent/utils/cgroup" + "volcano.sh/volcano/pkg/agent/utils/file" +) + +func TestCPUBurstHandle_Handle(t *testing.T) { + tmpDir := t.TempDir() + tests := []struct { + name string + event interface{} + cgroupMgr cgroup.CgroupManager + prepare func() + post func() map[string]string + wantErr bool + wantVal map[string]string + }{ + { + name: "not support cpu burst, return no err", + event: framework.PodEvent{ + UID: "fake-id1", + QoSLevel: 0, + QoSClass: "", + Pod: getPod("100000", "true"), + }, + cgroupMgr: cgroup.NewCgroupManager("cgroupfs", tmpDir, ""), + + prepare: func() { + prepare(t, tmpDir, "fake-id1", []info{ + {path: cgroup.CPUQuotaTotalFile, value: "100000"}, + }) + }, + wantErr: false, + }, + { + name: "quota=-1, no need set, return no err", + event: framework.PodEvent{ + UID: "fake-id2", + QoSLevel: 0, + QoSClass: "", + Pod: getPod("100000", "true"), + }, + cgroupMgr: cgroup.NewCgroupManager("cgroupfs", tmpDir, ""), + prepare: func() { + prepare(t, tmpDir, "fake-id2", []info{ + {path: cgroup.CPUQuotaBurstFile, value: "0"}, + {path: cgroup.CPUQuotaTotalFile, value: "-1"}}) + }, + wantErr: false, + }, + { + name: "one container quota=100000, another quota=-1, set quota burst successfully", + event: framework.PodEvent{ + UID: "fake-id3", + QoSLevel: 0, + QoSClass: "", + Pod: getPod("50000", "true"), + }, + cgroupMgr: cgroup.NewCgroupManager("cgroupfs", tmpDir, ""), + prepare: func() { + prepare(t, tmpDir, "fake-id3", []info{ + {path: cgroup.CPUQuotaBurstFile, value: "0"}, + {path: cgroup.CPUQuotaTotalFile, value: "100000"}, + {dir: "container1", path: cgroup.CPUQuotaBurstFile, value: "0"}, + {dir: "container1", path: cgroup.CPUQuotaTotalFile, value: "100000"}, + {dir: "container2", path: cgroup.CPUQuotaBurstFile, value: "0"}, + {dir: "container2", path: cgroup.CPUQuotaTotalFile, value: "-1"}, + }) + }, + post: func() map[string]string { + return file.ReadBatchFromFile([]string{ + path.Join(tmpDir, "cpu/kubepods/podfake-id3/cpu.cfs_burst_us"), + path.Join(tmpDir, "cpu/kubepods/podfake-id3/container1/cpu.cfs_burst_us"), + path.Join(tmpDir, "cpu/kubepods/podfake-id3/container2/cpu.cfs_burst_us"), + }) + }, + wantErr: false, + wantVal: map[string]string{ + path.Join(tmpDir, "cpu/kubepods/podfake-id3/cpu.cfs_burst_us"): "50000", + path.Join(tmpDir, "cpu/kubepods/podfake-id3/container1/cpu.cfs_burst_us"): "50000", + path.Join(tmpDir, "cpu/kubepods/podfake-id3/container2/cpu.cfs_burst_us"): "0", + }, + }, + { + name: "quota burst < one container's quota, set min quota burst", + event: framework.PodEvent{ + UID: "fake-id4", + QoSLevel: 0, + QoSClass: "", + Pod: getPod("100000", "true"), + }, + cgroupMgr: cgroup.NewCgroupManager("cgroupfs", tmpDir, ""), + prepare: func() { + prepare(t, tmpDir, "fake-id4", []info{ + {path: cgroup.CPUQuotaBurstFile, value: "0"}, + {path: cgroup.CPUQuotaTotalFile, value: "300000"}, + {dir: "container1", path: cgroup.CPUQuotaBurstFile, value: "0"}, + {dir: "container1", path: cgroup.CPUQuotaTotalFile, value: "100000"}, + {dir: "container2", path: cgroup.CPUQuotaBurstFile, value: "0"}, + {dir: "container2", path: cgroup.CPUQuotaTotalFile, value: "200000"}, + }) + }, + post: func() map[string]string { + return file.ReadBatchFromFile([]string{ + path.Join(tmpDir, "cpu/kubepods/podfake-id4/cpu.cfs_burst_us"), + path.Join(tmpDir, "cpu/kubepods/podfake-id4/container1/cpu.cfs_burst_us"), + path.Join(tmpDir, "cpu/kubepods/podfake-id4/container2/cpu.cfs_burst_us"), + }) + }, + wantErr: false, + wantVal: map[string]string{ + path.Join(tmpDir, "cpu/kubepods/podfake-id4/cpu.cfs_burst_us"): "200000", + path.Join(tmpDir, "cpu/kubepods/podfake-id4/container1/cpu.cfs_burst_us"): "100000", + path.Join(tmpDir, "cpu/kubepods/podfake-id4/container2/cpu.cfs_burst_us"): "100000", + }, + }, + { + name: "all containers contains quota!=-1, set quota burst successfully", + event: framework.PodEvent{ + UID: "fake-id5", + QoSLevel: 0, + QoSClass: "", + Pod: getPod("200000", "true"), + }, + cgroupMgr: cgroup.NewCgroupManager("cgroupfs", tmpDir, ""), + prepare: func() { + prepare(t, tmpDir, "fake-id5", []info{ + {path: cgroup.CPUQuotaBurstFile, value: "0"}, + {path: cgroup.CPUQuotaTotalFile, value: "300000"}, + {dir: "container1", path: cgroup.CPUQuotaBurstFile, value: "0"}, + {dir: "container1", path: cgroup.CPUQuotaTotalFile, value: "100000"}, + {dir: "container2", path: cgroup.CPUQuotaBurstFile, value: "0"}, + {dir: "container2", path: cgroup.CPUQuotaTotalFile, value: "200000"}, + }) + }, + post: func() map[string]string { + return file.ReadBatchFromFile([]string{ + path.Join(tmpDir, "cpu/kubepods/podfake-id5/cpu.cfs_burst_us"), + path.Join(tmpDir, "cpu/kubepods/podfake-id5/container1/cpu.cfs_burst_us"), + path.Join(tmpDir, "cpu/kubepods/podfake-id5/container2/cpu.cfs_burst_us"), + }) + }, + wantErr: false, + wantVal: map[string]string{ + path.Join(tmpDir, "cpu/kubepods/podfake-id5/cpu.cfs_burst_us"): "300000", + path.Join(tmpDir, "cpu/kubepods/podfake-id5/container1/cpu.cfs_burst_us"): "100000", + path.Join(tmpDir, "cpu/kubepods/podfake-id5/container2/cpu.cfs_burst_us"): "200000", + }, + }, + { + name: "all containers contains quota!=-1, set quota burst successfully", + event: framework.PodEvent{ + UID: "fake-id6", + QoSLevel: 0, + QoSClass: "", + Pod: getPod("200000", "false"), + }, + cgroupMgr: cgroup.NewCgroupManager("cgroupfs", tmpDir, ""), + prepare: func() { + prepare(t, tmpDir, "fake-id6", []info{ + {path: cgroup.CPUQuotaBurstFile, value: "0"}, + {path: cgroup.CPUQuotaTotalFile, value: "300000"}, + {dir: "container1", path: cgroup.CPUQuotaBurstFile, value: "0"}, + {dir: "container1", path: cgroup.CPUQuotaTotalFile, value: "100000"}, + {dir: "container2", path: cgroup.CPUQuotaBurstFile, value: "0"}, + {dir: "container2", path: cgroup.CPUQuotaTotalFile, value: "200000"}, + }) + }, + post: func() map[string]string { + return file.ReadBatchFromFile([]string{ + path.Join(tmpDir, "cpu/kubepods/podfake-id6/cpu.cfs_burst_us"), + path.Join(tmpDir, "cpu/kubepods/podfake-id6/container1/cpu.cfs_burst_us"), + path.Join(tmpDir, "cpu/kubepods/podfake-id6/container2/cpu.cfs_burst_us"), + }) + }, + wantErr: false, + wantVal: map[string]string{ + path.Join(tmpDir, "cpu/kubepods/podfake-id6/cpu.cfs_burst_us"): "0", + path.Join(tmpDir, "cpu/kubepods/podfake-id6/container1/cpu.cfs_burst_us"): "0", + path.Join(tmpDir, "cpu/kubepods/podfake-id6/container2/cpu.cfs_burst_us"): "0", + }, + }, + } + fakeClient := fake.NewSimpleClientset() + informerFactory := informers.NewSharedInformerFactory(fakeClient, 0) + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + c := &CPUBurstHandle{ + cgroupMgr: tt.cgroupMgr, + podInformer: informerFactory.Core().V1().Pods(), + } + if tt.prepare != nil { + tt.prepare() + } + if err := c.Handle(tt.event); (err != nil) != tt.wantErr { + t.Errorf("Handle() error = %v, wantErr %v", err, tt.wantErr) + } + if tt.post != nil { + assert.Equal(t, tt.wantVal, tt.post()) + } + }) + } +} + +func getPod(cpuQuotaBurst string, enableBurst string) *corev1.Pod { + return &corev1.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Annotations: map[string]string{ + "volcano.sh/enable-quota-burst": enableBurst, + "volcano.sh/quota-burst-time": cpuQuotaBurst, + }, + }, + } +} + +type info struct { + dir string + path string + value string +} + +func prepare(t *testing.T, tmpDir, podUID string, infos []info) { + for _, info := range infos { + dir := path.Join(tmpDir, "cpu", "kubepods", "pod"+podUID, info.dir) + err := os.MkdirAll(dir, 0644) + assert.NoError(t, err) + filePath := path.Join(dir, info.path) + f, err := os.OpenFile(filePath, os.O_RDWR|os.O_CREATE, 0644) + assert.NoError(t, err) + err = f.Chmod(0600) + assert.NoError(t, err) + _, err = f.WriteString(info.value) + assert.NoError(t, err) + err = f.Close() + assert.NoError(t, err) + } +} diff --git a/pkg/agent/events/handlers/cpuburst/types.go b/pkg/agent/events/handlers/cpuburst/types.go new file mode 100644 index 000000000..89ab1e6fb --- /dev/null +++ b/pkg/agent/events/handlers/cpuburst/types.go @@ -0,0 +1,24 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package cpuburst + +const ( + EnabledKey = "volcano.sh/enable-quota-burst" + QuotaTimeKey = "volcano.sh/quota-burst-time" + + fixedQuotaValue = -1 +) diff --git a/pkg/agent/events/handlers/cpuqos/cpuqos_linux.go b/pkg/agent/events/handlers/cpuqos/cpuqos_linux.go new file mode 100644 index 000000000..a536d5441 --- /dev/null +++ b/pkg/agent/events/handlers/cpuqos/cpuqos_linux.go @@ -0,0 +1,80 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package cpuqos + +import ( + "errors" + "fmt" + "os" + "path" + + "k8s.io/klog/v2" + + "volcano.sh/volcano/pkg/agent/events/framework" + "volcano.sh/volcano/pkg/agent/events/handlers" + "volcano.sh/volcano/pkg/agent/events/handlers/base" + "volcano.sh/volcano/pkg/agent/features" + "volcano.sh/volcano/pkg/agent/utils" + "volcano.sh/volcano/pkg/agent/utils/cgroup" + "volcano.sh/volcano/pkg/config" + "volcano.sh/volcano/pkg/metriccollect" +) + +func init() { + handlers.RegisterEventHandleFunc(string(framework.PodEventName), NewCPUQoSHandle) +} + +type CPUQoSHandle struct { + *base.BaseHandle + cgroupMgr cgroup.CgroupManager +} + +func NewCPUQoSHandle(config *config.Configuration, mgr *metriccollect.MetricCollectorManager, cgroupMgr cgroup.CgroupManager) framework.Handle { + return &CPUQoSHandle{ + BaseHandle: &base.BaseHandle{ + Name: string(features.CPUQoSFeature), + Config: config, + }, + cgroupMgr: cgroupMgr, + } +} + +func (h *CPUQoSHandle) Handle(event interface{}) error { + podEvent, ok := event.(framework.PodEvent) + if !ok { + return fmt.Errorf("illegal pod event") + } + + cgroupPath, err := h.cgroupMgr.GetPodCgroupPath(podEvent.QoSClass, cgroup.CgroupCpuSubsystem, podEvent.UID) + if err != nil { + return fmt.Errorf("failed to get pod cgroup file(%s), error: %v", podEvent.UID, err) + } + qosLevelFile := path.Join(cgroupPath, cgroup.CPUQoSLevelFile) + qosLevel := []byte(fmt.Sprintf("%d", podEvent.QoSLevel)) + + err = utils.UpdatePodCgroup(qosLevelFile, qosLevel) + if err != nil { + if errors.Is(err, os.ErrNotExist) { + klog.InfoS("Cgroup file not existed", "cgroupFile", qosLevelFile) + return nil + } + return err + } + + klog.InfoS("Successfully set cpu qos level to cgroup file", "qosLevel", podEvent.QoSLevel, "cgroupFile", qosLevelFile) + return nil +} diff --git a/pkg/agent/events/handlers/cpuqos/cpuqos_linux_test.go b/pkg/agent/events/handlers/cpuqos/cpuqos_linux_test.go new file mode 100644 index 000000000..014e3d2a3 --- /dev/null +++ b/pkg/agent/events/handlers/cpuqos/cpuqos_linux_test.go @@ -0,0 +1,87 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package cpuqos + +import ( + "os" + "path" + "strconv" + "testing" + + "github.com/stretchr/testify/assert" + + "volcano.sh/volcano/pkg/agent/events/framework" + "volcano.sh/volcano/pkg/agent/utils/cgroup" +) + +func TestCPUQoSHandle_Handle(t *testing.T) { + // make a fake pod cgroup path first. + tmpDir := t.TempDir() + dir := path.Join(tmpDir, "cpu", "kubepods", "podfake-id2") + err := os.MkdirAll(dir, 0644) + assert.NoError(t, err) + filePath := path.Join(dir, "cpu.qos_level") + _, err = os.OpenFile(filePath, os.O_RDWR|os.O_CREATE, 0644) + assert.NoError(t, err) + + tests := []struct { + name string + cgroupMgr cgroup.CgroupManager + event framework.PodEvent + post func() int64 + wantErr bool + }{ + { + name: "cgroup path not exits, return no err", + cgroupMgr: cgroup.NewCgroupManager("cgroupfs", tmpDir, ""), + event: framework.PodEvent{ + UID: "fake-id1", + QoSLevel: -1, + QoSClass: "Guaranteed", + }, + wantErr: false, + }, + { + name: "update cgroup path successfully, return no err", + cgroupMgr: cgroup.NewCgroupManager("cgroupfs", tmpDir, ""), + event: framework.PodEvent{ + UID: "fake-id2", + QoSLevel: -1, + QoSClass: "Guaranteed", + }, + post: func() int64 { + value, _ := os.ReadFile(filePath) + i, _ := strconv.Atoi(string(value)) + return int64(i) + }, + wantErr: false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + h := &CPUQoSHandle{ + cgroupMgr: tt.cgroupMgr, + } + if err := h.Handle(tt.event); (err != nil) != tt.wantErr { + t.Errorf("Handle() error = %v, wantErr %v", err, tt.wantErr) + } + if tt.post != nil { + assert.Equal(t, tt.event.QoSLevel, tt.post()) + } + }) + } +} diff --git a/pkg/agent/events/handlers/eviction/eviction.go b/pkg/agent/events/handlers/eviction/eviction.go new file mode 100644 index 000000000..bbe41c8f3 --- /dev/null +++ b/pkg/agent/events/handlers/eviction/eviction.go @@ -0,0 +1,115 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package eviction + +import ( + "context" + "fmt" + "reflect" + + "k8s.io/klog/v2" + + "volcano.sh/volcano/pkg/agent/apis" + "volcano.sh/volcano/pkg/agent/config/api" + "volcano.sh/volcano/pkg/agent/events/framework" + "volcano.sh/volcano/pkg/agent/events/handlers" + "volcano.sh/volcano/pkg/agent/features" + "volcano.sh/volcano/pkg/agent/oversubscription/policy" + "volcano.sh/volcano/pkg/agent/oversubscription/queue" + "volcano.sh/volcano/pkg/agent/utils/cgroup" + "volcano.sh/volcano/pkg/agent/utils/eviction" + utilnode "volcano.sh/volcano/pkg/agent/utils/node" + utilpod "volcano.sh/volcano/pkg/agent/utils/pod" + "volcano.sh/volcano/pkg/config" + "volcano.sh/volcano/pkg/metriccollect" +) + +func init() { + handlers.RegisterEventHandleFunc(string(framework.NodeMonitorEventName), NewManager) +} + +type manager struct { + cfg *config.Configuration + eviction.Eviction + policy.Interface + getNodeFunc utilnode.ActiveNode + getPodsFunc utilpod.ActivePods +} + +func NewManager(config *config.Configuration, mgr *metriccollect.MetricCollectorManager, cgroupMgr cgroup.CgroupManager) framework.Handle { + evictor := eviction.NewEviction(config.GenericConfiguration.KubeClient, config.GenericConfiguration.KubeNodeName) + m := &manager{ + cfg: config, + Eviction: evictor, + Interface: policy.GetPolicyFunc(config.GenericConfiguration.OverSubscriptionPolicy)(config, mgr, evictor, queue.NewSqQueue(), ""), + getNodeFunc: config.GetNode, + getPodsFunc: config.GetActivePods, + } + return m +} + +func (m *manager) Handle(event interface{}) error { + nodeMonitorEvent, ok := event.(framework.NodeMonitorEvent) + if !ok { + klog.ErrorS(nil, "Invalid node monitor event", "type", reflect.TypeOf(event)) + return nil + } + + klog.InfoS("Received node pressure event", "resource", nodeMonitorEvent.Resource, "time", nodeMonitorEvent.TimeStamp) + node, err := m.getNodeFunc() + if err != nil { + klog.ErrorS(err, "Failed to get node") + return err + } + nodeCopy := node.DeepCopy() + + for _, res := range apis.OverSubscriptionResourceTypes { + if res != nodeMonitorEvent.Resource { + continue + } + preemptablePods, _, err := utilnode.GetLatestPodsAndResList(nodeCopy, m.getPodsFunc, res) + if err != nil { + klog.ErrorS(err, "Failed to get pods and resource list") + return err + } + + for _, pod := range preemptablePods { + if err = m.DisableSchedule(); err != nil { + klog.ErrorS(err, "Failed to add eviction annotation") + } + klog.InfoS("Successfully disable schedule") + + klog.InfoS("Try to evict pod", "pod", klog.KObj(pod)) + if m.Evict(context.TODO(), pod, m.cfg.GenericConfiguration.Recorder, 0, fmt.Sprintf("Evict offline pod due to %s resource pressure", res)) { + break + } + } + } + return nil +} + +func (m *manager) RefreshCfg(cfg *api.ColocationConfig) error { + return nil +} + +func (m *manager) IsActive() bool { + return true +} + +func (m *manager) HandleName() string { + return string(features.EvictionFeature) +} diff --git a/pkg/agent/events/handlers/eviction/eviction_test.go b/pkg/agent/events/handlers/eviction/eviction_test.go new file mode 100644 index 000000000..9f67ca0e5 --- /dev/null +++ b/pkg/agent/events/handlers/eviction/eviction_test.go @@ -0,0 +1,135 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package eviction + +import ( + "context" + "fmt" + "testing" + "time" + + "github.com/agiledragon/gomonkey/v2" + "github.com/stretchr/testify/assert" + v1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + fakeclientset "k8s.io/client-go/kubernetes/fake" + + "volcano.sh/volcano/pkg/agent/apis" + "volcano.sh/volcano/pkg/agent/events/framework" + "volcano.sh/volcano/pkg/agent/oversubscription/policy" + "volcano.sh/volcano/pkg/agent/oversubscription/policy/extend" + "volcano.sh/volcano/pkg/agent/utils/eviction" + utilnode "volcano.sh/volcano/pkg/agent/utils/node" + utilpod "volcano.sh/volcano/pkg/agent/utils/pod" + utiltesting "volcano.sh/volcano/pkg/agent/utils/testing" + "volcano.sh/volcano/pkg/config" +) + +func makeNode() (*v1.Node, error) { + return &v1.Node{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test-node", + Labels: make(map[string]string), + Annotations: make(map[string]string), + }, + }, nil +} + +func Test_manager_Handle(t *testing.T) { + fakeTime, err := time.Parse("2006-01-02", "2023-04-01") + assert.NoError(t, err) + patch := gomonkey.NewPatches() + defer patch.Reset() + patch.ApplyFunc(time.Now, func() time.Time { + return fakeTime + }) + + pp := utiltesting.NewPodProvider( + utiltesting.MakePod("offline-pod-1", 30, 30, "BE"), + utiltesting.MakePod("offline-pod-2", 40, 30, "BE"), + utiltesting.MakePod("online-pod", 10, 10, ""), + ) + + tests := []struct { + name string + event interface{} + Eviction eviction.Eviction + policy func(cfg *config.Configuration, pods utilpod.ActivePods, evictor eviction.Eviction) policy.Interface + getNodeFunc utilnode.ActiveNode + getPodsFunc utilpod.ActivePods + wantErr assert.ErrorAssertionFunc + expectedNode func() *v1.Node + }{ + { + name: "evict high request pod with extend resource", + event: framework.NodeMonitorEvent{ + TimeStamp: time.Now(), + Resource: v1.ResourceCPU, + }, + Eviction: pp, + policy: func(cfg *config.Configuration, pods utilpod.ActivePods, evictor eviction.Eviction) policy.Interface { + return extend.NewExtendResource(cfg, nil, evictor, nil, "") + }, + getPodsFunc: pp.GetPodsFunc, + getNodeFunc: makeNode, + wantErr: assert.NoError, + expectedNode: func() *v1.Node { + node := &v1.Node{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test-node", + }, + Spec: v1.NodeSpec{Taints: []v1.Taint{{Key: apis.PodEvictingKey, Effect: v1.TaintEffectNoSchedule}}}, + } + return node + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + fakeNode, err := makeNode() + assert.NoError(t, err) + fakeClient := fakeclientset.NewSimpleClientset(fakeNode) + cfg := &config.Configuration{GenericConfiguration: &config.VolcanoAgentConfiguration{ + KubeClient: fakeClient, + KubeNodeName: "test-node", + NodeHasSynced: func() bool { + return false + }, + }} + m := &manager{ + cfg: cfg, + Interface: tt.policy(cfg, tt.getPodsFunc, nil), + Eviction: tt.Eviction, + getNodeFunc: tt.getNodeFunc, + getPodsFunc: tt.getPodsFunc, + } + tt.wantErr(t, m.Handle(tt.event), fmt.Sprintf("Handle(%v)", tt.event)) + evictedPods := pp.GetEvictedPods() + // Verify that pod should be evicted. + if len(evictedPods) == 0 || evictedPods[0].Name != "offline-pod-2" { + t.Errorf("Manager should have evicted offline-pod-2 but not") + } + + // Node should be schedule disabled. + node, err := fakeClient.CoreV1().Nodes().Get(context.TODO(), "test-node", metav1.GetOptions{}) + if err != nil { + t.Errorf("Failed to get node, err: %v", err) + } + assert.Equalf(t, tt.expectedNode(), node, "Node should have eviction annotation or taint") + }) + } +} diff --git a/pkg/agent/events/handlers/memoryqos/memoryqos_linux.go b/pkg/agent/events/handlers/memoryqos/memoryqos_linux.go new file mode 100644 index 000000000..f71ea4108 --- /dev/null +++ b/pkg/agent/events/handlers/memoryqos/memoryqos_linux.go @@ -0,0 +1,81 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package memoryqos + +import ( + "errors" + "fmt" + "os" + "path" + + "k8s.io/klog/v2" + + "volcano.sh/volcano/pkg/agent/apis/extension" + "volcano.sh/volcano/pkg/agent/events/framework" + "volcano.sh/volcano/pkg/agent/events/handlers" + "volcano.sh/volcano/pkg/agent/events/handlers/base" + "volcano.sh/volcano/pkg/agent/features" + "volcano.sh/volcano/pkg/agent/utils" + "volcano.sh/volcano/pkg/agent/utils/cgroup" + "volcano.sh/volcano/pkg/config" + "volcano.sh/volcano/pkg/metriccollect" +) + +func init() { + handlers.RegisterEventHandleFunc(string(framework.PodEventName), NewMemoryQoSHandle) +} + +type MemoryQoSHandle struct { + *base.BaseHandle + cgroupMgr cgroup.CgroupManager +} + +func NewMemoryQoSHandle(config *config.Configuration, mgr *metriccollect.MetricCollectorManager, cgroupMgr cgroup.CgroupManager) framework.Handle { + return &MemoryQoSHandle{ + BaseHandle: &base.BaseHandle{ + Name: string(features.MemoryQoSFeature), + Config: config, + }, + cgroupMgr: cgroupMgr, + } +} + +func (h *MemoryQoSHandle) Handle(event interface{}) error { + podEvent, ok := event.(framework.PodEvent) + if !ok { + return fmt.Errorf("illegal pod event") + } + + cgroupPath, err := h.cgroupMgr.GetPodCgroupPath(podEvent.QoSClass, cgroup.CgroupMemorySubsystem, podEvent.UID) + if err != nil { + return fmt.Errorf("failed to get pod cgroup file(%s), error: %v", podEvent.UID, err) + } + qosLevelFile := path.Join(cgroupPath, cgroup.MemoryQoSLevelFile) + qosLevel := []byte(fmt.Sprintf("%d", extension.NormalizeQosLevel(podEvent.QoSLevel))) + + err = utils.UpdatePodCgroup(qosLevelFile, qosLevel) + if err != nil { + if errors.Is(err, os.ErrNotExist) { + klog.InfoS("Cgroup file not existed", "cgroupFile", qosLevelFile) + return nil + } + return err + } + + klog.InfoS("Successfully set memory qos level to cgroup file", "qosLevel", qosLevel, "cgroupFile", qosLevelFile) + return nil +} diff --git a/pkg/agent/events/handlers/memoryqos/memoryqos_linux_test.go b/pkg/agent/events/handlers/memoryqos/memoryqos_linux_test.go new file mode 100644 index 000000000..4d2eae03f --- /dev/null +++ b/pkg/agent/events/handlers/memoryqos/memoryqos_linux_test.go @@ -0,0 +1,131 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package memoryqos + +import ( + "os" + "path" + "testing" + + "github.com/stretchr/testify/assert" + + "volcano.sh/volcano/pkg/agent/events/framework" + "volcano.sh/volcano/pkg/agent/utils/cgroup" +) + +func TestMemroyQoSHandle_Handle(t *testing.T) { + dir, err := os.MkdirTemp("/tmp", "MkdirTempCgroup") + defer func() { + err = os.RemoveAll(dir) + if err != nil { + t.Errorf("remove dir(%s) failed: %v", dir, err) + } + assert.Equal(t, err == nil, true) + }() + assert.Equal(t, err == nil, true) + + testCases := []struct { + name string + cgroupMgr cgroup.CgroupManager + cgroupSubpath string + event framework.PodEvent + expectedErr bool + expectedQoSLevel string + }{ + { + name: "Burstable pod event && CgroupDriver=Cgroupfs", + cgroupMgr: cgroup.NewCgroupManager("cgroupfs", path.Join(dir, "cgroup"), ""), + cgroupSubpath: "cgroup/memory/kubepods/burstable", + event: framework.PodEvent{ + UID: "00000000-1111-2222-3333-000000000001", + QoSLevel: -1, + QoSClass: "Burstable", + }, + expectedErr: false, + expectedQoSLevel: "-1", + }, + + { + name: "Guaranteed pod event && CgroupDriver=Cgroupfs", + cgroupMgr: cgroup.NewCgroupManager("cgroupfs", path.Join(dir, "cgroup"), ""), + cgroupSubpath: "cgroup/memory/kubepods", + event: framework.PodEvent{ + UID: "00000000-1111-2222-3333-000000000002", + QoSLevel: -1, + QoSClass: "Guaranteed", + }, + expectedErr: false, + expectedQoSLevel: "-1", + }, + + { + name: "BestEffort pod event && CgroupDriver=Cgroupfs", + cgroupMgr: cgroup.NewCgroupManager("cgroupfs", path.Join(dir, "cgroup"), ""), + cgroupSubpath: "cgroup/memory/kubepods/besteffort", + event: framework.PodEvent{ + UID: "00000000-1111-2222-3333-000000000003", + QoSLevel: -1, + QoSClass: "BestEffort", + }, + expectedErr: false, + expectedQoSLevel: "-1", + }, + { + name: "BestEffort pod event && CgroupDriver=Cgroupfs qos level=-2", + cgroupMgr: cgroup.NewCgroupManager("cgroupfs", path.Join(dir, "cgroup"), ""), + cgroupSubpath: "cgroup/memory/kubepods/besteffort", + event: framework.PodEvent{ + UID: "00000000-1111-2222-3333-000000000003", + QoSLevel: -2, + QoSClass: "BestEffort", + }, + expectedErr: false, + expectedQoSLevel: "-1", + }, + { + name: "BestEffort pod event && CgroupDriver=Cgroupfs qos level=2", + cgroupMgr: cgroup.NewCgroupManager("cgroupfs", path.Join(dir, "cgroup"), ""), + cgroupSubpath: "cgroup/memory/kubepods/besteffort", + event: framework.PodEvent{ + UID: "00000000-1111-2222-3333-000000000003", + QoSLevel: 2, + QoSClass: "BestEffort", + }, + expectedErr: false, + expectedQoSLevel: "0", + }, + } + + for _, tc := range testCases { + fakeCgroupPath := path.Join(dir, tc.cgroupSubpath, "pod"+string(tc.event.UID)) + err = os.MkdirAll(fakeCgroupPath, 0750) + assert.Equal(t, err == nil, true, tc.name) + + tmpFile := path.Join(fakeCgroupPath, "memory.qos_level") + if err = os.WriteFile(tmpFile, []byte("0"), 0660); err != nil { + assert.Equal(t, nil, err, tc.name) + } + + h := NewMemoryQoSHandle(nil, nil, tc.cgroupMgr) + handleErr := h.Handle(tc.event) + assert.Equal(t, tc.expectedErr, handleErr != nil, tc.name) + + actualLevel, readErr := os.ReadFile(tmpFile) + assert.Equal(t, nil, readErr, tc.name) + assert.Equal(t, tc.expectedQoSLevel, string(actualLevel), tc.name) + } +} diff --git a/pkg/agent/events/handlers/networkqos/networkqos_linux.go b/pkg/agent/events/handlers/networkqos/networkqos_linux.go new file mode 100644 index 000000000..030f9f193 --- /dev/null +++ b/pkg/agent/events/handlers/networkqos/networkqos_linux.go @@ -0,0 +1,135 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package networkqos + +import ( + "fmt" + "os" + "path" + "strconv" + + corev1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/errors" + listersv1 "k8s.io/client-go/listers/core/v1" + "k8s.io/client-go/tools/record" + "k8s.io/klog/v2" + + "volcano.sh/volcano/pkg/agent/apis/extension" + "volcano.sh/volcano/pkg/agent/config/api" + "volcano.sh/volcano/pkg/agent/events/framework" + "volcano.sh/volcano/pkg/agent/events/handlers" + "volcano.sh/volcano/pkg/agent/events/handlers/base" + "volcano.sh/volcano/pkg/agent/features" + "volcano.sh/volcano/pkg/agent/utils" + "volcano.sh/volcano/pkg/agent/utils/cgroup" + "volcano.sh/volcano/pkg/config" + "volcano.sh/volcano/pkg/metriccollect" + "volcano.sh/volcano/pkg/networkqos" +) + +func init() { + handlers.RegisterEventHandleFunc(string(framework.PodEventName), NewNetworkQoSHandle) +} + +type NetworkQoSHandle struct { + *base.BaseHandle + cgroupMgr cgroup.CgroupManager + networkqosMgr networkqos.NetworkQoSManager + poLister listersv1.PodLister + recorder record.EventRecorder +} + +func NewNetworkQoSHandle(config *config.Configuration, mgr *metriccollect.MetricCollectorManager, cgroupMgr cgroup.CgroupManager) framework.Handle { + return &NetworkQoSHandle{ + BaseHandle: &base.BaseHandle{ + Name: string(features.NetworkQoSFeature), + Config: config, + }, + cgroupMgr: cgroupMgr, + networkqosMgr: networkqos.GetNetworkQoSManager(config), + poLister: config.InformerFactory.K8SInformerFactory.Core().V1().Pods().Lister(), + recorder: config.GenericConfiguration.Recorder, + } +} + +func (h *NetworkQoSHandle) Handle(event interface{}) error { + podEvent, ok := event.(framework.PodEvent) + if !ok { + return fmt.Errorf("illegal pod event: %v", event) + } + + pod, err := h.poLister.Pods(podEvent.Pod.Namespace).Get(podEvent.Pod.Name) + if err != nil { + if !errors.IsNotFound(err) { + klog.V(4).InfoS("pod does not existed, skipped handling network qos", "namespace", podEvent.Pod.Namespace, "name", podEvent.Pod.Name) + return nil + } + return err + } + + _, ingressExisted := pod.Annotations["kubernetes.io/ingress-bandwidth"] + _, egressExisted := pod.Annotations["kubernetes.io/egress-bandwidth"] + if ingressExisted || egressExisted { + h.recorder.Event(pod, corev1.EventTypeWarning, "NetworkQoSSkipped", + fmt.Sprintf("Colocation Network QoS is not set, because it already has an Ingress-Bandwidth/Egress-Bandwidth"+ + " network rate limit(with annotation key kubernetes.io/ingress-bandwidth or kubernetes.io/egress-bandwidth )")) + return nil + } + + cgroupPath, err := h.cgroupMgr.GetPodCgroupPath(podEvent.QoSClass, cgroup.CgroupNetCLSSubsystem, podEvent.UID) + if err != nil { + return fmt.Errorf("failed to get pod cgroup file(%s), error: %v", podEvent.UID, err) + } + + qosLevelFile := path.Join(cgroupPath, cgroup.NetCLSFileName) + uintQoSLevel := uint32(extension.NormalizeQosLevel(podEvent.QoSLevel)) + qosLevel := []byte(strconv.FormatUint(uint64(uintQoSLevel), 10)) + + err = utils.UpdatePodCgroup(qosLevelFile, qosLevel) + if os.IsNotExist(err) { + klog.InfoS("Cgroup file not existed", "cgroupFile", qosLevelFile) + return nil + } + klog.InfoS("Successfully set network qos level to cgroup file", "qosLevel", string(qosLevel), "cgroupFile", qosLevelFile) + return nil +} + +func (h *NetworkQoSHandle) RefreshCfg(cfg *api.ColocationConfig) error { + if err := h.BaseHandle.RefreshCfg(cfg); err != nil { + return err + } + + h.Lock.Lock() + defer h.Lock.Unlock() + if h.Active { + err := h.networkqosMgr.EnableNetworkQoS(cfg.NetworkQosConfig) + if err != nil { + klog.ErrorS(err, "Failed to enable network qos") + return err + } + klog.V(5).InfoS("Successfully enable/update network QoS") + return nil + } + + err := h.networkqosMgr.DisableNetworkQoS() + if err != nil { + klog.ErrorS(err, "Failed to disable network qos") + return err + } + klog.V(5).InfoS("Successfully disable network QoS") + return nil +} diff --git a/pkg/agent/events/handlers/networkqos/networkqos_linux_test.go b/pkg/agent/events/handlers/networkqos/networkqos_linux_test.go new file mode 100644 index 000000000..724bd7dd2 --- /dev/null +++ b/pkg/agent/events/handlers/networkqos/networkqos_linux_test.go @@ -0,0 +1,154 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package networkqos + +import ( + "context" + "fmt" + "os" + "path" + "testing" + + "github.com/stretchr/testify/assert" + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/client-go/informers" + "k8s.io/client-go/kubernetes/fake" + "k8s.io/client-go/tools/cache" + "k8s.io/client-go/tools/record" + + "volcano.sh/volcano/pkg/agent/events/framework" + "volcano.sh/volcano/pkg/agent/utils/cgroup" + "volcano.sh/volcano/pkg/config" +) + +func TestNeworkQoSHandle_Handle(t *testing.T) { + dir, err := os.MkdirTemp("/tmp", "MkdirTempCgroup") + defer func() { + err = os.RemoveAll(dir) + if err != nil { + t.Errorf("remove dir(%s) failed: %v", dir, err) + } + assert.Equal(t, err == nil, true) + }() + assert.Equal(t, err == nil, true) + + testCases := []struct { + name string + cgroupMgr cgroup.CgroupManager + cgroupSubpath string + recorder record.EventRecorder + event framework.PodEvent + expectedErr bool + expectedQoSLevel string + }{ + { + name: "Burstable pod event && CgroupDriver=Cgroupfs", + cgroupMgr: cgroup.NewCgroupManager("cgroupfs", path.Join(dir, "cgroup"), ""), + cgroupSubpath: "cgroup/net_cls/kubepods/burstable", + event: framework.PodEvent{ + UID: "00000000-1111-2222-3333-000000000001", + QoSLevel: -1, + QoSClass: "Burstable", + Pod: &corev1.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test1", + Namespace: "default", + }, + }, + }, + expectedErr: false, + expectedQoSLevel: "4294967295", + }, + + { + name: "Guaranteed pod event && CgroupDriver=Cgroupfs", + cgroupMgr: cgroup.NewCgroupManager("cgroupfs", path.Join(dir, "cgroup"), ""), + cgroupSubpath: "cgroup/net_cls/kubepods", + event: framework.PodEvent{ + UID: "00000000-1111-2222-3333-000000000002", + QoSLevel: -1, + QoSClass: "Guaranteed", + Pod: &corev1.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test2", + Namespace: "default", + }, + }, + }, + expectedErr: false, + expectedQoSLevel: "4294967295", + }, + + { + name: "BestEffort pod event && CgroupDriver=Cgroupfs", + cgroupMgr: cgroup.NewCgroupManager("cgroupfs", path.Join(dir, "cgroup"), ""), + cgroupSubpath: "cgroup/net_cls/kubepods/besteffort", + event: framework.PodEvent{ + UID: "00000000-1111-2222-3333-000000000003", + QoSLevel: -1, + QoSClass: "BestEffort", + Pod: &corev1.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test3", + Namespace: "default", + }, + }, + }, + expectedErr: false, + expectedQoSLevel: "4294967295", + }, + } + + for _, tc := range testCases { + fakeCgroupPath := path.Join(dir, tc.cgroupSubpath, "pod"+string(tc.event.UID)) + err = os.MkdirAll(fakeCgroupPath, 0750) + assert.Equal(t, err == nil, true, tc.name) + + tmpFile := path.Join(fakeCgroupPath, "net_cls.classid") + if err = os.WriteFile(tmpFile, []byte("0"), 0660); err != nil { + assert.Equal(t, nil, err, tc.name) + } + + fakeClient := fake.NewSimpleClientset(tc.event.Pod) + informerFactory := informers.NewSharedInformerFactory(fakeClient, 0) + informerFactory.Core().V1().Pods().Informer() + informerFactory.Start(context.TODO().Done()) + if !cache.WaitForNamedCacheSync("", context.TODO().Done(), informerFactory.Core().V1().Pods().Informer().HasSynced) { + assert.Equal(t, nil, err, tc.name) + } + + cfg := &config.Configuration{ + InformerFactory: &config.InformerFactory{ + K8SInformerFactory: informerFactory, + }, + GenericConfiguration: &config.VolcanoAgentConfiguration{ + KubeClient: fakeClient, + Recorder: record.NewFakeRecorder(100), + }, + } + + h := NewNetworkQoSHandle(cfg, nil, tc.cgroupMgr) + handleErr := h.Handle(tc.event) + fmt.Println(handleErr) + assert.Equal(t, tc.expectedErr, handleErr != nil, tc.name) + + actualLevel, readErr := os.ReadFile(tmpFile) + assert.Equal(t, nil, readErr, tc.name) + assert.Equal(t, tc.expectedQoSLevel, string(actualLevel), tc.name) + } +} diff --git a/pkg/agent/events/handlers/oversubscription/resource_reporter.go b/pkg/agent/events/handlers/oversubscription/resource_reporter.go new file mode 100644 index 000000000..961258fa0 --- /dev/null +++ b/pkg/agent/events/handlers/oversubscription/resource_reporter.go @@ -0,0 +1,151 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package oversubscription + +import ( + "reflect" + + corev1 "k8s.io/api/core/v1" + "k8s.io/klog/v2" + + "volcano.sh/volcano/pkg/agent/apis" + "volcano.sh/volcano/pkg/agent/config/api" + "volcano.sh/volcano/pkg/agent/events/framework" + "volcano.sh/volcano/pkg/agent/events/handlers" + "volcano.sh/volcano/pkg/agent/events/handlers/base" + "volcano.sh/volcano/pkg/agent/features" + "volcano.sh/volcano/pkg/agent/metrics" + "volcano.sh/volcano/pkg/agent/oversubscription/policy" + "volcano.sh/volcano/pkg/agent/utils/cgroup" + "volcano.sh/volcano/pkg/agent/utils/eviction" + utilnode "volcano.sh/volcano/pkg/agent/utils/node" + utilpod "volcano.sh/volcano/pkg/agent/utils/pod" + "volcano.sh/volcano/pkg/config" + "volcano.sh/volcano/pkg/metriccollect" +) + +const ( + reSyncPeriod = 6 // report overSubscription resources every 10s, so 6 represents 1 minutes. +) + +func init() { + handlers.RegisterEventHandleFunc(string(framework.NodeResourcesEventName), NewReporter) +} + +type reporter struct { + *base.BaseHandle + policy.Interface + enabled bool + getNodeFunc utilnode.ActiveNode + getPodsFunc utilpod.ActivePods + killPodFunc utilpod.KillPod + reportTimes int64 +} + +func NewReporter(config *config.Configuration, mgr *metriccollect.MetricCollectorManager, cgroupMgr cgroup.CgroupManager) framework.Handle { + evictor := eviction.NewEviction(config.GenericConfiguration.KubeClient, config.GenericConfiguration.KubeNodeName) + return &reporter{ + BaseHandle: &base.BaseHandle{ + Name: string(features.OverSubscriptionFeature), + Config: config, + }, + Interface: policy.GetPolicyFunc(config.GenericConfiguration.OverSubscriptionPolicy)(config, nil, evictor, nil, ""), + enabled: true, + getPodsFunc: config.GetActivePods, + getNodeFunc: config.GetNode, + } +} + +func (r *reporter) Handle(event interface{}) error { + nodeResourceEvent, ok := event.(framework.NodeResourceEvent) + if !ok { + klog.ErrorS(nil, "Invalid node resource event", "type", reflect.TypeOf(event)) + return nil + } + + overSubRes := apis.Resource{ + corev1.ResourceCPU: nodeResourceEvent.MillCPU, + corev1.ResourceMemory: nodeResourceEvent.MemoryBytes, + } + + node, err := r.getNodeFunc() + if err != nil { + klog.ErrorS(nil, "overSubscription: failed to get node") + return err + } + nodeCopy := node.DeepCopy() + + if !utilnode.IsNodeSupportOverSubscription(nodeCopy) { + return nil + } + + r.reportTimes++ + if !r.shouldPatchOverSubscription(nodeCopy, overSubRes) { + return nil + } + + if err = r.UpdateOverSubscription(overSubRes); err != nil { + klog.ErrorS(err, "OverSubscription: failed to update overSubscription resource") + return nil + } + metrics.UpdateOverSubscriptionResourceQuantity(r.Config.GenericConfiguration.KubeNodeName, overSubRes) + return nil +} + +func (r *reporter) RefreshCfg(cfg *api.ColocationConfig) error { + if err := r.BaseHandle.RefreshCfg(cfg); err != nil { + return err + } + + r.Lock.Lock() + defer r.Lock.Unlock() + + emptyRes := apis.Resource{ + corev1.ResourceCPU: 0, + corev1.ResourceMemory: 0, + } + // OverSubscriptionConfig is disabled. + if !*cfg.OverSubscriptionConfig.Enable { + r.enabled = false + metrics.UpdateOverSubscriptionResourceQuantity(r.Config.GenericConfiguration.KubeNodeName, emptyRes) + return r.Cleanup() + } + + // OverSubscriptionConfig is enabled, we should check node label because overSubscription can be turned off by reset node label, too. + // node colocation and subscription are turned off by nodePool setting, do clean up. + if r.enabled && !*cfg.NodeLabelConfig.NodeOverSubscriptionEnable { + metrics.UpdateOverSubscriptionResourceQuantity(r.Config.GenericConfiguration.KubeNodeName, emptyRes) + return r.Cleanup() + } else { + // overSubscription is turned on by OverSubscriptionConfig, set node label. + if err := utilnode.SetOverSubscriptionLabel(r.Config); err != nil { + klog.ErrorS(err, "Failed to set overSubscription label") + return err + } + r.enabled = true + klog.InfoS("Successfully set overSubscription label=true") + return nil + } +} + +func (r *reporter) shouldPatchOverSubscription(node *corev1.Node, usage apis.Resource) bool { + // re-sync overSubscription resources every 1 minute. + if r.reportTimes%reSyncPeriod == 0 { + return true + } + return r.ShouldUpdateOverSubscription(node, usage) +} diff --git a/pkg/agent/events/handlers/oversubscription/resource_reporter_test.go b/pkg/agent/events/handlers/oversubscription/resource_reporter_test.go new file mode 100644 index 000000000..6e841fb9f --- /dev/null +++ b/pkg/agent/events/handlers/oversubscription/resource_reporter_test.go @@ -0,0 +1,254 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package oversubscription + +import ( + "context" + "fmt" + "testing" + + "github.com/stretchr/testify/assert" + v1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/resource" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/util/sets" + fakeclientset "k8s.io/client-go/kubernetes/fake" + utilpointer "k8s.io/utils/pointer" + + "volcano.sh/volcano/pkg/agent/apis" + "volcano.sh/volcano/pkg/agent/config/api" + "volcano.sh/volcano/pkg/agent/events/framework" + "volcano.sh/volcano/pkg/agent/events/handlers/base" + "volcano.sh/volcano/pkg/agent/features" + "volcano.sh/volcano/pkg/agent/oversubscription/policy" + "volcano.sh/volcano/pkg/agent/oversubscription/policy/extend" + "volcano.sh/volcano/pkg/agent/utils/eviction" + utilnode "volcano.sh/volcano/pkg/agent/utils/node" + utilpod "volcano.sh/volcano/pkg/agent/utils/pod" + utiltesting "volcano.sh/volcano/pkg/agent/utils/testing" + "volcano.sh/volcano/pkg/config" +) + +func makeNode() (*v1.Node, error) { + return &v1.Node{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test-node", + Annotations: map[string]string{ + apis.OverSubscriptionTypesKey: "cpu", + }, + Labels: map[string]string{ + apis.OverSubscriptionNodeLabelKey: "true", + }, + }, + Status: v1.NodeStatus{Allocatable: map[v1.ResourceName]resource.Quantity{ + v1.ResourceCPU: *resource.NewQuantity(10000, resource.DecimalSI), + v1.ResourceMemory: *resource.NewQuantity(10000, resource.BinarySI), + }}, + }, nil +} + +func Test_reporter_RefreshCfg(t *testing.T) { + tests := []struct { + name string + getNodeFunc utilnode.ActiveNode + getPodsFunc utilpod.ActivePods + podProvider *utiltesting.PodProvider + policy func(cfg *config.Configuration, pods utilpod.ActivePods, evictor eviction.Eviction) policy.Interface + cfg *api.ColocationConfig + enable bool + expectNode func() *v1.Node + expectTypes sets.String + expectEvictedPods []*v1.Pod + }{ + { + name: "enable overSubscription", + getNodeFunc: func() (*v1.Node, error) { + node, err := makeNode() + assert.NoError(t, err) + node.Labels[apis.OverSubscriptionNodeLabelKey] = "false" + return node, nil + }, + podProvider: utiltesting.NewPodProvider(), + policy: func(cfg *config.Configuration, activePods utilpod.ActivePods, evictor eviction.Eviction) policy.Interface { + return extend.NewExtendResource(cfg, nil, evictor, nil, "") + }, + cfg: &api.ColocationConfig{ + NodeLabelConfig: &api.NodeLabelConfig{ + NodeColocationEnable: utilpointer.Bool(false), + NodeOverSubscriptionEnable: utilpointer.Bool(true), + }, + OverSubscriptionConfig: &api.OverSubscription{ + Enable: utilpointer.Bool(true), + OverSubscriptionTypes: utilpointer.String("cpu,memory"), + }}, + enable: true, + expectTypes: sets.NewString("cpu", "memory"), + expectNode: func() *v1.Node { + node, err := makeNode() + assert.NoError(t, err) + return node + }, + expectEvictedPods: nil, + }, + { + name: "enable overSubscription after disable config", + getNodeFunc: func() (*v1.Node, error) { + node, err := makeNode() + assert.NoError(t, err) + node.Labels[apis.OverSubscriptionNodeLabelKey] = "false" + return node, nil + }, + podProvider: utiltesting.NewPodProvider(), + policy: func(cfg *config.Configuration, activePods utilpod.ActivePods, evictor eviction.Eviction) policy.Interface { + return extend.NewExtendResource(cfg, nil, evictor, nil, "") + }, + cfg: &api.ColocationConfig{ + NodeLabelConfig: &api.NodeLabelConfig{ + NodeColocationEnable: utilpointer.Bool(false), + NodeOverSubscriptionEnable: utilpointer.Bool(false), + }, + OverSubscriptionConfig: &api.OverSubscription{ + Enable: utilpointer.Bool(true), + OverSubscriptionTypes: utilpointer.String("cpu,memory"), + }}, + expectTypes: sets.NewString("cpu", "memory"), + expectNode: func() *v1.Node { + node, err := makeNode() + assert.NoError(t, err) + return node + }, + expectEvictedPods: nil, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + fakeNode, _ := tt.getNodeFunc() + fakeClient := fakeclientset.NewSimpleClientset(fakeNode) + cfg := &config.Configuration{GenericConfiguration: &config.VolcanoAgentConfiguration{ + KubeClient: fakeClient, + KubeNodeName: "test-node", + NodeHasSynced: func() bool { + return false + }, + SupportedFeatures: []string{string(features.OverSubscriptionFeature)}, + }} + r := &reporter{ + BaseHandle: &base.BaseHandle{ + Name: string(features.OverSubscriptionFeature), + Config: cfg, + }, + Interface: tt.policy(cfg, tt.podProvider.GetPodsFunc, tt.podProvider), + enabled: tt.enable, + getNodeFunc: tt.getNodeFunc, + getPodsFunc: tt.podProvider.GetPodsFunc, + } + assert.NoError(t, r.RefreshCfg(tt.cfg)) + node, err := fakeClient.CoreV1().Nodes().Get(context.TODO(), "test-node", metav1.GetOptions{}) + if err != nil { + t.Errorf("Failed to get node, err: %v", err) + } + assert.Equal(t, tt.expectNode(), node) + assert.Equal(t, tt.expectEvictedPods, tt.podProvider.GetEvictedPods()) + }) + } +} + +func Test_reporter_Handle(t *testing.T) { + tests := []struct { + name string + policy func(cfg *config.Configuration, pods utilpod.ActivePods, evictor eviction.Eviction) policy.Interface + getNodeFunc utilnode.ActiveNode + getPodsFunc utilpod.ActivePods + killPodFunc utilpod.KillPod + event interface{} + wantErr assert.ErrorAssertionFunc + expectedNode func() *v1.Node + }{ + { + name: "not over subscription node, skip patch", + policy: func(cfg *config.Configuration, pods utilpod.ActivePods, evictor eviction.Eviction) policy.Interface { + return extend.NewExtendResource(cfg, nil, evictor, nil, "") + }, + getNodeFunc: func() (*v1.Node, error) { + node, err := makeNode() + assert.NoError(t, err) + node.Labels[apis.OverSubscriptionNodeLabelKey] = "false" + return node, nil + }, + event: framework.NodeResourceEvent{ + MillCPU: 1000, + MemoryBytes: 2000, + }, + wantErr: assert.NoError, + expectedNode: func() *v1.Node { + node, err := makeNode() + assert.NoError(t, err) + node.Labels[apis.OverSubscriptionNodeLabelKey] = "false" + return node + }, + }, + { + name: "patch over subscription node to node status", + policy: func(cfg *config.Configuration, pods utilpod.ActivePods, evictor eviction.Eviction) policy.Interface { + return extend.NewExtendResource(cfg, nil, evictor, nil, "") + }, + getNodeFunc: makeNode, + event: framework.NodeResourceEvent{ + MillCPU: 1000, + MemoryBytes: 2000, + }, + wantErr: assert.NoError, + expectedNode: func() *v1.Node { + node, err := makeNode() + assert.NoError(t, err) + node.Status.Capacity = map[v1.ResourceName]resource.Quantity{} + node.Status.Capacity[apis.ExtendResourceCPU] = *resource.NewQuantity(1000, resource.DecimalSI) + node.Status.Capacity[apis.ExtendResourceMemory] = *resource.NewQuantity(2000, resource.BinarySI) + node.Status.Allocatable[apis.ExtendResourceCPU] = *resource.NewQuantity(1000, resource.DecimalSI) + node.Status.Allocatable[apis.ExtendResourceMemory] = *resource.NewQuantity(2000, resource.BinarySI) + return node + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + makeNode, _ := tt.getNodeFunc() + fakeClient := fakeclientset.NewSimpleClientset(makeNode) + cfg := &config.Configuration{GenericConfiguration: &config.VolcanoAgentConfiguration{ + KubeClient: fakeClient, + KubeNodeName: "test-node", + NodeHasSynced: func() bool { + return false + }, + }} + r := &reporter{ + BaseHandle: &base.BaseHandle{ + Config: cfg}, + Interface: tt.policy(cfg, tt.getPodsFunc, nil), + getNodeFunc: tt.getNodeFunc, + getPodsFunc: tt.getPodsFunc, + killPodFunc: tt.killPodFunc, + } + tt.wantErr(t, r.Handle(tt.event), fmt.Sprintf("Handle(%v)", tt.event)) + node, err := fakeClient.CoreV1().Nodes().Get(context.TODO(), "test-node", metav1.GetOptions{}) + if err != nil { + t.Errorf("Failed to get node, err: %v", err) + } + assert.Equal(t, tt.expectedNode(), node) + }) + } +} diff --git a/pkg/agent/events/handlers/resources/resources.go b/pkg/agent/events/handlers/resources/resources.go new file mode 100644 index 000000000..c07afb798 --- /dev/null +++ b/pkg/agent/events/handlers/resources/resources.go @@ -0,0 +1,100 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package resources + +import ( + "fmt" + "os" + "path" + "strconv" + + utilerrors "k8s.io/apimachinery/pkg/util/errors" + "k8s.io/klog/v2" + + "volcano.sh/volcano/pkg/agent/events/framework" + "volcano.sh/volcano/pkg/agent/events/handlers" + "volcano.sh/volcano/pkg/agent/events/handlers/base" + "volcano.sh/volcano/pkg/agent/features" + "volcano.sh/volcano/pkg/agent/utils" + "volcano.sh/volcano/pkg/agent/utils/cgroup" + utilpod "volcano.sh/volcano/pkg/agent/utils/pod" + "volcano.sh/volcano/pkg/config" + "volcano.sh/volcano/pkg/metriccollect" +) + +func init() { + handlers.RegisterEventHandleFunc(string(framework.PodEventName), NewResources) +} + +type ResourcesHandle struct { + *base.BaseHandle + cgroupMgr cgroup.CgroupManager +} + +func NewResources(config *config.Configuration, mgr *metriccollect.MetricCollectorManager, cgroupMgr cgroup.CgroupManager) framework.Handle { + return &ResourcesHandle{ + BaseHandle: &base.BaseHandle{ + Name: string(features.ResourcesFeature), + Config: config, + Active: true, + }, + cgroupMgr: cgroupMgr, + } +} + +func (r *ResourcesHandle) Handle(event interface{}) error { + podEvent, ok := event.(framework.PodEvent) + if !ok { + return fmt.Errorf("illegal pod event") + } + + if !allowedUseExtRes(podEvent.QoSLevel) { + return nil + } + + resources := utilpod.CalculateExtendResources(podEvent.Pod) + var errs []error + // set container and pod level cgroup. + for _, cr := range resources { + cgroupPath, err := r.cgroupMgr.GetPodCgroupPath(podEvent.QoSClass, cr.CgroupSubSystem, podEvent.UID) + if err != nil { + klog.ErrorS(err, "Failed to get pod cgroup", "pod", klog.KObj(podEvent.Pod), "subSystem", cr.CgroupSubSystem) + errs = append(errs, err) + } + + filePath := path.Join(cgroupPath, cr.ContainerID, cr.SubPath) + err = utils.UpdateFile(filePath, []byte(strconv.FormatInt(cr.Value, 10))) + if os.IsNotExist(err) { + klog.InfoS("Cgroup file not existed", "filePath", filePath) + continue + } + + if err != nil { + errs = append(errs, err) + klog.ErrorS(err, "Failed to set cgroup", "path", filePath, "pod", klog.KObj(podEvent.Pod)) + continue + } + klog.InfoS("Successfully set cpu and memory cgroup", "path", filePath, "pod", klog.KObj(podEvent.Pod)) + } + return utilerrors.NewAggregate(errs) +} + +// allowedUseExtRes defines what qos levels can use extension resources, +// currently only qos level QosLevelLS and QosLevelBE can use. +func allowedUseExtRes(qosLevel int64) bool { + return qosLevel <= 1 +} diff --git a/pkg/agent/events/handlers/resources/resources_test.go b/pkg/agent/events/handlers/resources/resources_test.go new file mode 100644 index 000000000..08879f6f8 --- /dev/null +++ b/pkg/agent/events/handlers/resources/resources_test.go @@ -0,0 +1,184 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package resources + +import ( + "fmt" + "os" + "path" + "testing" + + "github.com/stretchr/testify/assert" + v1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/resource" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/types" + + "volcano.sh/volcano/pkg/agent/events/framework" + "volcano.sh/volcano/pkg/agent/events/handlers/base" + "volcano.sh/volcano/pkg/agent/features" + "volcano.sh/volcano/pkg/agent/utils/cgroup" + "volcano.sh/volcano/pkg/agent/utils/file" +) + +func TestResourcesHandle_Handle(t *testing.T) { + tmpDir := t.TempDir() + containerID1 := "65a6099d" + containerID2 := "13b017b7" + tests := []struct { + name string + cgroupMgr cgroup.CgroupManager + event interface{} + prepare func() + post func() map[string]string + wantErr bool + wantVal map[string]string + }{ + { + name: "illegal pod event, return err", + cgroupMgr: cgroup.NewCgroupManager("cgroupfs", tmpDir, ""), + event: &framework.NodeResourceEvent{}, + wantErr: true, + }, + { + name: "set correctly", + cgroupMgr: cgroup.NewCgroupManager("cgroupfs", tmpDir, ""), + event: framework.PodEvent{ + UID: "uid1", + QoSLevel: -1, + QoSClass: "Burstable", + Pod: buildPodWithContainerID("p1", "uid1", containerID1, containerID2), + }, + prepare: func() { + prepare(t, tmpDir, "uid1", containerID1, containerID2) + }, + post: func() map[string]string { + return file.ReadBatchFromFile([]string{ + path.Join(tmpDir, "cpu/kubepods/burstable/poduid1/65a6099d/cpu.shares"), + path.Join(tmpDir, "cpu/kubepods/burstable/poduid1/65a6099d/cpu.cfs_quota_us"), + path.Join(tmpDir, "cpu/kubepods/burstable/poduid1/13b017b7/cpu.shares"), + path.Join(tmpDir, "memory/kubepods/burstable/poduid1/13b017b7/memory.limit_in_bytes"), + path.Join(tmpDir, "cpu/kubepods/burstable/poduid1/cpu.shares"), + }) + }, + wantErr: false, + wantVal: map[string]string{ + // container1 + path.Join(tmpDir, "cpu/kubepods/burstable/poduid1/65a6099d/cpu.shares"): "512", + path.Join(tmpDir, "cpu/kubepods/burstable/poduid1/65a6099d/cpu.cfs_quota_us"): "200000", + + // container2 + path.Join(tmpDir, "cpu/kubepods/burstable/poduid1/13b017b7/cpu.shares"): "1024", + path.Join(tmpDir, "memory/kubepods/burstable/poduid1/13b017b7/memory.limit_in_bytes"): "10737418240", + + // pod + path.Join(tmpDir, "cpu/kubepods/burstable/poduid1/cpu.shares"): "1536", + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + r := &ResourcesHandle{ + BaseHandle: &base.BaseHandle{ + Name: string(features.ResourcesFeature), + Config: nil, + Active: true, + }, + cgroupMgr: tt.cgroupMgr, + } + if tt.prepare != nil { + tt.prepare() + } + if err := r.Handle(tt.event); (err != nil) != tt.wantErr { + t.Errorf("Handle() error = %v, wantErr %v", err, tt.wantErr) + } + if tt.post != nil { + assert.Equal(t, tt.wantVal, tt.post()) + } + }) + } +} + +func buildPodWithContainerID(name, uid, containerID1, containerID2 string) *v1.Pod { + return &v1.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Name: name, + UID: types.UID(uid), + }, + Spec: v1.PodSpec{Containers: []v1.Container{ + { + Name: "container-1", + Resources: v1.ResourceRequirements{ + Limits: map[v1.ResourceName]resource.Quantity{ + "kubernetes.io/batch-cpu": *resource.NewQuantity(2000, resource.DecimalSI), + }, + Requests: map[v1.ResourceName]resource.Quantity{ + "kubernetes.io/batch-cpu": *resource.NewQuantity(500, resource.DecimalSI), + "kubernetes.io/batch-memory": *resource.NewQuantity(1024, resource.BinarySI), + }, + }, + }, + { + Name: "container-2", + Resources: v1.ResourceRequirements{ + Limits: map[v1.ResourceName]resource.Quantity{ + // limit=10Gi + "kubernetes.io/batch-memory": *resource.NewQuantity(1024*1024*1024*10, resource.BinarySI), + }, + Requests: map[v1.ResourceName]resource.Quantity{ + "kubernetes.io/batch-cpu": *resource.NewQuantity(1000, resource.DecimalSI), + "kubernetes.io/batch-memory": *resource.NewQuantity(1024*1024*1024*5, resource.BinarySI), + }, + }, + }, + }}, + Status: v1.PodStatus{ + ContainerStatuses: []v1.ContainerStatus{ + { + Name: "container-1", + ContainerID: fmt.Sprintf("containerd://%s", containerID1), + }, + { + Name: "container-2", + ContainerID: fmt.Sprintf("docker://%s", containerID2), + }, + }, + }, + } +} + +func prepare(t *testing.T, tmpDir, podUID, containerID1, containerID2 string) { + containers := []string{containerID1, containerID2} + cgroupPaths := []string{"cpu.cfs_quota_us", "cpu.shares", "memory.limit_in_bytes"} + subSystems := []string{"cpu", "memory"} + for _, c := range containers { + for _, ss := range subSystems { + podDir := path.Join(tmpDir, ss, "kubepods", "burstable", "pod"+podUID) + containerDir := path.Join(podDir, c) + err := os.MkdirAll(containerDir, 0644) + assert.NoError(t, err) + for _, cgrouPath := range cgroupPaths { + // create pod level cgroup. + _, err := os.OpenFile(path.Join(podDir, cgrouPath), os.O_RDWR|os.O_CREATE, 0644) + assert.NoError(t, err) + // create container level cgroup. + _, err = os.OpenFile(path.Join(containerDir, cgrouPath), os.O_RDWR|os.O_CREATE, 0644) + assert.NoError(t, err) + } + } + } +} diff --git a/pkg/agent/events/probes/nodemonitor/node_monitor.go b/pkg/agent/events/probes/nodemonitor/node_monitor.go new file mode 100644 index 000000000..b9f3bb7f4 --- /dev/null +++ b/pkg/agent/events/probes/nodemonitor/node_monitor.go @@ -0,0 +1,202 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package nodemonitor + +import ( + "sync" + "time" + + v1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/util/wait" + "k8s.io/client-go/util/workqueue" + "k8s.io/klog/v2" + + "volcano.sh/volcano/pkg/agent/apis" + "volcano.sh/volcano/pkg/agent/config/api" + "volcano.sh/volcano/pkg/agent/events/framework" + "volcano.sh/volcano/pkg/agent/events/probes" + "volcano.sh/volcano/pkg/agent/oversubscription/policy" + "volcano.sh/volcano/pkg/agent/oversubscription/queue" + "volcano.sh/volcano/pkg/agent/utils" + "volcano.sh/volcano/pkg/agent/utils/eviction" + utilnode "volcano.sh/volcano/pkg/agent/utils/node" + utilpod "volcano.sh/volcano/pkg/agent/utils/pod" + "volcano.sh/volcano/pkg/config" + "volcano.sh/volcano/pkg/metriccollect" + "volcano.sh/volcano/pkg/metriccollect/local" + "volcano.sh/volcano/pkg/resourceusage" +) + +func init() { + probes.RegisterEventProbeFunc(string(framework.NodeMonitorEventName), NewMonitor) +} + +const ( + highUsageCountLimit = 6 +) + +type monitor struct { + sync.Mutex + *config.Configuration + policy.Interface + cfgLock sync.RWMutex + queue workqueue.RateLimitingInterface + lowWatermark apis.Watermark + highWatermark apis.Watermark + // highUsageCountByResName is used to record whether resources usage are high. + highUsageCountByResName map[v1.ResourceName]int + getNodeFunc utilnode.ActiveNode + getPodsFunc utilpod.ActivePods + usageGetter resourceusage.Getter +} + +func NewMonitor(config *config.Configuration, mgr *metriccollect.MetricCollectorManager, workQueue workqueue.RateLimitingInterface) framework.Probe { + evictor := eviction.NewEviction(config.GenericConfiguration.KubeClient, config.GenericConfiguration.KubeNodeName) + return &monitor{ + Interface: policy.GetPolicyFunc(config.GenericConfiguration.OverSubscriptionPolicy)(config, mgr, evictor, queue.NewSqQueue(), local.CollectorName), + queue: workQueue, + getNodeFunc: config.GetNode, + getPodsFunc: config.GetActivePods, + lowWatermark: make(apis.Watermark), + highWatermark: make(apis.Watermark), + highUsageCountByResName: make(map[v1.ResourceName]int), + usageGetter: resourceusage.NewUsageGetter(mgr, local.CollectorName), + } +} + +func (m *monitor) ProbeName() string { + return "NodePressureProbe" +} + +func (m *monitor) Run(stop <-chan struct{}) { + klog.InfoS("Started nodePressure probe") + go wait.Until(m.utilizationMonitoring, 10*time.Second, stop) + go wait.Until(m.detect, 10*time.Second, stop) +} + +func (m *monitor) RefreshCfg(cfg *api.ColocationConfig) error { + m.cfgLock.Lock() + utils.SetEvictionWatermark(cfg, m.lowWatermark, m.highWatermark) + m.cfgLock.Unlock() + + m.Lock() + defer m.Unlock() + // reset historical statics + // TODO: make this more fine-grained, only when new setting is a higher watermark should we reset. + m.highUsageCountByResName = map[v1.ResourceName]int{} + return nil +} + +func (m *monitor) utilizationMonitoring() { + m.Lock() + defer m.Unlock() + + node, err := m.getNodeFunc() + if err != nil { + klog.ErrorS(err, "Eviction: failed to get node") + m.highUsageCountByResName = map[v1.ResourceName]int{} + return + } + nodeCopy := node.DeepCopy() + + // check if resource usage is high + usage := m.usageGetter.UsagesByPercentage(nodeCopy) + for _, res := range apis.OverSubscriptionResourceTypes { + if m.isHighResourceUsageOnce(nodeCopy, apis.Resource(usage), res) { + m.highUsageCountByResName[res]++ + } else { + m.highUsageCountByResName[res] = 0 + } + } +} + +func (m *monitor) detect() { + node, err := m.getNodeFunc() + if err != nil { + klog.ErrorS(err, "Eviction: failed to get node") + return + } + nodeCopy := node.DeepCopy() + + allResourcesAreLowUsage := true + for _, res := range apis.OverSubscriptionResourceTypes { + // Getting pod to be evicted should be executed in every resource for loop, + // it's important because for every resource we should get the latest pods state. + _, resList, err := utilnode.GetLatestPodsAndResList(nodeCopy, m.getPodsFunc, res) + if err != nil { + klog.ErrorS(err, "Failed to get pods and resource list") + return + } + if m.ShouldEvict(nodeCopy, res, resList, m.nodeHasPressure(res)) { + event := framework.NodeMonitorEvent{ + TimeStamp: time.Now(), + Resource: res, + } + klog.InfoS("Node pressure detected", "resource", res, "time", event.TimeStamp) + m.queue.Add(event) + } + + usage := m.usageGetter.UsagesByPercentage(nodeCopy) + if !m.isLowResourceUsageOnce(nodeCopy, apis.Resource(usage), res) { + allResourcesAreLowUsage = false + } + } + + // Only remove eviction annotation when all resources are low usage. + if !allResourcesAreLowUsage { + return + } + if err := m.RecoverSchedule(); err != nil { + klog.ErrorS(err, "Failed to recover schedule") + } +} + +func (m *monitor) isHighResourceUsageOnce(node *v1.Node, usage apis.Resource, resName v1.ResourceName) bool { + m.cfgLock.RLock() + defer m.cfgLock.RUnlock() + //TODO: set in node config + _, highWatermark, exists, err := utilnode.WatermarkAnnotationSetting(node) + if !exists { + return usage[resName] >= int64(m.highWatermark[resName]) + } + if err != nil { + klog.ErrorS(err, "Failed to get watermark in annotation") + return usage[resName] >= int64(m.highWatermark[resName]) + } + return usage[resName] >= highWatermark[resName] +} + +func (m *monitor) isLowResourceUsageOnce(node *v1.Node, usage apis.Resource, resName v1.ResourceName) bool { + m.cfgLock.RLock() + defer m.cfgLock.RUnlock() + lowWatermark, _, exists, err := utilnode.WatermarkAnnotationSetting(node) + if !exists { + return usage[resName] <= int64(m.lowWatermark[resName]) + } + if err != nil { + klog.ErrorS(err, "Failed to get watermark in annotation") + return usage[resName] <= int64(m.lowWatermark[resName]) + } + return usage[resName] <= lowWatermark[resName] +} + +func (m *monitor) nodeHasPressure(resName v1.ResourceName) bool { + m.Lock() + defer m.Unlock() + + return m.highUsageCountByResName[resName] >= highUsageCountLimit +} diff --git a/pkg/agent/events/probes/nodemonitor/node_monitor_test.go b/pkg/agent/events/probes/nodemonitor/node_monitor_test.go new file mode 100644 index 000000000..98e0f6f23 --- /dev/null +++ b/pkg/agent/events/probes/nodemonitor/node_monitor_test.go @@ -0,0 +1,151 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package nodemonitor + +import ( + "context" + "testing" + + "github.com/stretchr/testify/assert" + v1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + fakeclientset "k8s.io/client-go/kubernetes/fake" + "k8s.io/client-go/util/workqueue" + + "volcano.sh/volcano/pkg/agent/apis" + "volcano.sh/volcano/pkg/agent/events/framework" + "volcano.sh/volcano/pkg/agent/oversubscription/policy" + "volcano.sh/volcano/pkg/agent/oversubscription/policy/extend" + "volcano.sh/volcano/pkg/agent/utils/eviction" + utilnode "volcano.sh/volcano/pkg/agent/utils/node" + utilpod "volcano.sh/volcano/pkg/agent/utils/pod" + "volcano.sh/volcano/pkg/config" + "volcano.sh/volcano/pkg/resourceusage" +) + +func makeNode() (*v1.Node, error) { + return &v1.Node{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test-node", + Labels: map[string]string{ + apis.OverSubscriptionNodeLabelKey: "true", + }, + }, + Spec: v1.NodeSpec{Taints: []v1.Taint{{ + Key: apis.PodEvictingKey, + Effect: v1.TaintEffectNoSchedule, + }}}, + }, nil +} + +func Test_monitor_detect(t *testing.T) { + tests := []struct { + name string + Configuration *config.Configuration + policy func(cfg *config.Configuration, pods utilpod.ActivePods, evictor eviction.Eviction) policy.Interface + queue workqueue.RateLimitingInterface + lowWatermark apis.Watermark + highWatermark apis.Watermark + highUsageCountByResName map[v1.ResourceName]int + getNodeFunc utilnode.ActiveNode + getPodsFunc utilpod.ActivePods + usageGetter resourceusage.Getter + expectedNode func() *v1.Node + expectedRes v1.ResourceName + expectedLen int + }{ + { + name: "cpu in high usage with extend resource", + highUsageCountByResName: map[v1.ResourceName]int{v1.ResourceCPU: 6}, + getNodeFunc: makeNode, + getPodsFunc: func() ([]*v1.Pod, error) { + return []*v1.Pod{}, nil + }, + policy: func(cfg *config.Configuration, pods utilpod.ActivePods, evictor eviction.Eviction) policy.Interface { + return extend.NewExtendResource(cfg, nil, evictor, nil, "") + }, + usageGetter: resourceusage.NewFakeResourceGetter(0, 0, 60, 60), + expectedRes: v1.ResourceCPU, + expectedLen: 1, + }, + { + name: "remove taint when use extend resource", + highUsageCountByResName: map[v1.ResourceName]int{v1.ResourceCPU: 5}, + getNodeFunc: makeNode, + getPodsFunc: func() ([]*v1.Pod, error) { + return []*v1.Pod{}, nil + }, + policy: func(cfg *config.Configuration, pods utilpod.ActivePods, evictor eviction.Eviction) policy.Interface { + return extend.NewExtendResource(cfg, nil, evictor, nil, "") + }, + usageGetter: resourceusage.NewFakeResourceGetter(0, 0, 20, 20), + expectedRes: v1.ResourceCPU, + expectedNode: func() *v1.Node { + node, err := makeNode() + assert.NoError(t, err) + node.Spec.Taints = nil + return node + }, + expectedLen: 0, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + fakeNode, err := makeNode() + assert.NoError(t, err) + fakeClient := fakeclientset.NewSimpleClientset(fakeNode) + cfg := &config.Configuration{GenericConfiguration: &config.VolcanoAgentConfiguration{ + KubeClient: fakeClient, + KubeNodeName: "test-node", + NodeHasSynced: func() bool { + return false + }, + }} + queue := workqueue.NewNamedRateLimitingQueue(nil, "test") + m := &monitor{ + queue: queue, + Configuration: cfg, + Interface: tt.policy(cfg, nil, nil), + highUsageCountByResName: tt.highUsageCountByResName, + lowWatermark: map[v1.ResourceName]int{v1.ResourceCPU: 30, v1.ResourceMemory: 30}, + getNodeFunc: tt.getNodeFunc, + getPodsFunc: tt.getPodsFunc, + usageGetter: tt.usageGetter, + } + m.detect() + assert.Equalf(t, tt.expectedLen, queue.Len(), "detect()") + if queue.Len() != 0 { + key, shutdown := queue.Get() + if shutdown { + t.Errorf("Unexpected: queue is shutdown") + } + event, ok := key.(framework.NodeMonitorEvent) + if !ok { + t.Errorf("Invalid event: %v", key) + } + assert.Equalf(t, tt.expectedRes, event.Resource, "detect()") + } + if tt.expectedNode != nil { + node, err := fakeClient.CoreV1().Nodes().Get(context.TODO(), "test-node", metav1.GetOptions{}) + if err != nil { + t.Errorf("Failed to get node, err: %v", err) + } + assert.Equalf(t, tt.expectedNode(), node, "detect()") + } + }) + } +} diff --git a/pkg/agent/events/probes/noderesources/resource_calculator.go b/pkg/agent/events/probes/noderesources/resource_calculator.go new file mode 100644 index 000000000..963ab2f07 --- /dev/null +++ b/pkg/agent/events/probes/noderesources/resource_calculator.go @@ -0,0 +1,169 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package noderesources + +import ( + "fmt" + "strings" + "sync" + "time" + + v1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/util/sets" + "k8s.io/apimachinery/pkg/util/wait" + "k8s.io/client-go/util/workqueue" + "k8s.io/klog/v2" + + "volcano.sh/volcano/pkg/agent/apis" + "volcano.sh/volcano/pkg/agent/config/api" + "volcano.sh/volcano/pkg/agent/events/framework" + "volcano.sh/volcano/pkg/agent/events/probes" + "volcano.sh/volcano/pkg/agent/oversubscription/policy" + "volcano.sh/volcano/pkg/agent/oversubscription/queue" + utilnode "volcano.sh/volcano/pkg/agent/utils/node" + "volcano.sh/volcano/pkg/config" + "volcano.sh/volcano/pkg/metriccollect" + "volcano.sh/volcano/pkg/metriccollect/local" +) + +func init() { + probes.RegisterEventProbeFunc(string(framework.NodeResourcesEventName), NewCalculator) +} + +// historicalUsageCalculator is used to calculate the overSubscription +type historicalUsageCalculator struct { + sync.Mutex + cfgLock sync.Mutex + policy.Interface + usages workqueue.RateLimitingInterface + queue *queue.SqQueue + resourceTypes sets.String + getNodeFunc utilnode.ActiveNode +} + +// NewCalculator return overSubscription reporter by algorithm +func NewCalculator(config *config.Configuration, mgr *metriccollect.MetricCollectorManager, workQueue workqueue.RateLimitingInterface) framework.Probe { + sqQueue := queue.NewSqQueue() + return &historicalUsageCalculator{ + Interface: policy.GetPolicyFunc(config.GenericConfiguration.OverSubscriptionPolicy)(config, mgr, nil, sqQueue, local.CollectorName), + usages: workQueue, + queue: sqQueue, + resourceTypes: sets.NewString(), + getNodeFunc: config.GetNode, + } +} + +func (r *historicalUsageCalculator) Run(stop <-chan struct{}) { + klog.InfoS("Started nodeResources probe") + go wait.Until(r.CalOverSubscriptionResources, 10*time.Second, stop) + go wait.Until(r.preProcess, 10*time.Second, stop) +} + +func (r *historicalUsageCalculator) ProbeName() string { + return "NodeResourcesProbe" +} + +func (r *historicalUsageCalculator) RefreshCfg(cfg *api.ColocationConfig) error { + r.cfgLock.Lock() + defer r.cfgLock.Unlock() + + if cfg == nil || cfg.OverSubscriptionConfig == nil || cfg.OverSubscriptionConfig.OverSubscriptionTypes == nil { + return fmt.Errorf("nil colocation cfg") + } + // refresh overSubscription resource types. + set := sets.NewString() + typ := strings.Split(*cfg.OverSubscriptionConfig.OverSubscriptionTypes, ",") + for _, resType := range typ { + if resType == "" { + continue + } + set.Insert(strings.TrimSpace(resType)) + } + r.resourceTypes = set + return nil +} + +func (r *historicalUsageCalculator) preProcess() { + node, err := r.getNodeFunc() + if err != nil { + klog.ErrorS(nil, "OverSubscription: failed to get node") + return + } + nodeCopy := node.DeepCopy() + if !r.SupportOverSubscription(nodeCopy) { + return + } + + overSubRes := r.computeOverSubRes() + if overSubRes == nil { + return + } + customizationTypes := r.getOverSubscriptionTypes(nodeCopy) + for _, resType := range apis.OverSubscriptionResourceTypes { + if !customizationTypes[resType] { + overSubRes[resType] = 0 + } + } + r.usages.Add(framework.NodeResourceEvent{MillCPU: overSubRes[v1.ResourceCPU], MemoryBytes: overSubRes[v1.ResourceMemory]}) +} + +// computeOverSubRes calculate overSubscription resources +func (r *historicalUsageCalculator) computeOverSubRes() apis.Resource { + historicalUsages := r.queue.GetAll() + if len(historicalUsages) == 0 { + return nil + } + + overSubRes := make(apis.Resource) + totalWeight := int64(0) + initWeight := int64(1) + for _, usage := range historicalUsages { + totalWeight += initWeight + for _, res := range apis.OverSubscriptionResourceTypes { + overSubRes[res] = overSubRes[res] + usage[res]*initWeight + } + initWeight = initWeight * 2 + } + for _, res := range apis.OverSubscriptionResourceTypes { + overSubRes[res] = overSubRes[res] / totalWeight + } + return overSubRes +} + +func (r *historicalUsageCalculator) getOverSubscriptionTypes(node *v1.Node) map[v1.ResourceName]bool { + r.cfgLock.Lock() + defer r.cfgLock.Unlock() + ret := make(map[v1.ResourceName]bool) + for _, item := range r.resourceTypes.List() { + ret[v1.ResourceName(item)] = true + } + + // be compatible with old api. + value, exists := node.Annotations[apis.OverSubscriptionTypesKey] + if !exists || value == "" { + return ret + } + ret = make(map[v1.ResourceName]bool) + typ := strings.Split(value, ",") + for _, resType := range typ { + if resType == "" { + continue + } + ret[v1.ResourceName(strings.TrimSpace(resType))] = true + } + return ret +} diff --git a/pkg/agent/events/probes/noderesources/resource_calculator_test.go b/pkg/agent/events/probes/noderesources/resource_calculator_test.go new file mode 100644 index 000000000..6c80eca71 --- /dev/null +++ b/pkg/agent/events/probes/noderesources/resource_calculator_test.go @@ -0,0 +1,288 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package noderesources + +import ( + "fmt" + "os" + "path" + "testing" + + . "github.com/agiledragon/gomonkey/v2" + "github.com/stretchr/testify/assert" + v1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/resource" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/util/sets" + "k8s.io/client-go/util/workqueue" + utilpointer "k8s.io/utils/pointer" + + "volcano.sh/volcano/pkg/agent/apis" + "volcano.sh/volcano/pkg/agent/config/api" + "volcano.sh/volcano/pkg/agent/events/framework" + "volcano.sh/volcano/pkg/agent/oversubscription/policy/extend" + "volcano.sh/volcano/pkg/agent/oversubscription/queue" + utilnode "volcano.sh/volcano/pkg/agent/utils/node" + utilpod "volcano.sh/volcano/pkg/agent/utils/pod" + utiltesting "volcano.sh/volcano/pkg/agent/utils/testing" + "volcano.sh/volcano/pkg/config" + "volcano.sh/volcano/pkg/metriccollect" + fakecollector "volcano.sh/volcano/pkg/metriccollect/testing" +) + +func makeNode() (*v1.Node, error) { + return &v1.Node{ + ObjectMeta: metav1.ObjectMeta{ + Annotations: map[string]string{ + apis.OverSubscriptionTypesKey: "cpu", + }, + Labels: map[string]string{ + apis.OverSubscriptionNodeLabelKey: "true", + }, + }, + Status: v1.NodeStatus{Allocatable: map[v1.ResourceName]resource.Quantity{ + v1.ResourceCPU: *resource.NewMilliQuantity(3000, resource.DecimalSI), + v1.ResourceMemory: *resource.NewQuantity(10000, resource.BinarySI), + }}, + }, nil +} + +func Test_historicalUsageCalculator_utilizationMonitoring(t *testing.T) { + dir, err := os.MkdirTemp("", "cpuManagerPolicy") + assert.NoError(t, err) + defer func() { + err = os.RemoveAll(dir) + assert.NoError(t, err) + }() + + cfg := &config.Configuration{ + GenericConfiguration: &config.VolcanoAgentConfiguration{ + OverSubscriptionRatio: 60, + }, + } + + mgr, err := metriccollect.NewMetricCollectorManager(cfg, nil) + assert.NoError(t, err) + + tests := []struct { + name string + usages workqueue.RateLimitingInterface + getPodsFunc utilpod.ActivePods + getNodeFunc utilnode.ActiveNode + prepare func() + expectRes []apis.Resource + }{ + { + name: "calculate using extend cpu&memory && cpu manager policy none", + usages: workqueue.NewNamedRateLimitingQueue(nil, "calculator"), + getNodeFunc: makeNode, + prepare: func() { + err = os.Setenv("KUBELET_ROOT_DIR", dir) + assert.NoError(t, err) + b := []byte(`{"policyName":"none","defaultCpuSet":"0-1","checksum":1636926438}`) + err = os.WriteFile(path.Join(dir, "cpu_manager_state"), b, 0600) + assert.NoError(t, err) + }, + getPodsFunc: func() ([]*v1.Pod, error) { + return []*v1.Pod{ + utiltesting.MakePod("online-1", 3, 2000, ""), + utiltesting.MakePod("online-2", 2, 2000, ""), + utiltesting.MakePodWithExtendResources("offline-1", 1000, 1000, "BE"), + }, nil + }, + expectRes: []apis.Resource{{v1.ResourceCPU: 1200, v1.ResourceMemory: 4800}}, + }, + { + name: "calculate using extend cpu&memory && cpu manager policy static", + usages: workqueue.NewNamedRateLimitingQueue(nil, "calculator"), + getNodeFunc: makeNode, + prepare: func() { + err = os.Setenv("KUBELET_ROOT_DIR", dir) + assert.NoError(t, err) + b := []byte(`{"policyName":"static","defaultCpuSet":"0-1","checksum":1636926438}`) + err = os.WriteFile(path.Join(dir, "cpu_manager_state"), b, 0600) + assert.NoError(t, err) + }, + getPodsFunc: func() ([]*v1.Pod, error) { + return []*v1.Pod{ + utiltesting.MakePod("online-1", 1, 2000, ""), + utiltesting.MakePod("online-2", 1, 2000, ""), + utiltesting.MakePodWithExtendResources("offline-1", 1000, 1000, "BE"), + }, nil + }, + expectRes: []apis.Resource{{v1.ResourceCPU: 0, v1.ResourceMemory: 4800}}, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + sqQueue := queue.NewSqQueue() + + ApplyFunc(cfg.GetActivePods, func() ([]*v1.Pod, error) { + return tt.getPodsFunc() + }) + ApplyFunc(cfg.GetNode, func() (*v1.Node, error) { + return tt.getNodeFunc() + }) + r := &historicalUsageCalculator{ + // fake collector: cpu:1000m, memory:2000byte + Interface: extend.NewExtendResource(cfg, mgr, nil, sqQueue, fakecollector.CollectorName), + usages: tt.usages, + queue: sqQueue, + getNodeFunc: tt.getNodeFunc, + } + if tt.prepare != nil { + tt.prepare() + } + r.CalOverSubscriptionResources() + res := r.queue.GetAll() + assert.Equalf(t, tt.expectRes, res, "utilizationMonitoring") + }) + } +} + +func Test_historicalUsageCalculator_preProcess(t *testing.T) { + queue := queue.NewSqQueue() + queue.Enqueue(apis.Resource{ + v1.ResourceCPU: 1000, + v1.ResourceMemory: 1500, + }) + + queue.Enqueue(apis.Resource{ + v1.ResourceCPU: 1000, + v1.ResourceMemory: 1500, + }) + + tests := []struct { + name string + getNodeFunc utilnode.ActiveNode + getPodsFunc utilpod.ActivePods + resourceTypes sets.String + expectedResource framework.NodeResourceEvent + }{ + { + name: "default report cpu and memory", + getNodeFunc: func() (*v1.Node, error) { + node, err := makeNode() + assert.NoError(t, err) + node.Annotations = nil + return node, nil + }, + getPodsFunc: func() ([]*v1.Pod, error) { + return []*v1.Pod{ + utiltesting.MakePod("online-1", 3, 2000, ""), + utiltesting.MakePod("online-2", 2, 2000, ""), + utiltesting.MakePod("offline-1", 2, 2000, "BE"), + }, nil + }, + expectedResource: framework.NodeResourceEvent{ + MillCPU: 1000, + MemoryBytes: 1500, + }, + }, + { + name: "only report cpu with node annotation specified", + getNodeFunc: makeNode, + getPodsFunc: func() ([]*v1.Pod, error) { + return []*v1.Pod{ + utiltesting.MakePod("online-1", 3, 2000, ""), + utiltesting.MakePod("online-2", 2, 2000, ""), + utiltesting.MakePod("online-3", 2, 2000, ""), + }, nil + }, + expectedResource: framework.NodeResourceEvent{ + MillCPU: 1000, + MemoryBytes: 0, + }, + }, + } + + cfg := &config.Configuration{ + GenericConfiguration: &config.VolcanoAgentConfiguration{ + OverSubscriptionRatio: 60, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + r := &historicalUsageCalculator{ + Interface: extend.NewExtendResource(cfg, nil, nil, queue, ""), + queue: queue, + usages: workqueue.NewNamedRateLimitingQueue(nil, ""), + getNodeFunc: tt.getNodeFunc, + resourceTypes: sets.NewString("cpu", "memory"), + } + r.preProcess() + usages, shutdown := r.usages.Get() + if shutdown { + t.Errorf("queue shutdown") + } + event, ok := usages.(framework.NodeResourceEvent) + if !ok { + t.Errorf("illegal node resource event") + } + assert.Equal(t, tt.expectedResource, event) + }) + } +} + +func Test_historicalUsageCalculator_RefreshCfg(t *testing.T) { + tests := []struct { + name string + resourceTypes sets.String + cfg *api.ColocationConfig + expectedResourceType sets.String + wantErr assert.ErrorAssertionFunc + }{ + { + name: "return err", + cfg: nil, + resourceTypes: sets.NewString(), + expectedResourceType: sets.NewString(), + wantErr: assert.Error, + }, + { + name: "empty config", + cfg: &api.ColocationConfig{OverSubscriptionConfig: &api.OverSubscription{OverSubscriptionTypes: utilpointer.String("")}}, + resourceTypes: sets.NewString(), + expectedResourceType: sets.NewString(), + wantErr: assert.NoError, + }, + { + name: "cpu", + cfg: &api.ColocationConfig{OverSubscriptionConfig: &api.OverSubscription{OverSubscriptionTypes: utilpointer.String("cpu")}}, + resourceTypes: sets.NewString(), + expectedResourceType: sets.NewString("cpu"), + wantErr: assert.NoError, + }, + { + name: "cpu and memory", + cfg: &api.ColocationConfig{OverSubscriptionConfig: &api.OverSubscription{OverSubscriptionTypes: utilpointer.String("cpu,memory")}}, + resourceTypes: sets.NewString(), + expectedResourceType: sets.NewString("cpu", "memory"), + wantErr: assert.NoError, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + r := &historicalUsageCalculator{ + resourceTypes: tt.resourceTypes, + } + tt.wantErr(t, r.RefreshCfg(tt.cfg), fmt.Sprintf("RefreshCfg(%v)", tt.cfg)) + assert.Equal(t, tt.expectedResourceType, r.resourceTypes) + }) + } +} diff --git a/pkg/agent/events/probes/pods/pods.go b/pkg/agent/events/probes/pods/pods.go new file mode 100644 index 000000000..62b4bca07 --- /dev/null +++ b/pkg/agent/events/probes/pods/pods.go @@ -0,0 +1,86 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package pods + +import ( + corev1 "k8s.io/api/core/v1" + "k8s.io/client-go/tools/cache" + "k8s.io/client-go/util/workqueue" + "k8s.io/klog/v2" + + "volcano.sh/volcano/pkg/agent/apis/extension" + "volcano.sh/volcano/pkg/agent/config/api" + "volcano.sh/volcano/pkg/agent/events/framework" + "volcano.sh/volcano/pkg/agent/events/probes" + "volcano.sh/volcano/pkg/config" + "volcano.sh/volcano/pkg/metriccollect" +) + +func init() { + probes.RegisterEventProbeFunc(string(framework.PodEventName), NewPodProbe) +} + +type PodProbe struct { + queue workqueue.RateLimitingInterface +} + +func NewPodProbe(config *config.Configuration, mgr *metriccollect.MetricCollectorManager, queue workqueue.RateLimitingInterface) framework.Probe { + podHandler := cache.ResourceEventHandlerFuncs{ + AddFunc: func(obj interface{}) { enqueuePod(obj, queue) }, + UpdateFunc: func(oldObj, newObj interface{}) { enqueuePod(newObj, queue) }, + DeleteFunc: func(obj interface{}) {}, + } + config.InformerFactory.K8SInformerFactory.Core().V1().Pods().Informer().AddEventHandler(podHandler) + return &PodProbe{ + queue: queue, + } +} + +func (p *PodProbe) ProbeName() string { + return "PodProbe" +} + +func (p *PodProbe) Run(stop <-chan struct{}) { + klog.InfoS("Start pod probe") + <-stop +} + +func (p *PodProbe) RefreshCfg(cfg *api.ColocationConfig) error { + return nil +} + +func enqueuePod(obj interface{}, queue workqueue.RateLimitingInterface) { + pod, ok := obj.(*corev1.Pod) + if !ok { + klog.ErrorS(nil, "Pod phase invoked with an invalid data struct", "obj", obj) + return + } + + for _, podCondition := range pod.Status.Conditions { + if podCondition.Type == corev1.PodReady && podCondition.Status == corev1.ConditionTrue && pod.DeletionTimestamp == nil { + qosLevel := extension.GetQosLevel(pod) + podEvent := framework.PodEvent{ + UID: pod.UID, + QoSClass: pod.Status.QOSClass, + QoSLevel: int64(qosLevel), + Pod: pod, + } + klog.V(5).InfoS("Receive pod event", "pod", klog.KObj(pod)) + queue.Add(podEvent) + } + } +} diff --git a/pkg/agent/oversubscription/policy/extend/extend.go b/pkg/agent/oversubscription/policy/extend/extend.go new file mode 100644 index 000000000..e1b39bf40 --- /dev/null +++ b/pkg/agent/oversubscription/policy/extend/extend.go @@ -0,0 +1,152 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package extend + +import ( + corev1 "k8s.io/api/core/v1" + "k8s.io/klog/v2" + + "volcano.sh/volcano/pkg/agent/apis" + "volcano.sh/volcano/pkg/agent/oversubscription/policy" + "volcano.sh/volcano/pkg/agent/oversubscription/queue" + "volcano.sh/volcano/pkg/agent/utils/eviction" + utilnode "volcano.sh/volcano/pkg/agent/utils/node" + utilpod "volcano.sh/volcano/pkg/agent/utils/pod" + "volcano.sh/volcano/pkg/config" + "volcano.sh/volcano/pkg/metriccollect" + "volcano.sh/volcano/pkg/resourceusage" +) + +func init() { + policy.RegistryPolicy(string(ExtendResource), NewExtendResource) +} + +const ExtendResource policy.Name = "extend" + +type extendResource struct { + config *config.Configuration + getPodsFunc utilpod.ActivePods + getNodeFunc utilnode.ActiveNode + evictor eviction.Eviction + queue *queue.SqQueue + usageGetter resourceusage.Getter + ratio int +} + +func NewExtendResource(config *config.Configuration, mgr *metriccollect.MetricCollectorManager, evictor eviction.Eviction, queue *queue.SqQueue, collectorName string) policy.Interface { + return &extendResource{ + config: config, + getPodsFunc: config.GetActivePods, + getNodeFunc: config.GetNode, + evictor: evictor, + queue: queue, + usageGetter: resourceusage.NewUsageGetter(mgr, collectorName), + ratio: config.GenericConfiguration.OverSubscriptionRatio, + } +} + +func (e *extendResource) Name() string { + return string(ExtendResource) +} + +func (e *extendResource) SupportOverSubscription(node *corev1.Node) bool { + return utilnode.IsNodeSupportOverSubscription(node) +} + +func (e *extendResource) ShouldEvict(node *corev1.Node, resName corev1.ResourceName, resList *utilnode.ResourceList, hasPressure bool) bool { + return utilnode.IsNodeSupportOverSubscription(node) && hasPressure +} + +func (e *extendResource) ShouldUpdateOverSubscription(node *corev1.Node, resource apis.Resource) bool { + currentOverSubscription := utilnode.GetNodeStatusOverSubscription(node) + return policy.ShouldUpdateNodeOverSubscription(currentOverSubscription, resource) +} + +func (e *extendResource) UpdateOverSubscription(resource apis.Resource) error { + return utilnode.UpdateNodeExtendResource(e.config, resource) +} + +func (e *extendResource) Cleanup() error { + if err := utilnode.DeleteNodeOverSoldStatus(e.config); err != nil { + klog.ErrorS(err, "Failed to reset overSubscription info") + return err + } + klog.InfoS("Successfully reset overSubscription info") + if err := policy.EvictPods(&policy.EvictionCtx{ + Configuration: e.config, + Eviction: e.evictor, + GracePeriodOverride: 0, + EvictMsg: "Evict offline pod due to node overSubscription is turned off", + GetPodsFunc: e.getPodsFunc, + Filter: utilnode.UseExtendResource, + }); err != nil { + return err + } + return nil +} + +func (e *extendResource) DisableSchedule() error { + return utilnode.DisableSchedule(e.config) +} + +func (e *extendResource) RecoverSchedule() error { + return utilnode.RecoverSchedule(e.config) +} + +func (e *extendResource) CalOverSubscriptionResources() { + node, err := e.getNodeFunc() + if err != nil { + klog.ErrorS(nil, "overSubscription: failed to get node") + return + } + nodeCopy := node.DeepCopy() + + if !e.SupportOverSubscription(nodeCopy) { + return + } + + pods, err := e.getPodsFunc() + if err != nil { + klog.ErrorS(err, "Failed to get pods") + return + } + + includeGuaranteedPods := utilpod.IncludeGuaranteedPods() + currentUsage := e.usageGetter.UsagesByValue(includeGuaranteedPods) + overSubscriptionRes := make(apis.Resource) + + for _, resType := range apis.OverSubscriptionResourceTypes { + total := int64(0) + switch resType { + case corev1.ResourceCPU: + total = node.Status.Allocatable.Cpu().MilliValue() - utilpod.GuaranteedPodsCPURequest(pods) + case corev1.ResourceMemory: + total = node.Status.Allocatable.Memory().Value() + default: + klog.InfoS("overSubscription: reporter does not support resource", "resourceType", resType) + } + + if total >= currentUsage[resType] { + overSubscriptionRes[resType] = (total - currentUsage[resType]) * int64(e.ratio) / 100 + } else { + overSubscriptionRes[resType] = 0 + } + + klog.V(4).InfoS("overSubscription:", "resourceType", resType, "total", total, "usage", currentUsage[resType], "delta", overSubscriptionRes[resType]) + } + e.queue.Enqueue(overSubscriptionRes) +} diff --git a/pkg/agent/oversubscription/policy/policy.go b/pkg/agent/oversubscription/policy/policy.go new file mode 100644 index 000000000..4a5bf5d4d --- /dev/null +++ b/pkg/agent/oversubscription/policy/policy.go @@ -0,0 +1,159 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package policy + +import ( + "context" + "sync" + + corev1 "k8s.io/api/core/v1" + "k8s.io/klog/v2" + + "volcano.sh/volcano/pkg/agent/apis" + "volcano.sh/volcano/pkg/agent/oversubscription/queue" + "volcano.sh/volcano/pkg/agent/utils/eviction" + utilnode "volcano.sh/volcano/pkg/agent/utils/node" + utilpod "volcano.sh/volcano/pkg/agent/utils/pod" + "volcano.sh/volcano/pkg/config" + "volcano.sh/volcano/pkg/metriccollect" +) + +var ( + lock sync.Mutex + policyMap = make(map[string]PolicyFunc) +) + +const overSubscriptionChangeStep = 0.1 + +type PolicyFunc func(config *config.Configuration, mgr *metriccollect.MetricCollectorManager, evictor eviction.Eviction, queue *queue.SqQueue, collectorName string) Interface + +type Name string + +// Interface defines overSubscription resource policy, support overSubscription resource patch annotation currently. +// You can register your own overSubscription policy like patch overSubscription resource on node.Allocatable. +type Interface interface { + // Name is the policy name. + Name() string + // SupportOverSubscription return whether node support over subscription. + SupportOverSubscription(node *corev1.Node) bool + // ShouldEvict return whether we should evict low priority pods. + ShouldEvict(node *corev1.Node, resName corev1.ResourceName, resList *utilnode.ResourceList, hasPressure bool) bool + // CalOverSubscriptionResources calculate overSubscription resources. + CalOverSubscriptionResources() + // ShouldUpdateOverSubscription return whether new overSubscription resources should be patched. + ShouldUpdateOverSubscription(node *corev1.Node, resource apis.Resource) bool + // UpdateOverSubscription will update overSubscription resource to node. + UpdateOverSubscription(resource apis.Resource) error + // Cleanup reset overSubscription label and evict low priority pods when turn off overSubscription. + Cleanup() error + // DisableSchedule disable schedule. + DisableSchedule() error + // RecoverSchedule recover schedule. + RecoverSchedule() error +} + +func RegistryPolicy(name string, policyFunc PolicyFunc) { + lock.Lock() + defer lock.Unlock() + + if _, exist := policyMap[name]; exist { + klog.ErrorS(nil, "Policy has already been registered", "name", name) + return + } + policyMap[name] = policyFunc +} + +func GetPolicyFunc(name string) PolicyFunc { + lock.Lock() + defer lock.Unlock() + + fn, exist := policyMap[name] + if !exist { + klog.Fatalf("Policy %s not registered", name) + } + return fn +} + +type EvictionCtx struct { + *config.Configuration + eviction.Eviction + GracePeriodOverride int64 + EvictMsg string + GetPodsFunc utilpod.ActivePods + Filter func(resName corev1.ResourceName, resList *utilnode.ResourceList) bool +} + +func EvictPods(ctx *EvictionCtx) error { + evict := func(node *corev1.Node) (bool, error) { + keepGoing := false + for _, res := range apis.OverSubscriptionResourceTypes { + // Getting pod to be evicted should be executed in every resource for loop, + // it's important because for every resource we should get the latest pods state. + preemptablePods, resList, err := utilnode.GetLatestPodsAndResList(node, ctx.GetPodsFunc, res) + if err != nil { + klog.ErrorS(err, "Failed to get pods and resource list") + return true, err + } + + if !ctx.Filter(res, resList) { + continue + } + for _, pod := range preemptablePods { + klog.InfoS("Try to evict pod", "pod", klog.KObj(pod)) + if ctx.Evict(context.TODO(), pod, ctx.GenericConfiguration.Recorder, ctx.GracePeriodOverride, ctx.EvictMsg) { + keepGoing = true + break + } + } + } + return keepGoing, nil + } + + for { + node, err := ctx.GetNode() + if err != nil { + klog.ErrorS(err, "Failed to get node and pods") + return err + } + + keepGoing, err := evict(node) + if err != nil { + return err + } + if !keepGoing { + break + } + } + klog.InfoS("Successfully cleaned up resources when turn off oversubscription") + return nil +} + +func ShouldUpdateNodeOverSubscription(current, new apis.Resource) bool { + update := false + for _, res := range apis.OverSubscriptionResourceTypes { + delta := new[res] - current[res] + if delta < 0 { + delta = -delta + } + + if float64(delta)/float64(current[res]) > overSubscriptionChangeStep { + update = true + break + } + } + return update +} diff --git a/pkg/agent/oversubscription/queue/internal_queue.go b/pkg/agent/oversubscription/queue/internal_queue.go new file mode 100644 index 000000000..eaaa0c23f --- /dev/null +++ b/pkg/agent/oversubscription/queue/internal_queue.go @@ -0,0 +1,57 @@ +/* +Copyright 2024 The Volcano Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package queue + +import ( + "sync" + + "volcano.sh/volcano/pkg/agent/apis" +) + +const ( + queueSize = 10 +) + +type SqQueue struct { + sync.Mutex + data []apis.Resource +} + +func (q *SqQueue) Enqueue(r apis.Resource) { + q.Lock() + defer q.Unlock() + + q.data = append(q.data, r) + if len(q.data) > queueSize { + q.data = q.data[1:len(q.data)] + } +} + +func (q *SqQueue) GetAll() []apis.Resource { + q.Lock() + defer q.Unlock() + + queue := make([]apis.Resource, 0, len(q.data)) + queue = append(queue, q.data...) + return queue +} + +func NewSqQueue() *SqQueue { + return &SqQueue{ + data: make([]apis.Resource, 0), + } +} diff --git a/pkg/agent/utils/eviction/eviction.go b/pkg/agent/utils/eviction/eviction.go index 90a92ec43..d2da1b049 100644 --- a/pkg/agent/utils/eviction/eviction.go +++ b/pkg/agent/utils/eviction/eviction.go @@ -18,15 +18,18 @@ package eviction import ( "context" + "fmt" corev1 "k8s.io/api/core/v1" policyv1 "k8s.io/api/policy/v1" + policyv1beta1 "k8s.io/api/policy/v1beta1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" clientset "k8s.io/client-go/kubernetes" "k8s.io/client-go/tools/record" "k8s.io/klog/v2" "k8s.io/kubernetes/pkg/kubelet/types" + "volcano.sh/volcano/pkg/agent/utils" utilpod "volcano.sh/volcano/pkg/agent/utils/pod" ) @@ -41,21 +44,37 @@ const ( Reason = "Evicted" ) -func evictPod(ctx context.Context, client clientset.Interface, gracePeriodSeconds *int64, pod *corev1.Pod) error { +func evictPod(ctx context.Context, client clientset.Interface, gracePeriodSeconds *int64, pod *corev1.Pod, evictionVersion string) error { if *gracePeriodSeconds < int64(0) { *gracePeriodSeconds = int64(0) } - eviction := &policyv1.Eviction{ - ObjectMeta: metav1.ObjectMeta{ - Name: pod.Name, - Namespace: pod.Namespace, - }, - DeleteOptions: &metav1.DeleteOptions{ - GracePeriodSeconds: gracePeriodSeconds, - }, + + switch evictionVersion { + case "v1": + eviction := &policyv1.Eviction{ + ObjectMeta: metav1.ObjectMeta{ + Name: pod.Name, + Namespace: pod.Namespace, + }, + DeleteOptions: &metav1.DeleteOptions{ + GracePeriodSeconds: gracePeriodSeconds, + }, + } + return client.PolicyV1().Evictions(pod.Namespace).Evict(ctx, eviction) + case "v1beta1": + eviction := &policyv1beta1.Eviction{ + ObjectMeta: metav1.ObjectMeta{ + Name: pod.Name, + Namespace: pod.Namespace, + }, + DeleteOptions: &metav1.DeleteOptions{ + GracePeriodSeconds: gracePeriodSeconds, + }, + } + return client.PolicyV1beta1().Evictions(pod.Namespace).Evict(ctx, eviction) + default: + return fmt.Errorf("unsupported eviction version: %s", evictionVersion) } - // TODO: get policy version dynamically using discovery client. - return client.PolicyV1().Evictions(pod.Namespace).Evict(ctx, eviction) } type Eviction interface { @@ -63,17 +82,24 @@ type Eviction interface { } type eviction struct { - kubeClient clientset.Interface - nodeName string - killPodFunc utilpod.KillPod + kubeClient clientset.Interface + nodeName string + killPodFunc utilpod.KillPod + evictionVersion string } func NewEviction(client clientset.Interface, nodeName string) Eviction { - return &eviction{ + e := &eviction{ kubeClient: client, nodeName: nodeName, killPodFunc: evictPod, } + version, err := utils.GetEvictionVersion(client) + if err != nil { + klog.ErrorS(err, "Failed to get eviction version") + } + e.evictionVersion = version + return e } func (e *eviction) Evict(ctx context.Context, pod *corev1.Pod, eventRecorder record.EventRecorder, gracePeriodSeconds int64, evictMsg string) bool { @@ -82,13 +108,13 @@ func (e *eviction) Evict(ctx context.Context, pod *corev1.Pod, eventRecorder rec return false } - eventRecorder.Eventf(pod, corev1.EventTypeWarning, Reason, evictMsg) - err := e.killPodFunc(ctx, e.kubeClient, &gracePeriodSeconds, pod) + err := e.killPodFunc(ctx, e.kubeClient, &gracePeriodSeconds, pod, e.evictionVersion) if err != nil { klog.ErrorS(err, "Failed to evict pod", "pod", klog.KObj(pod)) return false } + eventRecorder.Eventf(pod, corev1.EventTypeWarning, Reason, evictMsg) klog.InfoS("Successfully evicted pod", "pod", klog.KObj(pod)) return true } diff --git a/pkg/agent/utils/pod/pod.go b/pkg/agent/utils/pod/pod.go index 6621029b8..e71f8354b 100644 --- a/pkg/agent/utils/pod/pod.go +++ b/pkg/agent/utils/pod/pod.go @@ -31,7 +31,7 @@ import ( // ActivePods returns pods bound to the kubelet that are active (i.e. non-terminal state) type ActivePods func() ([]*v1.Pod, error) -type KillPod func(ctx context.Context, client clientset.Interface, gracePeriodSeconds *int64, pod *v1.Pod) error +type KillPod func(ctx context.Context, client clientset.Interface, gracePeriodSeconds *int64, pod *v1.Pod, evictionVersion string) error type FilterPodsFunc func(*v1.Pod, v1.ResourceName) bool diff --git a/pkg/agent/utils/pod/resources.go b/pkg/agent/utils/pod/resources.go index 8ce215bac..158bcdfbb 100644 --- a/pkg/agent/utils/pod/resources.go +++ b/pkg/agent/utils/pod/resources.go @@ -90,6 +90,12 @@ func CalculateExtendResources(pod *v1.Pod) []Resources { if cpuSharesTotal == 0 { cpuSharesTotal = minShares } + + // pod didn't request any extend resources, skip setting cgroup. + if cpuLimitsTotal == 0 && !cpuLimitsDeclared && !memoryLimitsDeclared { + return containerRes + } + containerRes = append(containerRes, Resources{CgroupSubSystem: cgroup.CgroupCpuSubsystem, SubPath: cgroup.CPUShareFileName, Value: cpuSharesTotal}) // pod level should not set limit when exits one container has no cpu limit. diff --git a/pkg/agent/utils/pod/resources_test.go b/pkg/agent/utils/pod/resources_test.go index 862027efd..0e617e118 100644 --- a/pkg/agent/utils/pod/resources_test.go +++ b/pkg/agent/utils/pod/resources_test.go @@ -115,6 +115,50 @@ func TestCalculateExtendResources(t *testing.T) { }, }, }, + { + name: "no extend resources", + pod: &v1.Pod{ + Spec: v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "container-1", + Resources: v1.ResourceRequirements{ + Limits: map[v1.ResourceName]resource.Quantity{ + "cpu": *resource.NewQuantity(5, resource.DecimalSI), + }, + Requests: map[v1.ResourceName]resource.Quantity{ + "cpu": *resource.NewQuantity(500, resource.DecimalSI), + "memory": *resource.NewQuantity(100, resource.BinarySI), + }, + }, + }, + { + Name: "container-2", + Resources: v1.ResourceRequirements{ + Limits: map[v1.ResourceName]resource.Quantity{ + "cpu": *resource.NewQuantity(1000, resource.DecimalSI), + "memory": *resource.NewQuantity(200, resource.BinarySI), + }, + Requests: map[v1.ResourceName]resource.Quantity{ + "memory": *resource.NewQuantity(100, resource.BinarySI), + }, + }, + }, + }, + }, + Status: v1.PodStatus{ContainerStatuses: []v1.ContainerStatus{ + { + Name: "container-1", + ContainerID: fmt.Sprintf("containerd://%s", "111"), + }, + { + Name: "container-2", + ContainerID: fmt.Sprintf("docker://%s", "222"), + }, + }}, + }, + want: []Resources{}, + }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { diff --git a/pkg/agent/utils/utils.go b/pkg/agent/utils/utils.go index 9b9dbfac0..dcaeee63c 100644 --- a/pkg/agent/utils/utils.go +++ b/pkg/agent/utils/utils.go @@ -25,6 +25,7 @@ import ( "strings" v1 "k8s.io/api/core/v1" + clientset "k8s.io/client-go/kubernetes" "k8s.io/klog/v2" "k8s.io/kubernetes/pkg/kubelet/cm/cpumanager/state" @@ -47,6 +48,9 @@ const ( defaultKubeletRootDir = "/var/lib/kubelet" cpuManagerState = "cpu_manager_state" + + evictionKind = "Eviction" + evictionSubResourceName = "pods/eviction" ) func UpdateFile(path string, content []byte) error { @@ -152,3 +156,17 @@ func GetCPUManagerPolicy() string { } return s.PolicyName } + +func GetEvictionVersion(kubeClient clientset.Interface) (string, error) { + resourceList, err := kubeClient.Discovery().ServerResourcesForGroupVersion("v1") + if err != nil { + return "", err + } + + for _, apiResource := range resourceList.APIResources { + if apiResource.Name == evictionSubResourceName && apiResource.Kind == evictionKind { + return apiResource.Version, nil + } + } + return "", fmt.Errorf("eviction version not found") +} From b70762a0f487ff3e7df8cd2fe1f05297964b829a Mon Sep 17 00:00:00 2001 From: william-wang Date: Thu, 10 Oct 2024 16:14:46 +0800 Subject: [PATCH 3/3] Add volcano agent build script&deployment yaml Signed-off-by: william-wang --- .github/workflows/code_verify.yaml | 2 +- Makefile | 12 +- Makefile.def | 1 + docs/design/colocation/Overview.md | 456 ++++++++++++++++++ .../design/colocation/images/architecture.jpg | Bin 0 -> 2210062 bytes docs/design/colocation/images/network.png | Bin 0 -> 497405 bytes hack/check-generated-yaml.sh | 11 + hack/generate-yaml.sh | 14 + installer/build/volcano-agent/install.sh | 57 +++ installer/dockerfile/agent/Dockerfile | 38 ++ .../helm/chart/volcano/templates/agent.yaml | 240 +++++++++ installer/helm/chart/volcano/values.yaml | 17 +- installer/volcano-agent-development.yaml | 214 ++++++++ .../github.com/asaskevich/govalidator/LICENSE | 2 +- .../github.com/bits-and-blooms/bitset/LICENSE | 27 ++ licenses/github.com/cilium/ebpf/LICENSE | 23 + .../containernetworking/cni/LICENSE | 202 ++++++++ .../containernetworking/plugins/LICENSE | 201 ++++++++ .../cyphar/filepath-securejoin/LICENSE | 28 ++ licenses/github.com/godbus/dbus/v5/LICENSE | 25 + .../opencontainers/runtime-spec/LICENSE | 191 ++++++++ .../github.com/prometheus/prometheus/LICENSE | 201 ++++++++ licenses/github.com/sirupsen/logrus/LICENSE | 21 + .../github.com/vishvananda/netlink/LICENSE | 192 ++++++++ licenses/github.com/vishvananda/netns/LICENSE | 192 ++++++++ licenses/k8s.io/cri-api/LICENSE | 201 ++++++++ licenses/k8s.io/cri-client/LICENSE | 201 ++++++++ 27 files changed, 2762 insertions(+), 7 deletions(-) create mode 100644 docs/design/colocation/Overview.md create mode 100644 docs/design/colocation/images/architecture.jpg create mode 100644 docs/design/colocation/images/network.png create mode 100644 installer/build/volcano-agent/install.sh create mode 100644 installer/dockerfile/agent/Dockerfile create mode 100644 installer/helm/chart/volcano/templates/agent.yaml create mode 100644 installer/volcano-agent-development.yaml create mode 100644 licenses/github.com/bits-and-blooms/bitset/LICENSE create mode 100644 licenses/github.com/cilium/ebpf/LICENSE create mode 100644 licenses/github.com/containernetworking/cni/LICENSE create mode 100644 licenses/github.com/containernetworking/plugins/LICENSE create mode 100644 licenses/github.com/cyphar/filepath-securejoin/LICENSE create mode 100644 licenses/github.com/godbus/dbus/v5/LICENSE create mode 100644 licenses/github.com/opencontainers/runtime-spec/LICENSE create mode 100644 licenses/github.com/prometheus/prometheus/LICENSE create mode 100644 licenses/github.com/sirupsen/logrus/LICENSE create mode 100644 licenses/github.com/vishvananda/netlink/LICENSE create mode 100644 licenses/github.com/vishvananda/netns/LICENSE create mode 100644 licenses/k8s.io/cri-api/LICENSE create mode 100644 licenses/k8s.io/cri-client/LICENSE diff --git a/.github/workflows/code_verify.yaml b/.github/workflows/code_verify.yaml index 2efc2fb0f..eb9baf4bd 100644 --- a/.github/workflows/code_verify.yaml +++ b/.github/workflows/code_verify.yaml @@ -37,5 +37,5 @@ jobs: make verify make TAG=latest generate-yaml make verify-generated-yaml - make unit-test + sudo make unit-test working-directory: ./src/github.com/${{ github.repository }} diff --git a/Makefile b/Makefile index 4b8154776..c54662cf8 100644 --- a/Makefile +++ b/Makefile @@ -65,7 +65,7 @@ include Makefile.def .EXPORT_ALL_VARIABLES: -all: vc-scheduler vc-controller-manager vc-webhook-manager vcctl command-lines +all: vc-scheduler vc-controller-manager vc-webhook-manager vc-agent vcctl command-lines init: mkdir -p ${BIN_DIR} @@ -84,14 +84,18 @@ vc-controller-manager: init vc-webhook-manager: init CC=${CC} CGO_ENABLED=0 go build -ldflags ${LD_FLAGS} -o ${BIN_DIR}/vc-webhook-manager ./cmd/webhook-manager +vc-agent: init + CC=${CC} CGO_ENABLED=0 go build -ldflags ${LD_FLAGS} -o ${BIN_DIR}/vc-agent ./cmd/agent + CC=${CC} CGO_ENABLED=0 go build -ldflags ${LD_FLAGS} -o ${BIN_DIR}/network-qos ./cmd/network-qos + vcctl: init CC=${CC} CGO_ENABLED=0 GOOS=${OS} go build -ldflags ${LD_FLAGS} -o ${BIN_DIR}/vcctl ./cmd/cli -image_bins: vc-scheduler vc-controller-manager vc-webhook-manager +image_bins: vc-scheduler vc-controller-manager vc-webhook-manager vc-agent images: - for name in controller-manager scheduler webhook-manager; do\ - docker buildx build -t "${IMAGE_PREFIX}/vc-$$name:$(TAG)" . -f ./installer/dockerfile/$$name/Dockerfile --output=type=${BUILDX_OUTPUT_TYPE} --platform ${DOCKER_PLATFORMS} --build-arg APK_MIRROR=${APK_MIRROR}; \ + for name in controller-manager scheduler webhook-manager agent; do\ + docker buildx build -t "${IMAGE_PREFIX}/vc-$$name:$(TAG)" . -f ./installer/dockerfile/$$name/Dockerfile --output=type=${BUILDX_OUTPUT_TYPE} --platform ${DOCKER_PLATFORMS} --build-arg APK_MIRROR=${APK_MIRROR} --build-arg OPEN_EULER_IMAGE_TAG=${OPEN_EULER_IMAGE_TAG}; \ done generate-code: diff --git a/Makefile.def b/Makefile.def index 3cc3dcb51..884bf1748 100644 --- a/Makefile.def +++ b/Makefile.def @@ -4,6 +4,7 @@ TAG ?= $(shell git rev-parse --verify HEAD) GitSHA=`git rev-parse HEAD` Date=`date "+%Y-%m-%d %H:%M:%S"` RELEASE_VER=latest +OPEN_EULER_IMAGE_TAG ?= 22.03-lts-sp2 LD_FLAGS=" \ -X '${REPO_PATH}/pkg/version.GitSHA=${GitSHA}' \ -X '${REPO_PATH}/pkg/version.Built=${Date}' \ diff --git a/docs/design/colocation/Overview.md b/docs/design/colocation/Overview.md new file mode 100644 index 000000000..97a9bb675 --- /dev/null +++ b/docs/design/colocation/Overview.md @@ -0,0 +1,456 @@ +## Motivation + +Volcano now supports unified scheduling of microservices and batch workloads, it's compatible with the default scheduling algorithms of kubernetes, and provides rich scheduling policies for microservices and batch jobs, so it is suitable for unified scheduling of different types of jobs in colocation scenarios, and improves resource utilization simultaneously. + +## Architecture + +Volcano agent supports cloud-native online and offline workloads colocation. It runs as a daemonset in the kubernetes cluster, and is committed to improving the resource utilization of the kubernetes cluster and meanwhile ensures the Qos of online workloads through CPU/Memory/Network resource isolation and suppression. + +![architecture](images/architecture.jpg) + +### Qos Model + +| Qos | Typical Usage Scenario | +| :---------------------------: | :------------------------------------------------------: | +| LC(Latency Critical) | Exclusive CPU for latency critical core online workloads | +| HLS(Highly Latency Sensitive) | Extremely latency sensitive online workloads | +| LS(Latency Sensitive) | Latency sensitive approximate online workloads | +| BE(Best Effort) | Offline AI/Big Data workloads, tolerable evictions | + +You can set different qos levels to identify workloads of different priorities, and there is no seperate `priorityClass` definition to be consistent with k8s. + +### Features + +- Unified scheduling for all kinds of workloads including microservices and batch jobs. +- Qos based resource model for online and offline workloads. +- CPU burst: Allow containers to temporarily exceed the CPU limit to avoid throttling at critical moments. +- Dynamic resource oversubscription: Dynamically calculate the resources that can be oversold based on the real-time CPU/Memory utilization of the node, and oversold resources can be used by offline workloads. +- Network bandwidth isolation：Supports ingress network bandwidth limitation of the entire machine to ensure network usage for online workloads. + +## Quick start + +### Prepare + +Follow the [installation guide](https://github.com/volcano-sh/volcano?tab=readme-ov-file#quick-start-guide) to install volcano first, and then install volcano agent via kubectl, this way is both available for x86_64 and arm64 architecture. + +```shell +kubectl apply -f https://raw.githubusercontent.com/volcano-sh/volcano/master/installer/volcano-agent-development.yaml +``` + +Check volcano components including agent runs successfully. + +```shell +$ kubectl get po -n volcano-system +NAME READY STATUS RESTARTS AGE +volcano-admission-76bd985b56-fnpjg 1/1 Running 0 3d +volcano-admission-init-wmxc7 0/1 Completed 0 3d +volcano-agent-q85jn 1/1 Running 0 3d +volcano-controllers-7655bb499f-gpg9l 1/1 Running 0 3d +volcano-scheduler-6bf4759c45-c666z 1/1 Running 0 3d +``` + +Enable node level colocation by setting lable volcano.sh/oversubscription=true and volcano.sh/colocation=true. + +``` +$ kubectl label node $node volcano.sh/oversubscription=true # replace $node with real node name in your kubernetes cluster. + +$ kubectl label node $node volcano.sh/colocation=true # replace $node with real node name in your kubernetes cluster. +``` + +### CPU burst tutorial + +This example will demonstrate how to use CPU burst and what benefit it can bring. + +#### Enable cpu burst by set pod annotation + +Run a nginx deployment with cluster ip service exposed, pod with annotations `volcano.sh/enable-quota-burst: "true"` indicates pod cpu + +burst is enabled. + +```yaml +apiVersion: apps/v1 +kind: Deployment +metadata: + name: nginx + namespace: default +spec: + replicas: 1 + selector: + matchLabels: + app: nginx + template: + metadata: + labels: + app: nginx + annotations: + volcano.sh/enable-quota-burst: "true" # pod enabled cpu burst + spec: + containers: + - name: container-1 + image: nginx:latest + resources: + limits: + cpu: "2" + requests: + cpu: "1" +--- +apiVersion: v1 +kind: Service +metadata: + name: nginx + namespace: default + labels: + app: nginx +spec: + selector: + app: nginx + ports: + - name: http + targetPort: 80 + port: 80 + protocol: TCP + type: ClusterIP +``` + +#### Perform stress + +Perform stress with `wrk` to nginx app. + +```shell +wrk -H "Accept-Encoding: deflate, gzip" -t 2 -c 8 -d 120 --latency --timeout 2s http://$(kubectl get svc nginx -o jsonpath='{.spec.clusterIP}') +``` + +#### Check cpu burst + +Check container's cpu throttle state of pod, we can see that `nr_bursts` and `burst_time` is not 0, `nr_throttled` and `throttled_time` is a small value, which indicates pod has used burst cpu quota. + +```shell +$ cat /sys/fs/cgroup/cpu/kubepods/burstable/podd2988e14-83bc-4d3d-931a-59f8a3174396/cpu.stat # replace nginx pod uid in your kubernetes cluster. +nr_periods 1210 +nr_throttled 9 +throttled_time 193613865 +nr_bursts 448 +burst_time 6543701690 +``` + +If we set pod's annotations `volcano.sh/enable-quota-burst=false`(disable pod cpu burst) and perform another stress, `nr_throttled` and `throttled_time` will be a relatively large value, which indicates pod cpu is throttled strictly, `nr_bursts` and `burst_time` is 0, indicates that pod cpu burst not happened. + +```shell +$ cat /sys/fs/cgroup/cpu/kubepods/burstable/podeeb542c6-b667-4da4-9ac9-86ced4e93fbb/cpu.stat #replace nginx pod uid in your kubernetes cluster. +nr_periods 1210 +nr_throttled 488 +throttled_time 10125826283 +nr_bursts 0 +burst_time 0 +``` + +#### Limitation + +CPU burst relies on capabilities provided by the linux kernel, this feature only works with host upstream linux kernel >=5.14 and some Linux Distribution like OpenEuler 22.03 SP2 or higher version. + +### Dynamic resource oversubscription tutorial + +This example will demonstrate the resource overoversubscription capability on node, and shows the suppression and eviction mechanism when node is suffering from pressure. The node flavor is 8 core cpu and 16GB memory. + +#### Check node oversubscription resoures + +Node oversubscription resources are calculated by node allocatable resources sub actual resource usage, oversubscription resources include cpu and memory and is represented by `kubernetes.io/batch-cpu` and `kubernetes.io/batch-memory` respectively, and reported as extended resources to node.Allocatable filed. Online workloads use noraml resources and offline workloads use oversubscription resources so we can improve pod deployment density and resource utilization. + +```shell +$ kubectl describe node $node # replace $node with real node name in your kubernetes cluster. +Allocatable: + cpu: 8 + ephemeral-storage: 33042054704 + hugepages-1Gi: 0 + hugepages-2Mi: 0 + kubernetes.io/batch-cpu: 7937 # oversubscription resource cpu, unit is milli cpu + kubernetes.io/batch-memory: 14327175770 # oversubscription resource memory, utit is byte + memory: 15754924Ki + pods: 110 +``` + +#### Deploy online and offline workloads + +Online workloads are identified by setting annotation `volcano.sh/qos-level: "LC" or` `volcano.sh/qos-level: "HLS"` or `volcano.sh/qos-level: "LS"`.Offline workloads are identified by setting annotation `volcano.sh/qos-level: "BE"`, it can only use oversubscrption resources(kubernetes.io/batch-cpu and kubernetes.io/batch-memory). We use an image with stress tool of online workload to simulate online workloads business pressure rises, if you can not access the image, you can also replace it with other image that has stress tool. + +```yaml +# online workload +apiVersion: apps/v1 +kind: Deployment +metadata: + name: online-demo + namespace: default +spec: + replicas: 1 + selector: + matchLabels: + app: online-demo + template: + metadata: + labels: + app: online-demo + annotations: + volcano.sh/qos-level: "HLS" # identify online workloads + spec: + containers: + - name: container-1 + image: polinux/stress + imagePullPolicy: IfNotPresent + command: ["stress", "--cpu", "7"] # perform cpu stress + resources: + requests: + cpu: 2 +--- +# offline workload +apiVersion: apps/v1 +kind: Deployment +metadata: + name: offline-demo + namespace: default +spec: + replicas: 1 + selector: + matchLabels: + app: offline-demo + template: + metadata: + labels: + app: offline-demo + annotations: + volcano.sh/qos-level: "BE" # identify offline workloads + spec: + containers: + - name: container-1 + image: nginx:latest + resources: + requests: + kubernetes.io/batch-cpu: 4000 # 4 core cpu + kubernetes.io/batch-memory: 10737418240 # 10Gi memory +``` + +Make sure online and offline workloads are running. + +```shell +$ kubectl get po +NAME READY STATUS RESTARTS AGE +offline-demo-f59758bb-vlbp7 1/1 Running 0 6s +online-demo-9f9bbdb58-fljzs 1/1 Running 0 6s +``` + +#### Eviction happens when node has pressure + +Online workloads Qos is guaranteed by volcano agent and host OS, volcano agent detects node resource utilization in real time, and will evict offline workloads when node resource utilization exceeds the threshold, for CPU resource, it's 80% by default, we perform 7 core cpu stress to online workload, we can check event and it showed that offilne worload is evicted after about 1 minutes later. + +```shell +$ kubectl get event | grep Evicted +69s Warning Evicted pod/offline-demo-785cff7f58-gwqwc Evict offline pod due to cpu resource pressure +``` + +We can also find that oversubscription reduced when node has pressure. + +```shell +$ kubectl describe node $node # replace $node with real node name in your kubernetes cluster. +Allocatable: + cpu: 8 + ephemeral-storage: 33042054704 + hugepages-1Gi: 0 + hugepages-2Mi: 0 + kubernetes.io/batch-cpu: 978 # oversubscription resource of cpu reduced. + kubernetes.io/batch-memory: 14310391443 + memory: 15754924Ki + pods: 110 +``` + +Volcano agent will also add eviction taint to current node when eviction happened to avoid new workloads continuously scheduled to the node and put additional pressure on current node. We can find that new created offline pod is pening because of eviction taint. + +```shell +$ kubectl get po +NAME READY STATUS RESTARTS AGE +offline-demo-f59758bb-kwb54 0/1 Pending 0 58s +online-demo-9f9bbdb58-54fnx 1/1 Running 0 2m1s + +$ kubectl describe po offline-demo-f59758bb-kwb54 +Events: + Type Reason Age From Message + ---- ------ ---- ---- ------- + Warning FailedScheduling 69s default-scheduler 0/1 nodes are available: 1 node(s) had taint {volcano.sh/offline-job-evicting: }, that the pod didn't tolerate. +``` + +And if we stop online workload to release pressure then the eviction taint will be removed and pod can be scheduled normally. + +#### Limitation + +Volcano agent defines a Qos resource model for online and offline workloads, and provides application level guarantee(eviction when node has pressure) for online workloads Qos guarantee. The OS level cpu and memory isolation and suppress are guaranteed by host kernal, and currently volcano agent only adapted to openEuler 22.03 SP2 and higher version, please make sure that you are using the correct OS type and version. + +### Network bandwidth isolation tutorial + +The bandwidth usage of offline workloads will be limited when online workloads require more bandwidth. There are three watermarks parameters of network bandwidth isolation. + +| Watermark | Description | Default Value | +| :-------------------------------: | :----------------------------------------------------------: | :-----------: | +| `onlineBandwidthWatermarkPercent` | The ratio of online bandwidth watermark value to the base bandwidth of node:
onlineBandwidthWatermark value = node base bandwidth * `onlineBandwidthWatermarkPercent`/100 | 80 | +| `offlineHighBandwidthPercent` | The ratio of offline high bandwidth watermark value to the base bandwidth of node:
offlineHighBandwidth value = node base bandwidth * `offlineHighBandwidthPercent`/100
It represents the upper limit of bandwidth that can be used by offline workloads when the online workloads use bandwidth ratio less than `onlineBandwidthWatermarkPercent`，eg: node bandwidth=100Mbps, `onlineBandwidthWatermarkPercent` =80 and `offlineHighBandwidthPercent`=40, when online workloads use bandwidth less than 100Mbps\*0.8=80Mbps, then the offline workloads can use at most 100Mbps\*40=40Mbps bandwidth. | 40 | +| `offlineLowBandwidthPercent` | The ratio of offline low bandwidth watermark value to the base bandwidth of node:
offlineLowBandwidth value = node base bandwidth * `offlineLowBandwidthPercent`/100
It represents the upper limit of bandwidth that can be used by offline workloads when the online workloads use bandwidth ratio more than `onlineBandwidthWatermarkPercent`，eg: node bandwidth=100Mbps, `onlineBandwidthWatermarkPercent` =80 and `offlineLowBandwidthPercent`=10, when online workloads use bandwidth more than 100Mbps\*0.8=80Mbps, then the offline workloads can use at most 100Mbps\*10=10Mbps bandwidth. | 10 | + +This picture below shows the bandwidth that online and offline workloads actually can use when they compete for bandwidth resources on one node. + +![network](./images/network.png) + +#### Set network bandwidth + +This example will demonstrate the suppression of the entire network bandwidth of an offline workload by online workload, and we use`iperf` tool to simulate network ingress bandwidth traffic of both online and offline workloads. + +Add an annotation `volcano.sh/network-bandwidth-rate` on all nodes to specify the network bandwidth rate, the value in the example is 1000Mbps, please set an actual value according to your environment, and please replace `$node` with actual node name in your environment. + +```shell +$ kubectl annotate node $node_name volcano.sh/network-bandwidth-rate=1000 +``` + +#### Run online and offline workloads + +Run an online deployment with below container command. Please replace the `$node_ip` with a node ip that pod can access in your environment and also make sure iperf tool is installed in container image. And please also start iperf server on `$node_ip` with command `iperf -s` to make sure pod can access the iperf server. + +```shell +- command + - /bin/sh + - c + - iperf -c $node_ip -i 1 -t 30 -f mb; echo finished...; sleep 1000000 +``` + +And set the following annotation to identity the online workload. + +```yaml + annotations: + volcano.sh/qos-level: "HLS" # identify online workloads +``` + +Run an offline deployment with podTemplate specified with the following annotation + +```yaml + annotations: + volcano.sh/qos-level: "BE" # identify offline workloads +``` + +and also specify the container command like online deployment. + +```shell +- command + - /bin/sh + - c + - iperf -c $node_ip -i 1 -t 30 -f mb; echo finished...; sleep 1000000 +``` + +#### Check logs + +Check online and offine pod logs + +online pod log: + +```shell +Connecting to host 192.168.2.30, port 5201 +[ 5] local 192.168.2.115 port 58492 connected to 192.168.2.30 port 5201 +[ ID] Interval Transfer Bandwidth +[ 5] 0.00-1.00 sec 118 MBytes 990 Mbits/sec +[ 5] 1.00-2.00 sec 106 MBytes 889 Mbits/sec +[ 5] 2.00-3.00 sec 107 MBytes 897 Mbits/sec +[ 5] 3.00-4.00 sec 107 MBytes 903 Mbits/sec +[ 5] 4.00-5.00 sec 107 MBytes 899 Mbits/sec +[ 5] 5.00-6.00 sec 107 MBytes 902 Mbits/sec +[ 5] 6.00-7.00 sec 705 MBytes 884 Mbits/sec +... +``` + +offline pod log: + +```shell +Connecting to host 192.168.2.30, port 5201 +[ 5] local 192.168.2.115 port 44362 connected to 192.168.2.30 port 5201 +[ ID] Interval Transfer Bandwidth +[ 5] 0.00-1.00 sec 8 MBytes 70 Mbits/sec +[ 5] 1.00-2.00 sec 12 MBytes 102 Mbits/sec +[ 5] 2.00-3.00 sec 11 MBytes 98 Mbits/sec +[ 5] 3.00-4.00 sec 11 MBytes 99 Mbits/sec +[ 5] 4.00-5.00 sec 11 MBytes 99 Mbits/sec +[ 5] 5.00-6.00 sec 11 MBytes 97 Mbits/sec +[ 5] 6.00-7.00 sec 11 MBytes 98 Mbits/sec +... +``` + +You can see that offline pod can use almost 10% bandwidth when online pod use more bandwidth resources than `onlineBandwidthWatermarkPercent` of the whole node. + +## Advanced settings + +### Feature switch + +Colocation feature has a unified switch on node, node has label volcano.sh/oversubscription=true or volcano.sh/colocation=true indicates that coloation is enabled. You can remove the two labels to disable all colocation features. And all colocation features take effect when node has these lables. + +- If you only want to use online and offline workloads colocation but not resource oversubscription, you just need to set the node label volcano.sh/colocation="true". +- If you want to use colocation and resource oversubscription, you should set node label volcano.sh/oversubscription=true. + +The configMap `volcano-agent-configuration` of namespace `volcano-system` by default holds all the configurations of volcano agent. + +Every colocation feature CPU burst/Dynamic resource oversubscription/Network bandwidth isolation has a separate switch, you can enable/disable each of them by modify configMap `volcano-agent-configuration` of namespace, + +enable filed value true means enable CPU burst, false means disable it. + +```json +"cpuBurstConfig":{ + "enable": true +} +``` + +enable filed value true means enable dynamic resource oversubscription, false means disable it. + +```json +"overSubscriptionConfig":{ + "enable": true, +} +``` + +enable filed value true means enable network bandwidth isolation, false means disable it. + +```json +"networkQosConfig":{ + "enable": true, +} +``` + +### CPU burst + +Container in a pod enabled cpu burst can burst cpu quota at most equal to container's cpu limit, if many pods are using burst cpu at the same time, CPU contention will occur and affect cpu cfs scheduling. You can set pod annotation `volcano.sh/quota-burst-time` to specify custom burst quota, for example, if a container's cpu limit is 4 core, and volcano agent will set container's cgroup `cpu.cfs_quota_us` value to 400000(the basic cfs period is 100000, so 4 core cpu will be 4*100000=400000), which means container can use at most an extra 4 core cpu in a moment, if you set volcano.sh/quota-burst-time=200000, it means container can only use at most an extra 2 core cpu in a moment. + +```yaml +annotations: + volcano.sh/quota-burst-time: "200000" +``` + +### Dynamic resource oversubscription + +The oversubscription resources computation and offline workloads eviction only take pod's resource usage into consideration by default, if you want to consider the resource utilization of the node itself, you should set flag`--include-system-usage=true` of volcano agent. + +To avoid excessive pressure on nodes, volcano agent set an oversubscription ratio to determine the ratio of idle resource oversubscription, you can change the parameters by set flag `--oversubscription-ratio`, default value is 60, which means 60% of idle resources will be oversold, if you set `--oversubscription-ratio=100`, it means all idle resources will be oversold. + +Volcano agent will evict offline workloads when nodes have pressure, and the eviction threshold can be configured by configMap volcano-agent-configuration, `"evictingCPUHighWatermark":80` means eviction will happed when node's cpu utilization is beyond 80% in a period of time, and current node can not schedule new pods when eviction is happening, and `"evictingCPULowWatermark":30` means node will recover schedule when node's cpu utilization is below 30%, `evictingMemoryHighWatermark` and `evictingMemoryLowWatermark` has the same meaning but for memory resource. + +```json +"evictingConfig":{ + "evictingCPUHighWatermark": 80, + "evictingMemoryHighWatermark": 60, + "evictingCPULowWatermark": 30, + "evictingMemoryLowWatermark": 30 +} +``` + +### Network bandwidth isolation + +You can adjust the online and offline bandwidth watermark by modifying configMap `volcano-agent-configuration`, and `qosCheckInterval` represents the interval for monitoring bandwidth watermark by the volcano agent, please be careful to modify it. + +```json + "networkQosConfig":{ + "enable": true, + "onlineBandwidthWatermarkPercent": 80, + "offlineHighBandwidthPercent":40, + "offlineLowBandwidthPercent": 10, + "qosCheckInterval": 10000000 + } +``` diff --git a/docs/design/colocation/images/architecture.jpg b/docs/design/colocation/images/architecture.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d47c1cc5f308bd600f3a1a5c538f66694367b3c6 GIT binary patch literal 2210062 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≫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

    KjyfMvqXE;Ynh`mQ&m#0Zz!4fFR^nD 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 z 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�kLi-b_3bkrsa{13PnO)ieEGz{L_AhL zpo<}? z4tCIutDMdLpv?LgO_^sx%@C{@&v}fih1jo9OT`2kETb9MUCR+QM~ zuGmfN28Mbt<`7(2YxXQL5Y-o>#rN#%=Wgk`{idXr`roCpmhT{93JngDSURM;Xy%~{ zL?!{C&fKg!DoE;`7Mu@=Bynzg&B5fyuTif!}Wjli>Z|BOLN^jWotK4whH-7;YFW|P;+h} ztmf=*BcMD83hgRaEpD_~v}^Vs)ZD^Wx?WIN9JkPjwSA-&)IT790+5}>A00Wb$#WC* z-2clC|93qm02@6-pQHNKz87r^fTeh8n3-&i)jJ4Xf_ionw; z#5_1i$#2XBPV>BRX0#DTuWpd}$Rj=tOdPy|LVBT9VDCb&`4+@~Pt8u?I2&yc>#J;# zW9`P$@JKo)M3d!#ONZ!27?x?*)Z69yeF%9e)j+PRooyhKQzYS828V3!5e{M+n>+hs*v4|jW z{IQ?mMv#fDrKxcp$oyWczJK$FIieUe+`~xYhPVNQQ*1To4^B$11_1F>;M!rRLerPY zktkRv7BQzxwSn^u1_XztCv~{)1xN}__fg=)lR=+uoe+Ra3+gfC2OMx(u}R>3yUF`O zh1La)qJzlBEF8tXI|N=LO8h(x;)rh>xobB4(|U>`F}OEDIsOOPDul)x44++{2oFc9 zJ$$Ef8%Hi{jhtU+}C4%NqWEXT=O%MCif)#9YrXXhsJx?gir zK~KTHlu3XQ$PrOBzx+XX?iaESc`%!>8(ImLt3KKz!g^O}`T}OHyNu9%-ry(tK0{Fg z@FC_VX-C~_g}$>wELu$LN6jU5TsV>LY~ejm>=v@m#rBpdz$AK~;e)eLdsMy`VubJ2 z5YC%Yzft&Phx@~C8F%~Mym#We-r$sSyoM)ZhvkS^hIdMMkfP~QmcrmoeLYib^BYf# zljiE>Meko9k2qd7p}+t#W7wrj5C+t$|EUvaN~T{B;v~ME76kWbZzU+}&j?}XTyd>< z&K5&ZBT!)*LOtu2jUl_TgOwHz&7SwIM5-TxTjCN&RIh<%&BxG80TkD?g4mM;fqD}C zax*6>{v(O4eG|vEcQznRZzqRAu#OvI*)WLZKK(#KvPdZG?Ddv8#PZ@vP=F8r6_CA- z?L@`+`T;y`um$-zC&V>=1?^klF8`%mmmtsC*ZP}q-AauMHZ;CFSNfePgT|rLIT`@3 zi+($Pfe?nrp6Qi#UU3{b%vsJZVvXsP#3oOkjzyObi? zbWx+qYX|t%&L4(=WSoE;)DjWTq_IH?keoGY)xauzW9)=PCc(6K_76d zd|dyg(x$d8b&7E*b#2G)$B72pA1Mfhq?uj5=ceeBw)34%xtVB&Q60{CYEm&3BuBG~ z3i|iaWY;_7g(kl4NV68*)e(M{_Ht-vq1(;@^_Y@k?(OACKZQ`>8CZxO#`J={X%wMJ zJVT*6-?yu#j(XC~vO^`yA4UHzzKxEAz0P^!t-rx>lCY~&Mbl9{SK5_sxIs32XFSY( z5jr|(AXsrpVg2cM5PwLrcF&nTzNMDBsp7{n!>e7CZkl!^?X=7~U1zpwH$AE#>A8`C zSCgshgR||IrHUTm%u+}V)`gyhBdaX!GCGOsiO(fWRZr9;?aT4FnM)aP2dpm;dZ0p} z^(yGW2Na=sJ<@#{{-Vwo+~Az~@hf3bqTh~9L{IQh4N}(R#bRQ(7hCC{4sn zIN$FVG8jHVLf?M3I({Y1H$?=ak@>i6N0a>1Cehsw=?#3lY(FdBTw|7Wqp1|z)ys^v z9bvy@1uQl+M_=Mx)-BF9p{0f(Z8iF5AHJ@M&%1ac-O;8_N zpCz1$YlI?PAmj=vg5| z!~oS~#QHYd1WfWEl}B-pk=J?A(J5F?ydRMp(>=qrcjX&HKv3|BEdq8{mND{@DpcnH zY}C7`{vS3<=mU8$K3NUF5-L9cxkk92+r5Pn(n;8$DxNa}-%j-`<8{BhC;C#E+-}it zG>f#YH1Zcua^q8`LnoyYT|k){r|qLO#2$dB=}``*du?Ss2xvO@+Zo$*9zT?pxRhHo zZd@H#gERfA7`*XPnWl=j&Sq^P?f$_zXLlu*p_pn3?lZ@+daapGq}@ps&p{;{JUOp= z0DZ*^T?$YTau&V&kAc@(jup5bFkD@#&gPTmmjj+IFqrX_I(F}+(HZ?u8f=U(OrNn@ zOflt%U9`OP0=IMQ+84+xll2)m(g@A2x3DZ*2X@!lI6)Eh$K;gWjFjN$QBk=^*f)g3 zXd$+HByhWLS4tsa)E&b6D8lcw!s9hgC)!k-8gwhGqQ!~zS3FGps+J5kyvX#{vRIvy z5)pBnJXx)5g)X%}%Qc^vWyXDDi<8qy1IEeby=b3)EZ6P+K7!6{gKeHQ_)s^O zRSB5potM61L!_w=;O;knOO^?%?EU_P zasA_7-!S{UR%&u()iFodtycGHYE7#51!1FC6AsvW3*zUg*Y`U4hS`>Ed@iC-tP2nw zXEd)ly>BdtQK}b4QkL`9++Fz1#iJ$g#$)~CA{!;!Gb`du+rnqWoWp4oh6zc2H@i$G znlInb`EHL>&9-W>b2UrVW!&>Li*V4~MBP_msp#NSVV~BnBFG@lm;Qck7>8I1jqrV=BM+D&OuL_oI=NzgvU!v$qV2sn7cfPdZ z7S($@Bk;1n@+fbz!j|hR+#5{Z(g0uQcRulYaA143zpI&5ij72QHBIr163x^4-oz2% z*f>S+&~yWbD_e{E`;$!{w$|<`%zw-N#bcb%b>SxS z)+x4Ph1=Ziu!aGxF8T^1(P22?qsBV{q2w>A33i`5uP0)(A7)T@QDr1;((VW6hNd}} zWQtDrF=H;pj+n<|FIvh_;o(h;`JvE9N|W6^E?eTnTbUQF(oyFgx*41;p83pje(L$} zjOZfBi>)36Ml{%W5^3_O1-3G$Y(p1)5%*Prv*j+J4oVM^*gDN1voKKt8{&cjwnM{x zSb*n{g8+ew&r$V{fC$$UV(xALtt_Kkxg63QfTMR_0!wNLd6C&FG76wo3W*j)E&`Nd zOJtegr@;$cQvfn;8X%*VfT69k12sC!763r2MTSa&)sD^q_U24CG;vnwHUQH|8~XeY z?xeq|&%h_GIq z7c55g$3e+%91%DB3w+FZ?n8VuCm&q{@w->Q8}T>3G9Ythcq6;LLlTW6j%>^I;;x&7 zqsI3H+P-U+uTFIfr=yCjX@En}_C2$vs9^Z1siAK9adWumyv^K|J$BC_ z&gvJ=%M?Du2d(|%`>y?!M+X%}o;_Kn3H3NE7lYCx^Ksw$aq1K3yz5i9GbhA)i!#|N zNb`+H>FEO}J#`4A_&%3vCjiCfpzBKkDNz1KKcBS5Kg0M$Cr6*>5&pig?s;g%~;^#agltr`)k zol4T$=55L!|N0mROZcy1{u%gHSS z|M~a%6%!AClAieybo`&=Pa4v(fKxlHesclrQq$8}W_=74CkRi-g~pXNL;e$40&KGX zNyfDl5bsgZU@yveY_LD+IlvG54dKK*u9d`KRFiyO!}!V@$@#9UIM?28j^Ar<;p4jL zx+##C()-w|jNS0*xDn61t`bXy9?ubb%gpcMV5t#nXQ;tb)1t2mY0_e*C6D?lA>l_f zy#RCTqWlCCNnB`5O}?Cu`r%e1MZUGp+Q$Gt(ZTkQ+1TaBE0*CG-&)^f3pJ(zjHkYq z>rn_TL;GIM!FtPFd-~iLRoj(+#P%w$HPIwqj(XJaj)@Wnk6lg^@kx8upn}P7Is?hP zR*d+n=@YfY(kmxLDzr{BC~i!K(@>PU)WtEDDQS9UN? zJwC3)ERFQF}pnS z(6JaMZtO}AqLub-G5i2*UWmqNj92WK&x3l^H2}->#~zJsc|t)krI9)o3)UJ=`)9NRWXgu5bUWY-KD}9&67&Wh@!PR}pVT^~<2kQuQau|xtIYOh zT3_`RRqRZBNnJJ59uw{&e(=aH+4|4<`q%KGkF@vXFvOo6N>Z?@NYY4ewcH(k+H6Cb zsOT>LJ=hEN*x2RSMN?9IGni%7$yE&u?I|m^?l(&Q02vHi6SE{zaU0=SD|*y@N7@j) z_M}K<^7c{-PmDkrxUTCscxFdFLz;45(?oMydM~MG;eNqL+Y5{R7geEMXfG&IMvM#G zp*t}YEzOaqHzT5g!PU|bBHU>FF^pEgc&U3m9>>oO=+vz{Y^E5 zUQ~6)-^l(fu)oT5OIMQyw#oIYd?m}$`-xl6HQtHhSNLgkfmd7gnSOoqYzOhs$P=br zkA#J<4rZj=Jm)|1GNWEqwa^)I6iYt$cxttXay2cWNQk#?!NEG^pk?i%SDx90w#sTuQM>LOH7KD}ae|HO2scOrV#Xw}Oof zhA*1l-t7x8!AKCc5MZGTH=&o-YBmte<4b3~f$bkWnz>>VdF&#U|2guPPT zBtCWdo1cEMmu^fsdEk{#&C~;9zH(ZIfM^BBG}v>Z=wM%e!(hw!&%SRX)F{Sby%eeEEx-!@*v-aw9M3I+6mEFGCX$e%2o_u== zE(Q~4<267Y*oAoKUzxNNH;yobShcX_LFG=R2#{?D@^NDdKkw)sM4RAQJNBa4C;(RN zd}HS+0?@GcW03vKgC<->=J%58@gUp#pfe97k1Y%V31XDAaQ1Hv-D5~3gc1XL0j!kP ze8YBzlLRco!QWO-wq4IDyI<=>t;~BVndU4!_IPY$wSPyW}%lO74KFe z)#tB>y{NIoC3XV?&9Y+tX}jYZj5$&PwBxb%fRrgMm3qASC`_g~eliq%qm_1@zG&W- zdUf*gk=P8m3%B;@KXc4?GI*u^?Ip1wXx6G7gj(m+f8{Z+AQovN?x?q*xi~RZelqiSSE|!3`CM>#!+R8IR8}uVsz1(MSTsr$_-?Sp%7F05_*k?$V7`LBJbW& zCIgQbnt!+vpkDc<)_aSG+N<92w?)GgC#uT)EtRz zoURw-6c7+P1u}$|x|D?s{6RL{E=c#4f*9J(usgu9r?t}ZeT8+Q*v?%x&m~A6$IYA; zJk4;xR$MrT>%nzriZndZE$cnu-kKtFqpYpZ$Fjg9V~$I+_Oz42DT@}L-W0m?McKXC z3i2y-5E$P6D2+^ZXU@(*5b4C2xbz z!J4#f9@_V_hWxIE8D>!`H5(iIVq@t`T}zrWtqHM7Htc%0046lO)=EWQ}0DX4G^? zxxuw`?_A?LpQ2PzNixdQMAf&GZ@w1-%Bn86B-$L#ikQK57X<;{0JJn3Ku7%=rQ>$06Z9M(r{|F(4Q2{kNii&`G+W7aZ1n`;4Gqq(?Wl=^%)U-#u{ zG$s>_(_3Q*a$V>EfaTuSQkKrqFA$plL_t`A`voeuQjuH)?U?MfIkO4ZZ|5*-1%PZd z-H5Hdm0Mk;)+T%LAm7S>MVve`ASvP-#?1|2iH_X5!{0>Lf}ZeY^Y4zzHb_9Bcuu;&d8=58yJ! z3V7%5)sO%AoreEW&PJ3Cf`pZz{v7iw52F(Kv_M2&l}HoT{H*JWnJf)jX(}m92^-+J z7`4TfxY_*;&?JXEU$Yg-@?sePpThyDzutcf0O`_vNLtxm(&TD#>*EIPo6%+R#qogWmx#VD9I4WS-#s z0!yDQH?-%VU^mZl!Z$By)wc%^$WwRj33(#xtR#(Xjohxg9yVI_ov;5+tLMHqjau%!K9-@;sMXux87O~1<_M29miLYkVRA4~i{WJK z&}%ICsD+%!5HBfWrxy`!f3za>sS}ON1q4|2*&c|Mt|TZcJ!@|LQC9kK6siRVT_x#B zF*mwYZMQX)kLdd9(jTl?3s|umm9>Tatey@QOO4!_cfr*MK+Yh1!F~`d#CPAV#ZJmF zsKm`2y)NmZyCceoQZ9Y$Npj|#?`;=loytMF1+-0+^L9v3VZB^@3fJ_w&W=#2>_Ek zhz)$4pY~eK^MV8lSW9(oFnDyfvI@Nv_W?q8z?l1#Sx0X^ZeR`0I(@}da)5*iPld*3<#)Rjlr90TDu z@chCr_m1b6^*1D|NKWvI7bsyc%Ta+^eQ;YBqUx{RvhqSw&Q+X*d*`+-Qq)oo%EgiD zQPQ2IvMFcs%%yhg?-R7$^D(TFbpOU(Morl}RmP4#6w8`uyTdsbHDe7f;Ec%9hQIk} z8VcUEIjdI<=vf^aP`aS*Yi!wST8C2oKqCu%J6a0)T@`-!&F5}8>22m*7qT`}=PpwK z{%)7sN~$ywo4G6xlLuEtUw&6}dQLYf?RnER;y;_RZ7rK5c6iBgkmn&dw)fa*t9Sj} zE|pGR@h(K91DDP@-vW9gj}X@XFh8O{?JxN+&7z(IcZ_c>^vQ*31q#Rb8X{K_cEq)b zLh5Atr8G_u+7-oK%>iqpl@wUWm8J!A9H=sOB#k9T4M-GcqoV1ZtYjooB9*%CV ziTW;v@PnJUb6F#NvVn$1a)j<{a%4Ux~TxKrUAkh4ZcGQZfob zV^xy)uqy#t4OW2b8UYeauM-56vK2>tR~6_^UArjvgj086z^*qkgKPmfvj@?F=x==- z9}o=;+y)3jmrFr~530&hk?J**Om1#xRPq)X_0iCL64t1B<)U+}D@ zmg49bN}s3O8seLonoFM#tj4XJ$lYQ3@pG(^l;?i)-8`2~q`H916X`s=)^+G8G`VYymwyr6oHmH@c{ zynBW0A}@Ns zZK=%Z%e)|h)4}D}jzS7?-7t`R5Q-=Ru*r!5?mtds0@=fe4^c(>vf*H-60Z-3mb@hm zH@NMK+~Vcv`@A6UO;O|)C4qfg^WVI^)4ArkrEb}l@O?39qHd4FTWynNg7eb?%TJHU z?`o+yHpcXPnex4)(9Js4^J_Ag!)T%{>1jh(&uX!NX}hcFX`rP4*9;5y zv0Y|%3izvLPI)Dv=Rp84(k%BkFNLx1a&cnl!eWoH7GzlRyJl z;dRgeCIF3Ns}&V0JKK;s59SP#ebGw&hK#DLL;qBT8Se=E<|959Ed;V$m^40%~ z*~?-Ylj8-Ahia{h^e$?!8yqLE%_p>8NtT68B@=$-IXLNc|9kdeN#I*UpLN)c+KVYq zHXp`UpOE~OXTQU*JO`Rr*U!O*75OHY=X~*oaZRQTb*a7YrSjyK)!3I}{73_(8=j8R z90GJMXFQs-t}Q1gc=$&zp;nkuG@{H;jm(v8N5|@#0YgJT8~p?DXJy|!*;1_u}sOCENM#7br@f=jCg6^_}cSE68Cee%iA}(Z{8+PO!$e*?KYB&Je01n zBGbq}?iDfsZBXzscNRb>_df&%idBikTa5V-xjMY!5QR~KI{I%dGuWF%eFEOj0ab^^h4x6=M z^6hiv4{M9PJ?40LJU|^djV`=p}=!6L*4%n>RN6qM|a_TNy;UZ{@zlzT`>1d7^L-?~u`KLM6 zA!%bdDJHt{&ox6rKUBURJ^aq!6__d;;HAz0d?MrE9+N z0O~W~JP9C{VpKFY`YFV<;GD#T7P9TY#R9C7*gzNqP}VsB;B6o=EG_$Q=kmk*{_zNz zQU2D4f~Ar;8`=<4R4t0VvsVa7QNk75uHamU%8#RmIm-=`T|zfvwM6e%P*4#qN zXOIFf#9@wjEcC5;h&toMdjQqf|AV0Uha)NwO?P;EikROnX~JSjf!EK0zRUnWED z(*DO?R29MuRPOog9Duhu#$QA6VY%9TGfoPXIwGUrcB>HY)-@UPbWsKWbbFXN#$1pH0__GHCg-;=Q-BBK$g`)RU(nyv0OMl>4#qv-v;wp- zcrCXvFz{eBZWOej*x~g#vyGq$;I=Ca5|XakwdAEZ&%)7v)p4=C5Z$t89aMz>I4W(K zPdl*`T~)S2JqC7kD1VYITDPzE;=>hVe_Wk6@Z}hmGMOJe^$HdM zMj%^}{6QBHFjxzLlQdmE$&a|DI1fAS_!qu0^51(kNK-Dz+EkE45Mxk~@n9qe7aYg& z`Ew58uXTVQLDGL$7X`qtEAxun(JrLbWn}Pq$Z{pAnt-Zc=_a3!baiO00?T z(t6F($ffG^BF8K5?M2=8YRGRebz|y)k~EmBB`5iI^0%^`42j}BD1iy|1-424Mt&9jSnpBuVGy^LSD|OMkp>h~g#(OITiUHj zJR%6PqfyPhbI6A>VD!IH!fjV@wOal%GZ#CW#@Q@jaRH0)SF(@xKC25mLSOyz$O_gK zd{{D1$JfETi`LbVH^R?uI3PQpQ>FxR8xgQK$A-NI>6CPG2jh_M$n0aRIoKYxX51Ri zeX!e9v1He!XRe`vQVC0z>vM8TaTV`E^o~RcpVi!QQ!d}XOdDYM%$fbl2`^F;UG28K z339s?8;~7dN#ec(Q&*N%BHIm@9{+$@N(*YpnsgvorOSN;!d<21b~W3yssv5}shtdO zPvg9tWIBQfh*U-4S`&r6Mto-wlgQn`t>Azs?KrMHn?J+a2ngy*pz0}{hXfV=bZ{+q zJ9e2W#-|F^<#2ewf3p;j%;wEqblhFatdFlAQu7A98^N8hs+=-wGfZY~2K0B-CP@4W zNYSL!&Oi8(4EuLS>^#`Ft2?2(QU7xwCURkjA=$Wlg`DZGpZ|f?97di!54Ryz`5;;F z^);&uoKuVo*fqHzNK2y!GmCMxKiWfwV<+19KA1c5%Dg@ zJ0hrpD9bBnR|YC}R-4_q79E~=jvR0BP&B3vHWY$x_!V8a{}wB0?<^Tc2(^oEBtG&@ z)yVbRZ$J_YOULh|dKk_n>~{cPZzzTF?8P4%Sx6OX@V+x6gWM2A<}mTvA~S(*RFD{b z52P`~NqoFP+>w_qg3(O``bxt0E~*$uYR~yO1Tc(*ahK={ zWcIuIqoD}0Umzins!68FU&3fn`nm(yTu1e{U=TT84`ozw90;wxF`r&of|k5Q@in!K zC(9ibMsO?x4&;L;qgg)FTD9J;jF**XJ0n)IxOW;nZfMJ-&A_5BAio z-;@IuDY?yo{5hX$_r4!YcEo#0e!oeSferdM-6>DTZy0aMnC6L%`FQFV%ux{VSm+{# zOUL>q6D24UPsaKevWf<7Qa*8@YNea!oo0RvrvOMxKKRqr-T{i7?veMWJlqW!jm zy_nZ=OQF8F6lVEOa(0-D8wgfP=r7o{%k$o?)RujY5J86#h#6y)hk-1WZaa^GUEx@5 zgEpQjj5|ob=zCkd$^Oc?$?z$qOPAMhT|R!t!J+zUjrcIF!e4owvPJfeuqZB*zMCnN zmRJJ({sz}r1Yd`lG_ka(W>BAu(fc^(pno&W1n1N(NgWVVy z;exlDY-3*gm8XRwr8Em#vWL68jp55guCr@eop%=}ra0}D5P;RWwF~h-8}Y{N>Y_gf zMsqz>e`pKx={nHVQDK~fGy@0#9$jNdC2=jl0 zJ3o6Y%B_IP-=Swu59k7OnFuTtl1aL!$=ToaZ)n0)q6v|u)d9>K^Z=STq7P#>l7|zB z+;EUzzTfa4z=T4tp)&%H3b+O6vtEJC-+_`4>Gqae6E0Aw!DiD< zmv!8G9=b*P(a0@j@xnp z{hVkqmCO>fhx(e47|e;QfBfx$43J;?SM>9L9{-2e;{VxPDr^X$71W(Cq6+x9(Q2WT zr8{07(}gr#0h#kOcpB6n&YIKSBF_>Qc%bCwN*rrv8F((QtAe}~kV~46CC#0Oy}-s4 z`v`0hj0GK=MWCJX%HPAEc&ewO!r;)6Y$ z(yj$_U|a0h$+X~E2K^7@PIGCi_~&!{)?x_p3??6@t1?GHY#e+N;RAb4_lGsTA zNO7zkG;9LKeN91WlFSL z%%e~p)yw_Nw@gcSvhB5z^oG3+G5w?BE6MctVBjI}RwdvTH&!lv{&A0g9F<@r5NNd7 z*MY*@Dp~F`g-eGfw4gPl?FuPJh^q{w$A?M0yp4HrehQ=3K6h_(`>_mgt5#9I5KXvb z&G(BIVYH|~oM2&h-%7s_yj!}jdl_b+Dp@*4KRl{`dg7%}A7@3z^BOn#FWB2^PO_Am&VuuM~U>kn{`{n;!Q`QVcn5N#@F&l5I_ATF<+(~#WAisb3n(?T6Fm*?8ROmnTi~nJAVfbV z#M*-a)UHPSP#2Q%D-R%PKI>Y-flfm7a5Wkz>}!&vfT}RZ3O9Q9Bn7a(HZruik-4a) z*H0R0Bu@Bch%H8g7IXmu#m?)nPW|(uuHXXHP+t5fYgsPeLuuezA4h{8kUkmFMc7pu z=QA6fc%sPQ6c8x8j9qFbjZhFl@)z+&wv+D*lTWr$gE_a|)adU`C?X5emgr+H8$DFI zqIWeP#I+kig1#+wb__8+Q%ZMBy*rv=s8rcViZ3!{5nIYo<&}Y#M*&G^-iw2?d;7_U<1zYWYYS!XxXqC?H#msdt8_Q6Lz+yGCMAgyA@JOm6+H2O0bm*TU(m zptErtKX4XR4qirVdw=Q9H7qrEZ(?`(Ej(;@kQ}{IY9UIXtE11>|2RK z(0m;pH`;+4R{{y5W}w6gEz37E4;sh-PDIQAnMjC6&05kIxl!JzrHm&_!GX}MW+OD^ z2t1I@nSi7mP*WEIXPJ9E1t^urVp*2hrM$_%a;k=xF=}x2uRKGb7&9OK0+a&umiFOka0De}1%iu+-NPun- zJU+jI9SH9BHsH5W0B*eL8=B#&`)ZNhCjT>RC@1Y|ApxS4zXlvK_$*_r8d=T22UcjU zEoQ8~{n}&O3E>sT+0N@t#1(eDPf%2Bi}1ADW#KI9(VnU~@Y~P1KvU8a_0U8GelLld zV=*(!KUg&u{>^h=T+f~}w$6H)sq{-$R@$l)QX3Ag+;CuPxTM)4u{ZYP1$r$r3LYBV z!+)o*lDJ9V)#KHXW3@@b0T*W%4?f(+>rON($xS*?KmFkRIg2cRN%B4K6Mob^ClclD zJRdt*$_m<;--K^0yvAU3tSmwWr-2NAP?*Y`*+U<>_s0gAI=^#-lD%Ap_ zv>Ytd1BieTR3aiGARrPIVzT3;W^Xg=V8NqAm#uxx(g2~Y8s_6obm_nqVk%A3^=YfFOO+^AgOA@p-6Cg|x;C;J+!LntXg}!f$ zK`g!E$8ZWw3f6xOqOh6|04&1$AyJg*4cG!tJ6v8vOnaBLCwxq7T6J zpCFgf@EK@eYqUa7|9L_U7YlfBep>()L?;8w`4}90^BeoByXy!Wise3Vog6ePdFJOC zXISr}8w*N+U)CdfBcUTBR5X6$tf@b=ejcnr&(B6n*3JH9U*HOC09pFy=!x6vJS4-){z`V5k#b&3jZoG`I}neAViiM>yo9b-YC8;h># z*twzom|jFlc%pe$L2t2AtRt*APuq7YvLIKDUnO7PBH~m57bjx40TM@0jZC+fML{kd z0o(O87m&3)6!ZZnJ=di}SPgQOadGIE>C^PYxpT%%;=ev2vqj-3l5wx*Pg+y^>p-DC0G zAD4D35`9K=BXS{u0k=bvly#$&)xoHR#HP^8$3G1u)ttPB`FhW+Re#^pisK(|kstYe z=b%RrR`=6PgXb%)$ap>s%KQe&Ewoq>UAO7Cu(zVss(Vpou7rfSSL1PzggIL?+E3j{ zm@Wge(mV~{r!;I6leo+2fen5*u3=w1Ol`p zTU5P2<<C}q|Fyly)lSML9O}G50=M$FY_5J7pi#|y03_&-K*6~u zG8ZHiL4!33fL4G<`pC3`Y8;?(xLOAKo=t59R74jsqP+Z?>EDvMzP<+LRmOoI`aTD6 z`p6Vv=V|$p(2kdvl&)tX1^efbOg_EOnf1sL<x+kMBsyjkuPlmQEMvS%{o{GP7;#%vr2%uy+XNlin z*}DLXJdE7+J7&%T8}`3#XJMWH&gTCg(2`Z2wF7(1)kRa0oO7jp&V^mK>}IeHFx7<5uB8I8s!@No0?W$jztPtHn=B?9J) z>ZSLBzgS)pwBTlA`^>hFjr|FS4!Rn1$QZE04Xz9?F=Z~BcCadP&@wHs!}RN&!eA7A z>>fp!FpbmaNs#9=dad^v#E^>U-N^YYCP-rS6d4d! zz5YG({1@H7{r}D9>ODYO@!&T6aoy1R!8+h5$OfVxqiP_kIk<`AZX`FjUIbc`{+7i~ zpJF`$9d^Opq8Umfdx5_o1AruM!ph3uUjMfn=4k`Pi;Xd!h=D!z!cX{Bc*N+4E4Ow% z3N1l>D>SwJWNq0Y@!H;KTU+sW&LKfw_e%T=l-TCYtF_i@SGA*^L;wdl(#dwfo5k(5;MRq+=BkD zDJy|QpeqS8Un|!_3@H#ZZzj#&ly((G~L-G#)M;!1x;|MzK3v??8p6tt+VPI_O0*b%K4I zHy?pTD4{=`Ll-{j71C;|Me;KdgilYun%x+5P7#t$`6P+vt4({TWG8KJ5j`pUpU(xJ z51EOkADUt&jWpmH3czifvZ*Mo_~9$zdJWPfIz_syk=QpsuVm60Rlyc=O*7)-jr$x3U`T5 z5kJB4SbM-cPxuC!Htx|@1xM)5{1eL=BCy}%g-q~k3X{gbT%{806}jJQhvZjHVNUxr z?R3U1x)SYDA>hABYW9xbJT;LvEK>dLd@TNjsA_Sv<}%rRjSYHo?iN33)6p>CkPl>F3wz{=1gY-vyzQTg-gKPGT_8k%17<;}fbz z(!Iz-mW$h;6*?sfHl~up%TGNK(^pxLzxe!v3IF6l_pT>M#pyrPNd3>XBK;fj{Nq;g zR6wJN$Ym_V1_oJCOj*BFqR<0XkSOABnuI<<3IX2%WSd;kdyw;`SD{(XvB&VuxlJq( zp;554AF;qEEF7=}EX^a4bAM_ME&qY;P1XSUL`IF|uA-53f+*%w9Zsn1L}Ysr#{X(j zSE{{;X6lWg>0cU6*}ieCBN(SJj+F?829}5Vc6+)oR&almspSWf((>+W-_ADn` zB%kw%(PXljiBnE{7xLt z7F}&L6%1sbx8LfK^`x5D8mn3UjcG=0L%jPdN9RqtJ%B~S=_(_c&bg=`LXNriRK zKeo)~t>iC%*#f)v@2+Nma2(Gn(LRAA*=(nOq?ksWhWD2BVEHI4_Vb;={>4T^`~$fq zieeOae7M0U*Lkld1@l7humM-D_vHu^^2UCU57-Gcw_!!W!tDpgGl#vgWDTU0J3$l{ zz8(&)Mw5A1y2_w$#Q~tV|0`|!|HpOq4KLtihd|?Qta#-7H9AnYnWo$Nz(5cX{~_=t zQ!F1WFvXojk(~YTzC!@YBCcNrakCqx2~O7JxCT*OiC|t?KYne2iU6Dl=B+n8Go^o( zzj8zv%!>{|@4-paclI98bRR{C&~>_g;dZT-p)RJrEBqopakO?dn8Pn^Dr_k$?`Ur_ zSC4ZSw&d=Wbeq@2_;jw~9P0M6`jKzMJ?Qwt3K? zz~8*1v(o&$RD;50dFkgy;sP;e`JUWCiCGXkJz&~vHYtC;Bj7Uc zPFIjrj|2XUS46FC!6nqS$NtM?d9wi*T4 z(BmOvJPer?kbtqg)gcdj`R9@z0G_M_E{T~uV%izqHo}zn2vqVXDm&adj^89`UPE`u zY)xo>FvUz<0{wlJW1!henhUg(t_942nm=*gS($~J3?99H00ckU;Ja8@0^W4@DcxX4Z47*x;QXX92(sir$Nh<*pa{^U)9xbI9wDzPuI+vUn%w=Hci+F4dk6jo z0teXA!q(E_=1#V)KgZ7yz(#WMRhgeQ)-E6P=##v zm=EXp>PX(*#2dNN>~O3H+nF67z%7ZvDw`&gCvx!jt1U%uj22>D)zjRl9VePTBbljP{3IiXP$CfT%!^6DFmWsejZ9ghn)7Su$v| zY<_1R`n@Zf8+(QBoUi}ABR)Ym5g+6~MfW%oa#<6iw6LPGQ z6T!}`cI>`eeInv%LZBwc7@C{jzI^*2|0fj|*Sx;&sXd0d=Za9@F}~qZ98u*+!6U6= z*9~H`o2OsM+c}bNkGyMuwH*rTdgHhmvhRmpoYE9?D@?|8xh>{GY%c(#CX-|B_sl73 zH3_68f&bRriu*RQeqI5&rcGUgPFu2MfdCYP0c#`0YOH6i0GF!NLMLK?ZztOnft`r&|9EJ8 zzIrDJE&!M?+d^A|j`)IE$&(W!>qk3)o3j1s#*twBvN@SJ&vP97%Et~X(cl35B(t{v z6{h&>XF(P?nl(kxvJT`3G32X3_|v26Os5d$z2LpzF=O^Hz_A**K_$X(bI=iV*4DEC z2e%;TB2f7%Sab+t*=P(oFSQK_wLbiEj=2eqeuS1^@BlEn3dar22GZ@&(~9V+ZUEY~ z0=WMTt_!&~M+I<&g>s!3lV`dYoZVrtB)3a7!1`F}fWQkhBhUuG#rGWG>}8)hzkCJA z%c9iJ-_OA`&w$!FxBYO>ND(@y(<|9$Y^i1eA@bw&ERwfU5bSghs1|_kzc)iFM8vS7XW(BA|WD8&X*v3H#pigkZND zrF2#fpMI)8ZGYnS?PG{{bc67yJ@qMj^NzHNPN`4}-AdK=M%ARRBs-beJOGf4vz&x+ ztnsH~c6J8DP0(x<)A<$`ZK91z$N28G!>spX_bvwvtni-9uX_# z;KQ3nlwMbrW@_lrXt`^646#nZ)jqOby5Fe#E$71u2lB9NpLsj=p*g(EY8NvZYy3DK z3{0^VUIEshn9S1-boYORSj2F*a3U22n)L7lR?9O@sqMkEc2esF>Qp^aY}#7u72S%8 z8z(tF)(cftM4FbWso}P#%#PMLx^e6Jyvis~aCoIssQ-0}VL(`UPGa`Qp?HYL`}H9@qW(BiowcZ_)k#ef<+6@H^`9mvzz1sfU(Dt2S#uuJ=Qqj0>0s zbY6{k6}cKOR{!5e`jtjo+}7CptT)K{P%MCLdiL88T=ID+c;HS1Qky8qCyH*i-L6>o zQKT?kd(f;rbjq(5+K=%u>$I&(**zegC~l>E#rtq%=eYiWU|h&ScIK=$2>Y8aQh8WW z)q((OUkHTKk|AXru$=yowk!s!A3o5Z&PvtX;~^B9KOAeuwL{q-GTN@gF339fZ!|KF72uq4@X_4~Nc#~#SWZ72xC%_Kvd*;Uy1yQ$Cw$gE zS)ow>pr8^KFN-MHz&3^&{P@B{W1xo+Orh?Yy<-Uak<5l0=Z;?ZX|s)nsKbj7%64_h z)r=`B*Qp0|j`C)V=+U%O-Q^{=xd|}GpFn{va3>WZR3NeI!_UeOqJ56%3^%j-F~7QK zsViA`m-+gf+F;bb-$apWZw$ZoRoPMs4%)w?9{-oa#j^s?D8Dq& zUJ>a`U?{+{pdl^wqVE#$e)NI&6NKwWuUj#VnG18HVeljwzad-h1=pWdgWngfY&5BX zu&5LejO`RaSY+-F;Cxi6_di+4=yw3CF+lGv3xh`AA&X>RXMwJUgnFDbmYP+~Pvr>5 zUXpkn!Mk~G2fP|6yrYz7>LLz!i#6<;09`!!REW^xO*KOvcyk@g#=}0yg#yJD?{8NwfSNz&Gg3~`3(_pG{Q9x_o0h_IZDu+p|qz8DV(&7%$!Q^#c!F>wnriYznQ{9)tY?UPSVi|NW0eSwW>->l9ZPoL#R* z+C^@{)pFU?Q zB2A4MD~e!6gOvOGN`pxmU-KNK?yTO*T)XpJy4>- zzkW}k<}lmZ zKvAwemy1TG=}tM!ZmV^GNF>?(3cn-YJ5_ss(nu%Az@Gj%=9>1sbMdmM70_5S4EGcq z$|gzbZ{FtCD{2{-8IA)O&%8>Ap+GNkXw9V~DNr!B-P?_O&W5+ARI-k};iJU(qMIR{ zC%*xt!#_-upOi4aLY1Nj+!qzEMTn>(_86VazEf60>-S$%yg2lQ@yx(;^xB!^K`sZM z+ebX!Ak*nO;a5%h&UiMH&LqD4v1i8n*7E%AV}xYGOKXFVqMwgd>?3kbX3JL`ucK%Q za^K)IV7@(z_!0?<8HO@f?*4YisGrdweucMWR}-W??M(sEBqcA0eul7wfcJt3@5Mum zIoyJ8P-baeLs4+rQ1f0rxM{-yPW;OAt@0Fz3ZpVv;V1B$HUg{y!pbi!B7k=`iGUiY zj*iA}7FU|1XCUncD$#d;EMxDR>TRA zdEYnpJf6tv;NxrABZVdnj?01@hzse+O$p)>+>KN2=$F%UpB zchG$RA+O)czWE-!{|U7uh;aIUzVT?<%Yr^qROZWya_W#YxR+_B%e93OEk)mW84xOiSBa zTE4a(Stg^u*ho*f$&X2ptT8DmE}Ce#T;DM0py>GsDNKows&&BB z$Gr`C;r@`J8WOFtFk`K1zG4g1TrEO-YcB*h{Xx3mK2QvPSim>?pawL9<**W=b#@gB zAPT{UnA|k@DeXKN9qL*sGlu7G^-zk=w;udHtg?N*eay7FETz@Fq^g_XqMWOge{V@q z*+oflQE@8ftkj|MwFjD>3Iz2Q4>@YK`Wfyfj_@2VL#5no@?2xun6YuAlIyYMY{O&4 zu}(j4c;gO>{Q8JT(9G~s9p!G{Yg<8p(J&d`Qb<65OID6fXEo^Z03%$B$}vo9yr=IZPv`42&}$J_9= z(F51uJtbscXNFoWz9b<4N#^Uh)=~;$?CjA!@-r^-0j3HMpk)Fn>K*z#9;AIq1l? z(9190dbLcx4S6$^XQ^$zo-5=K?;vpd!&>$&siUNPvD{nl8Gn!%4fG;$SsQ!kp0w{Z+F-?pm_1Y6E#Gsl|tk26D@D9wtN~LAr!zXR% z)u=Pbj;RJj0GP|ng~^z!K?`9yDQGrKO1H=9IEwK}A5Nv4`^?-P4knn}=gbs-KsxlQ z77~d;JEoUi~5J^3{&R-gkcL z_3UryS=BNyp9r_;Bq(@_=w3h_i$!zRr|{h#NGPr!_e2)B$5d7m9Q#`3nui7lJk;q% z)#Z=lj_HCP=ri&Nt;G9x_6WA2l<_^z8bo_XQ%<$2k4m#yNJEmNmx#S9w&9N7W`cntc^C^O~k@#n=&09;LSnBWOFS8V$Zs*U0 znP&9!G~{Szm}{jVIJ6+o!x6fmcFNI4y8Fn7n8}@wB5Y>LlrlO{-S+msEy48O|5yT! zj&gHtaz(yq{`Pb^rR&ACVmCCq)ts9{Sf;Sa$rzMHj)InJO1tr?mHDP4Ur&Bq9y`7g zAYLqA_w%Lq`b3@pB?&fQoCQq%ffNsL6x&mNBhvo??|N9xOLYjZ26F+8sR>W9CkXVW z2C@3u5hLo)pod8dZdSyX%a{92y5E#nB;A@Aza5fh78IjvamDshz^sYNOs%J!i6L)* z)Uoylv4$rC4vDs3j&;;M5s@}%aIws`@no!7*n<~|W)bEu(gq6+PZ*aD78;x$4n6H* z*+oBJlcGd_N;#lbYqOKuNE|~5IPdqx|LcoAtcVGs^3Iu#->%;HFpng8vG)o8ol`#;yYcq%`jW^C%chwKSP?M7^*c8K{b$GG7On zf}b$ffQDc90^YBaDR6OX3Do%%%MPYIarX~LQh&Ytw2Ana-nFl2I=VLHmcaeeR!ZJ^ z#~9LLhe5@SW|k0kC+lVPPTbdF32iaDJatZoYF|=+spt4N$S~|H_VpHRcI3?Ugh0sQzWt9(W0$DssdVUE)Z*;s$i>d$x!t$)@4fk0_3?#~r_5xkhcrQz zwKi0zlDUEwIMW?W+fceO$N+`v>10_eW4=?z*4ZR&Ow+Pgy+j6gwTV0DqRNli zv|Jb+e(J|3zNgsxE;>SnUr9DZTV<7E=?M$D%pMs7tRL`R3$#A`%X$4hEl;3yz+4xpU7+o6saNBI zq6;%wqd{8=9YQ+)J|K)T*wpud9>W^FB%tt!#9A-P1PuU|Bx+Iz=rMU&PsX8GuuUyieD$W{LR%b@wu$+Bqj z*;`~ur;oa)gVZiQ`mpBa*WgV$k#{bw@~zi9ZPSPk(R{HLov0M9D)mjb`KiZ(I0KW{ z_?VAOI$-NE^KrVrxsbR?VEwj(@Z_(}AE(k8T5u=$GNSzmBC{UvFL@LU7jUSL&TM@* zd(Kz8?n>9%&@Rey%jVMgzK27)!<0RF+Ot!pMX$c%E-qB|QGa|Nw!U#uV1{)R*8L`mSjRu-fteaS~ zXBH-^@lXl$rc!C_SAXT^tZ~sOWd>4I;?Btu_3v5lF>yVN7nqQRCn`j!mS)%>k5L6d$N7&xp#SI3{P0*k8#Rdy?@W=lJhIek-orC zVeVz6R|05hcUdDL*qS3U_idDC*V>*hlHK)>cf>xOypHjzCt>3&7DMF=8&{O@5V!Ch zm8f;`mpTB8S05=cW%3qLgae4hl_-WhJrfo(@kbF1s!uF{qD zz9z>itrNZvpQ7qTR3E@Zn^A+KE9JqIYfPqoLURvOi{g8jaiLEEpIq%5l)AI3MNcl0 z+B)$vGa~mx<@3UVi8&S*tbzOb4>oqBBYGc#o9RS%2gh36`l3L=Ok&*7Co6h_j^hJs z(9=5A#K+j@;IjG!mk<6`-@L2ZLr$o5 z3xz~0%^gPpcZ!3i99?PV6BMpTZBOvXHsu!Ym0X9f#?F&$k~nX=dTJT^7;ASTy*)hm zx7Yn-{L>=yjr;%{40_ReDJ^>aA!yaG#fxtzb{u&NV-d?u$suAGL7Vt&lc z`_N)r+0B%3fhOx=`-Jd3dlAGpw^~y_G$)RoZjIQ`Tr zPoyuFy*IqmTe4te`+YN|#23oaFSk;<%Epn6T4bt`_n9X6Xqxz-7!JbXMzhT(QC5bA z?d^CKcac`@^3bkyd1zav-Kqk?|M*o`>yH6&m6a7kI^C3$qw2NmdsNZfVJrF5t?$ja&x%nbvF{|2-R=^al{Dw#EydGy?NlfyOd&7WbdG{zh2cT5+^)`?<-#hpF^)zg(6W;7!8xJ;PM#h=){vq`+kfqV zDJrF}w#Hgq{BCZp!ooe3PuCRH8(SLNce}W_+*_~>I+}`p@zKHUBw?JJfiO~SU%A&3 zAa^bZdA#A)bnW}F95K(?k2MyTUcAdlb+s2YkeyFk@S>O6h6E`iA{xvuM{4TImfY2S zWNwzNb~O8F>5IGyWc=-qmtn@J?D^`2Hwo&Wq@cIGM1-IhRMhzR^3#2k!M{$mG;<1iy}*eosLZ zWK>yb6<6_OY(e>WBnsfof6g>6yG7%K-Ndon^tRES2%{rmumEtf=gpq~%;>|)kckko2L))HSVawhs4D>s$!{N7k)W1eB?(vEGON3y2O~_koP#9lh z6KM@_(Pnx5uxFOXdNP%R($!x~z+%sm&*JtwY)qTk;Av$w9ArYHDF_pIxOD}odi8E% zm@5JYpSV0!=5tbaNefLWFmiDb`0znm(kxPJ<2|p zXRRvS@-U-XAI4^Ln!lcDwzim3e{dt+#3LY~3Mt2Cz&vB$#*qm>c@L z_wxToG+agK;hKg8-Nb;RDe4HS$K6vSieTB@eIr>*KN4%qJ<$#8#0xtdIpkjM zw~d4Gjxc@%=G;4ahXySaj1FCGlqscyGJFX-WkFOeL;M1?%SvP2d{_3E_@0+ZSt%kk zbbkqCL|68Ii19husOpwK*%g3TIlnU?RnJuBN@f3hXEKLXj@F8K zd-TMt=>WK3{>b1zd5+j62B0H0XTUv(b=QBefz0w9<>!h1r#^l*=mlk zL8EV#$PAk~_4f4pnmX@VZhq)momO%q$nxn)2gzfk-6dQZk8=3dCqNrXMO+`3?f>>JSc7VWlUQjnrtn2GvW(^xz`RHf9auKA?O*k2le;{+ z-7w(Ot?xU=&g>$F7_}NDYcJ2%E+6q*Y?<^i%90krxVog@bqH;8h_bkC`#qbmm_m%k z4|#G9 zbN)~Uz_HNJJf*a8cnbY{qgy}WbDbxzkOFIB#FNRD@fSZjo;q*-{=+~ZYOhB-! zxlbG?;{awcAX)~}gd+{T^c?h$jwW#7+9-NKHB~PidxNSP^wHbFMX@xTl62ZvzEKik zAUfU{O_5hjC>T_%ON#HxZ<`GFxW6Nz!oL6DKiH5XphFE`-55t5eu0Od$=*vOyVDI3 zr^jHvq>|z;ZRwf#*7)VI(xH8!lo45(R^znR^x3ipg?0AiS3J_}w3M)(zG7qNy2p8N zAVpEi{F`T+5_v&YOWgWHMc3L5^+n`bd_T!|_0kQ}b-m}+;vsg=AE+J8t@u;Y`QH>v ze(Pt5N7Iw0S08V~3(g&acWWl#6ifUfbuz*8z0J!yxn>WQM+ILL@4Xq$^MoFL8?e^> zwamPZzbJaJV;~dWT|k({55PxQnM@Q2r6!(ld1O{}q2)e?%?m7H-Hi`ZXW#cc!}djk zhXeV$YFP@W8Yr|dDM!CxCjqtl*UBJ*GTn%JjqLE5u;=1vM?f`arzRhH+%v`JhU`#e zU;3j01tdwVFUM1+F)!aqS3p1MQty(R8@GXkwpX0k;mtrc=)efoGI|5a6G>dFBS*vU zk=s#Ifw*9>t^eN7_CFbOs5ywqH&qjSmChI=h_-RYbk{(8^Y4)pTrXA^QS#i3N{d{^ zdGlmr)9HQ(Q@Lwi`j?0xnz=wjh|y>yPm&J(z*t8J>NITJQI9x~k9Rost9Twqjr9W( z$t3?5h46f58<|oPr=^d>*&km8*w;vZ&D?>{JaJ%f(#S4iH1hURRK*T6@9w(MYfJot z^}D8G#%k0~r=0RT6Kt*!bC>IR*2It>o6$|+Ag!^!%_h2}6lFN6Yo~JkaNH~joJ{g{ z{XVFbyjB@scBxcH+};m${+X@_)tMei_b2aJ3Le&^WjDEkwPCu{|@+|2-tA<=1$X8w1V zr`hQp00sQ_N+iO9#`;UvQ=$W!6k+28R7DZSt7+x)^9GuHP2{d$yw?;dG zf;kiHnf1fS+OHHU-P2f4!)9xg|;xf;xEYK)0qb1^-BU-v}W<*2YQEJ zV1_tRdb-=hVb`xi>7-;hF4Crrdf%|(eM;*>eM!0g7oNZc^81vV+RJbM!C#I_Y}kPndMw^PcZXrB~VKN9Zzc%$MlT z(Tr@c4eG-f_Ha}*4a{9$9SU01F~sqk;SH5gDtZ<7|jFk46?u6lJ?kdI(Ay`_J++> zt`my;gg0ghbHOm@3U#Ae0{#ND#>2UANXm>R8R;?BrvGAj{1wwN>-rqYt|e`|ba>s* z$Et6KR$NN2Kfztvw(k2!`tWb>ai^e~+puJHHnoGSS3l_NyF}&@b{ZD!NsqwJWYSxW z!#4XIX??>Zm#Br;8r$$nzQ4+ibv$OhA|xX3nFcPU=qL+&bOY;sdo5rM_G1WeMtC$97u)tTpWYA!E8CY z!+HXk3wMNc(i_0()DO%{?VodPO9^|Kb1~9Qj0)L+ngwhI)lGdSXA!p0$udhYu;By z9vm<2TXnQ5EC8I5t2GB2yVeU$`K-hTve@Z10FzV3da#m8@bl5()oi`Yvu>(&HR<%2 zqy6U8pmLPQu}-G(O@}Vm3=FEnMcpVw)%ofx+(;%#|5v-u@~myl^W+X5dYNvI=2=P} zk3LN~c+L4yNw12Qk8x4&YNYM})q0p=LJXpG%?cgdFF~!i%^vYYZ_H~!8Mp$DbgQur zV3^?!^(m&D+y2(cA5bkKw`8$^I%ihy(lKG(mPFvC8@0y`q!?Z4U;TvX({SFqz5UR~ zUyv^oti)D>W;5^=EnT zmEzF;g-zeIfJV(-e-6cd3(e%5eSE?{j+T`8IVa`3N-ZlbEeoAYp?D|T1?@f*X>D*P zUe_Y(OmFf~oTU-3{Mz}gez<;y@He~|RKz?_lSR_as@cnzGgm6jY-O6F)-3^aryf1s~ z=-cH*oD`<+OFz?5qwwCVTtZrDP;1?{uW4ze)nXqyM^lc!TX4O->k4E06Kx$<5~yt= z4D_$t_>q>#Km7sM$w6Y5I6eecx~sY*_CxgW@gKfXuo31SQ)_4ay-rg{a?V~!(xieS z<$C!^wf>&|hv0GI_ym)OzRSHkD)Z{)GeL{(R-tTc24@IgJ4n|+J8{Mt<}Uc#H%&l8 ztDU9$J5ScJo{okyJjltXX(y{uA(|c&Lo=rt(x@;Wmt8!3PLIlV->fbuI`Z`r4=>n` zQ4nVQwTzPRVGHjZ3?2(!a0fk(Xgrs?9ujs=lTv4gB>)^$yjt|FIBCqy{dQu&PcKE! zJg3df@2+>se5&-!;&(IWVl%(bbY5@WMqmCZXRKFHxmR?iW~#Rp_TvuD zo_D?AaIxUDnDpR>b1$)Gxpz1lA~iv%II_b>fq@)ePtzhg`(WsMqhz68nvv@umU zc=Gw_@(%CQjlo7(-?E23GMDFKK>M^vc} z@E7AUIG0DPzn@5T(__Xcla%2WWB_taq>}KA2nM}uoF(`p*Uz~S*KT6^szEBm|1om> zIj$30H)9?GWV?n5Ht2lu|1dQM(uSzl@B<#}Pg(D<#tcmxEI-|f;ug|3EcmTjY7i6T z#?$0**wK8J6zregeXD|DIh4KE>p6+DIZoEwnB7NdIu@vvVotXo!i-q@g6{Wvow!LKB)9|t{g&BXSfce8(A{xL9 z_d&8KRe2#j6RTHTy1Y6P32|4d5`GNH-7~eYDTbVI&s^ivz;lUdZ!z(~T=YH1lluxf^ej@yR#y~^zm zATNo-odoYjN_c~SVWv-C?UK8_* z00)~u!}}iYCWdmCO^ju`J{goaz!@bI2+?YQ60_b`3VKtQ#@y-%d$2}Sm${9FR7|RI z*xEh9j>|QY*{SGb;pX2|Umi-iyWm;1@26>R9>3$ol6f1usf}h}){1#WSM$?XY5~Vr^nL!lN;l9m>ZF0v_&j<}{Q(vn40x3bX4 zr4LERZLaC47uzu>C`#O8lG~atr?@1H6}G&{Id-!MD`;I<)04AnNd2Y4Aji>jf)6Jn z&sx?{-sLCnda=YDdUg9_2Ty-^19^^Y&zX5%^xWl#_Ge1RWPr} zBmv@XTKK3#BhSD}qZ*El-cKEC!0*+(;ZPOzoRTLyX6oGf@L8kkUdh$q?vf!{)Mdqz zNTHQWU5ihKT)gF0(6g2{Mzo|+WDSvosOh(1qYr_>w$Oe}8PCb%U6tnP=dpdl{CX1y z&R^)!OL$L*uIM*kRgL6gnDi>vXkQ$6NMxD&!OxfmF$@V|0g&gkdN93QH|JzQ9hlfH zFVC`zIdi=!&bc)rUAHpNEw9D&70bqmqGazk{x-3WValC{aKUsnnMZ}eT`lplt?75q zrIyi>ypXMT!e9b)4^LM+)XzXQ;tSNGm^BOrk$xF3uy&BZyzCoZgXd$uiEJPAMS}In z#jv$z(I=t>nP0JXbWz}bVgao2L|c`4hUQRbDr~i6mxjqPDDNh%4@jTbdtR^V(CUJZ zL0nI`i`|9F9+jLoYS(NGLH}7VPJlgg((-niA8O0$uRrS1*Lp&z_D;FIecQr))r|Ko zysqulq7>?q-ol$iy}7fdy!K~*oGoNtKVqhrh_S|hZ0K6*IOk&AaBudqXZG3@O78_| zt+}pO{O^F(wQ3P+S!ks*VFo8ibqn?!5u&GF|75gRxGqJk%WZAQ2UYcK|ACZ*G{;9j ztpi!zfw!Jn54Othls*LNeeY*-T4bLw&)nVO@p?k!94}zdOr323BpZQ=V+h-US4qh^a&KM-^j{aSxL6nTn&x;&ZdKjvOP3)`NEY7~p{VzD|7r ziZjuLOY<6x}e8$z6fE$!WT83OP9TqEVuk!4ZjlXo} zP8CqsUN24=cPXSEK0ycY_C~Fy+QJ8K6=L6OlEk<1&z6^3?pmPG3ug%mE(&X{msG79$z%RPvoNdlD5U#0 ziak$4eJt`Rk6%+UGRUpeu=jkWG9=l2?j6h4id0>YhVe1#0qrR*x{I}h4T@7h8<##+ zpE(ybqizM4XRRJSSx&-*HI5FBZv4fuKYp}HoH(5DyjMq+ncOIO#63ZxCr+aKM7EJq zwo3MGZ|m&9*8It;*K%f=$53D8jy*WqA&wF}W*XOBS8H+%XYkrx*E6NLPB7%f@vfNh z&t!{i+p_ELFNJ%a;3q03d-u9tanBTXzS~c$1Kiw`P_qv!5t@HS2Q+E(v+}FK>mUO4 ze?q(y{q!Gfq-tK)>v<$Ot@`kwcOP-E!gIU=S+gKS^U|Aaqjbm`0i4u(pIx#d^MJil zaCS}g(Mkuq<6mF{&;SWPhy)Qt8I2zd@@|UebF9cuO}lEEO22mQo60pUjyfCOZ<&=b ztW}qNE!z}VOD7jmua-QAOs)D{_cc`X9?^db>K|@WmFsMjTFaBz8wT>PDP+pkjjnJ# z%$`&vuSi@k_^uk9E+^{aUvHi&v@wAam5?F3Iq13!`9^QQ-|im#mAcWW%uRi1_|Tm% z!dM?LFQ$2C^{g<8Ir)AVLE*( z=D&(X(mm5L`;E$9XGx~3!$*4VC3e>%Bs9$_h%mKbtdDE#g?N2UdGcHd@CdF-5=$z(n(zVCmRhhf|D#9EX+S%?xbi3>8o3Y1%az&gnT1O?OPf zC!2EXLRRFSC#b3mO8KRASB%%xeQ(aQF3MXNP9kkC0>y>9g)RS$)xY(Mdda*;<%R@t zd$HDZ+moq!G;wlfR3%sKx$PjWDBP>U+Yq|#bP}~@nTuC~*Me`R=gRlTYsbHbi6ovJ z&kG`)->(a`UgNQjI{bpTKq@|F1P>{_o-j;T|L`bT?pZbm>ERUDGw4`%_y%HPO6BBW zn_?x+fSamMZR5`BY!xUtVQ~1l$SwmZPcSJ`^y>d&@4cg%OxONjJ1QU|9R!r#5owA@ zECUD#NSB&Hq((rb1qo!NOC7q>B0`ANNS7MvA_CGS)C2(mk%SV1B$;#L%o)sRY^4N%(T_d^sIIT0Evt_gp^<&AAKmVbfmw zJ3QBatj+IFNB+lN9!q&jz?-QAzzS|NkjYB4L=5tQHxxl?>ysRENAe`n#ebjs)7A&s z41gZOeVtiH?l{AL;A&!NpXjY%o@JuI*G%I)Hl;t_j0`5Cj?m0W6;BkS5yHS4tnc@c zK%oVu`b`Bz?MOvvu`IS2mHVR`-!|?iiVf`ykMy!)W6JXHrPHhk>YR&qg5A5Jfw`K$ zT>RpwEGOvk%!7@?G`{kahoAI#I`06Nq<#*e-*)n{#T~>)j0uK`nt6Qb&FyT>j)lsK zmmS@S67h@rLc@3bS9Ee*=Fxom>>gW-&7=PD_s3AXBPP%?;W}d)dlRK|pKMo)(ASjx z;{Y?3ARdkK0WTB@&gqmAzkUt*L4dxYD&KFFAYoDu?cyW9Czn!f`a~d9eaTSS%~0IO zoJ_4=c-&Ez9?=gZ>!MQu4pU4HTp>AGrWF4b2UXHoO6bm6!;@SVs0OhH)V2<@aM*`e zayo~(bh&gazkeAuUG#)z6#5nGyL+FkS?Lde-2n@DT%-M80<(wy%WIh~G%3Qu^-;D*Q9zDrg+v3>xoTy z)}`o4OnHidcd~WxEoa8+U+VcgKmJecPj=1r1i+WggoFv>mG@-3P`r*{b-PiafuCnW zFx_~&2_(l(DGwg>mKLXaFMpbK7xIXTpMlTrb(p>ti=_*V1$XPNoojs+z##QjNryXfQ=~uWl z)M4J$Z^Rh(OL1MK1$72#Be3jgj+G`|PBNAq`Ub2XHBu#9Ernxtzc_zw_}XADtzXm7 zD#`hr!i7YEu6&9N(?zY9(Fz^QbMfw-F5C0v*ERMS(w0mc>uJ=SbdtQ}bW z=w=1AzzS@kk$!ugpE@7eyWx|bqIKSh%Pn3z?$SdEhYm#31jn7HTv3#L>WzUF^L9s3Th0s$j4P>_&(_FItKMLDA;|~E)%j_R2TqVCyf&yx=a=!f zVz74VK`#C55tAf*_FwHsE;0{|GnFuk;soIuMSNWQg&PW9sRW}2;+kwo_AC(qp+_@t zr@x+yd>ClgA4G7wS9h3colWTEjuZL1t?YL8) zGQ2r^`*eV@w@R|s@hf-d!yOV$o*7H`S2Yi(&)lxR_}1mLfv#j&H^IlQc-uGOM4MLL zF#S}#kjUNJ4m@1KajZ`}h-d8WPmY#MEfv3qP{<7Ewp9V*S88A}O@vxWRwg)9r4$vD zmU~*|N!lAZO%8fArHVPX{)eYVtr9<5$Hh2nvm0_2%ULIkqAp{1^dmj)W^pR1NR-^^ zG%1KFFxBWr^KTbhp)a+Lplxy{(lVdZ?Tvg&kDG^^M&7znC{~vyb3^sK_@b1Nd=OBV z$eM=jFJ)XQl&Z$TfZ#llKla-aZwL0AWSExzs0D_KBV=KZ0%G)7<4Le|bP*4+y)>{P zrP_B16W$|tf-+FzJ1MlxIOZuFzMkkt?)eVYcxUylxNLxO?-z!Q-QsB z2T2ukeG8qMGX+yBx&+3Mq&kwj`#M0Y_Ytl0UmmqK6+qpyoMsKt?ya&UEp#Aj6xzv2 zp1#oI^TI=jXFTUaX<*5$t!;-J?w!LavX^mNj;n$Cpkxd>bF9y2*KdtL+U#uPQbL(i z{7Z%~Qe%GSz8K)&$9s&1d6=M0q<^6Whx;Og403PsC8pnUT#V{;L~HoXSQ%NgWXdfc zuT?kH@Xl@1*Hal4OV!=o7=of9b&9kz(UdlNJj!%J(|KNp{Jp(TBIOoCfp*aVwB6R9 z?Y*0Z>f(-rox;s$-uhtRqxe*%=_>EcJ5RqEn8nmm{SuIsS{wPNEq{^;N;G)>>(*^9 zXf%6Rry2IBti;Nwi3gg$($IIP(=^{k*dxUa?jq<-?JBqqQ@>mQ7I|`a?A^=5k|; z(Txf_U2kX1%D9PfU~r&jyl502&*zf<&Rpl-QE7dpc(k;R5^$H$;=JAat`S-iT=g3C zP2=ySdg)0Fdy4&ZkZMx&?CYlVz`hMO@Va5cGCYF-nV%Nky|5vOoE!j^qQC~9Xy>N| z|MZ0BaCobQK#CP8sC8Sv$>3`u%nYXb)1QR6pQRPONe*ylA zNQT;WSQg7^P@X+D>3Cn7;~Zl=`MzLTPbaP<)i}#z9BDAI+XN0PQ{>`#TyXokJF2^u z5{@ntJ) zqDxW@zf@ZIzcRr+~u8>OiVAsQRAh zP~HCDQPKZ;V*H=H{{MS3{jZ7Y|Fhmy|Id0e{j1aUFRu@70gALeslWAN=!ZEW2G7k0 z6IQdAsComMuK#Cy~5Eb!tj1`v3zD>)P?0|lG+Hr=Uo&k-A4K*_rX!~}7#N~4p@VTs zkmMa#2Jx~*3P9n|PPIH%GE+P9pu3H5oPwX{4PjOoe^HA6+`6H%;e=Sd{l)L5BflhH zrAM}mW(Fkpv!r&M_5Ed#Di2+KzL0c~DoS*XQiUExXp@qnX#Vr`M~6Mj;7(nQ3b{m9 zX48nxGg}5@^54pqq&~rO35qOFoS&v>TM7?g*OS0wt|O#DA{ZNwbK2km>Vy~MUt0a= zXfi<8Z?~HD$AJz(9YQ^1avOTua})ucA5_zEk@ag;8sXdxsI$~iefiB8q;JWo=h_x8 z8?!ENdn{h;d!6=>Q~6fIz1Lg>z5W~USM9>qZH6UzG34p~Dm#6e-MxbdGY^7fBs1`RCLuSv1UXErt5ANj zTOcz{P=ecq3S}rBe%i5cp_Yiz<%lddV82lY#YfsG7oP}l*V9)Zr#Xrdanjfut^8$Q z?n#a1+hi{m>(^c$2HyXjV&2|B8|%_b4HDVF6!>!S-?X)VCv;_ZWGO&%7IvNS30cQO zv5MIqWCDYWrW%Gi=FrTjXz!5xmBvJr#Du!mDbidr2<=M7$A8>_2~07|db3R5j+$NW z9A^n+Tiy8idlW-^a8=$EtEaWlQ^@vRYOUjEkhOkGEx>%5bI-CY;2z&I4sSllNGIS< z?V7!`y9@O=+!-o4QgpPuS^rf4+XrfWSLhjnF)TVmaSy7B=@lToN}c^h1&RnlYV(g z_}bz{VUl-JIKqB@V7Amp1CT zK6PhEv7%;;Dz{@`BA-557btsVm=`MCU=HZyyns!9?Wz=(I4d&X+Ijh#XP$XS2eamc zpe--yW3fzS{yLXbiAUMO3G>ASUI#DsrPNfD_#jh8*!$P)?>DDU+4EPGpXCvdOE`rv(>ifNIf?f0W z4>YcQ3}{;eg!O)$F1;x9!i?<_=sWNh$?A8dJmP4oUhO!-gjnixp4W4&jH+=X_PXJd z!XtWo!hPDvz&Vl*E_@RqLjR4y-m+dZMGP71z%xGh+{a zVQ{>ezQ*@^33r0Y6nXCKmPIB>93hfo;hWQQ__qk}vR6aJavhu#wlZ*irHr-jPa#i* zg9rmBh;LGI0|h!1+lf9G1BT3VEV&bC(`%zJY$JXWRcsE}eVnL|z*M+%@LzwRc{q{< zG-3l}Fqr5sYnW}35DU^^_z2PKcZ(ybT|T5fvnq1k3wbk^exKkMZuo(WlHcB~gpxa1 z5^H~OS^sEF$H4HGnEX{rGIT{_02Pe($WUi)WS+TVQkOA68FpUqv*I2xV2PU%jDEcR z2+>_+lIDx`V zcU}+s8^ow2SRWhvz(0^8S8HpDk6g!!gv2$uZJq>n?yA(MrtkI>q*(@%*+?57fz=3v^Pv}k(QX*k_q|oUCz7N zJ!9>SqhH3$Z?0OrUUzIMjnt@3TjqY%ScASamtqtUzL$7tpo*5M+G+8@<9*~=OIF8x z+sOg6hQC&&QHg&8C+4J=5)3b8s7*65`JPExhYr@S0~ygVdg!1q|L1XV(`qpJJx#S4+BI;R`K8RZFg;_f$eB z7=nyB>It%02jjw<`r5>08&Xv@vPEBV@~<7WcYhF0U;wVsBkc=@%M z{x~h}T@2fmlpBC!o^0u34?{1!+u{dh9WG~Dq=zlc1=8G|Uh|fCWQgQdJ*1?4PRYSU zcWN8p4ZgFu9F`!;o#mFu;8AMtzkCO4i9MEGD2~zCW);tz*8kD27la}9k5Mio<|%uBnO}btZimyWS%m-M6F6;be)nmaZv-uXD569??HeVrn^5~IyqIa_O%2Y#`?MKRXLIf;czp+o9^ssTs zXYESgDg2_}@9BT!^*fww!6{ji=+BHr2oO-lKaS1f3sz!>Ar2~KAs*OIl9VEP{7z;ib(w^-9M*)$PXc+f$d~KQ+N7z@Q`UbC z%-t#b>6g#%{WUO%?;5Iau!(Emr%yo+KPR|5J^Jb*AQ(~BP<-!U`pP}2e)nK=^kuZv zjPwnCu5E%PJr23_0(ho5lxIw`%;#IaiOC3QKzzN^o^RQ|MU0v(-ibamOX zhHzwRSjosNr=0i3BM(In-pACE*ZENeR_qQ1ix{2A%VWjr_zMxvlAcpl@s?F-rk;pu zs2Sq}67*(K+WQqAy~i{!+1`Te8Xx~|f?sn`%o861y3Usb!NC|!*AfBGlihw#65hL; z%uK`T|GXtDa7#!tNF|OY&`UBPBvGv5aWDu6vVEJJBV;&7lifJgTMX#=5~%^%&|X|) ze^Q)g;OE=1vU$gak~~LNjSO&dz>oVp}`d1ESrxn&xj*n znZNu9eez;O%}vkNUj5ea`uYR87e}8*SdNp6mRv-A&mfNw=Y%%P*lOEIc|3bgoDKPO zOnic!mX(oBg$E}jFurGUjZg2_*PB&=ISx4V=TLqpAI z4eW4h<|9@2%nFd%o-_lsV@##(YN#ezJ+fIBWAD~DR`it6#9X}1c1*k2y*|(q_n;XE zN(w2k$Tu}w!lO=>al38U)xo1wV@-lxl1gH5Wa7zI_h*ik&k(ZZMinCICoeHYA#EZh zFWo7XNojW5v#E|Z^FJ&8O|eV!+Q8=5HKjJqy6R4|HbbUvhNwZ?JGbLCj=~wRy zIW2OHZfW<;FF9<1Gm-u~^=AQWIhK`*G$*^p)Ce=X1@s4%!!vD$X^;ZELZH1zR{u7C z0P4XTmO$e`UzVFEjck82=8A)2P$b>KFhz1TWs7<(Qw<6O;qvxkEJGQd@LU~T6MFQn zGpYFlFXxrkb5QDyGrUPNy`mLM*D&t~mG!M946*f77U%Cc)KKwkFMPga5*+b6UZe0-p-efdz+V=3%bXt~~asb#J8 z<*{;8v_~~)ZBgrCUTW$+;4d?py_E_nb38s0A>Ag`o^#%a-B#yxyyJ1KR6Bd@<}EN> zVLyY$f9HU3O33+2$SDCLgvK$qP!=%0v|vWk#znS@uDrQ3dxNUmWurZg^I1I-%AVb6 z?R@UlgPe**?~xKBLyRh{N6jT|^x#-)7uoV@*GR5UX&hzJ*CqTw51356AmDy=9upb= zVal1D!X#S$c=Fi&O~jT&fBJgH(leF^4S{|nY9p7dwnBxu7HE=I;Vf7jf?`CMo4ZMS|D__lE01?vlY@xmfGc;Zbq_*GNinJ@7FdR7 z?s!&r_^as^oAhe0lapbTVR)kXShSrm3Vj3Z$`fQ~u&dpzM%&B7%kr5s7_8lN=D z6WZlxow;k=7)EJ!&QiUX-e2@d12ggEv@>^JakohdFw5M(f@9&%pP}|SIDh;7O(*n{^8W_Ta}b`D^?ko$6U$rT1Mco9mPBhXtAe+f^@%j7k))?r9Uo z8@Fvy*%mMziYI|Ot@EXmw>$Bwszl4Mm*jQMOorh2I)2WMH2%uzAddx!QBbrh_57E{ ze8yE&Rt#MWB=Pw>&W0vo&jZa~=F(Fg<-yxy@;tT!si|*D`H;pQ+m&wU{DSBhQ&ev2|)r8q*H#L<$&JFby%Z+eKV(?)Ik#nj3%kaV58C%4t+IxHV zyOT)EgH??~&5Nw;4P=lDidK-X?+Styta1Nwpb5#NNt8>CA|(mrxxnojBhg>!E!yj) z?`6L6K2W(#zLb@%V8bctGNHMG@%`9WRo0_c_IfwqRGmyw&g=l&pSb6Y8e3mzxVnE2KxJmba;DudY^0_nKqU!ywh<; zGv(d;n6eKC0X#j4Dw!G8tPNz(pS&q%BwU=IyiCGuJ$-um+OD3H?onNyz4O3RRt7l+?@x8(16u^Ej?xe(B8wVP zb}%kaORZI!n&2wSHs&kr6 zV5H6Yxg|6v|F=G$S|6VtCrRFWO8%13aPxw2%;4FpM~^MF)INUpR4pyv&_VK>CRaOe zo?wP3UqY8@@zX8>;l^DL_DAR&N+qQZ7K`s!N0;odlOqXYSa-w8=QbO(-*!-YM?D}v z^i+{)i^x*87(TP><1>>c9JfZF&%{_**j|oPRyrs1>PX711BdjwkZC(1Jwt<31eBo( zB5k)m4CefgU3kmyewy_N9DnSE@>E@93zd0EExpD+(hkaQjJxfa=I1B zeJ#1HlC7tP|Czi``N^aL$$XI2uSs>&t4kTHzn@VKQu*>Awcl8W^v02HLZhPJ3cnT( z-s_pMy=sVh*3LkV&Q5T4?;W>L46?t#5+vdE8{h8JB$Qu&r|U0_o9IP}NqwnNxpg3?2EF z@Twm<@@Y7}6uIb;j$K0efsGrkTL}LCS!IhdR-*{bn@nc`3W?19PDWbeCczv>N%=_(^?Z zE1DEY;Q1|-e{PLZH*PaF7v6js^CgfUotsl-4D$>YPgAPxRNFETs}zeUxl(=Lgv!Bn zzyFV=>|j5NN7V(=xS4O#lR`Du0EY$Jdf21&>YI->-mEZIqJeQtK&W8UB0{(DdI`F5 z#TS0%EKXn$P+% z51zhBw9Ya-HK^MJf==taehKV{>=LY}1RF>mkoOFlak68F!h4u82?LiXf(LTEa< zl)%&J9m(G(7NB*N6je)T^ZO#k7-(s&PWCIeQ8^!OT(BDFT4K9+_r$uWxGgWFZ7_xg zDWw{8YJ87GTz6K;#ll^!$21}3D_bmvj-_8FMpp3YIWHcH)i&2JTqtmvO)ACBioW<@0GAVxi17d7`W~ z6+$i2(!=F9%Jo&?!f@#{aQK7Jkj9FU#rP}d};qj^4 zp++k}T87!LS!OU-6Ffnq*mh)XQUsE4dNlhdxDhiiun%tJ_z7-=t6W`bDL|CA61O^1 z;jyxDPmNRa-2;j@85HVa0E7>fq2BB0MzJEC2!m&-R%UjSYqLCKWjhHPx+lxUn^PzI zr0QGhXNv)tw1$dXLNWv^&A}cg`$iZ&`SMCX+f!6(#y%_l4*o$}4f3g==l&c< zd*6QyBinx&#`dj0hfzIbspTcDbji*E9^lQceYG>X_v3b{`7R__^B`H^EtCrZ_?M8V zRwcl{M93CbJg5cy%W=TJ6pge@nOUyNF!2udZZZAV{rP5)tAb-=7@x)Oq04DLJg3MG z+&*vby?*n>DEn>>j^nu8FXzS5@}IuFXI@As&l%I$7N{-3^m*gjT!LJDbPU*RGDI#W zln_d~WeV?ow|KZ?=5_UKnui%E2K>kf!0q#v1UsR42RV8Q!ikbb2UYSi-ZAwnf^YW* zDaI$M8-2ILKbNW51jd!GzZZF~h=9uG2rusuquUjq&K=b>^Pk7Y2^}RX{-$Z{-hk34 zOFX|Ck$GD7S=YDhhpP{ELewnHC?RGBZ<j1U#@UMDb6&OIV8)!YXQ6Yr3F~RLM>h}z~+ z&*<}nxP!hfTkG;{TNN*Hh2DU^cU;$(jglD$xsT$d7ehk)K|~>wC{Od5PHG0m2MLp; z`DT5wSN3Q|E^#f`Gp5L3gXhCC(=LOWPl_W3wm~^(;IhP?CkTUiHcsnruEPj}B0Kj@ zyK5Cg<&>Yp;Ca#2a!;)oJ?-E=p|3t=uOFcr%7%Ja6w={ur)+oB#yqFN-O1gd^;q@z z>>!tsLRMNzBih<=&5!cPy?X0wht&U$!1M>H`=1C*zdUx3Iz%9Uk|&StlPB2#d6GFq zv168R*t@pH^$tK@j_e~ZoBl*zmi@njy!78kUbg-hAl{uYvs)qcGyCXIy4- zib$mnzaF27b@VsX*K%O>DpJ!IjK9utF-AirfeOi%(5qRBqFUu~ycwy*#sreogx`(T zmhD3#L+@RDeOfWL_JC#|tWQv8F;H^bn#4naQrY(|QiB=ngJHN+Ds0C(RFrO(z%E>y zV8~2-2)?UFWaC^_^siW*YdPjtUV+W(?w`qMA08I0R9v-FCuoIa?`i6QD9>xs#hP-5 zlSNLJrvSG~>;5ZWc}zTrwqSMwD|Z^8OiPz$ZQkH0ELW;)Z*ARk6{O>N^mE6Du~Jh= z7YZczFMOx$pZLyKG-EK6{yV;N{sH8l_)h0v<^O^2On(IMow8KsJw+P8ckVO0|HgMZ zX7T2asm7cO{^J1W+LGLb)J`GkQHM4Au|EzxW*M@bnY)^h-6S7bUU=mm6j7EC+{w=t z=@+8g=^#12jXDKK-l_}kx3Zh46}T#@J0dUI^W6WHhfTyd#WH~W**lBqwqO_k`W<%m z(J5BKEDvVzx3-ZVoxkoAFCUi2yK8Utt#O$4&HV z&sN-mqKL(L!tlMJ?cjIMT`S4A``Q>jNH^>h6D68nqMBL^lr(XrYj{6(dEY{+MjNiO zne|2GbR}5aR4Zd8_hKJT!_P>M*`AQ{>0dYd69|ydg7T}wX z9#ZqthW4R*g6=vPS!#ZGWY87W^_M#i4(?sM0ZdtWe01dLigF!2M}m9{O*<<+kDSk+ zgwdF0BqG5+tH9QVj6&iaxam1HP^x{NQuID?E2936dX{4Qy247JWH!s5=guDo_=3(9 zvzk3W#|cjn(>-y_=zoAB(<=f zM?LgZg1u%}k$9(xdNREA;ptTqN|>>QL3Fs)A`ZqU)HQ;OU2$7YSAW)G#nH>=ic z(k!zwQ>E}zmf#=1g;Pux!-3Z3r*^|vyrKJ2CO9*iX> zmNA4~wym#ebY)!QcQU))Y!4>&S0U%;ju$e#I9_4wvDMLNkM!&i#p9cjv@wfX$jcB> z{gG`!+1nqtL#aBJSpZV=o5hS5PO++ zFU^UwfVVIu{$AR>6iYp^l)wIje);Rw&-didfVYRlQa*vPa{4ztz%CDEje2gbhUaTF z8Tyu6?d4i$vYT#K9*afNhc{Ysq=<0)5xMnCT6RB(HuiAO!UOB|gvNSBB0MpSWHd zTC!@gF4cuvMrnsEfE9L*jv zo5ZARWHF6_WX}hJ=%m|qBVOX>JSNNYtBi9WKxL@KvxTY;=0QHZXDuGc+w+_H6)o^5 zw>GD{@5y`&akSKEQYP71@)xmjK$$IUiiFDb&AwzuWSLs+DJRJ-&?kXrQZ{1w@8Qu( zqUYgYz+$G@PC)9kSP;77&C0N=?RFls+lO7@=BCCOshK;K}wo_|r z$smH}x@!4|{Tw3!=j=^YP;Y08K~1)D(b0ZvR5J(ppVn@~gtjf+n~;ckG-cM`l*AJ% zM)J;;Eh!8vCJIX6Ra2Jlkj2w(f`dTP+-jV(0b=AV@0H#fAtaPFHz7HvLL6FcSN?hQDP_&aR10wt{1ETY91A!w3Uh) zqi;mfEC{saNy3&SJvu49pfC0n`nOVb=e?XjIVb%MH>dO0OVR7-COVrek=7*8XUxTD ziwUqSRd}GXNdKUn5;;4B<<-g?`W9M63!p!5J<1rK1)PKk*9EJNBsS{!uoReAquEcDgS+^B@i4q>=9CyH<~TiNpLTcS*M?|6L)sc+pI1H@6Uq*V<yhU}$r>59g;Fx<+j)I$T%N-M^u-U7CNDkRyA`G6P26ppH zi)L^r!aX(L^q23d|nAOLA-_@*sS2}XSb2<6M5wCaWJST>i zX@Y+tSBuCTVSd$`ocX%EFNrx~l`6mp$GGzF5=EaDEqLj5%PWul&%{-0w24KWWlf43 z*w~SLaLI1SDVp{x>dl^3ZZcE2rdgrE=haXlvQ~1)OBnY>-}-g_(0%5rSgd-7bkh60 zi&gC#0gK@)}Wx1NO~yXz{onCsgb-9 zhatP(Iz6XKToisi*_1N7BsiqLh5ZS@XAV72y$KNb$f}-LB*FO$`))npjcYpjV%%o6 zsv?|e2?Cu04>XmCxv_i^fxQIV`6uV<k{#@h`AzAQ8Uu_r`vJs9Cs^IOX3nBCSkKnD#@Yn`%1gM zI+l0s7o43wSSVWy`4ZqbJMjRN^ixGrNb!fhJp9q3f&1ivCw_Z_>*~eXJ9TTsM zMi=8eOj1BTAOKtp0c*8zWN1H_bSo@&TQ~}NQcE1+LN-K&wQ|9QJ6pBLhTm9hAW?oz zx%xyYgEH^n5HTswntruo{^~Y)Xw@Q=Tl9y<#;6N-Lm3PJJHByMXJb#j3ssAaM^?>i zS?oJh(SaYQJy^d3n7#~oB2zV?g3m^vAJQK1<4K0(8Ebge_@8*y<^L70>M&b9HCgoE z@v414@v3WvQuhDAt1=T%?Z}^uSl53rV$B|32aMS9eMT&&_&y`{7GT7>WHVpPE;lyK z8!@iAxnwup#VZFv?r)yw1?dwM?>Gp|n-?Uy+YzN$s`=b0Y6 zU5gCPxN~4fgFY8UJKwvx;retC?7t6)3+^G-(nEdHde)O8O9=>Pl+6}e-;#0IsOO6{ z^w_Vjr)zyr&>vS-Q}pzCZ(aSm;BVT3vPp>$rtQIQ_Gz)x*a1OIp#39U5d@)uTALLC zA$@kRHE?}#SB!^0o_sz*(Z9viOsyQdYI{O=bfC!NFj;mwSZ=&#g&dxWf z>Oa?%KaGokTUR_8`rZL(%pcvpjuho?T$!eSCQo#-9j09%jpr{Y z#9Gv_VH{qLO4~DzZkBBA=?p#h_DX)kggB|IS-HCm z@3sFt%fSoCbw0orN+c`8u?xnXPGSXx%GOUgt=39#Vf*J*tGI| zh}Ih^=MFFt@5xqj7wD2D&5Du3ReFMNtFwJ%^tLzktfhzKK6qc~ZxvQU`gEn-O3a6= z07>lDUz=ApQt2XIE_NPeVDx5!gEmLI^gQ8TR_-)1EG%KWBUiEDPIy3CIFT$1um0;! z%>TZVoB#bzn4TX?#@NVx(Cnp68r+(d*5=w}MQ9@|Jf6i{JpPoU4KlS@hjRU~61@%S z(bCHU#zj?CmU=qU+6ZU;bXg+{nbBOER0N34J<9n!XRYsL>OJKgPWJ~9{(mAeE zOE!@xUEu7TqIhzp-sEy(DAF7Dqq;pOVNp}jn8)Vqv$9nzCE{DT6u~?s@zALim0aG@ zPFruvvnKm#dT_)AHm0=hnuR_qVMy8g)qWF$R5qURfvj{}CMPUfv*Yg()O?fpF)QN%7&GKXpV+%XoCHqh6QME-Z$N2RCyeYxvhlS*$>@Kk* z_a(P9aD{VJ1><(hG0meSk^>2kzbLPb`7zk9`Rg(=cPJ%ZoVx{s z;_DoXriO*XfmI=(cqEVQ;#*>=Z?K$}M6OLv@=~T)(1=gMgtA>Pex>OO3`FK%^dq|V zj2JzC95@7l;aEPweHU~i#l~DeW}0Yml8us)S_#C#%85r<({V5E8RfSnq|`i zpb8KSQv2Oq2zKoEDQe^3&H8XeK;4hJQpms@cD&xQ9*CFftS&fM&$My%m(P?9P21W{ z8O6z|b8mGHa(*-vkV`fI@I6u40?7~5Zlf3boqcWQqcd2`? z)6HRbvQms>%4HtK6VdvmY338_Dn6IJe4|dL+eTEsxzp zpOo#chZMm9NI$#!!bUq}U6B*P1WJ%2cjnzRr%+#Q4cuz5u{MS!i?jyKD@(P}ahhq; zX9fvz1*LQS4MY;U%qgjhZlw?KVfx=e!g7i(Y&D|bTs2x#ZV7rfjn?eFJ6lM}tW)>t z@OSrR4ohj%H0cuvtN1NUmM#YSyn#2Ph=Q)V9(1)^p$fFCuN%qyQz6-g)JVdHA~=*z zt3;Yl9;hRW7s@N-dwQHu`(Yg8xl_(67@vTyCPXhz>&-7QbF3?Asy_V@=^BJ|brRQj zBi#a(XEDUYw9l;Yj^8bj)$Zpl*D_X_&*BOyS@aLZUWJa8HW)?ZQ7~4sr3O`I7Qf=2 z%j2G$l%+ILfLJk15)n$(rlW~TPk3;o)@Ej=Y+rhUD~vmnY@kS z9^5uM379z#d->P%j5c=u$mvQalSgv)#p}ym~?E^h=8Vdfhfirw)lEIE<*Y7~76Ms7Vko zY8~70)L)Xldc|NwUO{n3V6S&t_h@-~df}t#8N2@TCpb@Qi&b4d8S~*9b`rPW)TdzY z8sb+*KUufO07t!(cjV2c7qZHq`R)!RR-?Am6R9A~vRjFVTMb+zH8Z3e<1Ali-cJHp zu0*!&$UPMXm@L)aU-L2AJnhEO;}_s*U>ccFqlpm3PT|w4&VDB#D5C5ui|r}c3(jeG zEy21WKRv-;P?KS|E9r_+G)|8^%X$V-;Q<3tBpU24AS5^0 z3ZnR+9_A#++j=33L5eoL>@lWG&}OU-m&q2@JX%e{=42CsXeNO|<&FxIVx-#7x=cT; z=+BT&8&8C*groe~P9b_cUnx2N|Zm1<)j&9da1 zEJ~$%a#a@#-O9eTT^Id6aCY8Hh~UrvMozJ=M~Br|x%h z#bXN^BT1@%9QdX0B1^rrzMpjP?Hh)g_5m1M3-?D?q)g(h3{B%hrizX9zh~hR|2RNZ z@TTSUW9Z39AbePv>)P2n|I+|;#<}30fXoUX)mo9J2+pg3Sx;Ol;i`@-G&;)=|IL`1 zMcwLct{c-Vl08>XO2}*B+!L#57~L*r_%o~l8crDRO@yp_l0jiSaijCgwt#2AvO(p? z2P%UsE5q)MYDq6v9s!QjN=EXuJrp_}BZg~CG3eK4P$)qXo?9`dy!U7uU7@n?DjTl6 zdwuB#e7enr_qMi01f3xiabb{sUDS%}*q30-Rc)Pg=?V8@-}l_ryA>DuH-AtSztXfs zRLQa&I)!7xv!)n+hmq$-HPGti=9D`TC0B)&6Uq=9Am^|(x%)R^;~*szJ3`WnuepgE(Ar~|7;J}GK|qtYP{yl4*jCjdJ61D?lduEI1o!O!?G zZ&$f^Rx-s=QV6iDdid;BT}l@|ldDaQ9o*Vmj$c`AkRK9$^N_(czlk`?U9NuJ>Q%Yx zx{~}vN~pUzh6lM=e+``QYiz&nZzR$cPen8ziS(Y0?G^LN9~x@2)U`ZnZLP;rc>4Oe zFjkG&1AX=!+B#N-q6U_xeAW--xzf`IqLlscdO_}ERCsRke~hRV@$LcdfZP>L4X&Qt7|mwe@Wy) zhT4x)9g$C!>4&VkA@v(=OVpt~1==q|W#yq`M8y*}m`-Enm-!hkV+c_}fQ+cE(P!@S zFM)g62kO=&9GCZfb@O{=RU(Ucy3K> z=lbf0TMi*^7RXQY^xPhGbUI3JhQjK?oEwLB1Qksa3MK_tyTpb-lP^X;gk**KZH@<0 z4a&tHD^g8n)lu*3_gpH2DEpnE(0z{Tcq;aNlrdXSnUHIAms*B~f11lBo=%O39$%#N z=pCjX%y;LkJpuw66SIS0uiU?nlkKgccc--jU4vj6C(bq0Ha__rMx1qjShJTxQ?Ae}xA%UDFSU{I(zfyha`9$b% zS@kpp$cdZ#$Wmp$x<=#9T(!wZ47-4){2_$x=kCIq#@mf9rGc_?Y7TtK4UmzYgq;kG zE9})ueMVyxD#V*>EPW@T(<&e^qxwY(bGGd(p<4>_O9>gbik{A1W)BzTIyY8w03gie zVZV$c)Jx{RIEW0ZUS+Z!{w6eHHdI^6T&`#_QbD|w0_x3LW0{)_VtNk}-b7vIfn1FJ zfc<8+u<;cIQgxZb3DI4s11nkGXs(9(5lwpxmI6uev)GMyG9=5#_8=+nLhnoNf$JeJ z`=wX|i>43O;SS*3y{V!}-NMljypTARxdh007f5MZo;@^CD+5>|LT|(~Q+~0>y-|>- zEAKXJ%b>8Y$OCZGyIlX|roW6G0o-)gKe_3G``q-FpWJj|>%X|^3SxDwBO5Qnz6}#E z>QKGTCu$FVcv&rVV81TsA3sgPhY*_Ni7qzwN%&2|TtxHr1!E2mCOXePCq1xaPQ@|( zK0v14{mfl=$J?^8wbAXty6A^`<*t2BIu1~Mk5>{|tpFz#bZq|PKrD_RP^D$jLz9IZ zcCdlMhLh46{X|8cuZ=_7gU@dVs)Y(h+Xl_2UV#1Ze@}ZM9MgK38nl3o6%wr?MRx#M zet37Q#3pu5#jTLtlu1A8Y%I*XO4H;<0d&X2OgS|;~(GJ;O zO_E9<7uoZ`~!}jg9kW%N7?cPtc1dLB2#6VR5 zjlJL?4?a^5JjT<+QaKsZD=mRGjj#k)hZYNQ?QfOHV82(0+B6+5rjn0L=?F3Ec~bVg zaWqFe>Vzf}@ZOHNz160q56eS{jwO93(-PP0#w+p`tS7J*de?)?ptCbF!t&1SktVCP zKsgWSOeC$ySMY-FP>~@`X+nz(hZeem8fRWLw4Kcxeehc?E65<;4OC-4{ElB&CWh~m zG|hpI#?4pHv1y*C=MzwqO&uswRV|e^g#^NNE+N}eX=U}O zvJ;!%`_m08iNH@4E#f!8II#`85)aDo*IF2@C0rk{-#|Ff@ z@~!^NrBvB{!v|+d@(0{ENSx&9G<&pyGEV7)d zNCQz~@1JcevbwK$zFa{zibyNSmt|1a*=>HTuG+nuJ%3FoiR?}6No>6Yz`w#>icd8f zVR_1Ab4scQKHidB<33APK(1@SN?jdA!?UFv-BO1_yHnJ-SCfMhSgZ7W<-RMbYzB4x zv%2q4Np;mrX_tFk7S~-|oPH}grYH9MfdeTr1v}sNE0H`f<$7WR|Ns3 zQK~>7LMS3lx`31f=`8^Xfs}JM`kd#S^S<}qaqqa_?gvK(I9Sp%ZL9{XuL zEFi*0y{4?ZChpD60+AF8*ee%xM&Lht4gc&rgmwkf`7{YnNStftW$?(6>COQ?8F;8Z zxw^z4+`ha>6hfE;tR)YW=M4p1D|J+~DH?hE;Bu-3(oB8V5STh)RJ|#6D#u#{WY7n( z1|@)^lf8Gj4w(Sk?on|$gNDQJctesOWjaLRHQg^JPxY%G|9Ungkp-Ml|M&TCl<@-C z9{z&`sP!IcV`k5Mr~+|Q*`0=SM|6#5U|hDc6VT~6?@%FiF-^w`o9b+kg$DmSd&Bb? zJ0^^w2ab!Q7~#<$el#^8c``-b?HiY-fv?q#f(aIg>kXT4fZC5z$0*QCJ-Soj1C_w* z$#?6B*UcMuaiH@y^1MfrP;ytW9`=OH;gd#f3)c_;NVxbF_+`U9(^C?-LC|ZeM)upD|dOJs^@fY^;(J z!|eM~4m^C8ATC9EA(FsO-kvN=t!AudT7M$-#i^c*Di2A~!Ml6jAJ@adca=TP7%a1_ z@4J|NJw$;q3b=R7$?oCiEmOL6h8|1_s+dm|n5Xmpl`+MdIGAE8G5i~ss}2(t`Y>(T z`91EP!o1SfEDZ?$-yQu|_Z|K9emVME?Hg_#x5~Wx8m8(*(tI6UZ1|opFJl3}MU8Da z##OH5d(UFmoAIFkGH9V?k$kb^tl9&E?qq}I+x=fs0|NggWNX9c_Aj>QS6E_wke;9_ z6dfqb{&k?~`v+x?y`lKQi5>io{zv&yDIFW}bcb^w>C&vfK$t`yKSE z$~;?K8vflN@y1y4jY(r29q#hP(nE4`2TMy2m>oOKW%~QUKU+C|eo~a40Z*DT^NaWy zabfDU8L`mz;6<{+_Haaf^IMNj<%`k)#RWkbmx?*W(ylp#S&N^$8MLB?c7aVL?ejV6 zW~PB`+nt(8c})h>rG){cEQnN&6$yNVrW%a3i>&TV#{`YRpE1f`J-~e zwj9kx+gz-oN7-g#r{Jd>xguN@j~io3G4c_BB<6T;dCvZ zhrNQCJ#BO}6%@Ian<}hPKdfM{K(n8jJ`BG|Scodsm7W2!FY0lUdS7MAt0{3T1wGVz z?UMxysCpkM7{A5UL?jFse0W(^*?F$C_hBr{99?7v#Y)#DF`~lh#|e*Eo0-CcJYDa; zV71X>i+gVGPXGC*r^NsI(|F)dw;-`dL8btLn=~|~NG+R1al%EeBz1E+dIxuMw7*d^ znpe+B%D*l(tlo3Yy|+Fn$?XwhCCwy=55cILJ`)HY~P_LPSSV= zdUdvbWFuK5;i^YUxA!H`&1lnN?~KU4?0_}#&wIP0@@cCFBuD@{7Dxq$rYC_}$A#iZ zLQ(EX{{*_BW+%?O<6u~n7iskAPLI2HB)d9#CuRYs(mH>!kA1>e1$?sUEaDb5g6!Q| z>vVydKC1+xj2 zuufB1q4#)AQMuQSQfTptPQrRw(bSFixs%Jn3Ej2nwTjR4{3QDP)ha65gbhl+pOt-_ ztMgY*b?8eI5Bw;w!bP=iu+X&zufN@BpHldO)sl?3)`)H@Ds1)%Exd6034gZhj=)ys z!6FW9BHk;5`Bkk)qsw40fFW_SHgV8&pwvfgQg7f)blJU9pV{iF+W4SE!Lx~KVyTxg z3jkP(hZI7$CpWYr`M23k_cU8DoJQVg$XP_fET>?bKYIMt>!Cc{9nv?av)-xK=Iu>G z^NrgMzu#cK_*?S#*FocV!#Q`c&BBJH&K?$SSA3MVsL#MQ{b`(;EMIOgM&)F|Q% z(NPhi2^mFb7dv_Ep-Z?mORdvXuV|*87m?N;yOr2)iTaA0~A_FC=JEzb(L?~;V|3*xY%JqOhhm~VoS zN5LN8XV5B8R7Z^7DL`_4m7Mz0uXTrF70ls-@xYwlJu`~Eh)5fsN|4jAQZD>E=)s!` zl=BmGp(I)>zqlMpDW-b*7(Cr1rF(FD`lMHShF+0ZYr=}yT>O`wIb#;18FxVXqreMb zT2w&eeZS}!P!6O!)rInEAC8fs^KUo?$j1c@|2(1`zO{`xxn4oqiS}y_sT$MO3=}oq z)YU2La()cXg`T4Ni{`h?O?}B1GJ)O$AJdt)mgr3&!2+lpf5|{j(iDF29dm*Hl{8 zY(|Z9&P=ZzA&`lXa6RxBtecyt-z7$ND&8JYI(*iv!N*o2f>p9Xts_StNiADP zASi=VL@}!oDQN8yC7DN%1k6&G0RxWz{b`fz*e7+EB5@{#F)XjdY0)7#b{80s)t{h@8d3?jFD|Y5 zohQJVNcGddm*=lcayv#6nLP4;n=mGU@z`_?7OPoa>pgMGTa60w5L00+ZupM#-h z6&%D?Z1V(K45~DwbK6rQsDlg?5fsCPY)K@Eb)*7y(#+$Ey1_-`H6l#Ou;W`kid7rR zS0GjJ{FQ6)XB~k)&H$F;0_$8vBX-9h@9lkfRMT3e0|t~8MS3o^ZfPZ+caBu|luWY~ zGSiy<^V@*B`me7G|L2s$0lSSH(avsO15pW42TIbeDDT=HcW?ptzO7b$7L>{7_=1sy$FN#(gf+FC;7!(?(& zSf47bP2lZ(h^`@Fr^$Wk!0@Yo4qr4548O8JJQIQQgiz0Gu1U~L)hVe&7{6vX;y^%e z3~AwGS>RiEkoTP%Hq|Rn{1h?7NH?yk{*~Yz9gh!?Dx0N;VH*lzr+??HMedKFv_C>M zFai=70ek4z2tEF9;SYX}u+-LCkBhZ^ZZK$A4xRLTOVI0g$@ipTtEsX7oE;9{a84uI zl&ukyLl$0~i4?qzPV;p8*NZk@525eLhHlq^IJe3^y}<`O(OtM>xl{oXCm|iL%Imjm z#~G!tu4~ZwRFZ5}eXf2w2G!jqj6O4RYc21TJJ2iYm46v6k9LGp53B z50&-5Lg}66{p+a(ggO+b?4InJ0vQ8>p(Q zn)UEOwK>UZ=KCvUFT||rmNh|Bq=J+Bb^e!A?O*kme+K#g{`Ykd0G{x1>O|-bEYN;& zoN8wBBg5nv-GrzBx*9rEt6YX3mnsVJ8kIR@%H91Xic84lq(%K4LVXr8jTJ}2>8m5)3p=nM^8D5+*N9#Qpw6up7I3 z>>n%|fWxq%6Nxom*LnuRJEoUOgdL%#IFNwi#I9;nhXZN7ATZCXCZWzUrnadv=d5wj zMb#%+)_Z}YsM14q$sRNORkgjh9@R z3^3k?jr=JS;9Ex?0H&HGa3yQpEV<(&G*(ZR>OxIT{)cau9HcZkqS~Fkn+GwGZMV_U_>lqy zf>px9Ku?RfweuI%GW?R`bF=L%N(Qq5U)B+{nWDOkWw@+)mJ>NkTBzNmvu)*WhNn6s zgxNk#@(aDFvoLP_t)d*FsVVNfHeM+9>4)0<*l_ms%*cT<(|pL#R=+p zgI{};zHYOdt%$8>!fW;-;wOH`);taL=-7ph*3l0$^7V9?-Qr3~9iRhY=cy%x8eBc7 zR*a3RkyPI7+f5pSXX1nVC#k`$dk-&GqNAeK8Vv@tIkQD&R7&IMTkR-ACr}TgMl<|9 zczIpVVQ??P(wZmPDzjlOJft9@DsSfRcg{U2S$q8Ly`b;8qS#&3=6`S3L}7Ha=7ca1U;Q( z2HrGj2&fp`(TR*HJRn{~U^r<37>;bVom;~`Po$ z3=aYxkP}Qb__bSr7c5j9ZcS8r7HHX%6iq)<1{epsCKuVH4%K&r=1(a! zy>Zc4R8sgo+fJGOzSTjbUH4ETT6f|=;^$?v(j0cpX3G+JG2?eWE&1#k&Bmu9>=iu* zQyrvaWtT04&2e+ui6&Vj1{~`o-o*b~Mu755NlgPYyLJoZ0MR=I=pl#2VdI_rZE*VZ zgani06JV|L6OfV_wNVb7qcOsK=rN3#vg&k#nlyI=jE6a+sZ;&;52W8FcZtjGzM^)L zO=F8v106nQP7jP&rRkCYht!C|M> z35;;9aj@F{-u(V`2`gwu-3U9^`6!V+_WU0#rDFjh&f861@Ozu#e5uU$ouZ1)pR4EE z&2pWBYDd1IRQIsytqy%hIt|sMC^k;X*}=^W~d{OL%gIG6d@a>zhZ^RpwEA>1pS1?6qME{B|?muZcG)R%eakp z3EsZ(5hM~OLaihe#QA8}QXsKaMXP#~zR7~PDm8DqQNH)y%|y0|6=BKsH|TG(8av5} z-g^z<^veW2^|!^Y+JK`$>dA*=ch7#kIeH@5VQTb{omVO0=qf}zqKYG1(gx6{(f-XlyimdEG zBXorbJ;7~F=SLNjJM>A@kpY>EV5i{?*TWs2`JTd#jl+!Xu82GD020a>wi^xyum7Ed zl5J#gD*S8~TD$i__?csE+Q$A_5`qPQ=dWqr_qSPjLoNUu#i$T)`>mOi(Q23Zv!C1h zXf0Nm0ONsAKnLhDKzV1SNr7xo7m%g{2sl*prdR4Im{6&kK@ab~Ku=713G68H#Ws7x zR8xMBz35MN++*s=779i+>B!73Fx*rCg-XT87n){)s;i#2pn z6HThadi`Y(ANgfpYlEsBz**YAAzSmt`}pV%0@ibO;TUPUrulmx!?Wj2&&it{mJpdY zw;hpH^VrG=Ut6VzY4#94X?IX*^Kui94*Ageu8@CYP^{jli%M$CVW#es4z2Da3adLM zgj&|o%fo(BP&7M|VgcroGNVKnD1)-Ge%#uppgaZK{Ko!$cA(CB$I&o;5@`HPAbft< zjVxa4uF~mUM7`R3yAD~bG!{$|-&ZPRvv^D&2;*CH5*YGT;2yOjH*Sgr69r-{_(H(7 z2>0TUy>3cHZ~k0>xArO)?0&IsFd**yr}#&1w)O3me=<-k2Lmqg{K-IxTX9tVZwwUS z|H43NWB!|g(x+TxsPv10QWDWsolLo3boJ#N^g>bhOs=kvg9ZAcmNP+`7bn@Pm8;X| zN{DU!EEr;R{$KZtE#8ge0*z1k=AX5$xP>jQm3uH4SD{v-X)_X##Oe7kvJSIc?;G{j zQzK=1xxW4VBkz3Ahi(ZKLcXv-j;jvM3xWj-n7X={3D4x_a zj1mIp*k?Rb7|5S$v%MLO1yd%ubg_PzKtR~NDY;GPZ{&jKbJ8YA)-j_u%lBciN%C(VjEE?ink_oZeRIl(P`nWJdL1rqKx0TpQ{A+ej*KH8FIUS)@#d@ZjK zh~ssHKLgCv)eLPsNY9q3N*}{65Roo%Ju-kTv(WWj_q8oq)sWPOzP;3&`9D@VGL*iR zyfQgrVyWb!p1WP)bgdf=tag-Ph`z0071ezV-_M(;|MJ z{u2OW0rmz_&x6+-X&%eTJ>&*r5IUG(*+6qjCE;6$kP~#3ej!kIjm8vTMfTfa-_@`0 zsz%eoZp^dZ40p8MjfSEHe-2&11nbRwZ07;_jk8_TM*Z+z2<4c(F0i? zLpaqW9*vO6+jWwCSQl28Ov*8NQP{^3X-U3qH|uAt{$8M_Jau-Jw6x-OHOn=nvUs}= z5Nj+h4E)Cd?P0;k>2TmFSR=;~P|bbpx!HgbO@c0%AYwEkq2fti-V4{*8EMJei?;#I{rcD(U7~RD|xc?#rq3dAn6VV6O(W_M7M9@eDMc)z8f>na$z*p zHtC42!a`hJrhr|xk)izn-pc2}mil-1v8)G(T(MV1XdSh4h0+wVCCr3_J+RTU-4rP) zGi`zz-gt_YctZ!1VBvIDLfmZ^0`4%?{VFLvYBh2|K@D=!GpJrK)hE@${JYIqGruLT zSREVdq5QW%!k}Dik!_bMJDgQ)Sz;FGWs&(H+c?!-CskVelAHDrpxR9tG0VyvuG|eX zdpRf53AnAlL`$vD$pD|34*_kEna}bBtPsGc9Q?C+>CaE_bKoKIpUI@U0IEYsV*R5x zNjIrQGjf+79X74ls?;TPpxk;*h5(wskmX$h3^ycO- z)m`m3=%k++-8(R&bgDy_v~wUl`_?_^$x%!)@$BS$;Z?J?xk|5{xg2)hCH+RF2tUYV z1@qaAXq(H2U`_+G#(VYXn|%6@9%b2=MW(E{UoDA6{#Yu{021}EFOPt;1xPy6)1+G) z6Fcot5(F8yH`Kt1?};nE^mcxKDqzJdCD}aAbDZ?jHRGkrx!H3= zx%@e4$i-Y5P;zRv1-nd7CuMzfFo+ji0h9W{$5#=VNa}SxDX;WoD(1%EY|E}VH#K!`8vg9oChg|rG}8LcJIV6x#*DOE_{wmebc}A%II=ozG%`; zLYfi3Rn0SeJ-WA!a)UWs(RlIR%TnXx0l46<#IRS!v`fZS}t-qHLPHv|<&?iyMUkJlB{AaE&3I zs}|t#yZ{3@o+dtEp)f{D#_t2tBGO3}pJ|pps<-0&83pZO>|;tXSefr1n*tf6XEvnj z=rf$LQUHx72sd&NcYdGKClR$8Oat_FUer`9Fq5#^6DR**$p$tW*;NT{*@?;HIk}1p zG)O#MY_5ZV;tv@_X)t%oeqeZ~SR};H*BUcpXK;Dxr2D%5>C=QL$~wfbKlEmhdEZvH zLrv|L$uiWH0g@yu&AiDW&H-q#!|1-SGfUh(!I5zklj_}>c}kgxZ(h266L zv2KF;jx~H5>GI+(Tz-)CqLR-u3|mvLsZ6NO4~#I?s}uY%Q7VG1xNkDqp>O*Hzw>|K zLi!Wax$25m!@FMBj9=!bkxFi5rQfXvUSo~^@BY%)mfG1lLMQEQzD_teO-+5f=IQS4 zc_LlYI@p?9UV}0+LMj1DqrYH6o&Se0A)mz;PX8R%;hOi)VFms+Y}bDo7W7RC$XkzT z(rm)|p<_-8)D8i>`>hip44=2{22B+Cb`BEP7oXc@Kjho=sg++i%=uAJh1 z)MzTa<23zQbKmFkuqdMx?19^N0lO2$6haXm?Yn?cM@=#|e!74`ndhcY>e56SK|R0q zi(o{i;l81M=d5co3@Tx?S|;GA;0mHjS+B;?`0d7~=yKFRSQ-6VN{{M5b#M+ZGs@y&1fxt^|dH;W1PALLIxZyPqZ>24eU47JCs zx>B0+2B69A4$y3O#E+FbdS&6M1I^B&OSk<(We3eDU(>yz<9#n03n#7sAm$ixBQcjm zb@yb$e?><>u5740Rb2dgrRpi(gGMaYvzlvw9`8sC<2ll8dJW1B7qJ3RQwdaz+k!o^ zMUFITQ3Yf5*b5I$?<7N8`(*!Mxl*+`XLP#0g49+US6w1km{5a8FU?_xnZM!gL8-DE zYtLxzdgwRQ!497prHJ&hbAABv$91Pkgp|;h!p+ag>!>g^{s&9K>;5~T(O8pWr^S_E zq545JN4emaO$A4&lI;llRXy)MS`8P!w2Z4SJ0esv-WVQRNfS?{y>M zVheFAKG1%&#K6433e6_yr6_n)N<7fhJhR|dwpYddsH)bk)B@VcD=n{~oH7!sTUvj`qyxzDo5isob5-K|TM z(Ckr_pWxky=_XUVTN+HOif5J8->b&kkEV%_s1Y88$XqMyo4e;Em9NSd(>5Gj65DFk zYO!3mVwr7_x?L4AWWD2j3Xm^9{!iole{#=gC8{E_S(9o@d*Iy!?7M3)LDU5TAhf?$ znS7oyR*rK4TKA3x$F6a`({$=Y5+;ybUTh}MnUb-N&3A1E$rZRt6jcecN}1*XyMZ|o zo&)mw9nnbl4FUZ}gSM3Qd-A(~& zJLU(Z+4pP`7d+%eZ=g0gJVz;a+Qe|2hlcremG|Qgam{lF*{=@z7yqq%O z8~cO#vS)E0tw+{O*gXbd7+hrPap}=iiZif$SuPm)xqJ!BLN=@7X3$}Bzy%4QPINqs zh{Bg~5}{ARfoa4ANmb%pbD?Pi>s~ly7FfHJ27ugVO*a!-L7lM3 z7$gS8-N`g(oNKsfr{8r(~QFXY;Bh_)IeCsoTA#ErppE9gjh4s3yd*y z7-Y8gc(tUduv>RN?cQ~cY_s)bgD=DF`t-M7cTO@*fyC4fbqSHgwMHmy%8h&JY^wlO z5H-y;#(1=2Jxv!Ib06Z?3H_3WiPvoSRyAQ`}t$!;it#c0eX@v zvYBXHfdS-0sO9{>}w_2i~QM!}?1y86KCV2g0m8>#s%x;1IA`~4RfV$2EfLqw?i z5fr>A%h&u1muqQ={5>e;3UHfbGC!eevddDFTBf7lc_6u@9~%XeqKGWjq}o=K5Pq;q zz+k{w`MTOPf3xr7PW6pvfsSEQ<7XoorDzv6=Ht;B_&pfl`JC1BTS?aacE2laR&TUM zT0WObNX?2G2v@m>cMx2M>KvA4FASR2Tc-G$%*a>+X{?BnyS%S;e1V&m(XEs$^L`7o z+Tv*5c+i6cuLsumGaCE0iW%>bGcQ3k0;{fjX#nQ%U~MaBM3AX`4A4m!>qJdy2^ujr zvQOe2D=XDIO)@#>!|l*RG*#@=*L)!2sA@kPv|F}Y1YM>tCQEdjm4ET6G%@kbi~cA7 zY+VRb->siF@;8TSO9=PSKGR$CbFSo zog7*+&EWtyv2Ut>{%zT=nmH|l%hOU?k}xQE|B>7a-43C>V@`es`eQ`)Q(ntH*{X)# za!0Ew{))Y~PD^`MCPWL#&TE(OG;L21W@cuNwPGF<-jH?ivyEr(Mckbl@Dne&AC;6g z;POD2U!m_)mLG1!>#|Ls(&HObt0-ujj+6-{LfGuaWaMkbWh(4#5Laf>Zj1wP%+?IY z{Al0r8ufSUir2R6w{GF`E8UH-oVd5%dgq3#)>!fN1_c=J`o?b>!nfkyegzDuYYHCSCteIyxOnS*Y-ra+-S;zR zYHA{F(GU2zUOfT$Y%Vg!xA)1`GDZf<@#Zgq&vxaXKN~B@ntnF=JGu>ML(AK5Lo)(k zZc-y|o{Qs(?}?YJAzu)e@|GX2*Og4-ozWiS>JcMF#mm8?iW0RIgFjXT3$Tq1Iaj$w zygl49tk2vQisqvcelj_6;3`!6^eRR$Y(O}ju8PEWp@8}>*Ghv;AST{!IMXNPa}r+M zYbl3~c0CmEV&k6@^S_xT2bpR3kOUqE+RcDzm(F+zyhu2t}};!1Cdo?-z~|f%Jn57{$$s!gz?6?7A5gv;wsXMeD;zhJ?sWH)2#3O{#

    {*_@1*dJU0xxKvl)nYil`~?tqt;X3z*f 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 <%)G#DR~8 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 qIPvntb9AxwTR|b#$k$e19Sx|!o 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⁢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

    |B0m2~K`h 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�bGoNz60AZeQ*1^_HAcxfzRGg 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

    ciBLw!XE@{^h6)Wqb%=t73@#h)(QV0LY>Q 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

    vJm)?8G*_>pK>5KNSx77yJ{QUJ7>&!2 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%0AreS|)inbb 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¨IE?eIk(W(heQy4=>^3z*Q99IXx2reGaz5&M zMaXDC@-Eji{=9mtsk#X_<{ft7Bf;V|Kb$>bBS}S&V;jBW&^9WdTztC0@`FdXg=qc= zej62Crxs^XE!ISkq+4O_{Bdc8OYy`erx%CQcL2sc)iY?2yZsxvUmo=(f=wntX7bp@+8b1w57oK zoTZrE_wJeXN~VVCyzEu}v`rcho+-fj5)lAASc=2fbOAGT;r^7+^%}xAAzoewA z0LO1sxXU=$1(gq!-r~M>>ATrGisp5qzIEwjyjAQn9Dg=m#YdGV`&3&NTdw%|a?q5> zF|W5>s@_{dO4^D+p6*V5@O6**(fX`OOVji*mn-KkxHd#?i{7QfEK%=m%6Tba!f3%H zVM@1WJYnMaFI+ayBW?zK00T?5P9jh`#AHXjbC zVKX%OG$-rMrf2*~gP*Ff42tdumCt@Ol*7xqU6z%dll?9n;S>LCECMwi{xy1F;OW{D zC&@Tnc|a{%qBL(nEi!{>nf66&N2hmMzs^+j5({t3NXQMx*QtC~U2zI!?;rH^^fdGk z8ybj%ZOv_i2dqGwP1~}Pl9IB}t3M7ue`9f(;XrortAX6Asix;lO_^|TB-z!I7CqNz z#b^RvI9+E^jZrH_1+K+|RP?Fnc zkIF#vKYaJ9t~a)*IY&2OcfBuY&;Ac@I4S#bBt#Rd!ZE&dbZPqP#M0veZ!U+9=T&(B zj^=1xN4zL;8a-um*?>#oi?G8PE}@zJViI5Oy6zjIQ3N5bXhFk{dSacA(F`wIng`6E z9XLDuLjtViTgRv&hrP}2j@bIZJ*l^TmJ61hEvPszlW=$XYK|9+@Y8u6d z9-lJLH>=c6&9=X?8>K zEJbDcE|ravMJ#KOdyurNN=oM{$LXsob+`bV{gk{ltbwPZ2M0Cs{HKgU<3`+?bof3X zyLI?=fi0;Q2)aqpj`YY>XaXXf6P1g+Qs!f8Q8~SvuTdNP!%oJgbVh?U8w?^?mC%1nL6esdEdWRK7T&Y_4aUQ z+Sj(pF4v*wT^SR;w6?wG3*&^F52{eq%5{E5GXgF*)}tZMXov5tIyAkovj@q6X0Uur zr(6%Od!S0farG0esDUrQGAdJhc5j>E04+EyJu55SvSe3Il$2?*k$t9CzV0QR@2@8f z67tq^i`O!a*KqMjlXf+(+VQq}|M*p&10D>#mG z%~HaeMAu3$NEoN%>~x=>m}@fFN5D&88)_{I_(9KoG_>#ftN6wt7#21f=vE9^1F`iC zj*nP9(dP&I&-EI8t}4kKEJ?Xiyicjd>S@o-M?!~e`MF|i;Cp=qX(#olH0EK%4vgSQ z)BGfpuo^+04t2%2$iBdsj=5gVSA|v$C06nNrRe*I?-?F_oE5#|;bvyjgBL4Wjy{=0 zTL-s^D-3w?*bvh1uIHz!-!b?B$48P_Fxri3$YrrmtQ4u8*PeiSw6HEzuO|3xgiUVN zV?^`8^g6<<tbpdufDbUeA6Y)idg1j>$#0Zrz~x?k-c&?6TCi z590hhbq1=ZBERL`sjqUfSdd9?5xg-eYjb1X?g8yO5M{N45jic(8a9{!G~c5kZf((U z^<_6`iZRP$*0V_6`O`<#+G0;qznSuEc`WD=%WM7M?cwWZs`Nk*hq0?^eHT`)dln@5 zw)-~Yw!6(b)wsH5P7wqA0P<#^Qgd&cZE?-CrY5^Tn~@a~UOh%sS9q6}C&wQlHLELy zv3*rM>BEZoV6CQ%{#?ry=r46*z(=(=gx%9qSK`FmOi%0pt3s@LR%g`8M6{%nxs`?; zi&Vji^9P3`T7d%guNwJtwE4x)ojb*4#C6Kl^y1bmAiK)6#ULf+-duecTJSoXvY1(2UsNag*dygiQ?66F+KC`?cU!9HeHq9TC|8iQW zT1{Ia@8jFXL)Wimc8TYP>V^kDbTA1K@wL}VKVM^RhW!{ay31NPN%4kTgs0A7)%xNu z*NA=P^(EiFSRqA0b|s7N9ri5Mh)fvy9yBOG%_UE~Bd{0mU}sLDF4TDQ1iRHMWSL`T zN~U+OW6}=61{?X$v*t?eFclh&Z>NeNXdF3ftM0piN9FubM~(fQhqvbP^J_YXo)d2- zW%Z*9REJNdGAS@I{fs+pUy!5v#fe{56?;<-#^W)1mg8|c_uyR2b9=41+^_meH(gV; zQY&>8b2Jt*4V>qq4$urase0=wzJNt`H3t5Guw8?jCXIf&J%4uSK9-Ht&Nk&8!rEM| zWR1MgHM^v5K5imXa-bzsWM9k)bHQFsE`QxQtsGrul{iiRdcLD8_n*OJC4LdK~578+rPl>uAuA|EyC5%S_kQm+lJbjmz?zA>a zD*s^5y-tT#(YK0m>v3qZY8VUc7}c4)RKh}r)q(^u=HSweQfng`oTSfEtDh|sp3qnD zf+*u3USW0C{f?u5_0OlA#N@Xf(|KE#5+ovFU~nlaQw-gFCu(da4=>Sd>|rU@)MuYp zye+~^N2E_U_Dclvo{=V(5bO2uMrmixtcZF^#XH(ZavO!6(yf8gjhnm3Wectw!uw8V zcAOGaaa>npw3m8vuf*WCRXXx6w(iL()Rewe z2;M1m2UFPfl%Ut2vW*8j({*DiE7NtOW$w#q>n&YhAZl6pVjDw9s()q;P#hV&*R*Zu~A{X=#^2KpLzjr_}&Nn+Fsr6Vp zO$6*1D#p{*YH8y+569IDH^91dkY??{bo5UljJ zJNgHKyeL(?DzP!I;%fbr8Y{#0Bk zIn{=enRo(-(&INDUB{%cPBkMOal->)%$WXn@K=rXp+b$mFpA-W5-U8>uAV=%^x4P| zY-&*8ldRjSFE{pZ=@Z6onQNVG<7f$4N7?+&Db+ZZMB<3Z&rN%R2vwiVyGP423RDi) zju}@QXBxux2$+c~<>=m7OHzu@7=BTisazWQwKP`!4c`@e+Z@|yl&TYa|6|%9`JUj#h|X= zc%nLL=5;XIRBxYDhdn;#;cJlKq(wfQ1({AhO9r-dH8I{?-&6nYB>vL|ldK%|CV_a2 z@fg-Xpeg-WXE^^NvDTfnvEfaVEn+?k?lW98I&Ys1@-luzZ{2De6-5#4n{$$0M4#w??8rSbKDgs`gp&WwMBdFI%Mk_KfL)#@@#aoq;U{^)KjODeahonmb8Ij!NI0#(*U6eo$_fO zw|E`eN#rG}6N_MWd0DU#tK}$z9?r>+B-g`?= zWm1xiyA^Y-RMX0zck;69L}x_zsMelf!oATIFZcq^zr?#w9w}!C@}kbd3}G`QWA|&_ z$Gan96-RkIXZam^%q*vD?^SCvpY90NHd2eoZWYfWcxhTTm1N4UOmQ)M5o9y?eZ&D8 z*l64L(X*BSWCD6$xg#>WjVW!h%Fpxdk)TX5cT(-4#BlqbGo5`7mcHRGcJA!0oZ*T; z>mLaeauZfK3jcOc6A82HR>kpHaT&7hxs)G(@nns*)6rCWnfoDqXKNY8vQ@;+=gZ|s zJ5<*$rb|YoC0`=CYDwy^7l!7G#u6)OVGTpn!?1@~^I;I;Xn(i}=cC%zY3%PkLXD-U zjawh6Ta!(H;qa>e%XIk3ig^?CfN;fkvhlkx6*@;Yn2bM_9GLSTlqfBH*)`*68#6V(JU?zR zJL~9}65$g#c0MI^%>5F>LvYWJkg5G+>{Zh78`RyD6!8>_tiNz!6S=H$mw-z~wnMw{ z6XHITa~Cf^du)19=g?L(T|*p?3n9)bN?0H$HshoxS}s&eMy;ESFWz>NRnI=&m+5Jj{Iy*wWMSthy*MgW^3L*=a2MaUz1-vD<2@_=`T$IV z@As!gkN=f3{~k3LWKsJY5zEqO_?otiuMHK)I7<|x`!5dBWgZbOR!IWusZ4372lF>F z!dsBBRe%%p^Ku~Q5O-GvuzjxLKVy|aJl)9-JhMnxVuK6S;pSAG*C=vy_4b$cDM56B z)sMdz3iCK22tKc*2ilJ*%@k`2kZ= zJE~2K7~;o$J_H;d{Yvk<|B(J=qIHw;v=AZ-utuQxUGhoQYkYWx6d*JzgSgk#yMS<{ zn~E>6-%Ol}xz!g~u=lUvbblGdqJH;v-&PP|H+4%|XF(&^oZ?Ctn_jMPIt+~4Uf?iZ z`+{V|olpQ}?K5!tL%=xde71HLq=XjkuO0dW@9@99Yo&Pup#(OwWnIj-&%5y<0J=mK z(nAKK8@oTlK@IW9DTUHrC%233gkg8Vi%P=1>R~(=#$%A&?&`Sbfz`Kyo545VUk~Mr zu4+yxtsRl)wS0y5$D6|}C3ThTO`;{kjjt5y-geN@Rnrm6>G-Cp>o!$ilXlp6Z)=T< zaWHDYMnV6?Nwc_PV)YD@j26)SzU zUR|qduTjH&m`BT>cJG$5*Jwq#ZqJrq&43*r3$J>b5@ecdR%iMgt7#cMZGr{jstGwJ z33<^I$5kXwXi3fvHpxD|{ZOL*OoHuBO-uO)Mj@vCg+V$Z9)rQT;E*X4-wY=FPhNv! z7MtzZzr!_V2vCq*i;5#6tP&(JX!8ceM%sMaDC^v6G+9b$}a)#-G5u@3rJ7?B|i%)$=RGe{(Fq_ z|D@-jlAOP2IR#Yi1eJUJ|6K!6NzNZv?EJTu6p=^wrTA&hz3sRvNb_r+f3f7Z(ktcJ&R0{K>ZkK5tMWw|<~R zj;>_yP65g_uvPwaP!DkcLEkbx1M9P8==6ZcwjSUnBY*Ebji}8w9o~dIM7w{BFgpRV zK@)hXUq61q)(nL<{`JsC4MmQ2zkpHtqq36CsfQ;JH^%0m}r1^{y-YUgLsw$0G%1=MAC&Rt-d4Xq#@dVJH{zO zF@o-|!H1g^dxBnJ-~532Z4LL*QFHaUk5a>Ceu#b%)xxz6$vypbO4f?Knn0py0E zm$>EqdSG~VlWairtBvK`{XYOLf7OW5|KzwJWiz9{b+}4^r5?E|I(QsJi)}$&Mdxw! z{7Nlg)(CbWX5;_^e)5*mn*Tr15UM4W(SltO>o5THvg}s{g*KSHYH_`RxXJOmet=r@ zZKBQp7ZE(T673@JD{_!)6j0RqQLySAJq9uM+yS|);(%Op_&7ZZ6t_2}mNMOy*lY{i zWRnQ1Tl;YR?TqMl8}na1Jar%n3NQW3iY;8f;)xFA$*}`d!aq0d4BWAcA6a5HNo4%D zlcu1ta6)sg3C+QOWgnRTjuOya9;BLYZ_+#(Q7lIfpL+~n3w7Y!vKspPunG(WP8Mgq0Ll;V^tvzX*~*_cv#YK^@rtzEmNo1A7V-x!5dn0d-)9 zI?QjD0D!Ljd#{h*2|xa)c3?MGA~Rp=a>E6BTQBEleV+6%`t0y+B`$QJGCD^+hCR(; zg-1b?z4*zQl-TW0{V(d&dkLK8GZbna-PwF6#yZF-L}nL9r5_OUl0MP1?5<* zjy#~6%zlH(KVTTPCitW8jlXg*h{G1&)jI(CdRes7gz7h#7Q}rV5DRNzjJ+W8(_&Eb zFAgRw+ZOk2Hy;qh#1I%aV2;`h92iUWC&DV~v(XhCO&Y<3`?vr~!f6u4NQQnYgByMi z@y&~jV{j7XfSzf`lC(2@i!Fj221fZIc{U5kA5I~tY5_Mj`1O38EP=1mwLynhW1#(zc~#Q|%-nA$F^p>A%LD{MCaOVOuS@m>TDAlMulm%9a89nk84&W`_m>Op76|1pS=W%;d5gjNT%Iw0Hu zp;AXUgi0Zw<^OfJAfE;DXd#alig$ph5)|+FRcP-2W;6_;{!dkN=jTFJmerDgJS-Ab zRvPCYT0anPHE8kWtS4HnAo}V7MHTKjVFmy2gS@FP_vU5pNrM^vR(JPF)2R4YzAHC) z__Sr;H5f&>L|N8!=<6yNMOmUU(mA{I6%zv{Fr|r7>|Ofmnm0ioiszU6GUD|$LY0%W z{vTmpG1Wg{E&P{+d5vi&M(4JkCDB>=D$peHj9{&UV@}c4%vD zx8~hpwr$_eBLpRiV5q|=pT{>@%eWQBZ zen`PCJd|Tqo=73(lAwSm6!82-Z2te|0RV-=p>Q~q zEcs1#401~$w-ju(M$B@(qu}#;V=VpWb^BiA)#-N!wrb!{}94OSODr{Y>(cL&u#)V;57D zY1&xKe$mccgGh%pYf*gqT=G2jtg7MufZGY8(Yr)R;!R?+HlYp1I;+Y_;mbdYjgyl! zeyJFQ?cKa320m<4kqx&ki|N0pqul=6``($40JClPjSVJe#G3g@FYDht!30$Jp!%qP zbq>sashWZI_?6J_DZ$H|6`(@b{*uaz|C4p}&}aX})HwgK$dPN&8augegKNrTd?YMu zR~^DlDP>(`8CUror3}JeK=S>aCK^$jmf)H{#R5)sgw?3w`ZhRSq6}|{KT7QYjho6E zl9qQO)-E}pg2z>Hf#Uf1Q$VewDhZTX8};@o&8z&j8gkS6O0S{1b+7MObynQ8%ehk#~6}ltW zb~wPP+g&%98m4E0#FTdr&{QQjb+mq7CZEe2?lKqmuq971LSvW@?d zfS~)MTcy5IE8mbo)j55013S;+a#K^Q_j8RrKzWsv=Fr+a5@1$@K zDa>!Cbp>66w9x*Y*TCOdVIC6c++3s+nx8*^ejscEVVi$vdjO3c!ZUxDH2`6oKi|GV znBhNnP9baqVVl2;ZGgT9gmeC#*8qfV{&Vdxgu(v&-yXs?5VrYuwg=GIAw2VUSpyKZ z`Sa}?gc<&G=M=&=5VrZd*aql(Kse{$c@03==0DdCLm2GO|Lq}c17VwgXL|sR9l|qz zmo)%kn?K*aL73q`cTOQ}17VxLi*10u2ZVF}o!7u0Vw(*n^y9JEWh;7egfNO1dw?2v z*mV1o_Z4#4dQv~(Shb$a_((=zIJc|@Y%p!R43uZ(Ww|YdWKG^g4Xa9Q8;~ zdS-svEK8cwY~fUqA$im|zyOtM)l|HWq1mBbeb`=Kl`ie+RWW;crIo+fV}5`r{2|nx zDRM>Y9_waDU|vI*KV}bK z=IPpCTFg;f8?VwL<7pv87P|l91`}QKN!9CrsNjWA$$u^?`78YP5Hi|q+yB+BK^5fx z&Xx}vJA~XeTLY3Y>6sR2es@NAj^$}whC__GrAMl*J8ukexn^ybOu?+|kz08`U+HfV zR%ob&9Vkp>vrf5(NEix3zJ$#(ugg=Halu1{l^aZfOB+nPCs)k*W1=^hc0T{mi9JWY zQJkK5S9F6(C)m9)xY*<|{b~Ev9ce4eN6web3aT1g7!Ni$6_u zgXuvCQ{G+t6_W#>#Owx zwG1(GZ?N^%O{@8)d?OV8wNhvd)nf=;zFhscTG}kUH&711g1LXHT4ui9GU`V{ zsXB~ZR56RIVMo7di1cDr^QT|A??!TQHch@xYc%lgeQ8f1Tf(-r@i5rs?rTVPHZ@RE zs9ooKA1t(W-A$%C`?6ek*fjd2c+0xArtif`1lhu{FJr;M!52ntOg-=NdZ?DcUR82s zsjf6p1)b4|TND}PZF(>0pNXqBMcA$n5Kt8D5Jl`Lf~c{*SEQe@vV6fi!)3^6?$$?^ zZ(q5{tw}V__+_ce-9@7pjvnWe@ES%2#`wchbr62W>|Rq5g^6{;qgkc&DunIyOMba0 zjQyw1!zYiTd$beWty%?lFemEp3QX{-GOeuztvbN_otO2JzGHotU<>=^IS=0|@$-=^0p`EkmaVJht@!HyQbRt3)Y@ zukA(-IxZdHEI-dr9NbqXA#mq=poP4YKw&|rA&al!ZK>I$-~P9I8c``h;!J<^hc_V) z(eB?O%uWCv(ga@W*N5FBnY>emvN z!$?XE(NasXx|E?h-rKm(Wv?lk197$;GEv@sHa?(ZUbV;u)Ajy=p_^eNX5nvD8EupV zg_#W|&vmPF-N&BvulS4;^s`>Tn)KSKLa{TWhiz>~H<&`r9?o;$b$+)Jp4~(`L*3D% z|Kca6&Z65owu#5%lc++78Wph_91lb2UAZccn)4&4_v*tjLCx>?slF#3^LuctaVC^= z3pE!s?e=@;xWOd2!6Z;&%_Ah}`A`u>t$x3%gvLgEK18`6{=k5gu)##uB+m zn~iQ~2%^5HCf>;%`P?*``QfP7M7r-l$0;~JqY+ui6*d$4g4%z!kTTHwB(}k_Dmtgh z)t&SWt3mWZd3Y+Lw`%Tvl^Yy>v|NFY|GX|I>;9thyV07QOy(RE_!$BPai6C10)^&q z;Lk{O%s2BoC(n1GLqj;~(ayI7y=-G5S5pL5Cs%Vz^J@RghWL| zM2s&$Ku9SnAVP`~BudCuP~MPI6iO_JiU`U}fq()Md8>%XTY``WD)Qb@2wSqVb9bHl zjr(<<+kLugoIc&>-n$(m3=?DAuKinU{^x(rwNjS;eTv5SZLQ5E?c3&S9Qf;x3%N0J z+y|ADavY63=Wci2``^8Q3qF9Bl(5I&HwJFn@xTYw@RxkuH`a@?vwZXp-B zVZTk^!$D)e0`|bh0Am1S0Am1S;J*_CJ`aT4Z{PI+{cXsNHXrvtd%8{c`T+-=2KM;7 z#z6Cmi26;@TZT3RO+VBbC?GDA<6h`YjnUAv@Akh{O2fp|-zTQ9al*z4V*q0SW8k01 zfcrx_4cS&sm3&2m)!E(~y?^%n?Sha0k(Yq|*`NC?$LQ(EwqC#skgboY2vlj{epyg8 z*N+~6b=X4TBc`Y@MTseDi~)=RjDi1d3}}vK>7qx(o2ARD(P(va=405Ozc8)v^uLpJ z@!$Pgj`*Pal76w|_wdm@rgsW?f3{5$cm5=%oBmukVdH^~2gU%#0LH+-o`HYY4uJIs z{HJ;$u>Jt7{{ia(!5F|8z!>;HjDbIE2*COS{u8|rSbxAjubzd~4zaPu7{D0782HC9 zfb|Fb2YV_0s9%Nk2mB{g)PJ{{8FoEb9T#H&W8nV<2C)8sf2e(h^#}ax>s)_SyJ7Fg z?it1a#=!sU3}F2M|43`eEx6dv3}M^dGt+tbePZAqkNxM*I<9`{aBjunRmUhlyiqdT zlYslmhIU#KzfJkdaX>Knn-1&GpFY#U-hz$G|HlRf12#$i*Fu58fWd&lfQ3&?GyI!A zz?MU7ImDJjY&pc1Lu@(3@@dRO(7^-&CI~P=fC&Oj5MY7;69kwbzytwSV*3BfY?wO4 z)FGx0F?EQkLrfiF>JU?hm^#GNA*K$oZZxa~?|-%-V)+r4A7S|smLFmH5tbie`4N^M zVfhi3A7S|smLFmH5tbie`_-^bdfzZX@CO7zmAAngFICcD$EoCdiLLM3wN8*ue0gP+ zcG&mIPilvMR@=OBU-CcZNUwk7{#ER=uzP|rfH8nEfH8nEfH8nEfH8nEfH8nEfH8nE zfH8nEfH8nEfH8nEfH8nEfH8nEfH8nEfH8nEfH8nEfH8nEfH8nEfH8nEfH8nEfH8nE zfH8nEfH8nEfH8nEfH8nEfH8nEfH8nEfH8nEfH8nEfH8nEfH8nEfH8nEfH8nEfH8nE zfH8nEfH8nEfH8nEfH8nEfH8nEfH8nEfH8nEfH8nEfH8nEfH8nEfH8nEfH8nEfH8nE z@P7gW2cC5mluemTq%N@C>1U@%~l1X~%f7zF2Zay%sa#kQ_M)l+;gmCfR$3P`qBT3b+x+*xOIQ)@zA>RMq1{_ z$P!=eOm2(peM#^a2~Cc3V%GLY2cYpw2lPXzP>X zo=30|b4TnA*f?N3VDkc7AFy>23kO(O#N+`clQ6l6sbWkOW2zWa#h5C_R57NCF;$GI zVoVidsu)wnm@39pF{XWeNsjxZE635; z(!gyi?KBQ-n~y!PF~Au3!wl#P9W?eU{EdgwpUytKck`djzN20Hy;l z9q?bk0Hy;l9f0Y8e+dJa4#0E(7SsLW1eGLyVoEeg1^UFV<0-}2o;)VrLscJ5J4>hS=*bv5lDZSRnmyw3^9DxDmX%2tlSi*vHwL&_pM2r& ze@}V0ukNKX#8!^0WpY1mqE@hFH>5<_Hkd$VT~|QflOH=yoCT{SW3qH)3A2l@G-b%W|^+`cr^Mi z^3i$_EXkLCkN$omGRR-X72K2K9y1NuWaT!qp{;z$C+Lv4Wr$oip)CoLrOxQ-3M(3cxEh6yFx5l*pc-DLPk6o z#t*uCkz7uN)>^}Qn$qJ)zZ_S=8W&2}Gj>Arr54bkT3|)>v4`|r7JpeJ$3-*bxR0Buk78vv z@JoTwV(~|ynDZ}DBbdAMk8yXfas2D!h$&u7@nVYiuSGNL^?xcG{|d#+>V>t(kVBf% z^Kx7twM35V!q?6~->8oOkXrn0ulvNX9Cwo0BFF6~EA@V=cutI-lj9~-#QlQe=LBVH zK&4*-^9R@y3ITz7&$N=xwO4b;8?@kK|2?&`#aPO<7AgIy|vmYTJC5VF}F!+P2Ga0Z_KqA>&Im8_z5EXYfV4 zuHN^~Jbf}{VQO=wcG7K5S$RjVv$-61-LZiZJ7@v93{B}UHb5-lfODNb844F=M%4OP zg5{4FMjr-e6Ku^Ny#GA+i50o5^zQqSxf_{{Wii&*wEbu6jjnFq%Djw9Lj$rPTYm$3 zUA{~nUk&iLvz#$=7T(WZ4=D`|M~$z1ERIDlcq!EbsN0d&lO%2o5s{VO_aA{e>vTVs zFQX@JE9opM5_N>x9o+Jq+-JqTMuBW|kpr0^9%;)J_9A%%o+mdS{~dj}j;vm-F2u(Z z@bLEgQ0em;68I)|h`0dC-t|P=lM+`=6nSs%Kk}CI%u0Y;ThcY%(h}Gbpqy`UXv0Uh zSFDd@1dpoY>wXMHIj(dB3X|g=DoN6A6rWimr3s zXR0DoIiT`49cGnSy`jggz2!UrgtotL5z28m=;+aR@1d5)m?kh_EaLu%XXO1m#bchN zTjvz!{6s8Gi28hP!2?m74wSkLjJ;B}_0+STYG+Zh?>-Q@l--xT{@LJzg3(^9jC1TW z1+NP223~J6*&HRf%6>sk1i+uz@X{7R(}S~j>1>G*y{l#id(H=C5wGa$LaE|x$~FIR zr6uT1Cr81)!T`fpzoZlTj}O{kT3NKa_^XDj8qL^p`Q_oT2GCr=+$_6avmwxC@RBB+ zo}~`i3#$_Oc!mx*&nrg@q*I=6^l8mCo2XuP%Y$*Ch*U9TcW_?3C41>8>97xVcmf9$ z0?}N-M>b^8mQ-~6ajfJ;Irwqr^~k)Rpk_hEgrYFtb@OgRC%>LzM2i?(xXLKzd@zT8 zaQRoGPeyJhWj{mTOLrk{a$FfZrY(u=*OtsyuCaoSZ&Kogaj#^Nz~+>KGe%F{{ew78 z4C@D@#(SQTj^;^puJHyNP0j5s7MX4~K-0XL2;=80p6*ckc&%7_H^hPA+g?R=5SgwnwXx3n#O9W$!~*7L?Z^}gEcoW8K2lm^^A{pkDhu7VAPeRo$8CY>Ar zQ#QDr2>n2HK&g)-rAog?y2PJr7RgFNS@`z@bXucM=(!8zC^^o5zY2Vi2Mh_^78T+ z=fqpL;+HKq6I{`8%FPN`;hV5L+wGc@(aD_-r%ov^D*n0~y@W65ENozF%5i~&IG-P6 zH@L^;I6@#*m3xA{@HCHm#nwrz{+u`P>8gm!^PGI+6guE_;8ufSJuKUk{*S>!GKeyrC=6Y7+nh7CFy?z!)edW_a+ zfks(IP@Bj_4e7pV+*$2#m$4j_<5)8U)zh0QZ$uE5c#Wj5-;);a8cjg6U^z}{6;Qhz zF%B$e>UMC0RF&#=itf-&C%ia>B!tLC%khwv*HTif9k_dIH>b(8%XY%bJY z*1ftQg!&=e0S8o~|6#^i0XyDDs~rvjhnq-RV)UhIhttGrvIt!n>CsMN_bW3k22;zc z+TrbYy!j(GnGddQF_b#ocrT_ox=3$aL|12GKM~m{$4SunTY3#bSNME#qvp&oyiATm zl!v9RK&=^K8o>M>LMI)i5m*rBa!RE*fnS;%$Ej)uheY}}*Ea{{4S0Im4Au+y`i`fr zW~w(=>cw?UY$!Ah;^fnoKxe2>_j;v= zwkUWHxy?6_nr>t}8Kkk{`_7Uj=<0MwM3lKAw#74&+uuE9ub}tVa@DFW^XZ);d?I6$ zfU4wgCC8oVwe=V>i`WA;$CP=wj1YL7pm49M#~ssSz~-H-w(80lv&s0XvpA*=I<84T z?Y0_apw^O%X5h<_PJ&MEt^J&ioC+QqY}8X!Gy_}))C(rEG@f);2M8Vnt5Y&Qjn-Lr7Q%;6qvs^lVqc!& z_SV+^{+`CRxu-xa8j}S%=d)CRS_e z;7v+*KCLd_t$hSUas$F>1rWJm#Lrj%*`0x%y>2@Dp86Gj_S~)Xc>q(x|5P>n@BLux z`5*Vt|LT}UT%kusT)}L;KTv4atcTi=V_eBMIj)@Z{!iO~-YVh$#`cB(eR~72jttUc zDhfW6!M)rl?F{|m2cLU?Mh3`>3-48S6i=3o#hbAOgb7QN{%Xn3^(N0d>K7-gZ%V$G zV7=bc(h%m6g}$)89Czny6963!WW$-;2$T5^K>9GOiw2qbfjwN`;{NZ5eZxb=DV(jv zea(``-J#?~-lIP2dV;6UkXA5GeI=JN_2~n_9FzFF9c9F&t*G!{NKF28DB!di2d_#` zcduqqzynU?F13rw>+W7uHi5S>ZQ-5JB|u!Jd7at~&JDRq1RXd4@_*_`sORD74 zQ%2!bOe9LUict=JC=Gk=f&i>W9zkGX^O)t6IM1^i{lOTm-^2+#y$>t{IAz zK%Wb-%q_m^#)_%jXZe`wQf-2MesN=F@zTKLkQ!zE0Dv3H9vbF2S@+R&- z?GBU9AR1$`cEprn3TijwV|+-^RJBb_r8@zSjGgMs?3GVh@q=P~yI_fI_pNNk1G? zh05O!BD5Yok`~eJMxXo&=-4`P8}yfOdKr<@??*E@gCjGvh2PS3dK)Owk}q#+KUIP` z4HY$HFgXKFyKSu_h61-qE>JFq-m;%bhxHH1aqHedN^+cECx{w+hw&3;)L}A69nx-~ z^nDfe*0WOxix`gKLUKG+x%${0`fx3Cb?KJWeZAFofZClCozE#ZB6HuDt!;Ddm`rol z^V<8Qs*@c6a$CFOB!OFPGxu~ zH)|X)D1B*Ia@Qd3IBqSs*%(n-gT}RaVmz!7EBOl5id#8}Ep1mk)r!x9Z4yR%PJm(Q zTVydrKE&mK-5<1Qtwnc+0&j-l#0_fe)NNp31p$*J-q7N{RMCCbozqrdEuXzfFNE6a!W{r4O;=NJe1uMYEZR zfaMzTL!i|Iv7+;F-1VZO#b-26w9TE^uk?X1p^naN9rR=NF*``gUDbplW+Qh2NpoPp zqisR@5YWf3Ck_c>}KRgQujTB!tQ^rB;|*ns67?c+&D*wFI)8S=xH6xaf%TQ z31EZnTxbogkpQj1Pi!%+!)uJDLc>BzN|}_uoS_7jSq$Yi4zZNH1`9Kh^n(6fCrUf3 z&kI_fPFV1l2WX`)tILnLOOI;*v4i29(?EV#!@U7OTRR2kqQxr6B9@Syq<)0Q(nQ+$ zW!jf4BTYQ~?fDKuAYLn@qF#>EpfgvzSgWh&>)FLvTHupsGJF(r-#fp?rAPq@@R=v> zO=2#m_tpVR5q&7t9Sl!_7m3UWjWu|&&!zJl*o9DdL&khqCo8#NB>d6UH5>^W2%6to z{c!iPUDgW@9!4#aDR|kKq`w0Y+~Gb#t$g0yH$1+J7@xv0ouf1qDt9xg06gppo}6jB zLRvl2^Gj*e}#CmYs29c#m1*_vQ?;l zyM=l(L4Fb^^d=sGojMqV$hGVtE|1kPM;ULqL+#&pysD#m>rjwxgUxKifYZ_yYc~$S zKY+#Y41*2F>Ad;_;^3R-mRAR8us^C(2LV|B*^u++aWp!}acUFACtNmvnUZ9P??296 zAnR_F+`>Pfz}JVD7@s#Yo1tlLSJzLB*r?|MEYMJp5mBjH34jg+RrEJ5$Qr0~D11Uw ztAJZVex6L*_tuhy573^yV26H*9uPm9<~G*_sC9aG`c-sI6BpAXc2sqS@%2yJc(-Of zGb^tW7HaRPEKT=#)-z3U)|A;|>+>5ok%7gEw6@LEph9r1oHxYyI0mfA|Q-KYFgBPD6!T5dg2 zG#o`1dcbZ_COGuw+AxB;yA4Dgy5YpKizRJnijo^|X{Pk%>NbTF>EpWZakx{f6t)o_ z68@qW_#gDN0BKxU&sutRjKCql8sQDp?<~9zj>AT>WK&(CRcww~XZfu>_+ZzvP7mmr zsJu+=rB;sqBc5My4Pz)%paA-uw)CB*Jcj?wMlRSR&-=0_OA>b;V5FnydR z4M5)TIfN93Y98za_CA;6;=sp%@Jd>7M4|B^U@>i1!d)#4^Mk~b8fUHa#YVAS>}Vk4FsV* zbw-qNZD|COp_ZqUU=PJ{~Yq{FhN)M|KM#j3mt@gbakT#nx zDG%S99;Yhs7ixa&O;I*MvqU8-iFTd>l>0cUg;5(TUED0>1s0jTr7jg~8`0 zWHTV_1<~nZeq8~!MR@EIRs;TBxFio6kbcjgTvOp{!^_2my)pNDOea2;JreJV4hsk< zg0?n!2IbVh3<!~%M~ez=dPI&-Ii=mg@~6JG2i?cDVO?D*Z4@Y>z#4pEMSZ3p zwek_6JG^Z`z(Md~eI0SG}!AH;oq=+$l0j^I80;CjCqXGhVFNP`B1# zbaxI^im0FyYQ6#lpg+xJr887sv2eI9GeRIsk0Y(56XETGmLPj4 zoAHdat0#SFM(#FC-j+eW*VIFn1w`oVirbO@tsl%5sTG5%qV#%dLZ!mV-kKG3^j`9p zgzj?Rw0RU+EY`{t*;y1sueH+7IAip~ygT)3zZVo-G##D0f;f@p`??ESEbr&~2ITQd zFRtwO>2E%(@MFQN<&Epp6n<6wWqFFr=->X1gunG23fP}xWBA{I0h9M8^<(cbpW=`B z6h(w4;47+(D%xb6BGD6Ig&gAJr{qt@Vhto2Oi{WQ;_W~*=)}J{){Mu} zqewrYWNO?PtQkft$P)*|(RFg%B6wwqbKt!Vg=USj@zvfB8+BfV5*4AXyQAc|M*U4a z)fG;s9)ZXWU`_I!NXLU#o@cbRf05(#Q3(R;N9Md6olA?A>M&nWibkwT+caYvs61k0 z$q1R}w8DQVlcdG4J3kpzckQ!m2=R2{L4-+a#I0QNxyc zAx%up9*g)%Lv5z1>^C?7^#l%f6mGujRsltbHv<~HvDx{~)d9qYDb-!d1!u-rzPL!> zhiQWB@l9wrHkKuG1=&6eo{B5RABdwJ(Khwuz>^_EKA&GSg+;MxZt zPtQe`r5`xz;Q>W8hLIPIXemzrQAyrxD^Xbdn+?S7{in7wOiiCgbcrc7v=zIQT=+09(?RCW;?9r|#G);O6 zoFw*rZK!Okr@reKKI@%`6cw&18n-0G_v#zndQMObop96k-y|HMNbyI+jt%e3{1OhF z4a*)umV-6fieBFIvrQST1)osB7l#oc+p~yr$k_si$XtdF+Dz5De#P=4bPlN^=KM8X zF0*Ja(Ejux*!|j`-$dSaWevvjZ?9UijocyOM)M)N+)1F;oI5Bhk>k?GANV|wssgn` zWYy|$QIOJec16YWb)?1i`QB?X+nR|{l`+pmeB6lozIO>@4SbcbxG;*|=M23^N)s2@ zv9^cADu>MsG(g^t)O}oAp!NfIDMLwo_BjCVp~Q1l;A28Q0k#u2B};uER-L{%n3eBW zL_gbbK|dQmo@<$vdvCOSS!-Z;(B_rFDLdL^hI=cU<2M0Ft&s*`Q5Yqe z&%rm+RN=Ky`29EKOGYpB4|tzuuIkCDcv8s$`Ii}%_xkxzV&kAubp@yLN%`CAtvREf ziJrUxzSF#OR^j0ragoLjzydzU9o9b|v4Hd7Gw|4boON&DbB}wc!+qFMb`N%X;I#H> zz{+GDRIn;%3mYd>tx{4So(G*n#6A+?-5bk>T}m^olVFu&=+c-B)KUs(JczWKCCrAo z6t?+>P+zcR$TH_y3BKC2NGQ9VJhz+AfA*wn$+?7!bR(1ZmAN(Em{y*%YV`KKu;|c%M z-=U`zWB;@!QZ)1@qDub{X{g`z7P)y0QJInBzEAkQYjM1|4;WPv%zaBo7NO0&-=m={ z>KxkCJB_>~%yDZ7y`9v*(9-*w3p%%bb7H~j6==t)WVamGEd!B@WFC{7#fE-pK^7h5 zf(K~tI%b>D&|zy^89PCdZsY~lkfFWhTD3E*IDPfNBa_V4FyXa-r_WJ(>b}mx8U6y# z@oO|_U#On36DOmtrJ?cz+NigqYrhg?TT)_fm~WV^8TzB^jqAU>dbMr+tL^iaEL;_3 z?vs5|oGr48ttBpFz5(e8A8VFExuV=Crp0Nd`mZ+&L=a1W78$mIRVN?nN)$H2sT_A%KlZXk8ZXQ!_48Blu6O~#sW4mr^o%byPTN@r5M70?hT)Jig2j|Or;SfQa8jRZZNhE!UOJTWz z>=f8cgkM0rWUkD7~zAo<17NbSRDGHM#<9MiphpeS(=sY43BK{E8!iSTh^hD zryOudCLn0V$6eSLD-C0Ipz45DJL_ z79@1oI$H&DrQSXKkjKcN z1sGhBJ4g?2)?eHeyxK#xT7M0AKR-X9e0G9%E;MpapkA>el#FnMwNN{I3%{nNv9o1iOV?dK?$x*~iWSA!8Gq{R9t zfcM!}`68MQy`S0vZxTi-x>T%4n|158yp?ZfRX0GVZvG_N_@+fC_?#>GV+$JEm!to) zV+?DQ8B5viYC~{HVD=H_m$1i$#&HGk(xO2x?~${x2Xv|US!QkmbM4EV_rDgIF|0LX zQho0*Y|FaO2zq|(@bc~@8g$+lhtBDv=9jQ{P93OC(^sl`Bx9r7S!waa0GlK9(jo0S zs$xI2EZD3l7$MM28hA4k_YPkDSS{HPyFAJeS*{sk?JxIJIGM!$`aWgLnyUu!`W`34 zQhpe6J8yLL-FgFqs5g@h>mNqFZonht2$;Sgp8(nh#+xVFWC>j3Mfyai(kiqacvpm%(J!>f? zX;8W6wujcP5^g)mmf@V%vErwnS)}O5yQ3z$^H0Rgty0|3OB+Co*ERrTNkNpw=*C@Y zH%ybxV|EN~?5I`*$IwhGxl=@V&W{^h+qJ6G)c}wRbulUPI z3XozG&#hQ`g24bur2@))y7~4l(bHZ;13J{?d8Tp~R}3^QI=P8mm%H~ZZOTj7;K@pj z6p^)SGSBB8Ijy4>EAlEN!w)|zN}T_4hwr@;OD-(gUc2h+>>IjMT_B_`Fpu4A);?i%J<<|}TQ zae^F&I`TYEsjwRKt9Mfk1Y4yEh zX&vQ_wU5&7`UL(wLiUUBS{T$jeO9szT@pBm5wnX;U@9Z85o7dz1H98{_eZB#sg94g z0G2Y=L;Yd%ldnw0&1{WONj^PWJGdT-04#L0qW#wNaEpAnDRG@;-d1y?uAx^x?8lF{ zJl9#9BV>O^H>tnS+E_UF7`?bfblT4D-~vy-lBZo|g*vb5=0vTNt1B`mPE}TV!`XlD^|8?*Ev!=UAlRrr?{S{;X zj+FFITUHgnZ9vzzm)wub0Y&n-6j=_8k&(`BBtR2MLmR2iTf^CSfuD>G)Z=A-Xk@y; zZ8f+^4ua8DcwTjvE&9?tSI7*FHdc_sy+P_20gtR_xI=zY7ymS8%T6c3fuVXo@T=&a zmLPQ*L_ORk#|amU6L*xPx6c5|r|;`-#jB3>enE`f=i-6d;w&YQ)xd`gtXSZ1GeYRJ z^$<|?VF%egTfHHI%9z_&_&s`J9kQm^xP4|o{ZRSwc@mqfo9EB^h3OwIGylQOtsXC^ zLX^Lumo+2~ht<_3-B2v3xSw^Xt44eD3z>!B=shwtr>LWXu?^O}(L21V8h4AHh>4ej z3#S;`BJi=-im(agVYiCX=-u7ZH;r)!nz9Kx@MvqD#3!c!s3js65KD*om>5S|g}mft z<%h+M&qP*uqAd&DXt$0%AB;T90`lNJVC3C<2a0m=4JPMf8g1~&)taJAg9B>0!YK{9-=Xpz3%lb@yWF>j9LwwLf8SKn zY_xef{PgZM<4~Fe9r37rK&?HDrY-X=WQj~2q@AbG8QP{-Kmac@eg<7GS8;{&p=M#r z*43iI_3QLKa%1g#L{*Q(v6pqu-_N2ff)aOmz1)?f2`|9`tmeP3j6jX!6UZMb83Cxi zE)}Eo>_e)jxWRy+M~?gELKyFqq9P-SA=}_G_|RSCl>ZQ zx6?97FN(jSvOf9+_l%iWBfHFa{F`)%zfM8EfPdL%0W}3!VgaozEXo#}i%jRZv9KZS z!Oqv=gY>P>Z5%!#>1YPy#n{(%HOp^n&_!}Ot3Mk(TIUXWXYX(c@B!%#q`hY2Q?XLq zO#Gyot(h>4$r!cwowfE?LwTRkV4n>`w-QdZ2Y0$s-?X;>^&#Y@V zXVD7--K{E4lSZ|DD{7lJQAbhhVnHuZ`#njI*~ov~ThHZ1Hz7+Ob&*d`@mRGw)CN7j z#*D_x2gj(Yh&t5N)9DEs*ArA;{t!^ME{vd7&JuC;mme?fwxlc@Wxva483;hs-`?fm z5W+MSvUW#QwiiPOi7VbAb%<5;?u>Tg!4^*_5!_nOG+9!8YX3Dzy@9G>!PTujr*Ulh z8*HaHw|gh$%$ltxUv3Q%Q5l*9lyX@d+7-4Qq76+6l^TK;JFI;m;KtP~?}m*aPs>Lgk&dRoZb3)CJ51nFcnDG}t6OMoP% z-WZ9{KEWi>O}6*iI!dkK1A&45VQAM6V_OABySzq+?M~a^1{$*_O@kO)hFlCrou-9> zXM;prBeshOYMA<1^VyO2oq~g5)gfIs8FY`m0tT= zKRbJH4AJZ9Ac%XrEm|FScA-ZCxtBcc3=3L2H?_BGdhDIg;FtOXkDgrXk-VB*^xez( zt%a`-*4l1fUwyFY^YhJDsqIs+PP6pKF?J~cYpT?e7Y5JtK7x)(ef)Kr>+s71&bB0P zrs)Le?0PKXU$)_=J`E522`Z`^uC>|AC*KGV<2_^FRhNuR)*YTLih0Gp(gSVU&W*Zm*h4fU%vfgTQ@W=P>UKI^4ZLcOj7^yK5 zx88C#@>$gz=54s`Srm_;JetPi&OQ}UmyGBy1wU~`ZA-lGvu{JbJG&Y7h5VQ74K2Id z&-it5OrCCf(-LSBaG!COqYA{PPb?CrH}K0S%|H@czuGT6EJDOiVyjn&h>1rtzWCa{ z1ct~gAw##ey6jlhF;dBjvv64esQAw%1sHk+dQRR7c^tKrI-V%t&W9X@ZI>D50s;;S z+zEz9F;?6e$yx!juh?4WdXDHQ#WKiu`x=kk`^+PypIm8`rgM&ca-LOBd5_pA#6jm_ zv4#TT43y*lt*AABuPhN(D1hC?Q_p2Y5v88ExbNs`A2TuQd9l_z*eS8@LeRsT!5r_1 zy0^7C^tt|>CFLH)VU#7?g(jJbJ0DkMef8>^?hjpNJ%n(?6p?itqDR*ju6;H{UJ{7f zqRRtoY{bO+w)vwrmn$x4N6i$+#|w9gXNF_VP7!5kHS1~f=sv@4WgP$U+?tN2+vOvX z=ktzw%W;+VcXubROejhzNJ+VKwf&Nto7=q2kBm0|vVC6E#z6QsI?X>)-VthnM`(RL zoJwBAu=5krqN!!E(FIIf$fVw8?-EacpC!FvnKZArOaq8)|F~lJkDZ~nh+3c1Nk$zO z5nJh@ttvaj!B_8$1nOmF>Q&)5H{D82@h3?J>`3JFjk2-NDY z7Ng4>=WybL_5ROUD?2}NpOkl=iEdt-Q!r|#aUnSV-gExxZcap%nN^o%Yu6tB&@dWy z?NL~MWt>HS-ez_nYoR`|vwL@Fo5Bb$CO-#OgKRCo-(b55OcYM1uQRnsCiQI6yfK^* z77^iWX5Y*-wHg6LK_TI%I(KxIscJi-N4^QfWL~rzI>DDP@Uok*U7=IXAhVOdoM=hY z=6StP9Am4Jlmh1b;w)8lJ}SI7<%@_3$nwB75TA5u6nb;~O z*Hh=Cb@Hj0EK_t_uw!HA%LUN_{(_O8M=#{O+LjeGc_;LFv){eXmEKPRTm7g#8wxC3 zw3@ciW`cISd9%WgGT28Jbde!b1G*7Z$Xp3)rXSTJ2g-3*0twCJML^vdzb|mxczdLQ zBRI}qAbW#a@Dy(8>udwKF`hEB1`TJwG8+cxLFhD{C*jBnC(CqASV;hN~Em}8!@%6I6;5$GcUq2$fW6lOB1Uwpu=g|QP1}a{iy3__jVPo zLBGXocaO!l;OR_1mnY?2W%>OrD!*MNmH#$_6)_6|R?wA+IUcg)jW%bvZLtbuK zC@mg!!I>4prpmzU?IgbFNx`vLWSPqjU*vR`0y0U`7cYnxwJO?+DKQ*pv$OSCYucyV zPyy6)%f>r^*A!pSw>@vfGv~_d6U`xLpY74w@Ic!W_ujg!OxW|tvY6U71?w71_XSeR zD&S?#g5UIwyT}|{XQ?ecv5{N4E1S__{(8=_J_l9hu|28TTAN78U{xcc^!94_#x&Ip zChY5Pd?}xmu|)0Pc10RU8*CP&vnTA%I(C*1hxc=~nz%d}W0z6%H}NfB`Y@;vCHI35 z>;eI&TY9!s9}|8^|7>6r`)hOGe)ehH^d6H28aaS?$!*J5#2E6H%t-aRc&v{y_WYhH zNG&j}O7@8Cm%rmMeR|-B(ekVn;xpOc_0LWUZDqN9T++ozq5~r_Od1R?tZ2KD2VIlu zky?Z;_u4uqN<5G!Md!vOv(Of`ojTeLCQakM?b8dh$!_ch@e2h>9DDyd#feuY0uvUr zj&RYPd;%mU4v(?Qj{28Boo>5v{(RDGQ^?eja00mh*^09g>J{E^gKU4XYhgLF#wRwM zRd1m%XYRl}c@)h(g8RuQAWD$7tu9N)Ii&dstFGsragp`P(3fK#hk)80w)^|OkaRz9 znmfUYAt_o-innymh7PfvH=SGur{G6mr z_=xeWj|N1K?r_F0dv!r=Ohk7)D*3!^;+n!7-+{SbIGpmHU;(Ej1wl5X?&ca81270e|fF zQ9-2j>DR#KfMn@eM#z~TA-hd7KK|9&8U6$ENCHlF?Jie`D||}Y0<=*V0YY2g8;J!4 zQ&Om3d+X4fOh72N@qL~q;-^3`Ed}=@npduDmbMDNT_VrExu4DY(Qaf+8Vb`6rD{jL z_gx z(myt&Bb!o#t$#V;caA06AM*aYEaHCiQG4I%+xXrLlP`OS{ZbJcWT`@8Y=;`+%8nBb zktd*Qj1az3RtT>QH5Q{TK{Fx4kb2$b3*W45UT+!sjaK=j8Su$2Qrkv$%PVe);|lKR z8!i8e=zP9*;hWDYZfx&;nGNGC%ja_Vi(b?_j*8v0aYN0rCisg4vGxb;vQz7Ro+J$( zm-#DB*CoJXzrW@3XH^!5vAJjUjFgNjrI6{b7WsRT9}4>cXdS-(elrhNA39>=H$HL4 z+qYLgIM?sDb8pNiwh% zPl`c@W2ci`l{QFIkey!WXc5#NQz+HibCEaC(yBBnF>`1cRFRa|tdbhFm|9EXX zi+Nq)&L7?n{1>kn8?v%l0=V ziCC6|Xd`^IB;CmGql#Xu=wA|>)R)xWrKgx2DdJER=)-%DJa-8lx`S5REwq|u|jeoR=rJL%nuwIezY<;M>#I|8u$Hit`?e5+@*rsfp=RG ztPZpW+6I6+N(~=v|oiq3vG% zt>nGkx3#SKeVc1@_%0DA@B4!z&j}x_|4Lg29WAG!jUDqIqDL>ZNzh@ge+r@vAHO|g zjw7|)M{Tui$e21lb{lz3RiMFP4;Wj(sW^tKC{U$1u5vJ4M9{Fx7RlUPd|jP0DUNS# zEq&KK^nTUiw=Cd*?M9(d+9}-^N`0B?DQe}BFmdYBjL%1T`#s>a9*`KK#r|=pPdScKI zbl?ccotcmB`nW=AAjYBIc+XkdIA4>(mmpZc1H|Hl{Lk zHUHha%&qp&B@JyKEhtx*zumA+vnX0@QdeO^PAZswQFJe`{`SlK_w;j zAwkGSp!QdG2{mrUIiG)t&uMFBU9qw@e`#^SnpJHmU?sVwEn0iT^TLr6qSwwwBI!-S2VpSE1|S6KO^lar3VIw551j z74(BwxPr{4NhK&&%7FKX9TMIf9_@$B1(YkWQn+Q_FWNCG17}5!4fLQ%9n-rVtQy(P#7|CV5$dlP}BQ%zO34a)ZJ*K0pr zv*HnZUq`i)pf$vst%KS+w%S73PY#AWbUT^sYIOn*2?PWK6v#TYDRGF3Lnm+r`yyAk z5*&^t)eqtO&~3`%m@F}rdQ@ymQ$=4iW9$cK#@F-IuH0Ud!M$Xw_pm8ru(W6cTNL?o z%bvH>g`3+NxqKIm{YrMCsYP_Z=0SBa`4S`W&Pa_h7@llvS4gKcX6f_<`PQ_<_QK+& zBNaBJsyn0QhZZDExpbFRwdAXe1sra+<1{?}Vf_d9ZyQn8QP((`fbJ+wW9xI0soUPp zu+))evbrrL&jmCVWkhBlPTYZZ)OU#>NAWW0u^?h|%?gg!tw^g$*|q-PO9Nct+V)R@ zpKTA^r3cDrW3f;wx+|}@iK2*}^v7;wE7B>bOVXx2(lJ6>2U1cjRLvU(wR_7(_LO># zW^5=93O^RE^WuTU+9N9jPf|?cbhe069B^ny?%Z7Ob3z4wq8DV>qP{ksq|M}!IRJW? z7SE%IeNw>wAMCw%R8w95CmKZsMGS&~fDn|X4+1JpX|aPMqN1R*sB|JA(gK78LFo{Y zM|cEDP(&;g>77Vd5hFDeAtX_HAQ1=$Qk?C*cisE@d|Uc#*xVQfPeP;R`_CsY$}1i!7(Le5a!l<);i37rp!8hF@q|TvWE@SrVK4jf;-zv6oebR~ zG*JVp^L-Gd7HV&}9^S3y;y;XQ*Xz`WAzF3kSv(V554oDelAxEw;6+W%7^Ebc0`361 zc|ljVxKhdPy4~dD-XaXMb9{dz4?Sb9&~pXPLP%rYIXr82za!ptkb0zf(-?v^$J6TK z?G#dx3V3%Dl58il9@KwXlSy=I$M$dDtb7M_-FMssaNmO)(yww z%-44jd;j??^c%c-2|khipL0|O_^rM`=}xYWAP*-a>_><-T;^S%VJ)B&#V(kb zmMWqFls=K;*|LN}d4-q6O**??=)=iQhf+fro!9H#QfYQ&!8O<2jvP@v`y2KR_}hzu zF@Ysdq*meC*O0@sGXv%d)_G6__dO(`TwloFGZ<{6(RG0{p7PeQ-6*~Zjv?9IODY(` zq|Ub5^qXoIyFB$Z)ng=`*2~tGYg1OML;gI)(W4W9*Mqq!2ifu)mSnyaAVQ>gqWFNH zK1v2m`o;#_`wTNt+bY#BmHk1DCwJ@II+&d9*!8|S)c2rKNLjb9{uMH>!2ScdY7qd& zT+r`{j-Or+A@S_7Ti8>CmBuY2RyNzQC;R+X{I~Egvb!5%?PbI52@UFzc~GLWvPlAQ zNw_n|W$7xraP_6L^K_{6{<|B5NOE~5D~xwZ_z|bkz`@VAa~2t-53JCuR+!-0CM8U( zJzEeL&tfT9R8(*-Cin&j;uuLLH`E_HIwB=!MxGQkeD#Rkl{r=7F32ZO6o3Ws5^7Yu zRpbNE1ZA?kIRpmbeoA}M58;-6{#kweCffM*iD4I?CP{W+dJ^hOlIKd zMHh_Qxtt&VEIcEQFCW9xoXcv;3uDJ{$U`akpYMAb{3m|HHezjsU!<@d!@&{< zgu9)_9ZvozdS7dcsiI3wau@EdUJ0v?!B2c9Jm4DVG>|3n{)_QA&7Q&A)DUF}NQ6$_ z=o8qS9?x3w^=A;;(2h5vC**(j_)9(`l}Cj{!I${4^2HvB^EG z`<0BmPvS-b0RVCZaG$+rf5Y?>K}BavfegfjmsZ(R!Y=zx8-Z0u3)SHnlKVEu?>xsB74p)r>ggxo(jsij7%}#Y4#;Mz@1}a(dX+M^zld5$Ov4? zYh1kF-|uWEH&f zBJZqReJ=oH9PeYx$T+0pm0uID(kB`(xme4Ay>Ie`QqfL{bCIVa6i6H;!h9rwgb+8T=BopCx5 z_;z;nikjsc@0a}BWmWxHSGTq5Z4=RZZXSkk(Xk;dapC!9eU?s7wEd+WRh! zBSWp!O1dzuYY$O(P)RMN|4C5r-n9NF?kdqIwg4Zm|CAeoH>(tE#W#ai`>!nIaDfmI zJ4U2|$CPfHF?eA1KEGjVWayaV_5KwCr0vft5WHM+wQ7P8c{AV6|Lmn+C>3N2CB@yU zuUIB3zIyC@`o)BN$*aFpejP*3d82*;!j9-otYSY7Y>t{;Oe2_GNe6QKkY2hm_{~Di znb3#VN5+wHSan3R^Vy?r@+p86kJ}|$SGCDnVa##NYPZ$2+utH<<>l3Kp&3<0`XP+T zN%26_hBL6NYsuYvf5V6YvEzV6{HA2plf4j=kFjrEN5txDSr+PpHr2XEOx{q-^IK)T z6%qUO1?Ii#dk)$SX0TfoQa7q7z2mFS2};4^0550-Ee?N&G*r&@7UVY=y=i{a&atO! zKBz2_+^ujVh@yPMyJwoTv%&0MsY$02@P-I`g-JTmc-rGcV1Z?iUfaj{4P1#`_Np9_ zPMkF4IANoJy}((h^rVwT_-5>ac&slIAvp{GIW&!vV^^hz7NbWhM*$POiIhJy=6wFR zcGQ@-gUhY&?HgwQ$>Jdd@bjh)6jLK{?qw!uhYSJt3psTv4W6vU+8o z%0)wqSEu&P%sylB48K2fW8j+&4MrEim~1}%8+MZ{>0R1o#wGCFg54~x7s@HRJUQ3+|*mH4%uozK2{x0-6 zt_4+9TzzZLW11HjzV4*I5!* zj&+3OIeB#JibtmcI7W128!GO-73c*k_gFJ+MCX(h6RlE7H5UC(@@TyTw7Y_#@TQpfoJa(dN1n5 zq@&WdRc;8mFE4~g*(9gDZ$RM??)s0~zf;|PgsWQoALNN&WWu^!D)NraFo7G^vp7L+ z1a+!?8%~>ZHDrGG^tc*CXK3qSDy&*_KH*F?+02%#wFkvL1yG#zQ|IJ`(kT3%C;z#K zm%1ilzYc_E&Gld^iM1KB7q-Eb@UxR3M*z{~&sTm@ViUkSk85k%?VdhAg8ZDe2*N&$y6SRx+nAEAWVzIC?nUAAv0ULUp^upf0LXN!hRYQ(WuCb zYZ-G1PQLH@#(R|p=ii_Yxo74n*->pdr;#iX0)lNpg4B?Iya+aZ5g?%{jsg1#W)Z10MrZS4j7 zD#Im_f7)@8)b(CWy-)%`B+-)4#*VJ5oT>Sz?CNG?kNmfzUJfC7j70)UvBAjoH9EA^ ziQ<_z>^z5*pD$XdbgVhJFj>_%@z|=CQCa(Vzq88UB^JJbX#keFX6Z#=dVRSdp1(H~ z9Vlh(ALz@$bMF(!8S=aI15fFrz? za373A3HqdA_{6JhHu@rz6G0bPbQ;$AC-U)(2hQ?-pU`*on*g{JGah-+20nf*0ub#gA$s=U%wd1qrV4=C9Jud#m z*xQgTy>YIHe}?V;pl2%b9TayV19B}ssJ-CPcqeG>rs+hmiai01uk!z3h6o?UWZF`H zUWiRP&E~!xRxPu6J33?c*t6W?-X|f=2^ML41{aA28cfud<_1hC9eAu&p459kXPlAw ze9N*ncP~RKcV)VxAswt9(NWlwwc~Z7(G7cFzH`&^xi`E1y(i||yXMdrr=3DPtKBHq zKQf|_*Y}sSrJ%T-V48fpc)h{dJMZ+`7YB>Div925ZZ!?>n;I{K9Jp6B+tE;M54b=P z&fg7e5^#n!DN9Y`fY6qakwS7b(aMgnokj+Jn7DaKbaCaUAT?(v=~81wX_Tj)i&Lww zWT(?7lNSMLL^LHBm4XnfaBj7Qo=%{{q)l>B(lc^$rKusZtX7%=O*OUJ<}32?>|0gUO6~T+uo#xN%G{Y0xXm7TP)hqng`iC z_dmHmed@;01+m3v%so@PHt^)$3aO-W?vq+P-B{T3G?160b%G-^Igbxv@^nm8S;D{d zs09X7#w6AZ8`pPl$g9a@z{wNcp6@N2(M`Cavof?GXX+~0S@ZSoaZ$RGA{UUhgU3j> zfnR{72oo`?n~w>V7edq(r9%Zx?3bY>*LsnF6QXY7&^44luzw>_u}Hg$t9HX~Uu1u-@n-RE$tG)9cPrn6GH%-aW2LrO6?=@Sh9f=%hEB?A}`kY6T^V5xwC(s&=l>w%I#4 z1ZMSWC)YFD6!m(cgZ3Um->4rW{=+l-`zhs){mNdnr?)#I-5u@gE!nZJGFl7MaTK9; zKIy|u`;A=qq)R6^0%E;p&XYuO8b_+f9^*G-VtZvp>$*b=ns+MGKNf%Pn#><{|clTnVFa;!7Obt@FQi1}%(n)CJ*AL38#KUaw4`!c- z=cuV>&6iqhC^7@XU_~)SdPNk5aUj);6jT)^%VKmzNa@pE$CuZSkVB_);cXHAkVZkr zr$c@X&g`ZkOGR5GEl8{Gw-$$jWNE z1{&5{{@luD?d!Y{MPY`O6aLwf_Njlv`%tSeR zrT!V*cqEC2>ghXMy41{|U{d1fveJG%B5>!)xhr3+Y(g)*Wq<{%n1l zK<-5p(v&LP`i^~QLw!3*Ry=!O)ZrKog-cS6Wufr6+>j3pqdU5C&%a!z5w9c4A0PM%$y%~klgqaAm{-FyYs;53?lPJ`NEP44J5 zll6~N5#G~GwGbvvjppBW0^jAZ>FK9DMEjU5t{&G%*P3%$_xw!NJ-nDQv|2))-7msP zoDyz*%F)*2BIAjhNyW5^(K+r@Kt>-~Un zINk$HHosv}Q)cf{nji@d+4{RbP7-T8i@9ds$D{jr#|M1H%pcfz%WtXexN-B*yTV6ZiuVc?j_r&yjfu5WhW3#Q z&p(gM_s+@+3(v^D^;+X_+4|RU*5R2d%#YpNj{PEQ-lZUdsG^ZPO#F+ZoKvlcYc2K( z$qwlAA704oFu7fC0#7B&FSn50pnPWcyOh!~&}<#+14~Yn;FSAguvI^#mxNG=aHvp+{Erd3LK`bBu+%;vrYQK0=6aq6Rj zQa07Gbf#v8s8Tu*FjoQisD_dEwTM6LZGoo$P$44F3$@!{oAdaQ&-nJ(rO;gTJLJxx z`PExsja{HV^#M~K(B?k!Gu9+vH@vz3ImJpSrKD`3eBXCD#a%@C!)G}&ryX7*!$FkM z>WL!GwT5y|Rq{m<18%~t04d@R!_2~2sWJje{rYd%-JlYSUNRaECU5(Z_xw|36_1#Q zXY1_9`FAwSt?~IMe8PWyGI=dr-O{vq000*75sM2u?(mUxilpz?EoqEK4Jk-CL3Qg1 z=So!Y?EjuamXTS~xr@Be7KFTYxe2*+d4(f)u^vxHWZTj}vfUW5e*;f1AA22gF7{Qh zXhUuC*#Wf~jvweztJ$9b92j4h zB+rX+d4VqZdBPFA@^WMJBC4lye>1D}ZWyk=2lZq` zm%mG{L-G#biX_n&V^=P?hV@ih+nm&%z3NgBA5DbR<9t>c05|cBbqmd=pvp(VFyybDJQMqWM!yi=HX$ZHd6sgN0R7yj5@4 zfLE{JqQTQE^02gd2Sghs&P9F56v-rup?5&yJ4g&|joBa4JuZVh=U*;}e zBGoTa8~-iR{hun*1z`RE|6WJ`Zi)SC9-IH){VKMw2i&gvrpOxfxB;7(Xls&rjU$^@ zP{w?%6&fb(`QFKm2-8f2&Al$!FhKS}Mui^^2Iv}sO%Ef?|4^o-CKV7U{!|kxS8elNWJlfMO$!8G&JZ;8~U>+)xGtMCG6`D z_H|UwZu&f;vxxPj07Asu%cvBGOx7pPXI|*AJ3Axg8Ixz!+TmO)T;#S3i=Ksy)zb{7 z)(Na@;LBbe;}Q}So^2q~-tTFt?AUkUF*vqj)> z#QRWMC24-`=5;HMY_ErsZ09MC8RR;xR^Fo#$MKfIj}%{A;*LTRXp$;;6Y^3?uI#a2 ze(QKIMFdr5t+hb-8CBs@Kq$xV<6t972`urW`ot#kNVTD3V0#ffy$k)}p`-Pq217Rhj}Uk0Q^l;ZA>@lDT2|I`%$9Vk7qJF6U#3ELJfEv( z!TRdJiQ%F|%9Qg<2-IKVdxX1- z85H5x6h>#~s89yVXE zvY%1p1ufy?o+yk&CriMwF6W}eppD8kyfX#y#Q`%U-8Q@0POPh0>Gg8qI6~nSC9?pt zjfz}qJvETMCxmAo?}uxcBKc{}jiMk8i~H#aUx>u$N`1=HA>@sCQkBu5axZ@t+8tyE zc1^l5=Ll6G-O{(iSdaxq;$YNo7>%-RTvCtvIN*cI(s6`{4bPX4$u@U+L+?VZ)9Lkw zoh}w5F3gpW69Lp?dbnYHg<9<}Q%ei`8%9BFgPcp3d1up*b6Eo2Dsa>82`OxtdJ~io zmilU{E&NLQM^iz1YewEP*QleKyN{}R0HzjY{->;Iw{CmrQP2nz{?*_lz;#QIfmVW_ zm(8saJfGr$_+wAhI+IQj9bLy$;P8$Jc*(KZKybyCh|XcXdWK7x9-$VU*WTCnxzAP^ z>WG-qAm7?6h$ee@m6DsYiYS5*PF$kBS-607Ev7%Hb4+<{fWTE0WU6-Z9i{imuf61u z+O~X+yo!0PsnleHYxpM0=qFW_bcUI)wk=Af2J&i)Zchn^9SZgcX!WcQZwb89*nsp! z>}3vc0<(7TS_d*MGji0l2?!ce6(r(4b~i1y)a%`^UL~q?UN!_!yE&>qIIDziD$&}- zW@w7*MOfhP@3A?tH0z?8Szxo0)g{z?vj`AmZGe6YIOW1bQYw=D9Ejys4mX)$(XQzn z+s>QIYgntdD*VTE3uZEPVU>SGbAI$U>~v-;X?4{OgfBm_B$wIDPsE7OHDkrT;%>dJ z{S9j(3bK`l!KOe0Jm575)Tn1{JIT;h9~%FO1z(qxf?B?28Ua4_Y|(Gnr)#`!(C*IU zfoIX9#;z7{@ZcXS@U7~?ugK+drr_$ZD9{-3h2h}%79j+x;xjg#2szm;)iR;E< zO_mvF!PFOeTKsG~mgD_ch;xtm!6Qb_aqDb`$XvHflO`GO)}xfn5=@;MIk+zWGucic9pYG(Tf)TfxnMYd! zzjEiJ$|$A-%c97V18ZkUqhSx#P;0ffRJ}cCu4sHQo9p zv$m3xJV=h0f_#<=oTMq%twn$4tV=~(Ib2$-aU;287;EJjN^lCRJClLmgOdqg0{+{D zuW-$rqzhn4A2pQ;btRRgGn`K$VrPFAgD%%ovUDHvCU9poA=cxla`AV{XGoeC`VFU= zj9kZ~%r;W~Y&u*u%xR!asWg&KoqvSEEyFvU?|n!EcSuyJ-u{{=P<8F7?R6Y2b!8m&~>ncXV=7Avu6rf+S}Cf&UAX?9N|V5%wka`8UnGHsY?Lgq@^{ z;_RC5SWT+h=rcj|Z`kpHK*B$0LUl&;t;#bQ?Q|p`h(6WbV zM~iU>3aTER+f+9CB`#rKXyR#=rPz~&FLw^bq#Z}}=E(3_GXO?2-{-A}FKdWkTI>0b zDc}=>yAI`sY#d)dBwBqQ02w1z%;L=Id75;?Wu5P?ytA`PsH4JFZiQTZU10sOsbimV z;p16a9NPMyycU}9R{U9Ch!~4?`C4HUk zTX0+YF9&2)#yItP1keJT%JE{ZvsJTsyrx`4QIP#)RVH{_#gm^{qv`0^%*c*RM&%=t zb5&;ecFc-=qj}t5qw0AG+7 zzFWbb70E;TWM73QX37nbfp4dk_f?FN7M+SSwI4H^{2JE-U9w+d-65+IUj>^s(kADR z(5RoO)yvk9z&^na#;oFV;3_DlX@L?qu|wxuyIApS82CyXe1gw`FmeO>GPXkbAQ9Kjrdv= z1Yp;vFyVZS;1c0UVDPyeob(d;Cmg>6KVOLr0+9)|==BRFQ{qAi+ujv35XmUcUg)y# zD_MTm4^cQBXDj*(7Y_P8QRDbj_zkWeZr^X=ayb#!`b5osIpR1%UpRy+D`=sN`g47t zdY&%Uy$?s5KqldK)qm4jpvTGwBPGy>O&tgi8@zKBA9~&5AYx3dJo7QxCo`^jAuB5C zF~tnxSF5Bjd`BF&S@5LkfDo9Y6ac|p1XCxQ3s=Ufaonfk7ImH{dM#6=ynd;L$35hG z=ju;b8O51;((Ajm+SYfKJ**LS4`?&%6UB!Xv;iXTe_m*bpP0o%>iXnL-T75lULaqF z-H=7-Bo8MY&+22?rN0=eSg&rw53_WN4YbeuYlw}bS!nu}yf8dtbTdku)LchO?LFIA zSNiSX-y-}0^!gtoL`P7z>f_681Ynk`&=kH##Ro$sU~{(wXerC881VeI=76%`(Ytj3 zlgHdNMKH!xh2nZVLzGXGEJyjNtK0*mmrTaer5*zlt?MJG`v^(b6t|k%%EVnqEV~r8 z+;twlcCT&Y2I1Ra{(F4$0FXqHBype`EnSR5dQ%<{l`~zSE}jxH!Sqa#*Sc>*I$HT4 zBo54ntO)T{8HU_xxBg1xMwjV2Wa_+jzUvQ6IHfaSrib#@$8NA1)h|%}tE{Xn)^78S z>l+JS-h3zW$EHNAd5;1Na0U|vprVLA2s$m8ro-U({RTO%bV@u{FPKx#wdM>qG^ucG zS}F%__hPLl2+~fSp02N-zJppz4@N~8914sDiHJeyz|1($_Ggw{%9XQP!bWF zO|2xp489-cpJd}o={)OexnFsN9dkw@?_OX?7lXH0McTL4rM`LPd?ul&crrdt1u=tq zfo}##4BOJowj}_Q2#i5VN)1MZjc=WhQ7fcqg_X|4=TGxI(Q=LK6=D5ENNvjBr+Y1! za^*U+S7!2P`|#R$wj&%mX4FArUj_g;sa$lv{g1>@LXcsQRDS~-`37oQv;v!!O3o_@ z!v*SyWy#=&rf=N1F;f+i6_Vrad#hl`@r1jptNSLqst~)7QZ?DCjEwhc zcO4xaPbi$)B>CdZcFVMm#6%dZ9QC6TyuGr3h(w#$0~djSO5V;WD>d{9w+Q>f2g^BA z6O(1{kM<6RaE_M_6oha;H@0{mxT1Muq>M9%jrLnru)8{8P0b`kKoQ>lhvt2eE^ThIsyR+dz zY-j5N45@|MXHkGjKbz&~k$rK%cRAAE5)3hU;QAKl%+4S`he}#TI`Zj@(iqR{eWs`A zWB9X;HGRP;aOWQXoBb6juIKuF)e>i0uk;y+qa#KYN4;HZD(j*T(9_gXuH#?G@udSn zq_5zghFk2CR^>m}n4+18lfZhjo1S>*qw(@s%?aPYPLw!KL&AJyeAv`BA{Vo*^9H9n znvZ%{_9>v)OTj;;62DbYyuvhbiY{4lFJ zzDcHNpp(B3j59=Q5z>}p)B=~9NjjQ17(tVCys<_U9W1cBtoslfxFx12;YyhPbg=V* zn*)A$?foJGBfPIJWMU!QN@s`CJ8Hq6J?=Fok6Q+PiYOR!#GGw6-O5~yMTu8vdsq@p zd~G_3Do|Q3#;A>&W&PlxAMHFF6}N&ey4$8-T7(JK$#w!tx1+iQKsPntFYE&hTbw%X z8&aXcCYXsxM9E_9Uqh`O4ua2xR)KGPcD$1zk~|UX=9w?N26sAmH6eQL44OztpX^&^ zsoKOUDr#ZU$MCMYkY*e!iHE~1TC;WM>)9q9cuCng+a&8jJ|^hhm=@jseoyqL06eoK zL2i%(IkrA>aLA~WwU_&a&dMqnT2@lEAJC|LUn6{kpC}@;Pm?#`o3+Uk$uv=YmZ3Nv z`2P5}kw)X_*C-w2r1dTLUppNPx32!+KjIUi8;6G%y{d{tS%Tb2m&!t_edwj(Sr-G2 z+!F>u(s9^AG}hFJeizPsMW$v7C1`+be+1V;=Bi-kK%dX34M0n3C6GN431|a~9SG>c z9E$%CHHQb?DDDsqguI?z9P;bDQeM}$=*!>Cd{|T7RGrm3yTw15B&B4B4(mPk!o$LT zL(jRhb|RakHUO)<8Qumo@IawKnsV(nvBV8Mu7g5Dz7Dz1+!!ladbN9@go)hf=yMot zF4;GHJj?*T2NJdCgg(@_vd>UFfW7<%3ZE37j;4Ge@Z(;^I)=GNV_rsM)G!{gZeBlQ zuMfRUvr>GB`H|9}m-pK3=CvplFzaH@3lEbgYJtA%35|7vSt28(lG!%dcrlQe2u}cj zkqf9WOlR$7n`GFX?f$zgS%JY!RGh**3m(^?&JjVSJ%h4OQfZcKLgLCf#kP_XOoU6O z1711`Z%Shyr$IU?AP%;=9e5L;;uM_Z$Ptikh$Ny)HAgqT0)$$r7txZYHb+6qz;M z&|WdyhaNLt5KUwZ&Z5Iy)A$#okok+y(R87B0Nn=qOD?rZnZH}`jMZ?$owpxw#SM_s zGb3Pi37RVscZA3sqsyh4r$JY99KXZ)Gu0RoYpR!P^V(Z^bJ>7zA=XL_r^Y#(UovvN zslYYQ3v^QuU=i`6jUXm`zl0(;;Y|3R5Hh4}t(3wpVc=7Qi0=pIN0SqDA5?a0oX|pk zxo$Y=cTVHIP@2CRYUBV%Z3G-A#@B&jIH8>mL%W;~eY`MV;{exoE~_eQ!h2oF$YKkUO% zi3fuak|Pi5did^~0^8CE))p`-zLl6ZT7h~DzHHKMd$GKqRUxoxH*Q;%rJ75}i>w=i zIZltSCnz*m0BjGT7@fCPNp+8O&GlEZ20JaASz=0JF->nY>%TQqGYoGj; zt95MZ1MP})re|E=bO%JZGOaDzWqWP*Stui~y#DWPS^cm2b8i(=-@WqUc1OIMwNr4; zisUt({Wab(d{lFiIBEI9WrJzWg!FN_=@J-6mu10LZ4usf=AY=TG@Q#Kg<$dF zF~XN|rvv)GO4Z!x37YBYE@O1Uuq*c=Cp067@IZJl_Q2gMk>Ou;w~dx5KR!6FNwTy^ zCj4XS-kQ8??2(x0$hZo4U++UlsNoRmgNxeWb$2^!^rb#5QhMiyy9Ybt-4F1OA2~gL zbnn)q9J2`S8uUD}$xO7>1^(^U9oA!vftklT(z@IV@9Ac#6gpG9^#|<8j#c2f@C>1_ zg3>|loNE$ezmy;xkv9+*_}dc90{maifFzwVU-_9ror|!E48#e@U$`}GVlEQ!>l2mL z2Pj)C8%$oz;FLsa&tzXAwf&5mncRKp{Z!Ykyy;#oJQ9+p*m+*EJ_j+=R|eauK85xLtTINuso-I(NFXC z@YJ!d5!6Lg9P*a#aCxiHkum|+JgM&%(beXv9Od$W$Hq?&E{_)JT4ja?XEgWq9A`8x zwvxrncR{BufG&*Eir?h*7#wYkkJb0m-KwNu^|PGkR%~KgUJn{F#}VEBaUflMwLM?- zVS_Y-CKdM2P>}8pv_e@G=3|8TF{;->+e4AZ$2U>yFcDl`LB6R)=>+7B&mV0va>B%2 z{kE*TU-{wuiqd%{OI~5fkwXhF$S;n=z%LQl4wy);$a}!yVw{Zu3&arAg)g&?Xm^2q z+k3|^Rcj1=y@@~#lAIo_vcBKv@oLy~&kmc4X(aoC^EPdu;Z8EH6y9}|~*fAvkd4JM_=9pmFTE;CJ$7{O;k!taYhG*yOU! z7U)##3Hw%}40}B4?V-HW-! z9W{<0zk~kZdEPka>XE4AiGLpD{KB|0ek4%4%Bc-%WmA2)yn?v^-_BFjR(Do*cfga- z07^%u)_JVb_}kTZnF!zjnZr*Dp2`m zhO8#L+B_fQ3-z^Y*m@p1bgY>vKfyr_SX&%CY@^s}dbxXhqMc>_na9U=t=OluY8_bE zEg14EdnbJ6P(7@ej(_ zHPah)D3^W5@C?se{^-}+(}_A3rYn;T;%%fq>D0qr&P$3mJ=k;f18SdWbec5nybQ(U zF+xf={^ki{+Doh5d;Z%00fyKF#=s>6!r=~TC#2ev)vF_7_ymB=a#9<{Ue;v0L>*hW zG9cZ1*kzQyIJ!h{{ZqoHli(CwvVAhDEI^?*bS{n?sR)+g$ z69=Gk4E!*aSrF6EK^4ki2FJzjxi^;e=u{RNs~A5uFxwfdWF}WEUwr(|9_bhtYl)76 z7vpOgOSBo|ly^^-_C98`aL1bEoqH;5TPE(OJyE&;rzv3#oG$1T&~pHpE0ujXHPABI z&EDKpudl2Yce8UL8j6-Umq!rsl5B97iys!-6tNil2hL0g$7doEu)1^`spJ2^wR6ee z47TDMTo}hz6gO*DXXdMj9<$pG6Im%vglt<;)t#+o7F~q4aRrWjtS8n#WB5+6z*yIL zRkHim>qANnjq0D|KiWp&q5(`G!?tQCI?Nz<@{jH5olq|>4-)RF1Fh6nESUvri z;w>q^j!R|qc+rZUOQYXM$6A%T3)$aCKR;&>$FF9|Ut0G1netT0#=}l!y}$q8$n^iX z>3GA!e@hGDt`KZn{_z(y;aNp@SH5E?!dqnS+HY7@W$U;9nmygW|L?!YzEI{96xRu= zv&ZF_ymp}id+plT&pCzhoPsZ{@*9up__=1;-CDh}e{A%{8~qJ~mr**HIH1uI&s|G^ zC+cEP1t_0#gd$G&7vHn+TGXZY1$_z}&TDdCxhYn%odXAapp!}A7+d<+BK))X1=CZ7 z!!stv^zkn1s=nI!i1By8uX^c=Eq^?({BYYY z)#w_~=QKNYwNL*aiNSZThh{R~I4yuM#WZ|2<`}`q{|W919c8fySPE~CFCK0 z$j)C9%07GHfbf8JMMTbR;la>z+EN$ICl8YXfx8S}TD60^7oOOp385^$ZcoVds;iFY z%)VWJFfO-=``s3{RKeUN(qT|CTF=zUYt-)oQHeOcM+DE8E;Q%;X5w9MXEQU3TT31H zQwOZWG%9&E*f45n5+%WbRn~-ameB|M<9X2+dD9^d*gTP_j+25e*-5fh5CVuoTI#J+ z7)T{(&N1!K4gKcl(}uk}`%MGAN5(#!qI4-SjxtxD?cv$Q@FZ~E#>$=e4c)~~7RgR% zU|lUSIUlU+xh3EGm3jE1LA4Orc2G!35AZ#ia7jPmI0uzr(6~kuloZcqW$;(VxT9~X zJ(~ivp67cxjMwW9FIy{K8`S)$eDO(v^Q_d5Wo74=dgd3;Zu$O~S~Ii_?XY$)dOF^$F};u!7QmfE?oBVrvx^l1Iq{nQ@S zlxw>p{<;sUe!m2sJ|D+{o$bR(LTt5vhIR6DUA*qrn8|An_Srmq#0|bjV%Zl?|A}+d zemigEva?rz6LzOYIfD$Z+68zF?Rhkx)vXIfVvmCMOW*+i=r|&A#E1`KC)>YvP_cm% z66%VZGi~saXuS^jrB8;0ycVZ$^{(eE^>AW3*bTJw*`m?p-MYnr(d-#>iR#kP*>{0q z4DD0+^6b;A=LL2^4`WtAf;4E&;%0=m7y`qvRHb9t*YU*r3T$wjUDF=kl_?>apmZqA zJUbuPLMqq!XIIyRNu$fP4)p=7J>$(*)%p{jg*P0`BVwzxrZ-21oq=KOGI@t_lyGxe z85Y6bQ-3(-&9q_GF!L3&uxQP7p)G6KS(iQ)rEf+aYTClarIjlp%K+_Qh8K|R%Txc` zB;bCs>u#B$%g4puzJ9**+O^}`-fnz*{{w703^on>kpC~3qwN2$9IK^h3%vR&bI+FN zPLI656{|qZbj6ANxS8}?ebddfm|3((BJ7uvEf)_d7A_bQS`cy4mTNRq+>UR)I*#Vm zb|HtHNIYJr4-k8BwFOTreLL_E2W5+g_gU*YaV|c2Pn?q_6+4cS+%Y#ySQLX5rCl4? zsbKhSnimjPlsdZkp}A8gXEPaAHwMfO88jlU-xkd~tQM+-{!$6#ZWhrVV}ggkPTn{q zu$cWQ*J)69(o3bGX~)41-yK7y>KT`cHnmRb8<+d3On9CUsxXF zYL!UNQ?UM>jbRtd!H04LFZ8>CheJ%W%f8W^JPXdTs86ZcAat&;;*g$j7fq%w&ZN=rX7vk66x3) zv3uE#aJ)ZgXbXI=gGTbQn<|(ka6NcmJi*wmIjqpjeBad%qeYl|EoL8rcC5>B)lxb) zS1+1bNk5MCKLd8YF;JFLOdD!PkhVo`+OjkHQV*^$jpi^nc5JVLOSrt~cu7g{BBZJL zA;l(QMu9}Y8XfqQYNG9bvH##V;(Z2i>Kv`z6|zxixDx21RRX5(!+W->vB~Z2u9PR9 zCD4Uj?vjDFi6j2GR(`~NzRJeQI9?=Hw{a+IG1k=m`RAcA^#)_RQg`{qI=B8i{$k4q z3QCV26N!q9J0*D6v|(;k77;J&5JXA&HkXAf$qRGiM!e&R-GSFzgiM=MVnKEbr0L1p z@Y3H`!)6myd^laf+k9_E$IlPb%71L$3@Yv+7K(nv9~CS*VNmgSck+l_3-9Y2HlgE4 zVVJH)LP1Fa&MnMI~laCha}^pZ9w}tb1`B(|-%}>;RjVWNJ{dATM%;8q{q~ zkmps|+rC%vREat(rXqk@;qt`Z_c++qSH(ulUiMJ!?jnPaS!3 zbjnMG`Mj8X0>merYE_gw0mU#Sj_l`D4bs|-pO$`@R%o$$dhpryo1*ulx z5`}xbtDk_Qz173`kx zHHBq`6yEV4`Vn=!T1{$0^S&rEheRLC$1gr9zD%o&J-0I^@7?xyS_l66Yys?h_QYKL zcmDXlXjJu|>Tv!Ya`&&B0sfB+x%-cScmMC73vG5{JX>+Py?zyN+5f`cdjK{0@cF($ zR78631f@!qE?q@HKtvSj5EYRoM0$Ww1nIpiRjJaYcOrz|d!&=ldqNEmc+c}c_uk!e zXYbwJclYeQXU@C~1DSy*1J5MS^DE!)=Zp7K#i<9ue?VO!G`2FV3kk5C2d1U6FY6kr z>h%&n3yaDrx|q7YAnB$BLW=*wH#u+RSfrdVTt@Svh?@hA6HeaY`ObgFt1og#sWnqW ziJJ&R?G6KrlC+-XdCfFH6wxVC1bjuaAAEHK3q|e{56Oc6_};>Hg`t(eyW~YtDkmQT zE#F$LOWeJa(zEdTwf5VG98v!yO(UY{Y-yQqK1unc>Spgko_s2UqT!i3rG6I0KB7w= zKH5)SQKiA-EX187Q3)uM`aA%Hg2s+Wk$nX$=hbC|-}`xujuC}ks!-r6Z>J6fWsfHo&n#}0=a{q!Bq+pqwS z?NmFk>C`QZc`~wo$hc9Hl&&zp*jE=IwXiem+>w#`&o(?tXs0g)HYEDUmY}d4a~lus zvH&;0RvJc{4S@`#yQ5`1p$YT}o2f0OtBK_-JY8cC2foDTzDM=Xgb?VOu1GJ7?d(hK z5Wf&RZiU-|MrEZxeFw5`h`C7%KYCYps!STc!N|pUS1+DOG5mrt9E1U4*HGx;_IUkKHJ6UR%Y+^E~RvY6aAyIUROQDkT6%pUu_B6G__F*e8B?Kcp*vCnWd4ZcPY zU+Z?jko^tBFy9&L02j#{b`J{CX^j5vI>`6hlJEjD09uLmCro01yc5wv{xqh5E6zVN zL~#_SVaKKs2TSYrnt7Xgo9%ZW@ERI^7%>Yq

    T1|-8O?{#0BulKdNa(6R71N@t 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⋘DPUiArXWNb76Wkx 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 Swiu{Kx^up5EqawjPyPdQwO0}V literal 0 HcmV?d00001 diff --git a/docs/design/colocation/images/network.png b/docs/design/colocation/images/network.png new file mode 100644 index 0000000000000000000000000000000000000000..70dc20c3a3c3e4af51a3dd01d93abbc0305c6357 GIT binary patch literal 497405 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%0A``GSJK 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 SqqhqFQ&v<{$T)KT+W!Md0Vb{h literal 0 HcmV?d00001 diff --git a/hack/check-generated-yaml.sh b/hack/check-generated-yaml.sh index f3ea3e801..a1a30587f 100755 --- a/hack/check-generated-yaml.sh +++ b/hack/check-generated-yaml.sh @@ -31,3 +31,14 @@ if ! diff ${VK_ROOT}/installer/volcano-development.yaml ${RELEASE_FOLDER}/volcan } >&2 false fi + +if ! diff ${VK_ROOT}/installer/volcano-agent-development.yaml ${RELEASE_FOLDER}/volcano-agent-latest.yaml ; then + { + echo + echo "The Generated yaml is different from the one in installer/volcano-agent-development.yaml" + echo "please run 'make generate-yaml TAG=latest RELEASE_DIR=installer \ + && mv ${VK_ROOT}/installer/volcano-agent-latest.yaml ${VK_ROOT}/installer/volcano-agent-development.yaml' to update" + echo + } >&2 + false +fi \ No newline at end of file diff --git a/hack/generate-yaml.sh b/hack/generate-yaml.sh index 350ba948e..c13451237 100755 --- a/hack/generate-yaml.sh +++ b/hack/generate-yaml.sh @@ -28,6 +28,8 @@ export HELM_VER=${HELM_VER:-v3.6.3} export VOLCANO_IMAGE_TAG=${TAG:-"latest"} export YAML_FILENAME=volcano-${VOLCANO_IMAGE_TAG}.yaml export MONITOR_YAML_FILENAME=volcano-monitoring-${VOLCANO_IMAGE_TAG}.yaml +export AGENT_YAML_FILENAME=volcano-agent-${VOLCANO_IMAGE_TAG}.yaml + export CRD_VERSION=${CRD_VERSION:-v1} case $CRD_VERSION in @@ -103,6 +105,8 @@ fi DEPLOYMENT_FILE=${RELEASE_FOLDER}/${YAML_FILENAME} MONITOR_DEPLOYMENT_YAML_FILENAME=${RELEASE_FOLDER}/${MONITOR_YAML_FILENAME} +AGENT_DEPLOYMENT_YAML_FILENAME=${RELEASE_FOLDER}/${AGENT_YAML_FILENAME} + echo "Generating volcano yaml file into ${DEPLOYMENT_FILE}" if [[ -f ${DEPLOYMENT_FILE} ]];then @@ -113,6 +117,10 @@ if [[ -f ${MONITOR_DEPLOYMENT_YAML_FILENAME} ]];then rm ${MONITOR_DEPLOYMENT_YAML_FILENAME} fi +if [[ -f ${AGENT_DEPLOYMENT_YAML_FILENAME} ]];then + rm "${AGENT_DEPLOYMENT_YAML_FILENAME}" +fi + # Namespace cat ${VK_ROOT}/installer/namespace.yaml > ${DEPLOYMENT_FILE} @@ -145,3 +153,9 @@ ${HELM_BIN_DIR}/helm template ${VK_ROOT}/installer/helm/chart/volcano --namespac -s templates/kubestatemetrics.yaml \ -s templates/grafana.yaml \ >> ${MONITOR_DEPLOYMENT_YAML_FILENAME} + +# Agent +${HELM_BIN_DIR}/helm template ${VK_ROOT}/installer/helm/chart/volcano --namespace volcano-system \ + --name-template volcano --set basic.image_tag_version=${VOLCANO_IMAGE_TAG} --set custom.colocation_enable=true \ + -s templates/agent.yaml \ + >> ${AGENT_DEPLOYMENT_YAML_FILENAME} diff --git a/installer/build/volcano-agent/install.sh b/installer/build/volcano-agent/install.sh new file mode 100644 index 000000000..68df9bce4 --- /dev/null +++ b/installer/build/volcano-agent/install.sh @@ -0,0 +1,57 @@ +#!/bin/sh + +# Copyright 2024 The Volcano Authors. + +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at + +# http://www.apache.org/licenses/LICENSE-2.0 + +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +VOLCANO_AGENT_LOG_DIR="/var/log/volcano/agent" +VOLCANO_AGENT_LOG_PATH="${VOLCANO_AGENT_LOG_DIR}/volcano-agent.log" +NETWORK_QOS_LOG_PATH="${VOLCANO_AGENT_LOG_DIR}/network-qos.log" +NETWORK_QOS_TOOLS_LOG_PATH="${VOLCANO_AGENT_LOG_DIR}/network-qos-tools.log" + +MEMORY_QOS_ENABLED_PATH="/host/proc/sys/vm/memcg_qos_enable" +LOAD_BALANCE_ENABLED_PATH="/host/proc/sys/kernel/sched_prio_load_balance_enabled" + +function log() +{ + echo "[`date "+%Y-%m-%d %H:%M:%S"`] $*" +} + +function set_sched_prio_load_balance_enabled() { + log "Start to enable cpu load balance" + if [[ ! -f ${LOAD_BALANCE_ENABLED_PATH} ]]; then + log "Enable cpu load balance failed, file(${LOAD_BALANCE_ENABLED_PATH}) does not existed" + return 0 + fi + cat ${LOAD_BALANCE_ENABLED_PATH} + echo 1 > ${LOAD_BALANCE_ENABLED_PATH} + log "Successfully enabled cpu load balance" +} + +function set_memory_qos_enabled(){ + log "Start to enable memory qos enable" + if [[ ! -f ${MEMORY_QOS_ENABLED_PATH} ]]; then + log "Enable memory cgroup qos failed, file(${MEMORY_QOS_ENABLED_PATH}) does not existed" + return 0 + fi + cat ${MEMORY_QOS_ENABLED_PATH} + echo 1 > ${MEMORY_QOS_ENABLED_PATH} + log "Successfully enabled memory qos" +} + +touch ${VOLCANO_AGENT_LOG_PATH} +touch ${NETWORK_QOS_LOG_PATH} +touch ${NETWORK_QOS_TOOLS_LOG_PATH} + +set_memory_qos_enabled +set_sched_prio_load_balance_enabled diff --git a/installer/dockerfile/agent/Dockerfile b/installer/dockerfile/agent/Dockerfile new file mode 100644 index 000000000..7dc6d9918 --- /dev/null +++ b/installer/dockerfile/agent/Dockerfile @@ -0,0 +1,38 @@ +# Copyright 2024 The Volcano Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +ARG OPEN_EULER_IMAGE_TAG +ARG BWM_RPM_NAME + +FROM golang:1.22.2 AS builder +WORKDIR /go/src/volcano.sh/ +COPY go.mod go.sum ./ +RUN go mod download +ADD . volcano +RUN cd volcano && make vc-agent + +FROM openeuler/openeuler:${OPEN_EULER_IMAGE_TAG} AS repo +WORKDIR / +RUN yum install -y cpio && \ + yum install -y --downloadonly --destdir=./ oncn-bwm && \ + rpm2cpio $(ls | grep oncn-bwm) | cpio -div + +FROM alpine:latest +RUN apk add sudo +COPY --from=builder /go/src/volcano.sh/volcano/_output/bin/vc-agent /vc-agent +COPY --from=builder /go/src/volcano.sh/volcano/_output/bin/network-qos \ + /go/src/volcano.sh/volcano/installer/build/volcano-agent/install.sh /usr/local/bin/ +COPY --from=repo /usr/share/bwmcli/bwm_tc.o /usr/local/bin/ +RUN chmod +x /usr/local/bin/install.sh + diff --git a/installer/helm/chart/volcano/templates/agent.yaml b/installer/helm/chart/volcano/templates/agent.yaml new file mode 100644 index 000000000..33092434f --- /dev/null +++ b/installer/helm/chart/volcano/templates/agent.yaml @@ -0,0 +1,240 @@ +{{- if .Values.custom.colocation_enable }} +{{ $agent_affinity := or .Values.custom.agent_affinity .Values.custom.default_affinity }} +{{ $agent_tolerations := or .Values.custom.agent_tolerations .Values.custom.default_tolerations }} +{{ $agent_sc := or .Values.custom.agent_sc .Values.custom.default_sc }} +{{ $agent_ns := or .Values.custom.agent_ns .Values.custom.default_ns }} +apiVersion: apps/v1 +kind: DaemonSet +metadata: + name: {{ .Release.Name }}-agent + namespace: {{ .Release.Namespace }} +spec: + selector: + matchLabels: + name: volcano-agent + template: + metadata: + name: volcano-agent + labels: + name: volcano-agent + annotations: + prometheus.io/path: /metrics + prometheus.io/port: '3300' + prometheus.io/scheme: http + prometheus.io/scrape: 'true' + spec: + {{- if $agent_tolerations }} + tolerations: {{- toYaml $agent_tolerations | nindent 8 }} + {{- end }} + {{- if $agent_ns }} + nodeSelector: {{- toYaml $agent_ns | nindent 8 }} + {{- end }} + {{- if $agent_affinity }} + affinity: + {{- toYaml $agent_affinity | nindent 8 }} + {{- end }} + {{- if $agent_sc }} + securityContext: + {{- toYaml $agent_sc | nindent 8 }} + {{- end }} + {{- if .Values.basic.image_pull_secret }} + imagePullSecrets: + - name: {{ .Values.basic.image_pull_secret }} + {{- end }} + serviceAccountName: {{ .Release.Name }}-agent + hostNetwork: true + priorityClassName: system-node-critical + restartPolicy: Always + dnsPolicy: Default + volumes: + - name: bwm-dir + hostPath: + path: /usr/share/bwmcli/ + type: DirectoryOrCreate + - name: cni-plugin-dir + hostPath: + path: /opt/cni/bin + type: Directory + - name: host-etc + hostPath: + path: /etc + type: Directory + - name: host-sys-fs + hostPath: + path: /sys/fs + type: Directory + - name: host-proc-sys + hostPath: + path: /proc/sys + type: Directory + - name: log + hostPath: + path: /var/log/volcano/agent + type: '' + - name: localtime + hostPath: + path: /etc/localtime + type: '' + - name: kubelet-cpu-manager-policy + hostPath: + path: /var/lib/kubelet/ + type: '' + - name: proc-stat + hostPath: + path: /proc/stat + type: File + initContainers: + - name: volcano-agent-init + image: {{ .Values.basic.image_registry }}/{{.Values.basic.agent_image_name}}:{{.Values.basic.image_tag_version}} + command: + - /bin/sh + - '-c' + - /usr/local/bin/install.sh + {{- if .Values.custom.agent_resources }} + resources: + {{- toYaml .Values.custom.agent_resources | nindent 12 }} + {{- end }} + volumeMounts: + - name: bwm-dir + mountPath: /usr/share/bwmcli + - name: cni-plugin-dir + mountPath: /opt/cni/bin + - name: host-etc + mountPath: /host/etc + - mountPath: /var/log/volcano/agent + name: log + - name: host-proc-sys + mountPath: /host/proc/sys + terminationMessagePath: /dev/termination-log + terminationMessagePolicy: File + imagePullPolicy: {{ .Values.basic.image_pull_policy }} + containers: + - name: volcano-agent + image: {{ .Values.basic.image_registry }}/{{.Values.basic.agent_image_name}}:{{.Values.basic.image_tag_version}} + command: + - /bin/sh + - '-c' + - /vc-agent --v=2 1>>/var/log/volcano/agent/volcano-agent.log 2>&1 + env: + - name: SYS_FS_PATH + value: /host/sys/fs + - name: CNI_CONF_FILE_PATH + value: /host{{ .Values.custom.agent_cni_config_path }} + - name: KUBE_NODE_NAME + valueFrom: + fieldRef: + apiVersion: v1 + fieldPath: spec.nodeName + - name: KUBE_POD_NAME + valueFrom: + fieldRef: + apiVersion: v1 + fieldPath: metadata.name + - name: KUBE_POD_NAMESPACE + valueFrom: + fieldRef: + apiVersion: v1 + fieldPath: metadata.namespace + {{- if .Values.custom.agent_resources }} + resources: + {{- toYaml .Values.custom.agent_resources | nindent 12 }} + {{- end }} + volumeMounts: + - name: bwm-dir + mountPath: /usr/share/bwmcli + - name: cni-plugin-dir + mountPath: /opt/cni/bin + - name: host-etc + mountPath: /host/etc + - mountPath: /var/log/volcano/agent + name: log + - name: host-sys-fs + mountPath: /host/sys/fs + mountPropagation: HostToContainer + - name: host-proc-sys + mountPath: /host/proc/sys + - name: localtime + readOnly: true + mountPath: /etc/localtime + - name: kubelet-cpu-manager-policy + readOnly: true + mountPath: /var/lib/kubelet + - name: proc-stat + readOnly: true + mountPath: /host/proc/stat + livenessProbe: + httpGet: + path: /healthz + port: 3300 + scheme: HTTP + initialDelaySeconds: 60 + timeoutSeconds: 5 + periodSeconds: 10 + successThreshold: 1 + failureThreshold: 5 + imagePullPolicy: {{ .Values.basic.image_pull_policy }} + updateStrategy: + type: RollingUpdate + rollingUpdate: + maxUnavailable: 10% + maxSurge: 0 + revisionHistoryLimit: 10 + +--- +apiVersion: v1 +kind: ServiceAccount +metadata: + labels: + app: volcano-agent + name: {{ .Release.Name }}-agent + namespace: {{ .Release.Namespace }} + +--- +kind: ClusterRole +apiVersion: rbac.authorization.k8s.io/v1 +metadata: + labels: + app: volcano-agent + name: {{ .Release.Name }}-agent +rules: + - apiGroups: [""] + resources: [ "nodes", "nodes/status" ] + verbs: [ "get", "list", "watch", "update", "patch" ] + - apiGroups: [ "" ] + resources: [ "secrets" ] + verbs: [ "get", "list", "watch" ] + - apiGroups: [ "" ] + resources: [ "configmaps" ] + verbs: [ "get", "list", "watch", "create", "update" ] + - apiGroups: [ "" ] + resources: [ "pods" ] + verbs: [ "get", "list", "watch" ] + - apiGroups: [ "" ] + resources: [ "pods/eviction" ] + verbs: [ "create" ] + - apiGroups: [ "" ] + resources: [ "configmaps" ] + verbs: ["get", "list", "watch" ] + - apiGroups: [ "" ] + resources: [ "events" ] + verbs: [ "list", "watch", "create", "update", "patch" ] + +--- +kind: ClusterRoleBinding +apiVersion: rbac.authorization.k8s.io/v1 +metadata: + labels: + app: volcano-agent + name: {{ .Release.Name }}-agent-role +subjects: + - kind: ServiceAccount + name: {{ .Release.Name }}-agent + namespace: {{ .Release.Namespace }} + - kind: User + apiGroup: rbac.authorization.k8s.io + name: {{ .Release.Name }}-agent +roleRef: + kind: ClusterRole + name: {{ .Release.Name }}-agent + apiGroup: rbac.authorization.k8s.io +{{- end }} \ No newline at end of file diff --git a/installer/helm/chart/volcano/values.yaml b/installer/helm/chart/volcano/values.yaml index 2da9920ff..4c0de2790 100644 --- a/installer/helm/chart/volcano/values.yaml +++ b/installer/helm/chart/volcano/values.yaml @@ -2,6 +2,7 @@ basic: controller_image_name: "volcanosh/vc-controller-manager" scheduler_image_name: "volcanosh/vc-scheduler" admission_image_name: "volcanosh/vc-webhook-manager" + agent_image_name: "volcanosh/vc-agent" admission_secret_name: "volcano-admission-secret" admission_config_file: "config/volcano-admission.conf" scheduler_config_file: "config/volcano-scheduler.conf" @@ -23,6 +24,7 @@ custom: scheduler_name: ~ leader_elect_enable: false enabled_admissions: "/jobs/mutate,/jobs/validate,/podgroups/mutate,/pods/validate,/pods/mutate,/queues/mutate,/queues/validate" + colocation_enable: false # Override the configuration for admission or scheduler. # For example: @@ -62,6 +64,7 @@ custom: admission_affinity: ~ controller_affinity: ~ scheduler_affinity: ~ + agent_affinity: ~ # Specify tolerations for all main Volcano components or per component # For example: @@ -74,6 +77,10 @@ custom: admission_tolerations: ~ controller_tolerations: ~ scheduler_tolerations: ~ + agent_tolerations: + - key: "volcano.sh/offline-job-evicting" + operator: "Exists" + effect: "NoSchedule" # Specify securityContext for all main Volcano components or per component # For example: @@ -85,6 +92,7 @@ custom: scheduler_sc: ~ admission_sc: ~ controller_sc: ~ + agent_sc: ~ # Specify nodeSelector for all main Volcano components or per component # For example: @@ -96,6 +104,7 @@ custom: scheduler_ns: ~ controller_ns: ~ kube_state_metrics_ns: ~ + agent_ns: ~ # Specify labels for Volcano main component deployments and pods # For example: @@ -123,6 +132,7 @@ custom: admission_resources: ~ scheduler_resources: ~ controller_resources: ~ + agent_resources: ~ # Specify additional namespace selector expressions for Volcano admission webhooks. @@ -161,6 +171,9 @@ custom: scheduler_default_csc: ~ controller_default_csc: ~ + # Specify agent cni config path. + agent_cni_config_path: /etc/cni/net.d/cni.conflist + service: # @param service.ipFamilyPolicy [string], support SingleStack, PreferDualStack and RequireDualStack # @@ -171,4 +184,6 @@ service: # ipFamilies: # - IPv6 # - IPv4 - ipFamilies: [] \ No newline at end of file + ipFamilies: [] + + diff --git a/installer/volcano-agent-development.yaml b/installer/volcano-agent-development.yaml new file mode 100644 index 000000000..7b8818510 --- /dev/null +++ b/installer/volcano-agent-development.yaml @@ -0,0 +1,214 @@ +--- +# Source: volcano/templates/agent.yaml +apiVersion: v1 +kind: ServiceAccount +metadata: + labels: + app: volcano-agent + name: volcano-agent + namespace: volcano-system +--- +# Source: volcano/templates/agent.yaml +kind: ClusterRole +apiVersion: rbac.authorization.k8s.io/v1 +metadata: + labels: + app: volcano-agent + name: volcano-agent +rules: + - apiGroups: [""] + resources: [ "nodes", "nodes/status" ] + verbs: [ "get", "list", "watch", "update", "patch" ] + - apiGroups: [ "" ] + resources: [ "secrets" ] + verbs: [ "get", "list", "watch" ] + - apiGroups: [ "" ] + resources: [ "configmaps" ] + verbs: [ "get", "list", "watch", "create", "update" ] + - apiGroups: [ "" ] + resources: [ "pods" ] + verbs: [ "get", "list", "watch" ] + - apiGroups: [ "" ] + resources: [ "pods/eviction" ] + verbs: [ "create" ] + - apiGroups: [ "" ] + resources: [ "configmaps" ] + verbs: ["get", "list", "watch" ] + - apiGroups: [ "" ] + resources: [ "events" ] + verbs: [ "list", "watch", "create", "update", "patch" ] +--- +# Source: volcano/templates/agent.yaml +kind: ClusterRoleBinding +apiVersion: rbac.authorization.k8s.io/v1 +metadata: + labels: + app: volcano-agent + name: volcano-agent-role +subjects: + - kind: ServiceAccount + name: volcano-agent + namespace: volcano-system + - kind: User + apiGroup: rbac.authorization.k8s.io + name: volcano-agent +roleRef: + kind: ClusterRole + name: volcano-agent + apiGroup: rbac.authorization.k8s.io +--- +# Source: volcano/templates/agent.yaml +apiVersion: apps/v1 +kind: DaemonSet +metadata: + name: volcano-agent + namespace: volcano-system +spec: + selector: + matchLabels: + name: volcano-agent + template: + metadata: + name: volcano-agent + labels: + name: volcano-agent + annotations: + prometheus.io/path: /metrics + prometheus.io/port: '3300' + prometheus.io/scheme: http + prometheus.io/scrape: 'true' + spec: + tolerations: + - effect: NoSchedule + key: volcano.sh/offline-job-evicting + operator: Exists + serviceAccountName: volcano-agent + hostNetwork: true + priorityClassName: system-node-critical + restartPolicy: Always + dnsPolicy: Default + volumes: + - name: bwm-dir + hostPath: + path: /usr/share/bwmcli/ + type: DirectoryOrCreate + - name: cni-plugin-dir + hostPath: + path: /opt/cni/bin + type: Directory + - name: host-etc + hostPath: + path: /etc + type: Directory + - name: host-sys-fs + hostPath: + path: /sys/fs + type: Directory + - name: host-proc-sys + hostPath: + path: /proc/sys + type: Directory + - name: log + hostPath: + path: /var/log/volcano/agent + type: '' + - name: localtime + hostPath: + path: /etc/localtime + type: '' + - name: kubelet-cpu-manager-policy + hostPath: + path: /var/lib/kubelet/ + type: '' + - name: proc-stat + hostPath: + path: /proc/stat + type: File + initContainers: + - name: volcano-agent-init + image: docker.io/volcanosh/vc-agent:latest + command: + - /bin/sh + - '-c' + - /usr/local/bin/install.sh + volumeMounts: + - name: bwm-dir + mountPath: /usr/share/bwmcli + - name: cni-plugin-dir + mountPath: /opt/cni/bin + - name: host-etc + mountPath: /host/etc + - mountPath: /var/log/volcano/agent + name: log + - name: host-proc-sys + mountPath: /host/proc/sys + terminationMessagePath: /dev/termination-log + terminationMessagePolicy: File + imagePullPolicy: Always + containers: + - name: volcano-agent + image: docker.io/volcanosh/vc-agent:latest + command: + - /bin/sh + - '-c' + - /vc-agent --v=2 1>>/var/log/volcano/agent/volcano-agent.log 2>&1 + env: + - name: SYS_FS_PATH + value: /host/sys/fs + - name: CNI_CONF_FILE_PATH + value: /host/etc/cni/net.d/cni.conflist + - name: KUBE_NODE_NAME + valueFrom: + fieldRef: + apiVersion: v1 + fieldPath: spec.nodeName + - name: KUBE_POD_NAME + valueFrom: + fieldRef: + apiVersion: v1 + fieldPath: metadata.name + - name: KUBE_POD_NAMESPACE + valueFrom: + fieldRef: + apiVersion: v1 + fieldPath: metadata.namespace + volumeMounts: + - name: bwm-dir + mountPath: /usr/share/bwmcli + - name: cni-plugin-dir + mountPath: /opt/cni/bin + - name: host-etc + mountPath: /host/etc + - mountPath: /var/log/volcano/agent + name: log + - name: host-sys-fs + mountPath: /host/sys/fs + mountPropagation: HostToContainer + - name: host-proc-sys + mountPath: /host/proc/sys + - name: localtime + readOnly: true + mountPath: /etc/localtime + - name: kubelet-cpu-manager-policy + readOnly: true + mountPath: /var/lib/kubelet + - name: proc-stat + readOnly: true + mountPath: /host/proc/stat + livenessProbe: + httpGet: + path: /healthz + port: 3300 + scheme: HTTP + initialDelaySeconds: 60 + timeoutSeconds: 5 + periodSeconds: 10 + successThreshold: 1 + failureThreshold: 5 + imagePullPolicy: Always + updateStrategy: + type: RollingUpdate + rollingUpdate: + maxUnavailable: 10% + maxSurge: 0 + revisionHistoryLimit: 10 diff --git a/licenses/github.com/asaskevich/govalidator/LICENSE b/licenses/github.com/asaskevich/govalidator/LICENSE index 2f9a31fad..cacba9102 100644 --- a/licenses/github.com/asaskevich/govalidator/LICENSE +++ b/licenses/github.com/asaskevich/govalidator/LICENSE @@ -1,6 +1,6 @@ The MIT License (MIT) -Copyright (c) 2014 Alex Saskevich +Copyright (c) 2014-2020 Alex Saskevich Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/licenses/github.com/bits-and-blooms/bitset/LICENSE b/licenses/github.com/bits-and-blooms/bitset/LICENSE new file mode 100644 index 000000000..59cab8a93 --- /dev/null +++ b/licenses/github.com/bits-and-blooms/bitset/LICENSE @@ -0,0 +1,27 @@ +Copyright (c) 2014 Will Fitzgerald. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/licenses/github.com/cilium/ebpf/LICENSE b/licenses/github.com/cilium/ebpf/LICENSE new file mode 100644 index 000000000..c637ae99c --- /dev/null +++ b/licenses/github.com/cilium/ebpf/LICENSE @@ -0,0 +1,23 @@ +MIT License + +Copyright (c) 2017 Nathan Sweet +Copyright (c) 2018, 2019 Cloudflare +Copyright (c) 2019 Authors of Cilium + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/licenses/github.com/containernetworking/cni/LICENSE b/licenses/github.com/containernetworking/cni/LICENSE new file mode 100644 index 000000000..8f71f43fe --- /dev/null +++ b/licenses/github.com/containernetworking/cni/LICENSE @@ -0,0 +1,202 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "{}" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright {yyyy} {name of copyright owner} + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + diff --git a/licenses/github.com/containernetworking/plugins/LICENSE b/licenses/github.com/containernetworking/plugins/LICENSE new file mode 100644 index 000000000..8dada3eda --- /dev/null +++ b/licenses/github.com/containernetworking/plugins/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "{}" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright {yyyy} {name of copyright owner} + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/licenses/github.com/cyphar/filepath-securejoin/LICENSE b/licenses/github.com/cyphar/filepath-securejoin/LICENSE new file mode 100644 index 000000000..bec842f29 --- /dev/null +++ b/licenses/github.com/cyphar/filepath-securejoin/LICENSE @@ -0,0 +1,28 @@ +Copyright (C) 2014-2015 Docker Inc & Go Authors. All rights reserved. +Copyright (C) 2017 SUSE LLC. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/licenses/github.com/godbus/dbus/v5/LICENSE b/licenses/github.com/godbus/dbus/v5/LICENSE new file mode 100644 index 000000000..670d88fca --- /dev/null +++ b/licenses/github.com/godbus/dbus/v5/LICENSE @@ -0,0 +1,25 @@ +Copyright (c) 2013, Georg Reinke (), Google +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright notice, +this list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright +notice, this list of conditions and the following disclaimer in the +documentation and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED +TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/licenses/github.com/opencontainers/runtime-spec/LICENSE b/licenses/github.com/opencontainers/runtime-spec/LICENSE new file mode 100644 index 000000000..bdc403653 --- /dev/null +++ b/licenses/github.com/opencontainers/runtime-spec/LICENSE @@ -0,0 +1,191 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + Copyright 2015 The Linux Foundation. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/licenses/github.com/prometheus/prometheus/LICENSE b/licenses/github.com/prometheus/prometheus/LICENSE new file mode 100644 index 000000000..261eeb9e9 --- /dev/null +++ b/licenses/github.com/prometheus/prometheus/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/licenses/github.com/sirupsen/logrus/LICENSE b/licenses/github.com/sirupsen/logrus/LICENSE new file mode 100644 index 000000000..f090cb42f --- /dev/null +++ b/licenses/github.com/sirupsen/logrus/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2014 Simon Eskildsen + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/licenses/github.com/vishvananda/netlink/LICENSE b/licenses/github.com/vishvananda/netlink/LICENSE new file mode 100644 index 000000000..9f64db858 --- /dev/null +++ b/licenses/github.com/vishvananda/netlink/LICENSE @@ -0,0 +1,192 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + Copyright 2014 Vishvananda Ishaya. + Copyright 2014 Docker, Inc. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/licenses/github.com/vishvananda/netns/LICENSE b/licenses/github.com/vishvananda/netns/LICENSE new file mode 100644 index 000000000..9f64db858 --- /dev/null +++ b/licenses/github.com/vishvananda/netns/LICENSE @@ -0,0 +1,192 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + Copyright 2014 Vishvananda Ishaya. + Copyright 2014 Docker, Inc. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/licenses/k8s.io/cri-api/LICENSE b/licenses/k8s.io/cri-api/LICENSE new file mode 100644 index 000000000..8dada3eda --- /dev/null +++ b/licenses/k8s.io/cri-api/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "{}" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright {yyyy} {name of copyright owner} + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/licenses/k8s.io/cri-client/LICENSE b/licenses/k8s.io/cri-client/LICENSE new file mode 100644 index 000000000..8dada3eda --- /dev/null +++ b/licenses/k8s.io/cri-client/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "{}" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright {yyyy} {name of copyright owner} + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License.

    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