diff --git a/vertical-pod-autoscaler/go.mod b/vertical-pod-autoscaler/go.mod index f72aa38b3a3e..d991e7f57f47 100644 --- a/vertical-pod-autoscaler/go.mod +++ b/vertical-pod-autoscaler/go.mod @@ -3,13 +3,14 @@ module k8s.io/autoscaler/vertical-pod-autoscaler go 1.21 require ( + github.com/argoproj/argo-rollouts v1.6.6 github.com/fsnotify/fsnotify v1.7.0 github.com/golang/mock v1.6.0 github.com/prometheus/client_golang v1.17.0 github.com/prometheus/client_model v0.4.1-0.20230718164431-9a2bf3000d16 github.com/prometheus/common v0.44.0 github.com/spf13/pflag v1.0.5 - github.com/stretchr/testify v1.8.2 + github.com/stretchr/testify v1.8.4 golang.org/x/time v0.4.0 k8s.io/api v0.28.3 k8s.io/apimachinery v0.28.3 @@ -27,7 +28,7 @@ require ( github.com/cespare/xxhash/v2 v2.2.0 // indirect github.com/davecgh/go-spew v1.1.1 // indirect github.com/emicklei/go-restful/v3 v3.10.1 // indirect - github.com/evanphx/json-patch v4.12.0+incompatible // indirect + github.com/evanphx/json-patch v5.6.0+incompatible // indirect github.com/go-logr/logr v1.2.4 // indirect github.com/go-openapi/jsonpointer v0.19.6 // indirect github.com/go-openapi/jsonreference v0.20.2 // indirect @@ -39,7 +40,7 @@ require ( github.com/google/go-cmp v0.5.9 // indirect github.com/google/gofuzz v1.2.0 // indirect github.com/google/uuid v1.3.0 // indirect - github.com/imdario/mergo v0.3.6 // indirect + github.com/imdario/mergo v0.3.13 // 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 @@ -55,7 +56,7 @@ require ( github.com/stretchr/objx v0.5.0 // indirect golang.org/x/mod v0.10.0 // indirect golang.org/x/net v0.21.0 // indirect - golang.org/x/oauth2 v0.8.0 // indirect + golang.org/x/oauth2 v0.10.0 // indirect golang.org/x/sys v0.17.0 // indirect golang.org/x/term v0.17.0 // indirect golang.org/x/text v0.14.0 // indirect diff --git a/vertical-pod-autoscaler/go.sum b/vertical-pod-autoscaler/go.sum index 5cf118b9f86e..836ee0de8317 100644 --- a/vertical-pod-autoscaler/go.sum +++ b/vertical-pod-autoscaler/go.sum @@ -1,3 +1,5 @@ +github.com/argoproj/argo-rollouts v1.6.6 h1:JCJ0cGAwWkh2xCAHZ1OQmrobysRjCatmG9IZaLJpS1g= +github.com/argoproj/argo-rollouts v1.6.6/go.mod h1:X2kTiBaYCSounmw1kmONdIZTwJNzNQYC0SrXUgSw9UI= 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/blang/semver/v4 v4.0.0 h1:1PFHFE6yCCTv8C1TeyNNarDzntLi7wMI5i/pzqYIsAM= @@ -11,8 +13,8 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/emicklei/go-restful/v3 v3.10.1 h1:rc42Y5YTp7Am7CS630D7JmhRjq4UlEUuEKfrDac4bSQ= github.com/emicklei/go-restful/v3 v3.10.1/go.mod h1:6n3XBCmQQb25CM2LCACGz8ukIrRry+4bhvbpWn3mrbc= -github.com/evanphx/json-patch v4.12.0+incompatible h1:4onqiflcdA9EOZ4RxV643DvftH5pOlLGNtQ5lPWQu84= -github.com/evanphx/json-patch v4.12.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk= +github.com/evanphx/json-patch v5.6.0+incompatible h1:jBYDEEiFBPxA0v50tFdvOzQQTCvpL6mnFh5mB2/l16U= +github.com/evanphx/json-patch v5.6.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk= 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/go-logr/logr v0.2.0/go.mod h1:z6/tIYblkpsD+a4lm/fGIIU9mZ+XfAiaFtq7xTgseGU= @@ -52,8 +54,8 @@ github.com/google/pprof v0.0.0-20210720184732-4bb14d4b1be1 h1:K6RDEckDVWvDI9JAJY github.com/google/pprof v0.0.0-20210720184732-4bb14d4b1be1/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I= github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/imdario/mergo v0.3.6 h1:xTNEAn+kxVO7dTZGu0CegyqKZmoWFI0rF8UxjlB2d28= -github.com/imdario/mergo v0.3.6/go.mod h1:2EnlNZ0deacrJVfApfmtdGgDfMuh/nq6Ok1EcJh5FfA= +github.com/imdario/mergo v0.3.13 h1:lFzP57bqS/wsqKssCGmtLAb8A0wKjLGrve2q3PPVcBk= +github.com/imdario/mergo v0.3.13/go.mod h1:4lJ1jqUDcsbIECGy0RUJAXNIhg+6ocWgb1ALK2O4oXg= github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8= github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY= @@ -116,8 +118,8 @@ github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UV 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= -github.com/stretchr/testify v1.8.2 h1:+h33VjcLVPDHtOdpUCuF+7gSuG3yGIftsP1YvFihtJ8= -github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= +github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= +github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= @@ -137,8 +139,8 @@ golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwY golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= golang.org/x/net v0.21.0 h1:AQyQV4dYCvJ7vGmJyKki9+PBdyvhkSd8EIx/qb0AYv4= golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44= -golang.org/x/oauth2 v0.8.0 h1:6dkIjl3j3LtZ/O3sTgZTMsLKSftL/B8Zgq4huOIIUu8= -golang.org/x/oauth2 v0.8.0/go.mod h1:yr7u4HXZRm1R1kBWqr/xKNqewf0plRYoB7sla+BCIXE= +golang.org/x/oauth2 v0.10.0 h1:zHCpF2Khkwy4mMB4bv0U37YtJdTGW8jI0glAApi0Kh8= +golang.org/x/oauth2 v0.10.0/go.mod h1:kTpgurOux7LqtuxjuyZa4Gj2gdezIt/jQtGnNFfypQI= golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/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= @@ -190,6 +192,7 @@ gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.0/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= k8s.io/api v0.28.3 h1:Gj1HtbSdB4P08C8rs9AR94MfSGpRhJgsS+GF9V26xMM= diff --git a/vertical-pod-autoscaler/pkg/admission-controller/main.go b/vertical-pod-autoscaler/pkg/admission-controller/main.go index 08aca96f0882..41a498120dde 100644 --- a/vertical-pod-autoscaler/pkg/admission-controller/main.go +++ b/vertical-pod-autoscaler/pkg/admission-controller/main.go @@ -44,6 +44,9 @@ import ( "k8s.io/autoscaler/vertical-pod-autoscaler/pkg/utils/server" "k8s.io/autoscaler/vertical-pod-autoscaler/pkg/utils/status" vpa_api_util "k8s.io/autoscaler/vertical-pod-autoscaler/pkg/utils/vpa" + + rolloutclientset "github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned" + rolloutinformers "github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions" ) const ( @@ -98,8 +101,10 @@ func main() { vpaLister := vpa_api_util.NewVpasLister(vpaClient, make(chan struct{}), commonFlags.VpaObjectNamespace) kubeClient := kube_client.NewForConfigOrDie(config) factory := informers.NewSharedInformerFactory(kubeClient, defaultResyncPeriod) - targetSelectorFetcher := target.NewVpaTargetSelectorFetcher(config, kubeClient, factory) - controllerFetcher := controllerfetcher.NewControllerFetcher(config, kubeClient, factory, scaleCacheEntryFreshnessTime, scaleCacheEntryLifetime, scaleCacheEntryJitterFactor) + rolloutClient := rolloutclientset.NewForConfigOrDie(config) + rolloutInformerFactory := rolloutinformers.NewSharedInformerFactory(rolloutClient, defaultResyncPeriod) + targetSelectorFetcher := target.NewVpaTargetSelectorFetcher(config, kubeClient, factory, rolloutInformerFactory) + controllerFetcher := controllerfetcher.NewControllerFetcher(config, kubeClient, factory, rolloutInformerFactory, scaleCacheEntryFreshnessTime, scaleCacheEntryLifetime, scaleCacheEntryJitterFactor) podPreprocessor := pod.NewDefaultPreProcessor() vpaPreprocessor := vpa.NewDefaultPreProcessor() var limitRangeCalculator limitrange.LimitRangeCalculator diff --git a/vertical-pod-autoscaler/pkg/recommender/main.go b/vertical-pod-autoscaler/pkg/recommender/main.go index afa7c1629375..724c3fc2a30c 100644 --- a/vertical-pod-autoscaler/pkg/recommender/main.go +++ b/vertical-pod-autoscaler/pkg/recommender/main.go @@ -53,6 +53,9 @@ import ( metrics_recommender "k8s.io/autoscaler/vertical-pod-autoscaler/pkg/utils/metrics/recommender" "k8s.io/autoscaler/vertical-pod-autoscaler/pkg/utils/server" vpa_api_util "k8s.io/autoscaler/vertical-pod-autoscaler/pkg/utils/vpa" + + rolloutclientset "github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned" + rolloutinformers "github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions" ) var ( @@ -197,7 +200,9 @@ func run(healthCheck *metrics.HealthCheck, commonFlag *common.CommonFlags) { kubeClient := kube_client.NewForConfigOrDie(config) clusterState := model.NewClusterState(aggregateContainerStateGCInterval) factory := informers.NewSharedInformerFactoryWithOptions(kubeClient, defaultResyncPeriod, informers.WithNamespace(commonFlag.IgnoredVpaObjectNamespaces)) - controllerFetcher := controllerfetcher.NewControllerFetcher(config, kubeClient, factory, scaleCacheEntryFreshnessTime, scaleCacheEntryLifetime, scaleCacheEntryJitterFactor) + rolloutClient := rolloutclientset.NewForConfigOrDie(config) + rolloutInformerFactory := rolloutinformers.NewSharedInformerFactory(rolloutClient, defaultResyncPeriod) + controllerFetcher := controllerfetcher.NewControllerFetcher(config, kubeClient, factory, rolloutInformerFactory, scaleCacheEntryFreshnessTime, scaleCacheEntryLifetime, scaleCacheEntryJitterFactor) podLister, oomObserver := input.NewPodListerAndOOMObserver(kubeClient, commonFlag.IgnoredVpaObjectNamespaces) model.InitializeAggregationsConfig(model.NewAggregationsConfig(*memoryAggregationInterval, *memoryAggregationIntervalCount, *memoryHistogramDecayHalfLife, *cpuHistogramDecayHalfLife, *oomBumpUpRatio, *oomMinBumpUp)) @@ -238,7 +243,7 @@ func run(healthCheck *metrics.HealthCheck, commonFlag *common.CommonFlags) { VpaCheckpointClient: vpa_clientset.NewForConfigOrDie(config).AutoscalingV1(), VpaLister: vpa_api_util.NewVpasLister(vpa_clientset.NewForConfigOrDie(config), make(chan struct{}), commonFlag.VpaObjectNamespace), ClusterState: clusterState, - SelectorFetcher: target.NewVpaTargetSelectorFetcher(config, kubeClient, factory), + SelectorFetcher: target.NewVpaTargetSelectorFetcher(config, kubeClient, factory, rolloutInformerFactory), MemorySaveMode: *memorySaver, ControllerFetcher: controllerFetcher, RecommenderName: *recommenderName, diff --git a/vertical-pod-autoscaler/pkg/target/controller_fetcher/controller_fetcher.go b/vertical-pod-autoscaler/pkg/target/controller_fetcher/controller_fetcher.go index 933f2680c50f..5102ce5ba3c1 100644 --- a/vertical-pod-autoscaler/pkg/target/controller_fetcher/controller_fetcher.go +++ b/vertical-pod-autoscaler/pkg/target/controller_fetcher/controller_fetcher.go @@ -40,6 +40,9 @@ import ( "k8s.io/client-go/scale" "k8s.io/client-go/tools/cache" klog "k8s.io/klog/v2" + + rolloutv1alpha1 "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1" + rolloutinformers "github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions" ) type wellKnownController string @@ -53,6 +56,7 @@ const ( replicaSet wellKnownController = "ReplicaSet" replicationController wellKnownController = "ReplicationController" statefulSet wellKnownController = "StatefulSet" + rollout wellKnownController = "Rollout" ) const ( @@ -108,7 +112,7 @@ func (f *controllerFetcher) Start(ctx context.Context, loopPeriod time.Duration) } // NewControllerFetcher returns a new instance of controllerFetcher -func NewControllerFetcher(config *rest.Config, kubeClient kube_client.Interface, factory informers.SharedInformerFactory, betweenRefreshes, lifeTime time.Duration, jitterFactor float64) *controllerFetcher { +func NewControllerFetcher(config *rest.Config, kubeClient kube_client.Interface, factory informers.SharedInformerFactory, rolloutFactory rolloutinformers.SharedInformerFactory, betweenRefreshes, lifeTime time.Duration, jitterFactor float64) *controllerFetcher { discoveryClient, err := discovery.NewDiscoveryClientForConfig(config) if err != nil { klog.Fatalf("Could not create discoveryClient: %v", err) @@ -129,6 +133,7 @@ func NewControllerFetcher(config *rest.Config, kubeClient kube_client.Interface, replicationController: factory.Core().V1().ReplicationControllers().Informer(), job: factory.Batch().V1().Jobs().Informer(), cronJob: factory.Batch().V1().CronJobs().Informer(), + rollout: rolloutFactory.Argoproj().V1alpha1().Rollouts().Informer(), } for kind, informer := range informersMap { @@ -194,6 +199,8 @@ func getParentOfWellKnownController(informer cache.SharedIndexInformer, controll return getOwnerController(apiObj.OwnerReferences, namespace), nil case (*corev1.ReplicationController): return getOwnerController(apiObj.OwnerReferences, namespace), nil + case (*rolloutv1alpha1.Rollout): + return getOwnerController(apiObj.OwnerReferences, namespace), nil } return nil, fmt.Errorf("don't know how to read owner controller") diff --git a/vertical-pod-autoscaler/pkg/target/fetcher.go b/vertical-pod-autoscaler/pkg/target/fetcher.go index 284bc5323cc9..25dda676c898 100644 --- a/vertical-pod-autoscaler/pkg/target/fetcher.go +++ b/vertical-pod-autoscaler/pkg/target/fetcher.go @@ -40,6 +40,9 @@ import ( "k8s.io/client-go/scale" "k8s.io/client-go/tools/cache" klog "k8s.io/klog/v2" + + rolloutv1alpha1 "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1" + rolloutinformers "github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions" ) const ( @@ -63,10 +66,11 @@ const ( replicationController wellKnownController = "ReplicationController" job wellKnownController = "Job" cronJob wellKnownController = "CronJob" + rollout wellKnownController = "Rollout" ) // NewVpaTargetSelectorFetcher returns new instance of VpaTargetSelectorFetcher -func NewVpaTargetSelectorFetcher(config *rest.Config, kubeClient kube_client.Interface, factory informers.SharedInformerFactory) VpaTargetSelectorFetcher { +func NewVpaTargetSelectorFetcher(config *rest.Config, kubeClient kube_client.Interface, factory informers.SharedInformerFactory, rolloutFactory rolloutinformers.SharedInformerFactory) VpaTargetSelectorFetcher { discoveryClient, err := discovery.NewDiscoveryClientForConfig(config) if err != nil { klog.Fatalf("Could not create discoveryClient: %v", err) @@ -87,6 +91,7 @@ func NewVpaTargetSelectorFetcher(config *rest.Config, kubeClient kube_client.Int replicationController: factory.Core().V1().ReplicationControllers().Informer(), job: factory.Batch().V1().Jobs().Informer(), cronJob: factory.Batch().V1().CronJobs().Informer(), + rollout: rolloutFactory.Argoproj().V1alpha1().Rollouts().Informer(), } for kind, informer := range informersMap { @@ -168,6 +173,8 @@ func getLabelSelector(informer cache.SharedIndexInformer, kind, namespace, name return metav1.LabelSelectorAsSelector(metav1.SetAsLabelSelector(apiObj.Spec.JobTemplate.Spec.Template.Labels)) case (*corev1.ReplicationController): return metav1.LabelSelectorAsSelector(metav1.SetAsLabelSelector(apiObj.Spec.Selector)) + case (*rolloutv1alpha1.Rollout): + return metav1.LabelSelectorAsSelector(apiObj.Spec.Selector) } return nil, fmt.Errorf("don't know how to read label selector") } diff --git a/vertical-pod-autoscaler/pkg/updater/main.go b/vertical-pod-autoscaler/pkg/updater/main.go index 762a301c1f8a..0e2d50255db5 100644 --- a/vertical-pod-autoscaler/pkg/updater/main.go +++ b/vertical-pod-autoscaler/pkg/updater/main.go @@ -47,6 +47,9 @@ import ( "k8s.io/autoscaler/vertical-pod-autoscaler/pkg/utils/server" "k8s.io/autoscaler/vertical-pod-autoscaler/pkg/utils/status" vpa_api_util "k8s.io/autoscaler/vertical-pod-autoscaler/pkg/utils/vpa" + + rolloutclientset "github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned" + rolloutinformers "github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions" ) var ( @@ -167,8 +170,10 @@ func run(healthCheck *metrics.HealthCheck, commonFlag *common.CommonFlags) { kubeClient := kube_client.NewForConfigOrDie(config) vpaClient := vpa_clientset.NewForConfigOrDie(config) factory := informers.NewSharedInformerFactory(kubeClient, defaultResyncPeriod) - targetSelectorFetcher := target.NewVpaTargetSelectorFetcher(config, kubeClient, factory) - controllerFetcher := controllerfetcher.NewControllerFetcher(config, kubeClient, factory, scaleCacheEntryFreshnessTime, scaleCacheEntryLifetime, scaleCacheEntryJitterFactor) + rolloutClient := rolloutclientset.NewForConfigOrDie(config) + rolloutInformerFactory := rolloutinformers.NewSharedInformerFactory(rolloutClient, defaultResyncPeriod) + targetSelectorFetcher := target.NewVpaTargetSelectorFetcher(config, kubeClient, factory, rolloutInformerFactory) + controllerFetcher := controllerfetcher.NewControllerFetcher(config, kubeClient, factory, rolloutInformerFactory, scaleCacheEntryFreshnessTime, scaleCacheEntryLifetime, scaleCacheEntryJitterFactor) var limitRangeCalculator limitrange.LimitRangeCalculator limitRangeCalculator, err := limitrange.NewLimitsRangeCalculator(factory) if err != nil { diff --git a/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/LICENSE b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/LICENSE new file mode 100644 index 000000000000..67e99b065bcd --- /dev/null +++ b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/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 2017-2018 The Argo 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. diff --git a/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/apis/rollouts/register.go b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/apis/rollouts/register.go new file mode 100644 index 000000000000..b6d4a03f0fdb --- /dev/null +++ b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/apis/rollouts/register.go @@ -0,0 +1,46 @@ +/* +Copyright 2017 The Kubernetes 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 rollouts + +const ( + Group string = "argoproj.io" + + RolloutKind string = "Rollout" + RolloutSingular string = "rollout" + RolloutPlural string = "rollouts" + RolloutFullName string = RolloutPlural + "." + Group + + ExperimentKind string = "Experiment" + ExperimentSingular string = "experiment" + ExperimentPlural string = "experiments" + ExperimentFullName string = ExperimentPlural + "." + Group + + AnalysisTemplateKind string = "AnalysisTemplate" + AnalysisTemplateSingular string = "analysistemplate" + AnalysisTemplatePlural string = "analysistemplates" + AnalysisTemplateFullName string = AnalysisTemplatePlural + "." + Group + + ClusterAnalysisTemplateKind string = "ClusterAnalysisTemplate" + ClusterAnalysisTemplateSingular string = "clusteranalysistemplate" + ClusterAnalysisTemplatePlural string = "clusteranalysistemplates" + ClusterAnalysisTemplateFullName string = ClusterAnalysisTemplatePlural + "." + Group + + AnalysisRunKind string = "AnalysisRun" + AnalysisRunSingular string = "analysisrun" + AnalysisRunPlural string = "analysisruns" + AnalysisRunFullName string = AnalysisRunPlural + "." + Group +) diff --git a/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1/analysis_types.go b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1/analysis_types.go new file mode 100644 index 000000000000..d7d1685d0431 --- /dev/null +++ b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1/analysis_types.go @@ -0,0 +1,557 @@ +package v1alpha1 + +import ( + "encoding/json" + "time" + + intstrutil "k8s.io/apimachinery/pkg/util/intstr" + + batchv1 "k8s.io/api/batch/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) + +// ClusterAnalysisTemplate holds the template for performing canary analysis +// +genclient +// +genclient:nonNamespaced +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +// +kubebuilder:resource:path=clusteranalysistemplates,shortName=cat,scope=Cluster +// +kubebuilder:printcolumn:name="Age",type="date",JSONPath=".metadata.creationTimestamp",description="Time since resource was created" +type ClusterAnalysisTemplate struct { + metav1.TypeMeta `json:",inline"` + metav1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"` + + Spec AnalysisTemplateSpec `json:"spec" protobuf:"bytes,2,opt,name=spec"` +} + +// AnalysisTemplateList is a list of AnalysisTemplate resources +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +type ClusterAnalysisTemplateList struct { + metav1.TypeMeta `json:",inline"` + metav1.ListMeta `json:"metadata" protobuf:"bytes,1,opt,name=metadata"` + Items []ClusterAnalysisTemplate `json:"items" protobuf:"bytes,2,rep,name=items"` +} + +// AnalysisTemplate holds the template for performing canary analysis +// +genclient +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +// +kubebuilder:resource:path=analysistemplates,shortName=at +// +kubebuilder:printcolumn:name="Age",type="date",JSONPath=".metadata.creationTimestamp",description="Time since resource was created" +type AnalysisTemplate struct { + metav1.TypeMeta `json:",inline"` + metav1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"` + + Spec AnalysisTemplateSpec `json:"spec" protobuf:"bytes,2,opt,name=spec"` +} + +// AnalysisTemplateList is a list of AnalysisTemplate resources +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +type AnalysisTemplateList struct { + metav1.TypeMeta `json:",inline"` + metav1.ListMeta `json:"metadata" protobuf:"bytes,1,opt,name=metadata"` + Items []AnalysisTemplate `json:"items" protobuf:"bytes,2,rep,name=items"` +} + +// AnalysisTemplateSpec is the specification for a AnalysisTemplate resource +type AnalysisTemplateSpec struct { + // Metrics contains the list of metrics to query as part of an analysis run + // +patchMergeKey=name + // +patchStrategy=merge + Metrics []Metric `json:"metrics" patchStrategy:"merge" patchMergeKey:"name" protobuf:"bytes,1,rep,name=metrics"` + // Args are the list of arguments to the template + // +patchMergeKey=name + // +patchStrategy=merge + // +optional + Args []Argument `json:"args,omitempty" patchStrategy:"merge" patchMergeKey:"name" protobuf:"bytes,2,rep,name=args"` + // DryRun object contains the settings for running the analysis in Dry-Run mode + // +patchMergeKey=metricName + // +patchStrategy=merge + // +optional + DryRun []DryRun `json:"dryRun,omitempty" patchStrategy:"merge" patchMergeKey:"metricName" protobuf:"bytes,3,rep,name=dryRun"` + // MeasurementRetention object contains the settings for retaining the number of measurements during the analysis + // +patchMergeKey=metricName + // +patchStrategy=merge + // +optional + MeasurementRetention []MeasurementRetention `json:"measurementRetention,omitempty" patchStrategy:"merge" patchMergeKey:"metricName" protobuf:"bytes,4,rep,name=measurementRetention"` +} + +// DurationString is a string representing a duration (e.g. 30s, 5m, 1h) +type DurationString string + +// Duration converts DurationString into a time.Duration +func (d DurationString) Duration() (time.Duration, error) { + return time.ParseDuration(string(d)) +} + +// Metric defines a metric in which to perform analysis +type Metric struct { + // Name is the name of the metric + Name string `json:"name" protobuf:"bytes,1,opt,name=name"` + // Interval defines an interval string (e.g. 30s, 5m, 1h) between each measurement. + // If omitted, will perform a single measurement + Interval DurationString `json:"interval,omitempty" protobuf:"bytes,2,opt,name=interval,casttype=DurationString"` + // InitialDelay how long the AnalysisRun should wait before starting this metric + InitialDelay DurationString `json:"initialDelay,omitempty" protobuf:"bytes,3,opt,name=initialDelay,casttype=DurationString"` + // Count is the number of times to run the measurement. If both interval and count are omitted, + // the effective count is 1. If only interval is specified, metric runs indefinitely. + // If count > 1, interval must be specified. + Count *intstrutil.IntOrString `json:"count,omitempty" protobuf:"bytes,4,opt,name=count"` + // SuccessCondition is an expression which determines if a measurement is considered successful + // Expression is a goevaluate expression. The keyword `result` is a variable reference to the + // value of measurement. Results can be both structured data or primitive. + // Examples: + // result > 10 + // (result.requests_made * result.requests_succeeded / 100) >= 90 + SuccessCondition string `json:"successCondition,omitempty" protobuf:"bytes,5,opt,name=successCondition"` + // FailureCondition is an expression which determines if a measurement is considered failed + // If both success and failure conditions are specified, and the measurement does not fall into + // either condition, the measurement is considered Inconclusive + FailureCondition string `json:"failureCondition,omitempty" protobuf:"bytes,6,opt,name=failureCondition"` + // FailureLimit is the maximum number of times the measurement is allowed to fail, before the + // entire metric is considered Failed (default: 0) + FailureLimit *intstrutil.IntOrString `json:"failureLimit,omitempty" protobuf:"bytes,7,opt,name=failureLimit"` + // InconclusiveLimit is the maximum number of times the measurement is allowed to measure + // Inconclusive, before the entire metric is considered Inconclusive (default: 0) + InconclusiveLimit *intstrutil.IntOrString `json:"inconclusiveLimit,omitempty" protobuf:"bytes,8,opt,name=inconclusiveLimit"` + // ConsecutiveErrorLimit is the maximum number of times the measurement is allowed to error in + // succession, before the metric is considered error (default: 4) + ConsecutiveErrorLimit *intstrutil.IntOrString `json:"consecutiveErrorLimit,omitempty" protobuf:"bytes,9,opt,name=consecutiveErrorLimit"` + // Provider configuration to the external system to use to verify the analysis + Provider MetricProvider `json:"provider" protobuf:"bytes,10,opt,name=provider"` +} + +// DryRun defines the settings for running the analysis in Dry-Run mode. +type DryRun struct { + // Name of the metric which needs to be evaluated in the Dry-Run mode. Wildcard '*' is supported and denotes all + // the available metrics. + MetricName string `json:"metricName" protobuf:"bytes,1,opt,name=metricName"` +} + +// MeasurementRetention defines the settings for retaining the number of measurements during the analysis. +type MeasurementRetention struct { + // MetricName is the name of the metric on which this retention policy should be applied. + MetricName string `json:"metricName" protobuf:"bytes,1,opt,name=metricName"` + // Limit is the maximum number of measurements to be retained for this given metric. + Limit int32 `json:"limit" protobuf:"varint,2,opt,name=limit"` +} + +// EffectiveCount is the effective count based on whether or not count/interval is specified +// If neither count or interval is specified, the effective count is 1 +// If only interval is specified, metric runs indefinitely and there is no effective count (nil) +// Otherwise, it is the user specified value +func (m *Metric) EffectiveCount() *intstrutil.IntOrString { + // Need to check if type is String + if m.Count == nil || m.Count.IntValue() == 0 { + if m.Interval == "" { + one := intstrutil.FromInt(1) + return &one + } + return nil + } + return m.Count +} + +// MetricProvider which external system to use to verify the analysis +// Only one of the fields in this struct should be non-nil +type MetricProvider struct { + // Prometheus specifies the prometheus metric to query + Prometheus *PrometheusMetric `json:"prometheus,omitempty" protobuf:"bytes,1,opt,name=prometheus"` + // Kayenta specifies a Kayenta metric + Kayenta *KayentaMetric `json:"kayenta,omitempty" protobuf:"bytes,2,opt,name=kayenta"` + // Web specifies a generic HTTP web metric + Web *WebMetric `json:"web,omitempty" protobuf:"bytes,3,opt,name=web"` + // Datadog specifies a datadog metric to query + Datadog *DatadogMetric `json:"datadog,omitempty" protobuf:"bytes,4,opt,name=datadog"` + // Wavefront specifies the wavefront metric to query + Wavefront *WavefrontMetric `json:"wavefront,omitempty" protobuf:"bytes,5,opt,name=wavefront"` + // NewRelic specifies the newrelic metric to query + NewRelic *NewRelicMetric `json:"newRelic,omitempty" protobuf:"bytes,6,opt,name=newRelic"` + // Job specifies the job metric run + Job *JobMetric `json:"job,omitempty" protobuf:"bytes,7,opt,name=job"` + // CloudWatch specifies the cloudWatch metric to query + CloudWatch *CloudWatchMetric `json:"cloudWatch,omitempty" protobuf:"bytes,8,opt,name=cloudWatch"` + // Graphite specifies the Graphite metric to query + Graphite *GraphiteMetric `json:"graphite,omitempty" protobuf:"bytes,9,opt,name=graphite"` + // Influxdb specifies the influxdb metric to query + Influxdb *InfluxdbMetric `json:"influxdb,omitempty" protobuf:"bytes,10,opt,name=influxdb"` + // SkyWalking specifies the skywalking metric to query + SkyWalking *SkyWalkingMetric `json:"skywalking,omitempty" protobuf:"bytes,11,opt,name=skywalking"` + // +kubebuilder:validation:Schemaless + // +kubebuilder:pruning:PreserveUnknownFields + // +kubebuilder:validation:Type=object + // Plugin specifies the hashicorp go-plugin metric to query + Plugin map[string]json.RawMessage `json:"plugin,omitempty" protobuf:"bytes,12,opt,name=plugin"` +} + +// AnalysisPhase is the overall phase of an AnalysisRun, MetricResult, or Measurement +type AnalysisPhase string + +// Possible AnalysisPhase values +const ( + AnalysisPhasePending AnalysisPhase = "Pending" + AnalysisPhaseRunning AnalysisPhase = "Running" + AnalysisPhaseSuccessful AnalysisPhase = "Successful" + AnalysisPhaseFailed AnalysisPhase = "Failed" + AnalysisPhaseError AnalysisPhase = "Error" + AnalysisPhaseInconclusive AnalysisPhase = "Inconclusive" +) + +// Completed returns whether or not the analysis status is considered completed +func (as AnalysisPhase) Completed() bool { + switch as { + case AnalysisPhaseSuccessful, AnalysisPhaseFailed, AnalysisPhaseError, AnalysisPhaseInconclusive: + return true + } + return false +} + +// PrometheusMetric defines the prometheus query to perform canary analysis +type PrometheusMetric struct { + // Address is the HTTP address and port of the prometheus server + Address string `json:"address,omitempty" protobuf:"bytes,1,opt,name=address"` + // Query is a raw prometheus query to perform + Query string `json:"query,omitempty" protobuf:"bytes,2,opt,name=query"` + // Sigv4 Config is the aws SigV4 configuration to use for SigV4 signing if using Amazon Managed Prometheus + // +optional + Authentication PrometheusAuth `json:"authentication,omitempty" protobuf:"bytes,3,opt,name=authentication"` + // Timeout represents the duration within which a prometheus query should complete. It is expressed in seconds. + // +optional + Timeout *int64 `json:"timeout,omitempty" protobuf:"bytes,4,opt,name=timeout"` + // Insecure skips host TLS verification + Insecure bool `json:"insecure,omitempty" protobuf:"varint,5,opt,name=insecure"` + // Headers are optional HTTP headers to use in the request + // +optional + // +patchMergeKey=key + // +patchStrategy=merge + Headers []WebMetricHeader `json:"headers,omitempty" patchStrategy:"merge" patchMergeKey:"key" protobuf:"bytes,6,opt,name=headers"` +} + +// PrometheusMetric defines the prometheus query to perform canary analysis +type PrometheusAuth struct { + // +optional + Sigv4 Sigv4Config `json:"sigv4,omitempty" protobuf:"bytes,3,opt,name=sigv4"` +} + +type Sigv4Config struct { + // Region is the AWS Region to sign the SigV4 Request + Region string `json:"region,omitempty" protobuf:"bytes,1,opt,name=address"` + // Profile is the Credential Profile used to sign the SigV4 Request + Profile string `json:"profile,omitempty" protobuf:"bytes,2,opt,name=profile"` + // RoleARN is the IAM role used to sign the SIgV4 Request + RoleARN string `json:"roleArn,omitempty" protobuf:"bytes,3,opt,name=roleArn"` +} + +// WavefrontMetric defines the wavefront query to perform canary analysis +type WavefrontMetric struct { + // Address is the HTTP address and port of the wavefront server + Address string `json:"address,omitempty" protobuf:"bytes,1,opt,name=address"` + // Query is a raw wavefront query to perform + Query string `json:"query,omitempty" protobuf:"bytes,2,opt,name=query"` +} + +// NewRelicMetric defines the newrelic query to perform canary analysis +type NewRelicMetric struct { + // Profile is the name of the secret holding NR account configuration + Profile string `json:"profile,omitempty" protobuf:"bytes,1,opt,name=profile"` + // Query is a raw newrelic NRQL query to perform + Query string `json:"query" protobuf:"bytes,2,opt,name=query"` +} + +// JobMetric defines a job to run which acts as a metric +type JobMetric struct { + Metadata metav1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"` + Spec batchv1.JobSpec `json:"spec" protobuf:"bytes,2,opt,name=spec"` +} + +// GraphiteMetric defines the Graphite query to perform canary analysis +type GraphiteMetric struct { + // Address is the HTTP address and port of the Graphite server + Address string `json:"address,omitempty" protobuf:"bytes,1,opt,name=address"` + // Query is a raw Graphite query to perform + Query string `json:"query,omitempty" protobuf:"bytes,2,opt,name=query"` +} + +// InfluxdbMetric defines the InfluxDB Flux query to perform canary analysis +type InfluxdbMetric struct { + // Profile is the name of the secret holding InfluxDB account configuration + Profile string `json:"profile,omitempty" protobuf:"bytes,1,opt,name=profile"` + // Query is a raw InfluxDB flux query to perform + Query string `json:"query,omitempty" protobuf:"bytes,2,opt,name=query"` +} + +// CloudWatchMetric defines the cloudwatch query to perform canary analysis +type CloudWatchMetric struct { + Interval DurationString `json:"interval,omitempty" protobuf:"bytes,1,opt,name=interval,casttype=DurationString"` + MetricDataQueries []CloudWatchMetricDataQuery `json:"metricDataQueries" protobuf:"bytes,2,rep,name=metricDataQueries"` +} + +// CloudWatchMetricDataQuery defines the cloudwatch query +type CloudWatchMetricDataQuery struct { + Id string `json:"id,omitempty" protobuf:"bytes,1,opt,name=id"` + Expression *string `json:"expression,omitempty" protobuf:"bytes,2,opt,name=expression"` + Label *string `json:"label,omitempty" protobuf:"bytes,3,opt,name=label"` + MetricStat *CloudWatchMetricStat `json:"metricStat,omitempty" protobuf:"bytes,4,opt,name=metricStat"` + Period *intstrutil.IntOrString `json:"period,omitempty" protobuf:"varint,5,opt,name=period"` + ReturnData *bool `json:"returnData,omitempty" protobuf:"bytes,6,opt,name=returnData"` +} + +type CloudWatchMetricStat struct { + Metric CloudWatchMetricStatMetric `json:"metric,omitempty" protobuf:"bytes,1,opt,name=metric"` + Period intstrutil.IntOrString `json:"period,omitempty" protobuf:"varint,2,opt,name=period"` + Stat string `json:"stat,omitempty" protobuf:"bytes,3,opt,name=stat"` + Unit string `json:"unit,omitempty" protobuf:"bytes,4,opt,name=unit"` +} + +type CloudWatchMetricStatMetric struct { + Dimensions []CloudWatchMetricStatMetricDimension `json:"dimensions,omitempty" protobuf:"bytes,1,rep,name=dimensions"` + MetricName string `json:"metricName,omitempty" protobuf:"bytes,2,opt,name=metricName"` + Namespace *string `json:"namespace,omitempty" protobuf:"bytes,3,opt,name=namespace"` +} + +type CloudWatchMetricStatMetricDimension struct { + Name string `json:"name,omitempty" protobuf:"bytes,1,opt,name=name"` + Value string `json:"value,omitempty" protobuf:"bytes,2,opt,name=value"` +} + +// AnalysisRun is an instantiation of an AnalysisTemplate +// +genclient +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +// +kubebuilder:resource:path=analysisruns, shortName=ar +// +kubebuilder:printcolumn:name="Status",type="string",JSONPath=".status.phase",description="AnalysisRun status" +// +kubebuilder:printcolumn:name="Age",type="date",JSONPath=".metadata.creationTimestamp",description="Time since resource was created" +type AnalysisRun struct { + metav1.TypeMeta `json:",inline"` + metav1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"` + Spec AnalysisRunSpec `json:"spec" protobuf:"bytes,2,opt,name=spec"` + Status AnalysisRunStatus `json:"status,omitempty" protobuf:"bytes,3,opt,name=status"` +} + +// AnalysisRunList is a list of AnalysisTemplate resources +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +type AnalysisRunList struct { + metav1.TypeMeta `json:",inline"` + metav1.ListMeta `json:"metadata" protobuf:"bytes,1,opt,name=metadata"` + Items []AnalysisRun `json:"items" protobuf:"bytes,2,rep,name=items"` +} + +type SkyWalkingMetric struct { + Address string `json:"address,omitempty" protobuf:"bytes,1,opt,name=address"` + Query string `json:"query,omitempty" protobuf:"bytes,2,opt,name=query"` + Interval DurationString `json:"interval,omitempty" protobuf:"bytes,3,opt,name=interval,casttype=DurationString"` +} + +// AnalysisRunSpec is the spec for a AnalysisRun resource +type AnalysisRunSpec struct { + // Metrics contains the list of metrics to query as part of an analysis run + // +patchMergeKey=name + // +patchStrategy=merge + Metrics []Metric `json:"metrics" patchStrategy:"merge" patchMergeKey:"name" protobuf:"bytes,1,rep,name=metrics"` + // Args are the list of arguments used in this run + // +optional + // +patchMergeKey=name + // +patchStrategy=merge + Args []Argument `json:"args,omitempty" patchStrategy:"merge" patchMergeKey:"name" protobuf:"bytes,2,rep,name=args"` + // Terminate is used to prematurely stop the run (e.g. rollout completed and analysis is no longer desired) + Terminate bool `json:"terminate,omitempty" protobuf:"varint,3,opt,name=terminate"` + // DryRun object contains the settings for running the analysis in Dry-Run mode + // +patchMergeKey=metricName + // +patchStrategy=merge + // +optional + DryRun []DryRun `json:"dryRun,omitempty" patchStrategy:"merge" patchMergeKey:"metricName" protobuf:"bytes,4,rep,name=dryRun"` + // MeasurementRetention object contains the settings for retaining the number of measurements during the analysis + // +patchMergeKey=metricName + // +patchStrategy=merge + // +optional + MeasurementRetention []MeasurementRetention `json:"measurementRetention,omitempty" patchStrategy:"merge" patchMergeKey:"metricName" protobuf:"bytes,5,rep,name=measurementRetention"` +} + +// Argument is an argument to an AnalysisRun +type Argument struct { + // Name is the name of the argument + Name string `json:"name" protobuf:"bytes,1,opt,name=name"` + // Value is the value of the argument + // +optional + Value *string `json:"value,omitempty" protobuf:"bytes,2,opt,name=value"` + // ValueFrom is a reference to where a secret is stored. This field is one of the fields with valueFrom + // +optional + ValueFrom *ValueFrom `json:"valueFrom,omitempty" protobuf:"bytes,3,opt,name=valueFrom"` +} + +type ValueFrom struct { + // Secret is a reference to where a secret is stored. This field is one of the fields with valueFrom + // +optional + SecretKeyRef *SecretKeyRef `json:"secretKeyRef,omitempty" protobuf:"bytes,1,opt,name=secretKeyRef"` + //FieldRef is a reference to the fields in metadata which we are referencing. This field is one of the fields with + //valueFrom + // +optional + FieldRef *FieldRef `json:"fieldRef,omitempty" protobuf:"bytes,2,opt,name=fieldRef"` +} + +type SecretKeyRef struct { + // Name is the name of the secret + Name string `json:"name" protobuf:"bytes,1,opt,name=name"` + // Key is the key of the secret to select from. + Key string `json:"key" protobuf:"bytes,2,opt,name=key"` +} + +// AnalysisRunStatus is the status for a AnalysisRun resource +type AnalysisRunStatus struct { + // Phase is the status of the analysis run + Phase AnalysisPhase `json:"phase" protobuf:"bytes,1,opt,name=phase,casttype=AnalysisPhase"` + // Message is a message explaining current status + Message string `json:"message,omitempty" protobuf:"bytes,2,opt,name=message"` + // MetricResults contains the metrics collected during the run + MetricResults []MetricResult `json:"metricResults,omitempty" protobuf:"bytes,3,rep,name=metricResults"` + // StartedAt indicates when the analysisRun first started + StartedAt *metav1.Time `json:"startedAt,omitempty" protobuf:"bytes,4,opt,name=startedAt"` + // RunSummary contains the final results from the metric executions + RunSummary RunSummary `json:"runSummary,omitempty" protobuf:"bytes,5,opt,name=runSummary"` + // DryRunSummary contains the final results from the metric executions in the dry-run mode + DryRunSummary *RunSummary `json:"dryRunSummary,omitempty" protobuf:"bytes,6,opt,name=dryRunSummary"` +} + +// RunSummary contains the final results from the metric executions +type RunSummary struct { + // This is equal to the sum of Successful, Failed, Inconclusive + Count int32 `json:"count,omitempty" protobuf:"varint,1,opt,name=count"` + // Successful is the number of times the metric was measured Successful + Successful int32 `json:"successful,omitempty" protobuf:"varint,2,opt,name=successful"` + // Failed is the number of times the metric was measured Failed + Failed int32 `json:"failed,omitempty" protobuf:"varint,3,opt,name=failed"` + // Inconclusive is the number of times the metric was measured Inconclusive + Inconclusive int32 `json:"inconclusive,omitempty" protobuf:"varint,4,opt,name=inconclusive"` + // Error is the number of times an error was encountered during measurement + Error int32 `json:"error,omitempty" protobuf:"varint,5,opt,name=error"` +} + +// MetricResult contain a list of the most recent measurements for a single metric along with +// counters on how often the measurement +type MetricResult struct { + // Name is the name of the metric + Name string `json:"name" protobuf:"bytes,1,opt,name=name"` + // Phase is the overall aggregate status of the metric + Phase AnalysisPhase `json:"phase" protobuf:"bytes,2,opt,name=phase,casttype=AnalysisPhase"` + // Measurements holds the most recent measurements collected for the metric + Measurements []Measurement `json:"measurements,omitempty" protobuf:"bytes,3,rep,name=measurements"` + // Message contains a message describing current condition (e.g. error messages) + Message string `json:"message,omitempty" protobuf:"bytes,4,opt,name=message"` + // Count is the number of times the metric was measured without Error + // This is equal to the sum of Successful, Failed, Inconclusive + Count int32 `json:"count,omitempty" protobuf:"varint,5,opt,name=count"` + // Successful is the number of times the metric was measured Successful + Successful int32 `json:"successful,omitempty" protobuf:"varint,6,opt,name=successful"` + // Failed is the number of times the metric was measured Failed + Failed int32 `json:"failed,omitempty" protobuf:"varint,7,opt,name=failed"` + // Inconclusive is the number of times the metric was measured Inconclusive + Inconclusive int32 `json:"inconclusive,omitempty" protobuf:"varint,8,opt,name=inconclusive"` + // Error is the number of times an error was encountered during measurement + Error int32 `json:"error,omitempty" protobuf:"varint,9,opt,name=error"` + // ConsecutiveError is the number of times an error was encountered during measurement in succession + // Resets to zero when non-errors are encountered + ConsecutiveError int32 `json:"consecutiveError,omitempty" protobuf:"varint,10,opt,name=consecutiveError"` + // DryRun indicates whether this metric is running in a dry-run mode or not + DryRun bool `json:"dryRun,omitempty" protobuf:"varint,11,opt,name=dryRun"` + // Metadata stores additional metadata about this metric. It is used by different providers to store + // the final state which gets used while taking measurements. For example, Prometheus uses this field + // to store the final resolved query after substituting the template arguments. + Metadata map[string]string `json:"metadata,omitempty" protobuf:"bytes,12,rep,name=metadata"` +} + +// Measurement is a point in time result value of a single metric, and the time it was measured +type Measurement struct { + // Phase is the status of this single measurement + Phase AnalysisPhase `json:"phase" protobuf:"bytes,1,opt,name=phase,casttype=AnalysisPhase"` + // Message contains a message describing current condition (e.g. error messages) + Message string `json:"message,omitempty" protobuf:"bytes,2,opt,name=message"` + // StartedAt is the timestamp in which this measurement started to be measured + StartedAt *metav1.Time `json:"startedAt,omitempty" protobuf:"bytes,3,opt,name=startedAt"` + // FinishedAt is the timestamp in which this measurement completed and value was collected + FinishedAt *metav1.Time `json:"finishedAt,omitempty" protobuf:"bytes,4,opt,name=finishedAt"` + // Value is the measured value of the metric + Value string `json:"value,omitempty" protobuf:"bytes,5,opt,name=value"` + // Metadata stores additional metadata about this metric result, used by the different providers + // (e.g. kayenta run ID, job name) + Metadata map[string]string `json:"metadata,omitempty" protobuf:"bytes,6,rep,name=metadata"` + // ResumeAt is the timestamp when the analysisRun should try to resume the measurement + ResumeAt *metav1.Time `json:"resumeAt,omitempty" protobuf:"bytes,7,opt,name=resumeAt"` +} + +type KayentaMetric struct { + Address string `json:"address" protobuf:"bytes,1,opt,name=address"` + + Application string `json:"application" protobuf:"bytes,2,opt,name=application"` + + CanaryConfigName string `json:"canaryConfigName" protobuf:"bytes,3,opt,name=canaryConfigName"` + + MetricsAccountName string `json:"metricsAccountName" protobuf:"bytes,4,opt,name=metricsAccountName"` + ConfigurationAccountName string `json:"configurationAccountName" protobuf:"bytes,5,opt,name=configurationAccountName"` + StorageAccountName string `json:"storageAccountName" protobuf:"bytes,6,opt,name=storageAccountName"` + + Threshold KayentaThreshold `json:"threshold" protobuf:"bytes,7,opt,name=threshold"` + + Scopes []KayentaScope `json:"scopes" protobuf:"bytes,8,rep,name=scopes"` +} + +type KayentaThreshold struct { + Pass int64 `json:"pass" protobuf:"varint,1,opt,name=pass"` + Marginal int64 `json:"marginal" protobuf:"varint,2,opt,name=marginal"` +} + +type KayentaScope struct { + Name string `json:"name" protobuf:"bytes,1,opt,name=name"` + ControlScope ScopeDetail `json:"controlScope" protobuf:"bytes,2,opt,name=controlScope"` + ExperimentScope ScopeDetail `json:"experimentScope" protobuf:"bytes,3,opt,name=experimentScope"` +} + +type ScopeDetail struct { + Scope string `json:"scope" protobuf:"bytes,1,opt,name=scope"` + Region string `json:"region" protobuf:"bytes,2,opt,name=region"` + Step int64 `json:"step" protobuf:"varint,3,opt,name=step"` + Start string `json:"start" protobuf:"bytes,4,opt,name=start"` + End string `json:"end" protobuf:"bytes,5,opt,name=end"` +} + +type WebMetric struct { + // Method is the method of the web metric (empty defaults to GET) + Method WebMetricMethod `json:"method,omitempty" protobuf:"bytes,1,opt,name=method"` + // URL is the address of the web metric + URL string `json:"url" protobuf:"bytes,2,opt,name=url"` + // +patchMergeKey=key + // +patchStrategy=merge + // Headers are optional HTTP headers to use in the request + Headers []WebMetricHeader `json:"headers,omitempty" patchStrategy:"merge" patchMergeKey:"key" protobuf:"bytes,3,rep,name=headers"` + // Body is the body of the web metric (must be POST/PUT) + Body string `json:"body,omitempty" protobuf:"bytes,4,opt,name=body"` + // TimeoutSeconds is the timeout for the request in seconds (default: 10) + TimeoutSeconds int64 `json:"timeoutSeconds,omitempty" protobuf:"varint,5,opt,name=timeoutSeconds"` + // JSONPath is a JSON Path to use as the result variable (default: "{$}") + JSONPath string `json:"jsonPath,omitempty" protobuf:"bytes,6,opt,name=jsonPath"` + // Insecure skips host TLS verification + Insecure bool `json:"insecure,omitempty" protobuf:"varint,7,opt,name=insecure"` + // +kubebuilder:validation:Schemaless + // +kubebuilder:pruning:PreserveUnknownFields + // +kubebuilder:validation:Type=object + // JSONBody is the body of the web metric in a json format (method must be POST/PUT) + JSONBody json.RawMessage `json:"jsonBody,omitempty" protobuf:"bytes,8,opt,name=jsonBody,casttype=encoding/json.RawMessage"` +} + +// WebMetricMethod is the available HTTP methods +type WebMetricMethod string + +// Possible HTTP method values +const ( + WebMetricMethodGet WebMetricMethod = "GET" + WebMetricMethodPost WebMetricMethod = "POST" + WebMetricMethodPut WebMetricMethod = "PUT" +) + +type WebMetricHeader struct { + Key string `json:"key" protobuf:"bytes,1,opt,name=key"` + Value string `json:"value" protobuf:"bytes,2,opt,name=value"` +} + +type DatadogMetric struct { + Interval DurationString `json:"interval,omitempty" protobuf:"bytes,1,opt,name=interval,casttype=DurationString"` + Query string `json:"query" protobuf:"bytes,2,opt,name=query"` + // ApiVersion refers to the Datadog API version being used (default: v1). v1 will eventually be deprecated. + ApiVersion string `json:"apiVersion,omitempty" protobuf:"bytes,3,opt,name=apiVersion"` +} diff --git a/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1/doc.go b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1/doc.go new file mode 100644 index 000000000000..e338befeafb6 --- /dev/null +++ b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1/doc.go @@ -0,0 +1,6 @@ +// +k8s:deepcopy-gen=package +// +groupName=argoproj.io +// +k8s:openapi-gen=true + +// Package v1alpha1 is the v1alpha1 version of the API. +package v1alpha1 diff --git a/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1/experiment_types.go b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1/experiment_types.go new file mode 100644 index 000000000000..b7183cbc4590 --- /dev/null +++ b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1/experiment_types.go @@ -0,0 +1,244 @@ +package v1alpha1 + +import ( + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) + +// Annotations that are labeled into the ReplicaSets that are part of an experiment +const ( + ExperimentNameAnnotationKey = "experiment.argoproj.io/name" + ExperimentTemplateNameAnnotationKey = "experiment.argoproj.io/template-name" +) + +// Experiment is a specification for an Experiment resource +// +genclient +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +// +kubebuilder:resource:path=experiments,shortName=exp +// +kubebuilder:printcolumn:name="Status",type="string",JSONPath=".status.phase",description="Experiment status" +// +kubebuilder:printcolumn:name="Age",type="date",JSONPath=".metadata.creationTimestamp",description="Time since resource was created" +type Experiment struct { + metav1.TypeMeta `json:",inline"` + metav1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"` + + Spec ExperimentSpec `json:"spec" protobuf:"bytes,2,opt,name=spec"` + Status ExperimentStatus `json:"status,omitempty" protobuf:"bytes,3,opt,name=status"` +} + +// ExperimentSpec is the spec for a Experiment resource +type ExperimentSpec struct { + // Templates are a list of PodSpecs that define the ReplicaSets that should be run during an experiment. + // +patchMergeKey=name + // +patchStrategy=merge + Templates []TemplateSpec `json:"templates" patchStrategy:"merge" patchMergeKey:"name" protobuf:"bytes,1,rep,name=templates"` + // Duration the amount of time for the experiment to run as a duration string (e.g. 30s, 5m, 1h). + // If omitted, the experiment will run indefinitely, stopped either via termination, or a failed analysis run. + // +optional + Duration DurationString `json:"duration,omitempty" protobuf:"bytes,2,opt,name=duration,casttype=DurationString"` + // ProgressDeadlineSeconds The maximum time in seconds for a experiment to + // make progress before it is considered to be failed. Argo Rollouts will + // continue to process failed experiments and a condition with a + // ProgressDeadlineExceeded reason will be surfaced in the experiment status. + // Defaults to 600s. + // +optional + ProgressDeadlineSeconds *int32 `json:"progressDeadlineSeconds,omitempty" protobuf:"varint,3,opt,name=progressDeadlineSeconds"` + // Terminate is used to prematurely stop the experiment + Terminate bool `json:"terminate,omitempty" protobuf:"varint,4,opt,name=terminate"` + // Analyses references AnalysisTemplates to run during the experiment + // +patchMergeKey=name + // +patchStrategy=merge + Analyses []ExperimentAnalysisTemplateRef `json:"analyses,omitempty" patchStrategy:"merge" patchMergeKey:"name" protobuf:"bytes,5,rep,name=analyses"` + // ScaleDownDelaySeconds adds a delay before scaling down the Experiment. + // If omitted, the Experiment waits 30 seconds before scaling down. + // A minimum of 30 seconds is recommended to ensure IP table propagation across the nodes in + // a cluster. See https://github.com/argoproj/argo-rollouts/issues/19#issuecomment-476329960 for + // more information + // +optional + ScaleDownDelaySeconds *int32 `json:"scaleDownDelaySeconds,omitempty" protobuf:"varint,6,opt,name=scaleDownDelaySeconds"` + // DryRun object contains the settings for running the analysis in Dry-Run mode + // +patchMergeKey=metricName + // +patchStrategy=merge + // +optional + DryRun []DryRun `json:"dryRun,omitempty" patchStrategy:"merge" patchMergeKey:"metricName" protobuf:"bytes,7,rep,name=dryRun"` + // MeasurementRetention object contains the settings for retaining the number of measurements during the analysis + // +patchMergeKey=metricName + // +patchStrategy=merge + // +optional + MeasurementRetention []MeasurementRetention `json:"measurementRetention,omitempty" patchStrategy:"merge" patchMergeKey:"metricName" protobuf:"bytes,8,rep,name=measurementRetention"` +} + +type TemplateSpec struct { + // Name of the template used to identity replicaset running for this experiment + Name string `json:"name" protobuf:"bytes,1,opt,name=name"` + // Number of desired pods. This is a pointer to distinguish between explicit + // zero and not specified. Defaults to 1. + // +optional + Replicas *int32 `json:"replicas,omitempty" protobuf:"varint,2,opt,name=replicas"` + // Minimum number of seconds for which a newly created pod should be ready + // without any of its container crashing, for it to be considered available. + // Defaults to 0 (pod will be considered available as soon as it is ready) + // +optional + MinReadySeconds int32 `json:"minReadySeconds,omitempty" protobuf:"varint,3,opt,name=minReadySeconds"` + // Label selector for pods. Existing ReplicaSets whose pods are + // selected by this will be the ones affected by this experiment. + // It must match the pod template's labels. Each selector must be unique to the other selectors in the other templates + Selector *metav1.LabelSelector `json:"selector" protobuf:"bytes,4,opt,name=selector"` + // Template describes the pods that will be created. + Template corev1.PodTemplateSpec `json:"template" protobuf:"bytes,5,opt,name=template"` + // TemplateService describes how a service should be generated for template + Service *TemplateService `json:"service,omitempty" protobuf:"bytes,6,opt,name=service"` +} + +type TemplateService struct { + // Name of the service generated by the experiment + Name string `json:"name,omitempty" protobuf:"bytes,1,opt,name=name"` +} + +type TemplateStatusCode string + +const ( + TemplateStatusProgressing TemplateStatusCode = "Progressing" + TemplateStatusRunning TemplateStatusCode = "Running" + TemplateStatusSuccessful TemplateStatusCode = "Successful" + TemplateStatusFailed TemplateStatusCode = "Failed" + TemplateStatusError TemplateStatusCode = "Error" +) + +func (ts TemplateStatusCode) Completed() bool { + switch ts { + case TemplateStatusSuccessful, TemplateStatusFailed, TemplateStatusError: + return true + } + return false +} + +// TemplateStatus is the status of a specific template of an Experiment +type TemplateStatus struct { + // Name of the template used to identity which hash to compare to the hash + Name string `json:"name" protobuf:"bytes,1,opt,name=name"` + // Total number of non-terminated pods targeted by this experiment (their labels match the selector). + Replicas int32 `json:"replicas" protobuf:"varint,2,opt,name=replicas"` + // Total number of non-terminated pods targeted by this experiment that have the desired template spec. + UpdatedReplicas int32 `json:"updatedReplicas" protobuf:"varint,3,opt,name=updatedReplicas"` + // Total number of ready pods targeted by this experiment. + ReadyReplicas int32 `json:"readyReplicas" protobuf:"varint,4,opt,name=readyReplicas"` + // Total number of available pods (ready for at least minReadySeconds) targeted by this experiment. + AvailableReplicas int32 `json:"availableReplicas" protobuf:"varint,5,opt,name=availableReplicas"` + // CollisionCount count of hash collisions for the Experiment. The Experiment controller uses this + // field as a collision avoidance mechanism when it needs to create the name for the + // newest ReplicaSet. + // +optional + CollisionCount *int32 `json:"collisionCount,omitempty" protobuf:"varint,6,opt,name=collisionCount"` + // Phase is the status of the ReplicaSet associated with the template + Status TemplateStatusCode `json:"status,omitempty" protobuf:"bytes,7,opt,name=status,casttype=TemplateStatusCode"` + // Message is a message explaining the current status + Message string `json:"message,omitempty" protobuf:"bytes,8,opt,name=message"` + // LastTransitionTime is the last time the replicaset transitioned, which resets the countdown + // on the ProgressDeadlineSeconds check. + LastTransitionTime *metav1.Time `json:"lastTransitionTime,omitempty" protobuf:"bytes,9,opt,name=lastTransitionTime"` + // ServiceName is the name of the service which corresponds to this experiment + ServiceName string `json:"serviceName,omitempty" protobuf:"bytes,10,opt,name=serviceName"` + // PodTemplateHash is the value of the Replicas' PodTemplateHash + PodTemplateHash string `json:"podTemplateHash,omitempty" protobuf:"bytes,11,opt,name=podTemplateHash"` +} + +// ExperimentStatus is the status for a Experiment resource +type ExperimentStatus struct { + // Phase is the status of the experiment. Takes into consideration ReplicaSet degradations and + // AnalysisRun statuses + Phase AnalysisPhase `json:"phase,omitempty" protobuf:"bytes,1,opt,name=phase,casttype=AnalysisPhase"` + // Message is an explanation for the current status + // +optional + Message string `json:"message,omitempty" protobuf:"bytes,2,opt,name=message"` + // TemplateStatuses holds the ReplicaSet related statuses for individual templates + // +optional + TemplateStatuses []TemplateStatus `json:"templateStatuses,omitempty" protobuf:"bytes,3,rep,name=templateStatuses"` + // AvailableAt the time when all the templates become healthy and the experiment should start tracking the time to + // run for the duration of specificed in the spec. + // +optional + AvailableAt *metav1.Time `json:"availableAt,omitempty" protobuf:"bytes,4,opt,name=availableAt"` + // Conditions a list of conditions a experiment can have. + // +optional + Conditions []ExperimentCondition `json:"conditions,omitempty" protobuf:"bytes,5,rep,name=conditions"` + // AnalysisRuns tracks the status of AnalysisRuns associated with this Experiment + // +optional + AnalysisRuns []ExperimentAnalysisRunStatus `json:"analysisRuns,omitempty" protobuf:"bytes,6,rep,name=analysisRuns"` +} + +// ExperimentConditionType defines the conditions of Experiment +type ExperimentConditionType string + +// These are valid conditions of a experiment. +const ( + // InvalidExperimentSpec means the experiment has an invalid spec and will not progress until + // the spec is fixed. + InvalidExperimentSpec ExperimentConditionType = "InvalidSpec" + // ExperimentCompleted means the experiment is available, ie. the active service is pointing at a + // replicaset with the required replicas up and running for at least minReadySeconds. + ExperimentCompleted ExperimentConditionType = "Completed" + // ExperimentProgressing means the experiment is progressing. Progress for a experiment is + // considered when a new replica set is created or adopted, when pods scale + // up or old pods scale down, or when the services are updated. Progress is not estimated + // for paused experiment. + ExperimentProgressing ExperimentConditionType = "Progressing" + // ExperimentRunning means that an experiment has reached the desired state and is running for the duration + // specified in the spec + ExperimentRunning ExperimentConditionType = "Running" + // ExperimentReplicaFailure ReplicaFailure is added in a experiment when one of its pods + // fails to be created or deleted. + ExperimentReplicaFailure ExperimentConditionType = "ReplicaFailure" +) + +// ExperimentCondition describes the state of a experiment at a certain point. +type ExperimentCondition struct { + // Type of deployment condition. + Type ExperimentConditionType `json:"type" protobuf:"bytes,1,opt,name=type,casttype=ExperimentConditionType"` + // Phase of the condition, one of True, False, Unknown. + Status corev1.ConditionStatus `json:"status" protobuf:"bytes,2,opt,name=status,casttype=k8s.io/api/core/v1.ConditionStatus"` + // The last time this condition was updated. + LastUpdateTime metav1.Time `json:"lastUpdateTime" protobuf:"bytes,3,opt,name=lastUpdateTime"` + // Last time the condition transitioned from one status to another. + LastTransitionTime metav1.Time `json:"lastTransitionTime" protobuf:"bytes,4,opt,name=lastTransitionTime"` + // The reason for the condition's last transition. + Reason string `json:"reason" protobuf:"bytes,5,opt,name=reason"` + // A human readable message indicating details about the transition. + Message string `json:"message" protobuf:"bytes,6,opt,name=message"` +} + +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// ExperimentList is a list of Experiment resources +type ExperimentList struct { + metav1.TypeMeta `json:",inline"` + metav1.ListMeta `json:"metadata" protobuf:"bytes,1,opt,name=metadata"` + + Items []Experiment `json:"items" protobuf:"bytes,2,rep,name=items"` +} + +type ExperimentAnalysisTemplateRef struct { + // Name is the name of the analysis + Name string `json:"name" protobuf:"bytes,1,opt,name=name"` + // TemplateName reference of the AnalysisTemplate name used by the Experiment to create the run + TemplateName string `json:"templateName" protobuf:"bytes,2,opt,name=templateName"` + // Whether to look for the templateName at cluster scope or namespace scope + // +optional + ClusterScope bool `json:"clusterScope,omitempty" protobuf:"varint,3,opt,name=clusterScope"` + // Args are the arguments that will be added to the AnalysisRuns + // +optional + // +patchMergeKey=name + // +patchStrategy=merge + Args []Argument `json:"args,omitempty" patchStrategy:"merge" patchMergeKey:"name" protobuf:"bytes,4,rep,name=args"` + // RequiredForCompletion blocks the Experiment from completing until the analysis has completed + RequiredForCompletion bool `json:"requiredForCompletion,omitempty" protobuf:"varint,5,opt,name=requiredForCompletion"` +} + +type ExperimentAnalysisRunStatus struct { + // Name is the name of the analysis + Name string `json:"name" protobuf:"bytes,1,opt,name=name"` + // AnalysisRun is the name of the AnalysisRun + AnalysisRun string `json:"analysisRun" protobuf:"bytes,2,opt,name=analysisRun"` + // Phase is the status of the AnalysisRun + Phase AnalysisPhase `json:"phase" protobuf:"bytes,3,opt,name=phase,casttype=AnalysisPhase"` + // Message is a message explaining the current status + Message string `json:"message,omitempty" protobuf:"bytes,4,opt,name=message"` +} diff --git a/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1/generated.pb.go b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1/generated.pb.go new file mode 100644 index 000000000000..20730ac1d5b1 --- /dev/null +++ b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1/generated.pb.go @@ -0,0 +1,34242 @@ +/* +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 protoc-gen-gogo. DO NOT EDIT. +// source: github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1/generated.proto + +package v1alpha1 + +import ( + encoding_json "encoding/json" + fmt "fmt" + + io "io" + + proto "github.com/gogo/protobuf/proto" + github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys" + k8s_io_api_core_v1 "k8s.io/api/core/v1" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + + math "math" + math_bits "math/bits" + reflect "reflect" + strings "strings" + + intstr "k8s.io/apimachinery/pkg/util/intstr" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +func (m *ALBStatus) Reset() { *m = ALBStatus{} } +func (*ALBStatus) ProtoMessage() {} +func (*ALBStatus) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{0} +} +func (m *ALBStatus) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ALBStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *ALBStatus) XXX_Merge(src proto.Message) { + xxx_messageInfo_ALBStatus.Merge(m, src) +} +func (m *ALBStatus) XXX_Size() int { + return m.Size() +} +func (m *ALBStatus) XXX_DiscardUnknown() { + xxx_messageInfo_ALBStatus.DiscardUnknown(m) +} + +var xxx_messageInfo_ALBStatus proto.InternalMessageInfo + +func (m *ALBTrafficRouting) Reset() { *m = ALBTrafficRouting{} } +func (*ALBTrafficRouting) ProtoMessage() {} +func (*ALBTrafficRouting) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{1} +} +func (m *ALBTrafficRouting) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ALBTrafficRouting) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *ALBTrafficRouting) XXX_Merge(src proto.Message) { + xxx_messageInfo_ALBTrafficRouting.Merge(m, src) +} +func (m *ALBTrafficRouting) XXX_Size() int { + return m.Size() +} +func (m *ALBTrafficRouting) XXX_DiscardUnknown() { + xxx_messageInfo_ALBTrafficRouting.DiscardUnknown(m) +} + +var xxx_messageInfo_ALBTrafficRouting proto.InternalMessageInfo + +func (m *AmbassadorTrafficRouting) Reset() { *m = AmbassadorTrafficRouting{} } +func (*AmbassadorTrafficRouting) ProtoMessage() {} +func (*AmbassadorTrafficRouting) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{2} +} +func (m *AmbassadorTrafficRouting) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AmbassadorTrafficRouting) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *AmbassadorTrafficRouting) XXX_Merge(src proto.Message) { + xxx_messageInfo_AmbassadorTrafficRouting.Merge(m, src) +} +func (m *AmbassadorTrafficRouting) XXX_Size() int { + return m.Size() +} +func (m *AmbassadorTrafficRouting) XXX_DiscardUnknown() { + xxx_messageInfo_AmbassadorTrafficRouting.DiscardUnknown(m) +} + +var xxx_messageInfo_AmbassadorTrafficRouting proto.InternalMessageInfo + +func (m *AnalysisRun) Reset() { *m = AnalysisRun{} } +func (*AnalysisRun) ProtoMessage() {} +func (*AnalysisRun) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{3} +} +func (m *AnalysisRun) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AnalysisRun) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *AnalysisRun) XXX_Merge(src proto.Message) { + xxx_messageInfo_AnalysisRun.Merge(m, src) +} +func (m *AnalysisRun) XXX_Size() int { + return m.Size() +} +func (m *AnalysisRun) XXX_DiscardUnknown() { + xxx_messageInfo_AnalysisRun.DiscardUnknown(m) +} + +var xxx_messageInfo_AnalysisRun proto.InternalMessageInfo + +func (m *AnalysisRunArgument) Reset() { *m = AnalysisRunArgument{} } +func (*AnalysisRunArgument) ProtoMessage() {} +func (*AnalysisRunArgument) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{4} +} +func (m *AnalysisRunArgument) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AnalysisRunArgument) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *AnalysisRunArgument) XXX_Merge(src proto.Message) { + xxx_messageInfo_AnalysisRunArgument.Merge(m, src) +} +func (m *AnalysisRunArgument) XXX_Size() int { + return m.Size() +} +func (m *AnalysisRunArgument) XXX_DiscardUnknown() { + xxx_messageInfo_AnalysisRunArgument.DiscardUnknown(m) +} + +var xxx_messageInfo_AnalysisRunArgument proto.InternalMessageInfo + +func (m *AnalysisRunList) Reset() { *m = AnalysisRunList{} } +func (*AnalysisRunList) ProtoMessage() {} +func (*AnalysisRunList) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{5} +} +func (m *AnalysisRunList) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AnalysisRunList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *AnalysisRunList) XXX_Merge(src proto.Message) { + xxx_messageInfo_AnalysisRunList.Merge(m, src) +} +func (m *AnalysisRunList) XXX_Size() int { + return m.Size() +} +func (m *AnalysisRunList) XXX_DiscardUnknown() { + xxx_messageInfo_AnalysisRunList.DiscardUnknown(m) +} + +var xxx_messageInfo_AnalysisRunList proto.InternalMessageInfo + +func (m *AnalysisRunMetadata) Reset() { *m = AnalysisRunMetadata{} } +func (*AnalysisRunMetadata) ProtoMessage() {} +func (*AnalysisRunMetadata) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{6} +} +func (m *AnalysisRunMetadata) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AnalysisRunMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *AnalysisRunMetadata) XXX_Merge(src proto.Message) { + xxx_messageInfo_AnalysisRunMetadata.Merge(m, src) +} +func (m *AnalysisRunMetadata) XXX_Size() int { + return m.Size() +} +func (m *AnalysisRunMetadata) XXX_DiscardUnknown() { + xxx_messageInfo_AnalysisRunMetadata.DiscardUnknown(m) +} + +var xxx_messageInfo_AnalysisRunMetadata proto.InternalMessageInfo + +func (m *AnalysisRunSpec) Reset() { *m = AnalysisRunSpec{} } +func (*AnalysisRunSpec) ProtoMessage() {} +func (*AnalysisRunSpec) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{7} +} +func (m *AnalysisRunSpec) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AnalysisRunSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *AnalysisRunSpec) XXX_Merge(src proto.Message) { + xxx_messageInfo_AnalysisRunSpec.Merge(m, src) +} +func (m *AnalysisRunSpec) XXX_Size() int { + return m.Size() +} +func (m *AnalysisRunSpec) XXX_DiscardUnknown() { + xxx_messageInfo_AnalysisRunSpec.DiscardUnknown(m) +} + +var xxx_messageInfo_AnalysisRunSpec proto.InternalMessageInfo + +func (m *AnalysisRunStatus) Reset() { *m = AnalysisRunStatus{} } +func (*AnalysisRunStatus) ProtoMessage() {} +func (*AnalysisRunStatus) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{8} +} +func (m *AnalysisRunStatus) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AnalysisRunStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *AnalysisRunStatus) XXX_Merge(src proto.Message) { + xxx_messageInfo_AnalysisRunStatus.Merge(m, src) +} +func (m *AnalysisRunStatus) XXX_Size() int { + return m.Size() +} +func (m *AnalysisRunStatus) XXX_DiscardUnknown() { + xxx_messageInfo_AnalysisRunStatus.DiscardUnknown(m) +} + +var xxx_messageInfo_AnalysisRunStatus proto.InternalMessageInfo + +func (m *AnalysisRunStrategy) Reset() { *m = AnalysisRunStrategy{} } +func (*AnalysisRunStrategy) ProtoMessage() {} +func (*AnalysisRunStrategy) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{9} +} +func (m *AnalysisRunStrategy) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AnalysisRunStrategy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *AnalysisRunStrategy) XXX_Merge(src proto.Message) { + xxx_messageInfo_AnalysisRunStrategy.Merge(m, src) +} +func (m *AnalysisRunStrategy) XXX_Size() int { + return m.Size() +} +func (m *AnalysisRunStrategy) XXX_DiscardUnknown() { + xxx_messageInfo_AnalysisRunStrategy.DiscardUnknown(m) +} + +var xxx_messageInfo_AnalysisRunStrategy proto.InternalMessageInfo + +func (m *AnalysisTemplate) Reset() { *m = AnalysisTemplate{} } +func (*AnalysisTemplate) ProtoMessage() {} +func (*AnalysisTemplate) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{10} +} +func (m *AnalysisTemplate) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AnalysisTemplate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *AnalysisTemplate) XXX_Merge(src proto.Message) { + xxx_messageInfo_AnalysisTemplate.Merge(m, src) +} +func (m *AnalysisTemplate) XXX_Size() int { + return m.Size() +} +func (m *AnalysisTemplate) XXX_DiscardUnknown() { + xxx_messageInfo_AnalysisTemplate.DiscardUnknown(m) +} + +var xxx_messageInfo_AnalysisTemplate proto.InternalMessageInfo + +func (m *AnalysisTemplateList) Reset() { *m = AnalysisTemplateList{} } +func (*AnalysisTemplateList) ProtoMessage() {} +func (*AnalysisTemplateList) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{11} +} +func (m *AnalysisTemplateList) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AnalysisTemplateList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *AnalysisTemplateList) XXX_Merge(src proto.Message) { + xxx_messageInfo_AnalysisTemplateList.Merge(m, src) +} +func (m *AnalysisTemplateList) XXX_Size() int { + return m.Size() +} +func (m *AnalysisTemplateList) XXX_DiscardUnknown() { + xxx_messageInfo_AnalysisTemplateList.DiscardUnknown(m) +} + +var xxx_messageInfo_AnalysisTemplateList proto.InternalMessageInfo + +func (m *AnalysisTemplateSpec) Reset() { *m = AnalysisTemplateSpec{} } +func (*AnalysisTemplateSpec) ProtoMessage() {} +func (*AnalysisTemplateSpec) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{12} +} +func (m *AnalysisTemplateSpec) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AnalysisTemplateSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *AnalysisTemplateSpec) XXX_Merge(src proto.Message) { + xxx_messageInfo_AnalysisTemplateSpec.Merge(m, src) +} +func (m *AnalysisTemplateSpec) XXX_Size() int { + return m.Size() +} +func (m *AnalysisTemplateSpec) XXX_DiscardUnknown() { + xxx_messageInfo_AnalysisTemplateSpec.DiscardUnknown(m) +} + +var xxx_messageInfo_AnalysisTemplateSpec proto.InternalMessageInfo + +func (m *AntiAffinity) Reset() { *m = AntiAffinity{} } +func (*AntiAffinity) ProtoMessage() {} +func (*AntiAffinity) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{13} +} +func (m *AntiAffinity) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AntiAffinity) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *AntiAffinity) XXX_Merge(src proto.Message) { + xxx_messageInfo_AntiAffinity.Merge(m, src) +} +func (m *AntiAffinity) XXX_Size() int { + return m.Size() +} +func (m *AntiAffinity) XXX_DiscardUnknown() { + xxx_messageInfo_AntiAffinity.DiscardUnknown(m) +} + +var xxx_messageInfo_AntiAffinity proto.InternalMessageInfo + +func (m *ApisixRoute) Reset() { *m = ApisixRoute{} } +func (*ApisixRoute) ProtoMessage() {} +func (*ApisixRoute) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{14} +} +func (m *ApisixRoute) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ApisixRoute) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *ApisixRoute) XXX_Merge(src proto.Message) { + xxx_messageInfo_ApisixRoute.Merge(m, src) +} +func (m *ApisixRoute) XXX_Size() int { + return m.Size() +} +func (m *ApisixRoute) XXX_DiscardUnknown() { + xxx_messageInfo_ApisixRoute.DiscardUnknown(m) +} + +var xxx_messageInfo_ApisixRoute proto.InternalMessageInfo + +func (m *ApisixTrafficRouting) Reset() { *m = ApisixTrafficRouting{} } +func (*ApisixTrafficRouting) ProtoMessage() {} +func (*ApisixTrafficRouting) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{15} +} +func (m *ApisixTrafficRouting) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ApisixTrafficRouting) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *ApisixTrafficRouting) XXX_Merge(src proto.Message) { + xxx_messageInfo_ApisixTrafficRouting.Merge(m, src) +} +func (m *ApisixTrafficRouting) XXX_Size() int { + return m.Size() +} +func (m *ApisixTrafficRouting) XXX_DiscardUnknown() { + xxx_messageInfo_ApisixTrafficRouting.DiscardUnknown(m) +} + +var xxx_messageInfo_ApisixTrafficRouting proto.InternalMessageInfo + +func (m *AppMeshTrafficRouting) Reset() { *m = AppMeshTrafficRouting{} } +func (*AppMeshTrafficRouting) ProtoMessage() {} +func (*AppMeshTrafficRouting) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{16} +} +func (m *AppMeshTrafficRouting) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AppMeshTrafficRouting) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *AppMeshTrafficRouting) XXX_Merge(src proto.Message) { + xxx_messageInfo_AppMeshTrafficRouting.Merge(m, src) +} +func (m *AppMeshTrafficRouting) XXX_Size() int { + return m.Size() +} +func (m *AppMeshTrafficRouting) XXX_DiscardUnknown() { + xxx_messageInfo_AppMeshTrafficRouting.DiscardUnknown(m) +} + +var xxx_messageInfo_AppMeshTrafficRouting proto.InternalMessageInfo + +func (m *AppMeshVirtualNodeGroup) Reset() { *m = AppMeshVirtualNodeGroup{} } +func (*AppMeshVirtualNodeGroup) ProtoMessage() {} +func (*AppMeshVirtualNodeGroup) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{17} +} +func (m *AppMeshVirtualNodeGroup) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AppMeshVirtualNodeGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *AppMeshVirtualNodeGroup) XXX_Merge(src proto.Message) { + xxx_messageInfo_AppMeshVirtualNodeGroup.Merge(m, src) +} +func (m *AppMeshVirtualNodeGroup) XXX_Size() int { + return m.Size() +} +func (m *AppMeshVirtualNodeGroup) XXX_DiscardUnknown() { + xxx_messageInfo_AppMeshVirtualNodeGroup.DiscardUnknown(m) +} + +var xxx_messageInfo_AppMeshVirtualNodeGroup proto.InternalMessageInfo + +func (m *AppMeshVirtualNodeReference) Reset() { *m = AppMeshVirtualNodeReference{} } +func (*AppMeshVirtualNodeReference) ProtoMessage() {} +func (*AppMeshVirtualNodeReference) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{18} +} +func (m *AppMeshVirtualNodeReference) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AppMeshVirtualNodeReference) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *AppMeshVirtualNodeReference) XXX_Merge(src proto.Message) { + xxx_messageInfo_AppMeshVirtualNodeReference.Merge(m, src) +} +func (m *AppMeshVirtualNodeReference) XXX_Size() int { + return m.Size() +} +func (m *AppMeshVirtualNodeReference) XXX_DiscardUnknown() { + xxx_messageInfo_AppMeshVirtualNodeReference.DiscardUnknown(m) +} + +var xxx_messageInfo_AppMeshVirtualNodeReference proto.InternalMessageInfo + +func (m *AppMeshVirtualService) Reset() { *m = AppMeshVirtualService{} } +func (*AppMeshVirtualService) ProtoMessage() {} +func (*AppMeshVirtualService) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{19} +} +func (m *AppMeshVirtualService) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AppMeshVirtualService) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *AppMeshVirtualService) XXX_Merge(src proto.Message) { + xxx_messageInfo_AppMeshVirtualService.Merge(m, src) +} +func (m *AppMeshVirtualService) XXX_Size() int { + return m.Size() +} +func (m *AppMeshVirtualService) XXX_DiscardUnknown() { + xxx_messageInfo_AppMeshVirtualService.DiscardUnknown(m) +} + +var xxx_messageInfo_AppMeshVirtualService proto.InternalMessageInfo + +func (m *Argument) Reset() { *m = Argument{} } +func (*Argument) ProtoMessage() {} +func (*Argument) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{20} +} +func (m *Argument) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Argument) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *Argument) XXX_Merge(src proto.Message) { + xxx_messageInfo_Argument.Merge(m, src) +} +func (m *Argument) XXX_Size() int { + return m.Size() +} +func (m *Argument) XXX_DiscardUnknown() { + xxx_messageInfo_Argument.DiscardUnknown(m) +} + +var xxx_messageInfo_Argument proto.InternalMessageInfo + +func (m *ArgumentValueFrom) Reset() { *m = ArgumentValueFrom{} } +func (*ArgumentValueFrom) ProtoMessage() {} +func (*ArgumentValueFrom) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{21} +} +func (m *ArgumentValueFrom) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ArgumentValueFrom) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *ArgumentValueFrom) XXX_Merge(src proto.Message) { + xxx_messageInfo_ArgumentValueFrom.Merge(m, src) +} +func (m *ArgumentValueFrom) XXX_Size() int { + return m.Size() +} +func (m *ArgumentValueFrom) XXX_DiscardUnknown() { + xxx_messageInfo_ArgumentValueFrom.DiscardUnknown(m) +} + +var xxx_messageInfo_ArgumentValueFrom proto.InternalMessageInfo + +func (m *AwsResourceRef) Reset() { *m = AwsResourceRef{} } +func (*AwsResourceRef) ProtoMessage() {} +func (*AwsResourceRef) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{22} +} +func (m *AwsResourceRef) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AwsResourceRef) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *AwsResourceRef) XXX_Merge(src proto.Message) { + xxx_messageInfo_AwsResourceRef.Merge(m, src) +} +func (m *AwsResourceRef) XXX_Size() int { + return m.Size() +} +func (m *AwsResourceRef) XXX_DiscardUnknown() { + xxx_messageInfo_AwsResourceRef.DiscardUnknown(m) +} + +var xxx_messageInfo_AwsResourceRef proto.InternalMessageInfo + +func (m *BlueGreenStatus) Reset() { *m = BlueGreenStatus{} } +func (*BlueGreenStatus) ProtoMessage() {} +func (*BlueGreenStatus) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{23} +} +func (m *BlueGreenStatus) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *BlueGreenStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *BlueGreenStatus) XXX_Merge(src proto.Message) { + xxx_messageInfo_BlueGreenStatus.Merge(m, src) +} +func (m *BlueGreenStatus) XXX_Size() int { + return m.Size() +} +func (m *BlueGreenStatus) XXX_DiscardUnknown() { + xxx_messageInfo_BlueGreenStatus.DiscardUnknown(m) +} + +var xxx_messageInfo_BlueGreenStatus proto.InternalMessageInfo + +func (m *BlueGreenStrategy) Reset() { *m = BlueGreenStrategy{} } +func (*BlueGreenStrategy) ProtoMessage() {} +func (*BlueGreenStrategy) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{24} +} +func (m *BlueGreenStrategy) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *BlueGreenStrategy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *BlueGreenStrategy) XXX_Merge(src proto.Message) { + xxx_messageInfo_BlueGreenStrategy.Merge(m, src) +} +func (m *BlueGreenStrategy) XXX_Size() int { + return m.Size() +} +func (m *BlueGreenStrategy) XXX_DiscardUnknown() { + xxx_messageInfo_BlueGreenStrategy.DiscardUnknown(m) +} + +var xxx_messageInfo_BlueGreenStrategy proto.InternalMessageInfo + +func (m *CanaryStatus) Reset() { *m = CanaryStatus{} } +func (*CanaryStatus) ProtoMessage() {} +func (*CanaryStatus) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{25} +} +func (m *CanaryStatus) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CanaryStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *CanaryStatus) XXX_Merge(src proto.Message) { + xxx_messageInfo_CanaryStatus.Merge(m, src) +} +func (m *CanaryStatus) XXX_Size() int { + return m.Size() +} +func (m *CanaryStatus) XXX_DiscardUnknown() { + xxx_messageInfo_CanaryStatus.DiscardUnknown(m) +} + +var xxx_messageInfo_CanaryStatus proto.InternalMessageInfo + +func (m *CanaryStep) Reset() { *m = CanaryStep{} } +func (*CanaryStep) ProtoMessage() {} +func (*CanaryStep) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{26} +} +func (m *CanaryStep) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CanaryStep) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *CanaryStep) XXX_Merge(src proto.Message) { + xxx_messageInfo_CanaryStep.Merge(m, src) +} +func (m *CanaryStep) XXX_Size() int { + return m.Size() +} +func (m *CanaryStep) XXX_DiscardUnknown() { + xxx_messageInfo_CanaryStep.DiscardUnknown(m) +} + +var xxx_messageInfo_CanaryStep proto.InternalMessageInfo + +func (m *CanaryStrategy) Reset() { *m = CanaryStrategy{} } +func (*CanaryStrategy) ProtoMessage() {} +func (*CanaryStrategy) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{27} +} +func (m *CanaryStrategy) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CanaryStrategy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *CanaryStrategy) XXX_Merge(src proto.Message) { + xxx_messageInfo_CanaryStrategy.Merge(m, src) +} +func (m *CanaryStrategy) XXX_Size() int { + return m.Size() +} +func (m *CanaryStrategy) XXX_DiscardUnknown() { + xxx_messageInfo_CanaryStrategy.DiscardUnknown(m) +} + +var xxx_messageInfo_CanaryStrategy proto.InternalMessageInfo + +func (m *CloudWatchMetric) Reset() { *m = CloudWatchMetric{} } +func (*CloudWatchMetric) ProtoMessage() {} +func (*CloudWatchMetric) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{28} +} +func (m *CloudWatchMetric) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CloudWatchMetric) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *CloudWatchMetric) XXX_Merge(src proto.Message) { + xxx_messageInfo_CloudWatchMetric.Merge(m, src) +} +func (m *CloudWatchMetric) XXX_Size() int { + return m.Size() +} +func (m *CloudWatchMetric) XXX_DiscardUnknown() { + xxx_messageInfo_CloudWatchMetric.DiscardUnknown(m) +} + +var xxx_messageInfo_CloudWatchMetric proto.InternalMessageInfo + +func (m *CloudWatchMetricDataQuery) Reset() { *m = CloudWatchMetricDataQuery{} } +func (*CloudWatchMetricDataQuery) ProtoMessage() {} +func (*CloudWatchMetricDataQuery) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{29} +} +func (m *CloudWatchMetricDataQuery) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CloudWatchMetricDataQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *CloudWatchMetricDataQuery) XXX_Merge(src proto.Message) { + xxx_messageInfo_CloudWatchMetricDataQuery.Merge(m, src) +} +func (m *CloudWatchMetricDataQuery) XXX_Size() int { + return m.Size() +} +func (m *CloudWatchMetricDataQuery) XXX_DiscardUnknown() { + xxx_messageInfo_CloudWatchMetricDataQuery.DiscardUnknown(m) +} + +var xxx_messageInfo_CloudWatchMetricDataQuery proto.InternalMessageInfo + +func (m *CloudWatchMetricStat) Reset() { *m = CloudWatchMetricStat{} } +func (*CloudWatchMetricStat) ProtoMessage() {} +func (*CloudWatchMetricStat) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{30} +} +func (m *CloudWatchMetricStat) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CloudWatchMetricStat) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *CloudWatchMetricStat) XXX_Merge(src proto.Message) { + xxx_messageInfo_CloudWatchMetricStat.Merge(m, src) +} +func (m *CloudWatchMetricStat) XXX_Size() int { + return m.Size() +} +func (m *CloudWatchMetricStat) XXX_DiscardUnknown() { + xxx_messageInfo_CloudWatchMetricStat.DiscardUnknown(m) +} + +var xxx_messageInfo_CloudWatchMetricStat proto.InternalMessageInfo + +func (m *CloudWatchMetricStatMetric) Reset() { *m = CloudWatchMetricStatMetric{} } +func (*CloudWatchMetricStatMetric) ProtoMessage() {} +func (*CloudWatchMetricStatMetric) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{31} +} +func (m *CloudWatchMetricStatMetric) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CloudWatchMetricStatMetric) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *CloudWatchMetricStatMetric) XXX_Merge(src proto.Message) { + xxx_messageInfo_CloudWatchMetricStatMetric.Merge(m, src) +} +func (m *CloudWatchMetricStatMetric) XXX_Size() int { + return m.Size() +} +func (m *CloudWatchMetricStatMetric) XXX_DiscardUnknown() { + xxx_messageInfo_CloudWatchMetricStatMetric.DiscardUnknown(m) +} + +var xxx_messageInfo_CloudWatchMetricStatMetric proto.InternalMessageInfo + +func (m *CloudWatchMetricStatMetricDimension) Reset() { *m = CloudWatchMetricStatMetricDimension{} } +func (*CloudWatchMetricStatMetricDimension) ProtoMessage() {} +func (*CloudWatchMetricStatMetricDimension) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{32} +} +func (m *CloudWatchMetricStatMetricDimension) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CloudWatchMetricStatMetricDimension) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *CloudWatchMetricStatMetricDimension) XXX_Merge(src proto.Message) { + xxx_messageInfo_CloudWatchMetricStatMetricDimension.Merge(m, src) +} +func (m *CloudWatchMetricStatMetricDimension) XXX_Size() int { + return m.Size() +} +func (m *CloudWatchMetricStatMetricDimension) XXX_DiscardUnknown() { + xxx_messageInfo_CloudWatchMetricStatMetricDimension.DiscardUnknown(m) +} + +var xxx_messageInfo_CloudWatchMetricStatMetricDimension proto.InternalMessageInfo + +func (m *ClusterAnalysisTemplate) Reset() { *m = ClusterAnalysisTemplate{} } +func (*ClusterAnalysisTemplate) ProtoMessage() {} +func (*ClusterAnalysisTemplate) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{33} +} +func (m *ClusterAnalysisTemplate) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ClusterAnalysisTemplate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *ClusterAnalysisTemplate) XXX_Merge(src proto.Message) { + xxx_messageInfo_ClusterAnalysisTemplate.Merge(m, src) +} +func (m *ClusterAnalysisTemplate) XXX_Size() int { + return m.Size() +} +func (m *ClusterAnalysisTemplate) XXX_DiscardUnknown() { + xxx_messageInfo_ClusterAnalysisTemplate.DiscardUnknown(m) +} + +var xxx_messageInfo_ClusterAnalysisTemplate proto.InternalMessageInfo + +func (m *ClusterAnalysisTemplateList) Reset() { *m = ClusterAnalysisTemplateList{} } +func (*ClusterAnalysisTemplateList) ProtoMessage() {} +func (*ClusterAnalysisTemplateList) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{34} +} +func (m *ClusterAnalysisTemplateList) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ClusterAnalysisTemplateList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *ClusterAnalysisTemplateList) XXX_Merge(src proto.Message) { + xxx_messageInfo_ClusterAnalysisTemplateList.Merge(m, src) +} +func (m *ClusterAnalysisTemplateList) XXX_Size() int { + return m.Size() +} +func (m *ClusterAnalysisTemplateList) XXX_DiscardUnknown() { + xxx_messageInfo_ClusterAnalysisTemplateList.DiscardUnknown(m) +} + +var xxx_messageInfo_ClusterAnalysisTemplateList proto.InternalMessageInfo + +func (m *DatadogMetric) Reset() { *m = DatadogMetric{} } +func (*DatadogMetric) ProtoMessage() {} +func (*DatadogMetric) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{35} +} +func (m *DatadogMetric) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DatadogMetric) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *DatadogMetric) XXX_Merge(src proto.Message) { + xxx_messageInfo_DatadogMetric.Merge(m, src) +} +func (m *DatadogMetric) XXX_Size() int { + return m.Size() +} +func (m *DatadogMetric) XXX_DiscardUnknown() { + xxx_messageInfo_DatadogMetric.DiscardUnknown(m) +} + +var xxx_messageInfo_DatadogMetric proto.InternalMessageInfo + +func (m *DryRun) Reset() { *m = DryRun{} } +func (*DryRun) ProtoMessage() {} +func (*DryRun) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{36} +} +func (m *DryRun) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DryRun) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *DryRun) XXX_Merge(src proto.Message) { + xxx_messageInfo_DryRun.Merge(m, src) +} +func (m *DryRun) XXX_Size() int { + return m.Size() +} +func (m *DryRun) XXX_DiscardUnknown() { + xxx_messageInfo_DryRun.DiscardUnknown(m) +} + +var xxx_messageInfo_DryRun proto.InternalMessageInfo + +func (m *Experiment) Reset() { *m = Experiment{} } +func (*Experiment) ProtoMessage() {} +func (*Experiment) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{37} +} +func (m *Experiment) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Experiment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *Experiment) XXX_Merge(src proto.Message) { + xxx_messageInfo_Experiment.Merge(m, src) +} +func (m *Experiment) XXX_Size() int { + return m.Size() +} +func (m *Experiment) XXX_DiscardUnknown() { + xxx_messageInfo_Experiment.DiscardUnknown(m) +} + +var xxx_messageInfo_Experiment proto.InternalMessageInfo + +func (m *ExperimentAnalysisRunStatus) Reset() { *m = ExperimentAnalysisRunStatus{} } +func (*ExperimentAnalysisRunStatus) ProtoMessage() {} +func (*ExperimentAnalysisRunStatus) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{38} +} +func (m *ExperimentAnalysisRunStatus) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ExperimentAnalysisRunStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *ExperimentAnalysisRunStatus) XXX_Merge(src proto.Message) { + xxx_messageInfo_ExperimentAnalysisRunStatus.Merge(m, src) +} +func (m *ExperimentAnalysisRunStatus) XXX_Size() int { + return m.Size() +} +func (m *ExperimentAnalysisRunStatus) XXX_DiscardUnknown() { + xxx_messageInfo_ExperimentAnalysisRunStatus.DiscardUnknown(m) +} + +var xxx_messageInfo_ExperimentAnalysisRunStatus proto.InternalMessageInfo + +func (m *ExperimentAnalysisTemplateRef) Reset() { *m = ExperimentAnalysisTemplateRef{} } +func (*ExperimentAnalysisTemplateRef) ProtoMessage() {} +func (*ExperimentAnalysisTemplateRef) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{39} +} +func (m *ExperimentAnalysisTemplateRef) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ExperimentAnalysisTemplateRef) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *ExperimentAnalysisTemplateRef) XXX_Merge(src proto.Message) { + xxx_messageInfo_ExperimentAnalysisTemplateRef.Merge(m, src) +} +func (m *ExperimentAnalysisTemplateRef) XXX_Size() int { + return m.Size() +} +func (m *ExperimentAnalysisTemplateRef) XXX_DiscardUnknown() { + xxx_messageInfo_ExperimentAnalysisTemplateRef.DiscardUnknown(m) +} + +var xxx_messageInfo_ExperimentAnalysisTemplateRef proto.InternalMessageInfo + +func (m *ExperimentCondition) Reset() { *m = ExperimentCondition{} } +func (*ExperimentCondition) ProtoMessage() {} +func (*ExperimentCondition) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{40} +} +func (m *ExperimentCondition) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ExperimentCondition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *ExperimentCondition) XXX_Merge(src proto.Message) { + xxx_messageInfo_ExperimentCondition.Merge(m, src) +} +func (m *ExperimentCondition) XXX_Size() int { + return m.Size() +} +func (m *ExperimentCondition) XXX_DiscardUnknown() { + xxx_messageInfo_ExperimentCondition.DiscardUnknown(m) +} + +var xxx_messageInfo_ExperimentCondition proto.InternalMessageInfo + +func (m *ExperimentList) Reset() { *m = ExperimentList{} } +func (*ExperimentList) ProtoMessage() {} +func (*ExperimentList) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{41} +} +func (m *ExperimentList) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ExperimentList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *ExperimentList) XXX_Merge(src proto.Message) { + xxx_messageInfo_ExperimentList.Merge(m, src) +} +func (m *ExperimentList) XXX_Size() int { + return m.Size() +} +func (m *ExperimentList) XXX_DiscardUnknown() { + xxx_messageInfo_ExperimentList.DiscardUnknown(m) +} + +var xxx_messageInfo_ExperimentList proto.InternalMessageInfo + +func (m *ExperimentSpec) Reset() { *m = ExperimentSpec{} } +func (*ExperimentSpec) ProtoMessage() {} +func (*ExperimentSpec) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{42} +} +func (m *ExperimentSpec) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ExperimentSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *ExperimentSpec) XXX_Merge(src proto.Message) { + xxx_messageInfo_ExperimentSpec.Merge(m, src) +} +func (m *ExperimentSpec) XXX_Size() int { + return m.Size() +} +func (m *ExperimentSpec) XXX_DiscardUnknown() { + xxx_messageInfo_ExperimentSpec.DiscardUnknown(m) +} + +var xxx_messageInfo_ExperimentSpec proto.InternalMessageInfo + +func (m *ExperimentStatus) Reset() { *m = ExperimentStatus{} } +func (*ExperimentStatus) ProtoMessage() {} +func (*ExperimentStatus) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{43} +} +func (m *ExperimentStatus) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ExperimentStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *ExperimentStatus) XXX_Merge(src proto.Message) { + xxx_messageInfo_ExperimentStatus.Merge(m, src) +} +func (m *ExperimentStatus) XXX_Size() int { + return m.Size() +} +func (m *ExperimentStatus) XXX_DiscardUnknown() { + xxx_messageInfo_ExperimentStatus.DiscardUnknown(m) +} + +var xxx_messageInfo_ExperimentStatus proto.InternalMessageInfo + +func (m *FieldRef) Reset() { *m = FieldRef{} } +func (*FieldRef) ProtoMessage() {} +func (*FieldRef) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{44} +} +func (m *FieldRef) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *FieldRef) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *FieldRef) XXX_Merge(src proto.Message) { + xxx_messageInfo_FieldRef.Merge(m, src) +} +func (m *FieldRef) XXX_Size() int { + return m.Size() +} +func (m *FieldRef) XXX_DiscardUnknown() { + xxx_messageInfo_FieldRef.DiscardUnknown(m) +} + +var xxx_messageInfo_FieldRef proto.InternalMessageInfo + +func (m *GraphiteMetric) Reset() { *m = GraphiteMetric{} } +func (*GraphiteMetric) ProtoMessage() {} +func (*GraphiteMetric) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{45} +} +func (m *GraphiteMetric) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GraphiteMetric) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *GraphiteMetric) XXX_Merge(src proto.Message) { + xxx_messageInfo_GraphiteMetric.Merge(m, src) +} +func (m *GraphiteMetric) XXX_Size() int { + return m.Size() +} +func (m *GraphiteMetric) XXX_DiscardUnknown() { + xxx_messageInfo_GraphiteMetric.DiscardUnknown(m) +} + +var xxx_messageInfo_GraphiteMetric proto.InternalMessageInfo + +func (m *HeaderRoutingMatch) Reset() { *m = HeaderRoutingMatch{} } +func (*HeaderRoutingMatch) ProtoMessage() {} +func (*HeaderRoutingMatch) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{46} +} +func (m *HeaderRoutingMatch) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *HeaderRoutingMatch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *HeaderRoutingMatch) XXX_Merge(src proto.Message) { + xxx_messageInfo_HeaderRoutingMatch.Merge(m, src) +} +func (m *HeaderRoutingMatch) XXX_Size() int { + return m.Size() +} +func (m *HeaderRoutingMatch) XXX_DiscardUnknown() { + xxx_messageInfo_HeaderRoutingMatch.DiscardUnknown(m) +} + +var xxx_messageInfo_HeaderRoutingMatch proto.InternalMessageInfo + +func (m *InfluxdbMetric) Reset() { *m = InfluxdbMetric{} } +func (*InfluxdbMetric) ProtoMessage() {} +func (*InfluxdbMetric) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{47} +} +func (m *InfluxdbMetric) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *InfluxdbMetric) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *InfluxdbMetric) XXX_Merge(src proto.Message) { + xxx_messageInfo_InfluxdbMetric.Merge(m, src) +} +func (m *InfluxdbMetric) XXX_Size() int { + return m.Size() +} +func (m *InfluxdbMetric) XXX_DiscardUnknown() { + xxx_messageInfo_InfluxdbMetric.DiscardUnknown(m) +} + +var xxx_messageInfo_InfluxdbMetric proto.InternalMessageInfo + +func (m *IstioDestinationRule) Reset() { *m = IstioDestinationRule{} } +func (*IstioDestinationRule) ProtoMessage() {} +func (*IstioDestinationRule) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{48} +} +func (m *IstioDestinationRule) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *IstioDestinationRule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *IstioDestinationRule) XXX_Merge(src proto.Message) { + xxx_messageInfo_IstioDestinationRule.Merge(m, src) +} +func (m *IstioDestinationRule) XXX_Size() int { + return m.Size() +} +func (m *IstioDestinationRule) XXX_DiscardUnknown() { + xxx_messageInfo_IstioDestinationRule.DiscardUnknown(m) +} + +var xxx_messageInfo_IstioDestinationRule proto.InternalMessageInfo + +func (m *IstioTrafficRouting) Reset() { *m = IstioTrafficRouting{} } +func (*IstioTrafficRouting) ProtoMessage() {} +func (*IstioTrafficRouting) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{49} +} +func (m *IstioTrafficRouting) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *IstioTrafficRouting) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *IstioTrafficRouting) XXX_Merge(src proto.Message) { + xxx_messageInfo_IstioTrafficRouting.Merge(m, src) +} +func (m *IstioTrafficRouting) XXX_Size() int { + return m.Size() +} +func (m *IstioTrafficRouting) XXX_DiscardUnknown() { + xxx_messageInfo_IstioTrafficRouting.DiscardUnknown(m) +} + +var xxx_messageInfo_IstioTrafficRouting proto.InternalMessageInfo + +func (m *IstioVirtualService) Reset() { *m = IstioVirtualService{} } +func (*IstioVirtualService) ProtoMessage() {} +func (*IstioVirtualService) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{50} +} +func (m *IstioVirtualService) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *IstioVirtualService) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *IstioVirtualService) XXX_Merge(src proto.Message) { + xxx_messageInfo_IstioVirtualService.Merge(m, src) +} +func (m *IstioVirtualService) XXX_Size() int { + return m.Size() +} +func (m *IstioVirtualService) XXX_DiscardUnknown() { + xxx_messageInfo_IstioVirtualService.DiscardUnknown(m) +} + +var xxx_messageInfo_IstioVirtualService proto.InternalMessageInfo + +func (m *JobMetric) Reset() { *m = JobMetric{} } +func (*JobMetric) ProtoMessage() {} +func (*JobMetric) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{51} +} +func (m *JobMetric) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *JobMetric) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *JobMetric) XXX_Merge(src proto.Message) { + xxx_messageInfo_JobMetric.Merge(m, src) +} +func (m *JobMetric) XXX_Size() int { + return m.Size() +} +func (m *JobMetric) XXX_DiscardUnknown() { + xxx_messageInfo_JobMetric.DiscardUnknown(m) +} + +var xxx_messageInfo_JobMetric proto.InternalMessageInfo + +func (m *KayentaMetric) Reset() { *m = KayentaMetric{} } +func (*KayentaMetric) ProtoMessage() {} +func (*KayentaMetric) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{52} +} +func (m *KayentaMetric) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *KayentaMetric) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *KayentaMetric) XXX_Merge(src proto.Message) { + xxx_messageInfo_KayentaMetric.Merge(m, src) +} +func (m *KayentaMetric) XXX_Size() int { + return m.Size() +} +func (m *KayentaMetric) XXX_DiscardUnknown() { + xxx_messageInfo_KayentaMetric.DiscardUnknown(m) +} + +var xxx_messageInfo_KayentaMetric proto.InternalMessageInfo + +func (m *KayentaScope) Reset() { *m = KayentaScope{} } +func (*KayentaScope) ProtoMessage() {} +func (*KayentaScope) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{53} +} +func (m *KayentaScope) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *KayentaScope) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *KayentaScope) XXX_Merge(src proto.Message) { + xxx_messageInfo_KayentaScope.Merge(m, src) +} +func (m *KayentaScope) XXX_Size() int { + return m.Size() +} +func (m *KayentaScope) XXX_DiscardUnknown() { + xxx_messageInfo_KayentaScope.DiscardUnknown(m) +} + +var xxx_messageInfo_KayentaScope proto.InternalMessageInfo + +func (m *KayentaThreshold) Reset() { *m = KayentaThreshold{} } +func (*KayentaThreshold) ProtoMessage() {} +func (*KayentaThreshold) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{54} +} +func (m *KayentaThreshold) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *KayentaThreshold) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *KayentaThreshold) XXX_Merge(src proto.Message) { + xxx_messageInfo_KayentaThreshold.Merge(m, src) +} +func (m *KayentaThreshold) XXX_Size() int { + return m.Size() +} +func (m *KayentaThreshold) XXX_DiscardUnknown() { + xxx_messageInfo_KayentaThreshold.DiscardUnknown(m) +} + +var xxx_messageInfo_KayentaThreshold proto.InternalMessageInfo + +func (m *MangedRoutes) Reset() { *m = MangedRoutes{} } +func (*MangedRoutes) ProtoMessage() {} +func (*MangedRoutes) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{55} +} +func (m *MangedRoutes) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MangedRoutes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *MangedRoutes) XXX_Merge(src proto.Message) { + xxx_messageInfo_MangedRoutes.Merge(m, src) +} +func (m *MangedRoutes) XXX_Size() int { + return m.Size() +} +func (m *MangedRoutes) XXX_DiscardUnknown() { + xxx_messageInfo_MangedRoutes.DiscardUnknown(m) +} + +var xxx_messageInfo_MangedRoutes proto.InternalMessageInfo + +func (m *Measurement) Reset() { *m = Measurement{} } +func (*Measurement) ProtoMessage() {} +func (*Measurement) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{56} +} +func (m *Measurement) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Measurement) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *Measurement) XXX_Merge(src proto.Message) { + xxx_messageInfo_Measurement.Merge(m, src) +} +func (m *Measurement) XXX_Size() int { + return m.Size() +} +func (m *Measurement) XXX_DiscardUnknown() { + xxx_messageInfo_Measurement.DiscardUnknown(m) +} + +var xxx_messageInfo_Measurement proto.InternalMessageInfo + +func (m *MeasurementRetention) Reset() { *m = MeasurementRetention{} } +func (*MeasurementRetention) ProtoMessage() {} +func (*MeasurementRetention) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{57} +} +func (m *MeasurementRetention) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MeasurementRetention) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *MeasurementRetention) XXX_Merge(src proto.Message) { + xxx_messageInfo_MeasurementRetention.Merge(m, src) +} +func (m *MeasurementRetention) XXX_Size() int { + return m.Size() +} +func (m *MeasurementRetention) XXX_DiscardUnknown() { + xxx_messageInfo_MeasurementRetention.DiscardUnknown(m) +} + +var xxx_messageInfo_MeasurementRetention proto.InternalMessageInfo + +func (m *Metric) Reset() { *m = Metric{} } +func (*Metric) ProtoMessage() {} +func (*Metric) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{58} +} +func (m *Metric) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Metric) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *Metric) XXX_Merge(src proto.Message) { + xxx_messageInfo_Metric.Merge(m, src) +} +func (m *Metric) XXX_Size() int { + return m.Size() +} +func (m *Metric) XXX_DiscardUnknown() { + xxx_messageInfo_Metric.DiscardUnknown(m) +} + +var xxx_messageInfo_Metric proto.InternalMessageInfo + +func (m *MetricProvider) Reset() { *m = MetricProvider{} } +func (*MetricProvider) ProtoMessage() {} +func (*MetricProvider) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{59} +} +func (m *MetricProvider) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MetricProvider) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *MetricProvider) XXX_Merge(src proto.Message) { + xxx_messageInfo_MetricProvider.Merge(m, src) +} +func (m *MetricProvider) XXX_Size() int { + return m.Size() +} +func (m *MetricProvider) XXX_DiscardUnknown() { + xxx_messageInfo_MetricProvider.DiscardUnknown(m) +} + +var xxx_messageInfo_MetricProvider proto.InternalMessageInfo + +func (m *MetricResult) Reset() { *m = MetricResult{} } +func (*MetricResult) ProtoMessage() {} +func (*MetricResult) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{60} +} +func (m *MetricResult) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MetricResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *MetricResult) XXX_Merge(src proto.Message) { + xxx_messageInfo_MetricResult.Merge(m, src) +} +func (m *MetricResult) XXX_Size() int { + return m.Size() +} +func (m *MetricResult) XXX_DiscardUnknown() { + xxx_messageInfo_MetricResult.DiscardUnknown(m) +} + +var xxx_messageInfo_MetricResult proto.InternalMessageInfo + +func (m *NewRelicMetric) Reset() { *m = NewRelicMetric{} } +func (*NewRelicMetric) ProtoMessage() {} +func (*NewRelicMetric) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{61} +} +func (m *NewRelicMetric) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *NewRelicMetric) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *NewRelicMetric) XXX_Merge(src proto.Message) { + xxx_messageInfo_NewRelicMetric.Merge(m, src) +} +func (m *NewRelicMetric) XXX_Size() int { + return m.Size() +} +func (m *NewRelicMetric) XXX_DiscardUnknown() { + xxx_messageInfo_NewRelicMetric.DiscardUnknown(m) +} + +var xxx_messageInfo_NewRelicMetric proto.InternalMessageInfo + +func (m *NginxTrafficRouting) Reset() { *m = NginxTrafficRouting{} } +func (*NginxTrafficRouting) ProtoMessage() {} +func (*NginxTrafficRouting) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{62} +} +func (m *NginxTrafficRouting) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *NginxTrafficRouting) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *NginxTrafficRouting) XXX_Merge(src proto.Message) { + xxx_messageInfo_NginxTrafficRouting.Merge(m, src) +} +func (m *NginxTrafficRouting) XXX_Size() int { + return m.Size() +} +func (m *NginxTrafficRouting) XXX_DiscardUnknown() { + xxx_messageInfo_NginxTrafficRouting.DiscardUnknown(m) +} + +var xxx_messageInfo_NginxTrafficRouting proto.InternalMessageInfo + +func (m *ObjectRef) Reset() { *m = ObjectRef{} } +func (*ObjectRef) ProtoMessage() {} +func (*ObjectRef) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{63} +} +func (m *ObjectRef) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ObjectRef) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *ObjectRef) XXX_Merge(src proto.Message) { + xxx_messageInfo_ObjectRef.Merge(m, src) +} +func (m *ObjectRef) XXX_Size() int { + return m.Size() +} +func (m *ObjectRef) XXX_DiscardUnknown() { + xxx_messageInfo_ObjectRef.DiscardUnknown(m) +} + +var xxx_messageInfo_ObjectRef proto.InternalMessageInfo + +func (m *PauseCondition) Reset() { *m = PauseCondition{} } +func (*PauseCondition) ProtoMessage() {} +func (*PauseCondition) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{64} +} +func (m *PauseCondition) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PauseCondition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *PauseCondition) XXX_Merge(src proto.Message) { + xxx_messageInfo_PauseCondition.Merge(m, src) +} +func (m *PauseCondition) XXX_Size() int { + return m.Size() +} +func (m *PauseCondition) XXX_DiscardUnknown() { + xxx_messageInfo_PauseCondition.DiscardUnknown(m) +} + +var xxx_messageInfo_PauseCondition proto.InternalMessageInfo + +func (m *PingPongSpec) Reset() { *m = PingPongSpec{} } +func (*PingPongSpec) ProtoMessage() {} +func (*PingPongSpec) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{65} +} +func (m *PingPongSpec) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PingPongSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *PingPongSpec) XXX_Merge(src proto.Message) { + xxx_messageInfo_PingPongSpec.Merge(m, src) +} +func (m *PingPongSpec) XXX_Size() int { + return m.Size() +} +func (m *PingPongSpec) XXX_DiscardUnknown() { + xxx_messageInfo_PingPongSpec.DiscardUnknown(m) +} + +var xxx_messageInfo_PingPongSpec proto.InternalMessageInfo + +func (m *PodTemplateMetadata) Reset() { *m = PodTemplateMetadata{} } +func (*PodTemplateMetadata) ProtoMessage() {} +func (*PodTemplateMetadata) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{66} +} +func (m *PodTemplateMetadata) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PodTemplateMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *PodTemplateMetadata) XXX_Merge(src proto.Message) { + xxx_messageInfo_PodTemplateMetadata.Merge(m, src) +} +func (m *PodTemplateMetadata) XXX_Size() int { + return m.Size() +} +func (m *PodTemplateMetadata) XXX_DiscardUnknown() { + xxx_messageInfo_PodTemplateMetadata.DiscardUnknown(m) +} + +var xxx_messageInfo_PodTemplateMetadata proto.InternalMessageInfo + +func (m *PreferredDuringSchedulingIgnoredDuringExecution) Reset() { + *m = PreferredDuringSchedulingIgnoredDuringExecution{} +} +func (*PreferredDuringSchedulingIgnoredDuringExecution) ProtoMessage() {} +func (*PreferredDuringSchedulingIgnoredDuringExecution) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{67} +} +func (m *PreferredDuringSchedulingIgnoredDuringExecution) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PreferredDuringSchedulingIgnoredDuringExecution) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *PreferredDuringSchedulingIgnoredDuringExecution) XXX_Merge(src proto.Message) { + xxx_messageInfo_PreferredDuringSchedulingIgnoredDuringExecution.Merge(m, src) +} +func (m *PreferredDuringSchedulingIgnoredDuringExecution) XXX_Size() int { + return m.Size() +} +func (m *PreferredDuringSchedulingIgnoredDuringExecution) XXX_DiscardUnknown() { + xxx_messageInfo_PreferredDuringSchedulingIgnoredDuringExecution.DiscardUnknown(m) +} + +var xxx_messageInfo_PreferredDuringSchedulingIgnoredDuringExecution proto.InternalMessageInfo + +func (m *PrometheusAuth) Reset() { *m = PrometheusAuth{} } +func (*PrometheusAuth) ProtoMessage() {} +func (*PrometheusAuth) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{68} +} +func (m *PrometheusAuth) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PrometheusAuth) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *PrometheusAuth) XXX_Merge(src proto.Message) { + xxx_messageInfo_PrometheusAuth.Merge(m, src) +} +func (m *PrometheusAuth) XXX_Size() int { + return m.Size() +} +func (m *PrometheusAuth) XXX_DiscardUnknown() { + xxx_messageInfo_PrometheusAuth.DiscardUnknown(m) +} + +var xxx_messageInfo_PrometheusAuth proto.InternalMessageInfo + +func (m *PrometheusMetric) Reset() { *m = PrometheusMetric{} } +func (*PrometheusMetric) ProtoMessage() {} +func (*PrometheusMetric) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{69} +} +func (m *PrometheusMetric) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PrometheusMetric) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *PrometheusMetric) XXX_Merge(src proto.Message) { + xxx_messageInfo_PrometheusMetric.Merge(m, src) +} +func (m *PrometheusMetric) XXX_Size() int { + return m.Size() +} +func (m *PrometheusMetric) XXX_DiscardUnknown() { + xxx_messageInfo_PrometheusMetric.DiscardUnknown(m) +} + +var xxx_messageInfo_PrometheusMetric proto.InternalMessageInfo + +func (m *RequiredDuringSchedulingIgnoredDuringExecution) Reset() { + *m = RequiredDuringSchedulingIgnoredDuringExecution{} +} +func (*RequiredDuringSchedulingIgnoredDuringExecution) ProtoMessage() {} +func (*RequiredDuringSchedulingIgnoredDuringExecution) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{70} +} +func (m *RequiredDuringSchedulingIgnoredDuringExecution) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RequiredDuringSchedulingIgnoredDuringExecution) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *RequiredDuringSchedulingIgnoredDuringExecution) XXX_Merge(src proto.Message) { + xxx_messageInfo_RequiredDuringSchedulingIgnoredDuringExecution.Merge(m, src) +} +func (m *RequiredDuringSchedulingIgnoredDuringExecution) XXX_Size() int { + return m.Size() +} +func (m *RequiredDuringSchedulingIgnoredDuringExecution) XXX_DiscardUnknown() { + xxx_messageInfo_RequiredDuringSchedulingIgnoredDuringExecution.DiscardUnknown(m) +} + +var xxx_messageInfo_RequiredDuringSchedulingIgnoredDuringExecution proto.InternalMessageInfo + +func (m *RollbackWindowSpec) Reset() { *m = RollbackWindowSpec{} } +func (*RollbackWindowSpec) ProtoMessage() {} +func (*RollbackWindowSpec) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{71} +} +func (m *RollbackWindowSpec) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RollbackWindowSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *RollbackWindowSpec) XXX_Merge(src proto.Message) { + xxx_messageInfo_RollbackWindowSpec.Merge(m, src) +} +func (m *RollbackWindowSpec) XXX_Size() int { + return m.Size() +} +func (m *RollbackWindowSpec) XXX_DiscardUnknown() { + xxx_messageInfo_RollbackWindowSpec.DiscardUnknown(m) +} + +var xxx_messageInfo_RollbackWindowSpec proto.InternalMessageInfo + +func (m *Rollout) Reset() { *m = Rollout{} } +func (*Rollout) ProtoMessage() {} +func (*Rollout) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{72} +} +func (m *Rollout) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Rollout) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *Rollout) XXX_Merge(src proto.Message) { + xxx_messageInfo_Rollout.Merge(m, src) +} +func (m *Rollout) XXX_Size() int { + return m.Size() +} +func (m *Rollout) XXX_DiscardUnknown() { + xxx_messageInfo_Rollout.DiscardUnknown(m) +} + +var xxx_messageInfo_Rollout proto.InternalMessageInfo + +func (m *RolloutAnalysis) Reset() { *m = RolloutAnalysis{} } +func (*RolloutAnalysis) ProtoMessage() {} +func (*RolloutAnalysis) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{73} +} +func (m *RolloutAnalysis) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RolloutAnalysis) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *RolloutAnalysis) XXX_Merge(src proto.Message) { + xxx_messageInfo_RolloutAnalysis.Merge(m, src) +} +func (m *RolloutAnalysis) XXX_Size() int { + return m.Size() +} +func (m *RolloutAnalysis) XXX_DiscardUnknown() { + xxx_messageInfo_RolloutAnalysis.DiscardUnknown(m) +} + +var xxx_messageInfo_RolloutAnalysis proto.InternalMessageInfo + +func (m *RolloutAnalysisBackground) Reset() { *m = RolloutAnalysisBackground{} } +func (*RolloutAnalysisBackground) ProtoMessage() {} +func (*RolloutAnalysisBackground) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{74} +} +func (m *RolloutAnalysisBackground) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RolloutAnalysisBackground) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *RolloutAnalysisBackground) XXX_Merge(src proto.Message) { + xxx_messageInfo_RolloutAnalysisBackground.Merge(m, src) +} +func (m *RolloutAnalysisBackground) XXX_Size() int { + return m.Size() +} +func (m *RolloutAnalysisBackground) XXX_DiscardUnknown() { + xxx_messageInfo_RolloutAnalysisBackground.DiscardUnknown(m) +} + +var xxx_messageInfo_RolloutAnalysisBackground proto.InternalMessageInfo + +func (m *RolloutAnalysisRunStatus) Reset() { *m = RolloutAnalysisRunStatus{} } +func (*RolloutAnalysisRunStatus) ProtoMessage() {} +func (*RolloutAnalysisRunStatus) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{75} +} +func (m *RolloutAnalysisRunStatus) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RolloutAnalysisRunStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *RolloutAnalysisRunStatus) XXX_Merge(src proto.Message) { + xxx_messageInfo_RolloutAnalysisRunStatus.Merge(m, src) +} +func (m *RolloutAnalysisRunStatus) XXX_Size() int { + return m.Size() +} +func (m *RolloutAnalysisRunStatus) XXX_DiscardUnknown() { + xxx_messageInfo_RolloutAnalysisRunStatus.DiscardUnknown(m) +} + +var xxx_messageInfo_RolloutAnalysisRunStatus proto.InternalMessageInfo + +func (m *RolloutAnalysisTemplate) Reset() { *m = RolloutAnalysisTemplate{} } +func (*RolloutAnalysisTemplate) ProtoMessage() {} +func (*RolloutAnalysisTemplate) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{76} +} +func (m *RolloutAnalysisTemplate) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RolloutAnalysisTemplate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *RolloutAnalysisTemplate) XXX_Merge(src proto.Message) { + xxx_messageInfo_RolloutAnalysisTemplate.Merge(m, src) +} +func (m *RolloutAnalysisTemplate) XXX_Size() int { + return m.Size() +} +func (m *RolloutAnalysisTemplate) XXX_DiscardUnknown() { + xxx_messageInfo_RolloutAnalysisTemplate.DiscardUnknown(m) +} + +var xxx_messageInfo_RolloutAnalysisTemplate proto.InternalMessageInfo + +func (m *RolloutCondition) Reset() { *m = RolloutCondition{} } +func (*RolloutCondition) ProtoMessage() {} +func (*RolloutCondition) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{77} +} +func (m *RolloutCondition) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RolloutCondition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *RolloutCondition) XXX_Merge(src proto.Message) { + xxx_messageInfo_RolloutCondition.Merge(m, src) +} +func (m *RolloutCondition) XXX_Size() int { + return m.Size() +} +func (m *RolloutCondition) XXX_DiscardUnknown() { + xxx_messageInfo_RolloutCondition.DiscardUnknown(m) +} + +var xxx_messageInfo_RolloutCondition proto.InternalMessageInfo + +func (m *RolloutExperimentStep) Reset() { *m = RolloutExperimentStep{} } +func (*RolloutExperimentStep) ProtoMessage() {} +func (*RolloutExperimentStep) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{78} +} +func (m *RolloutExperimentStep) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RolloutExperimentStep) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *RolloutExperimentStep) XXX_Merge(src proto.Message) { + xxx_messageInfo_RolloutExperimentStep.Merge(m, src) +} +func (m *RolloutExperimentStep) XXX_Size() int { + return m.Size() +} +func (m *RolloutExperimentStep) XXX_DiscardUnknown() { + xxx_messageInfo_RolloutExperimentStep.DiscardUnknown(m) +} + +var xxx_messageInfo_RolloutExperimentStep proto.InternalMessageInfo + +func (m *RolloutExperimentStepAnalysisTemplateRef) Reset() { + *m = RolloutExperimentStepAnalysisTemplateRef{} +} +func (*RolloutExperimentStepAnalysisTemplateRef) ProtoMessage() {} +func (*RolloutExperimentStepAnalysisTemplateRef) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{79} +} +func (m *RolloutExperimentStepAnalysisTemplateRef) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RolloutExperimentStepAnalysisTemplateRef) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *RolloutExperimentStepAnalysisTemplateRef) XXX_Merge(src proto.Message) { + xxx_messageInfo_RolloutExperimentStepAnalysisTemplateRef.Merge(m, src) +} +func (m *RolloutExperimentStepAnalysisTemplateRef) XXX_Size() int { + return m.Size() +} +func (m *RolloutExperimentStepAnalysisTemplateRef) XXX_DiscardUnknown() { + xxx_messageInfo_RolloutExperimentStepAnalysisTemplateRef.DiscardUnknown(m) +} + +var xxx_messageInfo_RolloutExperimentStepAnalysisTemplateRef proto.InternalMessageInfo + +func (m *RolloutExperimentTemplate) Reset() { *m = RolloutExperimentTemplate{} } +func (*RolloutExperimentTemplate) ProtoMessage() {} +func (*RolloutExperimentTemplate) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{80} +} +func (m *RolloutExperimentTemplate) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RolloutExperimentTemplate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *RolloutExperimentTemplate) XXX_Merge(src proto.Message) { + xxx_messageInfo_RolloutExperimentTemplate.Merge(m, src) +} +func (m *RolloutExperimentTemplate) XXX_Size() int { + return m.Size() +} +func (m *RolloutExperimentTemplate) XXX_DiscardUnknown() { + xxx_messageInfo_RolloutExperimentTemplate.DiscardUnknown(m) +} + +var xxx_messageInfo_RolloutExperimentTemplate proto.InternalMessageInfo + +func (m *RolloutList) Reset() { *m = RolloutList{} } +func (*RolloutList) ProtoMessage() {} +func (*RolloutList) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{81} +} +func (m *RolloutList) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RolloutList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *RolloutList) XXX_Merge(src proto.Message) { + xxx_messageInfo_RolloutList.Merge(m, src) +} +func (m *RolloutList) XXX_Size() int { + return m.Size() +} +func (m *RolloutList) XXX_DiscardUnknown() { + xxx_messageInfo_RolloutList.DiscardUnknown(m) +} + +var xxx_messageInfo_RolloutList proto.InternalMessageInfo + +func (m *RolloutPause) Reset() { *m = RolloutPause{} } +func (*RolloutPause) ProtoMessage() {} +func (*RolloutPause) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{82} +} +func (m *RolloutPause) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RolloutPause) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *RolloutPause) XXX_Merge(src proto.Message) { + xxx_messageInfo_RolloutPause.Merge(m, src) +} +func (m *RolloutPause) XXX_Size() int { + return m.Size() +} +func (m *RolloutPause) XXX_DiscardUnknown() { + xxx_messageInfo_RolloutPause.DiscardUnknown(m) +} + +var xxx_messageInfo_RolloutPause proto.InternalMessageInfo + +func (m *RolloutSpec) Reset() { *m = RolloutSpec{} } +func (*RolloutSpec) ProtoMessage() {} +func (*RolloutSpec) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{83} +} +func (m *RolloutSpec) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RolloutSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *RolloutSpec) XXX_Merge(src proto.Message) { + xxx_messageInfo_RolloutSpec.Merge(m, src) +} +func (m *RolloutSpec) XXX_Size() int { + return m.Size() +} +func (m *RolloutSpec) XXX_DiscardUnknown() { + xxx_messageInfo_RolloutSpec.DiscardUnknown(m) +} + +var xxx_messageInfo_RolloutSpec proto.InternalMessageInfo + +func (m *RolloutStatus) Reset() { *m = RolloutStatus{} } +func (*RolloutStatus) ProtoMessage() {} +func (*RolloutStatus) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{84} +} +func (m *RolloutStatus) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RolloutStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *RolloutStatus) XXX_Merge(src proto.Message) { + xxx_messageInfo_RolloutStatus.Merge(m, src) +} +func (m *RolloutStatus) XXX_Size() int { + return m.Size() +} +func (m *RolloutStatus) XXX_DiscardUnknown() { + xxx_messageInfo_RolloutStatus.DiscardUnknown(m) +} + +var xxx_messageInfo_RolloutStatus proto.InternalMessageInfo + +func (m *RolloutStrategy) Reset() { *m = RolloutStrategy{} } +func (*RolloutStrategy) ProtoMessage() {} +func (*RolloutStrategy) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{85} +} +func (m *RolloutStrategy) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RolloutStrategy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *RolloutStrategy) XXX_Merge(src proto.Message) { + xxx_messageInfo_RolloutStrategy.Merge(m, src) +} +func (m *RolloutStrategy) XXX_Size() int { + return m.Size() +} +func (m *RolloutStrategy) XXX_DiscardUnknown() { + xxx_messageInfo_RolloutStrategy.DiscardUnknown(m) +} + +var xxx_messageInfo_RolloutStrategy proto.InternalMessageInfo + +func (m *RolloutTrafficRouting) Reset() { *m = RolloutTrafficRouting{} } +func (*RolloutTrafficRouting) ProtoMessage() {} +func (*RolloutTrafficRouting) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{86} +} +func (m *RolloutTrafficRouting) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RolloutTrafficRouting) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *RolloutTrafficRouting) XXX_Merge(src proto.Message) { + xxx_messageInfo_RolloutTrafficRouting.Merge(m, src) +} +func (m *RolloutTrafficRouting) XXX_Size() int { + return m.Size() +} +func (m *RolloutTrafficRouting) XXX_DiscardUnknown() { + xxx_messageInfo_RolloutTrafficRouting.DiscardUnknown(m) +} + +var xxx_messageInfo_RolloutTrafficRouting proto.InternalMessageInfo + +func (m *RouteMatch) Reset() { *m = RouteMatch{} } +func (*RouteMatch) ProtoMessage() {} +func (*RouteMatch) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{87} +} +func (m *RouteMatch) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RouteMatch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *RouteMatch) XXX_Merge(src proto.Message) { + xxx_messageInfo_RouteMatch.Merge(m, src) +} +func (m *RouteMatch) XXX_Size() int { + return m.Size() +} +func (m *RouteMatch) XXX_DiscardUnknown() { + xxx_messageInfo_RouteMatch.DiscardUnknown(m) +} + +var xxx_messageInfo_RouteMatch proto.InternalMessageInfo + +func (m *RunSummary) Reset() { *m = RunSummary{} } +func (*RunSummary) ProtoMessage() {} +func (*RunSummary) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{88} +} +func (m *RunSummary) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RunSummary) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *RunSummary) XXX_Merge(src proto.Message) { + xxx_messageInfo_RunSummary.Merge(m, src) +} +func (m *RunSummary) XXX_Size() int { + return m.Size() +} +func (m *RunSummary) XXX_DiscardUnknown() { + xxx_messageInfo_RunSummary.DiscardUnknown(m) +} + +var xxx_messageInfo_RunSummary proto.InternalMessageInfo + +func (m *SMITrafficRouting) Reset() { *m = SMITrafficRouting{} } +func (*SMITrafficRouting) ProtoMessage() {} +func (*SMITrafficRouting) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{89} +} +func (m *SMITrafficRouting) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SMITrafficRouting) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *SMITrafficRouting) XXX_Merge(src proto.Message) { + xxx_messageInfo_SMITrafficRouting.Merge(m, src) +} +func (m *SMITrafficRouting) XXX_Size() int { + return m.Size() +} +func (m *SMITrafficRouting) XXX_DiscardUnknown() { + xxx_messageInfo_SMITrafficRouting.DiscardUnknown(m) +} + +var xxx_messageInfo_SMITrafficRouting proto.InternalMessageInfo + +func (m *ScopeDetail) Reset() { *m = ScopeDetail{} } +func (*ScopeDetail) ProtoMessage() {} +func (*ScopeDetail) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{90} +} +func (m *ScopeDetail) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ScopeDetail) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *ScopeDetail) XXX_Merge(src proto.Message) { + xxx_messageInfo_ScopeDetail.Merge(m, src) +} +func (m *ScopeDetail) XXX_Size() int { + return m.Size() +} +func (m *ScopeDetail) XXX_DiscardUnknown() { + xxx_messageInfo_ScopeDetail.DiscardUnknown(m) +} + +var xxx_messageInfo_ScopeDetail proto.InternalMessageInfo + +func (m *SecretKeyRef) Reset() { *m = SecretKeyRef{} } +func (*SecretKeyRef) ProtoMessage() {} +func (*SecretKeyRef) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{91} +} +func (m *SecretKeyRef) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SecretKeyRef) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *SecretKeyRef) XXX_Merge(src proto.Message) { + xxx_messageInfo_SecretKeyRef.Merge(m, src) +} +func (m *SecretKeyRef) XXX_Size() int { + return m.Size() +} +func (m *SecretKeyRef) XXX_DiscardUnknown() { + xxx_messageInfo_SecretKeyRef.DiscardUnknown(m) +} + +var xxx_messageInfo_SecretKeyRef proto.InternalMessageInfo + +func (m *SetCanaryScale) Reset() { *m = SetCanaryScale{} } +func (*SetCanaryScale) ProtoMessage() {} +func (*SetCanaryScale) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{92} +} +func (m *SetCanaryScale) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SetCanaryScale) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *SetCanaryScale) XXX_Merge(src proto.Message) { + xxx_messageInfo_SetCanaryScale.Merge(m, src) +} +func (m *SetCanaryScale) XXX_Size() int { + return m.Size() +} +func (m *SetCanaryScale) XXX_DiscardUnknown() { + xxx_messageInfo_SetCanaryScale.DiscardUnknown(m) +} + +var xxx_messageInfo_SetCanaryScale proto.InternalMessageInfo + +func (m *SetHeaderRoute) Reset() { *m = SetHeaderRoute{} } +func (*SetHeaderRoute) ProtoMessage() {} +func (*SetHeaderRoute) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{93} +} +func (m *SetHeaderRoute) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SetHeaderRoute) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *SetHeaderRoute) XXX_Merge(src proto.Message) { + xxx_messageInfo_SetHeaderRoute.Merge(m, src) +} +func (m *SetHeaderRoute) XXX_Size() int { + return m.Size() +} +func (m *SetHeaderRoute) XXX_DiscardUnknown() { + xxx_messageInfo_SetHeaderRoute.DiscardUnknown(m) +} + +var xxx_messageInfo_SetHeaderRoute proto.InternalMessageInfo + +func (m *SetMirrorRoute) Reset() { *m = SetMirrorRoute{} } +func (*SetMirrorRoute) ProtoMessage() {} +func (*SetMirrorRoute) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{94} +} +func (m *SetMirrorRoute) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SetMirrorRoute) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *SetMirrorRoute) XXX_Merge(src proto.Message) { + xxx_messageInfo_SetMirrorRoute.Merge(m, src) +} +func (m *SetMirrorRoute) XXX_Size() int { + return m.Size() +} +func (m *SetMirrorRoute) XXX_DiscardUnknown() { + xxx_messageInfo_SetMirrorRoute.DiscardUnknown(m) +} + +var xxx_messageInfo_SetMirrorRoute proto.InternalMessageInfo + +func (m *Sigv4Config) Reset() { *m = Sigv4Config{} } +func (*Sigv4Config) ProtoMessage() {} +func (*Sigv4Config) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{95} +} +func (m *Sigv4Config) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Sigv4Config) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *Sigv4Config) XXX_Merge(src proto.Message) { + xxx_messageInfo_Sigv4Config.Merge(m, src) +} +func (m *Sigv4Config) XXX_Size() int { + return m.Size() +} +func (m *Sigv4Config) XXX_DiscardUnknown() { + xxx_messageInfo_Sigv4Config.DiscardUnknown(m) +} + +var xxx_messageInfo_Sigv4Config proto.InternalMessageInfo + +func (m *SkyWalkingMetric) Reset() { *m = SkyWalkingMetric{} } +func (*SkyWalkingMetric) ProtoMessage() {} +func (*SkyWalkingMetric) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{96} +} +func (m *SkyWalkingMetric) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SkyWalkingMetric) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *SkyWalkingMetric) XXX_Merge(src proto.Message) { + xxx_messageInfo_SkyWalkingMetric.Merge(m, src) +} +func (m *SkyWalkingMetric) XXX_Size() int { + return m.Size() +} +func (m *SkyWalkingMetric) XXX_DiscardUnknown() { + xxx_messageInfo_SkyWalkingMetric.DiscardUnknown(m) +} + +var xxx_messageInfo_SkyWalkingMetric proto.InternalMessageInfo + +func (m *StickinessConfig) Reset() { *m = StickinessConfig{} } +func (*StickinessConfig) ProtoMessage() {} +func (*StickinessConfig) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{97} +} +func (m *StickinessConfig) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StickinessConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *StickinessConfig) XXX_Merge(src proto.Message) { + xxx_messageInfo_StickinessConfig.Merge(m, src) +} +func (m *StickinessConfig) XXX_Size() int { + return m.Size() +} +func (m *StickinessConfig) XXX_DiscardUnknown() { + xxx_messageInfo_StickinessConfig.DiscardUnknown(m) +} + +var xxx_messageInfo_StickinessConfig proto.InternalMessageInfo + +func (m *StringMatch) Reset() { *m = StringMatch{} } +func (*StringMatch) ProtoMessage() {} +func (*StringMatch) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{98} +} +func (m *StringMatch) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StringMatch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *StringMatch) XXX_Merge(src proto.Message) { + xxx_messageInfo_StringMatch.Merge(m, src) +} +func (m *StringMatch) XXX_Size() int { + return m.Size() +} +func (m *StringMatch) XXX_DiscardUnknown() { + xxx_messageInfo_StringMatch.DiscardUnknown(m) +} + +var xxx_messageInfo_StringMatch proto.InternalMessageInfo + +func (m *TCPRoute) Reset() { *m = TCPRoute{} } +func (*TCPRoute) ProtoMessage() {} +func (*TCPRoute) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{99} +} +func (m *TCPRoute) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TCPRoute) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *TCPRoute) XXX_Merge(src proto.Message) { + xxx_messageInfo_TCPRoute.Merge(m, src) +} +func (m *TCPRoute) XXX_Size() int { + return m.Size() +} +func (m *TCPRoute) XXX_DiscardUnknown() { + xxx_messageInfo_TCPRoute.DiscardUnknown(m) +} + +var xxx_messageInfo_TCPRoute proto.InternalMessageInfo + +func (m *TLSRoute) Reset() { *m = TLSRoute{} } +func (*TLSRoute) ProtoMessage() {} +func (*TLSRoute) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{100} +} +func (m *TLSRoute) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TLSRoute) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *TLSRoute) XXX_Merge(src proto.Message) { + xxx_messageInfo_TLSRoute.Merge(m, src) +} +func (m *TLSRoute) XXX_Size() int { + return m.Size() +} +func (m *TLSRoute) XXX_DiscardUnknown() { + xxx_messageInfo_TLSRoute.DiscardUnknown(m) +} + +var xxx_messageInfo_TLSRoute proto.InternalMessageInfo + +func (m *TemplateService) Reset() { *m = TemplateService{} } +func (*TemplateService) ProtoMessage() {} +func (*TemplateService) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{101} +} +func (m *TemplateService) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TemplateService) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *TemplateService) XXX_Merge(src proto.Message) { + xxx_messageInfo_TemplateService.Merge(m, src) +} +func (m *TemplateService) XXX_Size() int { + return m.Size() +} +func (m *TemplateService) XXX_DiscardUnknown() { + xxx_messageInfo_TemplateService.DiscardUnknown(m) +} + +var xxx_messageInfo_TemplateService proto.InternalMessageInfo + +func (m *TemplateSpec) Reset() { *m = TemplateSpec{} } +func (*TemplateSpec) ProtoMessage() {} +func (*TemplateSpec) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{102} +} +func (m *TemplateSpec) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TemplateSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *TemplateSpec) XXX_Merge(src proto.Message) { + xxx_messageInfo_TemplateSpec.Merge(m, src) +} +func (m *TemplateSpec) XXX_Size() int { + return m.Size() +} +func (m *TemplateSpec) XXX_DiscardUnknown() { + xxx_messageInfo_TemplateSpec.DiscardUnknown(m) +} + +var xxx_messageInfo_TemplateSpec proto.InternalMessageInfo + +func (m *TemplateStatus) Reset() { *m = TemplateStatus{} } +func (*TemplateStatus) ProtoMessage() {} +func (*TemplateStatus) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{103} +} +func (m *TemplateStatus) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TemplateStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *TemplateStatus) XXX_Merge(src proto.Message) { + xxx_messageInfo_TemplateStatus.Merge(m, src) +} +func (m *TemplateStatus) XXX_Size() int { + return m.Size() +} +func (m *TemplateStatus) XXX_DiscardUnknown() { + xxx_messageInfo_TemplateStatus.DiscardUnknown(m) +} + +var xxx_messageInfo_TemplateStatus proto.InternalMessageInfo + +func (m *TraefikTrafficRouting) Reset() { *m = TraefikTrafficRouting{} } +func (*TraefikTrafficRouting) ProtoMessage() {} +func (*TraefikTrafficRouting) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{104} +} +func (m *TraefikTrafficRouting) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TraefikTrafficRouting) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *TraefikTrafficRouting) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraefikTrafficRouting.Merge(m, src) +} +func (m *TraefikTrafficRouting) XXX_Size() int { + return m.Size() +} +func (m *TraefikTrafficRouting) XXX_DiscardUnknown() { + xxx_messageInfo_TraefikTrafficRouting.DiscardUnknown(m) +} + +var xxx_messageInfo_TraefikTrafficRouting proto.InternalMessageInfo + +func (m *TrafficWeights) Reset() { *m = TrafficWeights{} } +func (*TrafficWeights) ProtoMessage() {} +func (*TrafficWeights) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{105} +} +func (m *TrafficWeights) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TrafficWeights) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *TrafficWeights) XXX_Merge(src proto.Message) { + xxx_messageInfo_TrafficWeights.Merge(m, src) +} +func (m *TrafficWeights) XXX_Size() int { + return m.Size() +} +func (m *TrafficWeights) XXX_DiscardUnknown() { + xxx_messageInfo_TrafficWeights.DiscardUnknown(m) +} + +var xxx_messageInfo_TrafficWeights proto.InternalMessageInfo + +func (m *ValueFrom) Reset() { *m = ValueFrom{} } +func (*ValueFrom) ProtoMessage() {} +func (*ValueFrom) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{106} +} +func (m *ValueFrom) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ValueFrom) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *ValueFrom) XXX_Merge(src proto.Message) { + xxx_messageInfo_ValueFrom.Merge(m, src) +} +func (m *ValueFrom) XXX_Size() int { + return m.Size() +} +func (m *ValueFrom) XXX_DiscardUnknown() { + xxx_messageInfo_ValueFrom.DiscardUnknown(m) +} + +var xxx_messageInfo_ValueFrom proto.InternalMessageInfo + +func (m *WavefrontMetric) Reset() { *m = WavefrontMetric{} } +func (*WavefrontMetric) ProtoMessage() {} +func (*WavefrontMetric) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{107} +} +func (m *WavefrontMetric) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *WavefrontMetric) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *WavefrontMetric) XXX_Merge(src proto.Message) { + xxx_messageInfo_WavefrontMetric.Merge(m, src) +} +func (m *WavefrontMetric) XXX_Size() int { + return m.Size() +} +func (m *WavefrontMetric) XXX_DiscardUnknown() { + xxx_messageInfo_WavefrontMetric.DiscardUnknown(m) +} + +var xxx_messageInfo_WavefrontMetric proto.InternalMessageInfo + +func (m *WebMetric) Reset() { *m = WebMetric{} } +func (*WebMetric) ProtoMessage() {} +func (*WebMetric) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{108} +} +func (m *WebMetric) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *WebMetric) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *WebMetric) XXX_Merge(src proto.Message) { + xxx_messageInfo_WebMetric.Merge(m, src) +} +func (m *WebMetric) XXX_Size() int { + return m.Size() +} +func (m *WebMetric) XXX_DiscardUnknown() { + xxx_messageInfo_WebMetric.DiscardUnknown(m) +} + +var xxx_messageInfo_WebMetric proto.InternalMessageInfo + +func (m *WebMetricHeader) Reset() { *m = WebMetricHeader{} } +func (*WebMetricHeader) ProtoMessage() {} +func (*WebMetricHeader) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{109} +} +func (m *WebMetricHeader) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *WebMetricHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *WebMetricHeader) XXX_Merge(src proto.Message) { + xxx_messageInfo_WebMetricHeader.Merge(m, src) +} +func (m *WebMetricHeader) XXX_Size() int { + return m.Size() +} +func (m *WebMetricHeader) XXX_DiscardUnknown() { + xxx_messageInfo_WebMetricHeader.DiscardUnknown(m) +} + +var xxx_messageInfo_WebMetricHeader proto.InternalMessageInfo + +func (m *WeightDestination) Reset() { *m = WeightDestination{} } +func (*WeightDestination) ProtoMessage() {} +func (*WeightDestination) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{110} +} +func (m *WeightDestination) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *WeightDestination) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *WeightDestination) XXX_Merge(src proto.Message) { + xxx_messageInfo_WeightDestination.Merge(m, src) +} +func (m *WeightDestination) XXX_Size() int { + return m.Size() +} +func (m *WeightDestination) XXX_DiscardUnknown() { + xxx_messageInfo_WeightDestination.DiscardUnknown(m) +} + +var xxx_messageInfo_WeightDestination proto.InternalMessageInfo + +func init() { + proto.RegisterType((*ALBStatus)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.ALBStatus") + proto.RegisterType((*ALBTrafficRouting)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.ALBTrafficRouting") + proto.RegisterType((*AmbassadorTrafficRouting)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.AmbassadorTrafficRouting") + proto.RegisterType((*AnalysisRun)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.AnalysisRun") + proto.RegisterType((*AnalysisRunArgument)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.AnalysisRunArgument") + proto.RegisterType((*AnalysisRunList)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.AnalysisRunList") + proto.RegisterType((*AnalysisRunMetadata)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.AnalysisRunMetadata") + proto.RegisterMapType((map[string]string)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.AnalysisRunMetadata.AnnotationsEntry") + proto.RegisterMapType((map[string]string)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.AnalysisRunMetadata.LabelsEntry") + proto.RegisterType((*AnalysisRunSpec)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.AnalysisRunSpec") + proto.RegisterType((*AnalysisRunStatus)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.AnalysisRunStatus") + proto.RegisterType((*AnalysisRunStrategy)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.AnalysisRunStrategy") + proto.RegisterType((*AnalysisTemplate)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.AnalysisTemplate") + proto.RegisterType((*AnalysisTemplateList)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.AnalysisTemplateList") + proto.RegisterType((*AnalysisTemplateSpec)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.AnalysisTemplateSpec") + proto.RegisterType((*AntiAffinity)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.AntiAffinity") + proto.RegisterType((*ApisixRoute)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.ApisixRoute") + proto.RegisterType((*ApisixTrafficRouting)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.ApisixTrafficRouting") + proto.RegisterType((*AppMeshTrafficRouting)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.AppMeshTrafficRouting") + proto.RegisterType((*AppMeshVirtualNodeGroup)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.AppMeshVirtualNodeGroup") + proto.RegisterType((*AppMeshVirtualNodeReference)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.AppMeshVirtualNodeReference") + proto.RegisterType((*AppMeshVirtualService)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.AppMeshVirtualService") + proto.RegisterType((*Argument)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.Argument") + proto.RegisterType((*ArgumentValueFrom)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.ArgumentValueFrom") + proto.RegisterType((*AwsResourceRef)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.AwsResourceRef") + proto.RegisterType((*BlueGreenStatus)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.BlueGreenStatus") + proto.RegisterType((*BlueGreenStrategy)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.BlueGreenStrategy") + proto.RegisterType((*CanaryStatus)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.CanaryStatus") + proto.RegisterType((*CanaryStep)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.CanaryStep") + proto.RegisterType((*CanaryStrategy)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.CanaryStrategy") + proto.RegisterType((*CloudWatchMetric)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.CloudWatchMetric") + proto.RegisterType((*CloudWatchMetricDataQuery)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.CloudWatchMetricDataQuery") + proto.RegisterType((*CloudWatchMetricStat)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.CloudWatchMetricStat") + proto.RegisterType((*CloudWatchMetricStatMetric)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.CloudWatchMetricStatMetric") + proto.RegisterType((*CloudWatchMetricStatMetricDimension)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.CloudWatchMetricStatMetricDimension") + proto.RegisterType((*ClusterAnalysisTemplate)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.ClusterAnalysisTemplate") + proto.RegisterType((*ClusterAnalysisTemplateList)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.ClusterAnalysisTemplateList") + proto.RegisterType((*DatadogMetric)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.DatadogMetric") + proto.RegisterType((*DryRun)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.DryRun") + proto.RegisterType((*Experiment)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.Experiment") + proto.RegisterType((*ExperimentAnalysisRunStatus)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.ExperimentAnalysisRunStatus") + proto.RegisterType((*ExperimentAnalysisTemplateRef)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.ExperimentAnalysisTemplateRef") + proto.RegisterType((*ExperimentCondition)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.ExperimentCondition") + proto.RegisterType((*ExperimentList)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.ExperimentList") + proto.RegisterType((*ExperimentSpec)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.ExperimentSpec") + proto.RegisterType((*ExperimentStatus)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.ExperimentStatus") + proto.RegisterType((*FieldRef)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.FieldRef") + proto.RegisterType((*GraphiteMetric)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.GraphiteMetric") + proto.RegisterType((*HeaderRoutingMatch)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.HeaderRoutingMatch") + proto.RegisterType((*InfluxdbMetric)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.InfluxdbMetric") + proto.RegisterType((*IstioDestinationRule)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.IstioDestinationRule") + proto.RegisterType((*IstioTrafficRouting)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.IstioTrafficRouting") + proto.RegisterType((*IstioVirtualService)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.IstioVirtualService") + proto.RegisterType((*JobMetric)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.JobMetric") + proto.RegisterType((*KayentaMetric)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.KayentaMetric") + proto.RegisterType((*KayentaScope)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.KayentaScope") + proto.RegisterType((*KayentaThreshold)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.KayentaThreshold") + proto.RegisterType((*MangedRoutes)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.MangedRoutes") + proto.RegisterType((*Measurement)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.Measurement") + proto.RegisterMapType((map[string]string)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.Measurement.MetadataEntry") + proto.RegisterType((*MeasurementRetention)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.MeasurementRetention") + proto.RegisterType((*Metric)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.Metric") + proto.RegisterType((*MetricProvider)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.MetricProvider") + proto.RegisterMapType((map[string]encoding_json.RawMessage)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.MetricProvider.PluginEntry") + proto.RegisterType((*MetricResult)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.MetricResult") + proto.RegisterMapType((map[string]string)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.MetricResult.MetadataEntry") + proto.RegisterType((*NewRelicMetric)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.NewRelicMetric") + proto.RegisterType((*NginxTrafficRouting)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.NginxTrafficRouting") + proto.RegisterMapType((map[string]string)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.NginxTrafficRouting.AdditionalIngressAnnotationsEntry") + proto.RegisterType((*ObjectRef)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.ObjectRef") + proto.RegisterType((*PauseCondition)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.PauseCondition") + proto.RegisterType((*PingPongSpec)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.PingPongSpec") + proto.RegisterType((*PodTemplateMetadata)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.PodTemplateMetadata") + proto.RegisterMapType((map[string]string)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.PodTemplateMetadata.AnnotationsEntry") + proto.RegisterMapType((map[string]string)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.PodTemplateMetadata.LabelsEntry") + proto.RegisterType((*PreferredDuringSchedulingIgnoredDuringExecution)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.PreferredDuringSchedulingIgnoredDuringExecution") + proto.RegisterType((*PrometheusAuth)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.PrometheusAuth") + proto.RegisterType((*PrometheusMetric)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.PrometheusMetric") + proto.RegisterType((*RequiredDuringSchedulingIgnoredDuringExecution)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.RequiredDuringSchedulingIgnoredDuringExecution") + proto.RegisterType((*RollbackWindowSpec)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.RollbackWindowSpec") + proto.RegisterType((*Rollout)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.Rollout") + proto.RegisterType((*RolloutAnalysis)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.RolloutAnalysis") + proto.RegisterType((*RolloutAnalysisBackground)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.RolloutAnalysisBackground") + proto.RegisterType((*RolloutAnalysisRunStatus)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.RolloutAnalysisRunStatus") + proto.RegisterType((*RolloutAnalysisTemplate)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.RolloutAnalysisTemplate") + proto.RegisterType((*RolloutCondition)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.RolloutCondition") + proto.RegisterType((*RolloutExperimentStep)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.RolloutExperimentStep") + proto.RegisterType((*RolloutExperimentStepAnalysisTemplateRef)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.RolloutExperimentStepAnalysisTemplateRef") + proto.RegisterType((*RolloutExperimentTemplate)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.RolloutExperimentTemplate") + proto.RegisterType((*RolloutList)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.RolloutList") + proto.RegisterType((*RolloutPause)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.RolloutPause") + proto.RegisterType((*RolloutSpec)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.RolloutSpec") + proto.RegisterType((*RolloutStatus)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.RolloutStatus") + proto.RegisterType((*RolloutStrategy)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.RolloutStrategy") + proto.RegisterType((*RolloutTrafficRouting)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.RolloutTrafficRouting") + proto.RegisterMapType((map[string]encoding_json.RawMessage)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.RolloutTrafficRouting.PluginsEntry") + proto.RegisterType((*RouteMatch)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.RouteMatch") + proto.RegisterMapType((map[string]StringMatch)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.RouteMatch.HeadersEntry") + proto.RegisterType((*RunSummary)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.RunSummary") + proto.RegisterType((*SMITrafficRouting)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.SMITrafficRouting") + proto.RegisterType((*ScopeDetail)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.ScopeDetail") + proto.RegisterType((*SecretKeyRef)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.SecretKeyRef") + proto.RegisterType((*SetCanaryScale)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.SetCanaryScale") + proto.RegisterType((*SetHeaderRoute)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.SetHeaderRoute") + proto.RegisterType((*SetMirrorRoute)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.SetMirrorRoute") + proto.RegisterType((*Sigv4Config)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.Sigv4Config") + proto.RegisterType((*SkyWalkingMetric)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.SkyWalkingMetric") + proto.RegisterType((*StickinessConfig)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.StickinessConfig") + proto.RegisterType((*StringMatch)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.StringMatch") + proto.RegisterType((*TCPRoute)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.TCPRoute") + proto.RegisterType((*TLSRoute)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.TLSRoute") + proto.RegisterType((*TemplateService)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.TemplateService") + proto.RegisterType((*TemplateSpec)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.TemplateSpec") + proto.RegisterType((*TemplateStatus)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.TemplateStatus") + proto.RegisterType((*TraefikTrafficRouting)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.TraefikTrafficRouting") + proto.RegisterType((*TrafficWeights)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.TrafficWeights") + proto.RegisterType((*ValueFrom)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.ValueFrom") + proto.RegisterType((*WavefrontMetric)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.WavefrontMetric") + proto.RegisterType((*WebMetric)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.WebMetric") + proto.RegisterType((*WebMetricHeader)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.WebMetricHeader") + proto.RegisterType((*WeightDestination)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.WeightDestination") +} + +func init() { + proto.RegisterFile("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1/generated.proto", fileDescriptor_e0e705f843545fab) +} + +var fileDescriptor_e0e705f843545fab = []byte{ + // 8214 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x7d, 0x6d, 0x6c, 0x24, 0xc9, + 0x75, 0xd8, 0x35, 0x87, 0x43, 0x72, 0x1e, 0xb9, 0x24, 0xb7, 0x76, 0x57, 0xcb, 0xe3, 0xdd, 0xee, + 0x9c, 0xfa, 0x9c, 0xcb, 0xca, 0x3a, 0x91, 0xd2, 0x7d, 0x24, 0x27, 0x9d, 0x72, 0xc9, 0x0c, 0xb9, + 0x7b, 0xcb, 0x3d, 0x72, 0x6f, 0xf6, 0x0d, 0xf7, 0x56, 0x96, 0x74, 0xb6, 0x9a, 0x33, 0xc5, 0x61, + 0x2f, 0x67, 0xba, 0xc7, 0xdd, 0x3d, 0xdc, 0xe5, 0xe9, 0x60, 0x9d, 0x2c, 0x9c, 0xa2, 0x18, 0x12, + 0xac, 0xc4, 0x16, 0x82, 0x20, 0x41, 0xa0, 0x18, 0x06, 0xec, 0xc4, 0xfe, 0x25, 0x24, 0xc8, 0x1f, + 0x03, 0x11, 0xe2, 0xd8, 0xd6, 0x8f, 0x38, 0x90, 0x7f, 0x24, 0xb2, 0x03, 0x98, 0x8e, 0xa8, 0xfc, + 0x49, 0x90, 0x40, 0x08, 0xe0, 0x20, 0xf0, 0xfe, 0x08, 0x82, 0xfa, 0xec, 0xea, 0x9e, 0x1e, 0xee, + 0xcc, 0x4e, 0x73, 0x75, 0x49, 0xfc, 0x6f, 0xa6, 0x5e, 0xd5, 0x7b, 0xaf, 0xeb, 0xe3, 0xd5, 0xab, + 0x57, 0xef, 0xbd, 0x82, 0xcd, 0x96, 0x1b, 0xed, 0xf5, 0x76, 0x56, 0x1a, 0x7e, 0x67, 0xd5, 0x09, + 0x5a, 0x7e, 0x37, 0xf0, 0xef, 0xf2, 0x1f, 0x1f, 0x0b, 0xfc, 0x76, 0xdb, 0xef, 0x45, 0xe1, 0x6a, + 0x77, 0xbf, 0xb5, 0xea, 0x74, 0xdd, 0x70, 0x55, 0x97, 0x1c, 0x7c, 0xc2, 0x69, 0x77, 0xf7, 0x9c, + 0x4f, 0xac, 0xb6, 0xa8, 0x47, 0x03, 0x27, 0xa2, 0xcd, 0x95, 0x6e, 0xe0, 0x47, 0x3e, 0xf9, 0x74, + 0x8c, 0x6d, 0x45, 0x61, 0xe3, 0x3f, 0x7e, 0x4e, 0xb5, 0x5d, 0xe9, 0xee, 0xb7, 0x56, 0x18, 0xb6, + 0x15, 0x5d, 0xa2, 0xb0, 0x2d, 0x7f, 0xcc, 0xe0, 0xa5, 0xe5, 0xb7, 0xfc, 0x55, 0x8e, 0x74, 0xa7, + 0xb7, 0xcb, 0xff, 0xf1, 0x3f, 0xfc, 0x97, 0x20, 0xb6, 0xfc, 0xec, 0xfe, 0x2b, 0xe1, 0x8a, 0xeb, + 0x33, 0xde, 0x56, 0x77, 0x9c, 0xa8, 0xb1, 0xb7, 0x7a, 0xd0, 0xc7, 0xd1, 0xb2, 0x6d, 0x54, 0x6a, + 0xf8, 0x01, 0xcd, 0xaa, 0xf3, 0x52, 0x5c, 0xa7, 0xe3, 0x34, 0xf6, 0x5c, 0x8f, 0x06, 0x87, 0xf1, + 0x57, 0x77, 0x68, 0xe4, 0x64, 0xb5, 0x5a, 0x1d, 0xd4, 0x2a, 0xe8, 0x79, 0x91, 0xdb, 0xa1, 0x7d, + 0x0d, 0xfe, 0xda, 0xc3, 0x1a, 0x84, 0x8d, 0x3d, 0xda, 0x71, 0xfa, 0xda, 0xbd, 0x38, 0xa8, 0x5d, + 0x2f, 0x72, 0xdb, 0xab, 0xae, 0x17, 0x85, 0x51, 0x90, 0x6e, 0x64, 0xff, 0xb8, 0x00, 0xa5, 0xca, + 0x66, 0xb5, 0x1e, 0x39, 0x51, 0x2f, 0x24, 0x5f, 0xb5, 0x60, 0xae, 0xed, 0x3b, 0xcd, 0xaa, 0xd3, + 0x76, 0xbc, 0x06, 0x0d, 0x96, 0xac, 0x67, 0xac, 0x2b, 0xb3, 0x2f, 0x6c, 0xae, 0x8c, 0x33, 0x5e, + 0x2b, 0x95, 0x7b, 0x21, 0xd2, 0xd0, 0xef, 0x05, 0x0d, 0x8a, 0x74, 0xb7, 0x7a, 0xfe, 0x7b, 0x47, + 0xe5, 0x27, 0x8e, 0x8f, 0xca, 0x73, 0x9b, 0x06, 0x25, 0x4c, 0xd0, 0x25, 0xdf, 0xb2, 0xe0, 0x6c, + 0xc3, 0xf1, 0x9c, 0xe0, 0x70, 0xdb, 0x09, 0x5a, 0x34, 0x7a, 0x3d, 0xf0, 0x7b, 0xdd, 0xa5, 0x89, + 0x53, 0xe0, 0xe6, 0x49, 0xc9, 0xcd, 0xd9, 0xb5, 0x34, 0x39, 0xec, 0xe7, 0x80, 0xf3, 0x15, 0x46, + 0xce, 0x4e, 0x9b, 0x9a, 0x7c, 0x15, 0x4e, 0x93, 0xaf, 0x7a, 0x9a, 0x1c, 0xf6, 0x73, 0x40, 0x3e, + 0x02, 0xd3, 0xae, 0xd7, 0x0a, 0x68, 0x18, 0x2e, 0x4d, 0x3e, 0x63, 0x5d, 0x29, 0x55, 0x17, 0x64, + 0xf3, 0xe9, 0x0d, 0x51, 0x8c, 0x0a, 0x6e, 0x7f, 0xa7, 0x00, 0x67, 0x2b, 0x9b, 0xd5, 0xed, 0xc0, + 0xd9, 0xdd, 0x75, 0x1b, 0xe8, 0xf7, 0x22, 0xd7, 0x6b, 0x99, 0x08, 0xac, 0x93, 0x11, 0x90, 0x97, + 0x61, 0x36, 0xa4, 0xc1, 0x81, 0xdb, 0xa0, 0x35, 0x3f, 0x88, 0xf8, 0xa0, 0x14, 0xab, 0xe7, 0x64, + 0xf5, 0xd9, 0x7a, 0x0c, 0x42, 0xb3, 0x1e, 0x6b, 0x16, 0xf8, 0x7e, 0x24, 0xe1, 0xbc, 0xcf, 0x4a, + 0x71, 0x33, 0x8c, 0x41, 0x68, 0xd6, 0x23, 0xeb, 0xb0, 0xe8, 0x78, 0x9e, 0x1f, 0x39, 0x91, 0xeb, + 0x7b, 0xb5, 0x80, 0xee, 0xba, 0xf7, 0xe5, 0x27, 0x2e, 0xc9, 0xb6, 0x8b, 0x95, 0x14, 0x1c, 0xfb, + 0x5a, 0x90, 0x6f, 0x5a, 0xb0, 0x18, 0x46, 0x6e, 0x63, 0xdf, 0xf5, 0x68, 0x18, 0xae, 0xf9, 0xde, + 0xae, 0xdb, 0x5a, 0x2a, 0xf2, 0x61, 0xbb, 0x39, 0xde, 0xb0, 0xd5, 0x53, 0x58, 0xab, 0xe7, 0x19, + 0x4b, 0xe9, 0x52, 0xec, 0xa3, 0x4e, 0x3e, 0x0a, 0x25, 0xd9, 0xa3, 0x34, 0x5c, 0x9a, 0x7a, 0xa6, + 0x70, 0xa5, 0x54, 0x3d, 0x73, 0x7c, 0x54, 0x2e, 0x6d, 0xa8, 0x42, 0x8c, 0xe1, 0xf6, 0x3a, 0x2c, + 0x55, 0x3a, 0x3b, 0x4e, 0x18, 0x3a, 0x4d, 0x3f, 0x48, 0x0d, 0xdd, 0x15, 0x98, 0xe9, 0x38, 0xdd, + 0xae, 0xeb, 0xb5, 0xd8, 0xd8, 0x31, 0x3c, 0x73, 0xc7, 0x47, 0xe5, 0x99, 0x2d, 0x59, 0x86, 0x1a, + 0x6a, 0xff, 0xc9, 0x04, 0xcc, 0x56, 0x3c, 0xa7, 0x7d, 0x18, 0xba, 0x21, 0xf6, 0x3c, 0xf2, 0x05, + 0x98, 0x61, 0x52, 0xab, 0xe9, 0x44, 0x8e, 0x5c, 0xe9, 0x1f, 0x5f, 0x11, 0x42, 0x64, 0xc5, 0x14, + 0x22, 0xf1, 0xe7, 0xb3, 0xda, 0x2b, 0x07, 0x9f, 0x58, 0x79, 0x73, 0xe7, 0x2e, 0x6d, 0x44, 0x5b, + 0x34, 0x72, 0xaa, 0x44, 0x8e, 0x02, 0xc4, 0x65, 0xa8, 0xb1, 0x12, 0x1f, 0x26, 0xc3, 0x2e, 0x6d, + 0xc8, 0x95, 0xbb, 0x35, 0xe6, 0x0a, 0x89, 0x59, 0xaf, 0x77, 0x69, 0xa3, 0x3a, 0x27, 0x49, 0x4f, + 0xb2, 0x7f, 0xc8, 0x09, 0x91, 0x7b, 0x30, 0x15, 0x72, 0x59, 0x26, 0x17, 0xe5, 0x9b, 0xf9, 0x91, + 0xe4, 0x68, 0xab, 0xf3, 0x92, 0xe8, 0x94, 0xf8, 0x8f, 0x92, 0x9c, 0xfd, 0x1f, 0x2d, 0x38, 0x67, + 0xd4, 0xae, 0x04, 0xad, 0x5e, 0x87, 0x7a, 0x11, 0x79, 0x06, 0x26, 0x3d, 0xa7, 0x43, 0xe5, 0xaa, + 0xd2, 0x2c, 0xdf, 0x74, 0x3a, 0x14, 0x39, 0x84, 0x3c, 0x0b, 0xc5, 0x03, 0xa7, 0xdd, 0xa3, 0xbc, + 0x93, 0x4a, 0xd5, 0x33, 0xb2, 0x4a, 0xf1, 0x2d, 0x56, 0x88, 0x02, 0x46, 0xde, 0x85, 0x12, 0xff, + 0x71, 0x2d, 0xf0, 0x3b, 0x39, 0x7d, 0x9a, 0xe4, 0xf0, 0x2d, 0x85, 0x56, 0x4c, 0x3f, 0xfd, 0x17, + 0x63, 0x82, 0xf6, 0x9f, 0x59, 0xb0, 0x60, 0x7c, 0xdc, 0xa6, 0x1b, 0x46, 0xe4, 0xf3, 0x7d, 0x93, + 0x67, 0x65, 0xb8, 0xc9, 0xc3, 0x5a, 0xf3, 0xa9, 0xb3, 0x28, 0xbf, 0x74, 0x46, 0x95, 0x18, 0x13, + 0xc7, 0x83, 0xa2, 0x1b, 0xd1, 0x4e, 0xb8, 0x34, 0xf1, 0x4c, 0xe1, 0xca, 0xec, 0x0b, 0x1b, 0xb9, + 0x0d, 0x63, 0xdc, 0xbf, 0x1b, 0x0c, 0x3f, 0x0a, 0x32, 0xf6, 0x3f, 0x2f, 0x24, 0x86, 0x6f, 0x4b, + 0xf1, 0xf1, 0xbe, 0x05, 0x53, 0x6d, 0x67, 0x87, 0xb6, 0xc5, 0xda, 0x9a, 0x7d, 0xe1, 0xed, 0xdc, + 0x38, 0x51, 0x34, 0x56, 0x36, 0x39, 0xfe, 0xab, 0x5e, 0x14, 0x1c, 0xc6, 0xd3, 0x4b, 0x14, 0xa2, + 0x24, 0x4e, 0xfe, 0x81, 0x05, 0xb3, 0xb1, 0x54, 0x53, 0xdd, 0xb2, 0x93, 0x3f, 0x33, 0xb1, 0x30, + 0x95, 0x1c, 0x69, 0x11, 0x6d, 0x40, 0xd0, 0xe4, 0x65, 0xf9, 0x93, 0x30, 0x6b, 0x7c, 0x02, 0x59, + 0x84, 0xc2, 0x3e, 0x3d, 0x14, 0x13, 0x1e, 0xd9, 0x4f, 0x72, 0x3e, 0x31, 0xc3, 0xe5, 0x94, 0xfe, + 0xd4, 0xc4, 0x2b, 0xd6, 0xf2, 0x6b, 0xb0, 0x98, 0x26, 0x38, 0x4a, 0x7b, 0xfb, 0x3b, 0x93, 0x89, + 0x89, 0xc9, 0x04, 0x01, 0xf1, 0x61, 0xba, 0x43, 0xa3, 0xc0, 0x6d, 0xa8, 0x21, 0x5b, 0x1f, 0xaf, + 0x97, 0xb6, 0x38, 0xb2, 0x78, 0x43, 0x14, 0xff, 0x43, 0x54, 0x54, 0xc8, 0x1e, 0x4c, 0x3a, 0x41, + 0x4b, 0x8d, 0xc9, 0xb5, 0x7c, 0x96, 0x65, 0x2c, 0x2a, 0x2a, 0x41, 0x2b, 0x44, 0x4e, 0x81, 0xac, + 0x42, 0x29, 0xa2, 0x41, 0xc7, 0xf5, 0x9c, 0x48, 0xec, 0xa0, 0x33, 0xd5, 0xb3, 0xb2, 0x5a, 0x69, + 0x5b, 0x01, 0x30, 0xae, 0x43, 0xda, 0x30, 0xd5, 0x0c, 0x0e, 0xb1, 0xe7, 0x2d, 0x4d, 0xe6, 0xd1, + 0x15, 0xeb, 0x1c, 0x57, 0x3c, 0x49, 0xc5, 0x7f, 0x94, 0x34, 0xc8, 0xaf, 0x5b, 0x70, 0xbe, 0x43, + 0x9d, 0xb0, 0x17, 0x50, 0xf6, 0x09, 0x48, 0x23, 0xea, 0xb1, 0x81, 0x5d, 0x2a, 0x72, 0xe2, 0x38, + 0xee, 0x38, 0xf4, 0x63, 0xae, 0x3e, 0x2d, 0x59, 0x39, 0x9f, 0x05, 0xc5, 0x4c, 0x6e, 0xec, 0x3f, + 0x99, 0x84, 0xb3, 0x7d, 0x82, 0x9d, 0xbc, 0x04, 0xc5, 0xee, 0x9e, 0x13, 0x2a, 0x49, 0x7d, 0x59, + 0x89, 0x89, 0x1a, 0x2b, 0x7c, 0x70, 0x54, 0x3e, 0xa3, 0x9a, 0xf0, 0x02, 0x14, 0x95, 0x99, 0xde, + 0xd4, 0xa1, 0x61, 0xe8, 0xb4, 0x94, 0xf8, 0x36, 0xa6, 0x09, 0x2f, 0x46, 0x05, 0x27, 0x7f, 0xdb, + 0x82, 0x33, 0x62, 0xca, 0x20, 0x0d, 0x7b, 0xed, 0x88, 0x6d, 0x51, 0xac, 0x5b, 0x6e, 0xe4, 0x31, + 0x3d, 0x05, 0xca, 0xea, 0x05, 0x49, 0xfd, 0x8c, 0x59, 0x1a, 0x62, 0x92, 0x2e, 0xb9, 0x03, 0xa5, + 0x30, 0x72, 0x82, 0x88, 0x36, 0x2b, 0x11, 0x57, 0xa6, 0x66, 0x5f, 0xf8, 0xe9, 0xe1, 0x64, 0xf7, + 0xb6, 0xdb, 0xa1, 0x62, 0x9f, 0xa8, 0x2b, 0x04, 0x18, 0xe3, 0x22, 0xef, 0x02, 0x04, 0x3d, 0xaf, + 0xde, 0xeb, 0x74, 0x9c, 0xe0, 0x50, 0xea, 0x57, 0xd7, 0xc7, 0xfb, 0x3c, 0xd4, 0xf8, 0x62, 0x55, + 0x23, 0x2e, 0x43, 0x83, 0x1e, 0xf9, 0xb2, 0x05, 0x67, 0xc4, 0x4c, 0x54, 0x1c, 0x4c, 0xe5, 0xcc, + 0xc1, 0x59, 0xd6, 0xb5, 0xeb, 0x26, 0x09, 0x4c, 0x52, 0xb4, 0xff, 0x7d, 0x52, 0x0d, 0xa8, 0x47, + 0xec, 0xb0, 0xd5, 0x3a, 0x24, 0x9f, 0x83, 0x27, 0xc3, 0x5e, 0xa3, 0x41, 0xc3, 0x70, 0xb7, 0xd7, + 0xc6, 0x9e, 0x77, 0xdd, 0x0d, 0x23, 0x3f, 0x38, 0xdc, 0x74, 0x3b, 0x6e, 0xc4, 0x67, 0x5c, 0xb1, + 0x7a, 0xe9, 0xf8, 0xa8, 0xfc, 0x64, 0x7d, 0x50, 0x25, 0x1c, 0xdc, 0x9e, 0x38, 0xf0, 0x54, 0xcf, + 0x1b, 0x8c, 0x5e, 0x68, 0xe8, 0xe5, 0xe3, 0xa3, 0xf2, 0x53, 0xb7, 0x07, 0x57, 0xc3, 0x93, 0x70, + 0xd8, 0xff, 0xd5, 0x62, 0x92, 0x5a, 0x7c, 0xd7, 0x36, 0xed, 0x74, 0xdb, 0x4c, 0xba, 0x9c, 0xbe, + 0xfe, 0x18, 0x25, 0xf4, 0x47, 0xcc, 0x67, 0xbb, 0x53, 0xfc, 0x0f, 0x52, 0x22, 0xed, 0xff, 0x62, + 0xc1, 0xf9, 0x74, 0xe5, 0xc7, 0xa0, 0xf3, 0x84, 0x49, 0x9d, 0xe7, 0x66, 0xbe, 0x5f, 0x3b, 0x40, + 0xf1, 0xf9, 0xea, 0x64, 0xff, 0xb7, 0xfe, 0xbf, 0xbe, 0x8d, 0xc6, 0xbb, 0x62, 0xe1, 0x27, 0xb9, + 0x2b, 0x4e, 0x7e, 0xa0, 0x76, 0xc5, 0xdf, 0x9c, 0x84, 0xb9, 0x8a, 0x17, 0xb9, 0x95, 0xdd, 0x5d, + 0xd7, 0x73, 0xa3, 0x43, 0xf2, 0xf5, 0x09, 0x58, 0xed, 0x06, 0x74, 0x97, 0x06, 0x01, 0x6d, 0xae, + 0xf7, 0x02, 0xd7, 0x6b, 0xd5, 0x1b, 0x7b, 0xb4, 0xd9, 0x6b, 0xbb, 0x5e, 0x6b, 0xa3, 0xe5, 0xf9, + 0xba, 0xf8, 0xea, 0x7d, 0xda, 0xe8, 0xf1, 0x4f, 0x12, 0x8b, 0xa2, 0x33, 0xde, 0x27, 0xd5, 0x46, + 0x23, 0x5a, 0x7d, 0xf1, 0xf8, 0xa8, 0xbc, 0x3a, 0x62, 0x23, 0x1c, 0xf5, 0xd3, 0xc8, 0xd7, 0x26, + 0x60, 0x25, 0xa0, 0x3f, 0xdf, 0x73, 0x87, 0xef, 0x0d, 0x21, 0xb5, 0xda, 0x63, 0x6e, 0x3f, 0x23, + 0xd1, 0xac, 0xbe, 0x70, 0x7c, 0x54, 0x1e, 0xb1, 0x0d, 0x8e, 0xf8, 0x5d, 0x76, 0x0d, 0x66, 0x2b, + 0x5d, 0x37, 0x74, 0xef, 0xa3, 0xdf, 0x8b, 0xe8, 0x10, 0x47, 0xdc, 0x32, 0x14, 0x83, 0x5e, 0x9b, + 0x8a, 0xb5, 0x5d, 0xaa, 0x96, 0x98, 0x14, 0x42, 0x56, 0x80, 0xa2, 0xdc, 0xfe, 0x45, 0x26, 0x71, + 0x39, 0xca, 0x94, 0x71, 0xe3, 0x2e, 0x14, 0x03, 0x46, 0x44, 0xce, 0xac, 0x71, 0xcf, 0x81, 0x31, + 0xd7, 0x92, 0x09, 0xf6, 0x13, 0x05, 0x09, 0xfb, 0x77, 0x27, 0xe0, 0x42, 0xa5, 0xdb, 0xdd, 0xa2, + 0xe1, 0x5e, 0x8a, 0x8b, 0x5f, 0xb6, 0x60, 0xfe, 0xc0, 0x0d, 0xa2, 0x9e, 0xd3, 0x56, 0xf6, 0x2b, + 0xc1, 0x4f, 0x7d, 0x5c, 0x7e, 0x38, 0xb5, 0xb7, 0x12, 0xa8, 0xab, 0xe4, 0xf8, 0xa8, 0x3c, 0x9f, + 0x2c, 0xc3, 0x14, 0x79, 0xf2, 0xf7, 0x2d, 0x58, 0x94, 0x45, 0x37, 0xfd, 0x26, 0x35, 0xed, 0xa3, + 0xb7, 0xf3, 0xe4, 0x49, 0x23, 0x17, 0x76, 0xad, 0x74, 0x29, 0xf6, 0x31, 0x61, 0xff, 0xf7, 0x09, + 0xb8, 0x38, 0x00, 0x07, 0xf9, 0x0d, 0x0b, 0xce, 0x0b, 0xa3, 0xaa, 0x01, 0x42, 0xba, 0x2b, 0x7b, + 0xf3, 0x67, 0xf2, 0xe6, 0x1c, 0xd9, 0x12, 0xa7, 0x5e, 0x83, 0x56, 0x97, 0x98, 0x34, 0x5c, 0xcb, + 0x20, 0x8d, 0x99, 0x0c, 0x71, 0x4e, 0x85, 0x99, 0x35, 0xc5, 0xe9, 0xc4, 0x63, 0xe1, 0xb4, 0x9e, + 0x41, 0x1a, 0x33, 0x19, 0xb2, 0xff, 0x26, 0x3c, 0x75, 0x02, 0xba, 0x87, 0x2f, 0x4e, 0xfb, 0x6d, + 0x3d, 0xeb, 0x93, 0x73, 0x6e, 0x88, 0x75, 0x6d, 0xc3, 0x14, 0x5f, 0x3a, 0x6a, 0x61, 0x03, 0xdb, + 0xfe, 0xf8, 0x9a, 0x0a, 0x51, 0x42, 0xec, 0xdf, 0xb5, 0x60, 0x66, 0x04, 0x6b, 0x58, 0x39, 0x69, + 0x0d, 0x2b, 0xf5, 0x59, 0xc2, 0xa2, 0x7e, 0x4b, 0xd8, 0xeb, 0xe3, 0x8d, 0xc6, 0x30, 0x16, 0xb0, + 0x1f, 0x5b, 0x70, 0xb6, 0xcf, 0x62, 0x46, 0xf6, 0xe0, 0x7c, 0xd7, 0x6f, 0x2a, 0xb5, 0xe9, 0xba, + 0x13, 0xee, 0x71, 0x98, 0xfc, 0xbc, 0x97, 0xd8, 0x48, 0xd6, 0x32, 0xe0, 0x0f, 0x8e, 0xca, 0x4b, + 0x1a, 0x49, 0xaa, 0x02, 0x66, 0x62, 0x24, 0x5d, 0x98, 0xd9, 0x75, 0x69, 0xbb, 0x19, 0x4f, 0xc1, + 0x31, 0x15, 0xa4, 0x6b, 0x12, 0x9b, 0x30, 0x16, 0xab, 0x7f, 0xa8, 0xa9, 0xd8, 0x5f, 0x82, 0xf9, + 0xe4, 0x95, 0xc4, 0x10, 0x83, 0x77, 0x09, 0x0a, 0x4e, 0xe0, 0xc9, 0xa1, 0x9b, 0x95, 0x15, 0x0a, + 0x15, 0xbc, 0x89, 0xac, 0x9c, 0x3c, 0x0f, 0x33, 0xbb, 0xbd, 0x76, 0x9b, 0x35, 0x90, 0xf6, 0x7f, + 0xad, 0x0e, 0x5f, 0x93, 0xe5, 0xa8, 0x6b, 0xd8, 0x7f, 0x31, 0x09, 0x0b, 0xd5, 0x76, 0x8f, 0xbe, + 0x1e, 0x50, 0xaa, 0x0e, 0xe9, 0x15, 0x58, 0xe8, 0x06, 0xf4, 0xc0, 0xa5, 0xf7, 0xea, 0xb4, 0x4d, + 0x1b, 0x91, 0x1f, 0x48, 0x6e, 0x2e, 0x4a, 0x44, 0x0b, 0xb5, 0x24, 0x18, 0xd3, 0xf5, 0xc9, 0x6b, + 0x30, 0xef, 0x34, 0x22, 0xf7, 0x80, 0x6a, 0x0c, 0x82, 0xdd, 0x0f, 0x49, 0x0c, 0xf3, 0x95, 0x04, + 0x14, 0x53, 0xb5, 0xc9, 0xe7, 0x61, 0x29, 0x6c, 0x38, 0x6d, 0x7a, 0xbb, 0x2b, 0x49, 0xad, 0xed, + 0xd1, 0xc6, 0x7e, 0xcd, 0x77, 0xbd, 0x48, 0x9a, 0x64, 0x9e, 0x91, 0x98, 0x96, 0xea, 0x03, 0xea, + 0xe1, 0x40, 0x0c, 0xe4, 0x5f, 0x59, 0x70, 0xa9, 0x1b, 0xd0, 0x5a, 0xe0, 0x77, 0x7c, 0xb6, 0xd7, + 0xf6, 0xd9, 0x29, 0xe4, 0x79, 0xfd, 0xad, 0x31, 0x95, 0x0a, 0x51, 0xd2, 0x6f, 0xde, 0xfe, 0xf0, + 0xf1, 0x51, 0xf9, 0x52, 0xed, 0x24, 0x06, 0xf0, 0x64, 0xfe, 0xc8, 0xbf, 0xb6, 0xe0, 0x72, 0xd7, + 0x0f, 0xa3, 0x13, 0x3e, 0xa1, 0x78, 0xaa, 0x9f, 0x60, 0x1f, 0x1f, 0x95, 0x2f, 0xd7, 0x4e, 0xe4, + 0x00, 0x1f, 0xc2, 0xa1, 0x7d, 0x3c, 0x0b, 0x67, 0x8d, 0xb9, 0x27, 0x0f, 0xf1, 0xaf, 0xc2, 0x19, + 0x35, 0x19, 0x62, 0x25, 0xa0, 0x14, 0x1b, 0x5d, 0x2a, 0x26, 0x10, 0x93, 0x75, 0xd9, 0xbc, 0xd3, + 0x53, 0x51, 0xb4, 0x4e, 0xcd, 0xbb, 0x5a, 0x02, 0x8a, 0xa9, 0xda, 0x64, 0x03, 0xce, 0xc9, 0x12, + 0xa4, 0xdd, 0xb6, 0xdb, 0x70, 0xd6, 0xfc, 0x9e, 0x9c, 0x72, 0xc5, 0xea, 0xc5, 0xe3, 0xa3, 0xf2, + 0xb9, 0x5a, 0x3f, 0x18, 0xb3, 0xda, 0x90, 0x4d, 0x38, 0xef, 0xf4, 0x22, 0x5f, 0x7f, 0xff, 0x55, + 0x8f, 0xed, 0x2b, 0x4d, 0x3e, 0xb5, 0x66, 0xc4, 0x06, 0x54, 0xc9, 0x80, 0x63, 0x66, 0x2b, 0x52, + 0x4b, 0x61, 0xab, 0xd3, 0x86, 0xef, 0x35, 0xc5, 0x28, 0x17, 0xe3, 0xa3, 0x48, 0x25, 0xa3, 0x0e, + 0x66, 0xb6, 0x24, 0x6d, 0x98, 0xef, 0x38, 0xf7, 0x6f, 0x7b, 0xce, 0x81, 0xe3, 0xb6, 0x19, 0x11, + 0x69, 0xc8, 0x19, 0x6c, 0x5d, 0xe8, 0x45, 0x6e, 0x7b, 0x45, 0x5c, 0x71, 0xaf, 0x6c, 0x78, 0xd1, + 0x9b, 0x41, 0x3d, 0x62, 0x2a, 0xab, 0x50, 0xa5, 0xb6, 0x12, 0xb8, 0x30, 0x85, 0x9b, 0xbc, 0x09, + 0x17, 0xf8, 0x72, 0x5c, 0xf7, 0xef, 0x79, 0xeb, 0xb4, 0xed, 0x1c, 0xaa, 0x0f, 0x98, 0xe6, 0x1f, + 0xf0, 0xe4, 0xf1, 0x51, 0xf9, 0x42, 0x3d, 0xab, 0x02, 0x66, 0xb7, 0x23, 0x0e, 0x3c, 0x95, 0x04, + 0x20, 0x3d, 0x70, 0x43, 0xd7, 0xf7, 0x84, 0x39, 0x66, 0x26, 0x36, 0xc7, 0xd4, 0x07, 0x57, 0xc3, + 0x93, 0x70, 0x90, 0x7f, 0x68, 0xc1, 0xf9, 0xac, 0x65, 0xb8, 0x54, 0xca, 0xe3, 0xa2, 0x2d, 0xb5, + 0xb4, 0xc4, 0x8c, 0xc8, 0x14, 0x0a, 0x99, 0x4c, 0x90, 0xf7, 0x2c, 0x98, 0x73, 0x8c, 0xa3, 0xe4, + 0x12, 0x70, 0xae, 0x6e, 0x8c, 0x6b, 0xd0, 0x88, 0x31, 0x56, 0x17, 0x8f, 0x8f, 0xca, 0x89, 0xe3, + 0x2a, 0x26, 0x28, 0x92, 0x7f, 0x6c, 0xc1, 0x85, 0xcc, 0x35, 0xbe, 0x34, 0x7b, 0x1a, 0x3d, 0xc4, + 0x27, 0x49, 0xb6, 0xcc, 0xc9, 0x66, 0x83, 0x7c, 0xd3, 0xd2, 0x5b, 0x99, 0xba, 0x7b, 0x59, 0x9a, + 0xe3, 0xac, 0xdd, 0x1a, 0xf3, 0xf4, 0x1c, 0xab, 0x0f, 0x0a, 0x71, 0xf5, 0x9c, 0xb1, 0x33, 0xaa, + 0x42, 0x4c, 0x93, 0x27, 0xdf, 0xb0, 0xd4, 0xd6, 0xa8, 0x39, 0x3a, 0x73, 0x5a, 0x1c, 0x91, 0x78, + 0xa7, 0xd5, 0x0c, 0xa5, 0x88, 0x93, 0x9f, 0x85, 0x65, 0x67, 0xc7, 0x0f, 0xa2, 0xcc, 0xc5, 0xb7, + 0x34, 0xcf, 0x97, 0xd1, 0xe5, 0xe3, 0xa3, 0xf2, 0x72, 0x65, 0x60, 0x2d, 0x3c, 0x01, 0x83, 0xfd, + 0xdb, 0x45, 0x98, 0x13, 0x47, 0x02, 0xb9, 0x75, 0xfd, 0x8e, 0x05, 0x4f, 0x37, 0x7a, 0x41, 0x40, + 0xbd, 0xa8, 0x1e, 0xd1, 0x6e, 0xff, 0xc6, 0x65, 0x9d, 0xea, 0xc6, 0xf5, 0xcc, 0xf1, 0x51, 0xf9, + 0xe9, 0xb5, 0x13, 0xe8, 0xe3, 0x89, 0xdc, 0x91, 0x7f, 0x67, 0x81, 0x2d, 0x2b, 0x54, 0x9d, 0xc6, + 0x7e, 0x2b, 0xf0, 0x7b, 0x5e, 0xb3, 0xff, 0x23, 0x26, 0x4e, 0xf5, 0x23, 0x9e, 0x3b, 0x3e, 0x2a, + 0xdb, 0x6b, 0x0f, 0xe5, 0x02, 0x87, 0xe0, 0x94, 0xbc, 0x0e, 0x67, 0x65, 0xad, 0xab, 0xf7, 0xbb, + 0x34, 0x70, 0x99, 0xf2, 0x2d, 0x15, 0xc7, 0xd8, 0x6d, 0x27, 0x5d, 0x01, 0xfb, 0xdb, 0x90, 0x10, + 0xa6, 0xef, 0x51, 0xb7, 0xb5, 0x17, 0x29, 0xf5, 0x69, 0x4c, 0x5f, 0x1d, 0x69, 0x1e, 0xb8, 0x23, + 0x70, 0x56, 0x67, 0x8f, 0x8f, 0xca, 0xd3, 0xf2, 0x0f, 0x2a, 0x4a, 0xe4, 0x26, 0xcc, 0x8b, 0x03, + 0x5b, 0xcd, 0xf5, 0x5a, 0x35, 0xdf, 0x13, 0x0e, 0x27, 0xa5, 0xea, 0x73, 0x6a, 0xc3, 0xaf, 0x27, + 0xa0, 0x0f, 0x8e, 0xca, 0x73, 0xea, 0xf7, 0xf6, 0x61, 0x97, 0x62, 0xaa, 0xb5, 0xfd, 0xfb, 0x53, + 0x00, 0x6a, 0xba, 0xd2, 0x2e, 0xf9, 0x28, 0x94, 0x42, 0x1a, 0x09, 0xaa, 0xf2, 0x06, 0x41, 0x5c, + 0xcc, 0xa8, 0x42, 0x8c, 0xe1, 0x64, 0x1f, 0x8a, 0x5d, 0xa7, 0x17, 0x52, 0x39, 0xf8, 0x37, 0x72, + 0x19, 0xfc, 0x1a, 0xc3, 0x28, 0x4e, 0x68, 0xfc, 0x27, 0x0a, 0x1a, 0xe4, 0x2b, 0x16, 0x00, 0x4d, + 0x0e, 0xd8, 0xd8, 0x96, 0x12, 0x49, 0x32, 0x1e, 0x53, 0xd6, 0x07, 0xd5, 0xf9, 0xe3, 0xa3, 0x32, + 0x18, 0x43, 0x6f, 0x90, 0x25, 0xf7, 0x60, 0xc6, 0x51, 0x32, 0x7f, 0xf2, 0x34, 0x64, 0x3e, 0x3f, + 0x38, 0xe9, 0x49, 0xab, 0x89, 0x91, 0xaf, 0x59, 0x30, 0x1f, 0xd2, 0x48, 0x0e, 0x15, 0x93, 0x3c, + 0x52, 0xe1, 0x1d, 0x73, 0xd2, 0xd5, 0x13, 0x38, 0x85, 0x04, 0x4d, 0x96, 0x61, 0x8a, 0xae, 0x62, + 0xe5, 0x3a, 0x75, 0x9a, 0x34, 0xe0, 0xe7, 0x72, 0xa9, 0x49, 0x8d, 0xcf, 0x8a, 0x81, 0x53, 0xb3, + 0x62, 0x94, 0x61, 0x8a, 0xae, 0x62, 0x65, 0xcb, 0x0d, 0x02, 0x5f, 0xb2, 0x32, 0x93, 0x13, 0x2b, + 0x06, 0x4e, 0xcd, 0x8a, 0x51, 0x86, 0x29, 0xba, 0xf6, 0xb7, 0xcf, 0xc0, 0xbc, 0x5a, 0x48, 0xb1, + 0x66, 0x2f, 0xcc, 0x40, 0x03, 0x34, 0xfb, 0x35, 0x13, 0x88, 0xc9, 0xba, 0xac, 0xb1, 0x58, 0xaa, + 0x49, 0xc5, 0x5e, 0x37, 0xae, 0x9b, 0x40, 0x4c, 0xd6, 0x25, 0x1d, 0x28, 0x86, 0x11, 0xed, 0xaa, + 0xcb, 0xe0, 0x31, 0xef, 0x2a, 0x63, 0xf9, 0x10, 0x5f, 0xf7, 0xb0, 0x7f, 0x21, 0x0a, 0x2a, 0xdc, + 0x92, 0x19, 0x25, 0x8c, 0x9b, 0x72, 0x71, 0xe4, 0xb3, 0x3e, 0x93, 0x76, 0x53, 0x31, 0x1a, 0xc9, + 0x32, 0x4c, 0x91, 0xcf, 0x50, 0xf6, 0x8b, 0xa7, 0xa8, 0xec, 0x7f, 0x16, 0x66, 0x3a, 0xce, 0xfd, + 0x7a, 0x2f, 0x68, 0x3d, 0xfa, 0xa1, 0x42, 0xba, 0xd7, 0x09, 0x2c, 0xa8, 0xf1, 0x91, 0x2f, 0x5b, + 0x86, 0xc8, 0x99, 0xe6, 0xc8, 0xef, 0xe4, 0x2b, 0x72, 0xf4, 0x5e, 0x39, 0x50, 0xf8, 0xf4, 0xa9, + 0xde, 0x33, 0x8f, 0x5d, 0xf5, 0x66, 0x6a, 0xa4, 0x58, 0x20, 0x5a, 0x8d, 0x2c, 0x9d, 0xaa, 0x1a, + 0xb9, 0x96, 0x20, 0x86, 0x29, 0xe2, 0x9c, 0x1f, 0xb1, 0xe6, 0x34, 0x3f, 0x70, 0xaa, 0xfc, 0xd4, + 0x13, 0xc4, 0x30, 0x45, 0x7c, 0xf0, 0x79, 0x73, 0xf6, 0x74, 0xce, 0x9b, 0x73, 0x39, 0x9c, 0x37, + 0x4f, 0x56, 0xc5, 0xcf, 0x8c, 0xab, 0x8a, 0x93, 0x1b, 0x40, 0x9a, 0x87, 0x9e, 0xd3, 0x71, 0x1b, + 0x52, 0x58, 0xf2, 0x6d, 0x73, 0x9e, 0xdb, 0x23, 0x96, 0xa5, 0x20, 0x23, 0xeb, 0x7d, 0x35, 0x30, + 0xa3, 0x15, 0x89, 0x60, 0xa6, 0xab, 0x34, 0xae, 0x85, 0x3c, 0x66, 0xbf, 0xd2, 0xc0, 0x84, 0xbf, + 0x00, 0x5b, 0x78, 0xaa, 0x04, 0x35, 0x25, 0xb2, 0x09, 0xe7, 0x3b, 0xae, 0x57, 0xf3, 0x9b, 0x61, + 0x8d, 0x06, 0xd2, 0xda, 0x52, 0xa7, 0xd1, 0xd2, 0x22, 0xef, 0x1b, 0x7e, 0x82, 0xde, 0xca, 0x80, + 0x63, 0x66, 0x2b, 0xfb, 0x7f, 0x5a, 0xb0, 0xb8, 0xd6, 0xf6, 0x7b, 0xcd, 0x3b, 0x4e, 0xd4, 0xd8, + 0x13, 0x57, 0xe5, 0xe4, 0x35, 0x98, 0x71, 0xbd, 0x88, 0x06, 0x07, 0x4e, 0x5b, 0xee, 0x4f, 0xb6, + 0x32, 0x9f, 0x6e, 0xc8, 0xf2, 0x07, 0x47, 0xe5, 0xf9, 0xf5, 0x5e, 0xc0, 0xdd, 0xe9, 0x84, 0xb4, + 0x42, 0xdd, 0x86, 0x7c, 0xdb, 0x82, 0xb3, 0xe2, 0xb2, 0x7d, 0xdd, 0x89, 0x9c, 0x5b, 0x3d, 0x1a, + 0xb8, 0x54, 0x5d, 0xb7, 0x8f, 0x29, 0xa8, 0xd2, 0xbc, 0x2a, 0x02, 0x87, 0xb1, 0xa2, 0xbe, 0x95, + 0xa6, 0x8c, 0xfd, 0xcc, 0xd8, 0xbf, 0x52, 0x80, 0x27, 0x07, 0xe2, 0x22, 0xcb, 0x30, 0xe1, 0x36, + 0xe5, 0xa7, 0x83, 0xc4, 0x3b, 0xb1, 0xd1, 0xc4, 0x09, 0xb7, 0x49, 0x56, 0xb8, 0xce, 0x19, 0xd0, + 0x30, 0x54, 0x37, 0xaf, 0x25, 0xad, 0x1e, 0xca, 0x52, 0x34, 0x6a, 0x90, 0x32, 0x14, 0xb9, 0x6b, + 0xa5, 0x3c, 0x4f, 0x70, 0x2d, 0x96, 0x7b, 0x31, 0xa2, 0x28, 0x27, 0xbf, 0x68, 0x01, 0x08, 0x06, + 0xd9, 0x69, 0x44, 0xee, 0x92, 0x98, 0x6f, 0x37, 0x31, 0xcc, 0x82, 0xcb, 0xf8, 0x3f, 0x1a, 0x54, + 0xc9, 0x36, 0x4c, 0x31, 0x85, 0xd6, 0x6f, 0x3e, 0xf2, 0xa6, 0xc8, 0xaf, 0x64, 0x6a, 0x1c, 0x07, + 0x4a, 0x5c, 0xac, 0xaf, 0x02, 0x1a, 0xf5, 0x02, 0x8f, 0x75, 0x2d, 0xdf, 0x06, 0x67, 0x04, 0x17, + 0xa8, 0x4b, 0xd1, 0xa8, 0x61, 0xff, 0xcb, 0x09, 0x38, 0x9f, 0xc5, 0x3a, 0xdb, 0x6d, 0xa6, 0x04, + 0xb7, 0xf2, 0x68, 0xfc, 0x99, 0xfc, 0xfb, 0x47, 0xfa, 0x8d, 0x68, 0xef, 0x0a, 0xe9, 0xd9, 0x26, + 0xe9, 0x92, 0xcf, 0xe8, 0x1e, 0x9a, 0x78, 0xc4, 0x1e, 0xd2, 0x98, 0x53, 0xbd, 0xf4, 0x0c, 0x4c, + 0x86, 0x6c, 0xe4, 0x0b, 0xc9, 0xeb, 0x0e, 0x3e, 0x46, 0x1c, 0xc2, 0x6a, 0xf4, 0x3c, 0x37, 0x92, + 0xf1, 0x08, 0xba, 0xc6, 0x6d, 0xcf, 0x8d, 0x90, 0x43, 0xec, 0x6f, 0x4d, 0xc0, 0xf2, 0xe0, 0x8f, + 0x22, 0xdf, 0xb2, 0x00, 0x9a, 0xec, 0xb8, 0x12, 0x72, 0xa7, 0x5e, 0xe1, 0x67, 0xe3, 0x9c, 0x56, + 0x1f, 0xae, 0x2b, 0x4a, 0xb1, 0xd3, 0x95, 0x2e, 0x0a, 0xd1, 0x60, 0x84, 0xbc, 0xa0, 0xa6, 0x3e, + 0xbf, 0xaa, 0x11, 0x8b, 0x49, 0xb7, 0xd9, 0xd2, 0x10, 0x34, 0x6a, 0xb1, 0xf3, 0xa8, 0xe7, 0x74, + 0x68, 0xd8, 0x75, 0x74, 0x74, 0x07, 0x3f, 0x8f, 0xde, 0x54, 0x85, 0x18, 0xc3, 0xed, 0x36, 0x3c, + 0x3b, 0x04, 0x9f, 0x39, 0x39, 0xcf, 0xdb, 0xff, 0xc3, 0x82, 0x8b, 0x6b, 0xed, 0x5e, 0x18, 0xd1, + 0xe0, 0xff, 0x1b, 0x1f, 0xb6, 0xff, 0x65, 0xc1, 0x53, 0x03, 0xbe, 0xf9, 0x31, 0xb8, 0xb2, 0xbd, + 0x93, 0x74, 0x65, 0xbb, 0x3d, 0xee, 0x94, 0xce, 0xfc, 0x8e, 0x01, 0x1e, 0x6d, 0xbf, 0x69, 0xc1, + 0x19, 0x26, 0xb6, 0x9a, 0x7e, 0x2b, 0xa7, 0x8d, 0xf3, 0x59, 0x28, 0xfe, 0x3c, 0xdb, 0x80, 0xd2, + 0x93, 0x8c, 0xef, 0x4a, 0x28, 0x60, 0x6c, 0xcd, 0x38, 0x5d, 0xf7, 0x2d, 0x1a, 0xf0, 0x0d, 0xa8, + 0x90, 0x5c, 0x33, 0x15, 0x0d, 0x41, 0xa3, 0x96, 0xfd, 0x69, 0x90, 0xce, 0x62, 0xa9, 0x15, 0x67, + 0x0d, 0xb3, 0xe2, 0xec, 0xff, 0x30, 0x01, 0x86, 0xf1, 0xe3, 0x31, 0xcc, 0x64, 0x2f, 0x31, 0x93, + 0xc7, 0x3c, 0xb8, 0x1b, 0xa6, 0x9c, 0x41, 0xc1, 0x3c, 0x07, 0xa9, 0x60, 0x9e, 0x9b, 0xb9, 0x51, + 0x3c, 0x39, 0x96, 0xe7, 0x07, 0x16, 0x3c, 0x15, 0x57, 0xee, 0xb7, 0x4b, 0x3e, 0x5c, 0x2c, 0xbd, + 0x0c, 0xb3, 0x4e, 0xdc, 0x4c, 0xce, 0x1b, 0x23, 0x92, 0x42, 0x83, 0xd0, 0xac, 0x17, 0xfb, 0xa0, + 0x17, 0x1e, 0xd1, 0x07, 0x7d, 0xf2, 0x64, 0x1f, 0x74, 0xfb, 0xcf, 0x27, 0xe0, 0x52, 0xff, 0x97, + 0xa9, 0x05, 0x35, 0xdc, 0x25, 0xff, 0x2b, 0x30, 0x17, 0xc9, 0x06, 0xc6, 0xf6, 0xa0, 0xa3, 0x3a, + 0xb7, 0x0d, 0x18, 0x26, 0x6a, 0xb2, 0x96, 0x0d, 0xb1, 0x94, 0xeb, 0x0d, 0xbf, 0xab, 0x22, 0x18, + 0x74, 0xcb, 0x35, 0x03, 0x86, 0x89, 0x9a, 0xda, 0x37, 0x74, 0xf2, 0xd4, 0x7d, 0x43, 0xeb, 0x70, + 0x41, 0x79, 0xc3, 0x5d, 0xf3, 0x83, 0x35, 0xbf, 0xd3, 0x6d, 0x53, 0x19, 0xc3, 0xc0, 0x98, 0xbd, + 0x24, 0x9b, 0x5c, 0xc0, 0xac, 0x4a, 0x98, 0xdd, 0xd6, 0xfe, 0x41, 0x01, 0xce, 0xc5, 0xdd, 0xbe, + 0xe6, 0x7b, 0x4d, 0x97, 0xfb, 0x14, 0xbe, 0x0a, 0x93, 0xd1, 0x61, 0x57, 0x75, 0xf6, 0x5f, 0x55, + 0xec, 0x6c, 0x1f, 0x76, 0xd9, 0x68, 0x5f, 0xcc, 0x68, 0xc2, 0x2d, 0xc3, 0xbc, 0x11, 0xd9, 0xd4, + 0xab, 0x43, 0x8c, 0xc0, 0x4b, 0xc9, 0xd9, 0xfc, 0xe0, 0xa8, 0x9c, 0x11, 0xd4, 0xbc, 0xa2, 0x31, + 0x25, 0xe7, 0x3c, 0xb9, 0x0b, 0xf3, 0x6d, 0x27, 0x8c, 0x6e, 0x77, 0x9b, 0x4e, 0x44, 0xb7, 0x5d, + 0xe9, 0xa1, 0x31, 0x5a, 0x60, 0x80, 0xbe, 0xca, 0xde, 0x4c, 0x60, 0xc2, 0x14, 0x66, 0x72, 0x00, + 0x84, 0x95, 0x6c, 0x07, 0x8e, 0x17, 0x8a, 0xaf, 0x62, 0xf4, 0x46, 0x0f, 0x44, 0xd0, 0x27, 0xc3, + 0xcd, 0x3e, 0x6c, 0x98, 0x41, 0x81, 0x3c, 0x07, 0x53, 0x01, 0x75, 0x42, 0x39, 0x98, 0xa5, 0x78, + 0xfd, 0x23, 0x2f, 0x45, 0x09, 0x35, 0x17, 0xd4, 0xd4, 0x43, 0x16, 0xd4, 0x9f, 0x5a, 0x30, 0x1f, + 0x0f, 0xd3, 0x63, 0xd8, 0x59, 0x3b, 0xc9, 0x9d, 0xf5, 0x7a, 0x5e, 0x22, 0x71, 0xc0, 0x66, 0xfa, + 0x07, 0x53, 0xe6, 0xf7, 0x71, 0xc7, 0xf0, 0x2f, 0x42, 0x49, 0xad, 0x6a, 0xa5, 0xb2, 0x8e, 0x79, + 0xc0, 0x4e, 0x28, 0x33, 0x46, 0x40, 0x93, 0x24, 0x82, 0x31, 0x3d, 0xb6, 0x95, 0x37, 0xe5, 0x36, + 0x2d, 0xa7, 0xbd, 0xde, 0xca, 0xd5, 0xf6, 0x9d, 0xb5, 0x95, 0xab, 0x36, 0xe4, 0x36, 0x5c, 0xec, + 0x06, 0x3e, 0x0f, 0xab, 0x5d, 0xa7, 0x4e, 0xb3, 0xed, 0x7a, 0x54, 0x59, 0x31, 0x84, 0x27, 0xc5, + 0x53, 0xc7, 0x47, 0xe5, 0x8b, 0xb5, 0xec, 0x2a, 0x38, 0xa8, 0x6d, 0x32, 0x30, 0x6b, 0x72, 0x88, + 0xc0, 0xac, 0xbf, 0xa3, 0x6d, 0x85, 0x34, 0x94, 0xe1, 0x51, 0x9f, 0xcb, 0x6b, 0x28, 0x33, 0xc4, + 0x7a, 0x3c, 0xa5, 0x2a, 0x92, 0x28, 0x6a, 0xf2, 0x83, 0x0d, 0x52, 0x53, 0x8f, 0x68, 0x90, 0x8a, + 0xfd, 0xeb, 0xa7, 0x7f, 0x92, 0xfe, 0xf5, 0x33, 0x1f, 0x28, 0xff, 0xfa, 0xf7, 0x8b, 0xb0, 0x98, + 0xd6, 0x40, 0x4e, 0x3f, 0xe8, 0xec, 0xef, 0x59, 0xb0, 0xa8, 0x56, 0x8f, 0xa0, 0x49, 0xd5, 0x55, + 0xc3, 0x66, 0x4e, 0x8b, 0x56, 0xe8, 0x52, 0x3a, 0x1a, 0x7f, 0x3b, 0x45, 0x0d, 0xfb, 0xe8, 0x93, + 0xb7, 0x61, 0x56, 0x5b, 0xe4, 0x1f, 0x29, 0x02, 0x6d, 0x81, 0x6b, 0x51, 0x31, 0x0a, 0x34, 0xf1, + 0x91, 0xf7, 0x2d, 0x80, 0x86, 0xda, 0xe6, 0xd4, 0xea, 0xba, 0x95, 0xd7, 0xea, 0xd2, 0x1b, 0x68, + 0xac, 0x2c, 0xeb, 0xa2, 0x10, 0x0d, 0xc2, 0xe4, 0x57, 0xb8, 0x2d, 0x5e, 0x6b, 0x77, 0x22, 0xca, + 0x7f, 0x6c, 0xdf, 0xe1, 0x13, 0x14, 0xd3, 0x58, 0x95, 0x32, 0x40, 0x21, 0x26, 0x98, 0xb0, 0x5f, + 0x05, 0xed, 0xed, 0xc9, 0xc4, 0x16, 0xf7, 0xf7, 0xac, 0x39, 0xd1, 0x9e, 0x9c, 0x82, 0x5a, 0x6c, + 0x5d, 0x53, 0x00, 0x8c, 0xeb, 0xd8, 0x5f, 0x80, 0xf9, 0xd7, 0x03, 0xa7, 0xbb, 0xe7, 0x72, 0x9b, + 0x37, 0x3b, 0x5b, 0x7d, 0x04, 0xa6, 0x9d, 0x66, 0x33, 0x2b, 0x71, 0x44, 0x45, 0x14, 0xa3, 0x82, + 0x0f, 0x75, 0x8c, 0xb2, 0x7f, 0xdf, 0x02, 0x12, 0xdf, 0x1b, 0xba, 0x5e, 0x6b, 0xcb, 0x89, 0x1a, + 0x7b, 0xec, 0x7c, 0xb4, 0xc7, 0x4b, 0xb3, 0xce, 0x47, 0xd7, 0x35, 0x04, 0x8d, 0x5a, 0xe4, 0x5d, + 0x98, 0x15, 0xff, 0xde, 0xd2, 0x16, 0x82, 0xb1, 0x23, 0x08, 0xc4, 0x86, 0xc2, 0x79, 0x12, 0xb3, + 0xf0, 0x7a, 0x4c, 0x01, 0x4d, 0x72, 0xac, 0xab, 0x36, 0xbc, 0xdd, 0x76, 0xef, 0x7e, 0x73, 0x27, + 0xee, 0xaa, 0x6e, 0xe0, 0xef, 0xba, 0x6d, 0x9a, 0xee, 0xaa, 0x9a, 0x28, 0x46, 0x05, 0x1f, 0xae, + 0xab, 0xfe, 0x8d, 0x05, 0xe7, 0x37, 0xc2, 0xc8, 0xf5, 0xd7, 0x69, 0x18, 0xb1, 0x6d, 0x85, 0x09, + 0x9f, 0x5e, 0x7b, 0x18, 0xc7, 0xed, 0x75, 0x58, 0x94, 0x77, 0x98, 0xbd, 0x9d, 0x90, 0x46, 0x86, + 0x1e, 0xaf, 0xd7, 0xf1, 0x5a, 0x0a, 0x8e, 0x7d, 0x2d, 0x18, 0x16, 0x79, 0x99, 0x19, 0x63, 0x29, + 0x24, 0xb1, 0xd4, 0x53, 0x70, 0xec, 0x6b, 0x61, 0x7f, 0xbf, 0x00, 0xe7, 0xf8, 0x67, 0xa4, 0x82, + 0x2e, 0xbe, 0x31, 0x28, 0xe8, 0x62, 0xcc, 0xa5, 0xcc, 0x69, 0x3d, 0x42, 0xc8, 0xc5, 0xdf, 0xb5, + 0x60, 0xa1, 0x99, 0xec, 0xe9, 0x7c, 0x6c, 0x3a, 0x59, 0x63, 0x28, 0x5c, 0xb6, 0x52, 0x85, 0x98, + 0xa6, 0x4f, 0x7e, 0xd5, 0x82, 0x85, 0x24, 0x9b, 0x4a, 0xba, 0x9f, 0x42, 0x27, 0x69, 0x1f, 0xeb, + 0x64, 0x79, 0x88, 0x69, 0x16, 0xec, 0x3f, 0x9c, 0x90, 0x43, 0x7a, 0x1a, 0x11, 0x05, 0xe4, 0x1e, + 0x94, 0xa2, 0x76, 0x28, 0x0a, 0xe5, 0xd7, 0x8e, 0x79, 0x22, 0xdc, 0xde, 0xac, 0x0b, 0xf7, 0x81, + 0x58, 0x69, 0x93, 0x25, 0x4c, 0xf9, 0x54, 0xb4, 0x38, 0xe1, 0x46, 0x57, 0x12, 0xce, 0xe5, 0x28, + 0xba, 0xbd, 0x56, 0x4b, 0x13, 0x96, 0x25, 0x8c, 0xb0, 0xa2, 0x65, 0xff, 0x96, 0x05, 0xa5, 0x1b, + 0xbe, 0x92, 0x23, 0x3f, 0x9b, 0x83, 0xa1, 0x47, 0xeb, 0x83, 0xfa, 0x9a, 0x32, 0x3e, 0x62, 0xbc, + 0x96, 0x30, 0xf3, 0x3c, 0x6d, 0xe0, 0x5e, 0xe1, 0xf9, 0xb3, 0x18, 0xaa, 0x1b, 0xfe, 0xce, 0x40, + 0xd3, 0xe3, 0xaf, 0x15, 0xe1, 0xcc, 0x1b, 0xce, 0x21, 0xf5, 0x22, 0x67, 0xf4, 0x4d, 0xe2, 0x65, + 0x98, 0x75, 0xba, 0xfc, 0x1e, 0xcc, 0xd0, 0xf1, 0x63, 0xcb, 0x49, 0x0c, 0x42, 0xb3, 0x5e, 0x2c, + 0xd0, 0x44, 0x76, 0x9d, 0x2c, 0x51, 0xb4, 0x96, 0x82, 0x63, 0x5f, 0x0b, 0x72, 0x03, 0x88, 0x8c, + 0x46, 0xad, 0x34, 0x1a, 0x7e, 0xcf, 0x13, 0x22, 0x4d, 0x18, 0x55, 0xf4, 0x61, 0x73, 0xab, 0xaf, + 0x06, 0x66, 0xb4, 0x22, 0x9f, 0x87, 0xa5, 0x06, 0xc7, 0x2c, 0x8f, 0x1e, 0x26, 0x46, 0x71, 0xfc, + 0xd4, 0x71, 0x02, 0x6b, 0x03, 0xea, 0xe1, 0x40, 0x0c, 0x8c, 0xd3, 0x30, 0xf2, 0x03, 0xa7, 0x45, + 0x4d, 0xbc, 0x53, 0x49, 0x4e, 0xeb, 0x7d, 0x35, 0x30, 0xa3, 0x15, 0xf9, 0x12, 0x94, 0xa2, 0xbd, + 0x80, 0x86, 0x7b, 0x7e, 0xbb, 0x29, 0xfd, 0x16, 0xc6, 0xb4, 0xb4, 0xc9, 0xd1, 0xdf, 0x56, 0x58, + 0x8d, 0xe9, 0xad, 0x8a, 0x30, 0xa6, 0x49, 0x02, 0x98, 0x0a, 0x1b, 0x7e, 0x97, 0x86, 0x52, 0x65, + 0xbf, 0x91, 0x0b, 0x75, 0x6e, 0x39, 0x32, 0x6c, 0x7c, 0x9c, 0x02, 0x4a, 0x4a, 0xf6, 0xef, 0x4d, + 0xc0, 0x9c, 0x59, 0x71, 0x08, 0xd9, 0xf4, 0x15, 0x0b, 0xe6, 0x1a, 0xbe, 0x17, 0x05, 0x7e, 0x5b, + 0xd8, 0xaf, 0xf2, 0xd1, 0x28, 0x18, 0xaa, 0x75, 0x1a, 0x39, 0x6e, 0xdb, 0x30, 0x85, 0x19, 0x64, + 0x30, 0x41, 0x94, 0x7c, 0xdd, 0x82, 0x85, 0xd8, 0xcd, 0x2d, 0x36, 0xa4, 0xe5, 0xca, 0x88, 0x16, + 0xf5, 0x57, 0x93, 0x94, 0x30, 0x4d, 0xda, 0xde, 0x81, 0xc5, 0xf4, 0x68, 0xb3, 0xae, 0xec, 0x3a, + 0x72, 0xad, 0x17, 0xe2, 0xae, 0xac, 0x39, 0x61, 0x88, 0x1c, 0x42, 0x9e, 0x87, 0x99, 0x8e, 0x13, + 0xb4, 0x5c, 0xcf, 0x69, 0xf3, 0x5e, 0x2c, 0x18, 0x02, 0x49, 0x96, 0xa3, 0xae, 0x61, 0x7f, 0x1c, + 0xe6, 0xb6, 0x1c, 0xaf, 0x45, 0x9b, 0x52, 0x0e, 0x3f, 0x3c, 0xa6, 0xed, 0x47, 0x93, 0x30, 0x6b, + 0x9c, 0xcd, 0x4e, 0xff, 0x9c, 0x95, 0x48, 0xa9, 0x51, 0xc8, 0x31, 0xa5, 0xc6, 0x67, 0x01, 0x76, + 0x5d, 0xcf, 0x0d, 0xf7, 0x1e, 0x31, 0x59, 0x07, 0xbf, 0xd7, 0xbd, 0xa6, 0x31, 0xa0, 0x81, 0x2d, + 0xbe, 0x3c, 0x2b, 0x9e, 0x90, 0x79, 0xea, 0x7d, 0xcb, 0xd8, 0x6e, 0xa6, 0xf2, 0x70, 0x16, 0x30, + 0x06, 0x66, 0x45, 0x6d, 0x3f, 0x22, 0xd7, 0xd0, 0x49, 0xbb, 0xd2, 0x36, 0xcc, 0x04, 0x34, 0xec, + 0x75, 0xd8, 0x89, 0x71, 0x7a, 0xe4, 0x6e, 0xe0, 0x6e, 0x1b, 0x28, 0xdb, 0xa3, 0xc6, 0xb4, 0xfc, + 0x2a, 0x9c, 0x49, 0xb0, 0x30, 0x52, 0xf6, 0x21, 0x1f, 0x32, 0x0d, 0x00, 0x8f, 0x72, 0x99, 0xc3, + 0xc6, 0xa2, 0x6d, 0x64, 0xeb, 0xd0, 0x63, 0x21, 0x9c, 0x73, 0x04, 0xcc, 0xfe, 0xf3, 0x29, 0x90, + 0xf7, 0xdf, 0x43, 0x88, 0x2b, 0xf3, 0xd6, 0x6b, 0xe2, 0x11, 0x6e, 0xbd, 0x6e, 0xc0, 0x9c, 0xeb, + 0xb9, 0x91, 0xeb, 0xb4, 0xb9, 0x71, 0x47, 0x6e, 0xa7, 0xca, 0x7b, 0x79, 0x6e, 0xc3, 0x80, 0x65, + 0xe0, 0x49, 0xb4, 0x25, 0xb7, 0xa0, 0xc8, 0xf7, 0x1b, 0x39, 0x81, 0x47, 0xbf, 0xa4, 0xe7, 0xfe, + 0x19, 0x22, 0xa4, 0x49, 0x60, 0xe2, 0x87, 0x0f, 0x91, 0xae, 0x44, 0x1f, 0xbf, 0xe5, 0x3c, 0x8e, + 0x0f, 0x1f, 0x29, 0x38, 0xf6, 0xb5, 0x60, 0x58, 0x76, 0x1d, 0xb7, 0xdd, 0x0b, 0x68, 0x8c, 0x65, + 0x2a, 0x89, 0xe5, 0x5a, 0x0a, 0x8e, 0x7d, 0x2d, 0xc8, 0x2e, 0xcc, 0xc9, 0x32, 0xe1, 0x72, 0x35, + 0xfd, 0x88, 0x5f, 0xc9, 0x5d, 0xeb, 0xae, 0x19, 0x98, 0x30, 0x81, 0x97, 0xf4, 0xe0, 0xac, 0xeb, + 0x35, 0x7c, 0xaf, 0xd1, 0xee, 0x85, 0xee, 0x01, 0x8d, 0xe3, 0x89, 0x1e, 0x85, 0xd8, 0x85, 0xe3, + 0xa3, 0xf2, 0xd9, 0x8d, 0x34, 0x3a, 0xec, 0xa7, 0x40, 0xbe, 0x6c, 0xc1, 0x85, 0x86, 0xef, 0x85, + 0x3c, 0xfe, 0xff, 0x80, 0x5e, 0x0d, 0x02, 0x3f, 0x10, 0xb4, 0x4b, 0x8f, 0x48, 0x9b, 0xdb, 0x14, + 0xd7, 0xb2, 0x50, 0x62, 0x36, 0x25, 0xf2, 0x0e, 0xcc, 0x74, 0x03, 0xff, 0xc0, 0x6d, 0xd2, 0x40, + 0xba, 0xef, 0x6d, 0xe6, 0x91, 0x8f, 0xa4, 0x26, 0x71, 0xc6, 0xa2, 0x47, 0x95, 0xa0, 0xa6, 0x67, + 0xff, 0xef, 0x59, 0x98, 0x4f, 0x56, 0x27, 0xbf, 0x00, 0xd0, 0x0d, 0xfc, 0x0e, 0x8d, 0xf6, 0xa8, + 0x8e, 0x0b, 0xb9, 0x39, 0x6e, 0xda, 0x0b, 0x85, 0x4f, 0xb9, 0xbc, 0x30, 0x71, 0x11, 0x97, 0xa2, + 0x41, 0x91, 0x04, 0x30, 0xbd, 0x2f, 0xb6, 0x5d, 0xa9, 0x85, 0xbc, 0x91, 0x8b, 0xce, 0x24, 0x29, + 0xf3, 0x80, 0x06, 0x59, 0x84, 0x8a, 0x10, 0xd9, 0x81, 0xc2, 0x3d, 0xba, 0x93, 0x4f, 0xcc, 0xf5, + 0x1d, 0x2a, 0x4f, 0x33, 0xd5, 0xe9, 0xe3, 0xa3, 0x72, 0xe1, 0x0e, 0xdd, 0x41, 0x86, 0x9c, 0x7d, + 0x57, 0x53, 0xdc, 0xdd, 0x4b, 0x51, 0x31, 0xe6, 0x77, 0x25, 0x1c, 0x01, 0xc4, 0x77, 0xc9, 0x22, + 0x54, 0x84, 0xc8, 0x3b, 0x50, 0xba, 0xe7, 0x1c, 0xd0, 0xdd, 0xc0, 0xf7, 0x22, 0xe9, 0x67, 0x35, + 0x66, 0xa8, 0xc0, 0x1d, 0x85, 0x4e, 0xd2, 0xe5, 0xdb, 0xbb, 0x2e, 0xc4, 0x98, 0x1c, 0x39, 0x80, + 0x19, 0x8f, 0xde, 0x43, 0xda, 0x76, 0x1b, 0xf9, 0xb8, 0xe6, 0xdf, 0x94, 0xd8, 0x24, 0x65, 0xbe, + 0xef, 0xa9, 0x32, 0xd4, 0xb4, 0xd8, 0x58, 0xde, 0xf5, 0x77, 0xa4, 0xa0, 0x1a, 0x73, 0x2c, 0xf5, + 0xc9, 0x54, 0x8c, 0xe5, 0x0d, 0x7f, 0x07, 0x19, 0x72, 0xb6, 0x46, 0x1a, 0xda, 0xc9, 0x47, 0x8a, + 0xa9, 0x9b, 0xf9, 0x3a, 0x37, 0x89, 0x35, 0x12, 0x97, 0xa2, 0x41, 0x91, 0xf5, 0x6d, 0x4b, 0x1a, + 0x2b, 0xa5, 0xa0, 0x1a, 0xb3, 0x6f, 0x93, 0xa6, 0x4f, 0xd1, 0xb7, 0xaa, 0x0c, 0x35, 0x2d, 0x46, + 0xd7, 0x95, 0x96, 0xbf, 0x7c, 0x44, 0x55, 0xd2, 0x8e, 0x28, 0xe8, 0xaa, 0x32, 0xd4, 0xb4, 0x58, + 0x7f, 0x87, 0xfb, 0x87, 0xf7, 0x9c, 0xf6, 0xbe, 0xeb, 0xb5, 0x64, 0x9c, 0xe3, 0xb8, 0xd9, 0x6d, + 0xf7, 0x0f, 0xef, 0x08, 0x7c, 0x66, 0x7f, 0xc7, 0xa5, 0x68, 0x50, 0x24, 0xff, 0xc8, 0x82, 0xa9, + 0x6e, 0xbb, 0xd7, 0x72, 0xbd, 0xa5, 0x39, 0xae, 0x27, 0x7e, 0x26, 0x4f, 0x09, 0xbd, 0x52, 0xe3, + 0xa8, 0x85, 0xa2, 0xf8, 0xd3, 0xda, 0x67, 0x8f, 0x17, 0xfe, 0xd2, 0x9f, 0x95, 0x97, 0xa8, 0xd7, + 0xf0, 0x9b, 0xae, 0xd7, 0x5a, 0xbd, 0x1b, 0xfa, 0xde, 0x0a, 0x3a, 0xf7, 0x94, 0x8e, 0x2e, 0x79, + 0x5a, 0xfe, 0x24, 0xcc, 0x1a, 0x28, 0x1e, 0xa6, 0xe8, 0xcd, 0x99, 0x8a, 0xde, 0x6f, 0x4d, 0xc1, + 0x9c, 0x99, 0x51, 0x6f, 0x08, 0xed, 0x4b, 0x9f, 0x38, 0x26, 0x46, 0x39, 0x71, 0xb0, 0x23, 0xa6, + 0x71, 0x7b, 0xa4, 0xcc, 0x5b, 0x1b, 0xb9, 0x29, 0xdc, 0xf1, 0x11, 0xd3, 0x28, 0x0c, 0x31, 0x41, + 0x74, 0x04, 0x87, 0x12, 0xa6, 0xb6, 0x0a, 0xc5, 0xae, 0x98, 0x54, 0x5b, 0x13, 0xaa, 0xda, 0x0b, + 0x00, 0x71, 0x66, 0x39, 0x79, 0xab, 0xa8, 0xf5, 0x61, 0x23, 0xe3, 0x9d, 0x51, 0x8b, 0x3c, 0x07, + 0x53, 0x4c, 0xf5, 0xa1, 0x4d, 0x19, 0x86, 0xad, 0xcf, 0xf1, 0xd7, 0x78, 0x29, 0x4a, 0x28, 0x79, + 0x85, 0x69, 0xa9, 0xb1, 0xc2, 0x22, 0xa3, 0xab, 0xcf, 0xc7, 0x5a, 0x6a, 0x0c, 0xc3, 0x44, 0x4d, + 0xc6, 0x3a, 0x65, 0xfa, 0x05, 0x97, 0x0d, 0x06, 0xeb, 0x5c, 0xe9, 0x40, 0x01, 0xe3, 0x76, 0xa5, + 0x94, 0x3e, 0xc2, 0xd7, 0x74, 0xd1, 0xb0, 0x2b, 0xa5, 0xe0, 0xd8, 0xd7, 0x82, 0x7d, 0x8c, 0xbc, + 0x10, 0x9d, 0x15, 0xce, 0xb6, 0x03, 0xae, 0x32, 0xbf, 0x6a, 0x9e, 0xb5, 0x72, 0x5c, 0x43, 0x62, + 0xd6, 0x0e, 0x7f, 0xd8, 0x1a, 0xef, 0x58, 0xf4, 0x05, 0x98, 0x4f, 0xee, 0x42, 0xb9, 0xdf, 0x7c, + 0x7c, 0x6d, 0x12, 0xce, 0xdd, 0x6c, 0xb9, 0x5e, 0x3a, 0x5b, 0x54, 0x56, 0xb2, 0x70, 0x6b, 0xe4, + 0x64, 0xe1, 0x3a, 0x9e, 0x4b, 0xa6, 0xe2, 0xce, 0x8e, 0xe7, 0x52, 0x79, 0xd1, 0x93, 0x75, 0xc9, + 0x9f, 0x5a, 0xf0, 0xb4, 0xd3, 0x14, 0xe7, 0x02, 0xa7, 0x2d, 0x4b, 0x8d, 0x1c, 0xb7, 0x72, 0x45, + 0x87, 0x63, 0xee, 0xf2, 0xfd, 0x1f, 0xbf, 0x52, 0x39, 0x81, 0xaa, 0x18, 0xf1, 0x9f, 0x92, 0x5f, + 0xf0, 0xf4, 0x49, 0x55, 0xf1, 0x44, 0xf6, 0xc9, 0xdf, 0x80, 0x85, 0xc4, 0x07, 0x4b, 0x4b, 0x78, + 0x49, 0x5c, 0x58, 0xd4, 0x93, 0x20, 0x4c, 0xd7, 0x5d, 0x7e, 0x13, 0x3e, 0xfc, 0x50, 0x3e, 0x47, + 0x9a, 0x6c, 0x5f, 0xb1, 0xa0, 0x24, 0xec, 0xda, 0x48, 0x77, 0x53, 0x4e, 0x98, 0xa9, 0x93, 0x77, + 0xa5, 0xb6, 0x91, 0xe1, 0x84, 0xc9, 0x64, 0xf9, 0xbe, 0xeb, 0x35, 0xe5, 0x28, 0x6b, 0x59, 0xfe, + 0x86, 0xeb, 0x35, 0x91, 0x43, 0xb4, 0xb4, 0x2f, 0x0c, 0xb4, 0x37, 0xfd, 0xba, 0x05, 0xf3, 0x3c, + 0x06, 0x36, 0x3e, 0x13, 0xbe, 0xac, 0x9d, 0x8d, 0x04, 0x1b, 0x97, 0x92, 0xce, 0x46, 0x0f, 0x8e, + 0xca, 0xb3, 0x22, 0x6a, 0x36, 0xe9, 0x7b, 0xf4, 0x39, 0x69, 0x48, 0xe2, 0x2e, 0x51, 0x13, 0x23, + 0xdb, 0x39, 0xb4, 0xa1, 0xb5, 0xae, 0x90, 0x60, 0x8c, 0xcf, 0x7e, 0x17, 0xe6, 0xcc, 0x60, 0x16, + 0xf2, 0x32, 0xcc, 0x76, 0x5d, 0xaf, 0x95, 0x0c, 0x7a, 0xd4, 0xc6, 0xf6, 0x5a, 0x0c, 0x42, 0xb3, + 0x1e, 0x6f, 0xe6, 0xc7, 0xcd, 0x52, 0x36, 0xfa, 0x9a, 0x6f, 0x36, 0x8b, 0xff, 0xf0, 0x1c, 0xdb, + 0x19, 0x41, 0x53, 0xb9, 0xe7, 0xd8, 0xce, 0xa0, 0xf1, 0x93, 0xcb, 0xb1, 0x9d, 0xc5, 0xcc, 0xff, + 0x5d, 0x39, 0xb6, 0x7f, 0x06, 0x46, 0x4d, 0xae, 0xc8, 0xf6, 0xbb, 0x7b, 0x66, 0x60, 0xba, 0xee, + 0x71, 0x19, 0x99, 0x2e, 0xa1, 0xf6, 0x7b, 0x6c, 0xd9, 0xe8, 0x43, 0x6d, 0xa5, 0x17, 0xed, 0x11, + 0x0f, 0x8a, 0xa1, 0xdb, 0x3a, 0x78, 0x29, 0x27, 0x9b, 0x36, 0x43, 0x25, 0x1f, 0x66, 0x88, 0x03, + 0x62, 0x59, 0x21, 0x0a, 0x32, 0xf6, 0x77, 0x0b, 0xb0, 0x98, 0x3e, 0x79, 0xe7, 0xed, 0xd4, 0x40, + 0xbe, 0x6e, 0xc1, 0xbc, 0xd3, 0x8b, 0xf6, 0xa8, 0x17, 0xa9, 0x8b, 0xad, 0x5c, 0xde, 0x0c, 0x49, + 0xf6, 0x9d, 0x91, 0xc2, 0x2a, 0x41, 0x0b, 0x53, 0xb4, 0xc9, 0x5f, 0x81, 0xe9, 0xc8, 0xed, 0x50, + 0xbf, 0x27, 0xec, 0x71, 0x05, 0x71, 0x2e, 0xde, 0x16, 0x45, 0xa8, 0x60, 0xe4, 0x79, 0x76, 0x8e, + 0x61, 0x8a, 0x4c, 0x40, 0xa5, 0xf7, 0xeb, 0x62, 0x6c, 0x40, 0x14, 0xe5, 0xa8, 0x6b, 0x90, 0xfb, + 0x30, 0x2d, 0xdc, 0x1f, 0x94, 0x9f, 0xcb, 0x56, 0x4e, 0x16, 0x02, 0xe1, 0x61, 0x11, 0x0f, 0x81, + 0xf8, 0x1f, 0xa2, 0x22, 0x67, 0x7f, 0x1c, 0x46, 0x4c, 0x78, 0x69, 0x5f, 0x05, 0x82, 0x7e, 0xbb, + 0xbd, 0xe3, 0x34, 0xf6, 0xef, 0xb8, 0x5e, 0xd3, 0xbf, 0xc7, 0xa5, 0xe1, 0x2a, 0x94, 0x02, 0x19, + 0xf5, 0x18, 0xca, 0x89, 0xab, 0xc5, 0xa9, 0x0a, 0x87, 0x0c, 0x31, 0xae, 0x63, 0xff, 0xe1, 0x04, + 0x4c, 0xcb, 0x10, 0xdd, 0xc7, 0xe0, 0x7d, 0xbf, 0x9f, 0xb8, 0x96, 0xdd, 0xc8, 0x25, 0xb2, 0x78, + 0xa0, 0xeb, 0x7d, 0x98, 0x72, 0xbd, 0x7f, 0x23, 0x1f, 0x72, 0x27, 0xfb, 0xdd, 0xff, 0x41, 0x11, + 0x16, 0x52, 0x21, 0xcf, 0x4c, 0x25, 0xee, 0x73, 0x37, 0xbd, 0x9d, 0x6b, 0x54, 0xb5, 0x0e, 0x27, + 0x39, 0xd9, 0xf3, 0x34, 0x4c, 0xa4, 0x27, 0xbe, 0x95, 0xdb, 0xcb, 0x0b, 0x7f, 0x99, 0xa9, 0x78, + 0x44, 0x4f, 0x4a, 0xf2, 0x6d, 0x0b, 0xce, 0x39, 0xfd, 0x4f, 0x57, 0x48, 0xd3, 0xdd, 0xad, 0xdc, + 0xdf, 0xc4, 0xa8, 0x3e, 0x25, 0x99, 0xcc, 0x7a, 0x21, 0x04, 0xb3, 0x58, 0xb1, 0xff, 0xb3, 0x05, + 0x4f, 0x0e, 0x0c, 0xde, 0xe7, 0xb9, 0x9f, 0x82, 0x24, 0x54, 0xca, 0x8c, 0x9c, 0x53, 0x94, 0xe8, + 0x6b, 0xdc, 0x74, 0xba, 0x9e, 0x34, 0x79, 0xf2, 0x12, 0xcc, 0x71, 0x35, 0x91, 0x49, 0xcf, 0x88, + 0x76, 0xe5, 0x2d, 0x14, 0xbf, 0x8f, 0xa8, 0x1b, 0xe5, 0x98, 0xa8, 0x65, 0x7f, 0xdb, 0x82, 0xa5, + 0x41, 0x99, 0x80, 0x86, 0xb0, 0x91, 0xfc, 0xf5, 0x54, 0x04, 0x43, 0xb9, 0x2f, 0x82, 0x21, 0x65, + 0x25, 0x51, 0xc1, 0x0a, 0x86, 0x81, 0xa2, 0xf0, 0x10, 0x07, 0xfd, 0x6f, 0x58, 0x70, 0x71, 0xc0, + 0x82, 0xef, 0x8b, 0x64, 0xb1, 0x1e, 0x39, 0x92, 0x65, 0x62, 0xd8, 0x48, 0x16, 0xfb, 0x8f, 0x0a, + 0xb0, 0x28, 0xf9, 0x89, 0xcf, 0x0a, 0xaf, 0x24, 0xe2, 0x40, 0x7e, 0x2a, 0x15, 0x07, 0x72, 0x3e, + 0x5d, 0xff, 0x2f, 0x83, 0x40, 0x3e, 0x58, 0x41, 0x20, 0x7f, 0x31, 0x01, 0x17, 0x32, 0x13, 0x14, + 0x91, 0xaf, 0x65, 0xec, 0x5e, 0x77, 0x72, 0xce, 0x84, 0x34, 0xe4, 0xfe, 0x35, 0x6e, 0xe4, 0xc4, + 0xaf, 0x9a, 0x11, 0x0b, 0x62, 0x37, 0xda, 0x3d, 0x85, 0x9c, 0x4e, 0x23, 0x06, 0x2f, 0xd8, 0xbf, + 0x54, 0x80, 0x2b, 0xc3, 0x22, 0xfa, 0x80, 0x06, 0xb7, 0x85, 0x89, 0xe0, 0xb6, 0xc7, 0xa4, 0x59, + 0x9c, 0x4a, 0x9c, 0xdb, 0x3f, 0x99, 0xd4, 0xdb, 0x5e, 0xff, 0xfc, 0x1c, 0xca, 0x65, 0x61, 0x9a, + 0x69, 0x9f, 0x2a, 0xc9, 0x71, 0x2c, 0x0a, 0xa7, 0xeb, 0xa2, 0xf8, 0xc1, 0x51, 0xf9, 0x6c, 0x9c, + 0x26, 0x43, 0x16, 0xa2, 0x6a, 0x44, 0xae, 0xc0, 0x4c, 0x20, 0xa0, 0x2a, 0x9c, 0x47, 0xfa, 0x7d, + 0x88, 0x32, 0xd4, 0x50, 0xf2, 0x25, 0x43, 0x5d, 0x9f, 0x3c, 0xad, 0x6c, 0x30, 0x27, 0xb9, 0xb3, + 0xbc, 0x0d, 0x33, 0xa1, 0x4a, 0x40, 0x2c, 0x14, 0x97, 0x17, 0x87, 0x8c, 0x12, 0x73, 0x76, 0x68, + 0x5b, 0x65, 0x23, 0x16, 0xdf, 0xa7, 0x73, 0x15, 0x6b, 0x94, 0xc4, 0xd6, 0x27, 0x70, 0x61, 0x6e, + 0x87, 0xfe, 0xd3, 0x37, 0x89, 0x60, 0x5a, 0x3e, 0xd0, 0x28, 0xef, 0x01, 0xb7, 0x72, 0x8a, 0x08, + 0x91, 0xfe, 0xc2, 0xfc, 0x54, 0xa9, 0x2c, 0x41, 0x8a, 0x94, 0xfd, 0x03, 0x0b, 0x66, 0xe5, 0x1c, + 0x79, 0x0c, 0xe1, 0x72, 0x77, 0x93, 0xe1, 0x72, 0x57, 0x73, 0x91, 0x58, 0x03, 0x62, 0xe5, 0xee, + 0xc2, 0x9c, 0x99, 0x19, 0x8f, 0x7c, 0xd6, 0x90, 0xb8, 0xd6, 0x38, 0xb9, 0xa6, 0x94, 0x4c, 0x8e, + 0xa5, 0xb1, 0xfd, 0xdb, 0x25, 0xdd, 0x8b, 0xfc, 0xec, 0x6a, 0xce, 0x7c, 0xeb, 0xc4, 0x99, 0x6f, + 0x4e, 0xbc, 0x89, 0xfc, 0x27, 0xde, 0x2d, 0x98, 0x51, 0x62, 0x51, 0x2a, 0x0f, 0xcf, 0x9a, 0x0e, + 0xc4, 0x4c, 0x03, 0x61, 0xc8, 0x8c, 0xe5, 0xc2, 0xcf, 0xa0, 0x7a, 0x0c, 0xb5, 0xb8, 0xd6, 0x68, + 0xc8, 0x3b, 0x30, 0x7b, 0xcf, 0x0f, 0xf6, 0xdb, 0xbe, 0xc3, 0xd3, 0x9f, 0x43, 0x1e, 0x77, 0xd6, + 0xda, 0x64, 0x2c, 0xa2, 0x38, 0xee, 0xc4, 0xf8, 0xd1, 0x24, 0x46, 0x2a, 0xb0, 0xd0, 0x71, 0x3d, + 0xa4, 0x4e, 0x53, 0x47, 0xc5, 0x4d, 0x8a, 0x8c, 0xcb, 0x4a, 0xb5, 0xde, 0x4a, 0x82, 0x31, 0x5d, + 0x9f, 0x1b, 0x7f, 0x82, 0x84, 0xb5, 0x41, 0xa6, 0x55, 0xad, 0x8d, 0x3f, 0x19, 0x93, 0x16, 0x0c, + 0x11, 0xc6, 0x90, 0x2c, 0xc7, 0x14, 0x6d, 0xf2, 0x45, 0x98, 0x09, 0x65, 0xda, 0xbb, 0x7c, 0x9c, + 0x1d, 0xf4, 0xd9, 0x5e, 0x20, 0x8d, 0x87, 0x52, 0x95, 0xa0, 0x26, 0x48, 0x36, 0xe1, 0xbc, 0x32, + 0x9f, 0x24, 0x9e, 0xa8, 0x9a, 0x8a, 0xb3, 0x24, 0x61, 0x06, 0x1c, 0x33, 0x5b, 0x31, 0x55, 0x8e, + 0x67, 0x9c, 0x14, 0x77, 0x84, 0xc6, 0xb5, 0x1a, 0x5f, 0x7f, 0x4d, 0x94, 0xd0, 0x93, 0x82, 0x3e, + 0x67, 0xc6, 0x08, 0xfa, 0xac, 0xc3, 0x85, 0x34, 0x88, 0xa7, 0xbf, 0xe2, 0x19, 0xb7, 0x8c, 0x2d, + 0xb4, 0x96, 0x55, 0x09, 0xb3, 0xdb, 0x92, 0x3b, 0x50, 0x0a, 0x28, 0x3f, 0x64, 0x55, 0x94, 0x7b, + 0xd5, 0xc8, 0x8e, 0xa4, 0xa8, 0x10, 0x60, 0x8c, 0x8b, 0x8d, 0xbb, 0x93, 0xcc, 0x81, 0x7c, 0x2b, + 0xc7, 0xb7, 0x51, 0xe5, 0xd8, 0x0f, 0x48, 0x4b, 0x67, 0xff, 0xdb, 0x05, 0x38, 0x93, 0xb0, 0x01, + 0x91, 0x67, 0xa1, 0xc8, 0xf3, 0x81, 0x71, 0x69, 0x35, 0x13, 0x4b, 0x54, 0xd1, 0x39, 0x02, 0x46, + 0x7e, 0xd9, 0x82, 0x85, 0x6e, 0xe2, 0x5a, 0x45, 0x09, 0xf2, 0x71, 0x0d, 0xa7, 0x09, 0xa4, 0xc6, + 0xeb, 0x01, 0x49, 0x62, 0x98, 0xa6, 0xce, 0xe4, 0x81, 0xf4, 0xc6, 0x6e, 0xd3, 0x80, 0xd7, 0x96, + 0x8a, 0x9e, 0x46, 0xb1, 0x96, 0x04, 0x63, 0xba, 0x3e, 0x1b, 0x61, 0xfe, 0x75, 0xe3, 0xbc, 0xbe, + 0x57, 0x51, 0x08, 0x30, 0xc6, 0x45, 0x5e, 0x83, 0x79, 0x99, 0xfa, 0xb6, 0xe6, 0x37, 0xaf, 0x3b, + 0xe1, 0x9e, 0x3c, 0xe1, 0xe8, 0x13, 0xd9, 0x5a, 0x02, 0x8a, 0xa9, 0xda, 0xfc, 0xdb, 0xe2, 0xfc, + 0xc2, 0x1c, 0xc1, 0x54, 0xf2, 0x71, 0x85, 0xb5, 0x24, 0x18, 0xd3, 0xf5, 0xc9, 0xf3, 0xc6, 0x36, + 0x24, 0xee, 0xed, 0xb5, 0x34, 0xc8, 0xd8, 0x8a, 0x2a, 0xb0, 0xd0, 0xe3, 0x07, 0xc2, 0xa6, 0x02, + 0xca, 0xf5, 0xa8, 0x09, 0xde, 0x4e, 0x82, 0x31, 0x5d, 0x9f, 0xbc, 0x0a, 0x67, 0x02, 0x26, 0x6c, + 0x35, 0x02, 0x71, 0x99, 0xaf, 0xef, 0x6a, 0xd1, 0x04, 0x62, 0xb2, 0x2e, 0x79, 0x1d, 0xce, 0xc6, + 0x99, 0x22, 0x15, 0x02, 0x71, 0xbb, 0xaf, 0xd3, 0x96, 0x55, 0xd2, 0x15, 0xb0, 0xbf, 0x0d, 0xf9, + 0x5b, 0xb0, 0x68, 0xf4, 0xc4, 0x86, 0xd7, 0xa4, 0xf7, 0x65, 0x36, 0x3f, 0xfe, 0x6a, 0xce, 0x5a, + 0x0a, 0x86, 0x7d, 0xb5, 0xc9, 0xa7, 0x60, 0xbe, 0xe1, 0xb7, 0xdb, 0x5c, 0xc6, 0x89, 0xc4, 0xfe, + 0x22, 0x6d, 0x9f, 0x48, 0x70, 0x98, 0x80, 0x60, 0xaa, 0x26, 0xb9, 0x01, 0xc4, 0xdf, 0x61, 0xea, + 0x15, 0x6d, 0xbe, 0x2e, 0x9e, 0x77, 0x67, 0x1a, 0xc7, 0x99, 0x64, 0x2c, 0xc8, 0x9b, 0x7d, 0x35, + 0x30, 0xa3, 0x15, 0xcf, 0x7a, 0x66, 0xc4, 0xce, 0xce, 0xe7, 0xf1, 0x12, 0x5d, 0xda, 0x7c, 0xf1, + 0xd0, 0xc0, 0xd9, 0x00, 0xa6, 0x44, 0x68, 0x4e, 0x3e, 0xf9, 0xfb, 0xcc, 0x1c, 0xdf, 0xf1, 0x1e, + 0x21, 0x4a, 0x51, 0x52, 0x22, 0xbf, 0x00, 0xa5, 0x1d, 0xf5, 0xe0, 0x03, 0x4f, 0xda, 0x37, 0xf6, + 0xbe, 0x98, 0x7a, 0xbb, 0x24, 0x3e, 0x9e, 0x6b, 0x00, 0xc6, 0x24, 0xc9, 0x73, 0x30, 0x7b, 0xbd, + 0x56, 0xd1, 0xb3, 0xf0, 0x2c, 0x1f, 0xfd, 0x49, 0xd6, 0x04, 0x4d, 0x00, 0x5b, 0x61, 0x5a, 0x7d, + 0x23, 0xc9, 0x37, 0x54, 0x32, 0xb4, 0x31, 0x56, 0x9b, 0xdf, 0xc0, 0x63, 0x7d, 0xe9, 0x5c, 0xaa, + 0xb6, 0x2c, 0x47, 0x5d, 0x83, 0xbc, 0x0d, 0xb3, 0x72, 0xbf, 0xe0, 0xb2, 0xe9, 0xfc, 0xa3, 0xc5, + 0x65, 0x63, 0x8c, 0x02, 0x4d, 0x7c, 0xfc, 0xda, 0x98, 0xe7, 0xc1, 0xa7, 0xd7, 0x7a, 0xed, 0xf6, + 0xd2, 0x05, 0x2e, 0x37, 0xe3, 0x6b, 0xe3, 0x18, 0x84, 0x66, 0x3d, 0xf2, 0xa2, 0xf2, 0xa4, 0xfa, + 0x50, 0xe2, 0x1e, 0x5d, 0x7b, 0x52, 0x69, 0xa5, 0x7b, 0x40, 0xe8, 0xc6, 0xc5, 0x87, 0xb8, 0x30, + 0xed, 0xc0, 0xb2, 0xd2, 0xf8, 0xfa, 0x17, 0xc9, 0xd2, 0x52, 0xc2, 0x54, 0xb2, 0x7c, 0x67, 0x60, + 0x4d, 0x3c, 0x01, 0x0b, 0xd9, 0x81, 0x82, 0xd3, 0xde, 0x59, 0x7a, 0x32, 0x0f, 0xd5, 0xb5, 0xb2, + 0x59, 0x95, 0x33, 0x8a, 0xbb, 0x5b, 0x56, 0x36, 0xab, 0xc8, 0x90, 0x13, 0x17, 0x26, 0x9d, 0xf6, + 0x4e, 0xb8, 0xb4, 0xcc, 0xd7, 0x6c, 0x6e, 0x44, 0x62, 0xe3, 0xc1, 0x66, 0x35, 0x44, 0x4e, 0xc2, + 0xfe, 0xf2, 0x84, 0xbe, 0xa8, 0xd1, 0x29, 0x94, 0xdf, 0x35, 0x17, 0x90, 0x95, 0xc7, 0x0b, 0xe5, + 0x7d, 0x0f, 0xb0, 0x88, 0xbd, 0x2f, 0x73, 0xf9, 0x74, 0xb5, 0xc8, 0xc8, 0x25, 0x39, 0x55, 0x32, + 0x3d, 0xb4, 0x38, 0x3d, 0x27, 0x05, 0x86, 0xfd, 0x5d, 0xd0, 0x46, 0xbf, 0x94, 0x17, 0x52, 0x00, + 0x45, 0x37, 0x8c, 0x5c, 0x3f, 0xc7, 0x70, 0xe5, 0x54, 0x5e, 0x65, 0x1e, 0x0d, 0xc1, 0x01, 0x28, + 0x48, 0x31, 0x9a, 0x5e, 0xcb, 0xf5, 0xee, 0xcb, 0xcf, 0xbf, 0x95, 0xbb, 0x7b, 0x91, 0xa0, 0xc9, + 0x01, 0x28, 0x48, 0x91, 0xbb, 0x62, 0x52, 0xe7, 0xf3, 0x1a, 0xfd, 0x66, 0x35, 0x45, 0x2f, 0x39, + 0xb9, 0xef, 0x42, 0x21, 0xec, 0xb8, 0x52, 0x5d, 0x1a, 0x93, 0x56, 0x7d, 0x6b, 0x23, 0x8b, 0x56, + 0x7d, 0x6b, 0x03, 0x19, 0x11, 0xf2, 0x55, 0x0b, 0xc0, 0xe9, 0xec, 0x38, 0x61, 0xe8, 0x34, 0xb5, + 0x75, 0x66, 0xcc, 0xf7, 0x12, 0x2a, 0x1a, 0x5f, 0x8a, 0x34, 0x77, 0xa8, 0x8d, 0xa1, 0x68, 0x50, + 0x26, 0xef, 0xc0, 0xb4, 0x23, 0x5e, 0x66, 0x93, 0xbe, 0xe1, 0xf9, 0x3c, 0x37, 0x98, 0xe2, 0x80, + 0x9b, 0x69, 0x24, 0x08, 0x15, 0x41, 0x46, 0x3b, 0x0a, 0x1c, 0xba, 0xeb, 0xee, 0x4b, 0xe3, 0x50, + 0x7d, 0xec, 0x27, 0x13, 0x18, 0xb2, 0x2c, 0xda, 0x12, 0x84, 0x8a, 0xa0, 0x78, 0x29, 0xdb, 0xf1, + 0x1c, 0x1d, 0xf1, 0x97, 0x4f, 0x5c, 0xa8, 0x19, 0x43, 0x68, 0xbc, 0x94, 0x6d, 0x12, 0xc2, 0x24, + 0x5d, 0x72, 0x00, 0x53, 0x0e, 0x7f, 0x33, 0x52, 0x1e, 0xc5, 0x30, 0x8f, 0xf7, 0x27, 0x53, 0x7d, + 0xc0, 0x85, 0x8b, 0x7c, 0x99, 0x52, 0x52, 0x23, 0xbf, 0x61, 0xc1, 0xb4, 0x70, 0x5b, 0x66, 0x0a, + 0x29, 0xfb, 0xf6, 0x2f, 0x9c, 0x42, 0x7e, 0x76, 0xe9, 0x52, 0x2d, 0x9d, 0x90, 0x3e, 0xaa, 0x7d, + 0x32, 0x45, 0xe9, 0x89, 0x4e, 0xd5, 0x8a, 0xbb, 0xe5, 0x4f, 0xc1, 0x9c, 0x89, 0x65, 0x24, 0xb7, + 0xea, 0x1f, 0x17, 0x00, 0x78, 0x47, 0x8b, 0x1c, 0x1f, 0x1d, 0x9e, 0x4c, 0x76, 0xcf, 0x6f, 0xe6, + 0xf3, 0xd8, 0xa7, 0x99, 0xaa, 0x03, 0x64, 0xe6, 0xd8, 0x3d, 0xbf, 0x89, 0x92, 0x08, 0x69, 0xc1, + 0x64, 0xd7, 0x89, 0xf6, 0xf2, 0xcf, 0x0b, 0x32, 0x23, 0x82, 0x5d, 0xa3, 0x3d, 0xe4, 0x04, 0xc8, + 0x7b, 0x56, 0xec, 0x1a, 0x53, 0xc8, 0xc7, 0x81, 0x41, 0xf5, 0xd9, 0x8a, 0x74, 0x86, 0x11, 0x23, + 0x38, 0xd0, 0x45, 0x66, 0xf9, 0x7d, 0x0b, 0xe6, 0xcc, 0xaa, 0x19, 0xc3, 0xf4, 0x73, 0xe6, 0x30, + 0xe5, 0xd9, 0x1f, 0xe6, 0x88, 0xff, 0x37, 0x0b, 0x8c, 0xd7, 0xdb, 0x63, 0xef, 0x71, 0x6b, 0x68, + 0xef, 0xf1, 0x89, 0x11, 0xbd, 0xc7, 0x0b, 0x23, 0x79, 0x8f, 0x4f, 0x8e, 0xee, 0x3d, 0x5e, 0x1c, + 0xec, 0x3d, 0x6e, 0x7f, 0xd3, 0x82, 0xb3, 0x7d, 0xbb, 0x0d, 0xd3, 0x83, 0x03, 0xdf, 0x8f, 0x06, + 0x78, 0x5d, 0x62, 0x0c, 0x42, 0xb3, 0x1e, 0x59, 0x87, 0x45, 0xf9, 0x74, 0x42, 0xbd, 0xdb, 0x76, + 0x33, 0x73, 0xb6, 0x6c, 0xa7, 0xe0, 0xd8, 0xd7, 0xc2, 0xfe, 0xae, 0x05, 0xb3, 0x46, 0xa4, 0x37, + 0xfb, 0x0e, 0x1e, 0x11, 0x2f, 0xd9, 0x88, 0x9d, 0xe4, 0xf8, 0x45, 0x95, 0x80, 0x89, 0x3b, 0xd3, + 0x96, 0x91, 0x58, 0x3b, 0xbe, 0x33, 0x65, 0xa5, 0x28, 0xa1, 0x22, 0x65, 0x32, 0xed, 0xf2, 0x4e, + 0x2f, 0x98, 0x29, 0x93, 0x69, 0x17, 0x39, 0x84, 0x93, 0x63, 0x07, 0x02, 0x19, 0x58, 0x60, 0x3c, + 0x52, 0xe1, 0x04, 0x11, 0x0a, 0x18, 0xb9, 0x04, 0x05, 0xea, 0x35, 0xa5, 0xf5, 0x42, 0x3f, 0x23, + 0x79, 0xd5, 0x6b, 0x22, 0x2b, 0xb7, 0xdf, 0x84, 0xb9, 0x3a, 0x6d, 0x04, 0x34, 0x7a, 0x83, 0x1e, + 0x0e, 0xfd, 0x2e, 0x25, 0x9b, 0xed, 0xa9, 0x77, 0x29, 0x59, 0x73, 0x56, 0x6e, 0xff, 0x33, 0x0b, + 0x52, 0x2f, 0xa9, 0x18, 0xf7, 0x27, 0xd6, 0xc0, 0xfb, 0x13, 0xd3, 0xe6, 0x3e, 0x71, 0xa2, 0xcd, + 0xfd, 0x06, 0x90, 0x0e, 0x5b, 0x0a, 0x89, 0x77, 0x83, 0xa4, 0xe1, 0x28, 0xce, 0x2b, 0xd1, 0x57, + 0x03, 0x33, 0x5a, 0xd9, 0xff, 0x54, 0x30, 0x6b, 0xbe, 0xad, 0xf2, 0xf0, 0x0e, 0xe8, 0x41, 0x91, + 0xa3, 0x92, 0xd6, 0xb3, 0x31, 0x2d, 0xcf, 0xfd, 0xf9, 0x99, 0xe2, 0x81, 0x94, 0x4b, 0x9e, 0x53, + 0xb3, 0xff, 0x48, 0xf0, 0x6a, 0x3c, 0xbe, 0x32, 0x04, 0xaf, 0x9d, 0x24, 0xaf, 0xd7, 0xf3, 0x92, + 0x95, 0xd9, 0x3c, 0x92, 0x15, 0x80, 0x2e, 0x0d, 0x1a, 0xd4, 0x8b, 0x54, 0xbc, 0x4b, 0x51, 0x46, + 0x5e, 0xea, 0x52, 0x34, 0x6a, 0xd8, 0xdf, 0x60, 0x0b, 0x28, 0x76, 0x2b, 0x25, 0x57, 0xd2, 0xbe, + 0xa2, 0xe9, 0xc5, 0xa1, 0x5d, 0x45, 0x8d, 0x28, 0x88, 0x89, 0x87, 0x44, 0x41, 0x7c, 0x04, 0xa6, + 0x03, 0xbf, 0x4d, 0x2b, 0x81, 0x97, 0x76, 0x70, 0x41, 0x56, 0x8c, 0x37, 0x51, 0xc1, 0xed, 0x5f, + 0xb3, 0x60, 0x31, 0x1d, 0xa6, 0x95, 0xbb, 0x03, 0xab, 0x19, 0x4b, 0x5e, 0x18, 0x3d, 0x96, 0xdc, + 0x7e, 0x8f, 0x31, 0x19, 0xb9, 0x8d, 0x7d, 0xd7, 0x13, 0xe1, 0xd7, 0xac, 0xe7, 0x3e, 0x02, 0xd3, + 0x54, 0xbe, 0x3c, 0x29, 0x8c, 0xc0, 0x9a, 0x49, 0xf5, 0xe0, 0xa4, 0x82, 0x93, 0x0a, 0x2c, 0xa8, + 0xab, 0x2f, 0x65, 0xb9, 0x17, 0x69, 0x23, 0xb4, 0xa5, 0x70, 0x3d, 0x09, 0xc6, 0x74, 0x7d, 0xfb, + 0x4b, 0x30, 0x6b, 0x6c, 0x4a, 0x5c, 0x7e, 0xdf, 0x77, 0x1a, 0x51, 0x5a, 0xee, 0x5d, 0x65, 0x85, + 0x28, 0x60, 0xfc, 0x82, 0x41, 0x44, 0x91, 0xa4, 0xe4, 0x9e, 0x8c, 0x1d, 0x91, 0x50, 0x86, 0x2c, + 0xa0, 0x2d, 0x7a, 0x5f, 0xe5, 0x3d, 0x57, 0xc8, 0x90, 0x15, 0xa2, 0x80, 0xd9, 0xcf, 0xc3, 0x8c, + 0x4a, 0xee, 0xc3, 0x33, 0x64, 0x28, 0xe3, 0xb7, 0x99, 0x21, 0xc3, 0x0f, 0x22, 0xe4, 0x10, 0xfb, + 0x2d, 0x98, 0x51, 0x39, 0x88, 0x1e, 0x5e, 0x9b, 0x89, 0xa2, 0xd0, 0x73, 0xaf, 0xfb, 0x61, 0xa4, + 0x12, 0x27, 0x89, 0xfb, 0xb9, 0x9b, 0x1b, 0xbc, 0x0c, 0x35, 0xd4, 0x7e, 0x11, 0x16, 0x52, 0xf7, + 0xb4, 0x43, 0xa4, 0xd3, 0xf8, 0xbd, 0x02, 0xcc, 0x99, 0xd7, 0x75, 0x43, 0xac, 0xe2, 0xe1, 0x85, + 0x63, 0xc6, 0x15, 0x5b, 0x61, 0xc4, 0x2b, 0x36, 0xf3, 0x4e, 0x73, 0xf2, 0x74, 0xef, 0x34, 0x8b, + 0xf9, 0xdc, 0x69, 0x1a, 0x77, 0xef, 0x53, 0x8f, 0xef, 0xee, 0xfd, 0x77, 0x8a, 0x30, 0x9f, 0xcc, + 0xcf, 0x38, 0xc4, 0x48, 0x3e, 0xdf, 0x37, 0x92, 0x23, 0xda, 0xf4, 0x0b, 0xe3, 0xda, 0xf4, 0x27, + 0xc7, 0xb5, 0xe9, 0x17, 0x1f, 0xc1, 0xa6, 0xdf, 0x6f, 0x91, 0x9f, 0x1a, 0xda, 0x22, 0xff, 0x69, + 0xed, 0x95, 0x37, 0x9d, 0x70, 0x63, 0x89, 0xbd, 0xf2, 0x48, 0x72, 0x18, 0xd6, 0xfc, 0x66, 0xa6, + 0x77, 0xe3, 0xcc, 0x43, 0x6c, 0x97, 0x41, 0xa6, 0x13, 0xdd, 0xe8, 0xd7, 0x86, 0x1f, 0x1a, 0xc1, + 0x81, 0xee, 0x65, 0x98, 0x95, 0xf3, 0x89, 0xab, 0xa0, 0x90, 0x54, 0x5f, 0xeb, 0x31, 0x08, 0xcd, + 0x7a, 0xfc, 0xe9, 0xee, 0xe4, 0xcb, 0xe6, 0xfc, 0x8a, 0xc4, 0x7c, 0xba, 0x3b, 0xf5, 0x12, 0x7a, + 0xba, 0xbe, 0xfd, 0x45, 0xb8, 0x90, 0x69, 0x46, 0xe0, 0x26, 0x5c, 0xae, 0x1d, 0xd1, 0xa6, 0xac, + 0x60, 0xb0, 0x91, 0x4a, 0xf9, 0xbf, 0x7c, 0x67, 0x60, 0x4d, 0x3c, 0x01, 0x8b, 0xfd, 0x9d, 0x02, + 0xcc, 0x27, 0xdf, 0x7d, 0x24, 0xf7, 0xb4, 0xd1, 0x31, 0x17, 0x7b, 0xa7, 0x40, 0x6b, 0xe4, 0xfc, + 0x1b, 0x78, 0x59, 0x71, 0x8f, 0xcf, 0xaf, 0x1d, 0x9d, 0x80, 0xf0, 0xf4, 0x08, 0xcb, 0x5b, 0x02, + 0x49, 0x8e, 0x3f, 0xed, 0x18, 0x87, 0x07, 0xca, 0xd3, 0x6c, 0xee, 0xd4, 0xe3, 0x88, 0x3d, 0x4d, + 0x0a, 0x0d, 0xb2, 0x6c, 0x6f, 0x39, 0xa0, 0x81, 0xbb, 0xeb, 0xea, 0x37, 0xab, 0xb9, 0xe4, 0x7e, + 0x4b, 0x96, 0xa1, 0x86, 0xda, 0xef, 0x4d, 0x40, 0xfc, 0x9e, 0x3f, 0x7f, 0x1c, 0x2d, 0x34, 0x4e, + 0x0e, 0x72, 0xd8, 0x6e, 0x8c, 0xfb, 0x02, 0x61, 0x8c, 0x51, 0x7a, 0x4c, 0x1b, 0x25, 0x98, 0xa0, + 0xf8, 0x13, 0x78, 0xc7, 0xdf, 0x81, 0x85, 0x54, 0x3a, 0x8a, 0xdc, 0x73, 0xb6, 0xfe, 0xa8, 0x00, + 0x25, 0x1d, 0xae, 0x43, 0x3e, 0x99, 0x30, 0xe3, 0x94, 0xaa, 0x1f, 0x36, 0x5e, 0xee, 0xd9, 0xf3, + 0x9b, 0x0f, 0x8e, 0xca, 0x0b, 0xba, 0x72, 0xca, 0x24, 0x73, 0x09, 0x0a, 0xbd, 0xa0, 0x9d, 0x3e, + 0xa7, 0xdd, 0xc6, 0x4d, 0x64, 0xe5, 0x66, 0x88, 0x51, 0xe1, 0xb1, 0x86, 0x18, 0xb1, 0x5d, 0x72, + 0xc7, 0x6f, 0x1e, 0xa6, 0x5f, 0xfa, 0xa9, 0xfa, 0xcd, 0x43, 0xe4, 0x10, 0xf2, 0x1a, 0xcc, 0xcb, + 0xb8, 0x29, 0xf3, 0xfd, 0xf3, 0x42, 0x7c, 0xf9, 0xbe, 0x9d, 0x80, 0x62, 0xaa, 0x36, 0xdb, 0x65, + 0xef, 0x86, 0xbe, 0xc7, 0x33, 0xf1, 0x4e, 0x25, 0x6f, 0xea, 0x6e, 0xd4, 0xdf, 0xbc, 0xc9, 0xcd, + 0x49, 0xba, 0x46, 0x22, 0x34, 0x6b, 0xfa, 0xa1, 0xa1, 0x59, 0xeb, 0x02, 0x37, 0xe3, 0x96, 0xef, + 0x28, 0x73, 0xd5, 0x2b, 0x0a, 0x2f, 0x2b, 0x7b, 0x70, 0x74, 0x82, 0xa1, 0x4f, 0xb7, 0xb4, 0x6f, + 0xc3, 0x42, 0xaa, 0xc3, 0xd4, 0xb9, 0xda, 0xca, 0x3e, 0x57, 0x0f, 0xf7, 0x38, 0xcf, 0xbf, 0xb0, + 0xe0, 0x6c, 0x9f, 0x08, 0x18, 0x36, 0x82, 0x30, 0xbd, 0x19, 0x4d, 0x3c, 0xfa, 0x66, 0x54, 0x18, + 0x6d, 0x33, 0xaa, 0xee, 0x7c, 0xef, 0x87, 0x97, 0x9f, 0xf8, 0xfe, 0x0f, 0x2f, 0x3f, 0xf1, 0xc7, + 0x3f, 0xbc, 0xfc, 0xc4, 0x7b, 0xc7, 0x97, 0xad, 0xef, 0x1d, 0x5f, 0xb6, 0xbe, 0x7f, 0x7c, 0xd9, + 0xfa, 0xe3, 0xe3, 0xcb, 0xd6, 0x7f, 0x3a, 0xbe, 0x6c, 0x7d, 0xf3, 0x47, 0x97, 0x9f, 0xf8, 0xec, + 0xa7, 0xe3, 0x09, 0xba, 0xaa, 0x26, 0x28, 0xff, 0xf1, 0x31, 0x35, 0x1d, 0x57, 0xbb, 0xfb, 0xad, + 0x55, 0x36, 0x41, 0x57, 0x75, 0x89, 0x9a, 0xa0, 0xff, 0x27, 0x00, 0x00, 0xff, 0xff, 0xdc, 0xf0, + 0x4e, 0x06, 0x76, 0x9f, 0x00, 0x00, +} + +func (m *ALBStatus) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ALBStatus) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ALBStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.Ingress) + copy(dAtA[i:], m.Ingress) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Ingress))) + i-- + dAtA[i] = 0x22 + { + size, err := m.StableTargetGroup.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + { + size, err := m.CanaryTargetGroup.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + { + size, err := m.LoadBalancer.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *ALBTrafficRouting) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ALBTrafficRouting) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ALBTrafficRouting) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Ingresses) > 0 { + for iNdEx := len(m.Ingresses) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Ingresses[iNdEx]) + copy(dAtA[i:], m.Ingresses[iNdEx]) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Ingresses[iNdEx]))) + i-- + dAtA[i] = 0x32 + } + } + if m.StickinessConfig != nil { + { + size, err := m.StickinessConfig.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + i -= len(m.AnnotationPrefix) + copy(dAtA[i:], m.AnnotationPrefix) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.AnnotationPrefix))) + i-- + dAtA[i] = 0x22 + i -= len(m.RootService) + copy(dAtA[i:], m.RootService) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.RootService))) + i-- + dAtA[i] = 0x1a + i = encodeVarintGenerated(dAtA, i, uint64(m.ServicePort)) + i-- + dAtA[i] = 0x10 + i -= len(m.Ingress) + copy(dAtA[i:], m.Ingress) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Ingress))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *AmbassadorTrafficRouting) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *AmbassadorTrafficRouting) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AmbassadorTrafficRouting) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Mappings) > 0 { + for iNdEx := len(m.Mappings) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Mappings[iNdEx]) + copy(dAtA[i:], m.Mappings[iNdEx]) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Mappings[iNdEx]))) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *AnalysisRun) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *AnalysisRun) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AnalysisRun) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Status.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + { + size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + { + size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *AnalysisRunArgument) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *AnalysisRunArgument) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AnalysisRunArgument) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.ValueFrom != nil { + { + size, err := m.ValueFrom.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + i -= len(m.Value) + copy(dAtA[i:], m.Value) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Value))) + i-- + dAtA[i] = 0x12 + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *AnalysisRunList) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *AnalysisRunList) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AnalysisRunList) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Items) > 0 { + for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + { + size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *AnalysisRunMetadata) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *AnalysisRunMetadata) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AnalysisRunMetadata) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Annotations) > 0 { + keysForAnnotations := make([]string, 0, len(m.Annotations)) + for k := range m.Annotations { + keysForAnnotations = append(keysForAnnotations, string(k)) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForAnnotations) + for iNdEx := len(keysForAnnotations) - 1; iNdEx >= 0; iNdEx-- { + v := m.Annotations[string(keysForAnnotations[iNdEx])] + baseI := i + i -= len(v) + copy(dAtA[i:], v) + i = encodeVarintGenerated(dAtA, i, uint64(len(v))) + i-- + dAtA[i] = 0x12 + i -= len(keysForAnnotations[iNdEx]) + copy(dAtA[i:], keysForAnnotations[iNdEx]) + i = encodeVarintGenerated(dAtA, i, uint64(len(keysForAnnotations[iNdEx]))) + i-- + dAtA[i] = 0xa + i = encodeVarintGenerated(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x12 + } + } + if len(m.Labels) > 0 { + keysForLabels := make([]string, 0, len(m.Labels)) + for k := range m.Labels { + keysForLabels = append(keysForLabels, string(k)) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForLabels) + for iNdEx := len(keysForLabels) - 1; iNdEx >= 0; iNdEx-- { + v := m.Labels[string(keysForLabels[iNdEx])] + baseI := i + i -= len(v) + copy(dAtA[i:], v) + i = encodeVarintGenerated(dAtA, i, uint64(len(v))) + i-- + dAtA[i] = 0x12 + i -= len(keysForLabels[iNdEx]) + copy(dAtA[i:], keysForLabels[iNdEx]) + i = encodeVarintGenerated(dAtA, i, uint64(len(keysForLabels[iNdEx]))) + i-- + dAtA[i] = 0xa + i = encodeVarintGenerated(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *AnalysisRunSpec) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *AnalysisRunSpec) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AnalysisRunSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.MeasurementRetention) > 0 { + for iNdEx := len(m.MeasurementRetention) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.MeasurementRetention[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + } + if len(m.DryRun) > 0 { + for iNdEx := len(m.DryRun) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.DryRun[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + } + i-- + if m.Terminate { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x18 + if len(m.Args) > 0 { + for iNdEx := len(m.Args) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Args[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + if len(m.Metrics) > 0 { + for iNdEx := len(m.Metrics) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Metrics[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *AnalysisRunStatus) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *AnalysisRunStatus) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AnalysisRunStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.DryRunSummary != nil { + { + size, err := m.DryRunSummary.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + } + { + size, err := m.RunSummary.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + if m.StartedAt != nil { + { + size, err := m.StartedAt.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + if len(m.MetricResults) > 0 { + for iNdEx := len(m.MetricResults) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.MetricResults[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + } + i -= len(m.Message) + copy(dAtA[i:], m.Message) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message))) + i-- + dAtA[i] = 0x12 + i -= len(m.Phase) + copy(dAtA[i:], m.Phase) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Phase))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *AnalysisRunStrategy) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *AnalysisRunStrategy) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AnalysisRunStrategy) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.UnsuccessfulRunHistoryLimit != nil { + i = encodeVarintGenerated(dAtA, i, uint64(*m.UnsuccessfulRunHistoryLimit)) + i-- + dAtA[i] = 0x10 + } + if m.SuccessfulRunHistoryLimit != nil { + i = encodeVarintGenerated(dAtA, i, uint64(*m.SuccessfulRunHistoryLimit)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *AnalysisTemplate) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *AnalysisTemplate) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AnalysisTemplate) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + { + size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *AnalysisTemplateList) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *AnalysisTemplateList) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AnalysisTemplateList) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Items) > 0 { + for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + { + size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *AnalysisTemplateSpec) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *AnalysisTemplateSpec) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AnalysisTemplateSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.MeasurementRetention) > 0 { + for iNdEx := len(m.MeasurementRetention) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.MeasurementRetention[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + } + if len(m.DryRun) > 0 { + for iNdEx := len(m.DryRun) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.DryRun[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + } + if len(m.Args) > 0 { + for iNdEx := len(m.Args) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Args[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + if len(m.Metrics) > 0 { + for iNdEx := len(m.Metrics) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Metrics[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *AntiAffinity) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *AntiAffinity) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AntiAffinity) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.RequiredDuringSchedulingIgnoredDuringExecution != nil { + { + size, err := m.RequiredDuringSchedulingIgnoredDuringExecution.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.PreferredDuringSchedulingIgnoredDuringExecution != nil { + { + size, err := m.PreferredDuringSchedulingIgnoredDuringExecution.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ApisixRoute) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ApisixRoute) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ApisixRoute) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Rules) > 0 { + for iNdEx := len(m.Rules) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Rules[iNdEx]) + copy(dAtA[i:], m.Rules[iNdEx]) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Rules[iNdEx]))) + i-- + dAtA[i] = 0x12 + } + } + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *ApisixTrafficRouting) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ApisixTrafficRouting) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ApisixTrafficRouting) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Route != nil { + { + size, err := m.Route.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *AppMeshTrafficRouting) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *AppMeshTrafficRouting) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AppMeshTrafficRouting) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.VirtualNodeGroup != nil { + { + size, err := m.VirtualNodeGroup.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.VirtualService != nil { + { + size, err := m.VirtualService.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *AppMeshVirtualNodeGroup) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *AppMeshVirtualNodeGroup) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AppMeshVirtualNodeGroup) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.StableVirtualNodeRef != nil { + { + size, err := m.StableVirtualNodeRef.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.CanaryVirtualNodeRef != nil { + { + size, err := m.CanaryVirtualNodeRef.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *AppMeshVirtualNodeReference) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *AppMeshVirtualNodeReference) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AppMeshVirtualNodeReference) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *AppMeshVirtualService) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *AppMeshVirtualService) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AppMeshVirtualService) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Routes) > 0 { + for iNdEx := len(m.Routes) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Routes[iNdEx]) + copy(dAtA[i:], m.Routes[iNdEx]) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Routes[iNdEx]))) + i-- + dAtA[i] = 0x12 + } + } + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *Argument) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Argument) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Argument) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.ValueFrom != nil { + { + size, err := m.ValueFrom.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.Value != nil { + i -= len(*m.Value) + copy(dAtA[i:], *m.Value) + i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Value))) + i-- + dAtA[i] = 0x12 + } + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *ArgumentValueFrom) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ArgumentValueFrom) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ArgumentValueFrom) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.FieldRef != nil { + { + size, err := m.FieldRef.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.PodTemplateHashValue != nil { + i -= len(*m.PodTemplateHashValue) + copy(dAtA[i:], *m.PodTemplateHashValue) + i = encodeVarintGenerated(dAtA, i, uint64(len(*m.PodTemplateHashValue))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *AwsResourceRef) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *AwsResourceRef) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AwsResourceRef) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.FullName) + copy(dAtA[i:], m.FullName) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.FullName))) + i-- + dAtA[i] = 0x1a + i -= len(m.ARN) + copy(dAtA[i:], m.ARN) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.ARN))) + i-- + dAtA[i] = 0x12 + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *BlueGreenStatus) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BlueGreenStatus) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *BlueGreenStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.PostPromotionAnalysisRunStatus != nil { + { + size, err := m.PostPromotionAnalysisRunStatus.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + if m.PrePromotionAnalysisRunStatus != nil { + { + size, err := m.PrePromotionAnalysisRunStatus.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + i-- + if m.ScaleUpPreviewCheckPoint { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x18 + i -= len(m.ActiveSelector) + copy(dAtA[i:], m.ActiveSelector) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.ActiveSelector))) + i-- + dAtA[i] = 0x12 + i -= len(m.PreviewSelector) + copy(dAtA[i:], m.PreviewSelector) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.PreviewSelector))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *BlueGreenStrategy) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BlueGreenStrategy) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *BlueGreenStrategy) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.AbortScaleDownDelaySeconds != nil { + i = encodeVarintGenerated(dAtA, i, uint64(*m.AbortScaleDownDelaySeconds)) + i-- + dAtA[i] = 0x70 + } + if m.ActiveMetadata != nil { + { + size, err := m.ActiveMetadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x6a + } + if m.PreviewMetadata != nil { + { + size, err := m.PreviewMetadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x62 + } + if m.PostPromotionAnalysis != nil { + { + size, err := m.PostPromotionAnalysis.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x5a + } + if m.AntiAffinity != nil { + { + size, err := m.AntiAffinity.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x52 + } + if m.PrePromotionAnalysis != nil { + { + size, err := m.PrePromotionAnalysis.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x4a + } + if m.ScaleDownDelayRevisionLimit != nil { + i = encodeVarintGenerated(dAtA, i, uint64(*m.ScaleDownDelayRevisionLimit)) + i-- + dAtA[i] = 0x40 + } + if m.ScaleDownDelaySeconds != nil { + i = encodeVarintGenerated(dAtA, i, uint64(*m.ScaleDownDelaySeconds)) + i-- + dAtA[i] = 0x38 + } + if m.MaxUnavailable != nil { + { + size, err := m.MaxUnavailable.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + } + i = encodeVarintGenerated(dAtA, i, uint64(m.AutoPromotionSeconds)) + i-- + dAtA[i] = 0x28 + if m.AutoPromotionEnabled != nil { + i-- + if *m.AutoPromotionEnabled { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x20 + } + if m.PreviewReplicaCount != nil { + i = encodeVarintGenerated(dAtA, i, uint64(*m.PreviewReplicaCount)) + i-- + dAtA[i] = 0x18 + } + i -= len(m.PreviewService) + copy(dAtA[i:], m.PreviewService) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.PreviewService))) + i-- + dAtA[i] = 0x12 + i -= len(m.ActiveService) + copy(dAtA[i:], m.ActiveService) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.ActiveService))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *CanaryStatus) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CanaryStatus) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CanaryStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.StablePingPong) + copy(dAtA[i:], m.StablePingPong) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.StablePingPong))) + i-- + dAtA[i] = 0x2a + if m.Weights != nil { + { + size, err := m.Weights.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + i -= len(m.CurrentExperiment) + copy(dAtA[i:], m.CurrentExperiment) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.CurrentExperiment))) + i-- + dAtA[i] = 0x1a + if m.CurrentBackgroundAnalysisRunStatus != nil { + { + size, err := m.CurrentBackgroundAnalysisRunStatus.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.CurrentStepAnalysisRunStatus != nil { + { + size, err := m.CurrentStepAnalysisRunStatus.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *CanaryStep) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CanaryStep) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CanaryStep) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.SetMirrorRoute != nil { + { + size, err := m.SetMirrorRoute.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x42 + } + if m.SetHeaderRoute != nil { + { + size, err := m.SetHeaderRoute.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + } + if m.SetCanaryScale != nil { + { + size, err := m.SetCanaryScale.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + if m.Analysis != nil { + { + size, err := m.Analysis.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + if m.Experiment != nil { + { + size, err := m.Experiment.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.Pause != nil { + { + size, err := m.Pause.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.SetWeight != nil { + i = encodeVarintGenerated(dAtA, i, uint64(*m.SetWeight)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *CanaryStrategy) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CanaryStrategy) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CanaryStrategy) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.MinPodsPerReplicaSet != nil { + i = encodeVarintGenerated(dAtA, i, uint64(*m.MinPodsPerReplicaSet)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x80 + } + if m.PingPong != nil { + { + size, err := m.PingPong.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x7a + } + i-- + if m.DynamicStableScale { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x70 + if m.AbortScaleDownDelaySeconds != nil { + i = encodeVarintGenerated(dAtA, i, uint64(*m.AbortScaleDownDelaySeconds)) + i-- + dAtA[i] = 0x68 + } + if m.ScaleDownDelayRevisionLimit != nil { + i = encodeVarintGenerated(dAtA, i, uint64(*m.ScaleDownDelayRevisionLimit)) + i-- + dAtA[i] = 0x60 + } + if m.ScaleDownDelaySeconds != nil { + i = encodeVarintGenerated(dAtA, i, uint64(*m.ScaleDownDelaySeconds)) + i-- + dAtA[i] = 0x58 + } + if m.StableMetadata != nil { + { + size, err := m.StableMetadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x52 + } + if m.CanaryMetadata != nil { + { + size, err := m.CanaryMetadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x4a + } + if m.AntiAffinity != nil { + { + size, err := m.AntiAffinity.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x42 + } + if m.Analysis != nil { + { + size, err := m.Analysis.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x3a + } + if m.MaxSurge != nil { + { + size, err := m.MaxSurge.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + } + if m.MaxUnavailable != nil { + { + size, err := m.MaxUnavailable.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + if m.TrafficRouting != nil { + { + size, err := m.TrafficRouting.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + if len(m.Steps) > 0 { + for iNdEx := len(m.Steps) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Steps[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + } + i -= len(m.StableService) + copy(dAtA[i:], m.StableService) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.StableService))) + i-- + dAtA[i] = 0x12 + i -= len(m.CanaryService) + copy(dAtA[i:], m.CanaryService) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.CanaryService))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *CloudWatchMetric) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CloudWatchMetric) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CloudWatchMetric) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.MetricDataQueries) > 0 { + for iNdEx := len(m.MetricDataQueries) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.MetricDataQueries[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + i -= len(m.Interval) + copy(dAtA[i:], m.Interval) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Interval))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *CloudWatchMetricDataQuery) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CloudWatchMetricDataQuery) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CloudWatchMetricDataQuery) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.ReturnData != nil { + i-- + if *m.ReturnData { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x30 + } + if m.Period != nil { + { + size, err := m.Period.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + if m.MetricStat != nil { + { + size, err := m.MetricStat.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + if m.Label != nil { + i -= len(*m.Label) + copy(dAtA[i:], *m.Label) + i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Label))) + i-- + dAtA[i] = 0x1a + } + if m.Expression != nil { + i -= len(*m.Expression) + copy(dAtA[i:], *m.Expression) + i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Expression))) + i-- + dAtA[i] = 0x12 + } + i -= len(m.Id) + copy(dAtA[i:], m.Id) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Id))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *CloudWatchMetricStat) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CloudWatchMetricStat) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CloudWatchMetricStat) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.Unit) + copy(dAtA[i:], m.Unit) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Unit))) + i-- + dAtA[i] = 0x22 + i -= len(m.Stat) + copy(dAtA[i:], m.Stat) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Stat))) + i-- + dAtA[i] = 0x1a + { + size, err := m.Period.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + { + size, err := m.Metric.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *CloudWatchMetricStatMetric) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CloudWatchMetricStatMetric) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CloudWatchMetricStatMetric) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Namespace != nil { + i -= len(*m.Namespace) + copy(dAtA[i:], *m.Namespace) + i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Namespace))) + i-- + dAtA[i] = 0x1a + } + i -= len(m.MetricName) + copy(dAtA[i:], m.MetricName) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.MetricName))) + i-- + dAtA[i] = 0x12 + if len(m.Dimensions) > 0 { + for iNdEx := len(m.Dimensions) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Dimensions[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *CloudWatchMetricStatMetricDimension) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CloudWatchMetricStatMetricDimension) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CloudWatchMetricStatMetricDimension) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.Value) + copy(dAtA[i:], m.Value) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Value))) + i-- + dAtA[i] = 0x12 + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *ClusterAnalysisTemplate) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClusterAnalysisTemplate) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ClusterAnalysisTemplate) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + { + size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *ClusterAnalysisTemplateList) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClusterAnalysisTemplateList) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ClusterAnalysisTemplateList) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Items) > 0 { + for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + { + size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *DatadogMetric) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DatadogMetric) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DatadogMetric) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.ApiVersion) + copy(dAtA[i:], m.ApiVersion) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.ApiVersion))) + i-- + dAtA[i] = 0x1a + i -= len(m.Query) + copy(dAtA[i:], m.Query) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Query))) + i-- + dAtA[i] = 0x12 + i -= len(m.Interval) + copy(dAtA[i:], m.Interval) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Interval))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *DryRun) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DryRun) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DryRun) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.MetricName) + copy(dAtA[i:], m.MetricName) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.MetricName))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *Experiment) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Experiment) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Experiment) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Status.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + { + size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + { + size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *ExperimentAnalysisRunStatus) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExperimentAnalysisRunStatus) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ExperimentAnalysisRunStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.Message) + copy(dAtA[i:], m.Message) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message))) + i-- + dAtA[i] = 0x22 + i -= len(m.Phase) + copy(dAtA[i:], m.Phase) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Phase))) + i-- + dAtA[i] = 0x1a + i -= len(m.AnalysisRun) + copy(dAtA[i:], m.AnalysisRun) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.AnalysisRun))) + i-- + dAtA[i] = 0x12 + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *ExperimentAnalysisTemplateRef) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExperimentAnalysisTemplateRef) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ExperimentAnalysisTemplateRef) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i-- + if m.RequiredForCompletion { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x28 + if len(m.Args) > 0 { + for iNdEx := len(m.Args) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Args[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + } + i-- + if m.ClusterScope { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x18 + i -= len(m.TemplateName) + copy(dAtA[i:], m.TemplateName) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.TemplateName))) + i-- + dAtA[i] = 0x12 + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *ExperimentCondition) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExperimentCondition) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ExperimentCondition) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.Message) + copy(dAtA[i:], m.Message) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message))) + i-- + dAtA[i] = 0x32 + i -= len(m.Reason) + copy(dAtA[i:], m.Reason) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason))) + i-- + dAtA[i] = 0x2a + { + size, err := m.LastTransitionTime.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + { + size, err := m.LastUpdateTime.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + i -= len(m.Status) + copy(dAtA[i:], m.Status) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status))) + i-- + dAtA[i] = 0x12 + i -= len(m.Type) + copy(dAtA[i:], m.Type) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *ExperimentList) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExperimentList) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ExperimentList) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Items) > 0 { + for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + { + size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *ExperimentSpec) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExperimentSpec) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ExperimentSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.MeasurementRetention) > 0 { + for iNdEx := len(m.MeasurementRetention) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.MeasurementRetention[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x42 + } + } + if len(m.DryRun) > 0 { + for iNdEx := len(m.DryRun) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.DryRun[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x3a + } + } + if m.ScaleDownDelaySeconds != nil { + i = encodeVarintGenerated(dAtA, i, uint64(*m.ScaleDownDelaySeconds)) + i-- + dAtA[i] = 0x30 + } + if len(m.Analyses) > 0 { + for iNdEx := len(m.Analyses) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Analyses[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + } + i-- + if m.Terminate { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x20 + if m.ProgressDeadlineSeconds != nil { + i = encodeVarintGenerated(dAtA, i, uint64(*m.ProgressDeadlineSeconds)) + i-- + dAtA[i] = 0x18 + } + i -= len(m.Duration) + copy(dAtA[i:], m.Duration) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Duration))) + i-- + dAtA[i] = 0x12 + if len(m.Templates) > 0 { + for iNdEx := len(m.Templates) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Templates[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *ExperimentStatus) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExperimentStatus) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ExperimentStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.AnalysisRuns) > 0 { + for iNdEx := len(m.AnalysisRuns) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.AnalysisRuns[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + } + } + if len(m.Conditions) > 0 { + for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Conditions[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + } + if m.AvailableAt != nil { + { + size, err := m.AvailableAt.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + if len(m.TemplateStatuses) > 0 { + for iNdEx := len(m.TemplateStatuses) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.TemplateStatuses[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + } + i -= len(m.Message) + copy(dAtA[i:], m.Message) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message))) + i-- + dAtA[i] = 0x12 + i -= len(m.Phase) + copy(dAtA[i:], m.Phase) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Phase))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *FieldRef) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *FieldRef) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *FieldRef) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.FieldPath) + copy(dAtA[i:], m.FieldPath) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.FieldPath))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *GraphiteMetric) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GraphiteMetric) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GraphiteMetric) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.Query) + copy(dAtA[i:], m.Query) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Query))) + i-- + dAtA[i] = 0x12 + i -= len(m.Address) + copy(dAtA[i:], m.Address) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Address))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *HeaderRoutingMatch) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *HeaderRoutingMatch) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *HeaderRoutingMatch) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.HeaderValue != nil { + { + size, err := m.HeaderValue.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + i -= len(m.HeaderName) + copy(dAtA[i:], m.HeaderName) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.HeaderName))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *InfluxdbMetric) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *InfluxdbMetric) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *InfluxdbMetric) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.Query) + copy(dAtA[i:], m.Query) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Query))) + i-- + dAtA[i] = 0x12 + i -= len(m.Profile) + copy(dAtA[i:], m.Profile) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Profile))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *IstioDestinationRule) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *IstioDestinationRule) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *IstioDestinationRule) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.StableSubsetName) + copy(dAtA[i:], m.StableSubsetName) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.StableSubsetName))) + i-- + dAtA[i] = 0x1a + i -= len(m.CanarySubsetName) + copy(dAtA[i:], m.CanarySubsetName) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.CanarySubsetName))) + i-- + dAtA[i] = 0x12 + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *IstioTrafficRouting) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *IstioTrafficRouting) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *IstioTrafficRouting) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.VirtualServices) > 0 { + for iNdEx := len(m.VirtualServices) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.VirtualServices[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + } + if m.DestinationRule != nil { + { + size, err := m.DestinationRule.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.VirtualService != nil { + { + size, err := m.VirtualService.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *IstioVirtualService) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *IstioVirtualService) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *IstioVirtualService) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.TCPRoutes) > 0 { + for iNdEx := len(m.TCPRoutes) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.TCPRoutes[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + } + if len(m.TLSRoutes) > 0 { + for iNdEx := len(m.TLSRoutes) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.TLSRoutes[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + } + if len(m.Routes) > 0 { + for iNdEx := len(m.Routes) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Routes[iNdEx]) + copy(dAtA[i:], m.Routes[iNdEx]) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Routes[iNdEx]))) + i-- + dAtA[i] = 0x12 + } + } + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *JobMetric) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *JobMetric) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *JobMetric) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + { + size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *KayentaMetric) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *KayentaMetric) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *KayentaMetric) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Scopes) > 0 { + for iNdEx := len(m.Scopes) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Scopes[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x42 + } + } + { + size, err := m.Threshold.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x3a + i -= len(m.StorageAccountName) + copy(dAtA[i:], m.StorageAccountName) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.StorageAccountName))) + i-- + dAtA[i] = 0x32 + i -= len(m.ConfigurationAccountName) + copy(dAtA[i:], m.ConfigurationAccountName) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.ConfigurationAccountName))) + i-- + dAtA[i] = 0x2a + i -= len(m.MetricsAccountName) + copy(dAtA[i:], m.MetricsAccountName) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.MetricsAccountName))) + i-- + dAtA[i] = 0x22 + i -= len(m.CanaryConfigName) + copy(dAtA[i:], m.CanaryConfigName) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.CanaryConfigName))) + i-- + dAtA[i] = 0x1a + i -= len(m.Application) + copy(dAtA[i:], m.Application) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Application))) + i-- + dAtA[i] = 0x12 + i -= len(m.Address) + copy(dAtA[i:], m.Address) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Address))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *KayentaScope) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *KayentaScope) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *KayentaScope) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.ExperimentScope.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + { + size, err := m.ControlScope.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *KayentaThreshold) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *KayentaThreshold) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *KayentaThreshold) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i = encodeVarintGenerated(dAtA, i, uint64(m.Marginal)) + i-- + dAtA[i] = 0x10 + i = encodeVarintGenerated(dAtA, i, uint64(m.Pass)) + i-- + dAtA[i] = 0x8 + return len(dAtA) - i, nil +} + +func (m *MangedRoutes) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MangedRoutes) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MangedRoutes) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *Measurement) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Measurement) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Measurement) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.ResumeAt != nil { + { + size, err := m.ResumeAt.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x3a + } + if len(m.Metadata) > 0 { + keysForMetadata := make([]string, 0, len(m.Metadata)) + for k := range m.Metadata { + keysForMetadata = append(keysForMetadata, string(k)) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForMetadata) + for iNdEx := len(keysForMetadata) - 1; iNdEx >= 0; iNdEx-- { + v := m.Metadata[string(keysForMetadata[iNdEx])] + baseI := i + i -= len(v) + copy(dAtA[i:], v) + i = encodeVarintGenerated(dAtA, i, uint64(len(v))) + i-- + dAtA[i] = 0x12 + i -= len(keysForMetadata[iNdEx]) + copy(dAtA[i:], keysForMetadata[iNdEx]) + i = encodeVarintGenerated(dAtA, i, uint64(len(keysForMetadata[iNdEx]))) + i-- + dAtA[i] = 0xa + i = encodeVarintGenerated(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x32 + } + } + i -= len(m.Value) + copy(dAtA[i:], m.Value) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Value))) + i-- + dAtA[i] = 0x2a + if m.FinishedAt != nil { + { + size, err := m.FinishedAt.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + if m.StartedAt != nil { + { + size, err := m.StartedAt.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + i -= len(m.Message) + copy(dAtA[i:], m.Message) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message))) + i-- + dAtA[i] = 0x12 + i -= len(m.Phase) + copy(dAtA[i:], m.Phase) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Phase))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *MeasurementRetention) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MeasurementRetention) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MeasurementRetention) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i = encodeVarintGenerated(dAtA, i, uint64(m.Limit)) + i-- + dAtA[i] = 0x10 + i -= len(m.MetricName) + copy(dAtA[i:], m.MetricName) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.MetricName))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *Metric) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Metric) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Metric) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Provider.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x52 + if m.ConsecutiveErrorLimit != nil { + { + size, err := m.ConsecutiveErrorLimit.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x4a + } + if m.InconclusiveLimit != nil { + { + size, err := m.InconclusiveLimit.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x42 + } + if m.FailureLimit != nil { + { + size, err := m.FailureLimit.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x3a + } + i -= len(m.FailureCondition) + copy(dAtA[i:], m.FailureCondition) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.FailureCondition))) + i-- + dAtA[i] = 0x32 + i -= len(m.SuccessCondition) + copy(dAtA[i:], m.SuccessCondition) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.SuccessCondition))) + i-- + dAtA[i] = 0x2a + if m.Count != nil { + { + size, err := m.Count.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + i -= len(m.InitialDelay) + copy(dAtA[i:], m.InitialDelay) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.InitialDelay))) + i-- + dAtA[i] = 0x1a + i -= len(m.Interval) + copy(dAtA[i:], m.Interval) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Interval))) + i-- + dAtA[i] = 0x12 + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *MetricProvider) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MetricProvider) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MetricProvider) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Plugin) > 0 { + keysForPlugin := make([]string, 0, len(m.Plugin)) + for k := range m.Plugin { + keysForPlugin = append(keysForPlugin, string(k)) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForPlugin) + for iNdEx := len(keysForPlugin) - 1; iNdEx >= 0; iNdEx-- { + v := m.Plugin[string(keysForPlugin[iNdEx])] + baseI := i + if v != nil { + i -= len(v) + copy(dAtA[i:], v) + i = encodeVarintGenerated(dAtA, i, uint64(len(v))) + i-- + dAtA[i] = 0x12 + } + i -= len(keysForPlugin[iNdEx]) + copy(dAtA[i:], keysForPlugin[iNdEx]) + i = encodeVarintGenerated(dAtA, i, uint64(len(keysForPlugin[iNdEx]))) + i-- + dAtA[i] = 0xa + i = encodeVarintGenerated(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x62 + } + } + if m.SkyWalking != nil { + { + size, err := m.SkyWalking.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x5a + } + if m.Influxdb != nil { + { + size, err := m.Influxdb.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x52 + } + if m.Graphite != nil { + { + size, err := m.Graphite.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x4a + } + if m.CloudWatch != nil { + { + size, err := m.CloudWatch.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x42 + } + if m.Job != nil { + { + size, err := m.Job.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x3a + } + if m.NewRelic != nil { + { + size, err := m.NewRelic.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + } + if m.Wavefront != nil { + { + size, err := m.Wavefront.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + if m.Datadog != nil { + { + size, err := m.Datadog.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + if m.Web != nil { + { + size, err := m.Web.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.Kayenta != nil { + { + size, err := m.Kayenta.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Prometheus != nil { + { + size, err := m.Prometheus.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MetricResult) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MetricResult) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MetricResult) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Metadata) > 0 { + keysForMetadata := make([]string, 0, len(m.Metadata)) + for k := range m.Metadata { + keysForMetadata = append(keysForMetadata, string(k)) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForMetadata) + for iNdEx := len(keysForMetadata) - 1; iNdEx >= 0; iNdEx-- { + v := m.Metadata[string(keysForMetadata[iNdEx])] + baseI := i + i -= len(v) + copy(dAtA[i:], v) + i = encodeVarintGenerated(dAtA, i, uint64(len(v))) + i-- + dAtA[i] = 0x12 + i -= len(keysForMetadata[iNdEx]) + copy(dAtA[i:], keysForMetadata[iNdEx]) + i = encodeVarintGenerated(dAtA, i, uint64(len(keysForMetadata[iNdEx]))) + i-- + dAtA[i] = 0xa + i = encodeVarintGenerated(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x62 + } + } + i-- + if m.DryRun { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x58 + i = encodeVarintGenerated(dAtA, i, uint64(m.ConsecutiveError)) + i-- + dAtA[i] = 0x50 + i = encodeVarintGenerated(dAtA, i, uint64(m.Error)) + i-- + dAtA[i] = 0x48 + i = encodeVarintGenerated(dAtA, i, uint64(m.Inconclusive)) + i-- + dAtA[i] = 0x40 + i = encodeVarintGenerated(dAtA, i, uint64(m.Failed)) + i-- + dAtA[i] = 0x38 + i = encodeVarintGenerated(dAtA, i, uint64(m.Successful)) + i-- + dAtA[i] = 0x30 + i = encodeVarintGenerated(dAtA, i, uint64(m.Count)) + i-- + dAtA[i] = 0x28 + i -= len(m.Message) + copy(dAtA[i:], m.Message) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message))) + i-- + dAtA[i] = 0x22 + if len(m.Measurements) > 0 { + for iNdEx := len(m.Measurements) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Measurements[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + } + i -= len(m.Phase) + copy(dAtA[i:], m.Phase) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Phase))) + i-- + dAtA[i] = 0x12 + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *NewRelicMetric) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *NewRelicMetric) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *NewRelicMetric) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.Query) + copy(dAtA[i:], m.Query) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Query))) + i-- + dAtA[i] = 0x12 + i -= len(m.Profile) + copy(dAtA[i:], m.Profile) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Profile))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *NginxTrafficRouting) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *NginxTrafficRouting) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *NginxTrafficRouting) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.StableIngresses) > 0 { + for iNdEx := len(m.StableIngresses) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.StableIngresses[iNdEx]) + copy(dAtA[i:], m.StableIngresses[iNdEx]) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.StableIngresses[iNdEx]))) + i-- + dAtA[i] = 0x22 + } + } + if len(m.AdditionalIngressAnnotations) > 0 { + keysForAdditionalIngressAnnotations := make([]string, 0, len(m.AdditionalIngressAnnotations)) + for k := range m.AdditionalIngressAnnotations { + keysForAdditionalIngressAnnotations = append(keysForAdditionalIngressAnnotations, string(k)) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForAdditionalIngressAnnotations) + for iNdEx := len(keysForAdditionalIngressAnnotations) - 1; iNdEx >= 0; iNdEx-- { + v := m.AdditionalIngressAnnotations[string(keysForAdditionalIngressAnnotations[iNdEx])] + baseI := i + i -= len(v) + copy(dAtA[i:], v) + i = encodeVarintGenerated(dAtA, i, uint64(len(v))) + i-- + dAtA[i] = 0x12 + i -= len(keysForAdditionalIngressAnnotations[iNdEx]) + copy(dAtA[i:], keysForAdditionalIngressAnnotations[iNdEx]) + i = encodeVarintGenerated(dAtA, i, uint64(len(keysForAdditionalIngressAnnotations[iNdEx]))) + i-- + dAtA[i] = 0xa + i = encodeVarintGenerated(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x1a + } + } + i -= len(m.StableIngress) + copy(dAtA[i:], m.StableIngress) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.StableIngress))) + i-- + dAtA[i] = 0x12 + i -= len(m.AnnotationPrefix) + copy(dAtA[i:], m.AnnotationPrefix) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.AnnotationPrefix))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *ObjectRef) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ObjectRef) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ObjectRef) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0x1a + i -= len(m.Kind) + copy(dAtA[i:], m.Kind) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind))) + i-- + dAtA[i] = 0x12 + i -= len(m.APIVersion) + copy(dAtA[i:], m.APIVersion) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.APIVersion))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *PauseCondition) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *PauseCondition) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PauseCondition) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.StartTime.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + i -= len(m.Reason) + copy(dAtA[i:], m.Reason) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *PingPongSpec) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *PingPongSpec) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PingPongSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.PongService) + copy(dAtA[i:], m.PongService) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.PongService))) + i-- + dAtA[i] = 0x12 + i -= len(m.PingService) + copy(dAtA[i:], m.PingService) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.PingService))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *PodTemplateMetadata) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *PodTemplateMetadata) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PodTemplateMetadata) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Annotations) > 0 { + keysForAnnotations := make([]string, 0, len(m.Annotations)) + for k := range m.Annotations { + keysForAnnotations = append(keysForAnnotations, string(k)) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForAnnotations) + for iNdEx := len(keysForAnnotations) - 1; iNdEx >= 0; iNdEx-- { + v := m.Annotations[string(keysForAnnotations[iNdEx])] + baseI := i + i -= len(v) + copy(dAtA[i:], v) + i = encodeVarintGenerated(dAtA, i, uint64(len(v))) + i-- + dAtA[i] = 0x12 + i -= len(keysForAnnotations[iNdEx]) + copy(dAtA[i:], keysForAnnotations[iNdEx]) + i = encodeVarintGenerated(dAtA, i, uint64(len(keysForAnnotations[iNdEx]))) + i-- + dAtA[i] = 0xa + i = encodeVarintGenerated(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x12 + } + } + if len(m.Labels) > 0 { + keysForLabels := make([]string, 0, len(m.Labels)) + for k := range m.Labels { + keysForLabels = append(keysForLabels, string(k)) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForLabels) + for iNdEx := len(keysForLabels) - 1; iNdEx >= 0; iNdEx-- { + v := m.Labels[string(keysForLabels[iNdEx])] + baseI := i + i -= len(v) + copy(dAtA[i:], v) + i = encodeVarintGenerated(dAtA, i, uint64(len(v))) + i-- + dAtA[i] = 0x12 + i -= len(keysForLabels[iNdEx]) + copy(dAtA[i:], keysForLabels[iNdEx]) + i = encodeVarintGenerated(dAtA, i, uint64(len(keysForLabels[iNdEx]))) + i-- + dAtA[i] = 0xa + i = encodeVarintGenerated(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *PreferredDuringSchedulingIgnoredDuringExecution) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *PreferredDuringSchedulingIgnoredDuringExecution) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PreferredDuringSchedulingIgnoredDuringExecution) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i = encodeVarintGenerated(dAtA, i, uint64(m.Weight)) + i-- + dAtA[i] = 0x8 + return len(dAtA) - i, nil +} + +func (m *PrometheusAuth) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *PrometheusAuth) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PrometheusAuth) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Sigv4.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + return len(dAtA) - i, nil +} + +func (m *PrometheusMetric) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *PrometheusMetric) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PrometheusMetric) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Headers) > 0 { + for iNdEx := len(m.Headers) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Headers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + } + } + i-- + if m.Insecure { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x28 + if m.Timeout != nil { + i = encodeVarintGenerated(dAtA, i, uint64(*m.Timeout)) + i-- + dAtA[i] = 0x20 + } + { + size, err := m.Authentication.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + i -= len(m.Query) + copy(dAtA[i:], m.Query) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Query))) + i-- + dAtA[i] = 0x12 + i -= len(m.Address) + copy(dAtA[i:], m.Address) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Address))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *RequiredDuringSchedulingIgnoredDuringExecution) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RequiredDuringSchedulingIgnoredDuringExecution) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RequiredDuringSchedulingIgnoredDuringExecution) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *RollbackWindowSpec) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RollbackWindowSpec) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RollbackWindowSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i = encodeVarintGenerated(dAtA, i, uint64(m.Revisions)) + i-- + dAtA[i] = 0x8 + return len(dAtA) - i, nil +} + +func (m *Rollout) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Rollout) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Rollout) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Status.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + { + size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + { + size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *RolloutAnalysis) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RolloutAnalysis) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RolloutAnalysis) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.AnalysisRunMetadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + if len(m.MeasurementRetention) > 0 { + for iNdEx := len(m.MeasurementRetention) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.MeasurementRetention[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + } + if len(m.DryRun) > 0 { + for iNdEx := len(m.DryRun) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.DryRun[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + } + if len(m.Args) > 0 { + for iNdEx := len(m.Args) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Args[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + if len(m.Templates) > 0 { + for iNdEx := len(m.Templates) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Templates[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *RolloutAnalysisBackground) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RolloutAnalysisBackground) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RolloutAnalysisBackground) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.StartingStep != nil { + i = encodeVarintGenerated(dAtA, i, uint64(*m.StartingStep)) + i-- + dAtA[i] = 0x10 + } + { + size, err := m.RolloutAnalysis.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *RolloutAnalysisRunStatus) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RolloutAnalysisRunStatus) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RolloutAnalysisRunStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.Message) + copy(dAtA[i:], m.Message) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message))) + i-- + dAtA[i] = 0x1a + i -= len(m.Status) + copy(dAtA[i:], m.Status) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status))) + i-- + dAtA[i] = 0x12 + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *RolloutAnalysisTemplate) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RolloutAnalysisTemplate) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RolloutAnalysisTemplate) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i-- + if m.ClusterScope { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x10 + i -= len(m.TemplateName) + copy(dAtA[i:], m.TemplateName) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.TemplateName))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *RolloutCondition) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RolloutCondition) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RolloutCondition) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.Message) + copy(dAtA[i:], m.Message) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message))) + i-- + dAtA[i] = 0x32 + i -= len(m.Reason) + copy(dAtA[i:], m.Reason) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason))) + i-- + dAtA[i] = 0x2a + { + size, err := m.LastTransitionTime.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + { + size, err := m.LastUpdateTime.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + i -= len(m.Status) + copy(dAtA[i:], m.Status) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status))) + i-- + dAtA[i] = 0x12 + i -= len(m.Type) + copy(dAtA[i:], m.Type) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *RolloutExperimentStep) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RolloutExperimentStep) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RolloutExperimentStep) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Analyses) > 0 { + for iNdEx := len(m.Analyses) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Analyses[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + } + i -= len(m.Duration) + copy(dAtA[i:], m.Duration) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Duration))) + i-- + dAtA[i] = 0x12 + if len(m.Templates) > 0 { + for iNdEx := len(m.Templates) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Templates[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *RolloutExperimentStepAnalysisTemplateRef) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RolloutExperimentStepAnalysisTemplateRef) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RolloutExperimentStepAnalysisTemplateRef) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i-- + if m.RequiredForCompletion { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x28 + if len(m.Args) > 0 { + for iNdEx := len(m.Args) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Args[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + } + i-- + if m.ClusterScope { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x18 + i -= len(m.TemplateName) + copy(dAtA[i:], m.TemplateName) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.TemplateName))) + i-- + dAtA[i] = 0x12 + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *RolloutExperimentTemplate) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RolloutExperimentTemplate) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RolloutExperimentTemplate) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Service != nil { + { + size, err := m.Service.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x3a + } + if m.Weight != nil { + i = encodeVarintGenerated(dAtA, i, uint64(*m.Weight)) + i-- + dAtA[i] = 0x30 + } + if m.Selector != nil { + { + size, err := m.Selector.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + { + size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + if m.Replicas != nil { + i = encodeVarintGenerated(dAtA, i, uint64(*m.Replicas)) + i-- + dAtA[i] = 0x18 + } + i -= len(m.SpecRef) + copy(dAtA[i:], m.SpecRef) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.SpecRef))) + i-- + dAtA[i] = 0x12 + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *RolloutList) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RolloutList) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RolloutList) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Items) > 0 { + for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + { + size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *RolloutPause) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RolloutPause) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RolloutPause) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Duration != nil { + { + size, err := m.Duration.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *RolloutSpec) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RolloutSpec) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RolloutSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.RollbackWindow != nil { + { + size, err := m.RollbackWindow.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x6a + } + i-- + if m.ProgressDeadlineAbort { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x60 + if m.Analysis != nil { + { + size, err := m.Analysis.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x5a + } + if m.WorkloadRef != nil { + { + size, err := m.WorkloadRef.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x52 + } + if m.RestartAt != nil { + { + size, err := m.RestartAt.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x4a + } + if m.ProgressDeadlineSeconds != nil { + i = encodeVarintGenerated(dAtA, i, uint64(*m.ProgressDeadlineSeconds)) + i-- + dAtA[i] = 0x40 + } + i-- + if m.Paused { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x38 + if m.RevisionHistoryLimit != nil { + i = encodeVarintGenerated(dAtA, i, uint64(*m.RevisionHistoryLimit)) + i-- + dAtA[i] = 0x30 + } + { + size, err := m.Strategy.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + i = encodeVarintGenerated(dAtA, i, uint64(m.MinReadySeconds)) + i-- + dAtA[i] = 0x20 + { + size, err := m.Template.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + if m.Selector != nil { + { + size, err := m.Selector.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Replicas != nil { + i = encodeVarintGenerated(dAtA, i, uint64(*m.Replicas)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *RolloutStatus) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RolloutStatus) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RolloutStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.ALBs) > 0 { + for iNdEx := len(m.ALBs) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.ALBs[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xd2 + } + } + if m.ALB != nil { + { + size, err := m.ALB.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xca + } + i -= len(m.WorkloadObservedGeneration) + copy(dAtA[i:], m.WorkloadObservedGeneration) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.WorkloadObservedGeneration))) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xc2 + i -= len(m.Message) + copy(dAtA[i:], m.Message) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message))) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xba + i -= len(m.Phase) + copy(dAtA[i:], m.Phase) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Phase))) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xb2 + i-- + if m.PromoteFull { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xa8 + if m.RestartedAt != nil { + { + size, err := m.RestartedAt.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xa2 + } + i -= len(m.StableRS) + copy(dAtA[i:], m.StableRS) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.StableRS))) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x9a + i -= len(m.Selector) + copy(dAtA[i:], m.Selector) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Selector))) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x92 + i = encodeVarintGenerated(dAtA, i, uint64(m.HPAReplicas)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x88 + { + size, err := m.BlueGreen.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x82 + { + size, err := m.Canary.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x7a + if len(m.Conditions) > 0 { + for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Conditions[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x72 + } + } + i -= len(m.ObservedGeneration) + copy(dAtA[i:], m.ObservedGeneration) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.ObservedGeneration))) + i-- + dAtA[i] = 0x6a + if m.CollisionCount != nil { + i = encodeVarintGenerated(dAtA, i, uint64(*m.CollisionCount)) + i-- + dAtA[i] = 0x60 + } + if m.CurrentStepIndex != nil { + i = encodeVarintGenerated(dAtA, i, uint64(*m.CurrentStepIndex)) + i-- + dAtA[i] = 0x58 + } + i = encodeVarintGenerated(dAtA, i, uint64(m.AvailableReplicas)) + i-- + dAtA[i] = 0x50 + i = encodeVarintGenerated(dAtA, i, uint64(m.ReadyReplicas)) + i-- + dAtA[i] = 0x48 + i = encodeVarintGenerated(dAtA, i, uint64(m.UpdatedReplicas)) + i-- + dAtA[i] = 0x40 + i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas)) + i-- + dAtA[i] = 0x38 + i -= len(m.CurrentStepHash) + copy(dAtA[i:], m.CurrentStepHash) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.CurrentStepHash))) + i-- + dAtA[i] = 0x32 + i -= len(m.CurrentPodHash) + copy(dAtA[i:], m.CurrentPodHash) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.CurrentPodHash))) + i-- + dAtA[i] = 0x2a + if m.AbortedAt != nil { + { + size, err := m.AbortedAt.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + i-- + if m.ControllerPause { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x18 + if len(m.PauseConditions) > 0 { + for iNdEx := len(m.PauseConditions) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.PauseConditions[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + i-- + if m.Abort { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x8 + return len(dAtA) - i, nil +} + +func (m *RolloutStrategy) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RolloutStrategy) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RolloutStrategy) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Canary != nil { + { + size, err := m.Canary.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.BlueGreen != nil { + { + size, err := m.BlueGreen.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *RolloutTrafficRouting) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RolloutTrafficRouting) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RolloutTrafficRouting) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Plugins) > 0 { + keysForPlugins := make([]string, 0, len(m.Plugins)) + for k := range m.Plugins { + keysForPlugins = append(keysForPlugins, string(k)) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForPlugins) + for iNdEx := len(keysForPlugins) - 1; iNdEx >= 0; iNdEx-- { + v := m.Plugins[string(keysForPlugins[iNdEx])] + baseI := i + if v != nil { + i -= len(v) + copy(dAtA[i:], v) + i = encodeVarintGenerated(dAtA, i, uint64(len(v))) + i-- + dAtA[i] = 0x12 + } + i -= len(keysForPlugins[iNdEx]) + copy(dAtA[i:], keysForPlugins[iNdEx]) + i = encodeVarintGenerated(dAtA, i, uint64(len(keysForPlugins[iNdEx]))) + i-- + dAtA[i] = 0xa + i = encodeVarintGenerated(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x52 + } + } + if m.Apisix != nil { + { + size, err := m.Apisix.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x4a + } + if len(m.ManagedRoutes) > 0 { + for iNdEx := len(m.ManagedRoutes) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.ManagedRoutes[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x42 + } + } + if m.Traefik != nil { + { + size, err := m.Traefik.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x3a + } + if m.AppMesh != nil { + { + size, err := m.AppMesh.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + } + if m.Ambassador != nil { + { + size, err := m.Ambassador.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + if m.SMI != nil { + { + size, err := m.SMI.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + if m.ALB != nil { + { + size, err := m.ALB.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.Nginx != nil { + { + size, err := m.Nginx.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Istio != nil { + { + size, err := m.Istio.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *RouteMatch) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RouteMatch) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RouteMatch) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Headers) > 0 { + keysForHeaders := make([]string, 0, len(m.Headers)) + for k := range m.Headers { + keysForHeaders = append(keysForHeaders, string(k)) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForHeaders) + for iNdEx := len(keysForHeaders) - 1; iNdEx >= 0; iNdEx-- { + v := m.Headers[string(keysForHeaders[iNdEx])] + baseI := i + { + size, err := (&v).MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + i -= len(keysForHeaders[iNdEx]) + copy(dAtA[i:], keysForHeaders[iNdEx]) + i = encodeVarintGenerated(dAtA, i, uint64(len(keysForHeaders[iNdEx]))) + i-- + dAtA[i] = 0xa + i = encodeVarintGenerated(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x1a + } + } + if m.Path != nil { + { + size, err := m.Path.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Method != nil { + { + size, err := m.Method.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *RunSummary) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RunSummary) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RunSummary) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i = encodeVarintGenerated(dAtA, i, uint64(m.Error)) + i-- + dAtA[i] = 0x28 + i = encodeVarintGenerated(dAtA, i, uint64(m.Inconclusive)) + i-- + dAtA[i] = 0x20 + i = encodeVarintGenerated(dAtA, i, uint64(m.Failed)) + i-- + dAtA[i] = 0x18 + i = encodeVarintGenerated(dAtA, i, uint64(m.Successful)) + i-- + dAtA[i] = 0x10 + i = encodeVarintGenerated(dAtA, i, uint64(m.Count)) + i-- + dAtA[i] = 0x8 + return len(dAtA) - i, nil +} + +func (m *SMITrafficRouting) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SMITrafficRouting) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SMITrafficRouting) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.TrafficSplitName) + copy(dAtA[i:], m.TrafficSplitName) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.TrafficSplitName))) + i-- + dAtA[i] = 0x12 + i -= len(m.RootService) + copy(dAtA[i:], m.RootService) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.RootService))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *ScopeDetail) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ScopeDetail) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ScopeDetail) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.End) + copy(dAtA[i:], m.End) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.End))) + i-- + dAtA[i] = 0x2a + i -= len(m.Start) + copy(dAtA[i:], m.Start) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Start))) + i-- + dAtA[i] = 0x22 + i = encodeVarintGenerated(dAtA, i, uint64(m.Step)) + i-- + dAtA[i] = 0x18 + i -= len(m.Region) + copy(dAtA[i:], m.Region) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Region))) + i-- + dAtA[i] = 0x12 + i -= len(m.Scope) + copy(dAtA[i:], m.Scope) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Scope))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *SecretKeyRef) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SecretKeyRef) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SecretKeyRef) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.Key) + copy(dAtA[i:], m.Key) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Key))) + i-- + dAtA[i] = 0x12 + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *SetCanaryScale) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SetCanaryScale) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SetCanaryScale) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i-- + if m.MatchTrafficWeight { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x18 + if m.Replicas != nil { + i = encodeVarintGenerated(dAtA, i, uint64(*m.Replicas)) + i-- + dAtA[i] = 0x10 + } + if m.Weight != nil { + i = encodeVarintGenerated(dAtA, i, uint64(*m.Weight)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *SetHeaderRoute) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SetHeaderRoute) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SetHeaderRoute) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Match) > 0 { + for iNdEx := len(m.Match) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Match[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *SetMirrorRoute) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SetMirrorRoute) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SetMirrorRoute) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Percentage != nil { + i = encodeVarintGenerated(dAtA, i, uint64(*m.Percentage)) + i-- + dAtA[i] = 0x20 + } + if len(m.Match) > 0 { + for iNdEx := len(m.Match) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Match[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *Sigv4Config) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Sigv4Config) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Sigv4Config) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.RoleARN) + copy(dAtA[i:], m.RoleARN) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.RoleARN))) + i-- + dAtA[i] = 0x1a + i -= len(m.Profile) + copy(dAtA[i:], m.Profile) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Profile))) + i-- + dAtA[i] = 0x12 + i -= len(m.Region) + copy(dAtA[i:], m.Region) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Region))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *SkyWalkingMetric) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SkyWalkingMetric) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SkyWalkingMetric) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.Interval) + copy(dAtA[i:], m.Interval) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Interval))) + i-- + dAtA[i] = 0x1a + i -= len(m.Query) + copy(dAtA[i:], m.Query) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Query))) + i-- + dAtA[i] = 0x12 + i -= len(m.Address) + copy(dAtA[i:], m.Address) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Address))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *StickinessConfig) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *StickinessConfig) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *StickinessConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i = encodeVarintGenerated(dAtA, i, uint64(m.DurationSeconds)) + i-- + dAtA[i] = 0x10 + i-- + if m.Enabled { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x8 + return len(dAtA) - i, nil +} + +func (m *StringMatch) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *StringMatch) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *StringMatch) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.Regex) + copy(dAtA[i:], m.Regex) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Regex))) + i-- + dAtA[i] = 0x1a + i -= len(m.Prefix) + copy(dAtA[i:], m.Prefix) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Prefix))) + i-- + dAtA[i] = 0x12 + i -= len(m.Exact) + copy(dAtA[i:], m.Exact) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Exact))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *TCPRoute) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *TCPRoute) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *TCPRoute) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i = encodeVarintGenerated(dAtA, i, uint64(m.Port)) + i-- + dAtA[i] = 0x8 + return len(dAtA) - i, nil +} + +func (m *TLSRoute) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *TLSRoute) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *TLSRoute) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.SNIHosts) > 0 { + for iNdEx := len(m.SNIHosts) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.SNIHosts[iNdEx]) + copy(dAtA[i:], m.SNIHosts[iNdEx]) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.SNIHosts[iNdEx]))) + i-- + dAtA[i] = 0x12 + } + } + i = encodeVarintGenerated(dAtA, i, uint64(m.Port)) + i-- + dAtA[i] = 0x8 + return len(dAtA) - i, nil +} + +func (m *TemplateService) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *TemplateService) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *TemplateService) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *TemplateSpec) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *TemplateSpec) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *TemplateSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Service != nil { + { + size, err := m.Service.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + } + { + size, err := m.Template.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + if m.Selector != nil { + { + size, err := m.Selector.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + i = encodeVarintGenerated(dAtA, i, uint64(m.MinReadySeconds)) + i-- + dAtA[i] = 0x18 + if m.Replicas != nil { + i = encodeVarintGenerated(dAtA, i, uint64(*m.Replicas)) + i-- + dAtA[i] = 0x10 + } + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *TemplateStatus) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *TemplateStatus) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *TemplateStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.PodTemplateHash) + copy(dAtA[i:], m.PodTemplateHash) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.PodTemplateHash))) + i-- + dAtA[i] = 0x5a + i -= len(m.ServiceName) + copy(dAtA[i:], m.ServiceName) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.ServiceName))) + i-- + dAtA[i] = 0x52 + if m.LastTransitionTime != nil { + { + size, err := m.LastTransitionTime.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x4a + } + i -= len(m.Message) + copy(dAtA[i:], m.Message) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message))) + i-- + dAtA[i] = 0x42 + i -= len(m.Status) + copy(dAtA[i:], m.Status) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status))) + i-- + dAtA[i] = 0x3a + if m.CollisionCount != nil { + i = encodeVarintGenerated(dAtA, i, uint64(*m.CollisionCount)) + i-- + dAtA[i] = 0x30 + } + i = encodeVarintGenerated(dAtA, i, uint64(m.AvailableReplicas)) + i-- + dAtA[i] = 0x28 + i = encodeVarintGenerated(dAtA, i, uint64(m.ReadyReplicas)) + i-- + dAtA[i] = 0x20 + i = encodeVarintGenerated(dAtA, i, uint64(m.UpdatedReplicas)) + i-- + dAtA[i] = 0x18 + i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas)) + i-- + dAtA[i] = 0x10 + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *TraefikTrafficRouting) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *TraefikTrafficRouting) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *TraefikTrafficRouting) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.WeightedTraefikServiceName) + copy(dAtA[i:], m.WeightedTraefikServiceName) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.WeightedTraefikServiceName))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *TrafficWeights) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *TrafficWeights) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *TrafficWeights) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Verified != nil { + i-- + if *m.Verified { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x20 + } + if len(m.Additional) > 0 { + for iNdEx := len(m.Additional) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Additional[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + } + { + size, err := m.Stable.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + { + size, err := m.Canary.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *ValueFrom) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ValueFrom) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ValueFrom) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.FieldRef != nil { + { + size, err := m.FieldRef.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.SecretKeyRef != nil { + { + size, err := m.SecretKeyRef.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *WavefrontMetric) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *WavefrontMetric) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *WavefrontMetric) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.Query) + copy(dAtA[i:], m.Query) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Query))) + i-- + dAtA[i] = 0x12 + i -= len(m.Address) + copy(dAtA[i:], m.Address) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Address))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *WebMetric) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *WebMetric) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *WebMetric) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.JSONBody != nil { + i -= len(m.JSONBody) + copy(dAtA[i:], m.JSONBody) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.JSONBody))) + i-- + dAtA[i] = 0x42 + } + i-- + if m.Insecure { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x38 + i -= len(m.JSONPath) + copy(dAtA[i:], m.JSONPath) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.JSONPath))) + i-- + dAtA[i] = 0x32 + i = encodeVarintGenerated(dAtA, i, uint64(m.TimeoutSeconds)) + i-- + dAtA[i] = 0x28 + i -= len(m.Body) + copy(dAtA[i:], m.Body) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Body))) + i-- + dAtA[i] = 0x22 + if len(m.Headers) > 0 { + for iNdEx := len(m.Headers) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Headers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + } + i -= len(m.URL) + copy(dAtA[i:], m.URL) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.URL))) + i-- + dAtA[i] = 0x12 + i -= len(m.Method) + copy(dAtA[i:], m.Method) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Method))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *WebMetricHeader) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *WebMetricHeader) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *WebMetricHeader) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.Value) + copy(dAtA[i:], m.Value) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Value))) + i-- + dAtA[i] = 0x12 + i -= len(m.Key) + copy(dAtA[i:], m.Key) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Key))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *WeightDestination) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *WeightDestination) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *WeightDestination) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.PodTemplateHash) + copy(dAtA[i:], m.PodTemplateHash) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.PodTemplateHash))) + i-- + dAtA[i] = 0x1a + i -= len(m.ServiceName) + copy(dAtA[i:], m.ServiceName) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.ServiceName))) + i-- + dAtA[i] = 0x12 + i = encodeVarintGenerated(dAtA, i, uint64(m.Weight)) + i-- + dAtA[i] = 0x8 + return len(dAtA) - i, nil +} + +func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int { + offset -= sovGenerated(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *ALBStatus) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.LoadBalancer.Size() + n += 1 + l + sovGenerated(uint64(l)) + l = m.CanaryTargetGroup.Size() + n += 1 + l + sovGenerated(uint64(l)) + l = m.StableTargetGroup.Size() + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Ingress) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *ALBTrafficRouting) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Ingress) + n += 1 + l + sovGenerated(uint64(l)) + n += 1 + sovGenerated(uint64(m.ServicePort)) + l = len(m.RootService) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.AnnotationPrefix) + n += 1 + l + sovGenerated(uint64(l)) + if m.StickinessConfig != nil { + l = m.StickinessConfig.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if len(m.Ingresses) > 0 { + for _, s := range m.Ingresses { + l = len(s) + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + +func (m *AmbassadorTrafficRouting) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Mappings) > 0 { + for _, s := range m.Mappings { + l = len(s) + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + +func (m *AnalysisRun) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.ObjectMeta.Size() + n += 1 + l + sovGenerated(uint64(l)) + l = m.Spec.Size() + n += 1 + l + sovGenerated(uint64(l)) + l = m.Status.Size() + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *AnalysisRunArgument) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Value) + n += 1 + l + sovGenerated(uint64(l)) + if m.ValueFrom != nil { + l = m.ValueFrom.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + return n +} + +func (m *AnalysisRunList) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.ListMeta.Size() + n += 1 + l + sovGenerated(uint64(l)) + if len(m.Items) > 0 { + for _, e := range m.Items { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + +func (m *AnalysisRunMetadata) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Labels) > 0 { + for k, v := range m.Labels { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v))) + n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize)) + } + } + if len(m.Annotations) > 0 { + for k, v := range m.Annotations { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v))) + n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize)) + } + } + return n +} + +func (m *AnalysisRunSpec) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Metrics) > 0 { + for _, e := range m.Metrics { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + if len(m.Args) > 0 { + for _, e := range m.Args { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + n += 2 + if len(m.DryRun) > 0 { + for _, e := range m.DryRun { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + if len(m.MeasurementRetention) > 0 { + for _, e := range m.MeasurementRetention { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + +func (m *AnalysisRunStatus) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Phase) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Message) + n += 1 + l + sovGenerated(uint64(l)) + if len(m.MetricResults) > 0 { + for _, e := range m.MetricResults { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + if m.StartedAt != nil { + l = m.StartedAt.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + l = m.RunSummary.Size() + n += 1 + l + sovGenerated(uint64(l)) + if m.DryRunSummary != nil { + l = m.DryRunSummary.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + return n +} + +func (m *AnalysisRunStrategy) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.SuccessfulRunHistoryLimit != nil { + n += 1 + sovGenerated(uint64(*m.SuccessfulRunHistoryLimit)) + } + if m.UnsuccessfulRunHistoryLimit != nil { + n += 1 + sovGenerated(uint64(*m.UnsuccessfulRunHistoryLimit)) + } + return n +} + +func (m *AnalysisTemplate) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.ObjectMeta.Size() + n += 1 + l + sovGenerated(uint64(l)) + l = m.Spec.Size() + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *AnalysisTemplateList) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.ListMeta.Size() + n += 1 + l + sovGenerated(uint64(l)) + if len(m.Items) > 0 { + for _, e := range m.Items { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + +func (m *AnalysisTemplateSpec) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Metrics) > 0 { + for _, e := range m.Metrics { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + if len(m.Args) > 0 { + for _, e := range m.Args { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + if len(m.DryRun) > 0 { + for _, e := range m.DryRun { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + if len(m.MeasurementRetention) > 0 { + for _, e := range m.MeasurementRetention { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + +func (m *AntiAffinity) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PreferredDuringSchedulingIgnoredDuringExecution != nil { + l = m.PreferredDuringSchedulingIgnoredDuringExecution.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.RequiredDuringSchedulingIgnoredDuringExecution != nil { + l = m.RequiredDuringSchedulingIgnoredDuringExecution.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + return n +} + +func (m *ApisixRoute) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + n += 1 + l + sovGenerated(uint64(l)) + if len(m.Rules) > 0 { + for _, s := range m.Rules { + l = len(s) + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + +func (m *ApisixTrafficRouting) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Route != nil { + l = m.Route.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + return n +} + +func (m *AppMeshTrafficRouting) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.VirtualService != nil { + l = m.VirtualService.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.VirtualNodeGroup != nil { + l = m.VirtualNodeGroup.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + return n +} + +func (m *AppMeshVirtualNodeGroup) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.CanaryVirtualNodeRef != nil { + l = m.CanaryVirtualNodeRef.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.StableVirtualNodeRef != nil { + l = m.StableVirtualNodeRef.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + return n +} + +func (m *AppMeshVirtualNodeReference) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *AppMeshVirtualService) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + n += 1 + l + sovGenerated(uint64(l)) + if len(m.Routes) > 0 { + for _, s := range m.Routes { + l = len(s) + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + +func (m *Argument) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + n += 1 + l + sovGenerated(uint64(l)) + if m.Value != nil { + l = len(*m.Value) + n += 1 + l + sovGenerated(uint64(l)) + } + if m.ValueFrom != nil { + l = m.ValueFrom.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + return n +} + +func (m *ArgumentValueFrom) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PodTemplateHashValue != nil { + l = len(*m.PodTemplateHashValue) + n += 1 + l + sovGenerated(uint64(l)) + } + if m.FieldRef != nil { + l = m.FieldRef.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + return n +} + +func (m *AwsResourceRef) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.ARN) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.FullName) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *BlueGreenStatus) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.PreviewSelector) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.ActiveSelector) + n += 1 + l + sovGenerated(uint64(l)) + n += 2 + if m.PrePromotionAnalysisRunStatus != nil { + l = m.PrePromotionAnalysisRunStatus.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.PostPromotionAnalysisRunStatus != nil { + l = m.PostPromotionAnalysisRunStatus.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + return n +} + +func (m *BlueGreenStrategy) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ActiveService) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.PreviewService) + n += 1 + l + sovGenerated(uint64(l)) + if m.PreviewReplicaCount != nil { + n += 1 + sovGenerated(uint64(*m.PreviewReplicaCount)) + } + if m.AutoPromotionEnabled != nil { + n += 2 + } + n += 1 + sovGenerated(uint64(m.AutoPromotionSeconds)) + if m.MaxUnavailable != nil { + l = m.MaxUnavailable.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.ScaleDownDelaySeconds != nil { + n += 1 + sovGenerated(uint64(*m.ScaleDownDelaySeconds)) + } + if m.ScaleDownDelayRevisionLimit != nil { + n += 1 + sovGenerated(uint64(*m.ScaleDownDelayRevisionLimit)) + } + if m.PrePromotionAnalysis != nil { + l = m.PrePromotionAnalysis.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.AntiAffinity != nil { + l = m.AntiAffinity.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.PostPromotionAnalysis != nil { + l = m.PostPromotionAnalysis.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.PreviewMetadata != nil { + l = m.PreviewMetadata.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.ActiveMetadata != nil { + l = m.ActiveMetadata.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.AbortScaleDownDelaySeconds != nil { + n += 1 + sovGenerated(uint64(*m.AbortScaleDownDelaySeconds)) + } + return n +} + +func (m *CanaryStatus) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.CurrentStepAnalysisRunStatus != nil { + l = m.CurrentStepAnalysisRunStatus.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.CurrentBackgroundAnalysisRunStatus != nil { + l = m.CurrentBackgroundAnalysisRunStatus.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + l = len(m.CurrentExperiment) + n += 1 + l + sovGenerated(uint64(l)) + if m.Weights != nil { + l = m.Weights.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + l = len(m.StablePingPong) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *CanaryStep) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.SetWeight != nil { + n += 1 + sovGenerated(uint64(*m.SetWeight)) + } + if m.Pause != nil { + l = m.Pause.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.Experiment != nil { + l = m.Experiment.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.Analysis != nil { + l = m.Analysis.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.SetCanaryScale != nil { + l = m.SetCanaryScale.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.SetHeaderRoute != nil { + l = m.SetHeaderRoute.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.SetMirrorRoute != nil { + l = m.SetMirrorRoute.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + return n +} + +func (m *CanaryStrategy) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.CanaryService) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.StableService) + n += 1 + l + sovGenerated(uint64(l)) + if len(m.Steps) > 0 { + for _, e := range m.Steps { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + if m.TrafficRouting != nil { + l = m.TrafficRouting.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.MaxUnavailable != nil { + l = m.MaxUnavailable.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.MaxSurge != nil { + l = m.MaxSurge.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.Analysis != nil { + l = m.Analysis.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.AntiAffinity != nil { + l = m.AntiAffinity.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.CanaryMetadata != nil { + l = m.CanaryMetadata.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.StableMetadata != nil { + l = m.StableMetadata.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.ScaleDownDelaySeconds != nil { + n += 1 + sovGenerated(uint64(*m.ScaleDownDelaySeconds)) + } + if m.ScaleDownDelayRevisionLimit != nil { + n += 1 + sovGenerated(uint64(*m.ScaleDownDelayRevisionLimit)) + } + if m.AbortScaleDownDelaySeconds != nil { + n += 1 + sovGenerated(uint64(*m.AbortScaleDownDelaySeconds)) + } + n += 2 + if m.PingPong != nil { + l = m.PingPong.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.MinPodsPerReplicaSet != nil { + n += 2 + sovGenerated(uint64(*m.MinPodsPerReplicaSet)) + } + return n +} + +func (m *CloudWatchMetric) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Interval) + n += 1 + l + sovGenerated(uint64(l)) + if len(m.MetricDataQueries) > 0 { + for _, e := range m.MetricDataQueries { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + +func (m *CloudWatchMetricDataQuery) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Id) + n += 1 + l + sovGenerated(uint64(l)) + if m.Expression != nil { + l = len(*m.Expression) + n += 1 + l + sovGenerated(uint64(l)) + } + if m.Label != nil { + l = len(*m.Label) + n += 1 + l + sovGenerated(uint64(l)) + } + if m.MetricStat != nil { + l = m.MetricStat.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.Period != nil { + l = m.Period.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.ReturnData != nil { + n += 2 + } + return n +} + +func (m *CloudWatchMetricStat) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Metric.Size() + n += 1 + l + sovGenerated(uint64(l)) + l = m.Period.Size() + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Stat) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Unit) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *CloudWatchMetricStatMetric) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Dimensions) > 0 { + for _, e := range m.Dimensions { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + l = len(m.MetricName) + n += 1 + l + sovGenerated(uint64(l)) + if m.Namespace != nil { + l = len(*m.Namespace) + n += 1 + l + sovGenerated(uint64(l)) + } + return n +} + +func (m *CloudWatchMetricStatMetricDimension) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Value) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *ClusterAnalysisTemplate) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.ObjectMeta.Size() + n += 1 + l + sovGenerated(uint64(l)) + l = m.Spec.Size() + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *ClusterAnalysisTemplateList) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.ListMeta.Size() + n += 1 + l + sovGenerated(uint64(l)) + if len(m.Items) > 0 { + for _, e := range m.Items { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + +func (m *DatadogMetric) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Interval) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Query) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.ApiVersion) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *DryRun) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.MetricName) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *Experiment) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.ObjectMeta.Size() + n += 1 + l + sovGenerated(uint64(l)) + l = m.Spec.Size() + n += 1 + l + sovGenerated(uint64(l)) + l = m.Status.Size() + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *ExperimentAnalysisRunStatus) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.AnalysisRun) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Phase) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Message) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *ExperimentAnalysisTemplateRef) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.TemplateName) + n += 1 + l + sovGenerated(uint64(l)) + n += 2 + if len(m.Args) > 0 { + for _, e := range m.Args { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + n += 2 + return n +} + +func (m *ExperimentCondition) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Type) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Status) + n += 1 + l + sovGenerated(uint64(l)) + l = m.LastUpdateTime.Size() + n += 1 + l + sovGenerated(uint64(l)) + l = m.LastTransitionTime.Size() + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Reason) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Message) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *ExperimentList) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.ListMeta.Size() + n += 1 + l + sovGenerated(uint64(l)) + if len(m.Items) > 0 { + for _, e := range m.Items { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + +func (m *ExperimentSpec) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Templates) > 0 { + for _, e := range m.Templates { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + l = len(m.Duration) + n += 1 + l + sovGenerated(uint64(l)) + if m.ProgressDeadlineSeconds != nil { + n += 1 + sovGenerated(uint64(*m.ProgressDeadlineSeconds)) + } + n += 2 + if len(m.Analyses) > 0 { + for _, e := range m.Analyses { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + if m.ScaleDownDelaySeconds != nil { + n += 1 + sovGenerated(uint64(*m.ScaleDownDelaySeconds)) + } + if len(m.DryRun) > 0 { + for _, e := range m.DryRun { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + if len(m.MeasurementRetention) > 0 { + for _, e := range m.MeasurementRetention { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + +func (m *ExperimentStatus) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Phase) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Message) + n += 1 + l + sovGenerated(uint64(l)) + if len(m.TemplateStatuses) > 0 { + for _, e := range m.TemplateStatuses { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + if m.AvailableAt != nil { + l = m.AvailableAt.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if len(m.Conditions) > 0 { + for _, e := range m.Conditions { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + if len(m.AnalysisRuns) > 0 { + for _, e := range m.AnalysisRuns { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + +func (m *FieldRef) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.FieldPath) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *GraphiteMetric) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Address) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Query) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *HeaderRoutingMatch) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.HeaderName) + n += 1 + l + sovGenerated(uint64(l)) + if m.HeaderValue != nil { + l = m.HeaderValue.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + return n +} + +func (m *InfluxdbMetric) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Profile) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Query) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *IstioDestinationRule) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.CanarySubsetName) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.StableSubsetName) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *IstioTrafficRouting) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.VirtualService != nil { + l = m.VirtualService.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.DestinationRule != nil { + l = m.DestinationRule.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if len(m.VirtualServices) > 0 { + for _, e := range m.VirtualServices { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + +func (m *IstioVirtualService) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + n += 1 + l + sovGenerated(uint64(l)) + if len(m.Routes) > 0 { + for _, s := range m.Routes { + l = len(s) + n += 1 + l + sovGenerated(uint64(l)) + } + } + if len(m.TLSRoutes) > 0 { + for _, e := range m.TLSRoutes { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + if len(m.TCPRoutes) > 0 { + for _, e := range m.TCPRoutes { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + +func (m *JobMetric) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Metadata.Size() + n += 1 + l + sovGenerated(uint64(l)) + l = m.Spec.Size() + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *KayentaMetric) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Address) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Application) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.CanaryConfigName) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.MetricsAccountName) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.ConfigurationAccountName) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.StorageAccountName) + n += 1 + l + sovGenerated(uint64(l)) + l = m.Threshold.Size() + n += 1 + l + sovGenerated(uint64(l)) + if len(m.Scopes) > 0 { + for _, e := range m.Scopes { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + +func (m *KayentaScope) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + n += 1 + l + sovGenerated(uint64(l)) + l = m.ControlScope.Size() + n += 1 + l + sovGenerated(uint64(l)) + l = m.ExperimentScope.Size() + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *KayentaThreshold) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + n += 1 + sovGenerated(uint64(m.Pass)) + n += 1 + sovGenerated(uint64(m.Marginal)) + return n +} + +func (m *MangedRoutes) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *Measurement) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Phase) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Message) + n += 1 + l + sovGenerated(uint64(l)) + if m.StartedAt != nil { + l = m.StartedAt.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.FinishedAt != nil { + l = m.FinishedAt.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + l = len(m.Value) + n += 1 + l + sovGenerated(uint64(l)) + if len(m.Metadata) > 0 { + for k, v := range m.Metadata { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v))) + n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize)) + } + } + if m.ResumeAt != nil { + l = m.ResumeAt.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + return n +} + +func (m *MeasurementRetention) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.MetricName) + n += 1 + l + sovGenerated(uint64(l)) + n += 1 + sovGenerated(uint64(m.Limit)) + return n +} + +func (m *Metric) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Interval) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.InitialDelay) + n += 1 + l + sovGenerated(uint64(l)) + if m.Count != nil { + l = m.Count.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + l = len(m.SuccessCondition) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.FailureCondition) + n += 1 + l + sovGenerated(uint64(l)) + if m.FailureLimit != nil { + l = m.FailureLimit.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.InconclusiveLimit != nil { + l = m.InconclusiveLimit.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.ConsecutiveErrorLimit != nil { + l = m.ConsecutiveErrorLimit.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + l = m.Provider.Size() + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *MetricProvider) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Prometheus != nil { + l = m.Prometheus.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.Kayenta != nil { + l = m.Kayenta.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.Web != nil { + l = m.Web.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.Datadog != nil { + l = m.Datadog.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.Wavefront != nil { + l = m.Wavefront.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.NewRelic != nil { + l = m.NewRelic.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.Job != nil { + l = m.Job.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.CloudWatch != nil { + l = m.CloudWatch.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.Graphite != nil { + l = m.Graphite.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.Influxdb != nil { + l = m.Influxdb.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.SkyWalking != nil { + l = m.SkyWalking.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if len(m.Plugin) > 0 { + for k, v := range m.Plugin { + _ = k + _ = v + l = 0 + if v != nil { + l = 1 + len(v) + sovGenerated(uint64(len(v))) + } + mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + l + n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize)) + } + } + return n +} + +func (m *MetricResult) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Phase) + n += 1 + l + sovGenerated(uint64(l)) + if len(m.Measurements) > 0 { + for _, e := range m.Measurements { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + l = len(m.Message) + n += 1 + l + sovGenerated(uint64(l)) + n += 1 + sovGenerated(uint64(m.Count)) + n += 1 + sovGenerated(uint64(m.Successful)) + n += 1 + sovGenerated(uint64(m.Failed)) + n += 1 + sovGenerated(uint64(m.Inconclusive)) + n += 1 + sovGenerated(uint64(m.Error)) + n += 1 + sovGenerated(uint64(m.ConsecutiveError)) + n += 2 + if len(m.Metadata) > 0 { + for k, v := range m.Metadata { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v))) + n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize)) + } + } + return n +} + +func (m *NewRelicMetric) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Profile) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Query) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *NginxTrafficRouting) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.AnnotationPrefix) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.StableIngress) + n += 1 + l + sovGenerated(uint64(l)) + if len(m.AdditionalIngressAnnotations) > 0 { + for k, v := range m.AdditionalIngressAnnotations { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v))) + n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize)) + } + } + if len(m.StableIngresses) > 0 { + for _, s := range m.StableIngresses { + l = len(s) + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + +func (m *ObjectRef) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.APIVersion) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Kind) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Name) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *PauseCondition) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Reason) + n += 1 + l + sovGenerated(uint64(l)) + l = m.StartTime.Size() + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *PingPongSpec) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.PingService) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.PongService) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *PodTemplateMetadata) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Labels) > 0 { + for k, v := range m.Labels { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v))) + n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize)) + } + } + if len(m.Annotations) > 0 { + for k, v := range m.Annotations { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v))) + n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize)) + } + } + return n +} + +func (m *PreferredDuringSchedulingIgnoredDuringExecution) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + n += 1 + sovGenerated(uint64(m.Weight)) + return n +} + +func (m *PrometheusAuth) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Sigv4.Size() + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *PrometheusMetric) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Address) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Query) + n += 1 + l + sovGenerated(uint64(l)) + l = m.Authentication.Size() + n += 1 + l + sovGenerated(uint64(l)) + if m.Timeout != nil { + n += 1 + sovGenerated(uint64(*m.Timeout)) + } + n += 2 + if len(m.Headers) > 0 { + for _, e := range m.Headers { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + +func (m *RequiredDuringSchedulingIgnoredDuringExecution) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *RollbackWindowSpec) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + n += 1 + sovGenerated(uint64(m.Revisions)) + return n +} + +func (m *Rollout) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.ObjectMeta.Size() + n += 1 + l + sovGenerated(uint64(l)) + l = m.Spec.Size() + n += 1 + l + sovGenerated(uint64(l)) + l = m.Status.Size() + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *RolloutAnalysis) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Templates) > 0 { + for _, e := range m.Templates { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + if len(m.Args) > 0 { + for _, e := range m.Args { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + if len(m.DryRun) > 0 { + for _, e := range m.DryRun { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + if len(m.MeasurementRetention) > 0 { + for _, e := range m.MeasurementRetention { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + l = m.AnalysisRunMetadata.Size() + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *RolloutAnalysisBackground) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.RolloutAnalysis.Size() + n += 1 + l + sovGenerated(uint64(l)) + if m.StartingStep != nil { + n += 1 + sovGenerated(uint64(*m.StartingStep)) + } + return n +} + +func (m *RolloutAnalysisRunStatus) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Status) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Message) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *RolloutAnalysisTemplate) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.TemplateName) + n += 1 + l + sovGenerated(uint64(l)) + n += 2 + return n +} + +func (m *RolloutCondition) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Type) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Status) + n += 1 + l + sovGenerated(uint64(l)) + l = m.LastUpdateTime.Size() + n += 1 + l + sovGenerated(uint64(l)) + l = m.LastTransitionTime.Size() + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Reason) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Message) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *RolloutExperimentStep) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Templates) > 0 { + for _, e := range m.Templates { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + l = len(m.Duration) + n += 1 + l + sovGenerated(uint64(l)) + if len(m.Analyses) > 0 { + for _, e := range m.Analyses { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + +func (m *RolloutExperimentStepAnalysisTemplateRef) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.TemplateName) + n += 1 + l + sovGenerated(uint64(l)) + n += 2 + if len(m.Args) > 0 { + for _, e := range m.Args { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + n += 2 + return n +} + +func (m *RolloutExperimentTemplate) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.SpecRef) + n += 1 + l + sovGenerated(uint64(l)) + if m.Replicas != nil { + n += 1 + sovGenerated(uint64(*m.Replicas)) + } + l = m.Metadata.Size() + n += 1 + l + sovGenerated(uint64(l)) + if m.Selector != nil { + l = m.Selector.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.Weight != nil { + n += 1 + sovGenerated(uint64(*m.Weight)) + } + if m.Service != nil { + l = m.Service.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + return n +} + +func (m *RolloutList) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.ListMeta.Size() + n += 1 + l + sovGenerated(uint64(l)) + if len(m.Items) > 0 { + for _, e := range m.Items { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + +func (m *RolloutPause) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Duration != nil { + l = m.Duration.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + return n +} + +func (m *RolloutSpec) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Replicas != nil { + n += 1 + sovGenerated(uint64(*m.Replicas)) + } + if m.Selector != nil { + l = m.Selector.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + l = m.Template.Size() + n += 1 + l + sovGenerated(uint64(l)) + n += 1 + sovGenerated(uint64(m.MinReadySeconds)) + l = m.Strategy.Size() + n += 1 + l + sovGenerated(uint64(l)) + if m.RevisionHistoryLimit != nil { + n += 1 + sovGenerated(uint64(*m.RevisionHistoryLimit)) + } + n += 2 + if m.ProgressDeadlineSeconds != nil { + n += 1 + sovGenerated(uint64(*m.ProgressDeadlineSeconds)) + } + if m.RestartAt != nil { + l = m.RestartAt.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.WorkloadRef != nil { + l = m.WorkloadRef.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.Analysis != nil { + l = m.Analysis.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + n += 2 + if m.RollbackWindow != nil { + l = m.RollbackWindow.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + return n +} + +func (m *RolloutStatus) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + n += 2 + if len(m.PauseConditions) > 0 { + for _, e := range m.PauseConditions { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + n += 2 + if m.AbortedAt != nil { + l = m.AbortedAt.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + l = len(m.CurrentPodHash) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.CurrentStepHash) + n += 1 + l + sovGenerated(uint64(l)) + n += 1 + sovGenerated(uint64(m.Replicas)) + n += 1 + sovGenerated(uint64(m.UpdatedReplicas)) + n += 1 + sovGenerated(uint64(m.ReadyReplicas)) + n += 1 + sovGenerated(uint64(m.AvailableReplicas)) + if m.CurrentStepIndex != nil { + n += 1 + sovGenerated(uint64(*m.CurrentStepIndex)) + } + if m.CollisionCount != nil { + n += 1 + sovGenerated(uint64(*m.CollisionCount)) + } + l = len(m.ObservedGeneration) + n += 1 + l + sovGenerated(uint64(l)) + if len(m.Conditions) > 0 { + for _, e := range m.Conditions { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + l = m.Canary.Size() + n += 1 + l + sovGenerated(uint64(l)) + l = m.BlueGreen.Size() + n += 2 + l + sovGenerated(uint64(l)) + n += 2 + sovGenerated(uint64(m.HPAReplicas)) + l = len(m.Selector) + n += 2 + l + sovGenerated(uint64(l)) + l = len(m.StableRS) + n += 2 + l + sovGenerated(uint64(l)) + if m.RestartedAt != nil { + l = m.RestartedAt.Size() + n += 2 + l + sovGenerated(uint64(l)) + } + n += 3 + l = len(m.Phase) + n += 2 + l + sovGenerated(uint64(l)) + l = len(m.Message) + n += 2 + l + sovGenerated(uint64(l)) + l = len(m.WorkloadObservedGeneration) + n += 2 + l + sovGenerated(uint64(l)) + if m.ALB != nil { + l = m.ALB.Size() + n += 2 + l + sovGenerated(uint64(l)) + } + if len(m.ALBs) > 0 { + for _, e := range m.ALBs { + l = e.Size() + n += 2 + l + sovGenerated(uint64(l)) + } + } + return n +} + +func (m *RolloutStrategy) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BlueGreen != nil { + l = m.BlueGreen.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.Canary != nil { + l = m.Canary.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + return n +} + +func (m *RolloutTrafficRouting) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Istio != nil { + l = m.Istio.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.Nginx != nil { + l = m.Nginx.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.ALB != nil { + l = m.ALB.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.SMI != nil { + l = m.SMI.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.Ambassador != nil { + l = m.Ambassador.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.AppMesh != nil { + l = m.AppMesh.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.Traefik != nil { + l = m.Traefik.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if len(m.ManagedRoutes) > 0 { + for _, e := range m.ManagedRoutes { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + if m.Apisix != nil { + l = m.Apisix.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if len(m.Plugins) > 0 { + for k, v := range m.Plugins { + _ = k + _ = v + l = 0 + if v != nil { + l = 1 + len(v) + sovGenerated(uint64(len(v))) + } + mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + l + n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize)) + } + } + return n +} + +func (m *RouteMatch) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Method != nil { + l = m.Method.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.Path != nil { + l = m.Path.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if len(m.Headers) > 0 { + for k, v := range m.Headers { + _ = k + _ = v + l = v.Size() + mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l)) + n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize)) + } + } + return n +} + +func (m *RunSummary) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + n += 1 + sovGenerated(uint64(m.Count)) + n += 1 + sovGenerated(uint64(m.Successful)) + n += 1 + sovGenerated(uint64(m.Failed)) + n += 1 + sovGenerated(uint64(m.Inconclusive)) + n += 1 + sovGenerated(uint64(m.Error)) + return n +} + +func (m *SMITrafficRouting) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.RootService) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.TrafficSplitName) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *ScopeDetail) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Scope) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Region) + n += 1 + l + sovGenerated(uint64(l)) + n += 1 + sovGenerated(uint64(m.Step)) + l = len(m.Start) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.End) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *SecretKeyRef) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Key) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *SetCanaryScale) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Weight != nil { + n += 1 + sovGenerated(uint64(*m.Weight)) + } + if m.Replicas != nil { + n += 1 + sovGenerated(uint64(*m.Replicas)) + } + n += 2 + return n +} + +func (m *SetHeaderRoute) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + n += 1 + l + sovGenerated(uint64(l)) + if len(m.Match) > 0 { + for _, e := range m.Match { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + +func (m *SetMirrorRoute) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + n += 1 + l + sovGenerated(uint64(l)) + if len(m.Match) > 0 { + for _, e := range m.Match { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + if m.Percentage != nil { + n += 1 + sovGenerated(uint64(*m.Percentage)) + } + return n +} + +func (m *Sigv4Config) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Region) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Profile) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.RoleARN) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *SkyWalkingMetric) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Address) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Query) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Interval) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *StickinessConfig) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + n += 2 + n += 1 + sovGenerated(uint64(m.DurationSeconds)) + return n +} + +func (m *StringMatch) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Exact) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Prefix) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Regex) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *TCPRoute) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + n += 1 + sovGenerated(uint64(m.Port)) + return n +} + +func (m *TLSRoute) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + n += 1 + sovGenerated(uint64(m.Port)) + if len(m.SNIHosts) > 0 { + for _, s := range m.SNIHosts { + l = len(s) + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + +func (m *TemplateService) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *TemplateSpec) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + n += 1 + l + sovGenerated(uint64(l)) + if m.Replicas != nil { + n += 1 + sovGenerated(uint64(*m.Replicas)) + } + n += 1 + sovGenerated(uint64(m.MinReadySeconds)) + if m.Selector != nil { + l = m.Selector.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + l = m.Template.Size() + n += 1 + l + sovGenerated(uint64(l)) + if m.Service != nil { + l = m.Service.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + return n +} + +func (m *TemplateStatus) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + n += 1 + l + sovGenerated(uint64(l)) + n += 1 + sovGenerated(uint64(m.Replicas)) + n += 1 + sovGenerated(uint64(m.UpdatedReplicas)) + n += 1 + sovGenerated(uint64(m.ReadyReplicas)) + n += 1 + sovGenerated(uint64(m.AvailableReplicas)) + if m.CollisionCount != nil { + n += 1 + sovGenerated(uint64(*m.CollisionCount)) + } + l = len(m.Status) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Message) + n += 1 + l + sovGenerated(uint64(l)) + if m.LastTransitionTime != nil { + l = m.LastTransitionTime.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + l = len(m.ServiceName) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.PodTemplateHash) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *TraefikTrafficRouting) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.WeightedTraefikServiceName) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *TrafficWeights) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Canary.Size() + n += 1 + l + sovGenerated(uint64(l)) + l = m.Stable.Size() + n += 1 + l + sovGenerated(uint64(l)) + if len(m.Additional) > 0 { + for _, e := range m.Additional { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + if m.Verified != nil { + n += 2 + } + return n +} + +func (m *ValueFrom) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.SecretKeyRef != nil { + l = m.SecretKeyRef.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.FieldRef != nil { + l = m.FieldRef.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + return n +} + +func (m *WavefrontMetric) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Address) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Query) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *WebMetric) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Method) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.URL) + n += 1 + l + sovGenerated(uint64(l)) + if len(m.Headers) > 0 { + for _, e := range m.Headers { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + l = len(m.Body) + n += 1 + l + sovGenerated(uint64(l)) + n += 1 + sovGenerated(uint64(m.TimeoutSeconds)) + l = len(m.JSONPath) + n += 1 + l + sovGenerated(uint64(l)) + n += 2 + if m.JSONBody != nil { + l = len(m.JSONBody) + n += 1 + l + sovGenerated(uint64(l)) + } + return n +} + +func (m *WebMetricHeader) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Key) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Value) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *WeightDestination) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + n += 1 + sovGenerated(uint64(m.Weight)) + l = len(m.ServiceName) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.PodTemplateHash) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func sovGenerated(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozGenerated(x uint64) (n int) { + return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *ALBStatus) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ALBStatus{`, + `LoadBalancer:` + strings.Replace(strings.Replace(this.LoadBalancer.String(), "AwsResourceRef", "AwsResourceRef", 1), `&`, ``, 1) + `,`, + `CanaryTargetGroup:` + strings.Replace(strings.Replace(this.CanaryTargetGroup.String(), "AwsResourceRef", "AwsResourceRef", 1), `&`, ``, 1) + `,`, + `StableTargetGroup:` + strings.Replace(strings.Replace(this.StableTargetGroup.String(), "AwsResourceRef", "AwsResourceRef", 1), `&`, ``, 1) + `,`, + `Ingress:` + fmt.Sprintf("%v", this.Ingress) + `,`, + `}`, + }, "") + return s +} +func (this *ALBTrafficRouting) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ALBTrafficRouting{`, + `Ingress:` + fmt.Sprintf("%v", this.Ingress) + `,`, + `ServicePort:` + fmt.Sprintf("%v", this.ServicePort) + `,`, + `RootService:` + fmt.Sprintf("%v", this.RootService) + `,`, + `AnnotationPrefix:` + fmt.Sprintf("%v", this.AnnotationPrefix) + `,`, + `StickinessConfig:` + strings.Replace(this.StickinessConfig.String(), "StickinessConfig", "StickinessConfig", 1) + `,`, + `Ingresses:` + fmt.Sprintf("%v", this.Ingresses) + `,`, + `}`, + }, "") + return s +} +func (this *AmbassadorTrafficRouting) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AmbassadorTrafficRouting{`, + `Mappings:` + fmt.Sprintf("%v", this.Mappings) + `,`, + `}`, + }, "") + return s +} +func (this *AnalysisRun) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AnalysisRun{`, + `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`, + `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "AnalysisRunSpec", "AnalysisRunSpec", 1), `&`, ``, 1) + `,`, + `Status:` + strings.Replace(strings.Replace(this.Status.String(), "AnalysisRunStatus", "AnalysisRunStatus", 1), `&`, ``, 1) + `,`, + `}`, + }, "") + return s +} +func (this *AnalysisRunArgument) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AnalysisRunArgument{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `Value:` + fmt.Sprintf("%v", this.Value) + `,`, + `ValueFrom:` + strings.Replace(this.ValueFrom.String(), "ArgumentValueFrom", "ArgumentValueFrom", 1) + `,`, + `}`, + }, "") + return s +} +func (this *AnalysisRunList) String() string { + if this == nil { + return "nil" + } + repeatedStringForItems := "[]AnalysisRun{" + for _, f := range this.Items { + repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "AnalysisRun", "AnalysisRun", 1), `&`, ``, 1) + "," + } + repeatedStringForItems += "}" + s := strings.Join([]string{`&AnalysisRunList{`, + `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`, + `Items:` + repeatedStringForItems + `,`, + `}`, + }, "") + return s +} +func (this *AnalysisRunMetadata) String() string { + if this == nil { + return "nil" + } + keysForLabels := make([]string, 0, len(this.Labels)) + for k := range this.Labels { + keysForLabels = append(keysForLabels, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForLabels) + mapStringForLabels := "map[string]string{" + for _, k := range keysForLabels { + mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k]) + } + mapStringForLabels += "}" + keysForAnnotations := make([]string, 0, len(this.Annotations)) + for k := range this.Annotations { + keysForAnnotations = append(keysForAnnotations, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForAnnotations) + mapStringForAnnotations := "map[string]string{" + for _, k := range keysForAnnotations { + mapStringForAnnotations += fmt.Sprintf("%v: %v,", k, this.Annotations[k]) + } + mapStringForAnnotations += "}" + s := strings.Join([]string{`&AnalysisRunMetadata{`, + `Labels:` + mapStringForLabels + `,`, + `Annotations:` + mapStringForAnnotations + `,`, + `}`, + }, "") + return s +} +func (this *AnalysisRunSpec) String() string { + if this == nil { + return "nil" + } + repeatedStringForMetrics := "[]Metric{" + for _, f := range this.Metrics { + repeatedStringForMetrics += strings.Replace(strings.Replace(f.String(), "Metric", "Metric", 1), `&`, ``, 1) + "," + } + repeatedStringForMetrics += "}" + repeatedStringForArgs := "[]Argument{" + for _, f := range this.Args { + repeatedStringForArgs += strings.Replace(strings.Replace(f.String(), "Argument", "Argument", 1), `&`, ``, 1) + "," + } + repeatedStringForArgs += "}" + repeatedStringForDryRun := "[]DryRun{" + for _, f := range this.DryRun { + repeatedStringForDryRun += strings.Replace(strings.Replace(f.String(), "DryRun", "DryRun", 1), `&`, ``, 1) + "," + } + repeatedStringForDryRun += "}" + repeatedStringForMeasurementRetention := "[]MeasurementRetention{" + for _, f := range this.MeasurementRetention { + repeatedStringForMeasurementRetention += strings.Replace(strings.Replace(f.String(), "MeasurementRetention", "MeasurementRetention", 1), `&`, ``, 1) + "," + } + repeatedStringForMeasurementRetention += "}" + s := strings.Join([]string{`&AnalysisRunSpec{`, + `Metrics:` + repeatedStringForMetrics + `,`, + `Args:` + repeatedStringForArgs + `,`, + `Terminate:` + fmt.Sprintf("%v", this.Terminate) + `,`, + `DryRun:` + repeatedStringForDryRun + `,`, + `MeasurementRetention:` + repeatedStringForMeasurementRetention + `,`, + `}`, + }, "") + return s +} +func (this *AnalysisRunStatus) String() string { + if this == nil { + return "nil" + } + repeatedStringForMetricResults := "[]MetricResult{" + for _, f := range this.MetricResults { + repeatedStringForMetricResults += strings.Replace(strings.Replace(f.String(), "MetricResult", "MetricResult", 1), `&`, ``, 1) + "," + } + repeatedStringForMetricResults += "}" + s := strings.Join([]string{`&AnalysisRunStatus{`, + `Phase:` + fmt.Sprintf("%v", this.Phase) + `,`, + `Message:` + fmt.Sprintf("%v", this.Message) + `,`, + `MetricResults:` + repeatedStringForMetricResults + `,`, + `StartedAt:` + strings.Replace(fmt.Sprintf("%v", this.StartedAt), "Time", "v1.Time", 1) + `,`, + `RunSummary:` + strings.Replace(strings.Replace(this.RunSummary.String(), "RunSummary", "RunSummary", 1), `&`, ``, 1) + `,`, + `DryRunSummary:` + strings.Replace(this.DryRunSummary.String(), "RunSummary", "RunSummary", 1) + `,`, + `}`, + }, "") + return s +} +func (this *AnalysisRunStrategy) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AnalysisRunStrategy{`, + `SuccessfulRunHistoryLimit:` + valueToStringGenerated(this.SuccessfulRunHistoryLimit) + `,`, + `UnsuccessfulRunHistoryLimit:` + valueToStringGenerated(this.UnsuccessfulRunHistoryLimit) + `,`, + `}`, + }, "") + return s +} +func (this *AnalysisTemplate) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AnalysisTemplate{`, + `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`, + `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "AnalysisTemplateSpec", "AnalysisTemplateSpec", 1), `&`, ``, 1) + `,`, + `}`, + }, "") + return s +} +func (this *AnalysisTemplateList) String() string { + if this == nil { + return "nil" + } + repeatedStringForItems := "[]AnalysisTemplate{" + for _, f := range this.Items { + repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "AnalysisTemplate", "AnalysisTemplate", 1), `&`, ``, 1) + "," + } + repeatedStringForItems += "}" + s := strings.Join([]string{`&AnalysisTemplateList{`, + `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`, + `Items:` + repeatedStringForItems + `,`, + `}`, + }, "") + return s +} +func (this *AnalysisTemplateSpec) String() string { + if this == nil { + return "nil" + } + repeatedStringForMetrics := "[]Metric{" + for _, f := range this.Metrics { + repeatedStringForMetrics += strings.Replace(strings.Replace(f.String(), "Metric", "Metric", 1), `&`, ``, 1) + "," + } + repeatedStringForMetrics += "}" + repeatedStringForArgs := "[]Argument{" + for _, f := range this.Args { + repeatedStringForArgs += strings.Replace(strings.Replace(f.String(), "Argument", "Argument", 1), `&`, ``, 1) + "," + } + repeatedStringForArgs += "}" + repeatedStringForDryRun := "[]DryRun{" + for _, f := range this.DryRun { + repeatedStringForDryRun += strings.Replace(strings.Replace(f.String(), "DryRun", "DryRun", 1), `&`, ``, 1) + "," + } + repeatedStringForDryRun += "}" + repeatedStringForMeasurementRetention := "[]MeasurementRetention{" + for _, f := range this.MeasurementRetention { + repeatedStringForMeasurementRetention += strings.Replace(strings.Replace(f.String(), "MeasurementRetention", "MeasurementRetention", 1), `&`, ``, 1) + "," + } + repeatedStringForMeasurementRetention += "}" + s := strings.Join([]string{`&AnalysisTemplateSpec{`, + `Metrics:` + repeatedStringForMetrics + `,`, + `Args:` + repeatedStringForArgs + `,`, + `DryRun:` + repeatedStringForDryRun + `,`, + `MeasurementRetention:` + repeatedStringForMeasurementRetention + `,`, + `}`, + }, "") + return s +} +func (this *AntiAffinity) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AntiAffinity{`, + `PreferredDuringSchedulingIgnoredDuringExecution:` + strings.Replace(this.PreferredDuringSchedulingIgnoredDuringExecution.String(), "PreferredDuringSchedulingIgnoredDuringExecution", "PreferredDuringSchedulingIgnoredDuringExecution", 1) + `,`, + `RequiredDuringSchedulingIgnoredDuringExecution:` + strings.Replace(this.RequiredDuringSchedulingIgnoredDuringExecution.String(), "RequiredDuringSchedulingIgnoredDuringExecution", "RequiredDuringSchedulingIgnoredDuringExecution", 1) + `,`, + `}`, + }, "") + return s +} +func (this *ApisixRoute) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ApisixRoute{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `Rules:` + fmt.Sprintf("%v", this.Rules) + `,`, + `}`, + }, "") + return s +} +func (this *ApisixTrafficRouting) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ApisixTrafficRouting{`, + `Route:` + strings.Replace(this.Route.String(), "ApisixRoute", "ApisixRoute", 1) + `,`, + `}`, + }, "") + return s +} +func (this *AppMeshTrafficRouting) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AppMeshTrafficRouting{`, + `VirtualService:` + strings.Replace(this.VirtualService.String(), "AppMeshVirtualService", "AppMeshVirtualService", 1) + `,`, + `VirtualNodeGroup:` + strings.Replace(this.VirtualNodeGroup.String(), "AppMeshVirtualNodeGroup", "AppMeshVirtualNodeGroup", 1) + `,`, + `}`, + }, "") + return s +} +func (this *AppMeshVirtualNodeGroup) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AppMeshVirtualNodeGroup{`, + `CanaryVirtualNodeRef:` + strings.Replace(this.CanaryVirtualNodeRef.String(), "AppMeshVirtualNodeReference", "AppMeshVirtualNodeReference", 1) + `,`, + `StableVirtualNodeRef:` + strings.Replace(this.StableVirtualNodeRef.String(), "AppMeshVirtualNodeReference", "AppMeshVirtualNodeReference", 1) + `,`, + `}`, + }, "") + return s +} +func (this *AppMeshVirtualNodeReference) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AppMeshVirtualNodeReference{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `}`, + }, "") + return s +} +func (this *AppMeshVirtualService) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AppMeshVirtualService{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `Routes:` + fmt.Sprintf("%v", this.Routes) + `,`, + `}`, + }, "") + return s +} +func (this *Argument) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Argument{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `Value:` + valueToStringGenerated(this.Value) + `,`, + `ValueFrom:` + strings.Replace(this.ValueFrom.String(), "ValueFrom", "ValueFrom", 1) + `,`, + `}`, + }, "") + return s +} +func (this *ArgumentValueFrom) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ArgumentValueFrom{`, + `PodTemplateHashValue:` + valueToStringGenerated(this.PodTemplateHashValue) + `,`, + `FieldRef:` + strings.Replace(this.FieldRef.String(), "FieldRef", "FieldRef", 1) + `,`, + `}`, + }, "") + return s +} +func (this *AwsResourceRef) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AwsResourceRef{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `ARN:` + fmt.Sprintf("%v", this.ARN) + `,`, + `FullName:` + fmt.Sprintf("%v", this.FullName) + `,`, + `}`, + }, "") + return s +} +func (this *BlueGreenStatus) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&BlueGreenStatus{`, + `PreviewSelector:` + fmt.Sprintf("%v", this.PreviewSelector) + `,`, + `ActiveSelector:` + fmt.Sprintf("%v", this.ActiveSelector) + `,`, + `ScaleUpPreviewCheckPoint:` + fmt.Sprintf("%v", this.ScaleUpPreviewCheckPoint) + `,`, + `PrePromotionAnalysisRunStatus:` + strings.Replace(this.PrePromotionAnalysisRunStatus.String(), "RolloutAnalysisRunStatus", "RolloutAnalysisRunStatus", 1) + `,`, + `PostPromotionAnalysisRunStatus:` + strings.Replace(this.PostPromotionAnalysisRunStatus.String(), "RolloutAnalysisRunStatus", "RolloutAnalysisRunStatus", 1) + `,`, + `}`, + }, "") + return s +} +func (this *BlueGreenStrategy) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&BlueGreenStrategy{`, + `ActiveService:` + fmt.Sprintf("%v", this.ActiveService) + `,`, + `PreviewService:` + fmt.Sprintf("%v", this.PreviewService) + `,`, + `PreviewReplicaCount:` + valueToStringGenerated(this.PreviewReplicaCount) + `,`, + `AutoPromotionEnabled:` + valueToStringGenerated(this.AutoPromotionEnabled) + `,`, + `AutoPromotionSeconds:` + fmt.Sprintf("%v", this.AutoPromotionSeconds) + `,`, + `MaxUnavailable:` + strings.Replace(fmt.Sprintf("%v", this.MaxUnavailable), "IntOrString", "intstr.IntOrString", 1) + `,`, + `ScaleDownDelaySeconds:` + valueToStringGenerated(this.ScaleDownDelaySeconds) + `,`, + `ScaleDownDelayRevisionLimit:` + valueToStringGenerated(this.ScaleDownDelayRevisionLimit) + `,`, + `PrePromotionAnalysis:` + strings.Replace(this.PrePromotionAnalysis.String(), "RolloutAnalysis", "RolloutAnalysis", 1) + `,`, + `AntiAffinity:` + strings.Replace(this.AntiAffinity.String(), "AntiAffinity", "AntiAffinity", 1) + `,`, + `PostPromotionAnalysis:` + strings.Replace(this.PostPromotionAnalysis.String(), "RolloutAnalysis", "RolloutAnalysis", 1) + `,`, + `PreviewMetadata:` + strings.Replace(this.PreviewMetadata.String(), "PodTemplateMetadata", "PodTemplateMetadata", 1) + `,`, + `ActiveMetadata:` + strings.Replace(this.ActiveMetadata.String(), "PodTemplateMetadata", "PodTemplateMetadata", 1) + `,`, + `AbortScaleDownDelaySeconds:` + valueToStringGenerated(this.AbortScaleDownDelaySeconds) + `,`, + `}`, + }, "") + return s +} +func (this *CanaryStatus) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CanaryStatus{`, + `CurrentStepAnalysisRunStatus:` + strings.Replace(this.CurrentStepAnalysisRunStatus.String(), "RolloutAnalysisRunStatus", "RolloutAnalysisRunStatus", 1) + `,`, + `CurrentBackgroundAnalysisRunStatus:` + strings.Replace(this.CurrentBackgroundAnalysisRunStatus.String(), "RolloutAnalysisRunStatus", "RolloutAnalysisRunStatus", 1) + `,`, + `CurrentExperiment:` + fmt.Sprintf("%v", this.CurrentExperiment) + `,`, + `Weights:` + strings.Replace(this.Weights.String(), "TrafficWeights", "TrafficWeights", 1) + `,`, + `StablePingPong:` + fmt.Sprintf("%v", this.StablePingPong) + `,`, + `}`, + }, "") + return s +} +func (this *CanaryStep) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CanaryStep{`, + `SetWeight:` + valueToStringGenerated(this.SetWeight) + `,`, + `Pause:` + strings.Replace(this.Pause.String(), "RolloutPause", "RolloutPause", 1) + `,`, + `Experiment:` + strings.Replace(this.Experiment.String(), "RolloutExperimentStep", "RolloutExperimentStep", 1) + `,`, + `Analysis:` + strings.Replace(this.Analysis.String(), "RolloutAnalysis", "RolloutAnalysis", 1) + `,`, + `SetCanaryScale:` + strings.Replace(this.SetCanaryScale.String(), "SetCanaryScale", "SetCanaryScale", 1) + `,`, + `SetHeaderRoute:` + strings.Replace(this.SetHeaderRoute.String(), "SetHeaderRoute", "SetHeaderRoute", 1) + `,`, + `SetMirrorRoute:` + strings.Replace(this.SetMirrorRoute.String(), "SetMirrorRoute", "SetMirrorRoute", 1) + `,`, + `}`, + }, "") + return s +} +func (this *CanaryStrategy) String() string { + if this == nil { + return "nil" + } + repeatedStringForSteps := "[]CanaryStep{" + for _, f := range this.Steps { + repeatedStringForSteps += strings.Replace(strings.Replace(f.String(), "CanaryStep", "CanaryStep", 1), `&`, ``, 1) + "," + } + repeatedStringForSteps += "}" + s := strings.Join([]string{`&CanaryStrategy{`, + `CanaryService:` + fmt.Sprintf("%v", this.CanaryService) + `,`, + `StableService:` + fmt.Sprintf("%v", this.StableService) + `,`, + `Steps:` + repeatedStringForSteps + `,`, + `TrafficRouting:` + strings.Replace(this.TrafficRouting.String(), "RolloutTrafficRouting", "RolloutTrafficRouting", 1) + `,`, + `MaxUnavailable:` + strings.Replace(fmt.Sprintf("%v", this.MaxUnavailable), "IntOrString", "intstr.IntOrString", 1) + `,`, + `MaxSurge:` + strings.Replace(fmt.Sprintf("%v", this.MaxSurge), "IntOrString", "intstr.IntOrString", 1) + `,`, + `Analysis:` + strings.Replace(this.Analysis.String(), "RolloutAnalysisBackground", "RolloutAnalysisBackground", 1) + `,`, + `AntiAffinity:` + strings.Replace(this.AntiAffinity.String(), "AntiAffinity", "AntiAffinity", 1) + `,`, + `CanaryMetadata:` + strings.Replace(this.CanaryMetadata.String(), "PodTemplateMetadata", "PodTemplateMetadata", 1) + `,`, + `StableMetadata:` + strings.Replace(this.StableMetadata.String(), "PodTemplateMetadata", "PodTemplateMetadata", 1) + `,`, + `ScaleDownDelaySeconds:` + valueToStringGenerated(this.ScaleDownDelaySeconds) + `,`, + `ScaleDownDelayRevisionLimit:` + valueToStringGenerated(this.ScaleDownDelayRevisionLimit) + `,`, + `AbortScaleDownDelaySeconds:` + valueToStringGenerated(this.AbortScaleDownDelaySeconds) + `,`, + `DynamicStableScale:` + fmt.Sprintf("%v", this.DynamicStableScale) + `,`, + `PingPong:` + strings.Replace(this.PingPong.String(), "PingPongSpec", "PingPongSpec", 1) + `,`, + `MinPodsPerReplicaSet:` + valueToStringGenerated(this.MinPodsPerReplicaSet) + `,`, + `}`, + }, "") + return s +} +func (this *CloudWatchMetric) String() string { + if this == nil { + return "nil" + } + repeatedStringForMetricDataQueries := "[]CloudWatchMetricDataQuery{" + for _, f := range this.MetricDataQueries { + repeatedStringForMetricDataQueries += strings.Replace(strings.Replace(f.String(), "CloudWatchMetricDataQuery", "CloudWatchMetricDataQuery", 1), `&`, ``, 1) + "," + } + repeatedStringForMetricDataQueries += "}" + s := strings.Join([]string{`&CloudWatchMetric{`, + `Interval:` + fmt.Sprintf("%v", this.Interval) + `,`, + `MetricDataQueries:` + repeatedStringForMetricDataQueries + `,`, + `}`, + }, "") + return s +} +func (this *CloudWatchMetricDataQuery) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CloudWatchMetricDataQuery{`, + `Id:` + fmt.Sprintf("%v", this.Id) + `,`, + `Expression:` + valueToStringGenerated(this.Expression) + `,`, + `Label:` + valueToStringGenerated(this.Label) + `,`, + `MetricStat:` + strings.Replace(this.MetricStat.String(), "CloudWatchMetricStat", "CloudWatchMetricStat", 1) + `,`, + `Period:` + strings.Replace(fmt.Sprintf("%v", this.Period), "IntOrString", "intstr.IntOrString", 1) + `,`, + `ReturnData:` + valueToStringGenerated(this.ReturnData) + `,`, + `}`, + }, "") + return s +} +func (this *CloudWatchMetricStat) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CloudWatchMetricStat{`, + `Metric:` + strings.Replace(strings.Replace(this.Metric.String(), "CloudWatchMetricStatMetric", "CloudWatchMetricStatMetric", 1), `&`, ``, 1) + `,`, + `Period:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Period), "IntOrString", "intstr.IntOrString", 1), `&`, ``, 1) + `,`, + `Stat:` + fmt.Sprintf("%v", this.Stat) + `,`, + `Unit:` + fmt.Sprintf("%v", this.Unit) + `,`, + `}`, + }, "") + return s +} +func (this *CloudWatchMetricStatMetric) String() string { + if this == nil { + return "nil" + } + repeatedStringForDimensions := "[]CloudWatchMetricStatMetricDimension{" + for _, f := range this.Dimensions { + repeatedStringForDimensions += strings.Replace(strings.Replace(f.String(), "CloudWatchMetricStatMetricDimension", "CloudWatchMetricStatMetricDimension", 1), `&`, ``, 1) + "," + } + repeatedStringForDimensions += "}" + s := strings.Join([]string{`&CloudWatchMetricStatMetric{`, + `Dimensions:` + repeatedStringForDimensions + `,`, + `MetricName:` + fmt.Sprintf("%v", this.MetricName) + `,`, + `Namespace:` + valueToStringGenerated(this.Namespace) + `,`, + `}`, + }, "") + return s +} +func (this *CloudWatchMetricStatMetricDimension) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CloudWatchMetricStatMetricDimension{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `Value:` + fmt.Sprintf("%v", this.Value) + `,`, + `}`, + }, "") + return s +} +func (this *ClusterAnalysisTemplate) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ClusterAnalysisTemplate{`, + `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`, + `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "AnalysisTemplateSpec", "AnalysisTemplateSpec", 1), `&`, ``, 1) + `,`, + `}`, + }, "") + return s +} +func (this *ClusterAnalysisTemplateList) String() string { + if this == nil { + return "nil" + } + repeatedStringForItems := "[]ClusterAnalysisTemplate{" + for _, f := range this.Items { + repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "ClusterAnalysisTemplate", "ClusterAnalysisTemplate", 1), `&`, ``, 1) + "," + } + repeatedStringForItems += "}" + s := strings.Join([]string{`&ClusterAnalysisTemplateList{`, + `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`, + `Items:` + repeatedStringForItems + `,`, + `}`, + }, "") + return s +} +func (this *DatadogMetric) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&DatadogMetric{`, + `Interval:` + fmt.Sprintf("%v", this.Interval) + `,`, + `Query:` + fmt.Sprintf("%v", this.Query) + `,`, + `ApiVersion:` + fmt.Sprintf("%v", this.ApiVersion) + `,`, + `}`, + }, "") + return s +} +func (this *DryRun) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&DryRun{`, + `MetricName:` + fmt.Sprintf("%v", this.MetricName) + `,`, + `}`, + }, "") + return s +} +func (this *Experiment) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Experiment{`, + `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`, + `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "ExperimentSpec", "ExperimentSpec", 1), `&`, ``, 1) + `,`, + `Status:` + strings.Replace(strings.Replace(this.Status.String(), "ExperimentStatus", "ExperimentStatus", 1), `&`, ``, 1) + `,`, + `}`, + }, "") + return s +} +func (this *ExperimentAnalysisRunStatus) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ExperimentAnalysisRunStatus{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `AnalysisRun:` + fmt.Sprintf("%v", this.AnalysisRun) + `,`, + `Phase:` + fmt.Sprintf("%v", this.Phase) + `,`, + `Message:` + fmt.Sprintf("%v", this.Message) + `,`, + `}`, + }, "") + return s +} +func (this *ExperimentAnalysisTemplateRef) String() string { + if this == nil { + return "nil" + } + repeatedStringForArgs := "[]Argument{" + for _, f := range this.Args { + repeatedStringForArgs += strings.Replace(strings.Replace(f.String(), "Argument", "Argument", 1), `&`, ``, 1) + "," + } + repeatedStringForArgs += "}" + s := strings.Join([]string{`&ExperimentAnalysisTemplateRef{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `TemplateName:` + fmt.Sprintf("%v", this.TemplateName) + `,`, + `ClusterScope:` + fmt.Sprintf("%v", this.ClusterScope) + `,`, + `Args:` + repeatedStringForArgs + `,`, + `RequiredForCompletion:` + fmt.Sprintf("%v", this.RequiredForCompletion) + `,`, + `}`, + }, "") + return s +} +func (this *ExperimentCondition) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ExperimentCondition{`, + `Type:` + fmt.Sprintf("%v", this.Type) + `,`, + `Status:` + fmt.Sprintf("%v", this.Status) + `,`, + `LastUpdateTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.LastUpdateTime), "Time", "v1.Time", 1), `&`, ``, 1) + `,`, + `LastTransitionTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.LastTransitionTime), "Time", "v1.Time", 1), `&`, ``, 1) + `,`, + `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`, + `Message:` + fmt.Sprintf("%v", this.Message) + `,`, + `}`, + }, "") + return s +} +func (this *ExperimentList) String() string { + if this == nil { + return "nil" + } + repeatedStringForItems := "[]Experiment{" + for _, f := range this.Items { + repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "Experiment", "Experiment", 1), `&`, ``, 1) + "," + } + repeatedStringForItems += "}" + s := strings.Join([]string{`&ExperimentList{`, + `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`, + `Items:` + repeatedStringForItems + `,`, + `}`, + }, "") + return s +} +func (this *ExperimentSpec) String() string { + if this == nil { + return "nil" + } + repeatedStringForTemplates := "[]TemplateSpec{" + for _, f := range this.Templates { + repeatedStringForTemplates += strings.Replace(strings.Replace(f.String(), "TemplateSpec", "TemplateSpec", 1), `&`, ``, 1) + "," + } + repeatedStringForTemplates += "}" + repeatedStringForAnalyses := "[]ExperimentAnalysisTemplateRef{" + for _, f := range this.Analyses { + repeatedStringForAnalyses += strings.Replace(strings.Replace(f.String(), "ExperimentAnalysisTemplateRef", "ExperimentAnalysisTemplateRef", 1), `&`, ``, 1) + "," + } + repeatedStringForAnalyses += "}" + repeatedStringForDryRun := "[]DryRun{" + for _, f := range this.DryRun { + repeatedStringForDryRun += strings.Replace(strings.Replace(f.String(), "DryRun", "DryRun", 1), `&`, ``, 1) + "," + } + repeatedStringForDryRun += "}" + repeatedStringForMeasurementRetention := "[]MeasurementRetention{" + for _, f := range this.MeasurementRetention { + repeatedStringForMeasurementRetention += strings.Replace(strings.Replace(f.String(), "MeasurementRetention", "MeasurementRetention", 1), `&`, ``, 1) + "," + } + repeatedStringForMeasurementRetention += "}" + s := strings.Join([]string{`&ExperimentSpec{`, + `Templates:` + repeatedStringForTemplates + `,`, + `Duration:` + fmt.Sprintf("%v", this.Duration) + `,`, + `ProgressDeadlineSeconds:` + valueToStringGenerated(this.ProgressDeadlineSeconds) + `,`, + `Terminate:` + fmt.Sprintf("%v", this.Terminate) + `,`, + `Analyses:` + repeatedStringForAnalyses + `,`, + `ScaleDownDelaySeconds:` + valueToStringGenerated(this.ScaleDownDelaySeconds) + `,`, + `DryRun:` + repeatedStringForDryRun + `,`, + `MeasurementRetention:` + repeatedStringForMeasurementRetention + `,`, + `}`, + }, "") + return s +} +func (this *ExperimentStatus) String() string { + if this == nil { + return "nil" + } + repeatedStringForTemplateStatuses := "[]TemplateStatus{" + for _, f := range this.TemplateStatuses { + repeatedStringForTemplateStatuses += strings.Replace(strings.Replace(f.String(), "TemplateStatus", "TemplateStatus", 1), `&`, ``, 1) + "," + } + repeatedStringForTemplateStatuses += "}" + repeatedStringForConditions := "[]ExperimentCondition{" + for _, f := range this.Conditions { + repeatedStringForConditions += strings.Replace(strings.Replace(f.String(), "ExperimentCondition", "ExperimentCondition", 1), `&`, ``, 1) + "," + } + repeatedStringForConditions += "}" + repeatedStringForAnalysisRuns := "[]ExperimentAnalysisRunStatus{" + for _, f := range this.AnalysisRuns { + repeatedStringForAnalysisRuns += strings.Replace(strings.Replace(f.String(), "ExperimentAnalysisRunStatus", "ExperimentAnalysisRunStatus", 1), `&`, ``, 1) + "," + } + repeatedStringForAnalysisRuns += "}" + s := strings.Join([]string{`&ExperimentStatus{`, + `Phase:` + fmt.Sprintf("%v", this.Phase) + `,`, + `Message:` + fmt.Sprintf("%v", this.Message) + `,`, + `TemplateStatuses:` + repeatedStringForTemplateStatuses + `,`, + `AvailableAt:` + strings.Replace(fmt.Sprintf("%v", this.AvailableAt), "Time", "v1.Time", 1) + `,`, + `Conditions:` + repeatedStringForConditions + `,`, + `AnalysisRuns:` + repeatedStringForAnalysisRuns + `,`, + `}`, + }, "") + return s +} +func (this *FieldRef) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&FieldRef{`, + `FieldPath:` + fmt.Sprintf("%v", this.FieldPath) + `,`, + `}`, + }, "") + return s +} +func (this *GraphiteMetric) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&GraphiteMetric{`, + `Address:` + fmt.Sprintf("%v", this.Address) + `,`, + `Query:` + fmt.Sprintf("%v", this.Query) + `,`, + `}`, + }, "") + return s +} +func (this *HeaderRoutingMatch) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&HeaderRoutingMatch{`, + `HeaderName:` + fmt.Sprintf("%v", this.HeaderName) + `,`, + `HeaderValue:` + strings.Replace(this.HeaderValue.String(), "StringMatch", "StringMatch", 1) + `,`, + `}`, + }, "") + return s +} +func (this *InfluxdbMetric) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&InfluxdbMetric{`, + `Profile:` + fmt.Sprintf("%v", this.Profile) + `,`, + `Query:` + fmt.Sprintf("%v", this.Query) + `,`, + `}`, + }, "") + return s +} +func (this *IstioDestinationRule) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&IstioDestinationRule{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `CanarySubsetName:` + fmt.Sprintf("%v", this.CanarySubsetName) + `,`, + `StableSubsetName:` + fmt.Sprintf("%v", this.StableSubsetName) + `,`, + `}`, + }, "") + return s +} +func (this *IstioTrafficRouting) String() string { + if this == nil { + return "nil" + } + repeatedStringForVirtualServices := "[]IstioVirtualService{" + for _, f := range this.VirtualServices { + repeatedStringForVirtualServices += strings.Replace(strings.Replace(f.String(), "IstioVirtualService", "IstioVirtualService", 1), `&`, ``, 1) + "," + } + repeatedStringForVirtualServices += "}" + s := strings.Join([]string{`&IstioTrafficRouting{`, + `VirtualService:` + strings.Replace(this.VirtualService.String(), "IstioVirtualService", "IstioVirtualService", 1) + `,`, + `DestinationRule:` + strings.Replace(this.DestinationRule.String(), "IstioDestinationRule", "IstioDestinationRule", 1) + `,`, + `VirtualServices:` + repeatedStringForVirtualServices + `,`, + `}`, + }, "") + return s +} +func (this *IstioVirtualService) String() string { + if this == nil { + return "nil" + } + repeatedStringForTLSRoutes := "[]TLSRoute{" + for _, f := range this.TLSRoutes { + repeatedStringForTLSRoutes += strings.Replace(strings.Replace(f.String(), "TLSRoute", "TLSRoute", 1), `&`, ``, 1) + "," + } + repeatedStringForTLSRoutes += "}" + repeatedStringForTCPRoutes := "[]TCPRoute{" + for _, f := range this.TCPRoutes { + repeatedStringForTCPRoutes += strings.Replace(strings.Replace(f.String(), "TCPRoute", "TCPRoute", 1), `&`, ``, 1) + "," + } + repeatedStringForTCPRoutes += "}" + s := strings.Join([]string{`&IstioVirtualService{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `Routes:` + fmt.Sprintf("%v", this.Routes) + `,`, + `TLSRoutes:` + repeatedStringForTLSRoutes + `,`, + `TCPRoutes:` + repeatedStringForTCPRoutes + `,`, + `}`, + }, "") + return s +} +func (this *JobMetric) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&JobMetric{`, + `Metadata:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Metadata), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`, + `Spec:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Spec), "JobSpec", "v11.JobSpec", 1), `&`, ``, 1) + `,`, + `}`, + }, "") + return s +} +func (this *KayentaMetric) String() string { + if this == nil { + return "nil" + } + repeatedStringForScopes := "[]KayentaScope{" + for _, f := range this.Scopes { + repeatedStringForScopes += strings.Replace(strings.Replace(f.String(), "KayentaScope", "KayentaScope", 1), `&`, ``, 1) + "," + } + repeatedStringForScopes += "}" + s := strings.Join([]string{`&KayentaMetric{`, + `Address:` + fmt.Sprintf("%v", this.Address) + `,`, + `Application:` + fmt.Sprintf("%v", this.Application) + `,`, + `CanaryConfigName:` + fmt.Sprintf("%v", this.CanaryConfigName) + `,`, + `MetricsAccountName:` + fmt.Sprintf("%v", this.MetricsAccountName) + `,`, + `ConfigurationAccountName:` + fmt.Sprintf("%v", this.ConfigurationAccountName) + `,`, + `StorageAccountName:` + fmt.Sprintf("%v", this.StorageAccountName) + `,`, + `Threshold:` + strings.Replace(strings.Replace(this.Threshold.String(), "KayentaThreshold", "KayentaThreshold", 1), `&`, ``, 1) + `,`, + `Scopes:` + repeatedStringForScopes + `,`, + `}`, + }, "") + return s +} +func (this *KayentaScope) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&KayentaScope{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `ControlScope:` + strings.Replace(strings.Replace(this.ControlScope.String(), "ScopeDetail", "ScopeDetail", 1), `&`, ``, 1) + `,`, + `ExperimentScope:` + strings.Replace(strings.Replace(this.ExperimentScope.String(), "ScopeDetail", "ScopeDetail", 1), `&`, ``, 1) + `,`, + `}`, + }, "") + return s +} +func (this *KayentaThreshold) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&KayentaThreshold{`, + `Pass:` + fmt.Sprintf("%v", this.Pass) + `,`, + `Marginal:` + fmt.Sprintf("%v", this.Marginal) + `,`, + `}`, + }, "") + return s +} +func (this *MangedRoutes) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&MangedRoutes{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `}`, + }, "") + return s +} +func (this *Measurement) String() string { + if this == nil { + return "nil" + } + keysForMetadata := make([]string, 0, len(this.Metadata)) + for k := range this.Metadata { + keysForMetadata = append(keysForMetadata, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForMetadata) + mapStringForMetadata := "map[string]string{" + for _, k := range keysForMetadata { + mapStringForMetadata += fmt.Sprintf("%v: %v,", k, this.Metadata[k]) + } + mapStringForMetadata += "}" + s := strings.Join([]string{`&Measurement{`, + `Phase:` + fmt.Sprintf("%v", this.Phase) + `,`, + `Message:` + fmt.Sprintf("%v", this.Message) + `,`, + `StartedAt:` + strings.Replace(fmt.Sprintf("%v", this.StartedAt), "Time", "v1.Time", 1) + `,`, + `FinishedAt:` + strings.Replace(fmt.Sprintf("%v", this.FinishedAt), "Time", "v1.Time", 1) + `,`, + `Value:` + fmt.Sprintf("%v", this.Value) + `,`, + `Metadata:` + mapStringForMetadata + `,`, + `ResumeAt:` + strings.Replace(fmt.Sprintf("%v", this.ResumeAt), "Time", "v1.Time", 1) + `,`, + `}`, + }, "") + return s +} +func (this *MeasurementRetention) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&MeasurementRetention{`, + `MetricName:` + fmt.Sprintf("%v", this.MetricName) + `,`, + `Limit:` + fmt.Sprintf("%v", this.Limit) + `,`, + `}`, + }, "") + return s +} +func (this *Metric) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Metric{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `Interval:` + fmt.Sprintf("%v", this.Interval) + `,`, + `InitialDelay:` + fmt.Sprintf("%v", this.InitialDelay) + `,`, + `Count:` + strings.Replace(fmt.Sprintf("%v", this.Count), "IntOrString", "intstr.IntOrString", 1) + `,`, + `SuccessCondition:` + fmt.Sprintf("%v", this.SuccessCondition) + `,`, + `FailureCondition:` + fmt.Sprintf("%v", this.FailureCondition) + `,`, + `FailureLimit:` + strings.Replace(fmt.Sprintf("%v", this.FailureLimit), "IntOrString", "intstr.IntOrString", 1) + `,`, + `InconclusiveLimit:` + strings.Replace(fmt.Sprintf("%v", this.InconclusiveLimit), "IntOrString", "intstr.IntOrString", 1) + `,`, + `ConsecutiveErrorLimit:` + strings.Replace(fmt.Sprintf("%v", this.ConsecutiveErrorLimit), "IntOrString", "intstr.IntOrString", 1) + `,`, + `Provider:` + strings.Replace(strings.Replace(this.Provider.String(), "MetricProvider", "MetricProvider", 1), `&`, ``, 1) + `,`, + `}`, + }, "") + return s +} +func (this *MetricProvider) String() string { + if this == nil { + return "nil" + } + keysForPlugin := make([]string, 0, len(this.Plugin)) + for k := range this.Plugin { + keysForPlugin = append(keysForPlugin, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForPlugin) + mapStringForPlugin := "map[string]encoding_json.RawMessage{" + for _, k := range keysForPlugin { + mapStringForPlugin += fmt.Sprintf("%v: %v,", k, this.Plugin[k]) + } + mapStringForPlugin += "}" + s := strings.Join([]string{`&MetricProvider{`, + `Prometheus:` + strings.Replace(this.Prometheus.String(), "PrometheusMetric", "PrometheusMetric", 1) + `,`, + `Kayenta:` + strings.Replace(this.Kayenta.String(), "KayentaMetric", "KayentaMetric", 1) + `,`, + `Web:` + strings.Replace(this.Web.String(), "WebMetric", "WebMetric", 1) + `,`, + `Datadog:` + strings.Replace(this.Datadog.String(), "DatadogMetric", "DatadogMetric", 1) + `,`, + `Wavefront:` + strings.Replace(this.Wavefront.String(), "WavefrontMetric", "WavefrontMetric", 1) + `,`, + `NewRelic:` + strings.Replace(this.NewRelic.String(), "NewRelicMetric", "NewRelicMetric", 1) + `,`, + `Job:` + strings.Replace(this.Job.String(), "JobMetric", "JobMetric", 1) + `,`, + `CloudWatch:` + strings.Replace(this.CloudWatch.String(), "CloudWatchMetric", "CloudWatchMetric", 1) + `,`, + `Graphite:` + strings.Replace(this.Graphite.String(), "GraphiteMetric", "GraphiteMetric", 1) + `,`, + `Influxdb:` + strings.Replace(this.Influxdb.String(), "InfluxdbMetric", "InfluxdbMetric", 1) + `,`, + `SkyWalking:` + strings.Replace(this.SkyWalking.String(), "SkyWalkingMetric", "SkyWalkingMetric", 1) + `,`, + `Plugin:` + mapStringForPlugin + `,`, + `}`, + }, "") + return s +} +func (this *MetricResult) String() string { + if this == nil { + return "nil" + } + repeatedStringForMeasurements := "[]Measurement{" + for _, f := range this.Measurements { + repeatedStringForMeasurements += strings.Replace(strings.Replace(f.String(), "Measurement", "Measurement", 1), `&`, ``, 1) + "," + } + repeatedStringForMeasurements += "}" + keysForMetadata := make([]string, 0, len(this.Metadata)) + for k := range this.Metadata { + keysForMetadata = append(keysForMetadata, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForMetadata) + mapStringForMetadata := "map[string]string{" + for _, k := range keysForMetadata { + mapStringForMetadata += fmt.Sprintf("%v: %v,", k, this.Metadata[k]) + } + mapStringForMetadata += "}" + s := strings.Join([]string{`&MetricResult{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `Phase:` + fmt.Sprintf("%v", this.Phase) + `,`, + `Measurements:` + repeatedStringForMeasurements + `,`, + `Message:` + fmt.Sprintf("%v", this.Message) + `,`, + `Count:` + fmt.Sprintf("%v", this.Count) + `,`, + `Successful:` + fmt.Sprintf("%v", this.Successful) + `,`, + `Failed:` + fmt.Sprintf("%v", this.Failed) + `,`, + `Inconclusive:` + fmt.Sprintf("%v", this.Inconclusive) + `,`, + `Error:` + fmt.Sprintf("%v", this.Error) + `,`, + `ConsecutiveError:` + fmt.Sprintf("%v", this.ConsecutiveError) + `,`, + `DryRun:` + fmt.Sprintf("%v", this.DryRun) + `,`, + `Metadata:` + mapStringForMetadata + `,`, + `}`, + }, "") + return s +} +func (this *NewRelicMetric) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NewRelicMetric{`, + `Profile:` + fmt.Sprintf("%v", this.Profile) + `,`, + `Query:` + fmt.Sprintf("%v", this.Query) + `,`, + `}`, + }, "") + return s +} +func (this *NginxTrafficRouting) String() string { + if this == nil { + return "nil" + } + keysForAdditionalIngressAnnotations := make([]string, 0, len(this.AdditionalIngressAnnotations)) + for k := range this.AdditionalIngressAnnotations { + keysForAdditionalIngressAnnotations = append(keysForAdditionalIngressAnnotations, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForAdditionalIngressAnnotations) + mapStringForAdditionalIngressAnnotations := "map[string]string{" + for _, k := range keysForAdditionalIngressAnnotations { + mapStringForAdditionalIngressAnnotations += fmt.Sprintf("%v: %v,", k, this.AdditionalIngressAnnotations[k]) + } + mapStringForAdditionalIngressAnnotations += "}" + s := strings.Join([]string{`&NginxTrafficRouting{`, + `AnnotationPrefix:` + fmt.Sprintf("%v", this.AnnotationPrefix) + `,`, + `StableIngress:` + fmt.Sprintf("%v", this.StableIngress) + `,`, + `AdditionalIngressAnnotations:` + mapStringForAdditionalIngressAnnotations + `,`, + `StableIngresses:` + fmt.Sprintf("%v", this.StableIngresses) + `,`, + `}`, + }, "") + return s +} +func (this *ObjectRef) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ObjectRef{`, + `APIVersion:` + fmt.Sprintf("%v", this.APIVersion) + `,`, + `Kind:` + fmt.Sprintf("%v", this.Kind) + `,`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `}`, + }, "") + return s +} +func (this *PauseCondition) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&PauseCondition{`, + `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`, + `StartTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.StartTime), "Time", "v1.Time", 1), `&`, ``, 1) + `,`, + `}`, + }, "") + return s +} +func (this *PingPongSpec) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&PingPongSpec{`, + `PingService:` + fmt.Sprintf("%v", this.PingService) + `,`, + `PongService:` + fmt.Sprintf("%v", this.PongService) + `,`, + `}`, + }, "") + return s +} +func (this *PodTemplateMetadata) String() string { + if this == nil { + return "nil" + } + keysForLabels := make([]string, 0, len(this.Labels)) + for k := range this.Labels { + keysForLabels = append(keysForLabels, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForLabels) + mapStringForLabels := "map[string]string{" + for _, k := range keysForLabels { + mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k]) + } + mapStringForLabels += "}" + keysForAnnotations := make([]string, 0, len(this.Annotations)) + for k := range this.Annotations { + keysForAnnotations = append(keysForAnnotations, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForAnnotations) + mapStringForAnnotations := "map[string]string{" + for _, k := range keysForAnnotations { + mapStringForAnnotations += fmt.Sprintf("%v: %v,", k, this.Annotations[k]) + } + mapStringForAnnotations += "}" + s := strings.Join([]string{`&PodTemplateMetadata{`, + `Labels:` + mapStringForLabels + `,`, + `Annotations:` + mapStringForAnnotations + `,`, + `}`, + }, "") + return s +} +func (this *PreferredDuringSchedulingIgnoredDuringExecution) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&PreferredDuringSchedulingIgnoredDuringExecution{`, + `Weight:` + fmt.Sprintf("%v", this.Weight) + `,`, + `}`, + }, "") + return s +} +func (this *PrometheusAuth) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&PrometheusAuth{`, + `Sigv4:` + strings.Replace(strings.Replace(this.Sigv4.String(), "Sigv4Config", "Sigv4Config", 1), `&`, ``, 1) + `,`, + `}`, + }, "") + return s +} +func (this *PrometheusMetric) String() string { + if this == nil { + return "nil" + } + repeatedStringForHeaders := "[]WebMetricHeader{" + for _, f := range this.Headers { + repeatedStringForHeaders += strings.Replace(strings.Replace(f.String(), "WebMetricHeader", "WebMetricHeader", 1), `&`, ``, 1) + "," + } + repeatedStringForHeaders += "}" + s := strings.Join([]string{`&PrometheusMetric{`, + `Address:` + fmt.Sprintf("%v", this.Address) + `,`, + `Query:` + fmt.Sprintf("%v", this.Query) + `,`, + `Authentication:` + strings.Replace(strings.Replace(this.Authentication.String(), "PrometheusAuth", "PrometheusAuth", 1), `&`, ``, 1) + `,`, + `Timeout:` + valueToStringGenerated(this.Timeout) + `,`, + `Insecure:` + fmt.Sprintf("%v", this.Insecure) + `,`, + `Headers:` + repeatedStringForHeaders + `,`, + `}`, + }, "") + return s +} +func (this *RequiredDuringSchedulingIgnoredDuringExecution) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&RequiredDuringSchedulingIgnoredDuringExecution{`, + `}`, + }, "") + return s +} +func (this *RollbackWindowSpec) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&RollbackWindowSpec{`, + `Revisions:` + fmt.Sprintf("%v", this.Revisions) + `,`, + `}`, + }, "") + return s +} +func (this *Rollout) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Rollout{`, + `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`, + `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "RolloutSpec", "RolloutSpec", 1), `&`, ``, 1) + `,`, + `Status:` + strings.Replace(strings.Replace(this.Status.String(), "RolloutStatus", "RolloutStatus", 1), `&`, ``, 1) + `,`, + `}`, + }, "") + return s +} +func (this *RolloutAnalysis) String() string { + if this == nil { + return "nil" + } + repeatedStringForTemplates := "[]RolloutAnalysisTemplate{" + for _, f := range this.Templates { + repeatedStringForTemplates += strings.Replace(strings.Replace(f.String(), "RolloutAnalysisTemplate", "RolloutAnalysisTemplate", 1), `&`, ``, 1) + "," + } + repeatedStringForTemplates += "}" + repeatedStringForArgs := "[]AnalysisRunArgument{" + for _, f := range this.Args { + repeatedStringForArgs += strings.Replace(strings.Replace(f.String(), "AnalysisRunArgument", "AnalysisRunArgument", 1), `&`, ``, 1) + "," + } + repeatedStringForArgs += "}" + repeatedStringForDryRun := "[]DryRun{" + for _, f := range this.DryRun { + repeatedStringForDryRun += strings.Replace(strings.Replace(f.String(), "DryRun", "DryRun", 1), `&`, ``, 1) + "," + } + repeatedStringForDryRun += "}" + repeatedStringForMeasurementRetention := "[]MeasurementRetention{" + for _, f := range this.MeasurementRetention { + repeatedStringForMeasurementRetention += strings.Replace(strings.Replace(f.String(), "MeasurementRetention", "MeasurementRetention", 1), `&`, ``, 1) + "," + } + repeatedStringForMeasurementRetention += "}" + s := strings.Join([]string{`&RolloutAnalysis{`, + `Templates:` + repeatedStringForTemplates + `,`, + `Args:` + repeatedStringForArgs + `,`, + `DryRun:` + repeatedStringForDryRun + `,`, + `MeasurementRetention:` + repeatedStringForMeasurementRetention + `,`, + `AnalysisRunMetadata:` + strings.Replace(strings.Replace(this.AnalysisRunMetadata.String(), "AnalysisRunMetadata", "AnalysisRunMetadata", 1), `&`, ``, 1) + `,`, + `}`, + }, "") + return s +} +func (this *RolloutAnalysisBackground) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&RolloutAnalysisBackground{`, + `RolloutAnalysis:` + strings.Replace(strings.Replace(this.RolloutAnalysis.String(), "RolloutAnalysis", "RolloutAnalysis", 1), `&`, ``, 1) + `,`, + `StartingStep:` + valueToStringGenerated(this.StartingStep) + `,`, + `}`, + }, "") + return s +} +func (this *RolloutAnalysisRunStatus) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&RolloutAnalysisRunStatus{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `Status:` + fmt.Sprintf("%v", this.Status) + `,`, + `Message:` + fmt.Sprintf("%v", this.Message) + `,`, + `}`, + }, "") + return s +} +func (this *RolloutAnalysisTemplate) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&RolloutAnalysisTemplate{`, + `TemplateName:` + fmt.Sprintf("%v", this.TemplateName) + `,`, + `ClusterScope:` + fmt.Sprintf("%v", this.ClusterScope) + `,`, + `}`, + }, "") + return s +} +func (this *RolloutCondition) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&RolloutCondition{`, + `Type:` + fmt.Sprintf("%v", this.Type) + `,`, + `Status:` + fmt.Sprintf("%v", this.Status) + `,`, + `LastUpdateTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.LastUpdateTime), "Time", "v1.Time", 1), `&`, ``, 1) + `,`, + `LastTransitionTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.LastTransitionTime), "Time", "v1.Time", 1), `&`, ``, 1) + `,`, + `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`, + `Message:` + fmt.Sprintf("%v", this.Message) + `,`, + `}`, + }, "") + return s +} +func (this *RolloutExperimentStep) String() string { + if this == nil { + return "nil" + } + repeatedStringForTemplates := "[]RolloutExperimentTemplate{" + for _, f := range this.Templates { + repeatedStringForTemplates += strings.Replace(strings.Replace(f.String(), "RolloutExperimentTemplate", "RolloutExperimentTemplate", 1), `&`, ``, 1) + "," + } + repeatedStringForTemplates += "}" + repeatedStringForAnalyses := "[]RolloutExperimentStepAnalysisTemplateRef{" + for _, f := range this.Analyses { + repeatedStringForAnalyses += strings.Replace(strings.Replace(f.String(), "RolloutExperimentStepAnalysisTemplateRef", "RolloutExperimentStepAnalysisTemplateRef", 1), `&`, ``, 1) + "," + } + repeatedStringForAnalyses += "}" + s := strings.Join([]string{`&RolloutExperimentStep{`, + `Templates:` + repeatedStringForTemplates + `,`, + `Duration:` + fmt.Sprintf("%v", this.Duration) + `,`, + `Analyses:` + repeatedStringForAnalyses + `,`, + `}`, + }, "") + return s +} +func (this *RolloutExperimentStepAnalysisTemplateRef) String() string { + if this == nil { + return "nil" + } + repeatedStringForArgs := "[]AnalysisRunArgument{" + for _, f := range this.Args { + repeatedStringForArgs += strings.Replace(strings.Replace(f.String(), "AnalysisRunArgument", "AnalysisRunArgument", 1), `&`, ``, 1) + "," + } + repeatedStringForArgs += "}" + s := strings.Join([]string{`&RolloutExperimentStepAnalysisTemplateRef{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `TemplateName:` + fmt.Sprintf("%v", this.TemplateName) + `,`, + `ClusterScope:` + fmt.Sprintf("%v", this.ClusterScope) + `,`, + `Args:` + repeatedStringForArgs + `,`, + `RequiredForCompletion:` + fmt.Sprintf("%v", this.RequiredForCompletion) + `,`, + `}`, + }, "") + return s +} +func (this *RolloutExperimentTemplate) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&RolloutExperimentTemplate{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `SpecRef:` + fmt.Sprintf("%v", this.SpecRef) + `,`, + `Replicas:` + valueToStringGenerated(this.Replicas) + `,`, + `Metadata:` + strings.Replace(strings.Replace(this.Metadata.String(), "PodTemplateMetadata", "PodTemplateMetadata", 1), `&`, ``, 1) + `,`, + `Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "v1.LabelSelector", 1) + `,`, + `Weight:` + valueToStringGenerated(this.Weight) + `,`, + `Service:` + strings.Replace(this.Service.String(), "TemplateService", "TemplateService", 1) + `,`, + `}`, + }, "") + return s +} +func (this *RolloutList) String() string { + if this == nil { + return "nil" + } + repeatedStringForItems := "[]Rollout{" + for _, f := range this.Items { + repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "Rollout", "Rollout", 1), `&`, ``, 1) + "," + } + repeatedStringForItems += "}" + s := strings.Join([]string{`&RolloutList{`, + `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`, + `Items:` + repeatedStringForItems + `,`, + `}`, + }, "") + return s +} +func (this *RolloutPause) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&RolloutPause{`, + `Duration:` + strings.Replace(fmt.Sprintf("%v", this.Duration), "IntOrString", "intstr.IntOrString", 1) + `,`, + `}`, + }, "") + return s +} +func (this *RolloutSpec) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&RolloutSpec{`, + `Replicas:` + valueToStringGenerated(this.Replicas) + `,`, + `Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "v1.LabelSelector", 1) + `,`, + `Template:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Template), "PodTemplateSpec", "v12.PodTemplateSpec", 1), `&`, ``, 1) + `,`, + `MinReadySeconds:` + fmt.Sprintf("%v", this.MinReadySeconds) + `,`, + `Strategy:` + strings.Replace(strings.Replace(this.Strategy.String(), "RolloutStrategy", "RolloutStrategy", 1), `&`, ``, 1) + `,`, + `RevisionHistoryLimit:` + valueToStringGenerated(this.RevisionHistoryLimit) + `,`, + `Paused:` + fmt.Sprintf("%v", this.Paused) + `,`, + `ProgressDeadlineSeconds:` + valueToStringGenerated(this.ProgressDeadlineSeconds) + `,`, + `RestartAt:` + strings.Replace(fmt.Sprintf("%v", this.RestartAt), "Time", "v1.Time", 1) + `,`, + `WorkloadRef:` + strings.Replace(this.WorkloadRef.String(), "ObjectRef", "ObjectRef", 1) + `,`, + `Analysis:` + strings.Replace(this.Analysis.String(), "AnalysisRunStrategy", "AnalysisRunStrategy", 1) + `,`, + `ProgressDeadlineAbort:` + fmt.Sprintf("%v", this.ProgressDeadlineAbort) + `,`, + `RollbackWindow:` + strings.Replace(this.RollbackWindow.String(), "RollbackWindowSpec", "RollbackWindowSpec", 1) + `,`, + `}`, + }, "") + return s +} +func (this *RolloutStatus) String() string { + if this == nil { + return "nil" + } + repeatedStringForPauseConditions := "[]PauseCondition{" + for _, f := range this.PauseConditions { + repeatedStringForPauseConditions += strings.Replace(strings.Replace(f.String(), "PauseCondition", "PauseCondition", 1), `&`, ``, 1) + "," + } + repeatedStringForPauseConditions += "}" + repeatedStringForConditions := "[]RolloutCondition{" + for _, f := range this.Conditions { + repeatedStringForConditions += strings.Replace(strings.Replace(f.String(), "RolloutCondition", "RolloutCondition", 1), `&`, ``, 1) + "," + } + repeatedStringForConditions += "}" + repeatedStringForALBs := "[]ALBStatus{" + for _, f := range this.ALBs { + repeatedStringForALBs += strings.Replace(strings.Replace(f.String(), "ALBStatus", "ALBStatus", 1), `&`, ``, 1) + "," + } + repeatedStringForALBs += "}" + s := strings.Join([]string{`&RolloutStatus{`, + `Abort:` + fmt.Sprintf("%v", this.Abort) + `,`, + `PauseConditions:` + repeatedStringForPauseConditions + `,`, + `ControllerPause:` + fmt.Sprintf("%v", this.ControllerPause) + `,`, + `AbortedAt:` + strings.Replace(fmt.Sprintf("%v", this.AbortedAt), "Time", "v1.Time", 1) + `,`, + `CurrentPodHash:` + fmt.Sprintf("%v", this.CurrentPodHash) + `,`, + `CurrentStepHash:` + fmt.Sprintf("%v", this.CurrentStepHash) + `,`, + `Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`, + `UpdatedReplicas:` + fmt.Sprintf("%v", this.UpdatedReplicas) + `,`, + `ReadyReplicas:` + fmt.Sprintf("%v", this.ReadyReplicas) + `,`, + `AvailableReplicas:` + fmt.Sprintf("%v", this.AvailableReplicas) + `,`, + `CurrentStepIndex:` + valueToStringGenerated(this.CurrentStepIndex) + `,`, + `CollisionCount:` + valueToStringGenerated(this.CollisionCount) + `,`, + `ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`, + `Conditions:` + repeatedStringForConditions + `,`, + `Canary:` + strings.Replace(strings.Replace(this.Canary.String(), "CanaryStatus", "CanaryStatus", 1), `&`, ``, 1) + `,`, + `BlueGreen:` + strings.Replace(strings.Replace(this.BlueGreen.String(), "BlueGreenStatus", "BlueGreenStatus", 1), `&`, ``, 1) + `,`, + `HPAReplicas:` + fmt.Sprintf("%v", this.HPAReplicas) + `,`, + `Selector:` + fmt.Sprintf("%v", this.Selector) + `,`, + `StableRS:` + fmt.Sprintf("%v", this.StableRS) + `,`, + `RestartedAt:` + strings.Replace(fmt.Sprintf("%v", this.RestartedAt), "Time", "v1.Time", 1) + `,`, + `PromoteFull:` + fmt.Sprintf("%v", this.PromoteFull) + `,`, + `Phase:` + fmt.Sprintf("%v", this.Phase) + `,`, + `Message:` + fmt.Sprintf("%v", this.Message) + `,`, + `WorkloadObservedGeneration:` + fmt.Sprintf("%v", this.WorkloadObservedGeneration) + `,`, + `ALB:` + strings.Replace(this.ALB.String(), "ALBStatus", "ALBStatus", 1) + `,`, + `ALBs:` + repeatedStringForALBs + `,`, + `}`, + }, "") + return s +} +func (this *RolloutStrategy) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&RolloutStrategy{`, + `BlueGreen:` + strings.Replace(this.BlueGreen.String(), "BlueGreenStrategy", "BlueGreenStrategy", 1) + `,`, + `Canary:` + strings.Replace(this.Canary.String(), "CanaryStrategy", "CanaryStrategy", 1) + `,`, + `}`, + }, "") + return s +} +func (this *RolloutTrafficRouting) String() string { + if this == nil { + return "nil" + } + repeatedStringForManagedRoutes := "[]MangedRoutes{" + for _, f := range this.ManagedRoutes { + repeatedStringForManagedRoutes += strings.Replace(strings.Replace(f.String(), "MangedRoutes", "MangedRoutes", 1), `&`, ``, 1) + "," + } + repeatedStringForManagedRoutes += "}" + keysForPlugins := make([]string, 0, len(this.Plugins)) + for k := range this.Plugins { + keysForPlugins = append(keysForPlugins, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForPlugins) + mapStringForPlugins := "map[string]encoding_json.RawMessage{" + for _, k := range keysForPlugins { + mapStringForPlugins += fmt.Sprintf("%v: %v,", k, this.Plugins[k]) + } + mapStringForPlugins += "}" + s := strings.Join([]string{`&RolloutTrafficRouting{`, + `Istio:` + strings.Replace(this.Istio.String(), "IstioTrafficRouting", "IstioTrafficRouting", 1) + `,`, + `Nginx:` + strings.Replace(this.Nginx.String(), "NginxTrafficRouting", "NginxTrafficRouting", 1) + `,`, + `ALB:` + strings.Replace(this.ALB.String(), "ALBTrafficRouting", "ALBTrafficRouting", 1) + `,`, + `SMI:` + strings.Replace(this.SMI.String(), "SMITrafficRouting", "SMITrafficRouting", 1) + `,`, + `Ambassador:` + strings.Replace(this.Ambassador.String(), "AmbassadorTrafficRouting", "AmbassadorTrafficRouting", 1) + `,`, + `AppMesh:` + strings.Replace(this.AppMesh.String(), "AppMeshTrafficRouting", "AppMeshTrafficRouting", 1) + `,`, + `Traefik:` + strings.Replace(this.Traefik.String(), "TraefikTrafficRouting", "TraefikTrafficRouting", 1) + `,`, + `ManagedRoutes:` + repeatedStringForManagedRoutes + `,`, + `Apisix:` + strings.Replace(this.Apisix.String(), "ApisixTrafficRouting", "ApisixTrafficRouting", 1) + `,`, + `Plugins:` + mapStringForPlugins + `,`, + `}`, + }, "") + return s +} +func (this *RouteMatch) String() string { + if this == nil { + return "nil" + } + keysForHeaders := make([]string, 0, len(this.Headers)) + for k := range this.Headers { + keysForHeaders = append(keysForHeaders, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForHeaders) + mapStringForHeaders := "map[string]StringMatch{" + for _, k := range keysForHeaders { + mapStringForHeaders += fmt.Sprintf("%v: %v,", k, this.Headers[k]) + } + mapStringForHeaders += "}" + s := strings.Join([]string{`&RouteMatch{`, + `Method:` + strings.Replace(this.Method.String(), "StringMatch", "StringMatch", 1) + `,`, + `Path:` + strings.Replace(this.Path.String(), "StringMatch", "StringMatch", 1) + `,`, + `Headers:` + mapStringForHeaders + `,`, + `}`, + }, "") + return s +} +func (this *RunSummary) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&RunSummary{`, + `Count:` + fmt.Sprintf("%v", this.Count) + `,`, + `Successful:` + fmt.Sprintf("%v", this.Successful) + `,`, + `Failed:` + fmt.Sprintf("%v", this.Failed) + `,`, + `Inconclusive:` + fmt.Sprintf("%v", this.Inconclusive) + `,`, + `Error:` + fmt.Sprintf("%v", this.Error) + `,`, + `}`, + }, "") + return s +} +func (this *SMITrafficRouting) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SMITrafficRouting{`, + `RootService:` + fmt.Sprintf("%v", this.RootService) + `,`, + `TrafficSplitName:` + fmt.Sprintf("%v", this.TrafficSplitName) + `,`, + `}`, + }, "") + return s +} +func (this *ScopeDetail) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ScopeDetail{`, + `Scope:` + fmt.Sprintf("%v", this.Scope) + `,`, + `Region:` + fmt.Sprintf("%v", this.Region) + `,`, + `Step:` + fmt.Sprintf("%v", this.Step) + `,`, + `Start:` + fmt.Sprintf("%v", this.Start) + `,`, + `End:` + fmt.Sprintf("%v", this.End) + `,`, + `}`, + }, "") + return s +} +func (this *SecretKeyRef) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SecretKeyRef{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `Key:` + fmt.Sprintf("%v", this.Key) + `,`, + `}`, + }, "") + return s +} +func (this *SetCanaryScale) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SetCanaryScale{`, + `Weight:` + valueToStringGenerated(this.Weight) + `,`, + `Replicas:` + valueToStringGenerated(this.Replicas) + `,`, + `MatchTrafficWeight:` + fmt.Sprintf("%v", this.MatchTrafficWeight) + `,`, + `}`, + }, "") + return s +} +func (this *SetHeaderRoute) String() string { + if this == nil { + return "nil" + } + repeatedStringForMatch := "[]HeaderRoutingMatch{" + for _, f := range this.Match { + repeatedStringForMatch += strings.Replace(strings.Replace(f.String(), "HeaderRoutingMatch", "HeaderRoutingMatch", 1), `&`, ``, 1) + "," + } + repeatedStringForMatch += "}" + s := strings.Join([]string{`&SetHeaderRoute{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `Match:` + repeatedStringForMatch + `,`, + `}`, + }, "") + return s +} +func (this *SetMirrorRoute) String() string { + if this == nil { + return "nil" + } + repeatedStringForMatch := "[]RouteMatch{" + for _, f := range this.Match { + repeatedStringForMatch += strings.Replace(strings.Replace(f.String(), "RouteMatch", "RouteMatch", 1), `&`, ``, 1) + "," + } + repeatedStringForMatch += "}" + s := strings.Join([]string{`&SetMirrorRoute{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `Match:` + repeatedStringForMatch + `,`, + `Percentage:` + valueToStringGenerated(this.Percentage) + `,`, + `}`, + }, "") + return s +} +func (this *Sigv4Config) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Sigv4Config{`, + `Region:` + fmt.Sprintf("%v", this.Region) + `,`, + `Profile:` + fmt.Sprintf("%v", this.Profile) + `,`, + `RoleARN:` + fmt.Sprintf("%v", this.RoleARN) + `,`, + `}`, + }, "") + return s +} +func (this *SkyWalkingMetric) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SkyWalkingMetric{`, + `Address:` + fmt.Sprintf("%v", this.Address) + `,`, + `Query:` + fmt.Sprintf("%v", this.Query) + `,`, + `Interval:` + fmt.Sprintf("%v", this.Interval) + `,`, + `}`, + }, "") + return s +} +func (this *StickinessConfig) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&StickinessConfig{`, + `Enabled:` + fmt.Sprintf("%v", this.Enabled) + `,`, + `DurationSeconds:` + fmt.Sprintf("%v", this.DurationSeconds) + `,`, + `}`, + }, "") + return s +} +func (this *StringMatch) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&StringMatch{`, + `Exact:` + fmt.Sprintf("%v", this.Exact) + `,`, + `Prefix:` + fmt.Sprintf("%v", this.Prefix) + `,`, + `Regex:` + fmt.Sprintf("%v", this.Regex) + `,`, + `}`, + }, "") + return s +} +func (this *TCPRoute) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TCPRoute{`, + `Port:` + fmt.Sprintf("%v", this.Port) + `,`, + `}`, + }, "") + return s +} +func (this *TLSRoute) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TLSRoute{`, + `Port:` + fmt.Sprintf("%v", this.Port) + `,`, + `SNIHosts:` + fmt.Sprintf("%v", this.SNIHosts) + `,`, + `}`, + }, "") + return s +} +func (this *TemplateService) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TemplateService{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `}`, + }, "") + return s +} +func (this *TemplateSpec) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TemplateSpec{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `Replicas:` + valueToStringGenerated(this.Replicas) + `,`, + `MinReadySeconds:` + fmt.Sprintf("%v", this.MinReadySeconds) + `,`, + `Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "v1.LabelSelector", 1) + `,`, + `Template:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Template), "PodTemplateSpec", "v12.PodTemplateSpec", 1), `&`, ``, 1) + `,`, + `Service:` + strings.Replace(this.Service.String(), "TemplateService", "TemplateService", 1) + `,`, + `}`, + }, "") + return s +} +func (this *TemplateStatus) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TemplateStatus{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`, + `UpdatedReplicas:` + fmt.Sprintf("%v", this.UpdatedReplicas) + `,`, + `ReadyReplicas:` + fmt.Sprintf("%v", this.ReadyReplicas) + `,`, + `AvailableReplicas:` + fmt.Sprintf("%v", this.AvailableReplicas) + `,`, + `CollisionCount:` + valueToStringGenerated(this.CollisionCount) + `,`, + `Status:` + fmt.Sprintf("%v", this.Status) + `,`, + `Message:` + fmt.Sprintf("%v", this.Message) + `,`, + `LastTransitionTime:` + strings.Replace(fmt.Sprintf("%v", this.LastTransitionTime), "Time", "v1.Time", 1) + `,`, + `ServiceName:` + fmt.Sprintf("%v", this.ServiceName) + `,`, + `PodTemplateHash:` + fmt.Sprintf("%v", this.PodTemplateHash) + `,`, + `}`, + }, "") + return s +} +func (this *TraefikTrafficRouting) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TraefikTrafficRouting{`, + `WeightedTraefikServiceName:` + fmt.Sprintf("%v", this.WeightedTraefikServiceName) + `,`, + `}`, + }, "") + return s +} +func (this *TrafficWeights) String() string { + if this == nil { + return "nil" + } + repeatedStringForAdditional := "[]WeightDestination{" + for _, f := range this.Additional { + repeatedStringForAdditional += strings.Replace(strings.Replace(f.String(), "WeightDestination", "WeightDestination", 1), `&`, ``, 1) + "," + } + repeatedStringForAdditional += "}" + s := strings.Join([]string{`&TrafficWeights{`, + `Canary:` + strings.Replace(strings.Replace(this.Canary.String(), "WeightDestination", "WeightDestination", 1), `&`, ``, 1) + `,`, + `Stable:` + strings.Replace(strings.Replace(this.Stable.String(), "WeightDestination", "WeightDestination", 1), `&`, ``, 1) + `,`, + `Additional:` + repeatedStringForAdditional + `,`, + `Verified:` + valueToStringGenerated(this.Verified) + `,`, + `}`, + }, "") + return s +} +func (this *ValueFrom) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ValueFrom{`, + `SecretKeyRef:` + strings.Replace(this.SecretKeyRef.String(), "SecretKeyRef", "SecretKeyRef", 1) + `,`, + `FieldRef:` + strings.Replace(this.FieldRef.String(), "FieldRef", "FieldRef", 1) + `,`, + `}`, + }, "") + return s +} +func (this *WavefrontMetric) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&WavefrontMetric{`, + `Address:` + fmt.Sprintf("%v", this.Address) + `,`, + `Query:` + fmt.Sprintf("%v", this.Query) + `,`, + `}`, + }, "") + return s +} +func (this *WebMetric) String() string { + if this == nil { + return "nil" + } + repeatedStringForHeaders := "[]WebMetricHeader{" + for _, f := range this.Headers { + repeatedStringForHeaders += strings.Replace(strings.Replace(f.String(), "WebMetricHeader", "WebMetricHeader", 1), `&`, ``, 1) + "," + } + repeatedStringForHeaders += "}" + s := strings.Join([]string{`&WebMetric{`, + `Method:` + fmt.Sprintf("%v", this.Method) + `,`, + `URL:` + fmt.Sprintf("%v", this.URL) + `,`, + `Headers:` + repeatedStringForHeaders + `,`, + `Body:` + fmt.Sprintf("%v", this.Body) + `,`, + `TimeoutSeconds:` + fmt.Sprintf("%v", this.TimeoutSeconds) + `,`, + `JSONPath:` + fmt.Sprintf("%v", this.JSONPath) + `,`, + `Insecure:` + fmt.Sprintf("%v", this.Insecure) + `,`, + `JSONBody:` + valueToStringGenerated(this.JSONBody) + `,`, + `}`, + }, "") + return s +} +func (this *WebMetricHeader) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&WebMetricHeader{`, + `Key:` + fmt.Sprintf("%v", this.Key) + `,`, + `Value:` + fmt.Sprintf("%v", this.Value) + `,`, + `}`, + }, "") + return s +} +func (this *WeightDestination) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&WeightDestination{`, + `Weight:` + fmt.Sprintf("%v", this.Weight) + `,`, + `ServiceName:` + fmt.Sprintf("%v", this.ServiceName) + `,`, + `PodTemplateHash:` + fmt.Sprintf("%v", this.PodTemplateHash) + `,`, + `}`, + }, "") + return s +} +func valueToStringGenerated(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *ALBStatus) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ALBStatus: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ALBStatus: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LoadBalancer", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.LoadBalancer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CanaryTargetGroup", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.CanaryTargetGroup.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StableTargetGroup", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.StableTargetGroup.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ingress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Ingress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ALBTrafficRouting) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ALBTrafficRouting: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ALBTrafficRouting: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ingress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Ingress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ServicePort", wireType) + } + m.ServicePort = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ServicePort |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RootService", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RootService = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AnnotationPrefix", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AnnotationPrefix = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StickinessConfig", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.StickinessConfig == nil { + m.StickinessConfig = &StickinessConfig{} + } + if err := m.StickinessConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ingresses", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Ingresses = append(m.Ingresses, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AmbassadorTrafficRouting) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AmbassadorTrafficRouting: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AmbassadorTrafficRouting: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Mappings", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Mappings = append(m.Mappings, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AnalysisRun) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AnalysisRun: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AnalysisRun: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AnalysisRunArgument) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AnalysisRunArgument: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AnalysisRunArgument: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Value = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValueFrom", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ValueFrom == nil { + m.ValueFrom = &ArgumentValueFrom{} + } + if err := m.ValueFrom.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AnalysisRunList) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AnalysisRunList: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AnalysisRunList: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Items = append(m.Items, AnalysisRun{}) + if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AnalysisRunMetadata) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AnalysisRunMetadata: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AnalysisRunMetadata: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Labels == nil { + m.Labels = make(map[string]string) + } + var mapkey string + var mapvalue string + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthGenerated + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return ErrInvalidLengthGenerated + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var stringLenmapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapvalue |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapvalue := int(stringLenmapvalue) + if intStringLenmapvalue < 0 { + return ErrInvalidLengthGenerated + } + postStringIndexmapvalue := iNdEx + intStringLenmapvalue + if postStringIndexmapvalue < 0 { + return ErrInvalidLengthGenerated + } + if postStringIndexmapvalue > l { + return io.ErrUnexpectedEOF + } + mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) + iNdEx = postStringIndexmapvalue + } else { + iNdEx = entryPreIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.Labels[mapkey] = mapvalue + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Annotations", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Annotations == nil { + m.Annotations = make(map[string]string) + } + var mapkey string + var mapvalue string + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthGenerated + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return ErrInvalidLengthGenerated + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var stringLenmapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapvalue |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapvalue := int(stringLenmapvalue) + if intStringLenmapvalue < 0 { + return ErrInvalidLengthGenerated + } + postStringIndexmapvalue := iNdEx + intStringLenmapvalue + if postStringIndexmapvalue < 0 { + return ErrInvalidLengthGenerated + } + if postStringIndexmapvalue > l { + return io.ErrUnexpectedEOF + } + mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) + iNdEx = postStringIndexmapvalue + } else { + iNdEx = entryPreIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.Annotations[mapkey] = mapvalue + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AnalysisRunSpec) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AnalysisRunSpec: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AnalysisRunSpec: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metrics", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Metrics = append(m.Metrics, Metric{}) + if err := m.Metrics[len(m.Metrics)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Args", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Args = append(m.Args, Argument{}) + if err := m.Args[len(m.Args)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Terminate", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Terminate = bool(v != 0) + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DryRun", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DryRun = append(m.DryRun, DryRun{}) + if err := m.DryRun[len(m.DryRun)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MeasurementRetention", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MeasurementRetention = append(m.MeasurementRetention, MeasurementRetention{}) + if err := m.MeasurementRetention[len(m.MeasurementRetention)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AnalysisRunStatus) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AnalysisRunStatus: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AnalysisRunStatus: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Phase", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Phase = AnalysisPhase(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Message = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MetricResults", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MetricResults = append(m.MetricResults, MetricResult{}) + if err := m.MetricResults[len(m.MetricResults)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StartedAt", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.StartedAt == nil { + m.StartedAt = &v1.Time{} + } + if err := m.StartedAt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RunSummary", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.RunSummary.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DryRunSummary", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DryRunSummary == nil { + m.DryRunSummary = &RunSummary{} + } + if err := m.DryRunSummary.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AnalysisRunStrategy) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AnalysisRunStrategy: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AnalysisRunStrategy: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SuccessfulRunHistoryLimit", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.SuccessfulRunHistoryLimit = &v + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field UnsuccessfulRunHistoryLimit", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.UnsuccessfulRunHistoryLimit = &v + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AnalysisTemplate) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AnalysisTemplate: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AnalysisTemplate: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AnalysisTemplateList) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AnalysisTemplateList: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AnalysisTemplateList: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Items = append(m.Items, AnalysisTemplate{}) + if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AnalysisTemplateSpec) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AnalysisTemplateSpec: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AnalysisTemplateSpec: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metrics", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Metrics = append(m.Metrics, Metric{}) + if err := m.Metrics[len(m.Metrics)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Args", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Args = append(m.Args, Argument{}) + if err := m.Args[len(m.Args)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DryRun", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DryRun = append(m.DryRun, DryRun{}) + if err := m.DryRun[len(m.DryRun)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MeasurementRetention", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MeasurementRetention = append(m.MeasurementRetention, MeasurementRetention{}) + if err := m.MeasurementRetention[len(m.MeasurementRetention)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AntiAffinity) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AntiAffinity: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AntiAffinity: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PreferredDuringSchedulingIgnoredDuringExecution", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PreferredDuringSchedulingIgnoredDuringExecution == nil { + m.PreferredDuringSchedulingIgnoredDuringExecution = &PreferredDuringSchedulingIgnoredDuringExecution{} + } + if err := m.PreferredDuringSchedulingIgnoredDuringExecution.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RequiredDuringSchedulingIgnoredDuringExecution", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RequiredDuringSchedulingIgnoredDuringExecution == nil { + m.RequiredDuringSchedulingIgnoredDuringExecution = &RequiredDuringSchedulingIgnoredDuringExecution{} + } + if err := m.RequiredDuringSchedulingIgnoredDuringExecution.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ApisixRoute) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ApisixRoute: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ApisixRoute: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Rules", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Rules = append(m.Rules, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ApisixTrafficRouting) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ApisixTrafficRouting: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ApisixTrafficRouting: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Route", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Route == nil { + m.Route = &ApisixRoute{} + } + if err := m.Route.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AppMeshTrafficRouting) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AppMeshTrafficRouting: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AppMeshTrafficRouting: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field VirtualService", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.VirtualService == nil { + m.VirtualService = &AppMeshVirtualService{} + } + if err := m.VirtualService.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field VirtualNodeGroup", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.VirtualNodeGroup == nil { + m.VirtualNodeGroup = &AppMeshVirtualNodeGroup{} + } + if err := m.VirtualNodeGroup.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AppMeshVirtualNodeGroup) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AppMeshVirtualNodeGroup: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AppMeshVirtualNodeGroup: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CanaryVirtualNodeRef", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.CanaryVirtualNodeRef == nil { + m.CanaryVirtualNodeRef = &AppMeshVirtualNodeReference{} + } + if err := m.CanaryVirtualNodeRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StableVirtualNodeRef", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.StableVirtualNodeRef == nil { + m.StableVirtualNodeRef = &AppMeshVirtualNodeReference{} + } + if err := m.StableVirtualNodeRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AppMeshVirtualNodeReference) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AppMeshVirtualNodeReference: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AppMeshVirtualNodeReference: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AppMeshVirtualService) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AppMeshVirtualService: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AppMeshVirtualService: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Routes", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Routes = append(m.Routes, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Argument) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Argument: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Argument: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(dAtA[iNdEx:postIndex]) + m.Value = &s + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValueFrom", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ValueFrom == nil { + m.ValueFrom = &ValueFrom{} + } + if err := m.ValueFrom.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ArgumentValueFrom) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ArgumentValueFrom: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ArgumentValueFrom: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PodTemplateHashValue", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := ValueFromPodTemplateHash(dAtA[iNdEx:postIndex]) + m.PodTemplateHashValue = &s + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldRef", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.FieldRef == nil { + m.FieldRef = &FieldRef{} + } + if err := m.FieldRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AwsResourceRef) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AwsResourceRef: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AwsResourceRef: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ARN", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ARN = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FullName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FullName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BlueGreenStatus) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BlueGreenStatus: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BlueGreenStatus: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PreviewSelector", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PreviewSelector = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ActiveSelector", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ActiveSelector = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ScaleUpPreviewCheckPoint", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.ScaleUpPreviewCheckPoint = bool(v != 0) + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PrePromotionAnalysisRunStatus", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PrePromotionAnalysisRunStatus == nil { + m.PrePromotionAnalysisRunStatus = &RolloutAnalysisRunStatus{} + } + if err := m.PrePromotionAnalysisRunStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PostPromotionAnalysisRunStatus", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PostPromotionAnalysisRunStatus == nil { + m.PostPromotionAnalysisRunStatus = &RolloutAnalysisRunStatus{} + } + if err := m.PostPromotionAnalysisRunStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BlueGreenStrategy) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BlueGreenStrategy: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BlueGreenStrategy: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ActiveService", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ActiveService = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PreviewService", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PreviewService = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PreviewReplicaCount", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.PreviewReplicaCount = &v + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AutoPromotionEnabled", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.AutoPromotionEnabled = &b + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AutoPromotionSeconds", wireType) + } + m.AutoPromotionSeconds = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.AutoPromotionSeconds |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MaxUnavailable", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.MaxUnavailable == nil { + m.MaxUnavailable = &intstr.IntOrString{} + } + if err := m.MaxUnavailable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ScaleDownDelaySeconds", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.ScaleDownDelaySeconds = &v + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ScaleDownDelayRevisionLimit", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.ScaleDownDelayRevisionLimit = &v + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PrePromotionAnalysis", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PrePromotionAnalysis == nil { + m.PrePromotionAnalysis = &RolloutAnalysis{} + } + if err := m.PrePromotionAnalysis.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AntiAffinity", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AntiAffinity == nil { + m.AntiAffinity = &AntiAffinity{} + } + if err := m.AntiAffinity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PostPromotionAnalysis", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PostPromotionAnalysis == nil { + m.PostPromotionAnalysis = &RolloutAnalysis{} + } + if err := m.PostPromotionAnalysis.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PreviewMetadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PreviewMetadata == nil { + m.PreviewMetadata = &PodTemplateMetadata{} + } + if err := m.PreviewMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ActiveMetadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ActiveMetadata == nil { + m.ActiveMetadata = &PodTemplateMetadata{} + } + if err := m.ActiveMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 14: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AbortScaleDownDelaySeconds", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.AbortScaleDownDelaySeconds = &v + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CanaryStatus) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CanaryStatus: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CanaryStatus: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CurrentStepAnalysisRunStatus", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.CurrentStepAnalysisRunStatus == nil { + m.CurrentStepAnalysisRunStatus = &RolloutAnalysisRunStatus{} + } + if err := m.CurrentStepAnalysisRunStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CurrentBackgroundAnalysisRunStatus", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.CurrentBackgroundAnalysisRunStatus == nil { + m.CurrentBackgroundAnalysisRunStatus = &RolloutAnalysisRunStatus{} + } + if err := m.CurrentBackgroundAnalysisRunStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CurrentExperiment", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.CurrentExperiment = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Weights", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Weights == nil { + m.Weights = &TrafficWeights{} + } + if err := m.Weights.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StablePingPong", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StablePingPong = PingPongType(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CanaryStep) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CanaryStep: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CanaryStep: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SetWeight", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.SetWeight = &v + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pause", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Pause == nil { + m.Pause = &RolloutPause{} + } + if err := m.Pause.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Experiment", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Experiment == nil { + m.Experiment = &RolloutExperimentStep{} + } + if err := m.Experiment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Analysis", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Analysis == nil { + m.Analysis = &RolloutAnalysis{} + } + if err := m.Analysis.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SetCanaryScale", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SetCanaryScale == nil { + m.SetCanaryScale = &SetCanaryScale{} + } + if err := m.SetCanaryScale.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SetHeaderRoute", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SetHeaderRoute == nil { + m.SetHeaderRoute = &SetHeaderRoute{} + } + if err := m.SetHeaderRoute.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SetMirrorRoute", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SetMirrorRoute == nil { + m.SetMirrorRoute = &SetMirrorRoute{} + } + if err := m.SetMirrorRoute.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CanaryStrategy) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CanaryStrategy: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CanaryStrategy: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CanaryService", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.CanaryService = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StableService", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StableService = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Steps", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Steps = append(m.Steps, CanaryStep{}) + if err := m.Steps[len(m.Steps)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TrafficRouting", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TrafficRouting == nil { + m.TrafficRouting = &RolloutTrafficRouting{} + } + if err := m.TrafficRouting.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MaxUnavailable", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.MaxUnavailable == nil { + m.MaxUnavailable = &intstr.IntOrString{} + } + if err := m.MaxUnavailable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MaxSurge", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.MaxSurge == nil { + m.MaxSurge = &intstr.IntOrString{} + } + if err := m.MaxSurge.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Analysis", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Analysis == nil { + m.Analysis = &RolloutAnalysisBackground{} + } + if err := m.Analysis.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AntiAffinity", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AntiAffinity == nil { + m.AntiAffinity = &AntiAffinity{} + } + if err := m.AntiAffinity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CanaryMetadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.CanaryMetadata == nil { + m.CanaryMetadata = &PodTemplateMetadata{} + } + if err := m.CanaryMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StableMetadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.StableMetadata == nil { + m.StableMetadata = &PodTemplateMetadata{} + } + if err := m.StableMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ScaleDownDelaySeconds", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.ScaleDownDelaySeconds = &v + case 12: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ScaleDownDelayRevisionLimit", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.ScaleDownDelayRevisionLimit = &v + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AbortScaleDownDelaySeconds", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.AbortScaleDownDelaySeconds = &v + case 14: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DynamicStableScale", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.DynamicStableScale = bool(v != 0) + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PingPong", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PingPong == nil { + m.PingPong = &PingPongSpec{} + } + if err := m.PingPong.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 16: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MinPodsPerReplicaSet", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.MinPodsPerReplicaSet = &v + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CloudWatchMetric) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CloudWatchMetric: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CloudWatchMetric: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Interval", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Interval = DurationString(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MetricDataQueries", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MetricDataQueries = append(m.MetricDataQueries, CloudWatchMetricDataQuery{}) + if err := m.MetricDataQueries[len(m.MetricDataQueries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CloudWatchMetricDataQuery) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CloudWatchMetricDataQuery: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CloudWatchMetricDataQuery: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Id = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Expression", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(dAtA[iNdEx:postIndex]) + m.Expression = &s + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Label", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(dAtA[iNdEx:postIndex]) + m.Label = &s + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MetricStat", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.MetricStat == nil { + m.MetricStat = &CloudWatchMetricStat{} + } + if err := m.MetricStat.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Period", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Period == nil { + m.Period = &intstr.IntOrString{} + } + if err := m.Period.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ReturnData", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.ReturnData = &b + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CloudWatchMetricStat) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CloudWatchMetricStat: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CloudWatchMetricStat: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metric", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Metric.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Period", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Period.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Stat", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Stat = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Unit", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Unit = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CloudWatchMetricStatMetric) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CloudWatchMetricStatMetric: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CloudWatchMetricStatMetric: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Dimensions", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Dimensions = append(m.Dimensions, CloudWatchMetricStatMetricDimension{}) + if err := m.Dimensions[len(m.Dimensions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MetricName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MetricName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(dAtA[iNdEx:postIndex]) + m.Namespace = &s + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CloudWatchMetricStatMetricDimension) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CloudWatchMetricStatMetricDimension: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CloudWatchMetricStatMetricDimension: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Value = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClusterAnalysisTemplate) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClusterAnalysisTemplate: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClusterAnalysisTemplate: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClusterAnalysisTemplateList) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClusterAnalysisTemplateList: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClusterAnalysisTemplateList: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Items = append(m.Items, ClusterAnalysisTemplate{}) + if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DatadogMetric) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DatadogMetric: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DatadogMetric: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Interval", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Interval = DurationString(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Query = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ApiVersion", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ApiVersion = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DryRun) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DryRun: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DryRun: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MetricName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MetricName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Experiment) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Experiment: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Experiment: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ExperimentAnalysisRunStatus) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ExperimentAnalysisRunStatus: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExperimentAnalysisRunStatus: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AnalysisRun", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AnalysisRun = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Phase", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Phase = AnalysisPhase(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Message = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ExperimentAnalysisTemplateRef) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ExperimentAnalysisTemplateRef: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExperimentAnalysisTemplateRef: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TemplateName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TemplateName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ClusterScope", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.ClusterScope = bool(v != 0) + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Args", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Args = append(m.Args, Argument{}) + if err := m.Args[len(m.Args)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RequiredForCompletion", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.RequiredForCompletion = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ExperimentCondition) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ExperimentCondition: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExperimentCondition: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Type = ExperimentConditionType(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Status = k8s_io_api_core_v1.ConditionStatus(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LastUpdateTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.LastUpdateTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Reason = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Message = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ExperimentList) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ExperimentList: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExperimentList: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Items = append(m.Items, Experiment{}) + if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ExperimentSpec) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ExperimentSpec: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExperimentSpec: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Templates", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Templates = append(m.Templates, TemplateSpec{}) + if err := m.Templates[len(m.Templates)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Duration", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Duration = DurationString(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ProgressDeadlineSeconds", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.ProgressDeadlineSeconds = &v + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Terminate", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Terminate = bool(v != 0) + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Analyses", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Analyses = append(m.Analyses, ExperimentAnalysisTemplateRef{}) + if err := m.Analyses[len(m.Analyses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ScaleDownDelaySeconds", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.ScaleDownDelaySeconds = &v + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DryRun", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DryRun = append(m.DryRun, DryRun{}) + if err := m.DryRun[len(m.DryRun)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MeasurementRetention", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MeasurementRetention = append(m.MeasurementRetention, MeasurementRetention{}) + if err := m.MeasurementRetention[len(m.MeasurementRetention)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ExperimentStatus) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ExperimentStatus: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExperimentStatus: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Phase", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Phase = AnalysisPhase(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Message = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TemplateStatuses", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TemplateStatuses = append(m.TemplateStatuses, TemplateStatus{}) + if err := m.TemplateStatuses[len(m.TemplateStatuses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AvailableAt", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AvailableAt == nil { + m.AvailableAt = &v1.Time{} + } + if err := m.AvailableAt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Conditions = append(m.Conditions, ExperimentCondition{}) + if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AnalysisRuns", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AnalysisRuns = append(m.AnalysisRuns, ExperimentAnalysisRunStatus{}) + if err := m.AnalysisRuns[len(m.AnalysisRuns)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *FieldRef) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: FieldRef: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: FieldRef: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldPath", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FieldPath = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GraphiteMetric) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GraphiteMetric: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GraphiteMetric: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Address = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Query = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *HeaderRoutingMatch) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: HeaderRoutingMatch: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: HeaderRoutingMatch: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field HeaderName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.HeaderName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field HeaderValue", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.HeaderValue == nil { + m.HeaderValue = &StringMatch{} + } + if err := m.HeaderValue.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *InfluxdbMetric) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: InfluxdbMetric: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: InfluxdbMetric: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Profile", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Profile = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Query = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *IstioDestinationRule) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: IstioDestinationRule: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: IstioDestinationRule: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CanarySubsetName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.CanarySubsetName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StableSubsetName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StableSubsetName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *IstioTrafficRouting) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: IstioTrafficRouting: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: IstioTrafficRouting: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field VirtualService", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.VirtualService == nil { + m.VirtualService = &IstioVirtualService{} + } + if err := m.VirtualService.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DestinationRule", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DestinationRule == nil { + m.DestinationRule = &IstioDestinationRule{} + } + if err := m.DestinationRule.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field VirtualServices", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.VirtualServices = append(m.VirtualServices, IstioVirtualService{}) + if err := m.VirtualServices[len(m.VirtualServices)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *IstioVirtualService) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: IstioVirtualService: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: IstioVirtualService: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Routes", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Routes = append(m.Routes, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TLSRoutes", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TLSRoutes = append(m.TLSRoutes, TLSRoute{}) + if err := m.TLSRoutes[len(m.TLSRoutes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TCPRoutes", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TCPRoutes = append(m.TCPRoutes, TCPRoute{}) + if err := m.TCPRoutes[len(m.TCPRoutes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *JobMetric) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: JobMetric: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: JobMetric: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *KayentaMetric) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: KayentaMetric: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: KayentaMetric: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Address = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Application", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Application = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CanaryConfigName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.CanaryConfigName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MetricsAccountName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MetricsAccountName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ConfigurationAccountName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ConfigurationAccountName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StorageAccountName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StorageAccountName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Threshold", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Threshold.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Scopes", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Scopes = append(m.Scopes, KayentaScope{}) + if err := m.Scopes[len(m.Scopes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *KayentaScope) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: KayentaScope: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: KayentaScope: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ControlScope", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ControlScope.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExperimentScope", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ExperimentScope.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *KayentaThreshold) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: KayentaThreshold: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: KayentaThreshold: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Pass", wireType) + } + m.Pass = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Pass |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Marginal", wireType) + } + m.Marginal = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Marginal |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MangedRoutes) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MangedRoutes: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MangedRoutes: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Measurement) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Measurement: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Measurement: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Phase", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Phase = AnalysisPhase(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Message = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StartedAt", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.StartedAt == nil { + m.StartedAt = &v1.Time{} + } + if err := m.StartedAt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FinishedAt", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.FinishedAt == nil { + m.FinishedAt = &v1.Time{} + } + if err := m.FinishedAt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Value = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Metadata == nil { + m.Metadata = make(map[string]string) + } + var mapkey string + var mapvalue string + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthGenerated + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return ErrInvalidLengthGenerated + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var stringLenmapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapvalue |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapvalue := int(stringLenmapvalue) + if intStringLenmapvalue < 0 { + return ErrInvalidLengthGenerated + } + postStringIndexmapvalue := iNdEx + intStringLenmapvalue + if postStringIndexmapvalue < 0 { + return ErrInvalidLengthGenerated + } + if postStringIndexmapvalue > l { + return io.ErrUnexpectedEOF + } + mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) + iNdEx = postStringIndexmapvalue + } else { + iNdEx = entryPreIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.Metadata[mapkey] = mapvalue + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ResumeAt", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ResumeAt == nil { + m.ResumeAt = &v1.Time{} + } + if err := m.ResumeAt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MeasurementRetention) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MeasurementRetention: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MeasurementRetention: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MetricName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MetricName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType) + } + m.Limit = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Limit |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Metric) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Metric: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Metric: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Interval", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Interval = DurationString(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field InitialDelay", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.InitialDelay = DurationString(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Count == nil { + m.Count = &intstr.IntOrString{} + } + if err := m.Count.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SuccessCondition", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SuccessCondition = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FailureCondition", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FailureCondition = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FailureLimit", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.FailureLimit == nil { + m.FailureLimit = &intstr.IntOrString{} + } + if err := m.FailureLimit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field InconclusiveLimit", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.InconclusiveLimit == nil { + m.InconclusiveLimit = &intstr.IntOrString{} + } + if err := m.InconclusiveLimit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ConsecutiveErrorLimit", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ConsecutiveErrorLimit == nil { + m.ConsecutiveErrorLimit = &intstr.IntOrString{} + } + if err := m.ConsecutiveErrorLimit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Provider", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Provider.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MetricProvider) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MetricProvider: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MetricProvider: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Prometheus", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Prometheus == nil { + m.Prometheus = &PrometheusMetric{} + } + if err := m.Prometheus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Kayenta", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Kayenta == nil { + m.Kayenta = &KayentaMetric{} + } + if err := m.Kayenta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Web", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Web == nil { + m.Web = &WebMetric{} + } + if err := m.Web.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Datadog", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Datadog == nil { + m.Datadog = &DatadogMetric{} + } + if err := m.Datadog.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Wavefront", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Wavefront == nil { + m.Wavefront = &WavefrontMetric{} + } + if err := m.Wavefront.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NewRelic", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NewRelic == nil { + m.NewRelic = &NewRelicMetric{} + } + if err := m.NewRelic.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Job", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Job == nil { + m.Job = &JobMetric{} + } + if err := m.Job.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CloudWatch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.CloudWatch == nil { + m.CloudWatch = &CloudWatchMetric{} + } + if err := m.CloudWatch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Graphite", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Graphite == nil { + m.Graphite = &GraphiteMetric{} + } + if err := m.Graphite.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Influxdb", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Influxdb == nil { + m.Influxdb = &InfluxdbMetric{} + } + if err := m.Influxdb.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SkyWalking", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SkyWalking == nil { + m.SkyWalking = &SkyWalkingMetric{} + } + if err := m.SkyWalking.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Plugin", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Plugin == nil { + m.Plugin = make(map[string]encoding_json.RawMessage) + } + var mapkey string + mapvalue := []byte{} + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthGenerated + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return ErrInvalidLengthGenerated + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var mapbyteLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapbyteLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intMapbyteLen := int(mapbyteLen) + if intMapbyteLen < 0 { + return ErrInvalidLengthGenerated + } + postbytesIndex := iNdEx + intMapbyteLen + if postbytesIndex < 0 { + return ErrInvalidLengthGenerated + } + if postbytesIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue = make([]byte, mapbyteLen) + copy(mapvalue, dAtA[iNdEx:postbytesIndex]) + iNdEx = postbytesIndex + } else { + iNdEx = entryPreIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.Plugin[mapkey] = ((encoding_json.RawMessage)(mapvalue)) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MetricResult) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MetricResult: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MetricResult: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Phase", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Phase = AnalysisPhase(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Measurements", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Measurements = append(m.Measurements, Measurement{}) + if err := m.Measurements[len(m.Measurements)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Message = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType) + } + m.Count = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Count |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Successful", wireType) + } + m.Successful = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Successful |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Failed", wireType) + } + m.Failed = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Failed |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Inconclusive", wireType) + } + m.Inconclusive = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Inconclusive |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 9: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) + } + m.Error = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Error |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 10: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ConsecutiveError", wireType) + } + m.ConsecutiveError = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ConsecutiveError |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 11: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DryRun", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.DryRun = bool(v != 0) + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Metadata == nil { + m.Metadata = make(map[string]string) + } + var mapkey string + var mapvalue string + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthGenerated + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return ErrInvalidLengthGenerated + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var stringLenmapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapvalue |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapvalue := int(stringLenmapvalue) + if intStringLenmapvalue < 0 { + return ErrInvalidLengthGenerated + } + postStringIndexmapvalue := iNdEx + intStringLenmapvalue + if postStringIndexmapvalue < 0 { + return ErrInvalidLengthGenerated + } + if postStringIndexmapvalue > l { + return io.ErrUnexpectedEOF + } + mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) + iNdEx = postStringIndexmapvalue + } else { + iNdEx = entryPreIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.Metadata[mapkey] = mapvalue + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NewRelicMetric) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NewRelicMetric: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NewRelicMetric: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Profile", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Profile = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Query = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NginxTrafficRouting) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NginxTrafficRouting: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NginxTrafficRouting: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AnnotationPrefix", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AnnotationPrefix = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StableIngress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StableIngress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AdditionalIngressAnnotations", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AdditionalIngressAnnotations == nil { + m.AdditionalIngressAnnotations = make(map[string]string) + } + var mapkey string + var mapvalue string + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthGenerated + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return ErrInvalidLengthGenerated + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var stringLenmapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapvalue |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapvalue := int(stringLenmapvalue) + if intStringLenmapvalue < 0 { + return ErrInvalidLengthGenerated + } + postStringIndexmapvalue := iNdEx + intStringLenmapvalue + if postStringIndexmapvalue < 0 { + return ErrInvalidLengthGenerated + } + if postStringIndexmapvalue > l { + return io.ErrUnexpectedEOF + } + mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) + iNdEx = postStringIndexmapvalue + } else { + iNdEx = entryPreIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.AdditionalIngressAnnotations[mapkey] = mapvalue + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StableIngresses", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StableIngresses = append(m.StableIngresses, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ObjectRef) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ObjectRef: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ObjectRef: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field APIVersion", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.APIVersion = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Kind = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PauseCondition) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: PauseCondition: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PauseCondition: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Reason = PauseReason(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StartTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.StartTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PingPongSpec) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: PingPongSpec: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PingPongSpec: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PingService", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PingService = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PongService", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PongService = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PodTemplateMetadata) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: PodTemplateMetadata: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PodTemplateMetadata: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Labels == nil { + m.Labels = make(map[string]string) + } + var mapkey string + var mapvalue string + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthGenerated + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return ErrInvalidLengthGenerated + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var stringLenmapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapvalue |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapvalue := int(stringLenmapvalue) + if intStringLenmapvalue < 0 { + return ErrInvalidLengthGenerated + } + postStringIndexmapvalue := iNdEx + intStringLenmapvalue + if postStringIndexmapvalue < 0 { + return ErrInvalidLengthGenerated + } + if postStringIndexmapvalue > l { + return io.ErrUnexpectedEOF + } + mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) + iNdEx = postStringIndexmapvalue + } else { + iNdEx = entryPreIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.Labels[mapkey] = mapvalue + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Annotations", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Annotations == nil { + m.Annotations = make(map[string]string) + } + var mapkey string + var mapvalue string + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthGenerated + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return ErrInvalidLengthGenerated + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var stringLenmapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapvalue |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapvalue := int(stringLenmapvalue) + if intStringLenmapvalue < 0 { + return ErrInvalidLengthGenerated + } + postStringIndexmapvalue := iNdEx + intStringLenmapvalue + if postStringIndexmapvalue < 0 { + return ErrInvalidLengthGenerated + } + if postStringIndexmapvalue > l { + return io.ErrUnexpectedEOF + } + mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) + iNdEx = postStringIndexmapvalue + } else { + iNdEx = entryPreIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.Annotations[mapkey] = mapvalue + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PreferredDuringSchedulingIgnoredDuringExecution) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: PreferredDuringSchedulingIgnoredDuringExecution: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PreferredDuringSchedulingIgnoredDuringExecution: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Weight", wireType) + } + m.Weight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Weight |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PrometheusAuth) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: PrometheusAuth: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PrometheusAuth: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sigv4", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Sigv4.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PrometheusMetric) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: PrometheusMetric: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PrometheusMetric: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Address = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Query = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Authentication", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Authentication.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Timeout", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Timeout = &v + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Insecure", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Insecure = bool(v != 0) + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Headers", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Headers = append(m.Headers, WebMetricHeader{}) + if err := m.Headers[len(m.Headers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RequiredDuringSchedulingIgnoredDuringExecution) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RequiredDuringSchedulingIgnoredDuringExecution: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RequiredDuringSchedulingIgnoredDuringExecution: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RollbackWindowSpec) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RollbackWindowSpec: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RollbackWindowSpec: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Revisions", wireType) + } + m.Revisions = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Revisions |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Rollout) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Rollout: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Rollout: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RolloutAnalysis) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RolloutAnalysis: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RolloutAnalysis: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Templates", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Templates = append(m.Templates, RolloutAnalysisTemplate{}) + if err := m.Templates[len(m.Templates)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Args", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Args = append(m.Args, AnalysisRunArgument{}) + if err := m.Args[len(m.Args)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DryRun", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DryRun = append(m.DryRun, DryRun{}) + if err := m.DryRun[len(m.DryRun)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MeasurementRetention", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MeasurementRetention = append(m.MeasurementRetention, MeasurementRetention{}) + if err := m.MeasurementRetention[len(m.MeasurementRetention)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AnalysisRunMetadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.AnalysisRunMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RolloutAnalysisBackground) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RolloutAnalysisBackground: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RolloutAnalysisBackground: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RolloutAnalysis", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.RolloutAnalysis.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StartingStep", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.StartingStep = &v + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RolloutAnalysisRunStatus) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RolloutAnalysisRunStatus: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RolloutAnalysisRunStatus: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Status = AnalysisPhase(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Message = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RolloutAnalysisTemplate) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RolloutAnalysisTemplate: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RolloutAnalysisTemplate: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TemplateName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TemplateName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ClusterScope", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.ClusterScope = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RolloutCondition) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RolloutCondition: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RolloutCondition: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Type = RolloutConditionType(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Status = k8s_io_api_core_v1.ConditionStatus(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LastUpdateTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.LastUpdateTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Reason = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Message = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RolloutExperimentStep) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RolloutExperimentStep: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RolloutExperimentStep: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Templates", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Templates = append(m.Templates, RolloutExperimentTemplate{}) + if err := m.Templates[len(m.Templates)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Duration", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Duration = DurationString(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Analyses", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Analyses = append(m.Analyses, RolloutExperimentStepAnalysisTemplateRef{}) + if err := m.Analyses[len(m.Analyses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RolloutExperimentStepAnalysisTemplateRef) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RolloutExperimentStepAnalysisTemplateRef: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RolloutExperimentStepAnalysisTemplateRef: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TemplateName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TemplateName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ClusterScope", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.ClusterScope = bool(v != 0) + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Args", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Args = append(m.Args, AnalysisRunArgument{}) + if err := m.Args[len(m.Args)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RequiredForCompletion", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.RequiredForCompletion = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RolloutExperimentTemplate) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RolloutExperimentTemplate: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RolloutExperimentTemplate: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SpecRef", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SpecRef = ReplicaSetSpecRef(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Replicas = &v + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Selector == nil { + m.Selector = &v1.LabelSelector{} + } + if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Weight", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Weight = &v + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Service", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Service == nil { + m.Service = &TemplateService{} + } + if err := m.Service.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RolloutList) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RolloutList: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RolloutList: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Items = append(m.Items, Rollout{}) + if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RolloutPause) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RolloutPause: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RolloutPause: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Duration", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Duration == nil { + m.Duration = &intstr.IntOrString{} + } + if err := m.Duration.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RolloutSpec) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RolloutSpec: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RolloutSpec: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Replicas = &v + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Selector == nil { + m.Selector = &v1.LabelSelector{} + } + if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MinReadySeconds", wireType) + } + m.MinReadySeconds = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MinReadySeconds |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Strategy", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Strategy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RevisionHistoryLimit", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.RevisionHistoryLimit = &v + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Paused", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Paused = bool(v != 0) + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ProgressDeadlineSeconds", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.ProgressDeadlineSeconds = &v + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RestartAt", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RestartAt == nil { + m.RestartAt = &v1.Time{} + } + if err := m.RestartAt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WorkloadRef", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.WorkloadRef == nil { + m.WorkloadRef = &ObjectRef{} + } + if err := m.WorkloadRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Analysis", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Analysis == nil { + m.Analysis = &AnalysisRunStrategy{} + } + if err := m.Analysis.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 12: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ProgressDeadlineAbort", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.ProgressDeadlineAbort = bool(v != 0) + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RollbackWindow", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RollbackWindow == nil { + m.RollbackWindow = &RollbackWindowSpec{} + } + if err := m.RollbackWindow.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RolloutStatus) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RolloutStatus: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RolloutStatus: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Abort", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Abort = bool(v != 0) + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PauseConditions", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PauseConditions = append(m.PauseConditions, PauseCondition{}) + if err := m.PauseConditions[len(m.PauseConditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ControllerPause", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.ControllerPause = bool(v != 0) + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AbortedAt", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AbortedAt == nil { + m.AbortedAt = &v1.Time{} + } + if err := m.AbortedAt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CurrentPodHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.CurrentPodHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CurrentStepHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.CurrentStepHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType) + } + m.Replicas = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Replicas |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field UpdatedReplicas", wireType) + } + m.UpdatedReplicas = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.UpdatedReplicas |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 9: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ReadyReplicas", wireType) + } + m.ReadyReplicas = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ReadyReplicas |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 10: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AvailableReplicas", wireType) + } + m.AvailableReplicas = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.AvailableReplicas |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 11: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CurrentStepIndex", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.CurrentStepIndex = &v + case 12: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CollisionCount", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.CollisionCount = &v + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ObservedGeneration = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Conditions = append(m.Conditions, RolloutCondition{}) + if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Canary", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Canary.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlueGreen", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.BlueGreen.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 17: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field HPAReplicas", wireType) + } + m.HPAReplicas = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.HPAReplicas |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 18: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Selector = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 19: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StableRS", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StableRS = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 20: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RestartedAt", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RestartedAt == nil { + m.RestartedAt = &v1.Time{} + } + if err := m.RestartedAt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 21: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PromoteFull", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.PromoteFull = bool(v != 0) + case 22: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Phase", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Phase = RolloutPhase(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 23: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Message = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 24: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WorkloadObservedGeneration", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.WorkloadObservedGeneration = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 25: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ALB", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ALB == nil { + m.ALB = &ALBStatus{} + } + if err := m.ALB.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 26: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ALBs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ALBs = append(m.ALBs, ALBStatus{}) + if err := m.ALBs[len(m.ALBs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RolloutStrategy) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RolloutStrategy: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RolloutStrategy: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlueGreen", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BlueGreen == nil { + m.BlueGreen = &BlueGreenStrategy{} + } + if err := m.BlueGreen.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Canary", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Canary == nil { + m.Canary = &CanaryStrategy{} + } + if err := m.Canary.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RolloutTrafficRouting) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RolloutTrafficRouting: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RolloutTrafficRouting: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Istio", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Istio == nil { + m.Istio = &IstioTrafficRouting{} + } + if err := m.Istio.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Nginx", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Nginx == nil { + m.Nginx = &NginxTrafficRouting{} + } + if err := m.Nginx.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ALB", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ALB == nil { + m.ALB = &ALBTrafficRouting{} + } + if err := m.ALB.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SMI", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SMI == nil { + m.SMI = &SMITrafficRouting{} + } + if err := m.SMI.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ambassador", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Ambassador == nil { + m.Ambassador = &AmbassadorTrafficRouting{} + } + if err := m.Ambassador.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AppMesh", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AppMesh == nil { + m.AppMesh = &AppMeshTrafficRouting{} + } + if err := m.AppMesh.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Traefik", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Traefik == nil { + m.Traefik = &TraefikTrafficRouting{} + } + if err := m.Traefik.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ManagedRoutes", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ManagedRoutes = append(m.ManagedRoutes, MangedRoutes{}) + if err := m.ManagedRoutes[len(m.ManagedRoutes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Apisix", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Apisix == nil { + m.Apisix = &ApisixTrafficRouting{} + } + if err := m.Apisix.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Plugins", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Plugins == nil { + m.Plugins = make(map[string]encoding_json.RawMessage) + } + var mapkey string + mapvalue := []byte{} + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthGenerated + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return ErrInvalidLengthGenerated + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var mapbyteLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapbyteLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intMapbyteLen := int(mapbyteLen) + if intMapbyteLen < 0 { + return ErrInvalidLengthGenerated + } + postbytesIndex := iNdEx + intMapbyteLen + if postbytesIndex < 0 { + return ErrInvalidLengthGenerated + } + if postbytesIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue = make([]byte, mapbyteLen) + copy(mapvalue, dAtA[iNdEx:postbytesIndex]) + iNdEx = postbytesIndex + } else { + iNdEx = entryPreIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.Plugins[mapkey] = ((encoding_json.RawMessage)(mapvalue)) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RouteMatch) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RouteMatch: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RouteMatch: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Method", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Method == nil { + m.Method = &StringMatch{} + } + if err := m.Method.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Path == nil { + m.Path = &StringMatch{} + } + if err := m.Path.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Headers", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Headers == nil { + m.Headers = make(map[string]StringMatch) + } + var mapkey string + mapvalue := &StringMatch{} + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthGenerated + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return ErrInvalidLengthGenerated + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapmsglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLengthGenerated + } + postmsgIndex := iNdEx + mapmsglen + if postmsgIndex < 0 { + return ErrInvalidLengthGenerated + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue = &StringMatch{} + if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + } else { + iNdEx = entryPreIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.Headers[mapkey] = *mapvalue + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RunSummary) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RunSummary: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RunSummary: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType) + } + m.Count = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Count |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Successful", wireType) + } + m.Successful = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Successful |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Failed", wireType) + } + m.Failed = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Failed |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Inconclusive", wireType) + } + m.Inconclusive = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Inconclusive |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) + } + m.Error = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Error |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SMITrafficRouting) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SMITrafficRouting: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SMITrafficRouting: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RootService", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RootService = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TrafficSplitName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TrafficSplitName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ScopeDetail) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ScopeDetail: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ScopeDetail: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Scope", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Scope = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Region = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Step", wireType) + } + m.Step = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Step |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Start", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Start = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field End", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.End = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SecretKeyRef) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SecretKeyRef: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SecretKeyRef: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SetCanaryScale) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SetCanaryScale: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SetCanaryScale: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Weight", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Weight = &v + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Replicas = &v + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MatchTrafficWeight", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.MatchTrafficWeight = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SetHeaderRoute) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SetHeaderRoute: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SetHeaderRoute: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Match", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Match = append(m.Match, HeaderRoutingMatch{}) + if err := m.Match[len(m.Match)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SetMirrorRoute) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SetMirrorRoute: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SetMirrorRoute: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Match", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Match = append(m.Match, RouteMatch{}) + if err := m.Match[len(m.Match)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Percentage", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Percentage = &v + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Sigv4Config) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Sigv4Config: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Sigv4Config: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Region = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Profile", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Profile = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RoleARN", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RoleARN = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SkyWalkingMetric) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SkyWalkingMetric: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SkyWalkingMetric: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Address = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Query = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Interval", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Interval = DurationString(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *StickinessConfig) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: StickinessConfig: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StickinessConfig: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Enabled", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Enabled = bool(v != 0) + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DurationSeconds", wireType) + } + m.DurationSeconds = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.DurationSeconds |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *StringMatch) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: StringMatch: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StringMatch: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Exact", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Exact = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Prefix", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Prefix = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Regex", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Regex = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TCPRoute) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: TCPRoute: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TCPRoute: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType) + } + m.Port = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Port |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TLSRoute) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: TLSRoute: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TLSRoute: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType) + } + m.Port = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Port |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SNIHosts", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SNIHosts = append(m.SNIHosts, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TemplateService) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: TemplateService: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TemplateService: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TemplateSpec) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: TemplateSpec: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TemplateSpec: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Replicas = &v + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MinReadySeconds", wireType) + } + m.MinReadySeconds = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MinReadySeconds |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Selector == nil { + m.Selector = &v1.LabelSelector{} + } + if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Service", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Service == nil { + m.Service = &TemplateService{} + } + if err := m.Service.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TemplateStatus) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: TemplateStatus: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TemplateStatus: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType) + } + m.Replicas = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Replicas |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field UpdatedReplicas", wireType) + } + m.UpdatedReplicas = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.UpdatedReplicas |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ReadyReplicas", wireType) + } + m.ReadyReplicas = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ReadyReplicas |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AvailableReplicas", wireType) + } + m.AvailableReplicas = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.AvailableReplicas |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CollisionCount", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.CollisionCount = &v + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Status = TemplateStatusCode(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Message = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.LastTransitionTime == nil { + m.LastTransitionTime = &v1.Time{} + } + if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ServiceName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ServiceName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PodTemplateHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PodTemplateHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TraefikTrafficRouting) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: TraefikTrafficRouting: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TraefikTrafficRouting: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WeightedTraefikServiceName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.WeightedTraefikServiceName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TrafficWeights) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: TrafficWeights: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TrafficWeights: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Canary", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Canary.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Stable", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Stable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Additional", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Additional = append(m.Additional, WeightDestination{}) + if err := m.Additional[len(m.Additional)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Verified", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.Verified = &b + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ValueFrom) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ValueFrom: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ValueFrom: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SecretKeyRef", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SecretKeyRef == nil { + m.SecretKeyRef = &SecretKeyRef{} + } + if err := m.SecretKeyRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldRef", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.FieldRef == nil { + m.FieldRef = &FieldRef{} + } + if err := m.FieldRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *WavefrontMetric) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: WavefrontMetric: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: WavefrontMetric: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Address = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Query = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *WebMetric) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: WebMetric: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: WebMetric: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Method", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Method = WebMetricMethod(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field URL", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.URL = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Headers", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Headers = append(m.Headers, WebMetricHeader{}) + if err := m.Headers[len(m.Headers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Body = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TimeoutSeconds", wireType) + } + m.TimeoutSeconds = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TimeoutSeconds |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field JSONPath", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.JSONPath = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Insecure", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Insecure = bool(v != 0) + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field JSONBody", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.JSONBody = append(m.JSONBody[:0], dAtA[iNdEx:postIndex]...) + if m.JSONBody == nil { + m.JSONBody = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *WebMetricHeader) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: WebMetricHeader: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: WebMetricHeader: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Value = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *WeightDestination) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: WeightDestination: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: WeightDestination: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Weight", wireType) + } + m.Weight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Weight |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ServiceName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ServiceName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PodTemplateHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PodTemplateHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipGenerated(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGenerated + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGenerated + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGenerated + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthGenerated + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupGenerated + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthGenerated + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupGenerated = fmt.Errorf("proto: unexpected end of group") +) diff --git a/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1/generated.proto b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1/generated.proto new file mode 100644 index 000000000000..687db1c72643 --- /dev/null +++ b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1/generated.proto @@ -0,0 +1,1866 @@ +/* +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. +*/ + + +// This file was autogenerated by go-to-protobuf. Do not edit it manually! + +syntax = "proto2"; + +package github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1; + +import "k8s.io/api/batch/v1/generated.proto"; +import "k8s.io/api/core/v1/generated.proto"; +import "k8s.io/apimachinery/pkg/apis/meta/v1/generated.proto"; +import "k8s.io/apimachinery/pkg/runtime/generated.proto"; +import "k8s.io/apimachinery/pkg/runtime/schema/generated.proto"; +import "k8s.io/apimachinery/pkg/util/intstr/generated.proto"; + +// Package-wide variables from generator "generated". +option go_package = "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1"; + +message ALBStatus { + optional AwsResourceRef loadBalancer = 1; + + optional AwsResourceRef canaryTargetGroup = 2; + + optional AwsResourceRef stableTargetGroup = 3; + + optional string ingress = 4; +} + +// ALBTrafficRouting configuration for ALB ingress controller to control traffic routing +message ALBTrafficRouting { + // Ingress refers to the name of an `Ingress` resource in the same namespace as the `Rollout` + optional string ingress = 1; + + // ServicePort refers to the port that the Ingress action should route traffic to + optional int32 servicePort = 2; + + // RootService references the service in the ingress to the controller should add the action to + optional string rootService = 3; + + // AnnotationPrefix has to match the configured annotation prefix on the alb ingress controller + // +optional + optional string annotationPrefix = 4; + + // StickinessConfig refers to the duration-based stickiness of the target groups associated with an `Ingress` + // +optional + optional StickinessConfig stickinessConfig = 5; + + // Ingresses refers to the name of an `Ingress` resource in the same namespace as the `Rollout` in a multi ingress scenario + // +optional + repeated string ingresses = 6; +} + +// AmbassadorTrafficRouting defines the configuration required to use Ambassador as traffic +// router +message AmbassadorTrafficRouting { + // Mappings refer to the name of the Ambassador Mappings used to route traffic to the + // service + repeated string mappings = 1; +} + +// AnalysisRun is an instantiation of an AnalysisTemplate +// +genclient +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +// +kubebuilder:resource:path=analysisruns, shortName=ar +// +kubebuilder:printcolumn:name="Status",type="string",JSONPath=".status.phase",description="AnalysisRun status" +// +kubebuilder:printcolumn:name="Age",type="date",JSONPath=".metadata.creationTimestamp",description="Time since resource was created" +message AnalysisRun { + optional k8s.io.apimachinery.pkg.apis.meta.v1.ObjectMeta metadata = 1; + + optional AnalysisRunSpec spec = 2; + + optional AnalysisRunStatus status = 3; +} + +// AnalysisRunArgument argument to add to analysisRun +message AnalysisRunArgument { + // Name argument name + optional string name = 1; + + // Value a hardcoded value for the argument. This field is a one of field with valueFrom + optional string value = 2; + + // ValueFrom A reference to where the value is stored. This field is a one of field with valueFrom + optional ArgumentValueFrom valueFrom = 3; +} + +// AnalysisRunList is a list of AnalysisTemplate resources +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +message AnalysisRunList { + optional k8s.io.apimachinery.pkg.apis.meta.v1.ListMeta metadata = 1; + + repeated AnalysisRun items = 2; +} + +// AnalysisRunMetadata extra labels to add to the AnalysisRun +message AnalysisRunMetadata { + // Labels Additional labels to add to the AnalysisRun + // +optional + map labels = 1; + + // Annotations additional annotations to add to the AnalysisRun + // +optional + map annotations = 2; +} + +// AnalysisRunSpec is the spec for a AnalysisRun resource +message AnalysisRunSpec { + // Metrics contains the list of metrics to query as part of an analysis run + // +patchMergeKey=name + // +patchStrategy=merge + repeated Metric metrics = 1; + + // Args are the list of arguments used in this run + // +optional + // +patchMergeKey=name + // +patchStrategy=merge + repeated Argument args = 2; + + // Terminate is used to prematurely stop the run (e.g. rollout completed and analysis is no longer desired) + optional bool terminate = 3; + + // DryRun object contains the settings for running the analysis in Dry-Run mode + // +patchMergeKey=metricName + // +patchStrategy=merge + // +optional + repeated DryRun dryRun = 4; + + // MeasurementRetention object contains the settings for retaining the number of measurements during the analysis + // +patchMergeKey=metricName + // +patchStrategy=merge + // +optional + repeated MeasurementRetention measurementRetention = 5; +} + +// AnalysisRunStatus is the status for a AnalysisRun resource +message AnalysisRunStatus { + // Phase is the status of the analysis run + optional string phase = 1; + + // Message is a message explaining current status + optional string message = 2; + + // MetricResults contains the metrics collected during the run + repeated MetricResult metricResults = 3; + + // StartedAt indicates when the analysisRun first started + optional k8s.io.apimachinery.pkg.apis.meta.v1.Time startedAt = 4; + + // RunSummary contains the final results from the metric executions + optional RunSummary runSummary = 5; + + // DryRunSummary contains the final results from the metric executions in the dry-run mode + optional RunSummary dryRunSummary = 6; +} + +// AnalysisRunStrategy configuration for the analysis runs and experiments to retain +message AnalysisRunStrategy { + // SuccessfulRunHistoryLimit limits the number of old successful analysis runs and experiments to be retained in a history + optional int32 successfulRunHistoryLimit = 1; + + // UnsuccessfulRunHistoryLimit limits the number of old unsuccessful analysis runs and experiments to be retained in a history. + // Stages for unsuccessful: "Error", "Failed", "Inconclusive" + optional int32 unsuccessfulRunHistoryLimit = 2; +} + +// AnalysisTemplate holds the template for performing canary analysis +// +genclient +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +// +kubebuilder:resource:path=analysistemplates,shortName=at +// +kubebuilder:printcolumn:name="Age",type="date",JSONPath=".metadata.creationTimestamp",description="Time since resource was created" +message AnalysisTemplate { + optional k8s.io.apimachinery.pkg.apis.meta.v1.ObjectMeta metadata = 1; + + optional AnalysisTemplateSpec spec = 2; +} + +// AnalysisTemplateList is a list of AnalysisTemplate resources +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +message AnalysisTemplateList { + optional k8s.io.apimachinery.pkg.apis.meta.v1.ListMeta metadata = 1; + + repeated AnalysisTemplate items = 2; +} + +// AnalysisTemplateSpec is the specification for a AnalysisTemplate resource +message AnalysisTemplateSpec { + // Metrics contains the list of metrics to query as part of an analysis run + // +patchMergeKey=name + // +patchStrategy=merge + repeated Metric metrics = 1; + + // Args are the list of arguments to the template + // +patchMergeKey=name + // +patchStrategy=merge + // +optional + repeated Argument args = 2; + + // DryRun object contains the settings for running the analysis in Dry-Run mode + // +patchMergeKey=metricName + // +patchStrategy=merge + // +optional + repeated DryRun dryRun = 3; + + // MeasurementRetention object contains the settings for retaining the number of measurements during the analysis + // +patchMergeKey=metricName + // +patchStrategy=merge + // +optional + repeated MeasurementRetention measurementRetention = 4; +} + +// AntiAffinity defines which inter-pod scheduling rule to use for anti-affinity injection +message AntiAffinity { + // +optional + optional PreferredDuringSchedulingIgnoredDuringExecution preferredDuringSchedulingIgnoredDuringExecution = 1; + + // +optional + optional RequiredDuringSchedulingIgnoredDuringExecution requiredDuringSchedulingIgnoredDuringExecution = 2; +} + +// ApisixRoute holds information on the APISIX Route the rollout needs to modify +message ApisixRoute { + // Name refer to the name of the APISIX Route used to route traffic to the service + optional string name = 1; + + // RuleRef a list of the APISIX Route HTTP Rules used to route traffic to the service + repeated string rules = 2; +} + +// ApisixTrafficRouting defines the configuration required to use APISIX as traffic router +message ApisixTrafficRouting { + // Route references an Apisix Route to modify to shape traffic + optional ApisixRoute route = 1; +} + +// AppMeshTrafficRouting configuration for AWS AppMesh service mesh to enable fine grain configuration +message AppMeshTrafficRouting { + // VirtualService references an AppMesh VirtualService and VirtualRouter to modify to shape traffic + optional AppMeshVirtualService virtualService = 1; + + // VirtualNodeGroup references an AppMesh Route targets that are formed by a set of VirtualNodes that are used to shape traffic + optional AppMeshVirtualNodeGroup virtualNodeGroup = 2; +} + +// AppMeshVirtualNodeGroup holds information about targets used for routing traffic to a virtual service +message AppMeshVirtualNodeGroup { + // CanaryVirtualNodeRef is the virtual node ref to modify labels with canary ReplicaSet pod template hash value + optional AppMeshVirtualNodeReference canaryVirtualNodeRef = 1; + + // StableVirtualNodeRef is the virtual node name to modify labels with stable ReplicaSet pod template hash value + optional AppMeshVirtualNodeReference stableVirtualNodeRef = 2; +} + +// AppMeshVirtualNodeReference holds a reference to VirtualNode.appmesh.k8s.aws +message AppMeshVirtualNodeReference { + // Name is the name of VirtualNode CR + optional string name = 1; +} + +// AppMeshVirtualService holds information on the virtual service the rollout needs to modify +message AppMeshVirtualService { + // Name is the name of virtual service + optional string name = 1; + + // Routes is list of HTTP routes within virtual router associated with virtual service to edit. If omitted, virtual service must have a single route of this type. + repeated string routes = 2; +} + +// Argument is an argument to an AnalysisRun +message Argument { + // Name is the name of the argument + optional string name = 1; + + // Value is the value of the argument + // +optional + optional string value = 2; + + // ValueFrom is a reference to where a secret is stored. This field is one of the fields with valueFrom + // +optional + optional ValueFrom valueFrom = 3; +} + +// ArgumentValueFrom defines references to fields within resources to grab for the value (i.e. Pod Template Hash) +message ArgumentValueFrom { + // PodTemplateHashValue gets the value from one of the children ReplicaSet's Pod Template Hash + optional string podTemplateHashValue = 1; + + // FieldRef + optional FieldRef fieldRef = 2; +} + +message AwsResourceRef { + optional string name = 1; + + optional string arn = 2; + + // FullName is the full name of the resource + // +optional + optional string fullName = 3; +} + +// BlueGreenStatus status fields that only pertain to the blueGreen rollout +message BlueGreenStatus { + // PreviewSelector indicates which replicas set the preview service is serving traffic to + // +optional + optional string previewSelector = 1; + + // ActiveSelector indicates which replicas set the active service is serving traffic to + // +optional + optional string activeSelector = 2; + + // ScaleUpPreviewCheckPoint indicates that the Replicaset receiving traffic from the preview service is ready to be scaled up after the rollout is unpaused + // +optional + optional bool scaleUpPreviewCheckPoint = 3; + + // PrePromotionAnalysisRunStatus indicates the status of the current prepromotion analysis run + optional RolloutAnalysisRunStatus prePromotionAnalysisRunStatus = 4; + + // PostPromotionAnalysisRunStatus indicates the status of the current post promotion analysis run + optional RolloutAnalysisRunStatus postPromotionAnalysisRunStatus = 5; +} + +// BlueGreenStrategy defines parameters for Blue Green deployment +message BlueGreenStrategy { + // Name of the service that the rollout modifies as the active service. + optional string activeService = 1; + + // Name of the service that the rollout modifies as the preview service. + // +optional + optional string previewService = 2; + + // PreviewReplicaCount is the number of replicas to run for the preview stack before the + // switchover. Once the rollout is resumed the desired replicaset will be full scaled up before the switch occurs + // +optional + optional int32 previewReplicaCount = 3; + + // AutoPromotionEnabled indicates if the rollout should automatically promote the new ReplicaSet + // to the active service or enter a paused state. If not specified, the default value is true. + // +optional + optional bool autoPromotionEnabled = 4; + + // AutoPromotionSeconds is a duration in seconds in which to delay auto-promotion (default: 0). + // The countdown begins after the preview ReplicaSet have reached full availability. + // This option is ignored if autoPromotionEnabled is set to false. + // +optional + optional int32 autoPromotionSeconds = 5; + + // MaxUnavailable The maximum number of pods that can be unavailable during a restart operation. + // Defaults to 25% of total replicas. + // +optional + optional k8s.io.apimachinery.pkg.util.intstr.IntOrString maxUnavailable = 6; + + // ScaleDownDelaySeconds adds a delay before scaling down the previous replicaset. + // If omitted, the Rollout waits 30 seconds before scaling down the previous ReplicaSet. + // A minimum of 30 seconds is recommended to ensure IP table propagation across the nodes in + // a cluster. See https://github.com/argoproj/argo-rollouts/issues/19#issuecomment-476329960 for + // more information + // +optional + optional int32 scaleDownDelaySeconds = 7; + + // ScaleDownDelayRevisionLimit limits the number of old RS that can run at one time before getting scaled down + // +optional + optional int32 scaleDownDelayRevisionLimit = 8; + + // PrePromotionAnalysis configuration to run analysis before a selector switch + optional RolloutAnalysis prePromotionAnalysis = 9; + + // AntiAffinity enables anti-affinity rules for Blue Green deployment + // +optional + optional AntiAffinity antiAffinity = 10; + + // PostPromotionAnalysis configuration to run analysis after a selector switch + optional RolloutAnalysis postPromotionAnalysis = 11; + + // PreviewMetadata specify labels and annotations which will be attached to the preview pods for + // the duration which they act as a preview pod, and will be removed after + optional PodTemplateMetadata previewMetadata = 12; + + // ActiveMetadata specify labels and annotations which will be attached to the active pods for + // the duration which they act as a active pod, and will be removed after + optional PodTemplateMetadata activeMetadata = 13; + + // AbortScaleDownDelaySeconds adds a delay in second before scaling down the preview replicaset + // if update is aborted. 0 means not to scale down. + // Default is 30 second + // +optional + optional int32 abortScaleDownDelaySeconds = 14; +} + +// CanaryStatus status fields that only pertain to the canary rollout +message CanaryStatus { + // CurrentStepAnalysisRunStatus indicates the status of the current step analysis run + optional RolloutAnalysisRunStatus currentStepAnalysisRunStatus = 1; + + // CurrentBackgroundAnalysisRunStatus indicates the status of the current background analysis run + optional RolloutAnalysisRunStatus currentBackgroundAnalysisRunStatus = 2; + + // CurrentExperiment indicates the running experiment + optional string currentExperiment = 3; + + // Weights records the weights which have been set on traffic provider. Only valid when using traffic routing + optional TrafficWeights weights = 4; + + // StablePingPong For the ping-pong feature holds the current stable service, ping or pong + optional string stablePingPong = 5; +} + +// CanaryStep defines a step of a canary deployment. +message CanaryStep { + // SetWeight sets what percentage of the newRS should receive + optional int32 setWeight = 1; + + // Pause freezes the rollout by setting spec.Paused to true. + // A Rollout will resume when spec.Paused is reset to false. + // +optional + optional RolloutPause pause = 2; + + // Experiment defines the experiment object that should be created + optional RolloutExperimentStep experiment = 3; + + // Analysis defines the AnalysisRun that will run for a step + optional RolloutAnalysis analysis = 4; + + // SetCanaryScale defines how to scale the newRS without changing traffic weight + // +optional + optional SetCanaryScale setCanaryScale = 5; + + // SetHeaderRoute defines the route with specified header name to send 100% of traffic to the canary service + // +optional + optional SetHeaderRoute setHeaderRoute = 6; + + // SetMirrorRoutes Mirrors traffic that matches rules to a particular destination + // +optional + optional SetMirrorRoute setMirrorRoute = 8; +} + +// CanaryStrategy defines parameters for a Replica Based Canary +message CanaryStrategy { + // CanaryService holds the name of a service which selects pods with canary version and don't select any pods with stable version. + // +optional + optional string canaryService = 1; + + // StableService holds the name of a service which selects pods with stable version and don't select any pods with canary version. + // +optional + optional string stableService = 2; + + // Steps define the order of phases to execute the canary deployment + // +optional + repeated CanaryStep steps = 3; + + // TrafficRouting hosts all the supported service meshes supported to enable more fine-grained traffic routing + optional RolloutTrafficRouting trafficRouting = 4; + + // MaxUnavailable The maximum number of pods that can be unavailable during the update. + // Value can be an absolute number (ex: 5) or a percentage of total pods at the start of update (ex: 10%). + // Absolute number is calculated from percentage by rounding down. + // This can not be 0 if MaxSurge is 0. + // By default, a fixed value of 25% is used. + // Example: when this is set to 30%, the old RC can be scaled down by 30% + // immediately when the rolling update starts. Once new pods are ready, old RC + // can be scaled down further, followed by scaling up the new RC, ensuring + // that at least 70% of original number of pods are available at all times + // during the update. + // +optional + optional k8s.io.apimachinery.pkg.util.intstr.IntOrString maxUnavailable = 5; + + // MaxSurge The maximum number of pods that can be scheduled above the original number of + // pods. + // Value can be an absolute number (ex: 5) or a percentage of total pods at + // the start of the update (ex: 10%). This can not be 0 if MaxUnavailable is 0. + // Absolute number is calculated from percentage by rounding up. + // By default, a value of 25% is used. + // Example: when this is set to 30%, the new RC can be scaled up by 30% + // immediately when the rolling update starts. Once old pods have been killed, + // new RC can be scaled up further, ensuring that total number of pods running + // at any time during the update is at most 130% of original pods. + // +optional + optional k8s.io.apimachinery.pkg.util.intstr.IntOrString maxSurge = 6; + + // Analysis runs a separate analysisRun while all the steps execute. This is intended to be a continuous validation of the new ReplicaSet + optional RolloutAnalysisBackground analysis = 7; + + // AntiAffinity enables anti-affinity rules for Canary deployment + // +optional + optional AntiAffinity antiAffinity = 8; + + // CanaryMetadata specify labels and annotations which will be attached to the canary pods for + // the duration which they act as a canary, and will be removed after + optional PodTemplateMetadata canaryMetadata = 9; + + // StableMetadata specify labels and annotations which will be attached to the stable pods for + // the duration which they act as a canary, and will be removed after + optional PodTemplateMetadata stableMetadata = 10; + + // ScaleDownDelaySeconds adds a delay before scaling down the previous ReplicaSet when the + // canary strategy is used with traffic routing (default 30 seconds). A delay in scaling down + // the previous ReplicaSet is needed after switching the stable service selector to point to + // the new ReplicaSet, in order to give time for traffic providers to re-target the new pods. + // This value is ignored with basic, replica-weighted canary without traffic routing. + // +optional + optional int32 scaleDownDelaySeconds = 11; + + // ScaleDownDelayRevisionLimit limits the number of old RS that can run at one time before getting scaled down + // +optional + optional int32 scaleDownDelayRevisionLimit = 12; + + // AbortScaleDownDelaySeconds adds a delay in second before scaling down the canary pods when update + // is aborted for canary strategy with traffic routing (not applicable for basic canary). + // 0 means canary pods are not scaled down. + // Default is 30 seconds. + // +optional + optional int32 abortScaleDownDelaySeconds = 13; + + // DynamicStableScale is a traffic routing feature which dynamically scales the stable + // ReplicaSet to minimize total pods which are running during an update. This is calculated by + // scaling down the stable as traffic is increased to canary. When disabled (the default behavior) + // the stable ReplicaSet remains fully scaled to support instantaneous aborts. + optional bool dynamicStableScale = 14; + + // PingPongSpec holds the ping and pong services + optional PingPongSpec pingPong = 15; + + // Assuming the desired number of pods in a stable or canary ReplicaSet is not zero, then make sure it is at least + // MinPodsPerReplicaSet for High Availability. Only applicable for TrafficRoutedCanary + optional int32 minPodsPerReplicaSet = 16; +} + +// CloudWatchMetric defines the cloudwatch query to perform canary analysis +message CloudWatchMetric { + optional string interval = 1; + + repeated CloudWatchMetricDataQuery metricDataQueries = 2; +} + +// CloudWatchMetricDataQuery defines the cloudwatch query +message CloudWatchMetricDataQuery { + optional string id = 1; + + optional string expression = 2; + + optional string label = 3; + + optional CloudWatchMetricStat metricStat = 4; + + optional k8s.io.apimachinery.pkg.util.intstr.IntOrString period = 5; + + optional bool returnData = 6; +} + +message CloudWatchMetricStat { + optional CloudWatchMetricStatMetric metric = 1; + + optional k8s.io.apimachinery.pkg.util.intstr.IntOrString period = 2; + + optional string stat = 3; + + optional string unit = 4; +} + +message CloudWatchMetricStatMetric { + repeated CloudWatchMetricStatMetricDimension dimensions = 1; + + optional string metricName = 2; + + optional string namespace = 3; +} + +message CloudWatchMetricStatMetricDimension { + optional string name = 1; + + optional string value = 2; +} + +// ClusterAnalysisTemplate holds the template for performing canary analysis +// +genclient +// +genclient:nonNamespaced +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +// +kubebuilder:resource:path=clusteranalysistemplates,shortName=cat,scope=Cluster +// +kubebuilder:printcolumn:name="Age",type="date",JSONPath=".metadata.creationTimestamp",description="Time since resource was created" +message ClusterAnalysisTemplate { + optional k8s.io.apimachinery.pkg.apis.meta.v1.ObjectMeta metadata = 1; + + optional AnalysisTemplateSpec spec = 2; +} + +// AnalysisTemplateList is a list of AnalysisTemplate resources +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +message ClusterAnalysisTemplateList { + optional k8s.io.apimachinery.pkg.apis.meta.v1.ListMeta metadata = 1; + + repeated ClusterAnalysisTemplate items = 2; +} + +message DatadogMetric { + optional string interval = 1; + + optional string query = 2; + + // ApiVersion refers to the Datadog API version being used (default: v1). v1 will eventually be deprecated. + optional string apiVersion = 3; +} + +// DryRun defines the settings for running the analysis in Dry-Run mode. +message DryRun { + // Name of the metric which needs to be evaluated in the Dry-Run mode. Wildcard '*' is supported and denotes all + // the available metrics. + optional string metricName = 1; +} + +// Experiment is a specification for an Experiment resource +// +genclient +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +// +kubebuilder:resource:path=experiments,shortName=exp +// +kubebuilder:printcolumn:name="Status",type="string",JSONPath=".status.phase",description="Experiment status" +// +kubebuilder:printcolumn:name="Age",type="date",JSONPath=".metadata.creationTimestamp",description="Time since resource was created" +message Experiment { + optional k8s.io.apimachinery.pkg.apis.meta.v1.ObjectMeta metadata = 1; + + optional ExperimentSpec spec = 2; + + optional ExperimentStatus status = 3; +} + +message ExperimentAnalysisRunStatus { + // Name is the name of the analysis + optional string name = 1; + + // AnalysisRun is the name of the AnalysisRun + optional string analysisRun = 2; + + // Phase is the status of the AnalysisRun + optional string phase = 3; + + // Message is a message explaining the current status + optional string message = 4; +} + +message ExperimentAnalysisTemplateRef { + // Name is the name of the analysis + optional string name = 1; + + // TemplateName reference of the AnalysisTemplate name used by the Experiment to create the run + optional string templateName = 2; + + // Whether to look for the templateName at cluster scope or namespace scope + // +optional + optional bool clusterScope = 3; + + // Args are the arguments that will be added to the AnalysisRuns + // +optional + // +patchMergeKey=name + // +patchStrategy=merge + repeated Argument args = 4; + + // RequiredForCompletion blocks the Experiment from completing until the analysis has completed + optional bool requiredForCompletion = 5; +} + +// ExperimentCondition describes the state of a experiment at a certain point. +message ExperimentCondition { + // Type of deployment condition. + optional string type = 1; + + // Phase of the condition, one of True, False, Unknown. + optional string status = 2; + + // The last time this condition was updated. + optional k8s.io.apimachinery.pkg.apis.meta.v1.Time lastUpdateTime = 3; + + // Last time the condition transitioned from one status to another. + optional k8s.io.apimachinery.pkg.apis.meta.v1.Time lastTransitionTime = 4; + + // The reason for the condition's last transition. + optional string reason = 5; + + // A human readable message indicating details about the transition. + optional string message = 6; +} + +// ExperimentList is a list of Experiment resources +message ExperimentList { + optional k8s.io.apimachinery.pkg.apis.meta.v1.ListMeta metadata = 1; + + repeated Experiment items = 2; +} + +// ExperimentSpec is the spec for a Experiment resource +message ExperimentSpec { + // Templates are a list of PodSpecs that define the ReplicaSets that should be run during an experiment. + // +patchMergeKey=name + // +patchStrategy=merge + repeated TemplateSpec templates = 1; + + // Duration the amount of time for the experiment to run as a duration string (e.g. 30s, 5m, 1h). + // If omitted, the experiment will run indefinitely, stopped either via termination, or a failed analysis run. + // +optional + optional string duration = 2; + + // ProgressDeadlineSeconds The maximum time in seconds for a experiment to + // make progress before it is considered to be failed. Argo Rollouts will + // continue to process failed experiments and a condition with a + // ProgressDeadlineExceeded reason will be surfaced in the experiment status. + // Defaults to 600s. + // +optional + optional int32 progressDeadlineSeconds = 3; + + // Terminate is used to prematurely stop the experiment + optional bool terminate = 4; + + // Analyses references AnalysisTemplates to run during the experiment + // +patchMergeKey=name + // +patchStrategy=merge + repeated ExperimentAnalysisTemplateRef analyses = 5; + + // ScaleDownDelaySeconds adds a delay before scaling down the Experiment. + // If omitted, the Experiment waits 30 seconds before scaling down. + // A minimum of 30 seconds is recommended to ensure IP table propagation across the nodes in + // a cluster. See https://github.com/argoproj/argo-rollouts/issues/19#issuecomment-476329960 for + // more information + // +optional + optional int32 scaleDownDelaySeconds = 6; + + // DryRun object contains the settings for running the analysis in Dry-Run mode + // +patchMergeKey=metricName + // +patchStrategy=merge + // +optional + repeated DryRun dryRun = 7; + + // MeasurementRetention object contains the settings for retaining the number of measurements during the analysis + // +patchMergeKey=metricName + // +patchStrategy=merge + // +optional + repeated MeasurementRetention measurementRetention = 8; +} + +// ExperimentStatus is the status for a Experiment resource +message ExperimentStatus { + // Phase is the status of the experiment. Takes into consideration ReplicaSet degradations and + // AnalysisRun statuses + optional string phase = 1; + + // Message is an explanation for the current status + // +optional + optional string message = 2; + + // TemplateStatuses holds the ReplicaSet related statuses for individual templates + // +optional + repeated TemplateStatus templateStatuses = 3; + + // AvailableAt the time when all the templates become healthy and the experiment should start tracking the time to + // run for the duration of specificed in the spec. + // +optional + optional k8s.io.apimachinery.pkg.apis.meta.v1.Time availableAt = 4; + + // Conditions a list of conditions a experiment can have. + // +optional + repeated ExperimentCondition conditions = 5; + + // AnalysisRuns tracks the status of AnalysisRuns associated with this Experiment + // +optional + repeated ExperimentAnalysisRunStatus analysisRuns = 6; +} + +message FieldRef { + // Required: Path of the field to select in the specified API version + optional string fieldPath = 1; +} + +// GraphiteMetric defines the Graphite query to perform canary analysis +message GraphiteMetric { + // Address is the HTTP address and port of the Graphite server + optional string address = 1; + + // Query is a raw Graphite query to perform + optional string query = 2; +} + +message HeaderRoutingMatch { + // HeaderName the name of the request header + optional string headerName = 1; + + // HeaderValue the value of the header + optional StringMatch headerValue = 2; +} + +// InfluxdbMetric defines the InfluxDB Flux query to perform canary analysis +message InfluxdbMetric { + // Profile is the name of the secret holding InfluxDB account configuration + optional string profile = 1; + + // Query is a raw InfluxDB flux query to perform + optional string query = 2; +} + +// IstioDestinationRule is a reference to an Istio DestinationRule to modify and shape traffic +message IstioDestinationRule { + // Name holds the name of the DestinationRule + optional string name = 1; + + // CanarySubsetName is the subset name to modify labels with canary ReplicaSet pod template hash value + optional string canarySubsetName = 2; + + // StableSubsetName is the subset name to modify labels with stable ReplicaSet pod template hash value + optional string stableSubsetName = 3; +} + +// IstioTrafficRouting configuration for Istio service mesh to enable fine grain configuration +message IstioTrafficRouting { + // VirtualService references an Istio VirtualService to modify to shape traffic + optional IstioVirtualService virtualService = 1; + + // DestinationRule references an Istio DestinationRule to modify to shape traffic + optional IstioDestinationRule destinationRule = 2; + + // VirtualServices references a list of Istio VirtualService to modify to shape traffic + repeated IstioVirtualService virtualServices = 3; +} + +// IstioVirtualService holds information on the virtual service the rollout needs to modify +message IstioVirtualService { + // Name holds the name of the VirtualService + optional string name = 1; + + // A list of HTTP routes within VirtualService to edit. If omitted, VirtualService must have a single route of this type. + repeated string routes = 2; + + // A list of TLS/HTTPS routes within VirtualService to edit. If omitted, VirtualService must have a single route of this type. + repeated TLSRoute tlsRoutes = 3; + + // A list of TCP routes within VirtualService to edit. If omitted, VirtualService must have a single route of this type. + repeated TCPRoute tcpRoutes = 4; +} + +// JobMetric defines a job to run which acts as a metric +message JobMetric { + optional k8s.io.apimachinery.pkg.apis.meta.v1.ObjectMeta metadata = 1; + + optional k8s.io.api.batch.v1.JobSpec spec = 2; +} + +message KayentaMetric { + optional string address = 1; + + optional string application = 2; + + optional string canaryConfigName = 3; + + optional string metricsAccountName = 4; + + optional string configurationAccountName = 5; + + optional string storageAccountName = 6; + + optional KayentaThreshold threshold = 7; + + repeated KayentaScope scopes = 8; +} + +message KayentaScope { + optional string name = 1; + + optional ScopeDetail controlScope = 2; + + optional ScopeDetail experimentScope = 3; +} + +message KayentaThreshold { + optional int64 pass = 1; + + optional int64 marginal = 2; +} + +message MangedRoutes { + optional string name = 1; +} + +// Measurement is a point in time result value of a single metric, and the time it was measured +message Measurement { + // Phase is the status of this single measurement + optional string phase = 1; + + // Message contains a message describing current condition (e.g. error messages) + optional string message = 2; + + // StartedAt is the timestamp in which this measurement started to be measured + optional k8s.io.apimachinery.pkg.apis.meta.v1.Time startedAt = 3; + + // FinishedAt is the timestamp in which this measurement completed and value was collected + optional k8s.io.apimachinery.pkg.apis.meta.v1.Time finishedAt = 4; + + // Value is the measured value of the metric + optional string value = 5; + + // Metadata stores additional metadata about this metric result, used by the different providers + // (e.g. kayenta run ID, job name) + map metadata = 6; + + // ResumeAt is the timestamp when the analysisRun should try to resume the measurement + optional k8s.io.apimachinery.pkg.apis.meta.v1.Time resumeAt = 7; +} + +// MeasurementRetention defines the settings for retaining the number of measurements during the analysis. +message MeasurementRetention { + // MetricName is the name of the metric on which this retention policy should be applied. + optional string metricName = 1; + + // Limit is the maximum number of measurements to be retained for this given metric. + optional int32 limit = 2; +} + +// Metric defines a metric in which to perform analysis +message Metric { + // Name is the name of the metric + optional string name = 1; + + // Interval defines an interval string (e.g. 30s, 5m, 1h) between each measurement. + // If omitted, will perform a single measurement + optional string interval = 2; + + // InitialDelay how long the AnalysisRun should wait before starting this metric + optional string initialDelay = 3; + + // Count is the number of times to run the measurement. If both interval and count are omitted, + // the effective count is 1. If only interval is specified, metric runs indefinitely. + // If count > 1, interval must be specified. + optional k8s.io.apimachinery.pkg.util.intstr.IntOrString count = 4; + + // SuccessCondition is an expression which determines if a measurement is considered successful + // Expression is a goevaluate expression. The keyword `result` is a variable reference to the + // value of measurement. Results can be both structured data or primitive. + // Examples: + // result > 10 + // (result.requests_made * result.requests_succeeded / 100) >= 90 + optional string successCondition = 5; + + // FailureCondition is an expression which determines if a measurement is considered failed + // If both success and failure conditions are specified, and the measurement does not fall into + // either condition, the measurement is considered Inconclusive + optional string failureCondition = 6; + + // FailureLimit is the maximum number of times the measurement is allowed to fail, before the + // entire metric is considered Failed (default: 0) + optional k8s.io.apimachinery.pkg.util.intstr.IntOrString failureLimit = 7; + + // InconclusiveLimit is the maximum number of times the measurement is allowed to measure + // Inconclusive, before the entire metric is considered Inconclusive (default: 0) + optional k8s.io.apimachinery.pkg.util.intstr.IntOrString inconclusiveLimit = 8; + + // ConsecutiveErrorLimit is the maximum number of times the measurement is allowed to error in + // succession, before the metric is considered error (default: 4) + optional k8s.io.apimachinery.pkg.util.intstr.IntOrString consecutiveErrorLimit = 9; + + // Provider configuration to the external system to use to verify the analysis + optional MetricProvider provider = 10; +} + +// MetricProvider which external system to use to verify the analysis +// Only one of the fields in this struct should be non-nil +message MetricProvider { + // Prometheus specifies the prometheus metric to query + optional PrometheusMetric prometheus = 1; + + // Kayenta specifies a Kayenta metric + optional KayentaMetric kayenta = 2; + + // Web specifies a generic HTTP web metric + optional WebMetric web = 3; + + // Datadog specifies a datadog metric to query + optional DatadogMetric datadog = 4; + + // Wavefront specifies the wavefront metric to query + optional WavefrontMetric wavefront = 5; + + // NewRelic specifies the newrelic metric to query + optional NewRelicMetric newRelic = 6; + + // Job specifies the job metric run + optional JobMetric job = 7; + + // CloudWatch specifies the cloudWatch metric to query + optional CloudWatchMetric cloudWatch = 8; + + // Graphite specifies the Graphite metric to query + optional GraphiteMetric graphite = 9; + + // Influxdb specifies the influxdb metric to query + optional InfluxdbMetric influxdb = 10; + + // SkyWalking specifies the skywalking metric to query + optional SkyWalkingMetric skywalking = 11; + + // +kubebuilder:validation:Schemaless + // +kubebuilder:pruning:PreserveUnknownFields + // +kubebuilder:validation:Type=object + // Plugin specifies the hashicorp go-plugin metric to query + map plugin = 12; +} + +// MetricResult contain a list of the most recent measurements for a single metric along with +// counters on how often the measurement +message MetricResult { + // Name is the name of the metric + optional string name = 1; + + // Phase is the overall aggregate status of the metric + optional string phase = 2; + + // Measurements holds the most recent measurements collected for the metric + repeated Measurement measurements = 3; + + // Message contains a message describing current condition (e.g. error messages) + optional string message = 4; + + // Count is the number of times the metric was measured without Error + // This is equal to the sum of Successful, Failed, Inconclusive + optional int32 count = 5; + + // Successful is the number of times the metric was measured Successful + optional int32 successful = 6; + + // Failed is the number of times the metric was measured Failed + optional int32 failed = 7; + + // Inconclusive is the number of times the metric was measured Inconclusive + optional int32 inconclusive = 8; + + // Error is the number of times an error was encountered during measurement + optional int32 error = 9; + + // ConsecutiveError is the number of times an error was encountered during measurement in succession + // Resets to zero when non-errors are encountered + optional int32 consecutiveError = 10; + + // DryRun indicates whether this metric is running in a dry-run mode or not + optional bool dryRun = 11; + + // Metadata stores additional metadata about this metric. It is used by different providers to store + // the final state which gets used while taking measurements. For example, Prometheus uses this field + // to store the final resolved query after substituting the template arguments. + map metadata = 12; +} + +// NewRelicMetric defines the newrelic query to perform canary analysis +message NewRelicMetric { + // Profile is the name of the secret holding NR account configuration + optional string profile = 1; + + // Query is a raw newrelic NRQL query to perform + optional string query = 2; +} + +// NginxTrafficRouting configuration for Nginx ingress controller to control traffic routing +message NginxTrafficRouting { + // AnnotationPrefix has to match the configured annotation prefix on the nginx ingress controller + // +optional + optional string annotationPrefix = 1; + + // StableIngress refers to the name of an `Ingress` resource in the same namespace as the `Rollout` + optional string stableIngress = 2; + + // +optional + map additionalIngressAnnotations = 3; + + // StableIngresses refers to the names of `Ingress` resources in the same namespace as the `Rollout` in a multi ingress scenario + // +optional + repeated string stableIngresses = 4; +} + +// ObjectRef holds a references to the Kubernetes object +message ObjectRef { + // API Version of the referent + optional string apiVersion = 1; + + // Kind of the referent + optional string kind = 2; + + // Name of the referent + optional string name = 3; +} + +// PauseCondition the reason for a pause and when it started +message PauseCondition { + optional string reason = 1; + + optional k8s.io.apimachinery.pkg.apis.meta.v1.Time startTime = 2; +} + +// PingPongSpec holds the ping and pong service name. +message PingPongSpec { + // name of the ping service + optional string pingService = 1; + + // name of the pong service + optional string pongService = 2; +} + +// PodTemplateMetadata extra labels to add to the template +message PodTemplateMetadata { + // Labels Additional labels to add to the experiment + // +optional + map labels = 1; + + // Annotations additional annotations to add to the experiment + // +optional + map annotations = 2; +} + +// PreferredDuringSchedulingIgnoredDuringExecution defines the weight of the anti-affinity injection +message PreferredDuringSchedulingIgnoredDuringExecution { + // Weight associated with matching the corresponding podAffinityTerm, in the range 1-100. + optional int32 weight = 1; +} + +// PrometheusMetric defines the prometheus query to perform canary analysis +message PrometheusAuth { + // +optional + optional Sigv4Config sigv4 = 3; +} + +// PrometheusMetric defines the prometheus query to perform canary analysis +message PrometheusMetric { + // Address is the HTTP address and port of the prometheus server + optional string address = 1; + + // Query is a raw prometheus query to perform + optional string query = 2; + + // Sigv4 Config is the aws SigV4 configuration to use for SigV4 signing if using Amazon Managed Prometheus + // +optional + optional PrometheusAuth authentication = 3; + + // Timeout represents the duration within which a prometheus query should complete. It is expressed in seconds. + // +optional + optional int64 timeout = 4; + + // Insecure skips host TLS verification + optional bool insecure = 5; + + // Headers are optional HTTP headers to use in the request + // +optional + // +patchMergeKey=key + // +patchStrategy=merge + repeated WebMetricHeader headers = 6; +} + +// RequiredDuringSchedulingIgnoredDuringExecution defines inter-pod scheduling rule to be RequiredDuringSchedulingIgnoredDuringExecution +message RequiredDuringSchedulingIgnoredDuringExecution { +} + +message RollbackWindowSpec { + optional int32 revisions = 1; +} + +// Rollout is a specification for a Rollout resource +message Rollout { + optional k8s.io.apimachinery.pkg.apis.meta.v1.ObjectMeta metadata = 1; + + optional RolloutSpec spec = 2; + + optional RolloutStatus status = 3; +} + +// RolloutAnalysis defines a template that is used to create a analysisRun +message RolloutAnalysis { + // Templates reference to a list of analysis templates to combine for an AnalysisRun + // +patchMergeKey=templateName + // +patchStrategy=merge + repeated RolloutAnalysisTemplate templates = 1; + + // Args the arguments that will be added to the AnalysisRuns + // +patchMergeKey=name + // +patchStrategy=merge + repeated AnalysisRunArgument args = 2; + + // DryRun object contains the settings for running the analysis in Dry-Run mode + // +patchMergeKey=metricName + // +patchStrategy=merge + // +optional + repeated DryRun dryRun = 3; + + // MeasurementRetention object contains the settings for retaining the number of measurements during the analysis + // +patchMergeKey=metricName + // +patchStrategy=merge + // +optional + repeated MeasurementRetention measurementRetention = 4; + + // AnalysisRunMetadata labels and annotations that will be added to the AnalysisRuns + // +optional + optional AnalysisRunMetadata analysisRunMetadata = 5; +} + +// RolloutAnalysisBackground defines a template that is used to create a background analysisRun +message RolloutAnalysisBackground { + optional RolloutAnalysis rolloutAnalysis = 1; + + // StartingStep indicates which step the background analysis should start on + // If not listed, controller defaults to 0 + optional int32 startingStep = 2; +} + +message RolloutAnalysisRunStatus { + optional string name = 1; + + optional string status = 2; + + optional string message = 3; +} + +message RolloutAnalysisTemplate { + // TemplateName name of template to use in AnalysisRun + // +optional + optional string templateName = 1; + + // Whether to look for the templateName at cluster scope or namespace scope + // +optional + optional bool clusterScope = 2; +} + +// RolloutCondition describes the state of a rollout at a certain point. +message RolloutCondition { + // Type of deployment condition. + optional string type = 1; + + // Phase of the condition, one of True, False, Unknown. + optional string status = 2; + + // The last time this condition was updated. + optional k8s.io.apimachinery.pkg.apis.meta.v1.Time lastUpdateTime = 3; + + // Last time the condition transitioned from one status to another. + optional k8s.io.apimachinery.pkg.apis.meta.v1.Time lastTransitionTime = 4; + + // The reason for the condition's last transition. + optional string reason = 5; + + // A human readable message indicating details about the transition. + optional string message = 6; +} + +// RolloutExperimentStep defines a template that is used to create a experiment for a step +message RolloutExperimentStep { + // Templates what templates that should be added to the experiment. Should be non-nil + // +patchMergeKey=name + // +patchStrategy=merge + repeated RolloutExperimentTemplate templates = 1; + + // Duration is a duration string (e.g. 30s, 5m, 1h) that the experiment should run for + // +optional + optional string duration = 2; + + // Analyses reference which analysis templates to run with the experiment + // +patchMergeKey=name + // +patchStrategy=merge + repeated RolloutExperimentStepAnalysisTemplateRef analyses = 3; +} + +message RolloutExperimentStepAnalysisTemplateRef { + // Name is a name for this analysis template invocation + optional string name = 1; + + // TemplateName reference of the AnalysisTemplate name used by the Experiment to create the run + optional string templateName = 2; + + // Whether to look for the templateName at cluster scope or namespace scope + // +optional + optional bool clusterScope = 3; + + // Args the arguments that will be added to the AnalysisRuns + // +patchMergeKey=name + // +patchStrategy=merge + repeated AnalysisRunArgument args = 4; + + // RequiredForCompletion blocks the Experiment from completing until the analysis has completed + optional bool requiredForCompletion = 5; +} + +// RolloutExperimentTemplate defines the template used to create experiments for the Rollout's experiment canary step +message RolloutExperimentTemplate { + // Name description of template that passed to the template + optional string name = 1; + + // SpecRef indicates where the rollout should get the RS template from + optional string specRef = 2; + + // Replicas replica count for the template + // +optional + optional int32 replicas = 3; + + // Metadata sets labels and annotations to use for the RS created from the template + // +optional + optional PodTemplateMetadata metadata = 4; + + // Selector overrides the selector to be used for the template's ReplicaSet. If omitted, will + // use the same selector as the Rollout + // +optional + optional k8s.io.apimachinery.pkg.apis.meta.v1.LabelSelector selector = 5; + + // Weight sets the percentage of traffic the template's replicas should receive + optional int32 weight = 6; + + // Service controls the optionally generated service + optional TemplateService service = 7; +} + +// RolloutList is a list of Rollout resources +message RolloutList { + optional k8s.io.apimachinery.pkg.apis.meta.v1.ListMeta metadata = 1; + + repeated Rollout items = 2; +} + +// RolloutPause defines a pause stage for a rollout +message RolloutPause { + // Duration the amount of time to wait before moving to the next step. + // +optional + optional k8s.io.apimachinery.pkg.util.intstr.IntOrString duration = 1; +} + +// RolloutSpec is the spec for a Rollout resource +message RolloutSpec { + // Number of desired pods. This is a pointer to distinguish between explicit + // zero and not specified. Defaults to 1. + // +optional + optional int32 replicas = 1; + + // Label selector for pods. Existing ReplicaSets whose pods are + // selected by this will be the ones affected by this rollout. + // It must match the pod template's labels. + // +optional + optional k8s.io.apimachinery.pkg.apis.meta.v1.LabelSelector selector = 2; + + // Template describes the pods that will be created. + // +optional + optional k8s.io.api.core.v1.PodTemplateSpec template = 3; + + // WorkloadRef holds a references to a workload that provides Pod template + // +optional + optional ObjectRef workloadRef = 10; + + // Minimum number of seconds for which a newly created pod should be ready + // without any of its container crashing, for it to be considered available. + // Defaults to 0 (pod will be considered available as soon as it is ready) + // +optional + optional int32 minReadySeconds = 4; + + // The window in which a rollback will be fast tracked (fully promoted) + // +optional + optional RollbackWindowSpec rollbackWindow = 13; + + // The deployment strategy to use to replace existing pods with new ones. + // +optional + optional RolloutStrategy strategy = 5; + + // The number of old ReplicaSets to retain. If unspecified, will retain 10 old ReplicaSets + optional int32 revisionHistoryLimit = 6; + + // Paused pauses the rollout at its current step. + optional bool paused = 7; + + // ProgressDeadlineSeconds The maximum time in seconds for a rollout to + // make progress before it is considered to be failed. Argo Rollouts will + // continue to process failed rollouts and a condition with a + // ProgressDeadlineExceeded reason will be surfaced in the rollout status. + // Note that progress will not be estimated during the time a rollout is paused. + // Defaults to 600s. + optional int32 progressDeadlineSeconds = 8; + + // ProgressDeadlineAbort is whether to abort the update when ProgressDeadlineSeconds + // is exceeded. + // +optional + optional bool progressDeadlineAbort = 12; + + // RestartAt indicates when all the pods of a Rollout should be restarted + optional k8s.io.apimachinery.pkg.apis.meta.v1.Time restartAt = 9; + + // Analysis configuration for the analysis runs to retain + optional AnalysisRunStrategy analysis = 11; +} + +// RolloutStatus is the status for a Rollout resource +message RolloutStatus { + // Abort cancel the current rollout progression + optional bool abort = 1; + + // PauseConditions is a list of reasons why rollout became automatically paused (e.g. + // CanaryPauseStep, BlueGreenPause, InconclusiveAnalysis). The items in this list are populated + // by the controller but are cleared by the user (e.g. plugin, argo-cd resume action) when they + // wish to unpause. If pause conditions is empty, but controllerPause is true, it indicates + // the user manually unpaused the Rollout + repeated PauseCondition pauseConditions = 2; + + // ControllerPause indicates the controller has paused the rollout. It is set to true when + // the controller adds a pause condition. This field helps to discern the scenario where a + // rollout was resumed after being paused by the controller (e.g. via the plugin). In that + // situation, the pauseConditions would have been cleared , but controllerPause would still be + // set to true. + optional bool controllerPause = 3; + + // AbortedAt indicates the controller reconciled an aborted rollout. The controller uses this to understand if + // the controller needs to do some specific work when a Rollout is aborted. For example, the reconcileAbort is used + // to indicate if the Rollout should enter an aborted state when the latest AnalysisRun is a failure, or the controller + // has already put the Rollout into an aborted and should create a new AnalysisRun. + optional k8s.io.apimachinery.pkg.apis.meta.v1.Time abortedAt = 4; + + // CurrentPodHash the hash of the current pod template + // +optional + optional string currentPodHash = 5; + + // CurrentStepHash the hash of the current list of steps for the current strategy. This is used to detect when the + // list of current steps change + // +optional + optional string currentStepHash = 6; + + // Total number of non-terminated pods targeted by this rollout (their labels match the selector). + // +optional + optional int32 replicas = 7; + + // Total number of non-terminated pods targeted by this rollout that have the desired template spec. + // +optional + optional int32 updatedReplicas = 8; + + // Total number of ready pods targeted by this rollout. + // +optional + optional int32 readyReplicas = 9; + + // Total number of available pods (ready for at least minReadySeconds) targeted by this rollout. + // +optional + optional int32 availableReplicas = 10; + + // CurrentStepIndex defines the current step of the rollout is on. If the current step index is null, the + // controller will execute the rollout. + // +optional + optional int32 currentStepIndex = 11; + + // Count of hash collisions for the Rollout. The Rollout controller uses this + // field as a collision avoidance mechanism when it needs to create the name for the + // newest ReplicaSet. + // +optional + optional int32 collisionCount = 12; + + // The generation observed by the rollout controller from metadata.generation + // +optional + optional string observedGeneration = 13; + + // Conditions a list of conditions a rollout can have. + // +optional + repeated RolloutCondition conditions = 14; + + // Canary describes the state of the canary rollout + // +optional + optional CanaryStatus canary = 15; + + // BlueGreen describes the state of the bluegreen rollout + // +optional + optional BlueGreenStatus blueGreen = 16; + + // HPAReplicas the number of non-terminated replicas that are receiving active traffic + // +optional + optional int32 HPAReplicas = 17; + + // Selector that identifies the pods that are receiving active traffic + // +optional + optional string selector = 18; + + // StableRS indicates the replicaset that has successfully rolled out + // +optional + optional string stableRS = 19; + + // RestartedAt indicates last time a Rollout was restarted + optional k8s.io.apimachinery.pkg.apis.meta.v1.Time restartedAt = 20; + + // PromoteFull indicates if the rollout should perform a full promotion, skipping analysis and pauses. + optional bool promoteFull = 21; + + // Phase is the rollout phase. Clients should only rely on the value if status.observedGeneration equals metadata.generation + optional string phase = 22; + + // Message provides details on why the rollout is in its current phase + optional string message = 23; + + // The generation of referenced workload observed by the rollout controller + // +optional + optional string workloadObservedGeneration = 24; + + // / ALB keeps information regarding the ALB and TargetGroups + optional ALBStatus alb = 25; + + // / ALBs keeps information regarding multiple ALBs and TargetGroups in a multi ingress scenario + repeated ALBStatus albs = 26; +} + +// RolloutStrategy defines strategy to apply during next rollout +message RolloutStrategy { + // +optional + optional BlueGreenStrategy blueGreen = 1; + + // +optional + optional CanaryStrategy canary = 2; +} + +// RolloutTrafficRouting hosts all the different configuration for supported service meshes to enable more fine-grained traffic routing +message RolloutTrafficRouting { + // Istio holds Istio specific configuration to route traffic + optional IstioTrafficRouting istio = 1; + + // Nginx holds Nginx Ingress specific configuration to route traffic + optional NginxTrafficRouting nginx = 2; + + // Nginx holds ALB Ingress specific configuration to route traffic + optional ALBTrafficRouting alb = 3; + + // SMI holds TrafficSplit specific configuration to route traffic + optional SMITrafficRouting smi = 4; + + // Ambassador holds specific configuration to use Ambassador to route traffic + optional AmbassadorTrafficRouting ambassador = 5; + + // AppMesh holds specific configuration to use AppMesh to route traffic + optional AppMeshTrafficRouting appMesh = 6; + + // Traefik holds specific configuration to use Traefik to route traffic + optional TraefikTrafficRouting traefik = 7; + + // ManagedRoutes A list of HTTP routes that Argo Rollouts manages, the order of this array also becomes the precedence in the upstream + // traffic router. + repeated MangedRoutes managedRoutes = 8; + + // Apisix holds specific configuration to use Apisix to route traffic + optional ApisixTrafficRouting apisix = 9; + + // +kubebuilder:validation:Schemaless + // +kubebuilder:pruning:PreserveUnknownFields + // +kubebuilder:validation:Type=object + // Plugins holds specific configuration that traffic router plugins can use for routing traffic + map plugins = 10; +} + +message RouteMatch { + // Method What http methods should be mirrored + // +optional + optional StringMatch method = 1; + + // Path What url paths should be mirrored + // +optional + optional StringMatch path = 2; + + // Headers What request with matching headers should be mirrored + // +optional + map headers = 3; +} + +// RunSummary contains the final results from the metric executions +message RunSummary { + // This is equal to the sum of Successful, Failed, Inconclusive + optional int32 count = 1; + + // Successful is the number of times the metric was measured Successful + optional int32 successful = 2; + + // Failed is the number of times the metric was measured Failed + optional int32 failed = 3; + + // Inconclusive is the number of times the metric was measured Inconclusive + optional int32 inconclusive = 4; + + // Error is the number of times an error was encountered during measurement + optional int32 error = 5; +} + +// SMITrafficRouting configuration for TrafficSplit Custom Resource to control traffic routing +message SMITrafficRouting { + // RootService holds the name of that clients use to communicate. + // +optional + optional string rootService = 1; + + // TrafficSplitName holds the name of the TrafficSplit. + // +optional + optional string trafficSplitName = 2; +} + +message ScopeDetail { + optional string scope = 1; + + optional string region = 2; + + optional int64 step = 3; + + optional string start = 4; + + optional string end = 5; +} + +message SecretKeyRef { + // Name is the name of the secret + optional string name = 1; + + // Key is the key of the secret to select from. + optional string key = 2; +} + +// SetCanaryScale defines how to scale the newRS without changing traffic weight +message SetCanaryScale { + // Weight sets the percentage of replicas the newRS should have + // +optional + optional int32 weight = 1; + + // Replicas sets the number of replicas the newRS should have + // +optional + optional int32 replicas = 2; + + // MatchTrafficWeight cancels out previously set Replicas or Weight, effectively activating SetWeight + // +optional + optional bool matchTrafficWeight = 3; +} + +// SetHeaderRoute defines the route with specified header name to send 100% of traffic to the canary service +message SetHeaderRoute { + // Name this is the name of the route to use for the mirroring of traffic this also needs + // to be included in the `spec.strategy.canary.trafficRouting.managedRoutes` field + optional string name = 1; + + repeated HeaderRoutingMatch match = 2; +} + +message SetMirrorRoute { + // Name this is the name of the route to use for the mirroring of traffic this also needs + // to be included in the `spec.strategy.canary.trafficRouting.managedRoutes` field + optional string name = 1; + + // Match Contains a list of rules that if mated will mirror the traffic to the services + // +optional + repeated RouteMatch match = 2; + + // Services The list of services to mirror the traffic to if the method, path, headers match + // Service string `json:"service" protobuf:"bytes,3,opt,name=service"` + // Percentage What percent of the traffic that matched the rules should be mirrored + optional int32 percentage = 4; +} + +message Sigv4Config { + // Region is the AWS Region to sign the SigV4 Request + optional string address = 1; + + // Profile is the Credential Profile used to sign the SigV4 Request + optional string profile = 2; + + // RoleARN is the IAM role used to sign the SIgV4 Request + optional string roleArn = 3; +} + +message SkyWalkingMetric { + optional string address = 1; + + optional string query = 2; + + optional string interval = 3; +} + +message StickinessConfig { + optional bool enabled = 1; + + optional int64 durationSeconds = 2; +} + +// StringMatch Used to define what type of matching we will use exact, prefix, or regular expression +message StringMatch { + // Exact The string must match exactly + optional string exact = 1; + + // Prefix The string will be prefixed matched + optional string prefix = 2; + + // Regex The string will be regular expression matched + optional string regex = 3; +} + +// TCPRoute holds the information on the virtual service's TCP routes that are desired to be matched for changing weights. +message TCPRoute { + // Port number of the TCP Route desired to be matched in the given Istio VirtualService. + optional int64 port = 1; +} + +// TLSRoute holds the information on the virtual service's TLS/HTTPS routes that are desired to be matched for changing weights. +message TLSRoute { + // Port number of the TLS Route desired to be matched in the given Istio VirtualService. + optional int64 port = 1; + + // A list of all the SNI Hosts of the TLS Route desired to be matched in the given Istio VirtualService. + repeated string sniHosts = 2; +} + +message TemplateService { + // Name of the service generated by the experiment + optional string name = 1; +} + +message TemplateSpec { + // Name of the template used to identity replicaset running for this experiment + optional string name = 1; + + // Number of desired pods. This is a pointer to distinguish between explicit + // zero and not specified. Defaults to 1. + // +optional + optional int32 replicas = 2; + + // Minimum number of seconds for which a newly created pod should be ready + // without any of its container crashing, for it to be considered available. + // Defaults to 0 (pod will be considered available as soon as it is ready) + // +optional + optional int32 minReadySeconds = 3; + + // Label selector for pods. Existing ReplicaSets whose pods are + // selected by this will be the ones affected by this experiment. + // It must match the pod template's labels. Each selector must be unique to the other selectors in the other templates + optional k8s.io.apimachinery.pkg.apis.meta.v1.LabelSelector selector = 4; + + // Template describes the pods that will be created. + optional k8s.io.api.core.v1.PodTemplateSpec template = 5; + + // TemplateService describes how a service should be generated for template + optional TemplateService service = 6; +} + +// TemplateStatus is the status of a specific template of an Experiment +message TemplateStatus { + // Name of the template used to identity which hash to compare to the hash + optional string name = 1; + + // Total number of non-terminated pods targeted by this experiment (their labels match the selector). + optional int32 replicas = 2; + + // Total number of non-terminated pods targeted by this experiment that have the desired template spec. + optional int32 updatedReplicas = 3; + + // Total number of ready pods targeted by this experiment. + optional int32 readyReplicas = 4; + + // Total number of available pods (ready for at least minReadySeconds) targeted by this experiment. + optional int32 availableReplicas = 5; + + // CollisionCount count of hash collisions for the Experiment. The Experiment controller uses this + // field as a collision avoidance mechanism when it needs to create the name for the + // newest ReplicaSet. + // +optional + optional int32 collisionCount = 6; + + // Phase is the status of the ReplicaSet associated with the template + optional string status = 7; + + // Message is a message explaining the current status + optional string message = 8; + + // LastTransitionTime is the last time the replicaset transitioned, which resets the countdown + // on the ProgressDeadlineSeconds check. + optional k8s.io.apimachinery.pkg.apis.meta.v1.Time lastTransitionTime = 9; + + // ServiceName is the name of the service which corresponds to this experiment + optional string serviceName = 10; + + // PodTemplateHash is the value of the Replicas' PodTemplateHash + optional string podTemplateHash = 11; +} + +// TraefikTrafficRouting defines the configuration required to use Traefik as traffic router +message TraefikTrafficRouting { + // TraefikServiceName refer to the name of the Traefik service used to route traffic to the service + optional string weightedTraefikServiceName = 1; +} + +// TrafficWeights describes the current status of how traffic has been split +message TrafficWeights { + // Canary is the current traffic weight split to canary ReplicaSet + optional WeightDestination canary = 1; + + // Stable is the current traffic weight split to stable ReplicaSet + optional WeightDestination stable = 2; + + // Additional holds the weights split to additional ReplicaSets such as experiment ReplicaSets + repeated WeightDestination additional = 3; + + // Verified is an optional indicator that the weight has been verified to have taken effect. + // This is currently only applicable to ALB traffic router + optional bool verified = 4; +} + +message ValueFrom { + // Secret is a reference to where a secret is stored. This field is one of the fields with valueFrom + // +optional + optional SecretKeyRef secretKeyRef = 1; + + // FieldRef is a reference to the fields in metadata which we are referencing. This field is one of the fields with + // valueFrom + // +optional + optional FieldRef fieldRef = 2; +} + +// WavefrontMetric defines the wavefront query to perform canary analysis +message WavefrontMetric { + // Address is the HTTP address and port of the wavefront server + optional string address = 1; + + // Query is a raw wavefront query to perform + optional string query = 2; +} + +message WebMetric { + // Method is the method of the web metric (empty defaults to GET) + optional string method = 1; + + // URL is the address of the web metric + optional string url = 2; + + // +patchMergeKey=key + // +patchStrategy=merge + // Headers are optional HTTP headers to use in the request + repeated WebMetricHeader headers = 3; + + // Body is the body of the web metric (must be POST/PUT) + optional string body = 4; + + // TimeoutSeconds is the timeout for the request in seconds (default: 10) + optional int64 timeoutSeconds = 5; + + // JSONPath is a JSON Path to use as the result variable (default: "{$}") + optional string jsonPath = 6; + + // Insecure skips host TLS verification + optional bool insecure = 7; + + // +kubebuilder:validation:Schemaless + // +kubebuilder:pruning:PreserveUnknownFields + // +kubebuilder:validation:Type=object + // JSONBody is the body of the web metric in a json format (method must be POST/PUT) + optional bytes jsonBody = 8; +} + +message WebMetricHeader { + optional string key = 1; + + optional string value = 2; +} + +message WeightDestination { + // Weight is an percentage of traffic being sent to this destination + optional int32 weight = 1; + + // ServiceName is the Kubernetes service name traffic is being sent to + optional string serviceName = 2; + + // PodTemplateHash is the pod template hash label for this destination + optional string podTemplateHash = 3; +} + diff --git a/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1/openapi_generated.go b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1/openapi_generated.go new file mode 100644 index 000000000000..f4142b09f3a9 --- /dev/null +++ b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1/openapi_generated.go @@ -0,0 +1,5528 @@ +//go:build !ignore_autogenerated +// +build !ignore_autogenerated + +/* +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 openapi-gen. DO NOT EDIT. + +// This file was autogenerated by openapi-gen. Do not edit it manually! + +package v1alpha1 + +import ( + common "k8s.io/kube-openapi/pkg/common" + spec "k8s.io/kube-openapi/pkg/validation/spec" +) + +func GetOpenAPIDefinitions(ref common.ReferenceCallback) map[string]common.OpenAPIDefinition { + return map[string]common.OpenAPIDefinition{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ALBStatus": schema_pkg_apis_rollouts_v1alpha1_ALBStatus(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ALBTrafficRouting": schema_pkg_apis_rollouts_v1alpha1_ALBTrafficRouting(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AmbassadorTrafficRouting": schema_pkg_apis_rollouts_v1alpha1_AmbassadorTrafficRouting(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AnalysisRun": schema_pkg_apis_rollouts_v1alpha1_AnalysisRun(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AnalysisRunArgument": schema_pkg_apis_rollouts_v1alpha1_AnalysisRunArgument(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AnalysisRunList": schema_pkg_apis_rollouts_v1alpha1_AnalysisRunList(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AnalysisRunMetadata": schema_pkg_apis_rollouts_v1alpha1_AnalysisRunMetadata(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AnalysisRunSpec": schema_pkg_apis_rollouts_v1alpha1_AnalysisRunSpec(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AnalysisRunStatus": schema_pkg_apis_rollouts_v1alpha1_AnalysisRunStatus(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AnalysisRunStrategy": schema_pkg_apis_rollouts_v1alpha1_AnalysisRunStrategy(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AnalysisTemplate": schema_pkg_apis_rollouts_v1alpha1_AnalysisTemplate(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AnalysisTemplateList": schema_pkg_apis_rollouts_v1alpha1_AnalysisTemplateList(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AnalysisTemplateSpec": schema_pkg_apis_rollouts_v1alpha1_AnalysisTemplateSpec(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AntiAffinity": schema_pkg_apis_rollouts_v1alpha1_AntiAffinity(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ApisixRoute": schema_pkg_apis_rollouts_v1alpha1_ApisixRoute(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ApisixTrafficRouting": schema_pkg_apis_rollouts_v1alpha1_ApisixTrafficRouting(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AppMeshTrafficRouting": schema_pkg_apis_rollouts_v1alpha1_AppMeshTrafficRouting(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AppMeshVirtualNodeGroup": schema_pkg_apis_rollouts_v1alpha1_AppMeshVirtualNodeGroup(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AppMeshVirtualNodeReference": schema_pkg_apis_rollouts_v1alpha1_AppMeshVirtualNodeReference(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AppMeshVirtualService": schema_pkg_apis_rollouts_v1alpha1_AppMeshVirtualService(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.Argument": schema_pkg_apis_rollouts_v1alpha1_Argument(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ArgumentValueFrom": schema_pkg_apis_rollouts_v1alpha1_ArgumentValueFrom(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AwsResourceRef": schema_pkg_apis_rollouts_v1alpha1_AwsResourceRef(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.BlueGreenStatus": schema_pkg_apis_rollouts_v1alpha1_BlueGreenStatus(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.BlueGreenStrategy": schema_pkg_apis_rollouts_v1alpha1_BlueGreenStrategy(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.CanaryStatus": schema_pkg_apis_rollouts_v1alpha1_CanaryStatus(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.CanaryStep": schema_pkg_apis_rollouts_v1alpha1_CanaryStep(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.CanaryStrategy": schema_pkg_apis_rollouts_v1alpha1_CanaryStrategy(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.CloudWatchMetric": schema_pkg_apis_rollouts_v1alpha1_CloudWatchMetric(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.CloudWatchMetricDataQuery": schema_pkg_apis_rollouts_v1alpha1_CloudWatchMetricDataQuery(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.CloudWatchMetricStat": schema_pkg_apis_rollouts_v1alpha1_CloudWatchMetricStat(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.CloudWatchMetricStatMetric": schema_pkg_apis_rollouts_v1alpha1_CloudWatchMetricStatMetric(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.CloudWatchMetricStatMetricDimension": schema_pkg_apis_rollouts_v1alpha1_CloudWatchMetricStatMetricDimension(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ClusterAnalysisTemplate": schema_pkg_apis_rollouts_v1alpha1_ClusterAnalysisTemplate(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ClusterAnalysisTemplateList": schema_pkg_apis_rollouts_v1alpha1_ClusterAnalysisTemplateList(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.DatadogMetric": schema_pkg_apis_rollouts_v1alpha1_DatadogMetric(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.DryRun": schema_pkg_apis_rollouts_v1alpha1_DryRun(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.Experiment": schema_pkg_apis_rollouts_v1alpha1_Experiment(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ExperimentAnalysisRunStatus": schema_pkg_apis_rollouts_v1alpha1_ExperimentAnalysisRunStatus(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ExperimentAnalysisTemplateRef": schema_pkg_apis_rollouts_v1alpha1_ExperimentAnalysisTemplateRef(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ExperimentCondition": schema_pkg_apis_rollouts_v1alpha1_ExperimentCondition(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ExperimentList": schema_pkg_apis_rollouts_v1alpha1_ExperimentList(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ExperimentSpec": schema_pkg_apis_rollouts_v1alpha1_ExperimentSpec(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ExperimentStatus": schema_pkg_apis_rollouts_v1alpha1_ExperimentStatus(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.FieldRef": schema_pkg_apis_rollouts_v1alpha1_FieldRef(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.GraphiteMetric": schema_pkg_apis_rollouts_v1alpha1_GraphiteMetric(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.HeaderRoutingMatch": schema_pkg_apis_rollouts_v1alpha1_HeaderRoutingMatch(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.InfluxdbMetric": schema_pkg_apis_rollouts_v1alpha1_InfluxdbMetric(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.IstioDestinationRule": schema_pkg_apis_rollouts_v1alpha1_IstioDestinationRule(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.IstioTrafficRouting": schema_pkg_apis_rollouts_v1alpha1_IstioTrafficRouting(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.IstioVirtualService": schema_pkg_apis_rollouts_v1alpha1_IstioVirtualService(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.JobMetric": schema_pkg_apis_rollouts_v1alpha1_JobMetric(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.KayentaMetric": schema_pkg_apis_rollouts_v1alpha1_KayentaMetric(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.KayentaScope": schema_pkg_apis_rollouts_v1alpha1_KayentaScope(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.KayentaThreshold": schema_pkg_apis_rollouts_v1alpha1_KayentaThreshold(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.MangedRoutes": schema_pkg_apis_rollouts_v1alpha1_MangedRoutes(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.Measurement": schema_pkg_apis_rollouts_v1alpha1_Measurement(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.MeasurementRetention": schema_pkg_apis_rollouts_v1alpha1_MeasurementRetention(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.Metric": schema_pkg_apis_rollouts_v1alpha1_Metric(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.MetricProvider": schema_pkg_apis_rollouts_v1alpha1_MetricProvider(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.MetricResult": schema_pkg_apis_rollouts_v1alpha1_MetricResult(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.NewRelicMetric": schema_pkg_apis_rollouts_v1alpha1_NewRelicMetric(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.NginxTrafficRouting": schema_pkg_apis_rollouts_v1alpha1_NginxTrafficRouting(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ObjectRef": schema_pkg_apis_rollouts_v1alpha1_ObjectRef(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.PauseCondition": schema_pkg_apis_rollouts_v1alpha1_PauseCondition(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.PingPongSpec": schema_pkg_apis_rollouts_v1alpha1_PingPongSpec(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.PodTemplateMetadata": schema_pkg_apis_rollouts_v1alpha1_PodTemplateMetadata(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.PreferredDuringSchedulingIgnoredDuringExecution": schema_pkg_apis_rollouts_v1alpha1_PreferredDuringSchedulingIgnoredDuringExecution(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.PrometheusAuth": schema_pkg_apis_rollouts_v1alpha1_PrometheusAuth(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.PrometheusMetric": schema_pkg_apis_rollouts_v1alpha1_PrometheusMetric(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RequiredDuringSchedulingIgnoredDuringExecution": schema_pkg_apis_rollouts_v1alpha1_RequiredDuringSchedulingIgnoredDuringExecution(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RollbackWindowSpec": schema_pkg_apis_rollouts_v1alpha1_RollbackWindowSpec(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.Rollout": schema_pkg_apis_rollouts_v1alpha1_Rollout(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutAnalysis": schema_pkg_apis_rollouts_v1alpha1_RolloutAnalysis(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutAnalysisBackground": schema_pkg_apis_rollouts_v1alpha1_RolloutAnalysisBackground(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutAnalysisRunStatus": schema_pkg_apis_rollouts_v1alpha1_RolloutAnalysisRunStatus(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutAnalysisTemplate": schema_pkg_apis_rollouts_v1alpha1_RolloutAnalysisTemplate(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutCondition": schema_pkg_apis_rollouts_v1alpha1_RolloutCondition(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutExperimentStep": schema_pkg_apis_rollouts_v1alpha1_RolloutExperimentStep(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutExperimentStepAnalysisTemplateRef": schema_pkg_apis_rollouts_v1alpha1_RolloutExperimentStepAnalysisTemplateRef(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutExperimentTemplate": schema_pkg_apis_rollouts_v1alpha1_RolloutExperimentTemplate(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutList": schema_pkg_apis_rollouts_v1alpha1_RolloutList(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutPause": schema_pkg_apis_rollouts_v1alpha1_RolloutPause(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutSpec": schema_pkg_apis_rollouts_v1alpha1_RolloutSpec(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutStatus": schema_pkg_apis_rollouts_v1alpha1_RolloutStatus(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutStrategy": schema_pkg_apis_rollouts_v1alpha1_RolloutStrategy(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutTrafficRouting": schema_pkg_apis_rollouts_v1alpha1_RolloutTrafficRouting(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RouteMatch": schema_pkg_apis_rollouts_v1alpha1_RouteMatch(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RunSummary": schema_pkg_apis_rollouts_v1alpha1_RunSummary(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.SMITrafficRouting": schema_pkg_apis_rollouts_v1alpha1_SMITrafficRouting(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ScopeDetail": schema_pkg_apis_rollouts_v1alpha1_ScopeDetail(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.SecretKeyRef": schema_pkg_apis_rollouts_v1alpha1_SecretKeyRef(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.SetCanaryScale": schema_pkg_apis_rollouts_v1alpha1_SetCanaryScale(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.SetHeaderRoute": schema_pkg_apis_rollouts_v1alpha1_SetHeaderRoute(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.SetMirrorRoute": schema_pkg_apis_rollouts_v1alpha1_SetMirrorRoute(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.Sigv4Config": schema_pkg_apis_rollouts_v1alpha1_Sigv4Config(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.SkyWalkingMetric": schema_pkg_apis_rollouts_v1alpha1_SkyWalkingMetric(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.StickinessConfig": schema_pkg_apis_rollouts_v1alpha1_StickinessConfig(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.StringMatch": schema_pkg_apis_rollouts_v1alpha1_StringMatch(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.TCPRoute": schema_pkg_apis_rollouts_v1alpha1_TCPRoute(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.TLSRoute": schema_pkg_apis_rollouts_v1alpha1_TLSRoute(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.TemplateService": schema_pkg_apis_rollouts_v1alpha1_TemplateService(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.TemplateSpec": schema_pkg_apis_rollouts_v1alpha1_TemplateSpec(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.TemplateStatus": schema_pkg_apis_rollouts_v1alpha1_TemplateStatus(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.TraefikTrafficRouting": schema_pkg_apis_rollouts_v1alpha1_TraefikTrafficRouting(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.TrafficWeights": schema_pkg_apis_rollouts_v1alpha1_TrafficWeights(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ValueFrom": schema_pkg_apis_rollouts_v1alpha1_ValueFrom(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.WavefrontMetric": schema_pkg_apis_rollouts_v1alpha1_WavefrontMetric(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.WebMetric": schema_pkg_apis_rollouts_v1alpha1_WebMetric(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.WebMetricHeader": schema_pkg_apis_rollouts_v1alpha1_WebMetricHeader(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.WeightDestination": schema_pkg_apis_rollouts_v1alpha1_WeightDestination(ref), + } +} + +func schema_pkg_apis_rollouts_v1alpha1_ALBStatus(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "loadBalancer": { + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AwsResourceRef"), + }, + }, + "canaryTargetGroup": { + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AwsResourceRef"), + }, + }, + "stableTargetGroup": { + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AwsResourceRef"), + }, + }, + "ingress": { + SchemaProps: spec.SchemaProps{ + Type: []string{"string"}, + Format: "", + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AwsResourceRef"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_ALBTrafficRouting(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "ALBTrafficRouting configuration for ALB ingress controller to control traffic routing", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "ingress": { + SchemaProps: spec.SchemaProps{ + Description: "Ingress refers to the name of an `Ingress` resource in the same namespace as the `Rollout`", + Type: []string{"string"}, + Format: "", + }, + }, + "servicePort": { + SchemaProps: spec.SchemaProps{ + Description: "ServicePort refers to the port that the Ingress action should route traffic to", + Default: 0, + Type: []string{"integer"}, + Format: "int32", + }, + }, + "rootService": { + SchemaProps: spec.SchemaProps{ + Description: "RootService references the service in the ingress to the controller should add the action to", + Type: []string{"string"}, + Format: "", + }, + }, + "annotationPrefix": { + SchemaProps: spec.SchemaProps{ + Description: "AnnotationPrefix has to match the configured annotation prefix on the alb ingress controller", + Type: []string{"string"}, + Format: "", + }, + }, + "stickinessConfig": { + SchemaProps: spec.SchemaProps{ + Description: "StickinessConfig refers to the duration-based stickiness of the target groups associated with an `Ingress`", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.StickinessConfig"), + }, + }, + "ingresses": { + SchemaProps: spec.SchemaProps{ + Description: "Ingresses refers to the name of an `Ingress` resource in the same namespace as the `Rollout` in a multi ingress scenario", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + }, + }, + }, + }, + Required: []string{"servicePort"}, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.StickinessConfig"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_AmbassadorTrafficRouting(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "AmbassadorTrafficRouting defines the configuration required to use Ambassador as traffic router", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "mappings": { + SchemaProps: spec.SchemaProps{ + Description: "Mappings refer to the name of the Ambassador Mappings used to route traffic to the service", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + }, + }, + }, + }, + Required: []string{"mappings"}, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_AnalysisRun(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "AnalysisRun is an instantiation of an AnalysisTemplate", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "kind": { + SchemaProps: spec.SchemaProps{ + Description: "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + Type: []string{"string"}, + Format: "", + }, + }, + "apiVersion": { + SchemaProps: spec.SchemaProps{ + Description: "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + Type: []string{"string"}, + Format: "", + }, + }, + "metadata": { + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.ObjectMeta"), + }, + }, + "spec": { + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AnalysisRunSpec"), + }, + }, + "status": { + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AnalysisRunStatus"), + }, + }, + }, + Required: []string{"spec"}, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AnalysisRunSpec", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AnalysisRunStatus", "k8s.io/apimachinery/pkg/apis/meta/v1.ObjectMeta"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_AnalysisRunArgument(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "AnalysisRunArgument argument to add to analysisRun", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "name": { + SchemaProps: spec.SchemaProps{ + Description: "Name argument name", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "value": { + SchemaProps: spec.SchemaProps{ + Description: "Value a hardcoded value for the argument. This field is a one of field with valueFrom", + Type: []string{"string"}, + Format: "", + }, + }, + "valueFrom": { + SchemaProps: spec.SchemaProps{ + Description: "ValueFrom A reference to where the value is stored. This field is a one of field with valueFrom", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ArgumentValueFrom"), + }, + }, + }, + Required: []string{"name"}, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ArgumentValueFrom"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_AnalysisRunList(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "AnalysisRunList is a list of AnalysisTemplate resources", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "kind": { + SchemaProps: spec.SchemaProps{ + Description: "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + Type: []string{"string"}, + Format: "", + }, + }, + "apiVersion": { + SchemaProps: spec.SchemaProps{ + Description: "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + Type: []string{"string"}, + Format: "", + }, + }, + "metadata": { + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.ListMeta"), + }, + }, + "items": { + SchemaProps: spec.SchemaProps{ + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AnalysisRun"), + }, + }, + }, + }, + }, + }, + Required: []string{"metadata", "items"}, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AnalysisRun", "k8s.io/apimachinery/pkg/apis/meta/v1.ListMeta"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_AnalysisRunMetadata(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "AnalysisRunMetadata extra labels to add to the AnalysisRun", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "labels": { + SchemaProps: spec.SchemaProps{ + Description: "Labels Additional labels to add to the AnalysisRun", + Type: []string{"object"}, + AdditionalProperties: &spec.SchemaOrBool{ + Allows: true, + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + }, + }, + }, + "annotations": { + SchemaProps: spec.SchemaProps{ + Description: "Annotations additional annotations to add to the AnalysisRun", + Type: []string{"object"}, + AdditionalProperties: &spec.SchemaOrBool{ + Allows: true, + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + }, + }, + }, + }, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_AnalysisRunSpec(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "AnalysisRunSpec is the spec for a AnalysisRun resource", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "metrics": { + VendorExtensible: spec.VendorExtensible{ + Extensions: spec.Extensions{ + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge", + }, + }, + SchemaProps: spec.SchemaProps{ + Description: "Metrics contains the list of metrics to query as part of an analysis run", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.Metric"), + }, + }, + }, + }, + }, + "args": { + VendorExtensible: spec.VendorExtensible{ + Extensions: spec.Extensions{ + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge", + }, + }, + SchemaProps: spec.SchemaProps{ + Description: "Args are the list of arguments used in this run", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.Argument"), + }, + }, + }, + }, + }, + "terminate": { + SchemaProps: spec.SchemaProps{ + Description: "Terminate is used to prematurely stop the run (e.g. rollout completed and analysis is no longer desired)", + Type: []string{"boolean"}, + Format: "", + }, + }, + "dryRun": { + VendorExtensible: spec.VendorExtensible{ + Extensions: spec.Extensions{ + "x-kubernetes-patch-merge-key": "metricName", + "x-kubernetes-patch-strategy": "merge", + }, + }, + SchemaProps: spec.SchemaProps{ + Description: "DryRun object contains the settings for running the analysis in Dry-Run mode", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.DryRun"), + }, + }, + }, + }, + }, + "measurementRetention": { + VendorExtensible: spec.VendorExtensible{ + Extensions: spec.Extensions{ + "x-kubernetes-patch-merge-key": "metricName", + "x-kubernetes-patch-strategy": "merge", + }, + }, + SchemaProps: spec.SchemaProps{ + Description: "MeasurementRetention object contains the settings for retaining the number of measurements during the analysis", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.MeasurementRetention"), + }, + }, + }, + }, + }, + }, + Required: []string{"metrics"}, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.Argument", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.DryRun", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.MeasurementRetention", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.Metric"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_AnalysisRunStatus(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "AnalysisRunStatus is the status for a AnalysisRun resource", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "phase": { + SchemaProps: spec.SchemaProps{ + Description: "Phase is the status of the analysis run", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "message": { + SchemaProps: spec.SchemaProps{ + Description: "Message is a message explaining current status", + Type: []string{"string"}, + Format: "", + }, + }, + "metricResults": { + SchemaProps: spec.SchemaProps{ + Description: "MetricResults contains the metrics collected during the run", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.MetricResult"), + }, + }, + }, + }, + }, + "startedAt": { + SchemaProps: spec.SchemaProps{ + Description: "StartedAt indicates when the analysisRun first started", + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.Time"), + }, + }, + "runSummary": { + SchemaProps: spec.SchemaProps{ + Description: "RunSummary contains the final results from the metric executions", + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RunSummary"), + }, + }, + "dryRunSummary": { + SchemaProps: spec.SchemaProps{ + Description: "DryRunSummary contains the final results from the metric executions in the dry-run mode", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RunSummary"), + }, + }, + }, + Required: []string{"phase"}, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.MetricResult", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RunSummary", "k8s.io/apimachinery/pkg/apis/meta/v1.Time"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_AnalysisRunStrategy(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "AnalysisRunStrategy configuration for the analysis runs and experiments to retain", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "successfulRunHistoryLimit": { + SchemaProps: spec.SchemaProps{ + Description: "SuccessfulRunHistoryLimit limits the number of old successful analysis runs and experiments to be retained in a history", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "unsuccessfulRunHistoryLimit": { + SchemaProps: spec.SchemaProps{ + Description: "UnsuccessfulRunHistoryLimit limits the number of old unsuccessful analysis runs and experiments to be retained in a history. Stages for unsuccessful: \"Error\", \"Failed\", \"Inconclusive\"", + Type: []string{"integer"}, + Format: "int32", + }, + }, + }, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_AnalysisTemplate(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "AnalysisTemplate holds the template for performing canary analysis", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "kind": { + SchemaProps: spec.SchemaProps{ + Description: "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + Type: []string{"string"}, + Format: "", + }, + }, + "apiVersion": { + SchemaProps: spec.SchemaProps{ + Description: "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + Type: []string{"string"}, + Format: "", + }, + }, + "metadata": { + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.ObjectMeta"), + }, + }, + "spec": { + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AnalysisTemplateSpec"), + }, + }, + }, + Required: []string{"spec"}, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AnalysisTemplateSpec", "k8s.io/apimachinery/pkg/apis/meta/v1.ObjectMeta"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_AnalysisTemplateList(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "AnalysisTemplateList is a list of AnalysisTemplate resources", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "kind": { + SchemaProps: spec.SchemaProps{ + Description: "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + Type: []string{"string"}, + Format: "", + }, + }, + "apiVersion": { + SchemaProps: spec.SchemaProps{ + Description: "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + Type: []string{"string"}, + Format: "", + }, + }, + "metadata": { + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.ListMeta"), + }, + }, + "items": { + SchemaProps: spec.SchemaProps{ + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AnalysisTemplate"), + }, + }, + }, + }, + }, + }, + Required: []string{"metadata", "items"}, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AnalysisTemplate", "k8s.io/apimachinery/pkg/apis/meta/v1.ListMeta"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_AnalysisTemplateSpec(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "AnalysisTemplateSpec is the specification for a AnalysisTemplate resource", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "metrics": { + VendorExtensible: spec.VendorExtensible{ + Extensions: spec.Extensions{ + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge", + }, + }, + SchemaProps: spec.SchemaProps{ + Description: "Metrics contains the list of metrics to query as part of an analysis run", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.Metric"), + }, + }, + }, + }, + }, + "args": { + VendorExtensible: spec.VendorExtensible{ + Extensions: spec.Extensions{ + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge", + }, + }, + SchemaProps: spec.SchemaProps{ + Description: "Args are the list of arguments to the template", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.Argument"), + }, + }, + }, + }, + }, + "dryRun": { + VendorExtensible: spec.VendorExtensible{ + Extensions: spec.Extensions{ + "x-kubernetes-patch-merge-key": "metricName", + "x-kubernetes-patch-strategy": "merge", + }, + }, + SchemaProps: spec.SchemaProps{ + Description: "DryRun object contains the settings for running the analysis in Dry-Run mode", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.DryRun"), + }, + }, + }, + }, + }, + "measurementRetention": { + VendorExtensible: spec.VendorExtensible{ + Extensions: spec.Extensions{ + "x-kubernetes-patch-merge-key": "metricName", + "x-kubernetes-patch-strategy": "merge", + }, + }, + SchemaProps: spec.SchemaProps{ + Description: "MeasurementRetention object contains the settings for retaining the number of measurements during the analysis", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.MeasurementRetention"), + }, + }, + }, + }, + }, + }, + Required: []string{"metrics"}, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.Argument", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.DryRun", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.MeasurementRetention", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.Metric"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_AntiAffinity(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "AntiAffinity defines which inter-pod scheduling rule to use for anti-affinity injection", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "preferredDuringSchedulingIgnoredDuringExecution": { + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.PreferredDuringSchedulingIgnoredDuringExecution"), + }, + }, + "requiredDuringSchedulingIgnoredDuringExecution": { + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RequiredDuringSchedulingIgnoredDuringExecution"), + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.PreferredDuringSchedulingIgnoredDuringExecution", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RequiredDuringSchedulingIgnoredDuringExecution"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_ApisixRoute(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "ApisixRoute holds information on the APISIX Route the rollout needs to modify", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "name": { + SchemaProps: spec.SchemaProps{ + Description: "Name refer to the name of the APISIX Route used to route traffic to the service", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "rules": { + SchemaProps: spec.SchemaProps{ + Description: "RuleRef a list of the APISIX Route HTTP Rules used to route traffic to the service", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + }, + }, + }, + }, + Required: []string{"name"}, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_ApisixTrafficRouting(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "ApisixTrafficRouting defines the configuration required to use APISIX as traffic router", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "route": { + SchemaProps: spec.SchemaProps{ + Description: "Route references an Apisix Route to modify to shape traffic", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ApisixRoute"), + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ApisixRoute"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_AppMeshTrafficRouting(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "AppMeshTrafficRouting configuration for AWS AppMesh service mesh to enable fine grain configuration", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "virtualService": { + SchemaProps: spec.SchemaProps{ + Description: "VirtualService references an AppMesh VirtualService and VirtualRouter to modify to shape traffic", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AppMeshVirtualService"), + }, + }, + "virtualNodeGroup": { + SchemaProps: spec.SchemaProps{ + Description: "VirtualNodeGroup references an AppMesh Route targets that are formed by a set of VirtualNodes that are used to shape traffic", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AppMeshVirtualNodeGroup"), + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AppMeshVirtualNodeGroup", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AppMeshVirtualService"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_AppMeshVirtualNodeGroup(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "AppMeshVirtualNodeGroup holds information about targets used for routing traffic to a virtual service", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "canaryVirtualNodeRef": { + SchemaProps: spec.SchemaProps{ + Description: "CanaryVirtualNodeRef is the virtual node ref to modify labels with canary ReplicaSet pod template hash value", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AppMeshVirtualNodeReference"), + }, + }, + "stableVirtualNodeRef": { + SchemaProps: spec.SchemaProps{ + Description: "StableVirtualNodeRef is the virtual node name to modify labels with stable ReplicaSet pod template hash value", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AppMeshVirtualNodeReference"), + }, + }, + }, + Required: []string{"canaryVirtualNodeRef", "stableVirtualNodeRef"}, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AppMeshVirtualNodeReference"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_AppMeshVirtualNodeReference(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "AppMeshVirtualNodeReference holds a reference to VirtualNode.appmesh.k8s.aws", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "name": { + SchemaProps: spec.SchemaProps{ + Description: "Name is the name of VirtualNode CR", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + }, + Required: []string{"name"}, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_AppMeshVirtualService(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "AppMeshVirtualService holds information on the virtual service the rollout needs to modify", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "name": { + SchemaProps: spec.SchemaProps{ + Description: "Name is the name of virtual service", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "routes": { + SchemaProps: spec.SchemaProps{ + Description: "Routes is list of HTTP routes within virtual router associated with virtual service to edit. If omitted, virtual service must have a single route of this type.", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + }, + }, + }, + }, + Required: []string{"name"}, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_Argument(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "Argument is an argument to an AnalysisRun", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "name": { + SchemaProps: spec.SchemaProps{ + Description: "Name is the name of the argument", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "value": { + SchemaProps: spec.SchemaProps{ + Description: "Value is the value of the argument", + Type: []string{"string"}, + Format: "", + }, + }, + "valueFrom": { + SchemaProps: spec.SchemaProps{ + Description: "ValueFrom is a reference to where a secret is stored. This field is one of the fields with valueFrom", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ValueFrom"), + }, + }, + }, + Required: []string{"name"}, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ValueFrom"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_ArgumentValueFrom(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "ArgumentValueFrom defines references to fields within resources to grab for the value (i.e. Pod Template Hash)", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "podTemplateHashValue": { + SchemaProps: spec.SchemaProps{ + Description: "PodTemplateHashValue gets the value from one of the children ReplicaSet's Pod Template Hash", + Type: []string{"string"}, + Format: "", + }, + }, + "fieldRef": { + SchemaProps: spec.SchemaProps{ + Description: "FieldRef", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.FieldRef"), + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.FieldRef"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_AwsResourceRef(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "name": { + SchemaProps: spec.SchemaProps{ + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "arn": { + SchemaProps: spec.SchemaProps{ + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "fullName": { + SchemaProps: spec.SchemaProps{ + Description: "FullName is the full name of the resource", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + }, + Required: []string{"name", "arn"}, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_BlueGreenStatus(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "BlueGreenStatus status fields that only pertain to the blueGreen rollout", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "previewSelector": { + SchemaProps: spec.SchemaProps{ + Description: "PreviewSelector indicates which replicas set the preview service is serving traffic to", + Type: []string{"string"}, + Format: "", + }, + }, + "activeSelector": { + SchemaProps: spec.SchemaProps{ + Description: "ActiveSelector indicates which replicas set the active service is serving traffic to", + Type: []string{"string"}, + Format: "", + }, + }, + "scaleUpPreviewCheckPoint": { + SchemaProps: spec.SchemaProps{ + Description: "ScaleUpPreviewCheckPoint indicates that the Replicaset receiving traffic from the preview service is ready to be scaled up after the rollout is unpaused", + Type: []string{"boolean"}, + Format: "", + }, + }, + "prePromotionAnalysisRunStatus": { + SchemaProps: spec.SchemaProps{ + Description: "PrePromotionAnalysisRunStatus indicates the status of the current prepromotion analysis run", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutAnalysisRunStatus"), + }, + }, + "postPromotionAnalysisRunStatus": { + SchemaProps: spec.SchemaProps{ + Description: "PostPromotionAnalysisRunStatus indicates the status of the current post promotion analysis run", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutAnalysisRunStatus"), + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutAnalysisRunStatus"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_BlueGreenStrategy(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "BlueGreenStrategy defines parameters for Blue Green deployment", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "activeService": { + SchemaProps: spec.SchemaProps{ + Description: "Name of the service that the rollout modifies as the active service.", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "previewService": { + SchemaProps: spec.SchemaProps{ + Description: "Name of the service that the rollout modifies as the preview service.", + Type: []string{"string"}, + Format: "", + }, + }, + "previewReplicaCount": { + SchemaProps: spec.SchemaProps{ + Description: "PreviewReplicaCount is the number of replicas to run for the preview stack before the switchover. Once the rollout is resumed the desired replicaset will be full scaled up before the switch occurs", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "autoPromotionEnabled": { + SchemaProps: spec.SchemaProps{ + Description: "AutoPromotionEnabled indicates if the rollout should automatically promote the new ReplicaSet to the active service or enter a paused state. If not specified, the default value is true.", + Type: []string{"boolean"}, + Format: "", + }, + }, + "autoPromotionSeconds": { + SchemaProps: spec.SchemaProps{ + Description: "AutoPromotionSeconds is a duration in seconds in which to delay auto-promotion (default: 0). The countdown begins after the preview ReplicaSet have reached full availability. This option is ignored if autoPromotionEnabled is set to false.", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "maxUnavailable": { + SchemaProps: spec.SchemaProps{ + Description: "MaxUnavailable The maximum number of pods that can be unavailable during a restart operation. Defaults to 25% of total replicas.", + Ref: ref("k8s.io/apimachinery/pkg/util/intstr.IntOrString"), + }, + }, + "scaleDownDelaySeconds": { + SchemaProps: spec.SchemaProps{ + Description: "ScaleDownDelaySeconds adds a delay before scaling down the previous replicaset. If omitted, the Rollout waits 30 seconds before scaling down the previous ReplicaSet. A minimum of 30 seconds is recommended to ensure IP table propagation across the nodes in a cluster. See https://github.com/argoproj/argo-rollouts/issues/19#issuecomment-476329960 for more information", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "scaleDownDelayRevisionLimit": { + SchemaProps: spec.SchemaProps{ + Description: "ScaleDownDelayRevisionLimit limits the number of old RS that can run at one time before getting scaled down", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "prePromotionAnalysis": { + SchemaProps: spec.SchemaProps{ + Description: "PrePromotionAnalysis configuration to run analysis before a selector switch", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutAnalysis"), + }, + }, + "antiAffinity": { + SchemaProps: spec.SchemaProps{ + Description: "AntiAffinity enables anti-affinity rules for Blue Green deployment", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AntiAffinity"), + }, + }, + "postPromotionAnalysis": { + SchemaProps: spec.SchemaProps{ + Description: "PostPromotionAnalysis configuration to run analysis after a selector switch", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutAnalysis"), + }, + }, + "previewMetadata": { + SchemaProps: spec.SchemaProps{ + Description: "PreviewMetadata specify labels and annotations which will be attached to the preview pods for the duration which they act as a preview pod, and will be removed after", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.PodTemplateMetadata"), + }, + }, + "activeMetadata": { + SchemaProps: spec.SchemaProps{ + Description: "ActiveMetadata specify labels and annotations which will be attached to the active pods for the duration which they act as a active pod, and will be removed after", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.PodTemplateMetadata"), + }, + }, + "abortScaleDownDelaySeconds": { + SchemaProps: spec.SchemaProps{ + Description: "AbortScaleDownDelaySeconds adds a delay in second before scaling down the preview replicaset if update is aborted. 0 means not to scale down. Default is 30 second", + Type: []string{"integer"}, + Format: "int32", + }, + }, + }, + Required: []string{"activeService"}, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AntiAffinity", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.PodTemplateMetadata", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutAnalysis", "k8s.io/apimachinery/pkg/util/intstr.IntOrString"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_CanaryStatus(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "CanaryStatus status fields that only pertain to the canary rollout", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "currentStepAnalysisRunStatus": { + SchemaProps: spec.SchemaProps{ + Description: "CurrentStepAnalysisRunStatus indicates the status of the current step analysis run", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutAnalysisRunStatus"), + }, + }, + "currentBackgroundAnalysisRunStatus": { + SchemaProps: spec.SchemaProps{ + Description: "CurrentBackgroundAnalysisRunStatus indicates the status of the current background analysis run", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutAnalysisRunStatus"), + }, + }, + "currentExperiment": { + SchemaProps: spec.SchemaProps{ + Description: "CurrentExperiment indicates the running experiment", + Type: []string{"string"}, + Format: "", + }, + }, + "weights": { + SchemaProps: spec.SchemaProps{ + Description: "Weights records the weights which have been set on traffic provider. Only valid when using traffic routing", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.TrafficWeights"), + }, + }, + "stablePingPong": { + SchemaProps: spec.SchemaProps{ + Description: "StablePingPong For the ping-pong feature holds the current stable service, ping or pong", + Type: []string{"string"}, + Format: "", + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutAnalysisRunStatus", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.TrafficWeights"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_CanaryStep(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "CanaryStep defines a step of a canary deployment.", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "setWeight": { + SchemaProps: spec.SchemaProps{ + Description: "SetWeight sets what percentage of the newRS should receive", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "pause": { + SchemaProps: spec.SchemaProps{ + Description: "Pause freezes the rollout by setting spec.Paused to true. A Rollout will resume when spec.Paused is reset to false.", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutPause"), + }, + }, + "experiment": { + SchemaProps: spec.SchemaProps{ + Description: "Experiment defines the experiment object that should be created", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutExperimentStep"), + }, + }, + "analysis": { + SchemaProps: spec.SchemaProps{ + Description: "Analysis defines the AnalysisRun that will run for a step", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutAnalysis"), + }, + }, + "setCanaryScale": { + SchemaProps: spec.SchemaProps{ + Description: "SetCanaryScale defines how to scale the newRS without changing traffic weight", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.SetCanaryScale"), + }, + }, + "setHeaderRoute": { + SchemaProps: spec.SchemaProps{ + Description: "SetHeaderRoute defines the route with specified header name to send 100% of traffic to the canary service", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.SetHeaderRoute"), + }, + }, + "setMirrorRoute": { + SchemaProps: spec.SchemaProps{ + Description: "SetMirrorRoutes Mirrors traffic that matches rules to a particular destination", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.SetMirrorRoute"), + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutAnalysis", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutExperimentStep", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutPause", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.SetCanaryScale", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.SetHeaderRoute", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.SetMirrorRoute"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_CanaryStrategy(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "CanaryStrategy defines parameters for a Replica Based Canary", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "canaryService": { + SchemaProps: spec.SchemaProps{ + Description: "CanaryService holds the name of a service which selects pods with canary version and don't select any pods with stable version.", + Type: []string{"string"}, + Format: "", + }, + }, + "stableService": { + SchemaProps: spec.SchemaProps{ + Description: "StableService holds the name of a service which selects pods with stable version and don't select any pods with canary version.", + Type: []string{"string"}, + Format: "", + }, + }, + "steps": { + SchemaProps: spec.SchemaProps{ + Description: "Steps define the order of phases to execute the canary deployment", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.CanaryStep"), + }, + }, + }, + }, + }, + "trafficRouting": { + SchemaProps: spec.SchemaProps{ + Description: "TrafficRouting hosts all the supported service meshes supported to enable more fine-grained traffic routing", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutTrafficRouting"), + }, + }, + "maxUnavailable": { + SchemaProps: spec.SchemaProps{ + Description: "MaxUnavailable The maximum number of pods that can be unavailable during the update. Value can be an absolute number (ex: 5) or a percentage of total pods at the start of update (ex: 10%). Absolute number is calculated from percentage by rounding down. This can not be 0 if MaxSurge is 0. By default, a fixed value of 25% is used. Example: when this is set to 30%, the old RC can be scaled down by 30% immediately when the rolling update starts. Once new pods are ready, old RC can be scaled down further, followed by scaling up the new RC, ensuring that at least 70% of original number of pods are available at all times during the update.", + Ref: ref("k8s.io/apimachinery/pkg/util/intstr.IntOrString"), + }, + }, + "maxSurge": { + SchemaProps: spec.SchemaProps{ + Description: "MaxSurge The maximum number of pods that can be scheduled above the original number of pods. Value can be an absolute number (ex: 5) or a percentage of total pods at the start of the update (ex: 10%). This can not be 0 if MaxUnavailable is 0. Absolute number is calculated from percentage by rounding up. By default, a value of 25% is used. Example: when this is set to 30%, the new RC can be scaled up by 30% immediately when the rolling update starts. Once old pods have been killed, new RC can be scaled up further, ensuring that total number of pods running at any time during the update is at most 130% of original pods.", + Ref: ref("k8s.io/apimachinery/pkg/util/intstr.IntOrString"), + }, + }, + "analysis": { + SchemaProps: spec.SchemaProps{ + Description: "Analysis runs a separate analysisRun while all the steps execute. This is intended to be a continuous validation of the new ReplicaSet", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutAnalysisBackground"), + }, + }, + "antiAffinity": { + SchemaProps: spec.SchemaProps{ + Description: "AntiAffinity enables anti-affinity rules for Canary deployment", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AntiAffinity"), + }, + }, + "canaryMetadata": { + SchemaProps: spec.SchemaProps{ + Description: "CanaryMetadata specify labels and annotations which will be attached to the canary pods for the duration which they act as a canary, and will be removed after", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.PodTemplateMetadata"), + }, + }, + "stableMetadata": { + SchemaProps: spec.SchemaProps{ + Description: "StableMetadata specify labels and annotations which will be attached to the stable pods for the duration which they act as a canary, and will be removed after", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.PodTemplateMetadata"), + }, + }, + "scaleDownDelaySeconds": { + SchemaProps: spec.SchemaProps{ + Description: "ScaleDownDelaySeconds adds a delay before scaling down the previous ReplicaSet when the canary strategy is used with traffic routing (default 30 seconds). A delay in scaling down the previous ReplicaSet is needed after switching the stable service selector to point to the new ReplicaSet, in order to give time for traffic providers to re-target the new pods. This value is ignored with basic, replica-weighted canary without traffic routing.", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "scaleDownDelayRevisionLimit": { + SchemaProps: spec.SchemaProps{ + Description: "ScaleDownDelayRevisionLimit limits the number of old RS that can run at one time before getting scaled down", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "abortScaleDownDelaySeconds": { + SchemaProps: spec.SchemaProps{ + Description: "AbortScaleDownDelaySeconds adds a delay in second before scaling down the canary pods when update is aborted for canary strategy with traffic routing (not applicable for basic canary). 0 means canary pods are not scaled down. Default is 30 seconds.", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "dynamicStableScale": { + SchemaProps: spec.SchemaProps{ + Description: "DynamicStableScale is a traffic routing feature which dynamically scales the stable ReplicaSet to minimize total pods which are running during an update. This is calculated by scaling down the stable as traffic is increased to canary. When disabled (the default behavior) the stable ReplicaSet remains fully scaled to support instantaneous aborts.", + Type: []string{"boolean"}, + Format: "", + }, + }, + "pingPong": { + SchemaProps: spec.SchemaProps{ + Description: "PingPongSpec holds the ping and pong services", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.PingPongSpec"), + }, + }, + "minPodsPerReplicaSet": { + SchemaProps: spec.SchemaProps{ + Description: "Assuming the desired number of pods in a stable or canary ReplicaSet is not zero, then make sure it is at least MinPodsPerReplicaSet for High Availability. Only applicable for TrafficRoutedCanary", + Type: []string{"integer"}, + Format: "int32", + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AntiAffinity", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.CanaryStep", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.PingPongSpec", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.PodTemplateMetadata", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutAnalysisBackground", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutTrafficRouting", "k8s.io/apimachinery/pkg/util/intstr.IntOrString"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_CloudWatchMetric(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "CloudWatchMetric defines the cloudwatch query to perform canary analysis", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "interval": { + SchemaProps: spec.SchemaProps{ + Type: []string{"string"}, + Format: "", + }, + }, + "metricDataQueries": { + SchemaProps: spec.SchemaProps{ + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.CloudWatchMetricDataQuery"), + }, + }, + }, + }, + }, + }, + Required: []string{"metricDataQueries"}, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.CloudWatchMetricDataQuery"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_CloudWatchMetricDataQuery(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "CloudWatchMetricDataQuery defines the cloudwatch query", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "id": { + SchemaProps: spec.SchemaProps{ + Type: []string{"string"}, + Format: "", + }, + }, + "expression": { + SchemaProps: spec.SchemaProps{ + Type: []string{"string"}, + Format: "", + }, + }, + "label": { + SchemaProps: spec.SchemaProps{ + Type: []string{"string"}, + Format: "", + }, + }, + "metricStat": { + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.CloudWatchMetricStat"), + }, + }, + "period": { + SchemaProps: spec.SchemaProps{ + Ref: ref("k8s.io/apimachinery/pkg/util/intstr.IntOrString"), + }, + }, + "returnData": { + SchemaProps: spec.SchemaProps{ + Type: []string{"boolean"}, + Format: "", + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.CloudWatchMetricStat", "k8s.io/apimachinery/pkg/util/intstr.IntOrString"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_CloudWatchMetricStat(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "metric": { + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.CloudWatchMetricStatMetric"), + }, + }, + "period": { + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("k8s.io/apimachinery/pkg/util/intstr.IntOrString"), + }, + }, + "stat": { + SchemaProps: spec.SchemaProps{ + Type: []string{"string"}, + Format: "", + }, + }, + "unit": { + SchemaProps: spec.SchemaProps{ + Type: []string{"string"}, + Format: "", + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.CloudWatchMetricStatMetric", "k8s.io/apimachinery/pkg/util/intstr.IntOrString"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_CloudWatchMetricStatMetric(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "dimensions": { + SchemaProps: spec.SchemaProps{ + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.CloudWatchMetricStatMetricDimension"), + }, + }, + }, + }, + }, + "metricName": { + SchemaProps: spec.SchemaProps{ + Type: []string{"string"}, + Format: "", + }, + }, + "namespace": { + SchemaProps: spec.SchemaProps{ + Type: []string{"string"}, + Format: "", + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.CloudWatchMetricStatMetricDimension"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_CloudWatchMetricStatMetricDimension(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "name": { + SchemaProps: spec.SchemaProps{ + Type: []string{"string"}, + Format: "", + }, + }, + "value": { + SchemaProps: spec.SchemaProps{ + Type: []string{"string"}, + Format: "", + }, + }, + }, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_ClusterAnalysisTemplate(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "ClusterAnalysisTemplate holds the template for performing canary analysis", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "kind": { + SchemaProps: spec.SchemaProps{ + Description: "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + Type: []string{"string"}, + Format: "", + }, + }, + "apiVersion": { + SchemaProps: spec.SchemaProps{ + Description: "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + Type: []string{"string"}, + Format: "", + }, + }, + "metadata": { + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.ObjectMeta"), + }, + }, + "spec": { + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AnalysisTemplateSpec"), + }, + }, + }, + Required: []string{"spec"}, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AnalysisTemplateSpec", "k8s.io/apimachinery/pkg/apis/meta/v1.ObjectMeta"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_ClusterAnalysisTemplateList(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "AnalysisTemplateList is a list of AnalysisTemplate resources", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "kind": { + SchemaProps: spec.SchemaProps{ + Description: "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + Type: []string{"string"}, + Format: "", + }, + }, + "apiVersion": { + SchemaProps: spec.SchemaProps{ + Description: "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + Type: []string{"string"}, + Format: "", + }, + }, + "metadata": { + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.ListMeta"), + }, + }, + "items": { + SchemaProps: spec.SchemaProps{ + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ClusterAnalysisTemplate"), + }, + }, + }, + }, + }, + }, + Required: []string{"metadata", "items"}, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ClusterAnalysisTemplate", "k8s.io/apimachinery/pkg/apis/meta/v1.ListMeta"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_DatadogMetric(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "interval": { + SchemaProps: spec.SchemaProps{ + Type: []string{"string"}, + Format: "", + }, + }, + "query": { + SchemaProps: spec.SchemaProps{ + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "apiVersion": { + SchemaProps: spec.SchemaProps{ + Description: "ApiVersion refers to the Datadog API version being used (default: v1). v1 will eventually be deprecated.", + Type: []string{"string"}, + Format: "", + }, + }, + }, + Required: []string{"query"}, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_DryRun(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "DryRun defines the settings for running the analysis in Dry-Run mode.", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "metricName": { + SchemaProps: spec.SchemaProps{ + Description: "Name of the metric which needs to be evaluated in the Dry-Run mode. Wildcard '*' is supported and denotes all the available metrics.", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + }, + Required: []string{"metricName"}, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_Experiment(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "Experiment is a specification for an Experiment resource", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "kind": { + SchemaProps: spec.SchemaProps{ + Description: "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + Type: []string{"string"}, + Format: "", + }, + }, + "apiVersion": { + SchemaProps: spec.SchemaProps{ + Description: "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + Type: []string{"string"}, + Format: "", + }, + }, + "metadata": { + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.ObjectMeta"), + }, + }, + "spec": { + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ExperimentSpec"), + }, + }, + "status": { + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ExperimentStatus"), + }, + }, + }, + Required: []string{"spec"}, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ExperimentSpec", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ExperimentStatus", "k8s.io/apimachinery/pkg/apis/meta/v1.ObjectMeta"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_ExperimentAnalysisRunStatus(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "name": { + SchemaProps: spec.SchemaProps{ + Description: "Name is the name of the analysis", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "analysisRun": { + SchemaProps: spec.SchemaProps{ + Description: "AnalysisRun is the name of the AnalysisRun", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "phase": { + SchemaProps: spec.SchemaProps{ + Description: "Phase is the status of the AnalysisRun", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "message": { + SchemaProps: spec.SchemaProps{ + Description: "Message is a message explaining the current status", + Type: []string{"string"}, + Format: "", + }, + }, + }, + Required: []string{"name", "analysisRun", "phase"}, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_ExperimentAnalysisTemplateRef(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "name": { + SchemaProps: spec.SchemaProps{ + Description: "Name is the name of the analysis", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "templateName": { + SchemaProps: spec.SchemaProps{ + Description: "TemplateName reference of the AnalysisTemplate name used by the Experiment to create the run", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "clusterScope": { + SchemaProps: spec.SchemaProps{ + Description: "Whether to look for the templateName at cluster scope or namespace scope", + Type: []string{"boolean"}, + Format: "", + }, + }, + "args": { + VendorExtensible: spec.VendorExtensible{ + Extensions: spec.Extensions{ + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge", + }, + }, + SchemaProps: spec.SchemaProps{ + Description: "Args are the arguments that will be added to the AnalysisRuns", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.Argument"), + }, + }, + }, + }, + }, + "requiredForCompletion": { + SchemaProps: spec.SchemaProps{ + Description: "RequiredForCompletion blocks the Experiment from completing until the analysis has completed", + Type: []string{"boolean"}, + Format: "", + }, + }, + }, + Required: []string{"name", "templateName"}, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.Argument"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_ExperimentCondition(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "ExperimentCondition describes the state of a experiment at a certain point.", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "type": { + SchemaProps: spec.SchemaProps{ + Description: "Type of deployment condition.", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "status": { + SchemaProps: spec.SchemaProps{ + Description: "Phase of the condition, one of True, False, Unknown.", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "lastUpdateTime": { + SchemaProps: spec.SchemaProps{ + Description: "The last time this condition was updated.", + Default: map[string]interface{}{}, + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.Time"), + }, + }, + "lastTransitionTime": { + SchemaProps: spec.SchemaProps{ + Description: "Last time the condition transitioned from one status to another.", + Default: map[string]interface{}{}, + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.Time"), + }, + }, + "reason": { + SchemaProps: spec.SchemaProps{ + Description: "The reason for the condition's last transition.", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "message": { + SchemaProps: spec.SchemaProps{ + Description: "A human readable message indicating details about the transition.", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + }, + Required: []string{"type", "status", "lastUpdateTime", "lastTransitionTime", "reason", "message"}, + }, + }, + Dependencies: []string{ + "k8s.io/apimachinery/pkg/apis/meta/v1.Time"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_ExperimentList(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "ExperimentList is a list of Experiment resources", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "kind": { + SchemaProps: spec.SchemaProps{ + Description: "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + Type: []string{"string"}, + Format: "", + }, + }, + "apiVersion": { + SchemaProps: spec.SchemaProps{ + Description: "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + Type: []string{"string"}, + Format: "", + }, + }, + "metadata": { + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.ListMeta"), + }, + }, + "items": { + SchemaProps: spec.SchemaProps{ + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.Experiment"), + }, + }, + }, + }, + }, + }, + Required: []string{"metadata", "items"}, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.Experiment", "k8s.io/apimachinery/pkg/apis/meta/v1.ListMeta"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_ExperimentSpec(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "ExperimentSpec is the spec for a Experiment resource", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "templates": { + VendorExtensible: spec.VendorExtensible{ + Extensions: spec.Extensions{ + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge", + }, + }, + SchemaProps: spec.SchemaProps{ + Description: "Templates are a list of PodSpecs that define the ReplicaSets that should be run during an experiment.", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.TemplateSpec"), + }, + }, + }, + }, + }, + "duration": { + SchemaProps: spec.SchemaProps{ + Description: "Duration the amount of time for the experiment to run as a duration string (e.g. 30s, 5m, 1h). If omitted, the experiment will run indefinitely, stopped either via termination, or a failed analysis run.", + Type: []string{"string"}, + Format: "", + }, + }, + "progressDeadlineSeconds": { + SchemaProps: spec.SchemaProps{ + Description: "ProgressDeadlineSeconds The maximum time in seconds for a experiment to make progress before it is considered to be failed. Argo Rollouts will continue to process failed experiments and a condition with a ProgressDeadlineExceeded reason will be surfaced in the experiment status. Defaults to 600s.", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "terminate": { + SchemaProps: spec.SchemaProps{ + Description: "Terminate is used to prematurely stop the experiment", + Type: []string{"boolean"}, + Format: "", + }, + }, + "analyses": { + VendorExtensible: spec.VendorExtensible{ + Extensions: spec.Extensions{ + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge", + }, + }, + SchemaProps: spec.SchemaProps{ + Description: "Analyses references AnalysisTemplates to run during the experiment", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ExperimentAnalysisTemplateRef"), + }, + }, + }, + }, + }, + "scaleDownDelaySeconds": { + SchemaProps: spec.SchemaProps{ + Description: "ScaleDownDelaySeconds adds a delay before scaling down the Experiment. If omitted, the Experiment waits 30 seconds before scaling down. A minimum of 30 seconds is recommended to ensure IP table propagation across the nodes in a cluster. See https://github.com/argoproj/argo-rollouts/issues/19#issuecomment-476329960 for more information", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "dryRun": { + VendorExtensible: spec.VendorExtensible{ + Extensions: spec.Extensions{ + "x-kubernetes-patch-merge-key": "metricName", + "x-kubernetes-patch-strategy": "merge", + }, + }, + SchemaProps: spec.SchemaProps{ + Description: "DryRun object contains the settings for running the analysis in Dry-Run mode", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.DryRun"), + }, + }, + }, + }, + }, + "measurementRetention": { + VendorExtensible: spec.VendorExtensible{ + Extensions: spec.Extensions{ + "x-kubernetes-patch-merge-key": "metricName", + "x-kubernetes-patch-strategy": "merge", + }, + }, + SchemaProps: spec.SchemaProps{ + Description: "MeasurementRetention object contains the settings for retaining the number of measurements during the analysis", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.MeasurementRetention"), + }, + }, + }, + }, + }, + }, + Required: []string{"templates"}, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.DryRun", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ExperimentAnalysisTemplateRef", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.MeasurementRetention", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.TemplateSpec"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_ExperimentStatus(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "ExperimentStatus is the status for a Experiment resource", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "phase": { + SchemaProps: spec.SchemaProps{ + Description: "Phase is the status of the experiment. Takes into consideration ReplicaSet degradations and AnalysisRun statuses", + Type: []string{"string"}, + Format: "", + }, + }, + "message": { + SchemaProps: spec.SchemaProps{ + Description: "Message is an explanation for the current status", + Type: []string{"string"}, + Format: "", + }, + }, + "templateStatuses": { + SchemaProps: spec.SchemaProps{ + Description: "TemplateStatuses holds the ReplicaSet related statuses for individual templates", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.TemplateStatus"), + }, + }, + }, + }, + }, + "availableAt": { + SchemaProps: spec.SchemaProps{ + Description: "AvailableAt the time when all the templates become healthy and the experiment should start tracking the time to run for the duration of specificed in the spec.", + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.Time"), + }, + }, + "conditions": { + SchemaProps: spec.SchemaProps{ + Description: "Conditions a list of conditions a experiment can have.", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ExperimentCondition"), + }, + }, + }, + }, + }, + "analysisRuns": { + SchemaProps: spec.SchemaProps{ + Description: "AnalysisRuns tracks the status of AnalysisRuns associated with this Experiment", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ExperimentAnalysisRunStatus"), + }, + }, + }, + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ExperimentAnalysisRunStatus", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ExperimentCondition", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.TemplateStatus", "k8s.io/apimachinery/pkg/apis/meta/v1.Time"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_FieldRef(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "fieldPath": { + SchemaProps: spec.SchemaProps{ + Description: "Required: Path of the field to select in the specified API version", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + }, + Required: []string{"fieldPath"}, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_GraphiteMetric(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "GraphiteMetric defines the Graphite query to perform canary analysis", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "address": { + SchemaProps: spec.SchemaProps{ + Description: "Address is the HTTP address and port of the Graphite server", + Type: []string{"string"}, + Format: "", + }, + }, + "query": { + SchemaProps: spec.SchemaProps{ + Description: "Query is a raw Graphite query to perform", + Type: []string{"string"}, + Format: "", + }, + }, + }, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_HeaderRoutingMatch(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "headerName": { + SchemaProps: spec.SchemaProps{ + Description: "HeaderName the name of the request header", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "headerValue": { + SchemaProps: spec.SchemaProps{ + Description: "HeaderValue the value of the header", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.StringMatch"), + }, + }, + }, + Required: []string{"headerName", "headerValue"}, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.StringMatch"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_InfluxdbMetric(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "InfluxdbMetric defines the InfluxDB Flux query to perform canary analysis", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "profile": { + SchemaProps: spec.SchemaProps{ + Description: "Profile is the name of the secret holding InfluxDB account configuration", + Type: []string{"string"}, + Format: "", + }, + }, + "query": { + SchemaProps: spec.SchemaProps{ + Description: "Query is a raw InfluxDB flux query to perform", + Type: []string{"string"}, + Format: "", + }, + }, + }, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_IstioDestinationRule(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "IstioDestinationRule is a reference to an Istio DestinationRule to modify and shape traffic", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "name": { + SchemaProps: spec.SchemaProps{ + Description: "Name holds the name of the DestinationRule", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "canarySubsetName": { + SchemaProps: spec.SchemaProps{ + Description: "CanarySubsetName is the subset name to modify labels with canary ReplicaSet pod template hash value", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "stableSubsetName": { + SchemaProps: spec.SchemaProps{ + Description: "StableSubsetName is the subset name to modify labels with stable ReplicaSet pod template hash value", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + }, + Required: []string{"name", "canarySubsetName", "stableSubsetName"}, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_IstioTrafficRouting(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "IstioTrafficRouting configuration for Istio service mesh to enable fine grain configuration", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "virtualService": { + SchemaProps: spec.SchemaProps{ + Description: "VirtualService references an Istio VirtualService to modify to shape traffic", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.IstioVirtualService"), + }, + }, + "destinationRule": { + SchemaProps: spec.SchemaProps{ + Description: "DestinationRule references an Istio DestinationRule to modify to shape traffic", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.IstioDestinationRule"), + }, + }, + "virtualServices": { + SchemaProps: spec.SchemaProps{ + Description: "VirtualServices references a list of Istio VirtualService to modify to shape traffic", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.IstioVirtualService"), + }, + }, + }, + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.IstioDestinationRule", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.IstioVirtualService"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_IstioVirtualService(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "IstioVirtualService holds information on the virtual service the rollout needs to modify", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "name": { + SchemaProps: spec.SchemaProps{ + Description: "Name holds the name of the VirtualService", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "routes": { + SchemaProps: spec.SchemaProps{ + Description: "A list of HTTP routes within VirtualService to edit. If omitted, VirtualService must have a single route of this type.", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + }, + }, + }, + "tlsRoutes": { + SchemaProps: spec.SchemaProps{ + Description: "A list of TLS/HTTPS routes within VirtualService to edit. If omitted, VirtualService must have a single route of this type.", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.TLSRoute"), + }, + }, + }, + }, + }, + "tcpRoutes": { + SchemaProps: spec.SchemaProps{ + Description: "A list of TCP routes within VirtualService to edit. If omitted, VirtualService must have a single route of this type.", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.TCPRoute"), + }, + }, + }, + }, + }, + }, + Required: []string{"name"}, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.TCPRoute", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.TLSRoute"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_JobMetric(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "JobMetric defines a job to run which acts as a metric", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "metadata": { + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.ObjectMeta"), + }, + }, + "spec": { + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("k8s.io/api/batch/v1.JobSpec"), + }, + }, + }, + Required: []string{"spec"}, + }, + }, + Dependencies: []string{ + "k8s.io/api/batch/v1.JobSpec", "k8s.io/apimachinery/pkg/apis/meta/v1.ObjectMeta"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_KayentaMetric(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "address": { + SchemaProps: spec.SchemaProps{ + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "application": { + SchemaProps: spec.SchemaProps{ + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "canaryConfigName": { + SchemaProps: spec.SchemaProps{ + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "metricsAccountName": { + SchemaProps: spec.SchemaProps{ + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "configurationAccountName": { + SchemaProps: spec.SchemaProps{ + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "storageAccountName": { + SchemaProps: spec.SchemaProps{ + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "threshold": { + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.KayentaThreshold"), + }, + }, + "scopes": { + SchemaProps: spec.SchemaProps{ + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.KayentaScope"), + }, + }, + }, + }, + }, + }, + Required: []string{"address", "application", "canaryConfigName", "metricsAccountName", "configurationAccountName", "storageAccountName", "threshold", "scopes"}, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.KayentaScope", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.KayentaThreshold"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_KayentaScope(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "name": { + SchemaProps: spec.SchemaProps{ + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "controlScope": { + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ScopeDetail"), + }, + }, + "experimentScope": { + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ScopeDetail"), + }, + }, + }, + Required: []string{"name", "controlScope", "experimentScope"}, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ScopeDetail"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_KayentaThreshold(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "pass": { + SchemaProps: spec.SchemaProps{ + Default: 0, + Type: []string{"integer"}, + Format: "int64", + }, + }, + "marginal": { + SchemaProps: spec.SchemaProps{ + Default: 0, + Type: []string{"integer"}, + Format: "int64", + }, + }, + }, + Required: []string{"pass", "marginal"}, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_MangedRoutes(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "name": { + SchemaProps: spec.SchemaProps{ + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + }, + Required: []string{"name"}, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_Measurement(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "Measurement is a point in time result value of a single metric, and the time it was measured", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "phase": { + SchemaProps: spec.SchemaProps{ + Description: "Phase is the status of this single measurement", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "message": { + SchemaProps: spec.SchemaProps{ + Description: "Message contains a message describing current condition (e.g. error messages)", + Type: []string{"string"}, + Format: "", + }, + }, + "startedAt": { + SchemaProps: spec.SchemaProps{ + Description: "StartedAt is the timestamp in which this measurement started to be measured", + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.Time"), + }, + }, + "finishedAt": { + SchemaProps: spec.SchemaProps{ + Description: "FinishedAt is the timestamp in which this measurement completed and value was collected", + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.Time"), + }, + }, + "value": { + SchemaProps: spec.SchemaProps{ + Description: "Value is the measured value of the metric", + Type: []string{"string"}, + Format: "", + }, + }, + "metadata": { + SchemaProps: spec.SchemaProps{ + Description: "Metadata stores additional metadata about this metric result, used by the different providers (e.g. kayenta run ID, job name)", + Type: []string{"object"}, + AdditionalProperties: &spec.SchemaOrBool{ + Allows: true, + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + }, + }, + }, + "resumeAt": { + SchemaProps: spec.SchemaProps{ + Description: "ResumeAt is the timestamp when the analysisRun should try to resume the measurement", + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.Time"), + }, + }, + }, + Required: []string{"phase"}, + }, + }, + Dependencies: []string{ + "k8s.io/apimachinery/pkg/apis/meta/v1.Time"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_MeasurementRetention(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "MeasurementRetention defines the settings for retaining the number of measurements during the analysis.", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "metricName": { + SchemaProps: spec.SchemaProps{ + Description: "MetricName is the name of the metric on which this retention policy should be applied.", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "limit": { + SchemaProps: spec.SchemaProps{ + Description: "Limit is the maximum number of measurements to be retained for this given metric.", + Default: 0, + Type: []string{"integer"}, + Format: "int32", + }, + }, + }, + Required: []string{"metricName", "limit"}, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_Metric(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "Metric defines a metric in which to perform analysis", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "name": { + SchemaProps: spec.SchemaProps{ + Description: "Name is the name of the metric", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "interval": { + SchemaProps: spec.SchemaProps{ + Description: "Interval defines an interval string (e.g. 30s, 5m, 1h) between each measurement. If omitted, will perform a single measurement", + Type: []string{"string"}, + Format: "", + }, + }, + "initialDelay": { + SchemaProps: spec.SchemaProps{ + Description: "InitialDelay how long the AnalysisRun should wait before starting this metric", + Type: []string{"string"}, + Format: "", + }, + }, + "count": { + SchemaProps: spec.SchemaProps{ + Description: "Count is the number of times to run the measurement. If both interval and count are omitted, the effective count is 1. If only interval is specified, metric runs indefinitely. If count > 1, interval must be specified.", + Ref: ref("k8s.io/apimachinery/pkg/util/intstr.IntOrString"), + }, + }, + "successCondition": { + SchemaProps: spec.SchemaProps{ + Description: "SuccessCondition is an expression which determines if a measurement is considered successful Expression is a goevaluate expression. The keyword `result` is a variable reference to the value of measurement. Results can be both structured data or primitive. Examples:\n result > 10\n (result.requests_made * result.requests_succeeded / 100) >= 90", + Type: []string{"string"}, + Format: "", + }, + }, + "failureCondition": { + SchemaProps: spec.SchemaProps{ + Description: "FailureCondition is an expression which determines if a measurement is considered failed If both success and failure conditions are specified, and the measurement does not fall into either condition, the measurement is considered Inconclusive", + Type: []string{"string"}, + Format: "", + }, + }, + "failureLimit": { + SchemaProps: spec.SchemaProps{ + Description: "FailureLimit is the maximum number of times the measurement is allowed to fail, before the entire metric is considered Failed (default: 0)", + Ref: ref("k8s.io/apimachinery/pkg/util/intstr.IntOrString"), + }, + }, + "inconclusiveLimit": { + SchemaProps: spec.SchemaProps{ + Description: "InconclusiveLimit is the maximum number of times the measurement is allowed to measure Inconclusive, before the entire metric is considered Inconclusive (default: 0)", + Ref: ref("k8s.io/apimachinery/pkg/util/intstr.IntOrString"), + }, + }, + "consecutiveErrorLimit": { + SchemaProps: spec.SchemaProps{ + Description: "ConsecutiveErrorLimit is the maximum number of times the measurement is allowed to error in succession, before the metric is considered error (default: 4)", + Ref: ref("k8s.io/apimachinery/pkg/util/intstr.IntOrString"), + }, + }, + "provider": { + SchemaProps: spec.SchemaProps{ + Description: "Provider configuration to the external system to use to verify the analysis", + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.MetricProvider"), + }, + }, + }, + Required: []string{"name", "provider"}, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.MetricProvider", "k8s.io/apimachinery/pkg/util/intstr.IntOrString"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_MetricProvider(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "MetricProvider which external system to use to verify the analysis Only one of the fields in this struct should be non-nil", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "prometheus": { + SchemaProps: spec.SchemaProps{ + Description: "Prometheus specifies the prometheus metric to query", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.PrometheusMetric"), + }, + }, + "kayenta": { + SchemaProps: spec.SchemaProps{ + Description: "Kayenta specifies a Kayenta metric", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.KayentaMetric"), + }, + }, + "web": { + SchemaProps: spec.SchemaProps{ + Description: "Web specifies a generic HTTP web metric", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.WebMetric"), + }, + }, + "datadog": { + SchemaProps: spec.SchemaProps{ + Description: "Datadog specifies a datadog metric to query", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.DatadogMetric"), + }, + }, + "wavefront": { + SchemaProps: spec.SchemaProps{ + Description: "Wavefront specifies the wavefront metric to query", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.WavefrontMetric"), + }, + }, + "newRelic": { + SchemaProps: spec.SchemaProps{ + Description: "NewRelic specifies the newrelic metric to query", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.NewRelicMetric"), + }, + }, + "job": { + SchemaProps: spec.SchemaProps{ + Description: "Job specifies the job metric run", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.JobMetric"), + }, + }, + "cloudWatch": { + SchemaProps: spec.SchemaProps{ + Description: "CloudWatch specifies the cloudWatch metric to query", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.CloudWatchMetric"), + }, + }, + "graphite": { + SchemaProps: spec.SchemaProps{ + Description: "Graphite specifies the Graphite metric to query", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.GraphiteMetric"), + }, + }, + "influxdb": { + SchemaProps: spec.SchemaProps{ + Description: "Influxdb specifies the influxdb metric to query", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.InfluxdbMetric"), + }, + }, + "skywalking": { + SchemaProps: spec.SchemaProps{ + Description: "SkyWalking specifies the skywalking metric to query", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.SkyWalkingMetric"), + }, + }, + "plugin": { + SchemaProps: spec.SchemaProps{ + Description: "Plugin specifies the hashicorp go-plugin metric to query", + Type: []string{"object"}, + AdditionalProperties: &spec.SchemaOrBool{ + Allows: true, + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"string"}, + Format: "byte", + }, + }, + }, + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.CloudWatchMetric", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.DatadogMetric", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.GraphiteMetric", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.InfluxdbMetric", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.JobMetric", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.KayentaMetric", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.NewRelicMetric", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.PrometheusMetric", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.SkyWalkingMetric", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.WavefrontMetric", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.WebMetric"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_MetricResult(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "MetricResult contain a list of the most recent measurements for a single metric along with counters on how often the measurement", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "name": { + SchemaProps: spec.SchemaProps{ + Description: "Name is the name of the metric", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "phase": { + SchemaProps: spec.SchemaProps{ + Description: "Phase is the overall aggregate status of the metric", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "measurements": { + SchemaProps: spec.SchemaProps{ + Description: "Measurements holds the most recent measurements collected for the metric", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.Measurement"), + }, + }, + }, + }, + }, + "message": { + SchemaProps: spec.SchemaProps{ + Description: "Message contains a message describing current condition (e.g. error messages)", + Type: []string{"string"}, + Format: "", + }, + }, + "count": { + SchemaProps: spec.SchemaProps{ + Description: "Count is the number of times the metric was measured without Error This is equal to the sum of Successful, Failed, Inconclusive", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "successful": { + SchemaProps: spec.SchemaProps{ + Description: "Successful is the number of times the metric was measured Successful", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "failed": { + SchemaProps: spec.SchemaProps{ + Description: "Failed is the number of times the metric was measured Failed", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "inconclusive": { + SchemaProps: spec.SchemaProps{ + Description: "Inconclusive is the number of times the metric was measured Inconclusive", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "error": { + SchemaProps: spec.SchemaProps{ + Description: "Error is the number of times an error was encountered during measurement", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "consecutiveError": { + SchemaProps: spec.SchemaProps{ + Description: "ConsecutiveError is the number of times an error was encountered during measurement in succession Resets to zero when non-errors are encountered", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "dryRun": { + SchemaProps: spec.SchemaProps{ + Description: "DryRun indicates whether this metric is running in a dry-run mode or not", + Type: []string{"boolean"}, + Format: "", + }, + }, + "metadata": { + SchemaProps: spec.SchemaProps{ + Description: "Metadata stores additional metadata about this metric. It is used by different providers to store the final state which gets used while taking measurements. For example, Prometheus uses this field to store the final resolved query after substituting the template arguments.", + Type: []string{"object"}, + AdditionalProperties: &spec.SchemaOrBool{ + Allows: true, + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + }, + }, + }, + }, + Required: []string{"name", "phase"}, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.Measurement"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_NewRelicMetric(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "NewRelicMetric defines the newrelic query to perform canary analysis", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "profile": { + SchemaProps: spec.SchemaProps{ + Description: "Profile is the name of the secret holding NR account configuration", + Type: []string{"string"}, + Format: "", + }, + }, + "query": { + SchemaProps: spec.SchemaProps{ + Description: "Query is a raw newrelic NRQL query to perform", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + }, + Required: []string{"query"}, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_NginxTrafficRouting(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "NginxTrafficRouting configuration for Nginx ingress controller to control traffic routing", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "annotationPrefix": { + SchemaProps: spec.SchemaProps{ + Description: "AnnotationPrefix has to match the configured annotation prefix on the nginx ingress controller", + Type: []string{"string"}, + Format: "", + }, + }, + "stableIngress": { + SchemaProps: spec.SchemaProps{ + Description: "StableIngress refers to the name of an `Ingress` resource in the same namespace as the `Rollout`", + Type: []string{"string"}, + Format: "", + }, + }, + "additionalIngressAnnotations": { + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + AdditionalProperties: &spec.SchemaOrBool{ + Allows: true, + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + }, + }, + }, + "stableIngresses": { + SchemaProps: spec.SchemaProps{ + Description: "StableIngresses refers to the names of `Ingress` resources in the same namespace as the `Rollout` in a multi ingress scenario", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + }, + }, + }, + }, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_ObjectRef(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "ObjectRef holds a references to the Kubernetes object", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "apiVersion": { + SchemaProps: spec.SchemaProps{ + Description: "API Version of the referent", + Type: []string{"string"}, + Format: "", + }, + }, + "kind": { + SchemaProps: spec.SchemaProps{ + Description: "Kind of the referent", + Type: []string{"string"}, + Format: "", + }, + }, + "name": { + SchemaProps: spec.SchemaProps{ + Description: "Name of the referent", + Type: []string{"string"}, + Format: "", + }, + }, + }, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_PauseCondition(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "PauseCondition the reason for a pause and when it started", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "reason": { + SchemaProps: spec.SchemaProps{ + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "startTime": { + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.Time"), + }, + }, + }, + Required: []string{"reason", "startTime"}, + }, + }, + Dependencies: []string{ + "k8s.io/apimachinery/pkg/apis/meta/v1.Time"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_PingPongSpec(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "PingPongSpec holds the ping and pong service name.", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "pingService": { + SchemaProps: spec.SchemaProps{ + Description: "name of the ping service", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "pongService": { + SchemaProps: spec.SchemaProps{ + Description: "name of the pong service", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + }, + Required: []string{"pingService", "pongService"}, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_PodTemplateMetadata(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "PodTemplateMetadata extra labels to add to the template", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "labels": { + SchemaProps: spec.SchemaProps{ + Description: "Labels Additional labels to add to the experiment", + Type: []string{"object"}, + AdditionalProperties: &spec.SchemaOrBool{ + Allows: true, + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + }, + }, + }, + "annotations": { + SchemaProps: spec.SchemaProps{ + Description: "Annotations additional annotations to add to the experiment", + Type: []string{"object"}, + AdditionalProperties: &spec.SchemaOrBool{ + Allows: true, + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + }, + }, + }, + }, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_PreferredDuringSchedulingIgnoredDuringExecution(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "PreferredDuringSchedulingIgnoredDuringExecution defines the weight of the anti-affinity injection", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "weight": { + SchemaProps: spec.SchemaProps{ + Description: "Weight associated with matching the corresponding podAffinityTerm, in the range 1-100.", + Default: 0, + Type: []string{"integer"}, + Format: "int32", + }, + }, + }, + Required: []string{"weight"}, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_PrometheusAuth(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "PrometheusMetric defines the prometheus query to perform canary analysis", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "sigv4": { + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.Sigv4Config"), + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.Sigv4Config"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_PrometheusMetric(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "PrometheusMetric defines the prometheus query to perform canary analysis", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "address": { + SchemaProps: spec.SchemaProps{ + Description: "Address is the HTTP address and port of the prometheus server", + Type: []string{"string"}, + Format: "", + }, + }, + "query": { + SchemaProps: spec.SchemaProps{ + Description: "Query is a raw prometheus query to perform", + Type: []string{"string"}, + Format: "", + }, + }, + "authentication": { + SchemaProps: spec.SchemaProps{ + Description: "Sigv4 Config is the aws SigV4 configuration to use for SigV4 signing if using Amazon Managed Prometheus", + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.PrometheusAuth"), + }, + }, + "timeout": { + SchemaProps: spec.SchemaProps{ + Description: "Timeout represents the duration within which a prometheus query should complete. It is expressed in seconds.", + Type: []string{"integer"}, + Format: "int64", + }, + }, + "insecure": { + SchemaProps: spec.SchemaProps{ + Description: "Insecure skips host TLS verification", + Type: []string{"boolean"}, + Format: "", + }, + }, + "headers": { + VendorExtensible: spec.VendorExtensible{ + Extensions: spec.Extensions{ + "x-kubernetes-patch-merge-key": "key", + "x-kubernetes-patch-strategy": "merge", + }, + }, + SchemaProps: spec.SchemaProps{ + Description: "Headers are optional HTTP headers to use in the request", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.WebMetricHeader"), + }, + }, + }, + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.PrometheusAuth", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.WebMetricHeader"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_RequiredDuringSchedulingIgnoredDuringExecution(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "RequiredDuringSchedulingIgnoredDuringExecution defines inter-pod scheduling rule to be RequiredDuringSchedulingIgnoredDuringExecution", + Type: []string{"object"}, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_RollbackWindowSpec(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "revisions": { + SchemaProps: spec.SchemaProps{ + Type: []string{"integer"}, + Format: "int32", + }, + }, + }, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_Rollout(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "Rollout is a specification for a Rollout resource", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "kind": { + SchemaProps: spec.SchemaProps{ + Description: "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + Type: []string{"string"}, + Format: "", + }, + }, + "apiVersion": { + SchemaProps: spec.SchemaProps{ + Description: "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + Type: []string{"string"}, + Format: "", + }, + }, + "metadata": { + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.ObjectMeta"), + }, + }, + "spec": { + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutSpec"), + }, + }, + "status": { + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutStatus"), + }, + }, + }, + Required: []string{"spec"}, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutSpec", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutStatus", "k8s.io/apimachinery/pkg/apis/meta/v1.ObjectMeta"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_RolloutAnalysis(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "RolloutAnalysis defines a template that is used to create a analysisRun", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "templates": { + VendorExtensible: spec.VendorExtensible{ + Extensions: spec.Extensions{ + "x-kubernetes-patch-merge-key": "templateName", + "x-kubernetes-patch-strategy": "merge", + }, + }, + SchemaProps: spec.SchemaProps{ + Description: "Templates reference to a list of analysis templates to combine for an AnalysisRun", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutAnalysisTemplate"), + }, + }, + }, + }, + }, + "args": { + VendorExtensible: spec.VendorExtensible{ + Extensions: spec.Extensions{ + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge", + }, + }, + SchemaProps: spec.SchemaProps{ + Description: "Args the arguments that will be added to the AnalysisRuns", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AnalysisRunArgument"), + }, + }, + }, + }, + }, + "dryRun": { + VendorExtensible: spec.VendorExtensible{ + Extensions: spec.Extensions{ + "x-kubernetes-patch-merge-key": "metricName", + "x-kubernetes-patch-strategy": "merge", + }, + }, + SchemaProps: spec.SchemaProps{ + Description: "DryRun object contains the settings for running the analysis in Dry-Run mode", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.DryRun"), + }, + }, + }, + }, + }, + "measurementRetention": { + VendorExtensible: spec.VendorExtensible{ + Extensions: spec.Extensions{ + "x-kubernetes-patch-merge-key": "metricName", + "x-kubernetes-patch-strategy": "merge", + }, + }, + SchemaProps: spec.SchemaProps{ + Description: "MeasurementRetention object contains the settings for retaining the number of measurements during the analysis", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.MeasurementRetention"), + }, + }, + }, + }, + }, + "analysisRunMetadata": { + SchemaProps: spec.SchemaProps{ + Description: "AnalysisRunMetadata labels and annotations that will be added to the AnalysisRuns", + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AnalysisRunMetadata"), + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AnalysisRunArgument", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AnalysisRunMetadata", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.DryRun", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.MeasurementRetention", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutAnalysisTemplate"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_RolloutAnalysisBackground(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "RolloutAnalysisBackground defines a template that is used to create a background analysisRun", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "templates": { + VendorExtensible: spec.VendorExtensible{ + Extensions: spec.Extensions{ + "x-kubernetes-patch-merge-key": "templateName", + "x-kubernetes-patch-strategy": "merge", + }, + }, + SchemaProps: spec.SchemaProps{ + Description: "Templates reference to a list of analysis templates to combine for an AnalysisRun", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutAnalysisTemplate"), + }, + }, + }, + }, + }, + "args": { + VendorExtensible: spec.VendorExtensible{ + Extensions: spec.Extensions{ + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge", + }, + }, + SchemaProps: spec.SchemaProps{ + Description: "Args the arguments that will be added to the AnalysisRuns", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AnalysisRunArgument"), + }, + }, + }, + }, + }, + "dryRun": { + VendorExtensible: spec.VendorExtensible{ + Extensions: spec.Extensions{ + "x-kubernetes-patch-merge-key": "metricName", + "x-kubernetes-patch-strategy": "merge", + }, + }, + SchemaProps: spec.SchemaProps{ + Description: "DryRun object contains the settings for running the analysis in Dry-Run mode", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.DryRun"), + }, + }, + }, + }, + }, + "measurementRetention": { + VendorExtensible: spec.VendorExtensible{ + Extensions: spec.Extensions{ + "x-kubernetes-patch-merge-key": "metricName", + "x-kubernetes-patch-strategy": "merge", + }, + }, + SchemaProps: spec.SchemaProps{ + Description: "MeasurementRetention object contains the settings for retaining the number of measurements during the analysis", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.MeasurementRetention"), + }, + }, + }, + }, + }, + "analysisRunMetadata": { + SchemaProps: spec.SchemaProps{ + Description: "AnalysisRunMetadata labels and annotations that will be added to the AnalysisRuns", + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AnalysisRunMetadata"), + }, + }, + "startingStep": { + SchemaProps: spec.SchemaProps{ + Description: "StartingStep indicates which step the background analysis should start on If not listed, controller defaults to 0", + Type: []string{"integer"}, + Format: "int32", + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AnalysisRunArgument", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AnalysisRunMetadata", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.DryRun", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.MeasurementRetention", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutAnalysisTemplate"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_RolloutAnalysisRunStatus(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "name": { + SchemaProps: spec.SchemaProps{ + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "status": { + SchemaProps: spec.SchemaProps{ + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "message": { + SchemaProps: spec.SchemaProps{ + Type: []string{"string"}, + Format: "", + }, + }, + }, + Required: []string{"name", "status"}, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_RolloutAnalysisTemplate(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "templateName": { + SchemaProps: spec.SchemaProps{ + Description: "TemplateName name of template to use in AnalysisRun", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "clusterScope": { + SchemaProps: spec.SchemaProps{ + Description: "Whether to look for the templateName at cluster scope or namespace scope", + Type: []string{"boolean"}, + Format: "", + }, + }, + }, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_RolloutCondition(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "RolloutCondition describes the state of a rollout at a certain point.", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "type": { + SchemaProps: spec.SchemaProps{ + Description: "Type of deployment condition.", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "status": { + SchemaProps: spec.SchemaProps{ + Description: "Phase of the condition, one of True, False, Unknown.", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "lastUpdateTime": { + SchemaProps: spec.SchemaProps{ + Description: "The last time this condition was updated.", + Default: map[string]interface{}{}, + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.Time"), + }, + }, + "lastTransitionTime": { + SchemaProps: spec.SchemaProps{ + Description: "Last time the condition transitioned from one status to another.", + Default: map[string]interface{}{}, + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.Time"), + }, + }, + "reason": { + SchemaProps: spec.SchemaProps{ + Description: "The reason for the condition's last transition.", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "message": { + SchemaProps: spec.SchemaProps{ + Description: "A human readable message indicating details about the transition.", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + }, + Required: []string{"type", "status", "lastUpdateTime", "lastTransitionTime", "reason", "message"}, + }, + }, + Dependencies: []string{ + "k8s.io/apimachinery/pkg/apis/meta/v1.Time"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_RolloutExperimentStep(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "RolloutExperimentStep defines a template that is used to create a experiment for a step", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "templates": { + VendorExtensible: spec.VendorExtensible{ + Extensions: spec.Extensions{ + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge", + }, + }, + SchemaProps: spec.SchemaProps{ + Description: "Templates what templates that should be added to the experiment. Should be non-nil", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutExperimentTemplate"), + }, + }, + }, + }, + }, + "duration": { + SchemaProps: spec.SchemaProps{ + Description: "Duration is a duration string (e.g. 30s, 5m, 1h) that the experiment should run for", + Type: []string{"string"}, + Format: "", + }, + }, + "analyses": { + VendorExtensible: spec.VendorExtensible{ + Extensions: spec.Extensions{ + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge", + }, + }, + SchemaProps: spec.SchemaProps{ + Description: "Analyses reference which analysis templates to run with the experiment", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutExperimentStepAnalysisTemplateRef"), + }, + }, + }, + }, + }, + }, + Required: []string{"templates"}, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutExperimentStepAnalysisTemplateRef", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutExperimentTemplate"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_RolloutExperimentStepAnalysisTemplateRef(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "name": { + SchemaProps: spec.SchemaProps{ + Description: "Name is a name for this analysis template invocation", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "templateName": { + SchemaProps: spec.SchemaProps{ + Description: "TemplateName reference of the AnalysisTemplate name used by the Experiment to create the run", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "clusterScope": { + SchemaProps: spec.SchemaProps{ + Description: "Whether to look for the templateName at cluster scope or namespace scope", + Type: []string{"boolean"}, + Format: "", + }, + }, + "args": { + VendorExtensible: spec.VendorExtensible{ + Extensions: spec.Extensions{ + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge", + }, + }, + SchemaProps: spec.SchemaProps{ + Description: "Args the arguments that will be added to the AnalysisRuns", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AnalysisRunArgument"), + }, + }, + }, + }, + }, + "requiredForCompletion": { + SchemaProps: spec.SchemaProps{ + Description: "RequiredForCompletion blocks the Experiment from completing until the analysis has completed", + Type: []string{"boolean"}, + Format: "", + }, + }, + }, + Required: []string{"name", "templateName"}, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AnalysisRunArgument"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_RolloutExperimentTemplate(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "RolloutExperimentTemplate defines the template used to create experiments for the Rollout's experiment canary step", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "name": { + SchemaProps: spec.SchemaProps{ + Description: "Name description of template that passed to the template", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "specRef": { + SchemaProps: spec.SchemaProps{ + Description: "SpecRef indicates where the rollout should get the RS template from", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "replicas": { + SchemaProps: spec.SchemaProps{ + Description: "Replicas replica count for the template", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "metadata": { + SchemaProps: spec.SchemaProps{ + Description: "Metadata sets labels and annotations to use for the RS created from the template", + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.PodTemplateMetadata"), + }, + }, + "selector": { + SchemaProps: spec.SchemaProps{ + Description: "Selector overrides the selector to be used for the template's ReplicaSet. If omitted, will use the same selector as the Rollout", + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.LabelSelector"), + }, + }, + "weight": { + SchemaProps: spec.SchemaProps{ + Description: "Weight sets the percentage of traffic the template's replicas should receive", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "service": { + SchemaProps: spec.SchemaProps{ + Description: "Service controls the optionally generated service", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.TemplateService"), + }, + }, + }, + Required: []string{"name", "specRef"}, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.PodTemplateMetadata", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.TemplateService", "k8s.io/apimachinery/pkg/apis/meta/v1.LabelSelector"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_RolloutList(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "RolloutList is a list of Rollout resources", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "kind": { + SchemaProps: spec.SchemaProps{ + Description: "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + Type: []string{"string"}, + Format: "", + }, + }, + "apiVersion": { + SchemaProps: spec.SchemaProps{ + Description: "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + Type: []string{"string"}, + Format: "", + }, + }, + "metadata": { + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.ListMeta"), + }, + }, + "items": { + SchemaProps: spec.SchemaProps{ + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.Rollout"), + }, + }, + }, + }, + }, + }, + Required: []string{"metadata", "items"}, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.Rollout", "k8s.io/apimachinery/pkg/apis/meta/v1.ListMeta"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_RolloutPause(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "RolloutPause defines a pause stage for a rollout", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "duration": { + SchemaProps: spec.SchemaProps{ + Description: "Duration the amount of time to wait before moving to the next step.", + Ref: ref("k8s.io/apimachinery/pkg/util/intstr.IntOrString"), + }, + }, + }, + }, + }, + Dependencies: []string{ + "k8s.io/apimachinery/pkg/util/intstr.IntOrString"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_RolloutSpec(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "RolloutSpec is the spec for a Rollout resource", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "replicas": { + SchemaProps: spec.SchemaProps{ + Description: "Number of desired pods. This is a pointer to distinguish between explicit zero and not specified. Defaults to 1.", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "selector": { + SchemaProps: spec.SchemaProps{ + Description: "Label selector for pods. Existing ReplicaSets whose pods are selected by this will be the ones affected by this rollout. It must match the pod template's labels.", + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.LabelSelector"), + }, + }, + "template": { + SchemaProps: spec.SchemaProps{ + Description: "Template describes the pods that will be created.", + Default: map[string]interface{}{}, + Ref: ref("k8s.io/api/core/v1.PodTemplateSpec"), + }, + }, + "workloadRef": { + SchemaProps: spec.SchemaProps{ + Description: "WorkloadRef holds a references to a workload that provides Pod template", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ObjectRef"), + }, + }, + "minReadySeconds": { + SchemaProps: spec.SchemaProps{ + Description: "Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready)", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "rollbackWindow": { + SchemaProps: spec.SchemaProps{ + Description: "The window in which a rollback will be fast tracked (fully promoted)", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RollbackWindowSpec"), + }, + }, + "strategy": { + SchemaProps: spec.SchemaProps{ + Description: "The deployment strategy to use to replace existing pods with new ones.", + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutStrategy"), + }, + }, + "revisionHistoryLimit": { + SchemaProps: spec.SchemaProps{ + Description: "The number of old ReplicaSets to retain. If unspecified, will retain 10 old ReplicaSets", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "paused": { + SchemaProps: spec.SchemaProps{ + Description: "Paused pauses the rollout at its current step.", + Type: []string{"boolean"}, + Format: "", + }, + }, + "progressDeadlineSeconds": { + SchemaProps: spec.SchemaProps{ + Description: "ProgressDeadlineSeconds The maximum time in seconds for a rollout to make progress before it is considered to be failed. Argo Rollouts will continue to process failed rollouts and a condition with a ProgressDeadlineExceeded reason will be surfaced in the rollout status. Note that progress will not be estimated during the time a rollout is paused. Defaults to 600s.", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "progressDeadlineAbort": { + SchemaProps: spec.SchemaProps{ + Description: "ProgressDeadlineAbort is whether to abort the update when ProgressDeadlineSeconds is exceeded.", + Type: []string{"boolean"}, + Format: "", + }, + }, + "restartAt": { + SchemaProps: spec.SchemaProps{ + Description: "RestartAt indicates when all the pods of a Rollout should be restarted", + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.Time"), + }, + }, + "analysis": { + SchemaProps: spec.SchemaProps{ + Description: "Analysis configuration for the analysis runs to retain", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AnalysisRunStrategy"), + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AnalysisRunStrategy", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ObjectRef", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RollbackWindowSpec", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutStrategy", "k8s.io/api/core/v1.PodTemplateSpec", "k8s.io/apimachinery/pkg/apis/meta/v1.LabelSelector", "k8s.io/apimachinery/pkg/apis/meta/v1.Time"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_RolloutStatus(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "RolloutStatus is the status for a Rollout resource", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "abort": { + SchemaProps: spec.SchemaProps{ + Description: "Abort cancel the current rollout progression", + Type: []string{"boolean"}, + Format: "", + }, + }, + "pauseConditions": { + SchemaProps: spec.SchemaProps{ + Description: "PauseConditions is a list of reasons why rollout became automatically paused (e.g. CanaryPauseStep, BlueGreenPause, InconclusiveAnalysis). The items in this list are populated by the controller but are cleared by the user (e.g. plugin, argo-cd resume action) when they wish to unpause. If pause conditions is empty, but controllerPause is true, it indicates the user manually unpaused the Rollout", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.PauseCondition"), + }, + }, + }, + }, + }, + "controllerPause": { + SchemaProps: spec.SchemaProps{ + Description: "ControllerPause indicates the controller has paused the rollout. It is set to true when the controller adds a pause condition. This field helps to discern the scenario where a rollout was resumed after being paused by the controller (e.g. via the plugin). In that situation, the pauseConditions would have been cleared , but controllerPause would still be set to true.", + Type: []string{"boolean"}, + Format: "", + }, + }, + "abortedAt": { + SchemaProps: spec.SchemaProps{ + Description: "AbortedAt indicates the controller reconciled an aborted rollout. The controller uses this to understand if the controller needs to do some specific work when a Rollout is aborted. For example, the reconcileAbort is used to indicate if the Rollout should enter an aborted state when the latest AnalysisRun is a failure, or the controller has already put the Rollout into an aborted and should create a new AnalysisRun.", + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.Time"), + }, + }, + "currentPodHash": { + SchemaProps: spec.SchemaProps{ + Description: "CurrentPodHash the hash of the current pod template", + Type: []string{"string"}, + Format: "", + }, + }, + "currentStepHash": { + SchemaProps: spec.SchemaProps{ + Description: "CurrentStepHash the hash of the current list of steps for the current strategy. This is used to detect when the list of current steps change", + Type: []string{"string"}, + Format: "", + }, + }, + "replicas": { + SchemaProps: spec.SchemaProps{ + Description: "Total number of non-terminated pods targeted by this rollout (their labels match the selector).", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "updatedReplicas": { + SchemaProps: spec.SchemaProps{ + Description: "Total number of non-terminated pods targeted by this rollout that have the desired template spec.", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "readyReplicas": { + SchemaProps: spec.SchemaProps{ + Description: "Total number of ready pods targeted by this rollout.", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "availableReplicas": { + SchemaProps: spec.SchemaProps{ + Description: "Total number of available pods (ready for at least minReadySeconds) targeted by this rollout.", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "currentStepIndex": { + SchemaProps: spec.SchemaProps{ + Description: "CurrentStepIndex defines the current step of the rollout is on. If the current step index is null, the controller will execute the rollout.", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "collisionCount": { + SchemaProps: spec.SchemaProps{ + Description: "Count of hash collisions for the Rollout. The Rollout controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ReplicaSet.", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "observedGeneration": { + SchemaProps: spec.SchemaProps{ + Description: "The generation observed by the rollout controller from metadata.generation", + Type: []string{"string"}, + Format: "", + }, + }, + "conditions": { + SchemaProps: spec.SchemaProps{ + Description: "Conditions a list of conditions a rollout can have.", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutCondition"), + }, + }, + }, + }, + }, + "canary": { + SchemaProps: spec.SchemaProps{ + Description: "Canary describes the state of the canary rollout", + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.CanaryStatus"), + }, + }, + "blueGreen": { + SchemaProps: spec.SchemaProps{ + Description: "BlueGreen describes the state of the bluegreen rollout", + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.BlueGreenStatus"), + }, + }, + "HPAReplicas": { + SchemaProps: spec.SchemaProps{ + Description: "HPAReplicas the number of non-terminated replicas that are receiving active traffic", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "selector": { + SchemaProps: spec.SchemaProps{ + Description: "Selector that identifies the pods that are receiving active traffic", + Type: []string{"string"}, + Format: "", + }, + }, + "stableRS": { + SchemaProps: spec.SchemaProps{ + Description: "StableRS indicates the replicaset that has successfully rolled out", + Type: []string{"string"}, + Format: "", + }, + }, + "restartedAt": { + SchemaProps: spec.SchemaProps{ + Description: "RestartedAt indicates last time a Rollout was restarted", + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.Time"), + }, + }, + "promoteFull": { + SchemaProps: spec.SchemaProps{ + Description: "PromoteFull indicates if the rollout should perform a full promotion, skipping analysis and pauses.", + Type: []string{"boolean"}, + Format: "", + }, + }, + "phase": { + SchemaProps: spec.SchemaProps{ + Description: "Phase is the rollout phase. Clients should only rely on the value if status.observedGeneration equals metadata.generation", + Type: []string{"string"}, + Format: "", + }, + }, + "message": { + SchemaProps: spec.SchemaProps{ + Description: "Message provides details on why the rollout is in its current phase", + Type: []string{"string"}, + Format: "", + }, + }, + "workloadObservedGeneration": { + SchemaProps: spec.SchemaProps{ + Description: "The generation of referenced workload observed by the rollout controller", + Type: []string{"string"}, + Format: "", + }, + }, + "alb": { + SchemaProps: spec.SchemaProps{ + Description: "/ ALB keeps information regarding the ALB and TargetGroups", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ALBStatus"), + }, + }, + "albs": { + SchemaProps: spec.SchemaProps{ + Description: "/ ALBs keeps information regarding multiple ALBs and TargetGroups in a multi ingress scenario", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ALBStatus"), + }, + }, + }, + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ALBStatus", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.BlueGreenStatus", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.CanaryStatus", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.PauseCondition", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RolloutCondition", "k8s.io/apimachinery/pkg/apis/meta/v1.Time"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_RolloutStrategy(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "RolloutStrategy defines strategy to apply during next rollout", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "blueGreen": { + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.BlueGreenStrategy"), + }, + }, + "canary": { + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.CanaryStrategy"), + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.BlueGreenStrategy", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.CanaryStrategy"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_RolloutTrafficRouting(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "RolloutTrafficRouting hosts all the different configuration for supported service meshes to enable more fine-grained traffic routing", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "istio": { + SchemaProps: spec.SchemaProps{ + Description: "Istio holds Istio specific configuration to route traffic", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.IstioTrafficRouting"), + }, + }, + "nginx": { + SchemaProps: spec.SchemaProps{ + Description: "Nginx holds Nginx Ingress specific configuration to route traffic", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.NginxTrafficRouting"), + }, + }, + "alb": { + SchemaProps: spec.SchemaProps{ + Description: "Nginx holds ALB Ingress specific configuration to route traffic", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ALBTrafficRouting"), + }, + }, + "smi": { + SchemaProps: spec.SchemaProps{ + Description: "SMI holds TrafficSplit specific configuration to route traffic", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.SMITrafficRouting"), + }, + }, + "ambassador": { + SchemaProps: spec.SchemaProps{ + Description: "Ambassador holds specific configuration to use Ambassador to route traffic", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AmbassadorTrafficRouting"), + }, + }, + "appMesh": { + SchemaProps: spec.SchemaProps{ + Description: "AppMesh holds specific configuration to use AppMesh to route traffic", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AppMeshTrafficRouting"), + }, + }, + "traefik": { + SchemaProps: spec.SchemaProps{ + Description: "Traefik holds specific configuration to use Traefik to route traffic", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.TraefikTrafficRouting"), + }, + }, + "managedRoutes": { + SchemaProps: spec.SchemaProps{ + Description: "ManagedRoutes A list of HTTP routes that Argo Rollouts manages, the order of this array also becomes the precedence in the upstream traffic router.", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.MangedRoutes"), + }, + }, + }, + }, + }, + "apisix": { + SchemaProps: spec.SchemaProps{ + Description: "Apisix holds specific configuration to use Apisix to route traffic", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ApisixTrafficRouting"), + }, + }, + "plugins": { + SchemaProps: spec.SchemaProps{ + Description: "Plugins holds specific configuration that traffic router plugins can use for routing traffic", + Type: []string{"object"}, + AdditionalProperties: &spec.SchemaOrBool{ + Allows: true, + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"string"}, + Format: "byte", + }, + }, + }, + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ALBTrafficRouting", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AmbassadorTrafficRouting", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ApisixTrafficRouting", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AppMeshTrafficRouting", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.IstioTrafficRouting", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.MangedRoutes", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.NginxTrafficRouting", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.SMITrafficRouting", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.TraefikTrafficRouting"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_RouteMatch(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "method": { + SchemaProps: spec.SchemaProps{ + Description: "Method What http methods should be mirrored", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.StringMatch"), + }, + }, + "path": { + SchemaProps: spec.SchemaProps{ + Description: "Path What url paths should be mirrored", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.StringMatch"), + }, + }, + "headers": { + SchemaProps: spec.SchemaProps{ + Description: "Headers What request with matching headers should be mirrored", + Type: []string{"object"}, + AdditionalProperties: &spec.SchemaOrBool{ + Allows: true, + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.StringMatch"), + }, + }, + }, + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.StringMatch"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_RunSummary(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "RunSummary contains the final results from the metric executions", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "count": { + SchemaProps: spec.SchemaProps{ + Description: "This is equal to the sum of Successful, Failed, Inconclusive", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "successful": { + SchemaProps: spec.SchemaProps{ + Description: "Successful is the number of times the metric was measured Successful", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "failed": { + SchemaProps: spec.SchemaProps{ + Description: "Failed is the number of times the metric was measured Failed", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "inconclusive": { + SchemaProps: spec.SchemaProps{ + Description: "Inconclusive is the number of times the metric was measured Inconclusive", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "error": { + SchemaProps: spec.SchemaProps{ + Description: "Error is the number of times an error was encountered during measurement", + Type: []string{"integer"}, + Format: "int32", + }, + }, + }, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_SMITrafficRouting(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "SMITrafficRouting configuration for TrafficSplit Custom Resource to control traffic routing", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "rootService": { + SchemaProps: spec.SchemaProps{ + Description: "RootService holds the name of that clients use to communicate.", + Type: []string{"string"}, + Format: "", + }, + }, + "trafficSplitName": { + SchemaProps: spec.SchemaProps{ + Description: "TrafficSplitName holds the name of the TrafficSplit.", + Type: []string{"string"}, + Format: "", + }, + }, + }, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_ScopeDetail(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "scope": { + SchemaProps: spec.SchemaProps{ + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "region": { + SchemaProps: spec.SchemaProps{ + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "step": { + SchemaProps: spec.SchemaProps{ + Default: 0, + Type: []string{"integer"}, + Format: "int64", + }, + }, + "start": { + SchemaProps: spec.SchemaProps{ + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "end": { + SchemaProps: spec.SchemaProps{ + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + }, + Required: []string{"scope", "region", "step", "start", "end"}, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_SecretKeyRef(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "name": { + SchemaProps: spec.SchemaProps{ + Description: "Name is the name of the secret", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "key": { + SchemaProps: spec.SchemaProps{ + Description: "Key is the key of the secret to select from.", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + }, + Required: []string{"name", "key"}, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_SetCanaryScale(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "SetCanaryScale defines how to scale the newRS without changing traffic weight", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "weight": { + SchemaProps: spec.SchemaProps{ + Description: "Weight sets the percentage of replicas the newRS should have", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "replicas": { + SchemaProps: spec.SchemaProps{ + Description: "Replicas sets the number of replicas the newRS should have", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "matchTrafficWeight": { + SchemaProps: spec.SchemaProps{ + Description: "MatchTrafficWeight cancels out previously set Replicas or Weight, effectively activating SetWeight", + Type: []string{"boolean"}, + Format: "", + }, + }, + }, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_SetHeaderRoute(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "SetHeaderRoute defines the route with specified header name to send 100% of traffic to the canary service", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "name": { + SchemaProps: spec.SchemaProps{ + Description: "Name this is the name of the route to use for the mirroring of traffic this also needs to be included in the `spec.strategy.canary.trafficRouting.managedRoutes` field", + Type: []string{"string"}, + Format: "", + }, + }, + "match": { + SchemaProps: spec.SchemaProps{ + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.HeaderRoutingMatch"), + }, + }, + }, + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.HeaderRoutingMatch"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_SetMirrorRoute(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "name": { + SchemaProps: spec.SchemaProps{ + Description: "Name this is the name of the route to use for the mirroring of traffic this also needs to be included in the `spec.strategy.canary.trafficRouting.managedRoutes` field", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "match": { + SchemaProps: spec.SchemaProps{ + Description: "Match Contains a list of rules that if mated will mirror the traffic to the services", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RouteMatch"), + }, + }, + }, + }, + }, + "percentage": { + SchemaProps: spec.SchemaProps{ + Description: "Services The list of services to mirror the traffic to if the method, path, headers match Service string `json:\"service\" protobuf:\"bytes,3,opt,name=service\"` Percentage What percent of the traffic that matched the rules should be mirrored", + Type: []string{"integer"}, + Format: "int32", + }, + }, + }, + Required: []string{"name"}, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RouteMatch"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_Sigv4Config(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "region": { + SchemaProps: spec.SchemaProps{ + Description: "Region is the AWS Region to sign the SigV4 Request", + Type: []string{"string"}, + Format: "", + }, + }, + "profile": { + SchemaProps: spec.SchemaProps{ + Description: "Profile is the Credential Profile used to sign the SigV4 Request", + Type: []string{"string"}, + Format: "", + }, + }, + "roleArn": { + SchemaProps: spec.SchemaProps{ + Description: "RoleARN is the IAM role used to sign the SIgV4 Request", + Type: []string{"string"}, + Format: "", + }, + }, + }, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_SkyWalkingMetric(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "address": { + SchemaProps: spec.SchemaProps{ + Type: []string{"string"}, + Format: "", + }, + }, + "query": { + SchemaProps: spec.SchemaProps{ + Type: []string{"string"}, + Format: "", + }, + }, + "interval": { + SchemaProps: spec.SchemaProps{ + Type: []string{"string"}, + Format: "", + }, + }, + }, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_StickinessConfig(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "enabled": { + SchemaProps: spec.SchemaProps{ + Default: false, + Type: []string{"boolean"}, + Format: "", + }, + }, + "durationSeconds": { + SchemaProps: spec.SchemaProps{ + Default: 0, + Type: []string{"integer"}, + Format: "int64", + }, + }, + }, + Required: []string{"enabled", "durationSeconds"}, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_StringMatch(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "StringMatch Used to define what type of matching we will use exact, prefix, or regular expression", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "exact": { + SchemaProps: spec.SchemaProps{ + Description: "Exact The string must match exactly", + Type: []string{"string"}, + Format: "", + }, + }, + "prefix": { + SchemaProps: spec.SchemaProps{ + Description: "Prefix The string will be prefixed matched", + Type: []string{"string"}, + Format: "", + }, + }, + "regex": { + SchemaProps: spec.SchemaProps{ + Description: "Regex The string will be regular expression matched", + Type: []string{"string"}, + Format: "", + }, + }, + }, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_TCPRoute(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "TCPRoute holds the information on the virtual service's TCP routes that are desired to be matched for changing weights.", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "port": { + SchemaProps: spec.SchemaProps{ + Description: "Port number of the TCP Route desired to be matched in the given Istio VirtualService.", + Type: []string{"integer"}, + Format: "int64", + }, + }, + }, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_TLSRoute(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "TLSRoute holds the information on the virtual service's TLS/HTTPS routes that are desired to be matched for changing weights.", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "port": { + SchemaProps: spec.SchemaProps{ + Description: "Port number of the TLS Route desired to be matched in the given Istio VirtualService.", + Type: []string{"integer"}, + Format: "int64", + }, + }, + "sniHosts": { + SchemaProps: spec.SchemaProps{ + Description: "A list of all the SNI Hosts of the TLS Route desired to be matched in the given Istio VirtualService.", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + }, + }, + }, + }, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_TemplateService(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "name": { + SchemaProps: spec.SchemaProps{ + Description: "Name of the service generated by the experiment", + Type: []string{"string"}, + Format: "", + }, + }, + }, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_TemplateSpec(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "name": { + SchemaProps: spec.SchemaProps{ + Description: "Name of the template used to identity replicaset running for this experiment", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "replicas": { + SchemaProps: spec.SchemaProps{ + Description: "Number of desired pods. This is a pointer to distinguish between explicit zero and not specified. Defaults to 1.", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "minReadySeconds": { + SchemaProps: spec.SchemaProps{ + Description: "Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready)", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "selector": { + SchemaProps: spec.SchemaProps{ + Description: "Label selector for pods. Existing ReplicaSets whose pods are selected by this will be the ones affected by this experiment. It must match the pod template's labels. Each selector must be unique to the other selectors in the other templates", + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.LabelSelector"), + }, + }, + "template": { + SchemaProps: spec.SchemaProps{ + Description: "Template describes the pods that will be created.", + Default: map[string]interface{}{}, + Ref: ref("k8s.io/api/core/v1.PodTemplateSpec"), + }, + }, + "service": { + SchemaProps: spec.SchemaProps{ + Description: "TemplateService describes how a service should be generated for template", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.TemplateService"), + }, + }, + }, + Required: []string{"name", "selector", "template"}, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.TemplateService", "k8s.io/api/core/v1.PodTemplateSpec", "k8s.io/apimachinery/pkg/apis/meta/v1.LabelSelector"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_TemplateStatus(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "TemplateStatus is the status of a specific template of an Experiment", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "name": { + SchemaProps: spec.SchemaProps{ + Description: "Name of the template used to identity which hash to compare to the hash", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "replicas": { + SchemaProps: spec.SchemaProps{ + Description: "Total number of non-terminated pods targeted by this experiment (their labels match the selector).", + Default: 0, + Type: []string{"integer"}, + Format: "int32", + }, + }, + "updatedReplicas": { + SchemaProps: spec.SchemaProps{ + Description: "Total number of non-terminated pods targeted by this experiment that have the desired template spec.", + Default: 0, + Type: []string{"integer"}, + Format: "int32", + }, + }, + "readyReplicas": { + SchemaProps: spec.SchemaProps{ + Description: "Total number of ready pods targeted by this experiment.", + Default: 0, + Type: []string{"integer"}, + Format: "int32", + }, + }, + "availableReplicas": { + SchemaProps: spec.SchemaProps{ + Description: "Total number of available pods (ready for at least minReadySeconds) targeted by this experiment.", + Default: 0, + Type: []string{"integer"}, + Format: "int32", + }, + }, + "collisionCount": { + SchemaProps: spec.SchemaProps{ + Description: "CollisionCount count of hash collisions for the Experiment. The Experiment controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ReplicaSet.", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "status": { + SchemaProps: spec.SchemaProps{ + Description: "Phase is the status of the ReplicaSet associated with the template", + Type: []string{"string"}, + Format: "", + }, + }, + "message": { + SchemaProps: spec.SchemaProps{ + Description: "Message is a message explaining the current status", + Type: []string{"string"}, + Format: "", + }, + }, + "lastTransitionTime": { + SchemaProps: spec.SchemaProps{ + Description: "LastTransitionTime is the last time the replicaset transitioned, which resets the countdown on the ProgressDeadlineSeconds check.", + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.Time"), + }, + }, + "serviceName": { + SchemaProps: spec.SchemaProps{ + Description: "ServiceName is the name of the service which corresponds to this experiment", + Type: []string{"string"}, + Format: "", + }, + }, + "podTemplateHash": { + SchemaProps: spec.SchemaProps{ + Description: "PodTemplateHash is the value of the Replicas' PodTemplateHash", + Type: []string{"string"}, + Format: "", + }, + }, + }, + Required: []string{"name", "replicas", "updatedReplicas", "readyReplicas", "availableReplicas"}, + }, + }, + Dependencies: []string{ + "k8s.io/apimachinery/pkg/apis/meta/v1.Time"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_TraefikTrafficRouting(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "TraefikTrafficRouting defines the configuration required to use Traefik as traffic router", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "weightedTraefikServiceName": { + SchemaProps: spec.SchemaProps{ + Description: "TraefikServiceName refer to the name of the Traefik service used to route traffic to the service", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + }, + Required: []string{"weightedTraefikServiceName"}, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_TrafficWeights(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "TrafficWeights describes the current status of how traffic has been split", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "canary": { + SchemaProps: spec.SchemaProps{ + Description: "Canary is the current traffic weight split to canary ReplicaSet", + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.WeightDestination"), + }, + }, + "stable": { + SchemaProps: spec.SchemaProps{ + Description: "Stable is the current traffic weight split to stable ReplicaSet", + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.WeightDestination"), + }, + }, + "additional": { + SchemaProps: spec.SchemaProps{ + Description: "Additional holds the weights split to additional ReplicaSets such as experiment ReplicaSets", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.WeightDestination"), + }, + }, + }, + }, + }, + "verified": { + SchemaProps: spec.SchemaProps{ + Description: "Verified is an optional indicator that the weight has been verified to have taken effect. This is currently only applicable to ALB traffic router", + Type: []string{"boolean"}, + Format: "", + }, + }, + }, + Required: []string{"canary", "stable"}, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.WeightDestination"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_ValueFrom(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "secretKeyRef": { + SchemaProps: spec.SchemaProps{ + Description: "Secret is a reference to where a secret is stored. This field is one of the fields with valueFrom", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.SecretKeyRef"), + }, + }, + "fieldRef": { + SchemaProps: spec.SchemaProps{ + Description: "FieldRef is a reference to the fields in metadata which we are referencing. This field is one of the fields with valueFrom", + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.FieldRef"), + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.FieldRef", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.SecretKeyRef"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_WavefrontMetric(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "WavefrontMetric defines the wavefront query to perform canary analysis", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "address": { + SchemaProps: spec.SchemaProps{ + Description: "Address is the HTTP address and port of the wavefront server", + Type: []string{"string"}, + Format: "", + }, + }, + "query": { + SchemaProps: spec.SchemaProps{ + Description: "Query is a raw wavefront query to perform", + Type: []string{"string"}, + Format: "", + }, + }, + }, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_WebMetric(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "method": { + SchemaProps: spec.SchemaProps{ + Description: "Method is the method of the web metric (empty defaults to GET)", + Type: []string{"string"}, + Format: "", + }, + }, + "url": { + SchemaProps: spec.SchemaProps{ + Description: "URL is the address of the web metric", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "headers": { + VendorExtensible: spec.VendorExtensible{ + Extensions: spec.Extensions{ + "x-kubernetes-patch-merge-key": "key", + "x-kubernetes-patch-strategy": "merge", + }, + }, + SchemaProps: spec.SchemaProps{ + Description: "Headers are optional HTTP headers to use in the request", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.WebMetricHeader"), + }, + }, + }, + }, + }, + "body": { + SchemaProps: spec.SchemaProps{ + Description: "Body is the body of the web metric (must be POST/PUT)", + Type: []string{"string"}, + Format: "", + }, + }, + "timeoutSeconds": { + SchemaProps: spec.SchemaProps{ + Description: "TimeoutSeconds is the timeout for the request in seconds (default: 10)", + Type: []string{"integer"}, + Format: "int64", + }, + }, + "jsonPath": { + SchemaProps: spec.SchemaProps{ + Description: "JSONPath is a JSON Path to use as the result variable (default: \"{$}\")", + Type: []string{"string"}, + Format: "", + }, + }, + "insecure": { + SchemaProps: spec.SchemaProps{ + Description: "Insecure skips host TLS verification", + Type: []string{"boolean"}, + Format: "", + }, + }, + "jsonBody": { + SchemaProps: spec.SchemaProps{ + Description: "JSONBody is the body of the web metric in a json format (method must be POST/PUT)", + Type: []string{"string"}, + Format: "byte", + }, + }, + }, + Required: []string{"url"}, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.WebMetricHeader"}, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_WebMetricHeader(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "key": { + SchemaProps: spec.SchemaProps{ + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "value": { + SchemaProps: spec.SchemaProps{ + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + }, + Required: []string{"key", "value"}, + }, + }, + } +} + +func schema_pkg_apis_rollouts_v1alpha1_WeightDestination(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "weight": { + SchemaProps: spec.SchemaProps{ + Description: "Weight is an percentage of traffic being sent to this destination", + Default: 0, + Type: []string{"integer"}, + Format: "int32", + }, + }, + "serviceName": { + SchemaProps: spec.SchemaProps{ + Description: "ServiceName is the Kubernetes service name traffic is being sent to", + Type: []string{"string"}, + Format: "", + }, + }, + "podTemplateHash": { + SchemaProps: spec.SchemaProps{ + Description: "PodTemplateHash is the pod template hash label for this destination", + Type: []string{"string"}, + Format: "", + }, + }, + }, + Required: []string{"weight"}, + }, + }, + } +} diff --git a/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1/register.go b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1/register.go new file mode 100644 index 000000000000..9c0da208a61c --- /dev/null +++ b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1/register.go @@ -0,0 +1,54 @@ +package v1alpha1 + +import ( + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" + + rollouts "github.com/argoproj/argo-rollouts/pkg/apis/rollouts" +) + +// SchemeGroupVersion is group version used to register these objects +var SchemeGroupVersion = schema.GroupVersion{Group: rollouts.Group, Version: "v1alpha1"} + +var ( + // GroupVersionResource for all rollout types + RolloutGVR = SchemeGroupVersion.WithResource("rollouts") + AnalysisRunGVR = SchemeGroupVersion.WithResource("analysisruns") + AnalysisTemplateGVR = SchemeGroupVersion.WithResource("analysistemplates") + ClusterAnalysisTemplateGVR = SchemeGroupVersion.WithResource("clusteranalysistemplates") + ExperimentGVR = SchemeGroupVersion.WithResource("experiments") +) + +// Kind takes an unqualified kind and returns back a Group qualified GroupKind +func Kind(kind string) schema.GroupKind { + return SchemeGroupVersion.WithKind(kind).GroupKind() +} + +// Resource takes an unqualified resource and returns a Group qualified GroupResource +func Resource(resource string) schema.GroupResource { + return SchemeGroupVersion.WithResource(resource).GroupResource() +} + +var ( + SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes) + AddToScheme = SchemeBuilder.AddToScheme +) + +// Adds the list of known types to Scheme. +func addKnownTypes(scheme *runtime.Scheme) error { + scheme.AddKnownTypes(SchemeGroupVersion, + &Rollout{}, + &RolloutList{}, + &Experiment{}, + &ExperimentList{}, + &AnalysisTemplate{}, + &AnalysisTemplateList{}, + &ClusterAnalysisTemplate{}, + &ClusterAnalysisTemplateList{}, + &AnalysisRun{}, + &AnalysisRunList{}, + ) + metav1.AddToGroupVersion(scheme, SchemeGroupVersion) + return nil +} diff --git a/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1/types.go b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1/types.go new file mode 100644 index 000000000000..f2c2dbe7fed4 --- /dev/null +++ b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1/types.go @@ -0,0 +1,1083 @@ +package v1alpha1 + +import ( + "encoding/json" + "strconv" + "time" + + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/util/intstr" +) + +// +genclient +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +// +kubebuilder:resource:path=rollouts,shortName=ro +// +kubebuilder:subresource:scale:specpath=.spec.replicas,statuspath=.status.HPAReplicas,selectorpath=.status.selector +// +kubebuilder:printcolumn:name="Desired",type="integer",JSONPath=".spec.replicas",description="Number of desired pods" +// +kubebuilder:printcolumn:name="Current",type="integer",JSONPath=".status.replicas",description="Total number of non-terminated pods targeted by this rollout" +// +kubebuilder:printcolumn:name="Up-to-date",type="integer",JSONPath=".status.updatedReplicas",description="Total number of non-terminated pods targeted by this rollout that have the desired template spec" +// +kubebuilder:printcolumn:name="Available",type="integer",JSONPath=".status.availableReplicas",description="Total number of available pods (ready for at least minReadySeconds) targeted by this rollout" +// +kubebuilder:printcolumn:name="Age",type="date",JSONPath=".metadata.creationTimestamp",description="Time since resource was created" +// +kubebuilder:subresource:status + +// Rollout is a specification for a Rollout resource +type Rollout struct { + metav1.TypeMeta `json:",inline"` + metav1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"` + + Spec RolloutSpec `json:"spec" protobuf:"bytes,2,opt,name=spec"` + Status RolloutStatus `json:"status,omitempty" protobuf:"bytes,3,opt,name=status"` +} + +// RolloutSpec is the spec for a Rollout resource +type RolloutSpec struct { + TemplateResolvedFromRef bool `json:"-"` + SelectorResolvedFromRef bool `json:"-"` + // Number of desired pods. This is a pointer to distinguish between explicit + // zero and not specified. Defaults to 1. + // +optional + Replicas *int32 `json:"replicas,omitempty" protobuf:"varint,1,opt,name=replicas"` + // Label selector for pods. Existing ReplicaSets whose pods are + // selected by this will be the ones affected by this rollout. + // It must match the pod template's labels. + // +optional + Selector *metav1.LabelSelector `json:"selector" protobuf:"bytes,2,opt,name=selector"` + // Template describes the pods that will be created. + // +optional + Template corev1.PodTemplateSpec `json:"template" protobuf:"bytes,3,opt,name=template"` + // WorkloadRef holds a references to a workload that provides Pod template + // +optional + WorkloadRef *ObjectRef `json:"workloadRef,omitempty" protobuf:"bytes,10,opt,name=workloadRef"` + // Minimum number of seconds for which a newly created pod should be ready + // without any of its container crashing, for it to be considered available. + // Defaults to 0 (pod will be considered available as soon as it is ready) + // +optional + MinReadySeconds int32 `json:"minReadySeconds,omitempty" protobuf:"varint,4,opt,name=minReadySeconds"` + // The window in which a rollback will be fast tracked (fully promoted) + // +optional + RollbackWindow *RollbackWindowSpec `json:"rollbackWindow,omitempty" protobuf:"bytes,13,opt,name=rollbackWindow"` + // The deployment strategy to use to replace existing pods with new ones. + // +optional + Strategy RolloutStrategy `json:"strategy" protobuf:"bytes,5,opt,name=strategy"` + // The number of old ReplicaSets to retain. If unspecified, will retain 10 old ReplicaSets + RevisionHistoryLimit *int32 `json:"revisionHistoryLimit,omitempty" protobuf:"varint,6,opt,name=revisionHistoryLimit"` + // Paused pauses the rollout at its current step. + Paused bool `json:"paused,omitempty" protobuf:"varint,7,opt,name=paused"` + // ProgressDeadlineSeconds The maximum time in seconds for a rollout to + // make progress before it is considered to be failed. Argo Rollouts will + // continue to process failed rollouts and a condition with a + // ProgressDeadlineExceeded reason will be surfaced in the rollout status. + // Note that progress will not be estimated during the time a rollout is paused. + // Defaults to 600s. + ProgressDeadlineSeconds *int32 `json:"progressDeadlineSeconds,omitempty" protobuf:"varint,8,opt,name=progressDeadlineSeconds"` + // ProgressDeadlineAbort is whether to abort the update when ProgressDeadlineSeconds + // is exceeded. + // +optional + ProgressDeadlineAbort bool `json:"progressDeadlineAbort,omitempty" protobuf:"varint,12,opt,name=progressDeadlineAbort"` + // RestartAt indicates when all the pods of a Rollout should be restarted + RestartAt *metav1.Time `json:"restartAt,omitempty" protobuf:"bytes,9,opt,name=restartAt"` + // Analysis configuration for the analysis runs to retain + Analysis *AnalysisRunStrategy `json:"analysis,omitempty" protobuf:"bytes,11,opt,name=analysis"` +} + +func (s *RolloutSpec) SetResolvedSelector(selector *metav1.LabelSelector) { + s.SelectorResolvedFromRef = true + s.Selector = selector +} + +func (s *RolloutSpec) SetResolvedTemplate(template corev1.PodTemplateSpec) { + s.TemplateResolvedFromRef = true + s.Template = template +} + +func (s *RolloutSpec) EmptyTemplate() bool { + if len(s.Template.Labels) > 0 { + return false + } + if len(s.Template.Annotations) > 0 { + return false + } + return true +} + +func (s *RolloutSpec) MarshalJSON() ([]byte, error) { + type Alias RolloutSpec + + if s.TemplateResolvedFromRef || s.SelectorResolvedFromRef { + obj, err := runtime.DefaultUnstructuredConverter.ToUnstructured(&struct { + Alias `json:",inline"` + }{ + Alias: (Alias)(*s), + }) + if err != nil { + return nil, err + } + if s.TemplateResolvedFromRef { + unstructured.RemoveNestedField(obj, "template") + } + if s.SelectorResolvedFromRef { + unstructured.RemoveNestedField(obj, "selector") + } + + return json.Marshal(obj) + } + return json.Marshal(&struct{ *Alias }{ + Alias: (*Alias)(s), + }) +} + +// ObjectRef holds a references to the Kubernetes object +type ObjectRef struct { + // API Version of the referent + APIVersion string `json:"apiVersion,omitempty" protobuf:"bytes,1,opt,name=apiVersion"` + // Kind of the referent + Kind string `json:"kind,omitempty" protobuf:"bytes,2,opt,name=kind"` + // Name of the referent + Name string `json:"name,omitempty" protobuf:"bytes,3,opt,name=name"` +} + +const ( + // DefaultRolloutUniqueLabelKey is the default key of the selector that is added + // to existing ReplicaSets (and label key that is added to its pods) to prevent the existing ReplicaSets + // to select new pods (and old pods being select by new ReplicaSet). + DefaultRolloutUniqueLabelKey string = "rollouts-pod-template-hash" + // DefaultReplicaSetScaleDownDeadlineAnnotationKey is the default key attached to an old stable ReplicaSet after + // the rollout transitioned to a new version. It contains the time when the controller can scale down the RS. + DefaultReplicaSetScaleDownDeadlineAnnotationKey = "scale-down-deadline" + // ManagedByRolloutKey is the key used to indicate which rollout(s) manage a resource but doesn't own it. + ManagedByRolloutsKey = "argo-rollouts.argoproj.io/managed-by-rollouts" + // DefaultReplicaSetRestartAnnotationKey indicates that the ReplicaSet with this annotation was restarted at the + // time listed in the value + DefaultReplicaSetRestartAnnotationKey = "argo-rollouts.argoproj.io/restarted-after" + // LabelKeyControllerInstanceID is the label the controller uses for the rollout, experiment, analysis segregation + // between controllers. Controllers will only operate on objects with the same instanceID as the controller. + LabelKeyControllerInstanceID = "argo-rollouts.argoproj.io/controller-instance-id" +) + +// RolloutStrategy defines strategy to apply during next rollout +type RolloutStrategy struct { + // +optional + BlueGreen *BlueGreenStrategy `json:"blueGreen,omitempty" protobuf:"bytes,1,opt,name=blueGreen"` + // +optional + Canary *CanaryStrategy `json:"canary,omitempty" protobuf:"bytes,2,opt,name=canary"` +} + +// BlueGreenStrategy defines parameters for Blue Green deployment +type BlueGreenStrategy struct { + // Name of the service that the rollout modifies as the active service. + ActiveService string `json:"activeService" protobuf:"bytes,1,opt,name=activeService"` + // Name of the service that the rollout modifies as the preview service. + // +optional + PreviewService string `json:"previewService,omitempty" protobuf:"bytes,2,opt,name=previewService"` + // PreviewReplicaCount is the number of replicas to run for the preview stack before the + // switchover. Once the rollout is resumed the desired replicaset will be full scaled up before the switch occurs + // +optional + PreviewReplicaCount *int32 `json:"previewReplicaCount,omitempty" protobuf:"varint,3,opt,name=previewReplicaCount"` + // AutoPromotionEnabled indicates if the rollout should automatically promote the new ReplicaSet + // to the active service or enter a paused state. If not specified, the default value is true. + // +optional + AutoPromotionEnabled *bool `json:"autoPromotionEnabled,omitempty" protobuf:"varint,4,opt,name=autoPromotionEnabled"` + // AutoPromotionSeconds is a duration in seconds in which to delay auto-promotion (default: 0). + // The countdown begins after the preview ReplicaSet have reached full availability. + // This option is ignored if autoPromotionEnabled is set to false. + // +optional + AutoPromotionSeconds int32 `json:"autoPromotionSeconds,omitempty" protobuf:"varint,5,opt,name=autoPromotionSeconds"` + // MaxUnavailable The maximum number of pods that can be unavailable during a restart operation. + // Defaults to 25% of total replicas. + // +optional + MaxUnavailable *intstr.IntOrString `json:"maxUnavailable,omitempty" protobuf:"bytes,6,opt,name=maxUnavailable"` + // ScaleDownDelaySeconds adds a delay before scaling down the previous replicaset. + // If omitted, the Rollout waits 30 seconds before scaling down the previous ReplicaSet. + // A minimum of 30 seconds is recommended to ensure IP table propagation across the nodes in + // a cluster. See https://github.com/argoproj/argo-rollouts/issues/19#issuecomment-476329960 for + // more information + // +optional + ScaleDownDelaySeconds *int32 `json:"scaleDownDelaySeconds,omitempty" protobuf:"varint,7,opt,name=scaleDownDelaySeconds"` + // ScaleDownDelayRevisionLimit limits the number of old RS that can run at one time before getting scaled down + // +optional + ScaleDownDelayRevisionLimit *int32 `json:"scaleDownDelayRevisionLimit,omitempty" protobuf:"varint,8,opt,name=scaleDownDelayRevisionLimit"` + // PrePromotionAnalysis configuration to run analysis before a selector switch + PrePromotionAnalysis *RolloutAnalysis `json:"prePromotionAnalysis,omitempty" protobuf:"bytes,9,opt,name=prePromotionAnalysis"` + // AntiAffinity enables anti-affinity rules for Blue Green deployment + // +optional + AntiAffinity *AntiAffinity `json:"antiAffinity,omitempty" protobuf:"bytes,10,opt,name=antiAffinity"` + // PostPromotionAnalysis configuration to run analysis after a selector switch + PostPromotionAnalysis *RolloutAnalysis `json:"postPromotionAnalysis,omitempty" protobuf:"bytes,11,opt,name=postPromotionAnalysis"` + // PreviewMetadata specify labels and annotations which will be attached to the preview pods for + // the duration which they act as a preview pod, and will be removed after + PreviewMetadata *PodTemplateMetadata `json:"previewMetadata,omitempty" protobuf:"bytes,12,opt,name=previewMetadata"` + // ActiveMetadata specify labels and annotations which will be attached to the active pods for + // the duration which they act as a active pod, and will be removed after + ActiveMetadata *PodTemplateMetadata `json:"activeMetadata,omitempty" protobuf:"bytes,13,opt,name=activeMetadata"` + // AbortScaleDownDelaySeconds adds a delay in second before scaling down the preview replicaset + // if update is aborted. 0 means not to scale down. + // Default is 30 second + // +optional + AbortScaleDownDelaySeconds *int32 `json:"abortScaleDownDelaySeconds,omitempty" protobuf:"varint,14,opt,name=abortScaleDownDelaySeconds"` +} + +// AntiAffinity defines which inter-pod scheduling rule to use for anti-affinity injection +type AntiAffinity struct { + // +optional + PreferredDuringSchedulingIgnoredDuringExecution *PreferredDuringSchedulingIgnoredDuringExecution `json:"preferredDuringSchedulingIgnoredDuringExecution,omitempty" protobuf:"bytes,1,opt,name=preferredDuringSchedulingIgnoredDuringExecution"` + // +optional + RequiredDuringSchedulingIgnoredDuringExecution *RequiredDuringSchedulingIgnoredDuringExecution `json:"requiredDuringSchedulingIgnoredDuringExecution,omitempty" protobuf:"bytes,2,opt,name=requiredDuringSchedulingIgnoredDuringExecution"` +} + +// PreferredDuringSchedulingIgnoredDuringExecution defines the weight of the anti-affinity injection +type PreferredDuringSchedulingIgnoredDuringExecution struct { + // Weight associated with matching the corresponding podAffinityTerm, in the range 1-100. + Weight int32 `json:"weight" protobuf:"varint,1,opt,name=weight"` +} + +// RequiredDuringSchedulingIgnoredDuringExecution defines inter-pod scheduling rule to be RequiredDuringSchedulingIgnoredDuringExecution +type RequiredDuringSchedulingIgnoredDuringExecution struct{} + +// CanaryStrategy defines parameters for a Replica Based Canary +type CanaryStrategy struct { + // CanaryService holds the name of a service which selects pods with canary version and don't select any pods with stable version. + // +optional + CanaryService string `json:"canaryService,omitempty" protobuf:"bytes,1,opt,name=canaryService"` + // StableService holds the name of a service which selects pods with stable version and don't select any pods with canary version. + // +optional + StableService string `json:"stableService,omitempty" protobuf:"bytes,2,opt,name=stableService"` + // Steps define the order of phases to execute the canary deployment + // +optional + Steps []CanaryStep `json:"steps,omitempty" protobuf:"bytes,3,rep,name=steps"` + // TrafficRouting hosts all the supported service meshes supported to enable more fine-grained traffic routing + TrafficRouting *RolloutTrafficRouting `json:"trafficRouting,omitempty" protobuf:"bytes,4,opt,name=trafficRouting"` + + // MaxUnavailable The maximum number of pods that can be unavailable during the update. + // Value can be an absolute number (ex: 5) or a percentage of total pods at the start of update (ex: 10%). + // Absolute number is calculated from percentage by rounding down. + // This can not be 0 if MaxSurge is 0. + // By default, a fixed value of 25% is used. + // Example: when this is set to 30%, the old RC can be scaled down by 30% + // immediately when the rolling update starts. Once new pods are ready, old RC + // can be scaled down further, followed by scaling up the new RC, ensuring + // that at least 70% of original number of pods are available at all times + // during the update. + // +optional + MaxUnavailable *intstr.IntOrString `json:"maxUnavailable,omitempty" protobuf:"bytes,5,opt,name=maxUnavailable"` + + // MaxSurge The maximum number of pods that can be scheduled above the original number of + // pods. + // Value can be an absolute number (ex: 5) or a percentage of total pods at + // the start of the update (ex: 10%). This can not be 0 if MaxUnavailable is 0. + // Absolute number is calculated from percentage by rounding up. + // By default, a value of 25% is used. + // Example: when this is set to 30%, the new RC can be scaled up by 30% + // immediately when the rolling update starts. Once old pods have been killed, + // new RC can be scaled up further, ensuring that total number of pods running + // at any time during the update is at most 130% of original pods. + // +optional + MaxSurge *intstr.IntOrString `json:"maxSurge,omitempty" protobuf:"bytes,6,opt,name=maxSurge"` + // Analysis runs a separate analysisRun while all the steps execute. This is intended to be a continuous validation of the new ReplicaSet + Analysis *RolloutAnalysisBackground `json:"analysis,omitempty" protobuf:"bytes,7,opt,name=analysis"` + // AntiAffinity enables anti-affinity rules for Canary deployment + // +optional + AntiAffinity *AntiAffinity `json:"antiAffinity,omitempty" protobuf:"bytes,8,opt,name=antiAffinity"` + // CanaryMetadata specify labels and annotations which will be attached to the canary pods for + // the duration which they act as a canary, and will be removed after + CanaryMetadata *PodTemplateMetadata `json:"canaryMetadata,omitempty" protobuf:"bytes,9,opt,name=canaryMetadata"` + // StableMetadata specify labels and annotations which will be attached to the stable pods for + // the duration which they act as a canary, and will be removed after + StableMetadata *PodTemplateMetadata `json:"stableMetadata,omitempty" protobuf:"bytes,10,opt,name=stableMetadata"` + + // ScaleDownDelaySeconds adds a delay before scaling down the previous ReplicaSet when the + // canary strategy is used with traffic routing (default 30 seconds). A delay in scaling down + // the previous ReplicaSet is needed after switching the stable service selector to point to + // the new ReplicaSet, in order to give time for traffic providers to re-target the new pods. + // This value is ignored with basic, replica-weighted canary without traffic routing. + // +optional + ScaleDownDelaySeconds *int32 `json:"scaleDownDelaySeconds,omitempty" protobuf:"varint,11,opt,name=scaleDownDelaySeconds"` + // ScaleDownDelayRevisionLimit limits the number of old RS that can run at one time before getting scaled down + // +optional + ScaleDownDelayRevisionLimit *int32 `json:"scaleDownDelayRevisionLimit,omitempty" protobuf:"varint,12,opt,name=scaleDownDelayRevisionLimit"` + // AbortScaleDownDelaySeconds adds a delay in second before scaling down the canary pods when update + // is aborted for canary strategy with traffic routing (not applicable for basic canary). + // 0 means canary pods are not scaled down. + // Default is 30 seconds. + // +optional + AbortScaleDownDelaySeconds *int32 `json:"abortScaleDownDelaySeconds,omitempty" protobuf:"varint,13,opt,name=abortScaleDownDelaySeconds"` + // DynamicStableScale is a traffic routing feature which dynamically scales the stable + // ReplicaSet to minimize total pods which are running during an update. This is calculated by + // scaling down the stable as traffic is increased to canary. When disabled (the default behavior) + // the stable ReplicaSet remains fully scaled to support instantaneous aborts. + DynamicStableScale bool `json:"dynamicStableScale,omitempty" protobuf:"varint,14,opt,name=dynamicStableScale"` + // PingPongSpec holds the ping and pong services + PingPong *PingPongSpec `json:"pingPong,omitempty" protobuf:"varint,15,opt,name=pingPong"` + // Assuming the desired number of pods in a stable or canary ReplicaSet is not zero, then make sure it is at least + // MinPodsPerReplicaSet for High Availability. Only applicable for TrafficRoutedCanary + MinPodsPerReplicaSet *int32 `json:"minPodsPerReplicaSet,omitempty" protobuf:"varint,16,opt,name=minPodsPerReplicaSet"` +} + +// PingPongSpec holds the ping and pong service name. +type PingPongSpec struct { + // name of the ping service + PingService string `json:"pingService" protobuf:"bytes,1,opt,name=pingService"` + // name of the pong service + PongService string `json:"pongService" protobuf:"bytes,2,opt,name=pongService"` +} + +// AnalysisRunStrategy configuration for the analysis runs and experiments to retain +type AnalysisRunStrategy struct { + // SuccessfulRunHistoryLimit limits the number of old successful analysis runs and experiments to be retained in a history + SuccessfulRunHistoryLimit *int32 `json:"successfulRunHistoryLimit,omitempty" protobuf:"varint,1,opt,name=successfulRunHistoryLimit"` + // UnsuccessfulRunHistoryLimit limits the number of old unsuccessful analysis runs and experiments to be retained in a history. + // Stages for unsuccessful: "Error", "Failed", "Inconclusive" + UnsuccessfulRunHistoryLimit *int32 `json:"unsuccessfulRunHistoryLimit,omitempty" protobuf:"varint,2,opt,name=unsuccessfulRunHistoryLimit"` +} + +// ALBTrafficRouting configuration for ALB ingress controller to control traffic routing +type ALBTrafficRouting struct { + // Ingress refers to the name of an `Ingress` resource in the same namespace as the `Rollout` + Ingress string `json:"ingress,omitempty" protobuf:"bytes,1,opt,name=ingress"` + // ServicePort refers to the port that the Ingress action should route traffic to + ServicePort int32 `json:"servicePort" protobuf:"varint,2,opt,name=servicePort"` + // RootService references the service in the ingress to the controller should add the action to + RootService string `json:"rootService,omitempty" protobuf:"bytes,3,opt,name=rootService"` + // AnnotationPrefix has to match the configured annotation prefix on the alb ingress controller + // +optional + AnnotationPrefix string `json:"annotationPrefix,omitempty" protobuf:"bytes,4,opt,name=annotationPrefix"` + // StickinessConfig refers to the duration-based stickiness of the target groups associated with an `Ingress` + // +optional + StickinessConfig *StickinessConfig `json:"stickinessConfig,omitempty" protobuf:"bytes,5,opt,name=stickinessConfig"` + // Ingresses refers to the name of an `Ingress` resource in the same namespace as the `Rollout` in a multi ingress scenario + // +optional + Ingresses []string `json:"ingresses,omitempty" protobuf:"bytes,6,opt,name=ingresses"` +} + +type StickinessConfig struct { + Enabled bool `json:"enabled" protobuf:"varint,1,opt,name=enabled"` + DurationSeconds int64 `json:"durationSeconds" protobuf:"varint,2,opt,name=durationSeconds"` +} + +// RolloutTrafficRouting hosts all the different configuration for supported service meshes to enable more fine-grained traffic routing +type RolloutTrafficRouting struct { + // Istio holds Istio specific configuration to route traffic + Istio *IstioTrafficRouting `json:"istio,omitempty" protobuf:"bytes,1,opt,name=istio"` + // Nginx holds Nginx Ingress specific configuration to route traffic + Nginx *NginxTrafficRouting `json:"nginx,omitempty" protobuf:"bytes,2,opt,name=nginx"` + // Nginx holds ALB Ingress specific configuration to route traffic + ALB *ALBTrafficRouting `json:"alb,omitempty" protobuf:"bytes,3,opt,name=alb"` + // SMI holds TrafficSplit specific configuration to route traffic + SMI *SMITrafficRouting `json:"smi,omitempty" protobuf:"bytes,4,opt,name=smi"` + // Ambassador holds specific configuration to use Ambassador to route traffic + Ambassador *AmbassadorTrafficRouting `json:"ambassador,omitempty" protobuf:"bytes,5,opt,name=ambassador"` + // AppMesh holds specific configuration to use AppMesh to route traffic + AppMesh *AppMeshTrafficRouting `json:"appMesh,omitempty" protobuf:"bytes,6,opt,name=appMesh"` + // Traefik holds specific configuration to use Traefik to route traffic + Traefik *TraefikTrafficRouting `json:"traefik,omitempty" protobuf:"bytes,7,opt,name=traefik"` + // ManagedRoutes A list of HTTP routes that Argo Rollouts manages, the order of this array also becomes the precedence in the upstream + // traffic router. + ManagedRoutes []MangedRoutes `json:"managedRoutes,omitempty" protobuf:"bytes,8,rep,name=managedRoutes"` + // Apisix holds specific configuration to use Apisix to route traffic + Apisix *ApisixTrafficRouting `json:"apisix,omitempty" protobuf:"bytes,9,opt,name=apisix"` + // +kubebuilder:validation:Schemaless + // +kubebuilder:pruning:PreserveUnknownFields + // +kubebuilder:validation:Type=object + // Plugins holds specific configuration that traffic router plugins can use for routing traffic + Plugins map[string]json.RawMessage `json:"plugins,omitempty" protobuf:"bytes,10,opt,name=plugins"` +} + +type MangedRoutes struct { + Name string `json:"name" protobuf:"bytes,1,opt,name=name"` + //Possibly name for future use + //canaryRoute bool +} + +// TraefikTrafficRouting defines the configuration required to use Traefik as traffic router +type TraefikTrafficRouting struct { + // TraefikServiceName refer to the name of the Traefik service used to route traffic to the service + WeightedTraefikServiceName string `json:"weightedTraefikServiceName" protobuf:"bytes,1,name=weightedTraefikServiceName"` +} + +// ApisixTrafficRouting defines the configuration required to use APISIX as traffic router +type ApisixTrafficRouting struct { + // Route references an Apisix Route to modify to shape traffic + Route *ApisixRoute `json:"route,omitempty" protobuf:"bytes,1,opt,name=route"` +} + +// ApisixRoute holds information on the APISIX Route the rollout needs to modify +type ApisixRoute struct { + // Name refer to the name of the APISIX Route used to route traffic to the service + Name string `json:"name" protobuf:"bytes,1,name=name"` + // RuleRef a list of the APISIX Route HTTP Rules used to route traffic to the service + Rules []string `json:"rules,omitempty" protobuf:"bytes,2,rep,name=rules"` +} + +// AmbassadorTrafficRouting defines the configuration required to use Ambassador as traffic +// router +type AmbassadorTrafficRouting struct { + // Mappings refer to the name of the Ambassador Mappings used to route traffic to the + // service + Mappings []string `json:"mappings" protobuf:"bytes,1,rep,name=mappings"` +} + +// SMITrafficRouting configuration for TrafficSplit Custom Resource to control traffic routing +type SMITrafficRouting struct { + // RootService holds the name of that clients use to communicate. + // +optional + RootService string `json:"rootService,omitempty" protobuf:"bytes,1,opt,name=rootService"` + // TrafficSplitName holds the name of the TrafficSplit. + // +optional + TrafficSplitName string `json:"trafficSplitName,omitempty" protobuf:"bytes,2,opt,name=trafficSplitName"` +} + +// NginxTrafficRouting configuration for Nginx ingress controller to control traffic routing +type NginxTrafficRouting struct { + // AnnotationPrefix has to match the configured annotation prefix on the nginx ingress controller + // +optional + AnnotationPrefix string `json:"annotationPrefix,omitempty" protobuf:"bytes,1,opt,name=annotationPrefix"` + // StableIngress refers to the name of an `Ingress` resource in the same namespace as the `Rollout` + StableIngress string `json:"stableIngress,omitempty" protobuf:"bytes,2,opt,name=stableIngress"` + // +optional + AdditionalIngressAnnotations map[string]string `json:"additionalIngressAnnotations,omitempty" protobuf:"bytes,3,rep,name=additionalIngressAnnotations"` + // StableIngresses refers to the names of `Ingress` resources in the same namespace as the `Rollout` in a multi ingress scenario + // +optional + StableIngresses []string `json:"stableIngresses,omitempty" protobuf:"bytes,4,rep,name=stableIngresses"` +} + +// IstioTrafficRouting configuration for Istio service mesh to enable fine grain configuration +type IstioTrafficRouting struct { + // VirtualService references an Istio VirtualService to modify to shape traffic + VirtualService *IstioVirtualService `json:"virtualService,omitempty" protobuf:"bytes,1,opt,name=virtualService"` + // DestinationRule references an Istio DestinationRule to modify to shape traffic + DestinationRule *IstioDestinationRule `json:"destinationRule,omitempty" protobuf:"bytes,2,opt,name=destinationRule"` + // VirtualServices references a list of Istio VirtualService to modify to shape traffic + VirtualServices []IstioVirtualService `json:"virtualServices,omitempty" protobuf:"bytes,3,opt,name=virtualServices"` +} + +// IstioVirtualService holds information on the virtual service the rollout needs to modify +type IstioVirtualService struct { + // Name holds the name of the VirtualService + Name string `json:"name" protobuf:"bytes,1,opt,name=name"` + // A list of HTTP routes within VirtualService to edit. If omitted, VirtualService must have a single route of this type. + Routes []string `json:"routes,omitempty" protobuf:"bytes,2,rep,name=routes"` + // A list of TLS/HTTPS routes within VirtualService to edit. If omitted, VirtualService must have a single route of this type. + TLSRoutes []TLSRoute `json:"tlsRoutes,omitempty" protobuf:"bytes,3,rep,name=tlsRoutes"` + // A list of TCP routes within VirtualService to edit. If omitted, VirtualService must have a single route of this type. + TCPRoutes []TCPRoute `json:"tcpRoutes,omitempty" protobuf:"bytes,4,rep,name=tcpRoutes"` +} + +// TLSRoute holds the information on the virtual service's TLS/HTTPS routes that are desired to be matched for changing weights. +type TLSRoute struct { + // Port number of the TLS Route desired to be matched in the given Istio VirtualService. + Port int64 `json:"port,omitempty" protobuf:"bytes,1,opt,name=port"` + // A list of all the SNI Hosts of the TLS Route desired to be matched in the given Istio VirtualService. + SNIHosts []string `json:"sniHosts,omitempty" protobuf:"bytes,2,rep,name=sniHosts"` +} + +// TCPRoute holds the information on the virtual service's TCP routes that are desired to be matched for changing weights. +type TCPRoute struct { + // Port number of the TCP Route desired to be matched in the given Istio VirtualService. + Port int64 `json:"port,omitempty" protobuf:"bytes,1,opt,name=port"` +} + +// IstioDestinationRule is a reference to an Istio DestinationRule to modify and shape traffic +type IstioDestinationRule struct { + // Name holds the name of the DestinationRule + Name string `json:"name" protobuf:"bytes,1,opt,name=name"` + // CanarySubsetName is the subset name to modify labels with canary ReplicaSet pod template hash value + CanarySubsetName string `json:"canarySubsetName" protobuf:"bytes,2,opt,name=canarySubsetName"` + // StableSubsetName is the subset name to modify labels with stable ReplicaSet pod template hash value + StableSubsetName string `json:"stableSubsetName" protobuf:"bytes,3,opt,name=stableSubsetName"` +} + +// AppMeshTrafficRouting configuration for AWS AppMesh service mesh to enable fine grain configuration +type AppMeshTrafficRouting struct { + // VirtualService references an AppMesh VirtualService and VirtualRouter to modify to shape traffic + VirtualService *AppMeshVirtualService `json:"virtualService,omitempty" protobuf:"bytes,1,opt,name=virtualService"` + // VirtualNodeGroup references an AppMesh Route targets that are formed by a set of VirtualNodes that are used to shape traffic + VirtualNodeGroup *AppMeshVirtualNodeGroup `json:"virtualNodeGroup,omitempty" protobuf:"bytes,2,opt,name=virtualNodeGroup"` +} + +// AppMeshVirtualService holds information on the virtual service the rollout needs to modify +type AppMeshVirtualService struct { + // Name is the name of virtual service + Name string `json:"name" protobuf:"bytes,1,opt,name=name"` + // Routes is list of HTTP routes within virtual router associated with virtual service to edit. If omitted, virtual service must have a single route of this type. + Routes []string `json:"routes,omitempty" protobuf:"bytes,2,rep,name=routes"` +} + +// AppMeshVirtualNodeGroup holds information about targets used for routing traffic to a virtual service +type AppMeshVirtualNodeGroup struct { + // CanaryVirtualNodeRef is the virtual node ref to modify labels with canary ReplicaSet pod template hash value + CanaryVirtualNodeRef *AppMeshVirtualNodeReference `json:"canaryVirtualNodeRef" protobuf:"bytes,1,opt,name=canaryVirtualNodeRef"` + // StableVirtualNodeRef is the virtual node name to modify labels with stable ReplicaSet pod template hash value + StableVirtualNodeRef *AppMeshVirtualNodeReference `json:"stableVirtualNodeRef" protobuf:"bytes,2,opt,name=stableVirtualNodeRef"` +} + +// AppMeshVirtualNodeReference holds a reference to VirtualNode.appmesh.k8s.aws +type AppMeshVirtualNodeReference struct { + // Name is the name of VirtualNode CR + Name string `json:"name" protobuf:"bytes,1,opt,name=name"` +} + +// RolloutExperimentStep defines a template that is used to create a experiment for a step +type RolloutExperimentStep struct { + // Templates what templates that should be added to the experiment. Should be non-nil + // +patchMergeKey=name + // +patchStrategy=merge + Templates []RolloutExperimentTemplate `json:"templates" patchStrategy:"merge" patchMergeKey:"name" protobuf:"bytes,1,rep,name=templates"` + // Duration is a duration string (e.g. 30s, 5m, 1h) that the experiment should run for + // +optional + Duration DurationString `json:"duration,omitempty" protobuf:"bytes,2,opt,name=duration,casttype=DurationString"` + // Analyses reference which analysis templates to run with the experiment + // +patchMergeKey=name + // +patchStrategy=merge + Analyses []RolloutExperimentStepAnalysisTemplateRef `json:"analyses,omitempty" patchStrategy:"merge" patchMergeKey:"name" protobuf:"bytes,3,rep,name=analyses"` +} + +type RolloutExperimentStepAnalysisTemplateRef struct { + // Name is a name for this analysis template invocation + Name string `json:"name" protobuf:"bytes,1,opt,name=name"` + // TemplateName reference of the AnalysisTemplate name used by the Experiment to create the run + TemplateName string `json:"templateName" protobuf:"bytes,2,opt,name=templateName"` + // Whether to look for the templateName at cluster scope or namespace scope + // +optional + ClusterScope bool `json:"clusterScope,omitempty" protobuf:"varint,3,opt,name=clusterScope"` + // Args the arguments that will be added to the AnalysisRuns + // +patchMergeKey=name + // +patchStrategy=merge + Args []AnalysisRunArgument `json:"args,omitempty" patchStrategy:"merge" patchMergeKey:"name" protobuf:"bytes,4,rep,name=args"` + // RequiredForCompletion blocks the Experiment from completing until the analysis has completed + RequiredForCompletion bool `json:"requiredForCompletion,omitempty" protobuf:"varint,5,opt,name=requiredForCompletion"` +} + +// RolloutExperimentTemplate defines the template used to create experiments for the Rollout's experiment canary step +type RolloutExperimentTemplate struct { + // Name description of template that passed to the template + Name string `json:"name" protobuf:"bytes,1,opt,name=name"` + // SpecRef indicates where the rollout should get the RS template from + SpecRef ReplicaSetSpecRef `json:"specRef" protobuf:"bytes,2,opt,name=specRef,casttype=ReplicaSetSpecRef"` + // Replicas replica count for the template + // +optional + Replicas *int32 `json:"replicas,omitempty" protobuf:"varint,3,opt,name=replicas"` + // Metadata sets labels and annotations to use for the RS created from the template + // +optional + Metadata PodTemplateMetadata `json:"metadata,omitempty" protobuf:"bytes,4,opt,name=metadata"` + // Selector overrides the selector to be used for the template's ReplicaSet. If omitted, will + // use the same selector as the Rollout + // +optional + Selector *metav1.LabelSelector `json:"selector,omitempty" protobuf:"bytes,5,opt,name=selector"` + // Weight sets the percentage of traffic the template's replicas should receive + Weight *int32 `json:"weight,omitempty" protobuf:"varint,6,opt,name=weight"` + // Service controls the optionally generated service + Service *TemplateService `json:"service,omitempty" protobuf:"bytes,7,opt,name=service"` +} + +// PodTemplateMetadata extra labels to add to the template +type PodTemplateMetadata struct { + // Labels Additional labels to add to the experiment + // +optional + Labels map[string]string `json:"labels,omitempty" protobuf:"bytes,1,rep,name=labels"` + // Annotations additional annotations to add to the experiment + // +optional + Annotations map[string]string `json:"annotations,omitempty" protobuf:"bytes,2,rep,name=annotations"` +} + +// AnalysisRunMetadata extra labels to add to the AnalysisRun +type AnalysisRunMetadata struct { + // Labels Additional labels to add to the AnalysisRun + // +optional + Labels map[string]string `json:"labels,omitempty" protobuf:"bytes,1,rep,name=labels"` + // Annotations additional annotations to add to the AnalysisRun + // +optional + Annotations map[string]string `json:"annotations,omitempty" protobuf:"bytes,2,rep,name=annotations"` +} + +// ReplicaSetSpecRef defines which RS that the experiment's template will use. +type ReplicaSetSpecRef string + +const ( + // CanarySpecRef indicates the RS template should be pulled from the newRS's template + CanarySpecRef ReplicaSetSpecRef = "canary" + // StableSpecRef indicates the RS template should be pulled from the stableRS's template + StableSpecRef ReplicaSetSpecRef = "stable" +) + +// CanaryStep defines a step of a canary deployment. +type CanaryStep struct { + // SetWeight sets what percentage of the newRS should receive + SetWeight *int32 `json:"setWeight,omitempty" protobuf:"varint,1,opt,name=setWeight"` + // Pause freezes the rollout by setting spec.Paused to true. + // A Rollout will resume when spec.Paused is reset to false. + // +optional + Pause *RolloutPause `json:"pause,omitempty" protobuf:"bytes,2,opt,name=pause"` + // Experiment defines the experiment object that should be created + Experiment *RolloutExperimentStep `json:"experiment,omitempty" protobuf:"bytes,3,opt,name=experiment"` + // Analysis defines the AnalysisRun that will run for a step + Analysis *RolloutAnalysis `json:"analysis,omitempty" protobuf:"bytes,4,opt,name=analysis"` + // SetCanaryScale defines how to scale the newRS without changing traffic weight + // +optional + SetCanaryScale *SetCanaryScale `json:"setCanaryScale,omitempty" protobuf:"bytes,5,opt,name=setCanaryScale"` + // SetHeaderRoute defines the route with specified header name to send 100% of traffic to the canary service + // +optional + SetHeaderRoute *SetHeaderRoute `json:"setHeaderRoute,omitempty" protobuf:"bytes,6,opt,name=setHeaderRoute"` + // SetMirrorRoutes Mirrors traffic that matches rules to a particular destination + // +optional + SetMirrorRoute *SetMirrorRoute `json:"setMirrorRoute,omitempty" protobuf:"bytes,8,opt,name=setMirrorRoute"` +} + +type SetMirrorRoute struct { + // Name this is the name of the route to use for the mirroring of traffic this also needs + // to be included in the `spec.strategy.canary.trafficRouting.managedRoutes` field + Name string `json:"name" protobuf:"bytes,1,opt,name=name"` + // Match Contains a list of rules that if mated will mirror the traffic to the services + // +optional + Match []RouteMatch `json:"match,omitempty" protobuf:"bytes,2,opt,name=match"` + + // Services The list of services to mirror the traffic to if the method, path, headers match + //Service string `json:"service" protobuf:"bytes,3,opt,name=service"` + // Percentage What percent of the traffic that matched the rules should be mirrored + Percentage *int32 `json:"percentage,omitempty" protobuf:"varint,4,opt,name=percentage"` +} + +type RouteMatch struct { + // Method What http methods should be mirrored + // +optional + Method *StringMatch `json:"method,omitempty" protobuf:"bytes,1,opt,name=method"` + // Path What url paths should be mirrored + // +optional + Path *StringMatch `json:"path,omitempty" protobuf:"bytes,2,opt,name=path"` + // Headers What request with matching headers should be mirrored + // +optional + Headers map[string]StringMatch `json:"headers,omitempty" protobuf:"bytes,3,opt,name=headers"` +} + +// StringMatch Used to define what type of matching we will use exact, prefix, or regular expression +type StringMatch struct { + // Exact The string must match exactly + Exact string `json:"exact,omitempty" protobuf:"bytes,1,opt,name=exact"` + // Prefix The string will be prefixed matched + Prefix string `json:"prefix,omitempty" protobuf:"bytes,2,opt,name=prefix"` + // Regex The string will be regular expression matched + Regex string `json:"regex,omitempty" protobuf:"bytes,3,opt,name=regex"` +} + +// SetHeaderRoute defines the route with specified header name to send 100% of traffic to the canary service +type SetHeaderRoute struct { + // Name this is the name of the route to use for the mirroring of traffic this also needs + // to be included in the `spec.strategy.canary.trafficRouting.managedRoutes` field + Name string `json:"name,omitempty" protobuf:"bytes,1,opt,name=name"` + Match []HeaderRoutingMatch `json:"match,omitempty" protobuf:"bytes,2,rep,name=match"` +} + +type HeaderRoutingMatch struct { + // HeaderName the name of the request header + HeaderName string `json:"headerName" protobuf:"bytes,1,opt,name=headerName"` + // HeaderValue the value of the header + HeaderValue *StringMatch `json:"headerValue" protobuf:"bytes,2,opt,name=headerValue"` +} + +// SetCanaryScale defines how to scale the newRS without changing traffic weight +type SetCanaryScale struct { + // Weight sets the percentage of replicas the newRS should have + // +optional + Weight *int32 `json:"weight,omitempty" protobuf:"varint,1,opt,name=weight"` + // Replicas sets the number of replicas the newRS should have + // +optional + Replicas *int32 `json:"replicas,omitempty" protobuf:"varint,2,opt,name=replicas"` + // MatchTrafficWeight cancels out previously set Replicas or Weight, effectively activating SetWeight + // +optional + MatchTrafficWeight bool `json:"matchTrafficWeight,omitempty" protobuf:"varint,3,opt,name=matchTrafficWeight"` +} + +// RolloutAnalysisBackground defines a template that is used to create a background analysisRun +type RolloutAnalysisBackground struct { + RolloutAnalysis `json:",inline" protobuf:"bytes,1,opt,name=rolloutAnalysis"` + // StartingStep indicates which step the background analysis should start on + // If not listed, controller defaults to 0 + StartingStep *int32 `json:"startingStep,omitempty" protobuf:"varint,2,opt,name=startingStep"` +} + +// RolloutAnalysis defines a template that is used to create a analysisRun +type RolloutAnalysis struct { + // Templates reference to a list of analysis templates to combine for an AnalysisRun + // +patchMergeKey=templateName + // +patchStrategy=merge + Templates []RolloutAnalysisTemplate `json:"templates,omitempty" patchStrategy:"merge" patchMergeKey:"templateName" protobuf:"bytes,1,rep,name=templates"` + // Args the arguments that will be added to the AnalysisRuns + // +patchMergeKey=name + // +patchStrategy=merge + Args []AnalysisRunArgument `json:"args,omitempty" patchStrategy:"merge" patchMergeKey:"name" protobuf:"bytes,2,rep,name=args"` + // DryRun object contains the settings for running the analysis in Dry-Run mode + // +patchMergeKey=metricName + // +patchStrategy=merge + // +optional + DryRun []DryRun `json:"dryRun,omitempty" patchStrategy:"merge" patchMergeKey:"metricName" protobuf:"bytes,3,rep,name=dryRun"` + // MeasurementRetention object contains the settings for retaining the number of measurements during the analysis + // +patchMergeKey=metricName + // +patchStrategy=merge + // +optional + MeasurementRetention []MeasurementRetention `json:"measurementRetention,omitempty" patchStrategy:"merge" patchMergeKey:"metricName" protobuf:"bytes,4,rep,name=measurementRetention"` + // AnalysisRunMetadata labels and annotations that will be added to the AnalysisRuns + // +optional + AnalysisRunMetadata AnalysisRunMetadata `json:"analysisRunMetadata,omitempty" protobuf:"bytes,5,opt,name=analysisRunMetadata"` +} + +type RolloutAnalysisTemplate struct { + //TemplateName name of template to use in AnalysisRun + // +optional + TemplateName string `json:"templateName" protobuf:"bytes,1,opt,name=templateName"` + // Whether to look for the templateName at cluster scope or namespace scope + // +optional + ClusterScope bool `json:"clusterScope,omitempty" protobuf:"varint,2,opt,name=clusterScope"` +} + +// AnalysisRunArgument argument to add to analysisRun +type AnalysisRunArgument struct { + // Name argument name + Name string `json:"name" protobuf:"bytes,1,opt,name=name"` + // Value a hardcoded value for the argument. This field is a one of field with valueFrom + Value string `json:"value,omitempty" protobuf:"bytes,2,opt,name=value"` + // ValueFrom A reference to where the value is stored. This field is a one of field with valueFrom + ValueFrom *ArgumentValueFrom `json:"valueFrom,omitempty" protobuf:"bytes,3,opt,name=valueFrom"` +} + +// ArgumentValueFrom defines references to fields within resources to grab for the value (i.e. Pod Template Hash) +type ArgumentValueFrom struct { + // PodTemplateHashValue gets the value from one of the children ReplicaSet's Pod Template Hash + PodTemplateHashValue *ValueFromPodTemplateHash `json:"podTemplateHashValue,omitempty" protobuf:"bytes,1,opt,name=podTemplateHashValue,casttype=ValueFromPodTemplateHash"` + //FieldRef + FieldRef *FieldRef `json:"fieldRef,omitempty" protobuf:"bytes,2,opt,name=fieldRef"` +} + +type FieldRef struct { + // Required: Path of the field to select in the specified API version + FieldPath string `json:"fieldPath" protobuf:"bytes,1,opt,name=fieldPath"` +} + +// ValueFromPodTemplateHash indicates which ReplicaSet pod template pod hash to use +type ValueFromPodTemplateHash string + +const ( + // Stable tells the Rollout to get the pod template hash from the stable ReplicaSet + Stable ValueFromPodTemplateHash = "Stable" + // Latest tells the Rollout to get the pod template hash from the latest ReplicaSet + Latest ValueFromPodTemplateHash = "Latest" +) + +const ( + // RolloutTypeLabel indicates how the rollout created the analysisRun + RolloutTypeLabel = "rollout-type" + // RolloutTypeStepLabel indicates that the analysisRun was created as a canary step + RolloutTypeStepLabel = "Step" + // RolloutTypeBackgroundRunLabel indicates that the analysisRun was created in Background to an execution + RolloutTypeBackgroundRunLabel = "Background" + // RolloutTypePrePromotionLabel indicates that the analysisRun was created before the active service promotion + RolloutTypePrePromotionLabel = "PrePromotion" + // RolloutTypePostPromotionLabel indicates that the analysisRun was created after the active service promotion + RolloutTypePostPromotionLabel = "PostPromotion" + // RolloutCanaryStepIndexLabel indicates which step created this analysisRun + RolloutCanaryStepIndexLabel = "step-index" +) + +// RolloutPause defines a pause stage for a rollout +type RolloutPause struct { + // Duration the amount of time to wait before moving to the next step. + // +optional + Duration *intstr.IntOrString `json:"duration,omitempty" protobuf:"bytes,1,opt,name=duration"` +} + +// DurationSeconds converts the pause duration to seconds +// If Duration is nil 0 is returned +// if Duration values is string and does not contain a valid unit -1 is returned +func (p RolloutPause) DurationSeconds() int32 { + if p.Duration != nil { + if p.Duration.Type == intstr.String { + s, err := strconv.ParseInt(p.Duration.StrVal, 10, 32) + if err != nil { + d, err := time.ParseDuration(p.Duration.StrVal) + if err != nil { + return -1 + } + return int32(d.Seconds()) + } + // special case where no unit was specified + return int32(s) + } + return p.Duration.IntVal + } + return 0 +} + +// DurationFromInt creates duration in seconds from int value +func DurationFromInt(i int) *intstr.IntOrString { + d := intstr.FromInt(i) + return &d +} + +// DurationFromString creates duration from string +// value must be a string representation of an int with optional time unit (see time.ParseDuration) +func DurationFromString(s string) *intstr.IntOrString { + d := intstr.FromString(s) + return &d +} + +// PauseReason reasons that the rollout can pause +type PauseReason string + +const ( + // PauseReasonInconclusiveAnalysis pauses rollout when rollout has an inconclusive analysis run + PauseReasonInconclusiveAnalysis PauseReason = "InconclusiveAnalysisRun" + // PauseReasonInconclusiveExperiment pauses rollout when rollout has an inconclusive experiment + PauseReasonInconclusiveExperiment PauseReason = "InconclusiveExperiment" + // PauseReasonCanaryPauseStep pause rollout for canary pause step + PauseReasonCanaryPauseStep PauseReason = "CanaryPauseStep" + // PauseReasonBlueGreenPause pause rollout before promoting rollout + PauseReasonBlueGreenPause PauseReason = "BlueGreenPause" +) + +// PauseCondition the reason for a pause and when it started +type PauseCondition struct { + Reason PauseReason `json:"reason" protobuf:"bytes,1,opt,name=reason,casttype=PauseReason"` + StartTime metav1.Time `json:"startTime" protobuf:"bytes,2,opt,name=startTime"` +} + +// RolloutPhase are a set of phases that this rollout +type RolloutPhase string + +const ( + // RolloutPhaseHealthy indicates a rollout is healthy + RolloutPhaseHealthy RolloutPhase = "Healthy" + // RolloutPhaseDegraded indicates a rollout is degraded (e.g. pod unavailability, misconfiguration) + RolloutPhaseDegraded RolloutPhase = "Degraded" + // RolloutPhaseProgressing indicates a rollout is not yet healthy but still making progress towards a healthy state + RolloutPhaseProgressing RolloutPhase = "Progressing" + // RolloutPhasePaused indicates a rollout is not yet healthy and will not make progress until unpaused + RolloutPhasePaused RolloutPhase = "Paused" +) + +// RolloutStatus is the status for a Rollout resource +type RolloutStatus struct { + // Abort cancel the current rollout progression + Abort bool `json:"abort,omitempty" protobuf:"varint,1,opt,name=abort"` + // PauseConditions is a list of reasons why rollout became automatically paused (e.g. + // CanaryPauseStep, BlueGreenPause, InconclusiveAnalysis). The items in this list are populated + // by the controller but are cleared by the user (e.g. plugin, argo-cd resume action) when they + // wish to unpause. If pause conditions is empty, but controllerPause is true, it indicates + // the user manually unpaused the Rollout + PauseConditions []PauseCondition `json:"pauseConditions,omitempty" protobuf:"bytes,2,rep,name=pauseConditions"` + // ControllerPause indicates the controller has paused the rollout. It is set to true when + // the controller adds a pause condition. This field helps to discern the scenario where a + // rollout was resumed after being paused by the controller (e.g. via the plugin). In that + // situation, the pauseConditions would have been cleared , but controllerPause would still be + // set to true. + ControllerPause bool `json:"controllerPause,omitempty" protobuf:"varint,3,opt,name=controllerPause"` + // AbortedAt indicates the controller reconciled an aborted rollout. The controller uses this to understand if + // the controller needs to do some specific work when a Rollout is aborted. For example, the reconcileAbort is used + // to indicate if the Rollout should enter an aborted state when the latest AnalysisRun is a failure, or the controller + // has already put the Rollout into an aborted and should create a new AnalysisRun. + AbortedAt *metav1.Time `json:"abortedAt,omitempty" protobuf:"bytes,4,opt,name=abortedAt"` + // CurrentPodHash the hash of the current pod template + // +optional + CurrentPodHash string `json:"currentPodHash,omitempty" protobuf:"bytes,5,opt,name=currentPodHash"` + // CurrentStepHash the hash of the current list of steps for the current strategy. This is used to detect when the + // list of current steps change + // +optional + CurrentStepHash string `json:"currentStepHash,omitempty" protobuf:"bytes,6,opt,name=currentStepHash"` + // Total number of non-terminated pods targeted by this rollout (their labels match the selector). + // +optional + Replicas int32 `json:"replicas,omitempty" protobuf:"varint,7,opt,name=replicas"` + // Total number of non-terminated pods targeted by this rollout that have the desired template spec. + // +optional + UpdatedReplicas int32 `json:"updatedReplicas,omitempty" protobuf:"varint,8,opt,name=updatedReplicas"` + // Total number of ready pods targeted by this rollout. + // +optional + ReadyReplicas int32 `json:"readyReplicas,omitempty" protobuf:"varint,9,opt,name=readyReplicas"` + // Total number of available pods (ready for at least minReadySeconds) targeted by this rollout. + // +optional + AvailableReplicas int32 `json:"availableReplicas,omitempty" protobuf:"varint,10,opt,name=availableReplicas"` + // CurrentStepIndex defines the current step of the rollout is on. If the current step index is null, the + // controller will execute the rollout. + // +optional + CurrentStepIndex *int32 `json:"currentStepIndex,omitempty" protobuf:"varint,11,opt,name=currentStepIndex"` + // Count of hash collisions for the Rollout. The Rollout controller uses this + // field as a collision avoidance mechanism when it needs to create the name for the + // newest ReplicaSet. + // +optional + CollisionCount *int32 `json:"collisionCount,omitempty" protobuf:"varint,12,opt,name=collisionCount"` + // The generation observed by the rollout controller from metadata.generation + // +optional + ObservedGeneration string `json:"observedGeneration,omitempty" protobuf:"bytes,13,opt,name=observedGeneration"` + // Conditions a list of conditions a rollout can have. + // +optional + Conditions []RolloutCondition `json:"conditions,omitempty" protobuf:"bytes,14,rep,name=conditions"` + // Canary describes the state of the canary rollout + // +optional + Canary CanaryStatus `json:"canary,omitempty" protobuf:"bytes,15,opt,name=canary"` + // BlueGreen describes the state of the bluegreen rollout + // +optional + BlueGreen BlueGreenStatus `json:"blueGreen,omitempty" protobuf:"bytes,16,opt,name=blueGreen"` + // HPAReplicas the number of non-terminated replicas that are receiving active traffic + // +optional + HPAReplicas int32 `json:"HPAReplicas,omitempty" protobuf:"varint,17,opt,name=HPAReplicas"` + // Selector that identifies the pods that are receiving active traffic + // +optional + Selector string `json:"selector,omitempty" protobuf:"bytes,18,opt,name=selector"` + // StableRS indicates the replicaset that has successfully rolled out + // +optional + StableRS string `json:"stableRS,omitempty" protobuf:"bytes,19,opt,name=stableRS"` + // RestartedAt indicates last time a Rollout was restarted + RestartedAt *metav1.Time `json:"restartedAt,omitempty" protobuf:"bytes,20,opt,name=restartedAt"` + // PromoteFull indicates if the rollout should perform a full promotion, skipping analysis and pauses. + PromoteFull bool `json:"promoteFull,omitempty" protobuf:"varint,21,opt,name=promoteFull"` + // Phase is the rollout phase. Clients should only rely on the value if status.observedGeneration equals metadata.generation + Phase RolloutPhase `json:"phase,omitempty" protobuf:"bytes,22,opt,name=phase,casttype=RolloutPhase"` + // Message provides details on why the rollout is in its current phase + Message string `json:"message,omitempty" protobuf:"bytes,23,opt,name=message"` + // The generation of referenced workload observed by the rollout controller + // +optional + WorkloadObservedGeneration string `json:"workloadObservedGeneration,omitempty" protobuf:"bytes,24,opt,name=workloadObservedGeneration"` + /// ALB keeps information regarding the ALB and TargetGroups + ALB *ALBStatus `json:"alb,omitempty" protobuf:"bytes,25,opt,name=alb"` + /// ALBs keeps information regarding multiple ALBs and TargetGroups in a multi ingress scenario + ALBs []ALBStatus `json:"albs,omitempty" protobuf:"bytes,26,opt,name=albs"` +} + +// BlueGreenStatus status fields that only pertain to the blueGreen rollout +type BlueGreenStatus struct { + // PreviewSelector indicates which replicas set the preview service is serving traffic to + // +optional + PreviewSelector string `json:"previewSelector,omitempty" protobuf:"bytes,1,opt,name=previewSelector"` + // ActiveSelector indicates which replicas set the active service is serving traffic to + // +optional + ActiveSelector string `json:"activeSelector,omitempty" protobuf:"bytes,2,opt,name=activeSelector"` + // ScaleUpPreviewCheckPoint indicates that the Replicaset receiving traffic from the preview service is ready to be scaled up after the rollout is unpaused + // +optional + ScaleUpPreviewCheckPoint bool `json:"scaleUpPreviewCheckPoint,omitempty" protobuf:"varint,3,opt,name=scaleUpPreviewCheckPoint"` + // PrePromotionAnalysisRunStatus indicates the status of the current prepromotion analysis run + PrePromotionAnalysisRunStatus *RolloutAnalysisRunStatus `json:"prePromotionAnalysisRunStatus,omitempty" protobuf:"bytes,4,opt,name=prePromotionAnalysisRunStatus"` + // PostPromotionAnalysisRunStatus indicates the status of the current post promotion analysis run + PostPromotionAnalysisRunStatus *RolloutAnalysisRunStatus `json:"postPromotionAnalysisRunStatus,omitempty" protobuf:"bytes,5,opt,name=postPromotionAnalysisRunStatus"` +} + +// CanaryStatus status fields that only pertain to the canary rollout +type CanaryStatus struct { + // CurrentStepAnalysisRunStatus indicates the status of the current step analysis run + CurrentStepAnalysisRunStatus *RolloutAnalysisRunStatus `json:"currentStepAnalysisRunStatus,omitempty" protobuf:"bytes,1,opt,name=currentStepAnalysisRunStatus"` + // CurrentBackgroundAnalysisRunStatus indicates the status of the current background analysis run + CurrentBackgroundAnalysisRunStatus *RolloutAnalysisRunStatus `json:"currentBackgroundAnalysisRunStatus,omitempty" protobuf:"bytes,2,opt,name=currentBackgroundAnalysisRunStatus"` + // CurrentExperiment indicates the running experiment + CurrentExperiment string `json:"currentExperiment,omitempty" protobuf:"bytes,3,opt,name=currentExperiment"` + // Weights records the weights which have been set on traffic provider. Only valid when using traffic routing + Weights *TrafficWeights `json:"weights,omitempty" protobuf:"bytes,4,opt,name=weights"` + // StablePingPong For the ping-pong feature holds the current stable service, ping or pong + StablePingPong PingPongType `json:"stablePingPong,omitempty" protobuf:"bytes,5,opt,name=stablePingPong"` +} + +type PingPongType string + +const ( + PPPing PingPongType = "ping" + PPPong PingPongType = "pong" +) + +// TrafficWeights describes the current status of how traffic has been split +type TrafficWeights struct { + // Canary is the current traffic weight split to canary ReplicaSet + Canary WeightDestination `json:"canary" protobuf:"bytes,1,opt,name=canary"` + // Stable is the current traffic weight split to stable ReplicaSet + Stable WeightDestination `json:"stable" protobuf:"bytes,2,opt,name=stable"` + // Additional holds the weights split to additional ReplicaSets such as experiment ReplicaSets + Additional []WeightDestination `json:"additional,omitempty" protobuf:"bytes,3,rep,name=additional"` + // Verified is an optional indicator that the weight has been verified to have taken effect. + // This is currently only applicable to ALB traffic router + Verified *bool `json:"verified,omitempty" protobuf:"bytes,4,opt,name=verified"` +} + +type WeightDestination struct { + // Weight is an percentage of traffic being sent to this destination + Weight int32 `json:"weight" protobuf:"varint,1,opt,name=weight"` + // ServiceName is the Kubernetes service name traffic is being sent to + ServiceName string `json:"serviceName,omitempty" protobuf:"bytes,2,opt,name=serviceName"` + // PodTemplateHash is the pod template hash label for this destination + PodTemplateHash string `json:"podTemplateHash,omitempty" protobuf:"bytes,3,opt,name=podTemplateHash"` +} + +type RolloutAnalysisRunStatus struct { + Name string `json:"name" protobuf:"bytes,1,opt,name=name"` + Status AnalysisPhase `json:"status" protobuf:"bytes,2,opt,name=status,casttype=AnalysisPhase"` + Message string `json:"message,omitempty" protobuf:"bytes,3,opt,name=message"` +} + +type ALBStatus struct { + LoadBalancer AwsResourceRef `json:"loadBalancer,omitempty" protobuf:"bytes,1,opt,name=loadBalancer"` + CanaryTargetGroup AwsResourceRef `json:"canaryTargetGroup,omitempty" protobuf:"bytes,2,opt,name=canaryTargetGroup"` + StableTargetGroup AwsResourceRef `json:"stableTargetGroup,omitempty" protobuf:"bytes,3,opt,name=stableTargetGroup"` + Ingress string `json:"ingress,omitempty" protobuf:"bytes,4,opt,name=ingress"` +} + +type AwsResourceRef struct { + Name string `json:"name" protobuf:"bytes,1,opt,name=name"` + ARN string `json:"arn" protobuf:"bytes,2,opt,name=arn"` + // FullName is the full name of the resource + // +optional + FullName string `json:"fullName" protobuf:"bytes,3,opt,name=fullName"` +} + +// RolloutConditionType defines the conditions of Rollout +type RolloutConditionType string + +// These are valid conditions of a rollout. +const ( + // InvalidSpec means the rollout has an invalid spec and will not progress until + // the spec is fixed. + InvalidSpec RolloutConditionType = "InvalidSpec" + // RolloutAvailable means the rollout is available, ie. the active service is pointing at a + // replicaset with the required replicas up and running for at least minReadySeconds. + RolloutAvailable RolloutConditionType = "Available" + // RolloutProgressing means the rollout is progressing. Progress for a rollout is + // considered when a new replica set is created or adopted, when pods scale + // up or old pods scale down, or when the services are updated. Progress is not estimated + // for paused rollouts. + RolloutProgressing RolloutConditionType = "Progressing" + // RolloutReplicaFailure ReplicaFailure is added in a deployment when one of its pods + // fails to be created or deleted. + RolloutReplicaFailure RolloutConditionType = "ReplicaFailure" + // RolloutPaused means that rollout is in a paused state. It is still progressing at this point. + RolloutPaused RolloutConditionType = "Paused" + // RolloutCompleted indicates that the rollout completed its update to the desired revision and is not in the middle + // of any update. Note that a Completed rollout could also be considered Progressing or Degraded, if its Pods become + // unavailable sometime after the update completes. + RolloutCompleted RolloutConditionType = "Completed" + // RolloutHealthy means that rollout is in a completed state and is healthy. Which means that all the pods have been updated + // and are passing their health checks and are ready to serve traffic. + RolloutHealthy RolloutConditionType = "Healthy" +) + +// RolloutCondition describes the state of a rollout at a certain point. +type RolloutCondition struct { + // Type of deployment condition. + Type RolloutConditionType `json:"type" protobuf:"bytes,1,opt,name=type,casttype=RolloutConditionType"` + // Phase of the condition, one of True, False, Unknown. + Status corev1.ConditionStatus `json:"status" protobuf:"bytes,2,opt,name=status,casttype=k8s.io/api/core/v1.ConditionStatus"` + // The last time this condition was updated. + LastUpdateTime metav1.Time `json:"lastUpdateTime" protobuf:"bytes,3,opt,name=lastUpdateTime"` + // Last time the condition transitioned from one status to another. + LastTransitionTime metav1.Time `json:"lastTransitionTime" protobuf:"bytes,4,opt,name=lastTransitionTime"` + // The reason for the condition's last transition. + Reason string `json:"reason" protobuf:"bytes,5,opt,name=reason"` + // A human readable message indicating details about the transition. + Message string `json:"message" protobuf:"bytes,6,opt,name=message"` +} + +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// RolloutList is a list of Rollout resources +type RolloutList struct { + metav1.TypeMeta `json:",inline"` + metav1.ListMeta `json:"metadata" protobuf:"bytes,1,opt,name=metadata"` + + Items []Rollout `json:"items" protobuf:"bytes,2,rep,name=items"` +} + +type RollbackWindowSpec struct { + Revisions int32 `json:"revisions,omitempty" protobuf:"varint,1,opt,name=revisions"` +} diff --git a/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1/zz_generated.deepcopy.go b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1/zz_generated.deepcopy.go new file mode 100644 index 000000000000..2ec2d88b9751 --- /dev/null +++ b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1/zz_generated.deepcopy.go @@ -0,0 +1,2971 @@ +//go:build !ignore_autogenerated +// +build !ignore_autogenerated + +/* +Copyright The Kubernetes 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 deepcopy-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + json "encoding/json" + + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + runtime "k8s.io/apimachinery/pkg/runtime" + intstr "k8s.io/apimachinery/pkg/util/intstr" +) + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ALBStatus) DeepCopyInto(out *ALBStatus) { + *out = *in + out.LoadBalancer = in.LoadBalancer + out.CanaryTargetGroup = in.CanaryTargetGroup + out.StableTargetGroup = in.StableTargetGroup + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ALBStatus. +func (in *ALBStatus) DeepCopy() *ALBStatus { + if in == nil { + return nil + } + out := new(ALBStatus) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ALBTrafficRouting) DeepCopyInto(out *ALBTrafficRouting) { + *out = *in + if in.StickinessConfig != nil { + in, out := &in.StickinessConfig, &out.StickinessConfig + *out = new(StickinessConfig) + **out = **in + } + if in.Ingresses != nil { + in, out := &in.Ingresses, &out.Ingresses + *out = make([]string, len(*in)) + copy(*out, *in) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ALBTrafficRouting. +func (in *ALBTrafficRouting) DeepCopy() *ALBTrafficRouting { + if in == nil { + return nil + } + out := new(ALBTrafficRouting) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *AmbassadorTrafficRouting) DeepCopyInto(out *AmbassadorTrafficRouting) { + *out = *in + if in.Mappings != nil { + in, out := &in.Mappings, &out.Mappings + *out = make([]string, len(*in)) + copy(*out, *in) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AmbassadorTrafficRouting. +func (in *AmbassadorTrafficRouting) DeepCopy() *AmbassadorTrafficRouting { + if in == nil { + return nil + } + out := new(AmbassadorTrafficRouting) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *AnalysisRun) DeepCopyInto(out *AnalysisRun) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + in.Spec.DeepCopyInto(&out.Spec) + in.Status.DeepCopyInto(&out.Status) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AnalysisRun. +func (in *AnalysisRun) DeepCopy() *AnalysisRun { + if in == nil { + return nil + } + out := new(AnalysisRun) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *AnalysisRun) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *AnalysisRunArgument) DeepCopyInto(out *AnalysisRunArgument) { + *out = *in + if in.ValueFrom != nil { + in, out := &in.ValueFrom, &out.ValueFrom + *out = new(ArgumentValueFrom) + (*in).DeepCopyInto(*out) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AnalysisRunArgument. +func (in *AnalysisRunArgument) DeepCopy() *AnalysisRunArgument { + if in == nil { + return nil + } + out := new(AnalysisRunArgument) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *AnalysisRunList) DeepCopyInto(out *AnalysisRunList) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ListMeta.DeepCopyInto(&out.ListMeta) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]AnalysisRun, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AnalysisRunList. +func (in *AnalysisRunList) DeepCopy() *AnalysisRunList { + if in == nil { + return nil + } + out := new(AnalysisRunList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *AnalysisRunList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *AnalysisRunMetadata) DeepCopyInto(out *AnalysisRunMetadata) { + *out = *in + if in.Labels != nil { + in, out := &in.Labels, &out.Labels + *out = make(map[string]string, len(*in)) + for key, val := range *in { + (*out)[key] = val + } + } + if in.Annotations != nil { + in, out := &in.Annotations, &out.Annotations + *out = make(map[string]string, len(*in)) + for key, val := range *in { + (*out)[key] = val + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AnalysisRunMetadata. +func (in *AnalysisRunMetadata) DeepCopy() *AnalysisRunMetadata { + if in == nil { + return nil + } + out := new(AnalysisRunMetadata) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *AnalysisRunSpec) DeepCopyInto(out *AnalysisRunSpec) { + *out = *in + if in.Metrics != nil { + in, out := &in.Metrics, &out.Metrics + *out = make([]Metric, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + if in.Args != nil { + in, out := &in.Args, &out.Args + *out = make([]Argument, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + if in.DryRun != nil { + in, out := &in.DryRun, &out.DryRun + *out = make([]DryRun, len(*in)) + copy(*out, *in) + } + if in.MeasurementRetention != nil { + in, out := &in.MeasurementRetention, &out.MeasurementRetention + *out = make([]MeasurementRetention, len(*in)) + copy(*out, *in) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AnalysisRunSpec. +func (in *AnalysisRunSpec) DeepCopy() *AnalysisRunSpec { + if in == nil { + return nil + } + out := new(AnalysisRunSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *AnalysisRunStatus) DeepCopyInto(out *AnalysisRunStatus) { + *out = *in + if in.MetricResults != nil { + in, out := &in.MetricResults, &out.MetricResults + *out = make([]MetricResult, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + if in.StartedAt != nil { + in, out := &in.StartedAt, &out.StartedAt + *out = (*in).DeepCopy() + } + out.RunSummary = in.RunSummary + if in.DryRunSummary != nil { + in, out := &in.DryRunSummary, &out.DryRunSummary + *out = new(RunSummary) + **out = **in + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AnalysisRunStatus. +func (in *AnalysisRunStatus) DeepCopy() *AnalysisRunStatus { + if in == nil { + return nil + } + out := new(AnalysisRunStatus) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *AnalysisRunStrategy) DeepCopyInto(out *AnalysisRunStrategy) { + *out = *in + if in.SuccessfulRunHistoryLimit != nil { + in, out := &in.SuccessfulRunHistoryLimit, &out.SuccessfulRunHistoryLimit + *out = new(int32) + **out = **in + } + if in.UnsuccessfulRunHistoryLimit != nil { + in, out := &in.UnsuccessfulRunHistoryLimit, &out.UnsuccessfulRunHistoryLimit + *out = new(int32) + **out = **in + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AnalysisRunStrategy. +func (in *AnalysisRunStrategy) DeepCopy() *AnalysisRunStrategy { + if in == nil { + return nil + } + out := new(AnalysisRunStrategy) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *AnalysisTemplate) DeepCopyInto(out *AnalysisTemplate) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + in.Spec.DeepCopyInto(&out.Spec) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AnalysisTemplate. +func (in *AnalysisTemplate) DeepCopy() *AnalysisTemplate { + if in == nil { + return nil + } + out := new(AnalysisTemplate) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *AnalysisTemplate) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *AnalysisTemplateList) DeepCopyInto(out *AnalysisTemplateList) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ListMeta.DeepCopyInto(&out.ListMeta) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]AnalysisTemplate, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AnalysisTemplateList. +func (in *AnalysisTemplateList) DeepCopy() *AnalysisTemplateList { + if in == nil { + return nil + } + out := new(AnalysisTemplateList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *AnalysisTemplateList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *AnalysisTemplateSpec) DeepCopyInto(out *AnalysisTemplateSpec) { + *out = *in + if in.Metrics != nil { + in, out := &in.Metrics, &out.Metrics + *out = make([]Metric, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + if in.Args != nil { + in, out := &in.Args, &out.Args + *out = make([]Argument, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + if in.DryRun != nil { + in, out := &in.DryRun, &out.DryRun + *out = make([]DryRun, len(*in)) + copy(*out, *in) + } + if in.MeasurementRetention != nil { + in, out := &in.MeasurementRetention, &out.MeasurementRetention + *out = make([]MeasurementRetention, len(*in)) + copy(*out, *in) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AnalysisTemplateSpec. +func (in *AnalysisTemplateSpec) DeepCopy() *AnalysisTemplateSpec { + if in == nil { + return nil + } + out := new(AnalysisTemplateSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *AntiAffinity) DeepCopyInto(out *AntiAffinity) { + *out = *in + if in.PreferredDuringSchedulingIgnoredDuringExecution != nil { + in, out := &in.PreferredDuringSchedulingIgnoredDuringExecution, &out.PreferredDuringSchedulingIgnoredDuringExecution + *out = new(PreferredDuringSchedulingIgnoredDuringExecution) + **out = **in + } + if in.RequiredDuringSchedulingIgnoredDuringExecution != nil { + in, out := &in.RequiredDuringSchedulingIgnoredDuringExecution, &out.RequiredDuringSchedulingIgnoredDuringExecution + *out = new(RequiredDuringSchedulingIgnoredDuringExecution) + **out = **in + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AntiAffinity. +func (in *AntiAffinity) DeepCopy() *AntiAffinity { + if in == nil { + return nil + } + out := new(AntiAffinity) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ApisixRoute) DeepCopyInto(out *ApisixRoute) { + *out = *in + if in.Rules != nil { + in, out := &in.Rules, &out.Rules + *out = make([]string, len(*in)) + copy(*out, *in) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ApisixRoute. +func (in *ApisixRoute) DeepCopy() *ApisixRoute { + if in == nil { + return nil + } + out := new(ApisixRoute) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ApisixTrafficRouting) DeepCopyInto(out *ApisixTrafficRouting) { + *out = *in + if in.Route != nil { + in, out := &in.Route, &out.Route + *out = new(ApisixRoute) + (*in).DeepCopyInto(*out) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ApisixTrafficRouting. +func (in *ApisixTrafficRouting) DeepCopy() *ApisixTrafficRouting { + if in == nil { + return nil + } + out := new(ApisixTrafficRouting) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *AppMeshTrafficRouting) DeepCopyInto(out *AppMeshTrafficRouting) { + *out = *in + if in.VirtualService != nil { + in, out := &in.VirtualService, &out.VirtualService + *out = new(AppMeshVirtualService) + (*in).DeepCopyInto(*out) + } + if in.VirtualNodeGroup != nil { + in, out := &in.VirtualNodeGroup, &out.VirtualNodeGroup + *out = new(AppMeshVirtualNodeGroup) + (*in).DeepCopyInto(*out) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AppMeshTrafficRouting. +func (in *AppMeshTrafficRouting) DeepCopy() *AppMeshTrafficRouting { + if in == nil { + return nil + } + out := new(AppMeshTrafficRouting) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *AppMeshVirtualNodeGroup) DeepCopyInto(out *AppMeshVirtualNodeGroup) { + *out = *in + if in.CanaryVirtualNodeRef != nil { + in, out := &in.CanaryVirtualNodeRef, &out.CanaryVirtualNodeRef + *out = new(AppMeshVirtualNodeReference) + **out = **in + } + if in.StableVirtualNodeRef != nil { + in, out := &in.StableVirtualNodeRef, &out.StableVirtualNodeRef + *out = new(AppMeshVirtualNodeReference) + **out = **in + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AppMeshVirtualNodeGroup. +func (in *AppMeshVirtualNodeGroup) DeepCopy() *AppMeshVirtualNodeGroup { + if in == nil { + return nil + } + out := new(AppMeshVirtualNodeGroup) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *AppMeshVirtualNodeReference) DeepCopyInto(out *AppMeshVirtualNodeReference) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AppMeshVirtualNodeReference. +func (in *AppMeshVirtualNodeReference) DeepCopy() *AppMeshVirtualNodeReference { + if in == nil { + return nil + } + out := new(AppMeshVirtualNodeReference) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *AppMeshVirtualService) DeepCopyInto(out *AppMeshVirtualService) { + *out = *in + if in.Routes != nil { + in, out := &in.Routes, &out.Routes + *out = make([]string, len(*in)) + copy(*out, *in) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AppMeshVirtualService. +func (in *AppMeshVirtualService) DeepCopy() *AppMeshVirtualService { + if in == nil { + return nil + } + out := new(AppMeshVirtualService) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *Argument) DeepCopyInto(out *Argument) { + *out = *in + if in.Value != nil { + in, out := &in.Value, &out.Value + *out = new(string) + **out = **in + } + if in.ValueFrom != nil { + in, out := &in.ValueFrom, &out.ValueFrom + *out = new(ValueFrom) + (*in).DeepCopyInto(*out) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Argument. +func (in *Argument) DeepCopy() *Argument { + if in == nil { + return nil + } + out := new(Argument) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ArgumentValueFrom) DeepCopyInto(out *ArgumentValueFrom) { + *out = *in + if in.PodTemplateHashValue != nil { + in, out := &in.PodTemplateHashValue, &out.PodTemplateHashValue + *out = new(ValueFromPodTemplateHash) + **out = **in + } + if in.FieldRef != nil { + in, out := &in.FieldRef, &out.FieldRef + *out = new(FieldRef) + **out = **in + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ArgumentValueFrom. +func (in *ArgumentValueFrom) DeepCopy() *ArgumentValueFrom { + if in == nil { + return nil + } + out := new(ArgumentValueFrom) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *AwsResourceRef) DeepCopyInto(out *AwsResourceRef) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AwsResourceRef. +func (in *AwsResourceRef) DeepCopy() *AwsResourceRef { + if in == nil { + return nil + } + out := new(AwsResourceRef) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *BlueGreenStatus) DeepCopyInto(out *BlueGreenStatus) { + *out = *in + if in.PrePromotionAnalysisRunStatus != nil { + in, out := &in.PrePromotionAnalysisRunStatus, &out.PrePromotionAnalysisRunStatus + *out = new(RolloutAnalysisRunStatus) + **out = **in + } + if in.PostPromotionAnalysisRunStatus != nil { + in, out := &in.PostPromotionAnalysisRunStatus, &out.PostPromotionAnalysisRunStatus + *out = new(RolloutAnalysisRunStatus) + **out = **in + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new BlueGreenStatus. +func (in *BlueGreenStatus) DeepCopy() *BlueGreenStatus { + if in == nil { + return nil + } + out := new(BlueGreenStatus) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *BlueGreenStrategy) DeepCopyInto(out *BlueGreenStrategy) { + *out = *in + if in.PreviewReplicaCount != nil { + in, out := &in.PreviewReplicaCount, &out.PreviewReplicaCount + *out = new(int32) + **out = **in + } + if in.AutoPromotionEnabled != nil { + in, out := &in.AutoPromotionEnabled, &out.AutoPromotionEnabled + *out = new(bool) + **out = **in + } + if in.MaxUnavailable != nil { + in, out := &in.MaxUnavailable, &out.MaxUnavailable + *out = new(intstr.IntOrString) + **out = **in + } + if in.ScaleDownDelaySeconds != nil { + in, out := &in.ScaleDownDelaySeconds, &out.ScaleDownDelaySeconds + *out = new(int32) + **out = **in + } + if in.ScaleDownDelayRevisionLimit != nil { + in, out := &in.ScaleDownDelayRevisionLimit, &out.ScaleDownDelayRevisionLimit + *out = new(int32) + **out = **in + } + if in.PrePromotionAnalysis != nil { + in, out := &in.PrePromotionAnalysis, &out.PrePromotionAnalysis + *out = new(RolloutAnalysis) + (*in).DeepCopyInto(*out) + } + if in.AntiAffinity != nil { + in, out := &in.AntiAffinity, &out.AntiAffinity + *out = new(AntiAffinity) + (*in).DeepCopyInto(*out) + } + if in.PostPromotionAnalysis != nil { + in, out := &in.PostPromotionAnalysis, &out.PostPromotionAnalysis + *out = new(RolloutAnalysis) + (*in).DeepCopyInto(*out) + } + if in.PreviewMetadata != nil { + in, out := &in.PreviewMetadata, &out.PreviewMetadata + *out = new(PodTemplateMetadata) + (*in).DeepCopyInto(*out) + } + if in.ActiveMetadata != nil { + in, out := &in.ActiveMetadata, &out.ActiveMetadata + *out = new(PodTemplateMetadata) + (*in).DeepCopyInto(*out) + } + if in.AbortScaleDownDelaySeconds != nil { + in, out := &in.AbortScaleDownDelaySeconds, &out.AbortScaleDownDelaySeconds + *out = new(int32) + **out = **in + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new BlueGreenStrategy. +func (in *BlueGreenStrategy) DeepCopy() *BlueGreenStrategy { + if in == nil { + return nil + } + out := new(BlueGreenStrategy) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *CanaryStatus) DeepCopyInto(out *CanaryStatus) { + *out = *in + if in.CurrentStepAnalysisRunStatus != nil { + in, out := &in.CurrentStepAnalysisRunStatus, &out.CurrentStepAnalysisRunStatus + *out = new(RolloutAnalysisRunStatus) + **out = **in + } + if in.CurrentBackgroundAnalysisRunStatus != nil { + in, out := &in.CurrentBackgroundAnalysisRunStatus, &out.CurrentBackgroundAnalysisRunStatus + *out = new(RolloutAnalysisRunStatus) + **out = **in + } + if in.Weights != nil { + in, out := &in.Weights, &out.Weights + *out = new(TrafficWeights) + (*in).DeepCopyInto(*out) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CanaryStatus. +func (in *CanaryStatus) DeepCopy() *CanaryStatus { + if in == nil { + return nil + } + out := new(CanaryStatus) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *CanaryStep) DeepCopyInto(out *CanaryStep) { + *out = *in + if in.SetWeight != nil { + in, out := &in.SetWeight, &out.SetWeight + *out = new(int32) + **out = **in + } + if in.Pause != nil { + in, out := &in.Pause, &out.Pause + *out = new(RolloutPause) + (*in).DeepCopyInto(*out) + } + if in.Experiment != nil { + in, out := &in.Experiment, &out.Experiment + *out = new(RolloutExperimentStep) + (*in).DeepCopyInto(*out) + } + if in.Analysis != nil { + in, out := &in.Analysis, &out.Analysis + *out = new(RolloutAnalysis) + (*in).DeepCopyInto(*out) + } + if in.SetCanaryScale != nil { + in, out := &in.SetCanaryScale, &out.SetCanaryScale + *out = new(SetCanaryScale) + (*in).DeepCopyInto(*out) + } + if in.SetHeaderRoute != nil { + in, out := &in.SetHeaderRoute, &out.SetHeaderRoute + *out = new(SetHeaderRoute) + (*in).DeepCopyInto(*out) + } + if in.SetMirrorRoute != nil { + in, out := &in.SetMirrorRoute, &out.SetMirrorRoute + *out = new(SetMirrorRoute) + (*in).DeepCopyInto(*out) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CanaryStep. +func (in *CanaryStep) DeepCopy() *CanaryStep { + if in == nil { + return nil + } + out := new(CanaryStep) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *CanaryStrategy) DeepCopyInto(out *CanaryStrategy) { + *out = *in + if in.Steps != nil { + in, out := &in.Steps, &out.Steps + *out = make([]CanaryStep, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + if in.TrafficRouting != nil { + in, out := &in.TrafficRouting, &out.TrafficRouting + *out = new(RolloutTrafficRouting) + (*in).DeepCopyInto(*out) + } + if in.MaxUnavailable != nil { + in, out := &in.MaxUnavailable, &out.MaxUnavailable + *out = new(intstr.IntOrString) + **out = **in + } + if in.MaxSurge != nil { + in, out := &in.MaxSurge, &out.MaxSurge + *out = new(intstr.IntOrString) + **out = **in + } + if in.Analysis != nil { + in, out := &in.Analysis, &out.Analysis + *out = new(RolloutAnalysisBackground) + (*in).DeepCopyInto(*out) + } + if in.AntiAffinity != nil { + in, out := &in.AntiAffinity, &out.AntiAffinity + *out = new(AntiAffinity) + (*in).DeepCopyInto(*out) + } + if in.CanaryMetadata != nil { + in, out := &in.CanaryMetadata, &out.CanaryMetadata + *out = new(PodTemplateMetadata) + (*in).DeepCopyInto(*out) + } + if in.StableMetadata != nil { + in, out := &in.StableMetadata, &out.StableMetadata + *out = new(PodTemplateMetadata) + (*in).DeepCopyInto(*out) + } + if in.ScaleDownDelaySeconds != nil { + in, out := &in.ScaleDownDelaySeconds, &out.ScaleDownDelaySeconds + *out = new(int32) + **out = **in + } + if in.ScaleDownDelayRevisionLimit != nil { + in, out := &in.ScaleDownDelayRevisionLimit, &out.ScaleDownDelayRevisionLimit + *out = new(int32) + **out = **in + } + if in.AbortScaleDownDelaySeconds != nil { + in, out := &in.AbortScaleDownDelaySeconds, &out.AbortScaleDownDelaySeconds + *out = new(int32) + **out = **in + } + if in.PingPong != nil { + in, out := &in.PingPong, &out.PingPong + *out = new(PingPongSpec) + **out = **in + } + if in.MinPodsPerReplicaSet != nil { + in, out := &in.MinPodsPerReplicaSet, &out.MinPodsPerReplicaSet + *out = new(int32) + **out = **in + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CanaryStrategy. +func (in *CanaryStrategy) DeepCopy() *CanaryStrategy { + if in == nil { + return nil + } + out := new(CanaryStrategy) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *CloudWatchMetric) DeepCopyInto(out *CloudWatchMetric) { + *out = *in + if in.MetricDataQueries != nil { + in, out := &in.MetricDataQueries, &out.MetricDataQueries + *out = make([]CloudWatchMetricDataQuery, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CloudWatchMetric. +func (in *CloudWatchMetric) DeepCopy() *CloudWatchMetric { + if in == nil { + return nil + } + out := new(CloudWatchMetric) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *CloudWatchMetricDataQuery) DeepCopyInto(out *CloudWatchMetricDataQuery) { + *out = *in + if in.Expression != nil { + in, out := &in.Expression, &out.Expression + *out = new(string) + **out = **in + } + if in.Label != nil { + in, out := &in.Label, &out.Label + *out = new(string) + **out = **in + } + if in.MetricStat != nil { + in, out := &in.MetricStat, &out.MetricStat + *out = new(CloudWatchMetricStat) + (*in).DeepCopyInto(*out) + } + if in.Period != nil { + in, out := &in.Period, &out.Period + *out = new(intstr.IntOrString) + **out = **in + } + if in.ReturnData != nil { + in, out := &in.ReturnData, &out.ReturnData + *out = new(bool) + **out = **in + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CloudWatchMetricDataQuery. +func (in *CloudWatchMetricDataQuery) DeepCopy() *CloudWatchMetricDataQuery { + if in == nil { + return nil + } + out := new(CloudWatchMetricDataQuery) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *CloudWatchMetricStat) DeepCopyInto(out *CloudWatchMetricStat) { + *out = *in + in.Metric.DeepCopyInto(&out.Metric) + out.Period = in.Period + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CloudWatchMetricStat. +func (in *CloudWatchMetricStat) DeepCopy() *CloudWatchMetricStat { + if in == nil { + return nil + } + out := new(CloudWatchMetricStat) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *CloudWatchMetricStatMetric) DeepCopyInto(out *CloudWatchMetricStatMetric) { + *out = *in + if in.Dimensions != nil { + in, out := &in.Dimensions, &out.Dimensions + *out = make([]CloudWatchMetricStatMetricDimension, len(*in)) + copy(*out, *in) + } + if in.Namespace != nil { + in, out := &in.Namespace, &out.Namespace + *out = new(string) + **out = **in + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CloudWatchMetricStatMetric. +func (in *CloudWatchMetricStatMetric) DeepCopy() *CloudWatchMetricStatMetric { + if in == nil { + return nil + } + out := new(CloudWatchMetricStatMetric) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *CloudWatchMetricStatMetricDimension) DeepCopyInto(out *CloudWatchMetricStatMetricDimension) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CloudWatchMetricStatMetricDimension. +func (in *CloudWatchMetricStatMetricDimension) DeepCopy() *CloudWatchMetricStatMetricDimension { + if in == nil { + return nil + } + out := new(CloudWatchMetricStatMetricDimension) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ClusterAnalysisTemplate) DeepCopyInto(out *ClusterAnalysisTemplate) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + in.Spec.DeepCopyInto(&out.Spec) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterAnalysisTemplate. +func (in *ClusterAnalysisTemplate) DeepCopy() *ClusterAnalysisTemplate { + if in == nil { + return nil + } + out := new(ClusterAnalysisTemplate) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *ClusterAnalysisTemplate) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ClusterAnalysisTemplateList) DeepCopyInto(out *ClusterAnalysisTemplateList) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ListMeta.DeepCopyInto(&out.ListMeta) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]ClusterAnalysisTemplate, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterAnalysisTemplateList. +func (in *ClusterAnalysisTemplateList) DeepCopy() *ClusterAnalysisTemplateList { + if in == nil { + return nil + } + out := new(ClusterAnalysisTemplateList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *ClusterAnalysisTemplateList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *DatadogMetric) DeepCopyInto(out *DatadogMetric) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DatadogMetric. +func (in *DatadogMetric) DeepCopy() *DatadogMetric { + if in == nil { + return nil + } + out := new(DatadogMetric) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *DryRun) DeepCopyInto(out *DryRun) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DryRun. +func (in *DryRun) DeepCopy() *DryRun { + if in == nil { + return nil + } + out := new(DryRun) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *Experiment) DeepCopyInto(out *Experiment) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + in.Spec.DeepCopyInto(&out.Spec) + in.Status.DeepCopyInto(&out.Status) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Experiment. +func (in *Experiment) DeepCopy() *Experiment { + if in == nil { + return nil + } + out := new(Experiment) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *Experiment) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ExperimentAnalysisRunStatus) DeepCopyInto(out *ExperimentAnalysisRunStatus) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ExperimentAnalysisRunStatus. +func (in *ExperimentAnalysisRunStatus) DeepCopy() *ExperimentAnalysisRunStatus { + if in == nil { + return nil + } + out := new(ExperimentAnalysisRunStatus) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ExperimentAnalysisTemplateRef) DeepCopyInto(out *ExperimentAnalysisTemplateRef) { + *out = *in + if in.Args != nil { + in, out := &in.Args, &out.Args + *out = make([]Argument, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ExperimentAnalysisTemplateRef. +func (in *ExperimentAnalysisTemplateRef) DeepCopy() *ExperimentAnalysisTemplateRef { + if in == nil { + return nil + } + out := new(ExperimentAnalysisTemplateRef) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ExperimentCondition) DeepCopyInto(out *ExperimentCondition) { + *out = *in + in.LastUpdateTime.DeepCopyInto(&out.LastUpdateTime) + in.LastTransitionTime.DeepCopyInto(&out.LastTransitionTime) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ExperimentCondition. +func (in *ExperimentCondition) DeepCopy() *ExperimentCondition { + if in == nil { + return nil + } + out := new(ExperimentCondition) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ExperimentList) DeepCopyInto(out *ExperimentList) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ListMeta.DeepCopyInto(&out.ListMeta) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]Experiment, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ExperimentList. +func (in *ExperimentList) DeepCopy() *ExperimentList { + if in == nil { + return nil + } + out := new(ExperimentList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *ExperimentList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ExperimentSpec) DeepCopyInto(out *ExperimentSpec) { + *out = *in + if in.Templates != nil { + in, out := &in.Templates, &out.Templates + *out = make([]TemplateSpec, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + if in.ProgressDeadlineSeconds != nil { + in, out := &in.ProgressDeadlineSeconds, &out.ProgressDeadlineSeconds + *out = new(int32) + **out = **in + } + if in.Analyses != nil { + in, out := &in.Analyses, &out.Analyses + *out = make([]ExperimentAnalysisTemplateRef, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + if in.ScaleDownDelaySeconds != nil { + in, out := &in.ScaleDownDelaySeconds, &out.ScaleDownDelaySeconds + *out = new(int32) + **out = **in + } + if in.DryRun != nil { + in, out := &in.DryRun, &out.DryRun + *out = make([]DryRun, len(*in)) + copy(*out, *in) + } + if in.MeasurementRetention != nil { + in, out := &in.MeasurementRetention, &out.MeasurementRetention + *out = make([]MeasurementRetention, len(*in)) + copy(*out, *in) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ExperimentSpec. +func (in *ExperimentSpec) DeepCopy() *ExperimentSpec { + if in == nil { + return nil + } + out := new(ExperimentSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ExperimentStatus) DeepCopyInto(out *ExperimentStatus) { + *out = *in + if in.TemplateStatuses != nil { + in, out := &in.TemplateStatuses, &out.TemplateStatuses + *out = make([]TemplateStatus, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + if in.AvailableAt != nil { + in, out := &in.AvailableAt, &out.AvailableAt + *out = (*in).DeepCopy() + } + if in.Conditions != nil { + in, out := &in.Conditions, &out.Conditions + *out = make([]ExperimentCondition, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + if in.AnalysisRuns != nil { + in, out := &in.AnalysisRuns, &out.AnalysisRuns + *out = make([]ExperimentAnalysisRunStatus, len(*in)) + copy(*out, *in) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ExperimentStatus. +func (in *ExperimentStatus) DeepCopy() *ExperimentStatus { + if in == nil { + return nil + } + out := new(ExperimentStatus) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *FieldRef) DeepCopyInto(out *FieldRef) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new FieldRef. +func (in *FieldRef) DeepCopy() *FieldRef { + if in == nil { + return nil + } + out := new(FieldRef) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *GraphiteMetric) DeepCopyInto(out *GraphiteMetric) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GraphiteMetric. +func (in *GraphiteMetric) DeepCopy() *GraphiteMetric { + if in == nil { + return nil + } + out := new(GraphiteMetric) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *HeaderRoutingMatch) DeepCopyInto(out *HeaderRoutingMatch) { + *out = *in + if in.HeaderValue != nil { + in, out := &in.HeaderValue, &out.HeaderValue + *out = new(StringMatch) + **out = **in + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HeaderRoutingMatch. +func (in *HeaderRoutingMatch) DeepCopy() *HeaderRoutingMatch { + if in == nil { + return nil + } + out := new(HeaderRoutingMatch) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *InfluxdbMetric) DeepCopyInto(out *InfluxdbMetric) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new InfluxdbMetric. +func (in *InfluxdbMetric) DeepCopy() *InfluxdbMetric { + if in == nil { + return nil + } + out := new(InfluxdbMetric) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *IstioDestinationRule) DeepCopyInto(out *IstioDestinationRule) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new IstioDestinationRule. +func (in *IstioDestinationRule) DeepCopy() *IstioDestinationRule { + if in == nil { + return nil + } + out := new(IstioDestinationRule) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *IstioTrafficRouting) DeepCopyInto(out *IstioTrafficRouting) { + *out = *in + if in.VirtualService != nil { + in, out := &in.VirtualService, &out.VirtualService + *out = new(IstioVirtualService) + (*in).DeepCopyInto(*out) + } + if in.DestinationRule != nil { + in, out := &in.DestinationRule, &out.DestinationRule + *out = new(IstioDestinationRule) + **out = **in + } + if in.VirtualServices != nil { + in, out := &in.VirtualServices, &out.VirtualServices + *out = make([]IstioVirtualService, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new IstioTrafficRouting. +func (in *IstioTrafficRouting) DeepCopy() *IstioTrafficRouting { + if in == nil { + return nil + } + out := new(IstioTrafficRouting) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *IstioVirtualService) DeepCopyInto(out *IstioVirtualService) { + *out = *in + if in.Routes != nil { + in, out := &in.Routes, &out.Routes + *out = make([]string, len(*in)) + copy(*out, *in) + } + if in.TLSRoutes != nil { + in, out := &in.TLSRoutes, &out.TLSRoutes + *out = make([]TLSRoute, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + if in.TCPRoutes != nil { + in, out := &in.TCPRoutes, &out.TCPRoutes + *out = make([]TCPRoute, len(*in)) + copy(*out, *in) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new IstioVirtualService. +func (in *IstioVirtualService) DeepCopy() *IstioVirtualService { + if in == nil { + return nil + } + out := new(IstioVirtualService) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *JobMetric) DeepCopyInto(out *JobMetric) { + *out = *in + in.Metadata.DeepCopyInto(&out.Metadata) + in.Spec.DeepCopyInto(&out.Spec) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JobMetric. +func (in *JobMetric) DeepCopy() *JobMetric { + if in == nil { + return nil + } + out := new(JobMetric) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *KayentaMetric) DeepCopyInto(out *KayentaMetric) { + *out = *in + out.Threshold = in.Threshold + if in.Scopes != nil { + in, out := &in.Scopes, &out.Scopes + *out = make([]KayentaScope, len(*in)) + copy(*out, *in) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new KayentaMetric. +func (in *KayentaMetric) DeepCopy() *KayentaMetric { + if in == nil { + return nil + } + out := new(KayentaMetric) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *KayentaScope) DeepCopyInto(out *KayentaScope) { + *out = *in + out.ControlScope = in.ControlScope + out.ExperimentScope = in.ExperimentScope + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new KayentaScope. +func (in *KayentaScope) DeepCopy() *KayentaScope { + if in == nil { + return nil + } + out := new(KayentaScope) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *KayentaThreshold) DeepCopyInto(out *KayentaThreshold) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new KayentaThreshold. +func (in *KayentaThreshold) DeepCopy() *KayentaThreshold { + if in == nil { + return nil + } + out := new(KayentaThreshold) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *MangedRoutes) DeepCopyInto(out *MangedRoutes) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MangedRoutes. +func (in *MangedRoutes) DeepCopy() *MangedRoutes { + if in == nil { + return nil + } + out := new(MangedRoutes) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *Measurement) DeepCopyInto(out *Measurement) { + *out = *in + if in.StartedAt != nil { + in, out := &in.StartedAt, &out.StartedAt + *out = (*in).DeepCopy() + } + if in.FinishedAt != nil { + in, out := &in.FinishedAt, &out.FinishedAt + *out = (*in).DeepCopy() + } + if in.Metadata != nil { + in, out := &in.Metadata, &out.Metadata + *out = make(map[string]string, len(*in)) + for key, val := range *in { + (*out)[key] = val + } + } + if in.ResumeAt != nil { + in, out := &in.ResumeAt, &out.ResumeAt + *out = (*in).DeepCopy() + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Measurement. +func (in *Measurement) DeepCopy() *Measurement { + if in == nil { + return nil + } + out := new(Measurement) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *MeasurementRetention) DeepCopyInto(out *MeasurementRetention) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MeasurementRetention. +func (in *MeasurementRetention) DeepCopy() *MeasurementRetention { + if in == nil { + return nil + } + out := new(MeasurementRetention) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *Metric) DeepCopyInto(out *Metric) { + *out = *in + if in.Count != nil { + in, out := &in.Count, &out.Count + *out = new(intstr.IntOrString) + **out = **in + } + if in.FailureLimit != nil { + in, out := &in.FailureLimit, &out.FailureLimit + *out = new(intstr.IntOrString) + **out = **in + } + if in.InconclusiveLimit != nil { + in, out := &in.InconclusiveLimit, &out.InconclusiveLimit + *out = new(intstr.IntOrString) + **out = **in + } + if in.ConsecutiveErrorLimit != nil { + in, out := &in.ConsecutiveErrorLimit, &out.ConsecutiveErrorLimit + *out = new(intstr.IntOrString) + **out = **in + } + in.Provider.DeepCopyInto(&out.Provider) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Metric. +func (in *Metric) DeepCopy() *Metric { + if in == nil { + return nil + } + out := new(Metric) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *MetricProvider) DeepCopyInto(out *MetricProvider) { + *out = *in + if in.Prometheus != nil { + in, out := &in.Prometheus, &out.Prometheus + *out = new(PrometheusMetric) + (*in).DeepCopyInto(*out) + } + if in.Kayenta != nil { + in, out := &in.Kayenta, &out.Kayenta + *out = new(KayentaMetric) + (*in).DeepCopyInto(*out) + } + if in.Web != nil { + in, out := &in.Web, &out.Web + *out = new(WebMetric) + (*in).DeepCopyInto(*out) + } + if in.Datadog != nil { + in, out := &in.Datadog, &out.Datadog + *out = new(DatadogMetric) + **out = **in + } + if in.Wavefront != nil { + in, out := &in.Wavefront, &out.Wavefront + *out = new(WavefrontMetric) + **out = **in + } + if in.NewRelic != nil { + in, out := &in.NewRelic, &out.NewRelic + *out = new(NewRelicMetric) + **out = **in + } + if in.Job != nil { + in, out := &in.Job, &out.Job + *out = new(JobMetric) + (*in).DeepCopyInto(*out) + } + if in.CloudWatch != nil { + in, out := &in.CloudWatch, &out.CloudWatch + *out = new(CloudWatchMetric) + (*in).DeepCopyInto(*out) + } + if in.Graphite != nil { + in, out := &in.Graphite, &out.Graphite + *out = new(GraphiteMetric) + **out = **in + } + if in.Influxdb != nil { + in, out := &in.Influxdb, &out.Influxdb + *out = new(InfluxdbMetric) + **out = **in + } + if in.SkyWalking != nil { + in, out := &in.SkyWalking, &out.SkyWalking + *out = new(SkyWalkingMetric) + **out = **in + } + if in.Plugin != nil { + in, out := &in.Plugin, &out.Plugin + *out = make(map[string]json.RawMessage, len(*in)) + for key, val := range *in { + var outVal []byte + if val == nil { + (*out)[key] = nil + } else { + in, out := &val, &outVal + *out = make(json.RawMessage, len(*in)) + copy(*out, *in) + } + (*out)[key] = outVal + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MetricProvider. +func (in *MetricProvider) DeepCopy() *MetricProvider { + if in == nil { + return nil + } + out := new(MetricProvider) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *MetricResult) DeepCopyInto(out *MetricResult) { + *out = *in + if in.Measurements != nil { + in, out := &in.Measurements, &out.Measurements + *out = make([]Measurement, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + if in.Metadata != nil { + in, out := &in.Metadata, &out.Metadata + *out = make(map[string]string, len(*in)) + for key, val := range *in { + (*out)[key] = val + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MetricResult. +func (in *MetricResult) DeepCopy() *MetricResult { + if in == nil { + return nil + } + out := new(MetricResult) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *NewRelicMetric) DeepCopyInto(out *NewRelicMetric) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NewRelicMetric. +func (in *NewRelicMetric) DeepCopy() *NewRelicMetric { + if in == nil { + return nil + } + out := new(NewRelicMetric) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *NginxTrafficRouting) DeepCopyInto(out *NginxTrafficRouting) { + *out = *in + if in.AdditionalIngressAnnotations != nil { + in, out := &in.AdditionalIngressAnnotations, &out.AdditionalIngressAnnotations + *out = make(map[string]string, len(*in)) + for key, val := range *in { + (*out)[key] = val + } + } + if in.StableIngresses != nil { + in, out := &in.StableIngresses, &out.StableIngresses + *out = make([]string, len(*in)) + copy(*out, *in) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NginxTrafficRouting. +func (in *NginxTrafficRouting) DeepCopy() *NginxTrafficRouting { + if in == nil { + return nil + } + out := new(NginxTrafficRouting) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ObjectRef) DeepCopyInto(out *ObjectRef) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ObjectRef. +func (in *ObjectRef) DeepCopy() *ObjectRef { + if in == nil { + return nil + } + out := new(ObjectRef) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *PauseCondition) DeepCopyInto(out *PauseCondition) { + *out = *in + in.StartTime.DeepCopyInto(&out.StartTime) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PauseCondition. +func (in *PauseCondition) DeepCopy() *PauseCondition { + if in == nil { + return nil + } + out := new(PauseCondition) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *PingPongSpec) DeepCopyInto(out *PingPongSpec) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PingPongSpec. +func (in *PingPongSpec) DeepCopy() *PingPongSpec { + if in == nil { + return nil + } + out := new(PingPongSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *PodTemplateMetadata) DeepCopyInto(out *PodTemplateMetadata) { + *out = *in + if in.Labels != nil { + in, out := &in.Labels, &out.Labels + *out = make(map[string]string, len(*in)) + for key, val := range *in { + (*out)[key] = val + } + } + if in.Annotations != nil { + in, out := &in.Annotations, &out.Annotations + *out = make(map[string]string, len(*in)) + for key, val := range *in { + (*out)[key] = val + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodTemplateMetadata. +func (in *PodTemplateMetadata) DeepCopy() *PodTemplateMetadata { + if in == nil { + return nil + } + out := new(PodTemplateMetadata) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *PreferredDuringSchedulingIgnoredDuringExecution) DeepCopyInto(out *PreferredDuringSchedulingIgnoredDuringExecution) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PreferredDuringSchedulingIgnoredDuringExecution. +func (in *PreferredDuringSchedulingIgnoredDuringExecution) DeepCopy() *PreferredDuringSchedulingIgnoredDuringExecution { + if in == nil { + return nil + } + out := new(PreferredDuringSchedulingIgnoredDuringExecution) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *PrometheusAuth) DeepCopyInto(out *PrometheusAuth) { + *out = *in + out.Sigv4 = in.Sigv4 + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PrometheusAuth. +func (in *PrometheusAuth) DeepCopy() *PrometheusAuth { + if in == nil { + return nil + } + out := new(PrometheusAuth) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *PrometheusMetric) DeepCopyInto(out *PrometheusMetric) { + *out = *in + out.Authentication = in.Authentication + if in.Timeout != nil { + in, out := &in.Timeout, &out.Timeout + *out = new(int64) + **out = **in + } + if in.Headers != nil { + in, out := &in.Headers, &out.Headers + *out = make([]WebMetricHeader, len(*in)) + copy(*out, *in) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PrometheusMetric. +func (in *PrometheusMetric) DeepCopy() *PrometheusMetric { + if in == nil { + return nil + } + out := new(PrometheusMetric) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *RequiredDuringSchedulingIgnoredDuringExecution) DeepCopyInto(out *RequiredDuringSchedulingIgnoredDuringExecution) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RequiredDuringSchedulingIgnoredDuringExecution. +func (in *RequiredDuringSchedulingIgnoredDuringExecution) DeepCopy() *RequiredDuringSchedulingIgnoredDuringExecution { + if in == nil { + return nil + } + out := new(RequiredDuringSchedulingIgnoredDuringExecution) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *RollbackWindowSpec) DeepCopyInto(out *RollbackWindowSpec) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RollbackWindowSpec. +func (in *RollbackWindowSpec) DeepCopy() *RollbackWindowSpec { + if in == nil { + return nil + } + out := new(RollbackWindowSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *Rollout) DeepCopyInto(out *Rollout) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + in.Spec.DeepCopyInto(&out.Spec) + in.Status.DeepCopyInto(&out.Status) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Rollout. +func (in *Rollout) DeepCopy() *Rollout { + if in == nil { + return nil + } + out := new(Rollout) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *Rollout) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *RolloutAnalysis) DeepCopyInto(out *RolloutAnalysis) { + *out = *in + if in.Templates != nil { + in, out := &in.Templates, &out.Templates + *out = make([]RolloutAnalysisTemplate, len(*in)) + copy(*out, *in) + } + if in.Args != nil { + in, out := &in.Args, &out.Args + *out = make([]AnalysisRunArgument, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + if in.DryRun != nil { + in, out := &in.DryRun, &out.DryRun + *out = make([]DryRun, len(*in)) + copy(*out, *in) + } + if in.MeasurementRetention != nil { + in, out := &in.MeasurementRetention, &out.MeasurementRetention + *out = make([]MeasurementRetention, len(*in)) + copy(*out, *in) + } + in.AnalysisRunMetadata.DeepCopyInto(&out.AnalysisRunMetadata) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RolloutAnalysis. +func (in *RolloutAnalysis) DeepCopy() *RolloutAnalysis { + if in == nil { + return nil + } + out := new(RolloutAnalysis) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *RolloutAnalysisBackground) DeepCopyInto(out *RolloutAnalysisBackground) { + *out = *in + in.RolloutAnalysis.DeepCopyInto(&out.RolloutAnalysis) + if in.StartingStep != nil { + in, out := &in.StartingStep, &out.StartingStep + *out = new(int32) + **out = **in + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RolloutAnalysisBackground. +func (in *RolloutAnalysisBackground) DeepCopy() *RolloutAnalysisBackground { + if in == nil { + return nil + } + out := new(RolloutAnalysisBackground) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *RolloutAnalysisRunStatus) DeepCopyInto(out *RolloutAnalysisRunStatus) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RolloutAnalysisRunStatus. +func (in *RolloutAnalysisRunStatus) DeepCopy() *RolloutAnalysisRunStatus { + if in == nil { + return nil + } + out := new(RolloutAnalysisRunStatus) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *RolloutAnalysisTemplate) DeepCopyInto(out *RolloutAnalysisTemplate) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RolloutAnalysisTemplate. +func (in *RolloutAnalysisTemplate) DeepCopy() *RolloutAnalysisTemplate { + if in == nil { + return nil + } + out := new(RolloutAnalysisTemplate) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *RolloutCondition) DeepCopyInto(out *RolloutCondition) { + *out = *in + in.LastUpdateTime.DeepCopyInto(&out.LastUpdateTime) + in.LastTransitionTime.DeepCopyInto(&out.LastTransitionTime) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RolloutCondition. +func (in *RolloutCondition) DeepCopy() *RolloutCondition { + if in == nil { + return nil + } + out := new(RolloutCondition) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *RolloutExperimentStep) DeepCopyInto(out *RolloutExperimentStep) { + *out = *in + if in.Templates != nil { + in, out := &in.Templates, &out.Templates + *out = make([]RolloutExperimentTemplate, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + if in.Analyses != nil { + in, out := &in.Analyses, &out.Analyses + *out = make([]RolloutExperimentStepAnalysisTemplateRef, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RolloutExperimentStep. +func (in *RolloutExperimentStep) DeepCopy() *RolloutExperimentStep { + if in == nil { + return nil + } + out := new(RolloutExperimentStep) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *RolloutExperimentStepAnalysisTemplateRef) DeepCopyInto(out *RolloutExperimentStepAnalysisTemplateRef) { + *out = *in + if in.Args != nil { + in, out := &in.Args, &out.Args + *out = make([]AnalysisRunArgument, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RolloutExperimentStepAnalysisTemplateRef. +func (in *RolloutExperimentStepAnalysisTemplateRef) DeepCopy() *RolloutExperimentStepAnalysisTemplateRef { + if in == nil { + return nil + } + out := new(RolloutExperimentStepAnalysisTemplateRef) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *RolloutExperimentTemplate) DeepCopyInto(out *RolloutExperimentTemplate) { + *out = *in + if in.Replicas != nil { + in, out := &in.Replicas, &out.Replicas + *out = new(int32) + **out = **in + } + in.Metadata.DeepCopyInto(&out.Metadata) + if in.Selector != nil { + in, out := &in.Selector, &out.Selector + *out = new(v1.LabelSelector) + (*in).DeepCopyInto(*out) + } + if in.Weight != nil { + in, out := &in.Weight, &out.Weight + *out = new(int32) + **out = **in + } + if in.Service != nil { + in, out := &in.Service, &out.Service + *out = new(TemplateService) + **out = **in + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RolloutExperimentTemplate. +func (in *RolloutExperimentTemplate) DeepCopy() *RolloutExperimentTemplate { + if in == nil { + return nil + } + out := new(RolloutExperimentTemplate) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *RolloutList) DeepCopyInto(out *RolloutList) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ListMeta.DeepCopyInto(&out.ListMeta) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]Rollout, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RolloutList. +func (in *RolloutList) DeepCopy() *RolloutList { + if in == nil { + return nil + } + out := new(RolloutList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *RolloutList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *RolloutPause) DeepCopyInto(out *RolloutPause) { + *out = *in + if in.Duration != nil { + in, out := &in.Duration, &out.Duration + *out = new(intstr.IntOrString) + **out = **in + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RolloutPause. +func (in *RolloutPause) DeepCopy() *RolloutPause { + if in == nil { + return nil + } + out := new(RolloutPause) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *RolloutSpec) DeepCopyInto(out *RolloutSpec) { + *out = *in + if in.Replicas != nil { + in, out := &in.Replicas, &out.Replicas + *out = new(int32) + **out = **in + } + if in.Selector != nil { + in, out := &in.Selector, &out.Selector + *out = new(v1.LabelSelector) + (*in).DeepCopyInto(*out) + } + in.Template.DeepCopyInto(&out.Template) + if in.WorkloadRef != nil { + in, out := &in.WorkloadRef, &out.WorkloadRef + *out = new(ObjectRef) + **out = **in + } + if in.RollbackWindow != nil { + in, out := &in.RollbackWindow, &out.RollbackWindow + *out = new(RollbackWindowSpec) + **out = **in + } + in.Strategy.DeepCopyInto(&out.Strategy) + if in.RevisionHistoryLimit != nil { + in, out := &in.RevisionHistoryLimit, &out.RevisionHistoryLimit + *out = new(int32) + **out = **in + } + if in.ProgressDeadlineSeconds != nil { + in, out := &in.ProgressDeadlineSeconds, &out.ProgressDeadlineSeconds + *out = new(int32) + **out = **in + } + if in.RestartAt != nil { + in, out := &in.RestartAt, &out.RestartAt + *out = (*in).DeepCopy() + } + if in.Analysis != nil { + in, out := &in.Analysis, &out.Analysis + *out = new(AnalysisRunStrategy) + (*in).DeepCopyInto(*out) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RolloutSpec. +func (in *RolloutSpec) DeepCopy() *RolloutSpec { + if in == nil { + return nil + } + out := new(RolloutSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *RolloutStatus) DeepCopyInto(out *RolloutStatus) { + *out = *in + if in.PauseConditions != nil { + in, out := &in.PauseConditions, &out.PauseConditions + *out = make([]PauseCondition, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + if in.AbortedAt != nil { + in, out := &in.AbortedAt, &out.AbortedAt + *out = (*in).DeepCopy() + } + if in.CurrentStepIndex != nil { + in, out := &in.CurrentStepIndex, &out.CurrentStepIndex + *out = new(int32) + **out = **in + } + if in.CollisionCount != nil { + in, out := &in.CollisionCount, &out.CollisionCount + *out = new(int32) + **out = **in + } + if in.Conditions != nil { + in, out := &in.Conditions, &out.Conditions + *out = make([]RolloutCondition, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + in.Canary.DeepCopyInto(&out.Canary) + in.BlueGreen.DeepCopyInto(&out.BlueGreen) + if in.RestartedAt != nil { + in, out := &in.RestartedAt, &out.RestartedAt + *out = (*in).DeepCopy() + } + if in.ALB != nil { + in, out := &in.ALB, &out.ALB + *out = new(ALBStatus) + **out = **in + } + if in.ALBs != nil { + in, out := &in.ALBs, &out.ALBs + *out = make([]ALBStatus, len(*in)) + copy(*out, *in) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RolloutStatus. +func (in *RolloutStatus) DeepCopy() *RolloutStatus { + if in == nil { + return nil + } + out := new(RolloutStatus) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *RolloutStrategy) DeepCopyInto(out *RolloutStrategy) { + *out = *in + if in.BlueGreen != nil { + in, out := &in.BlueGreen, &out.BlueGreen + *out = new(BlueGreenStrategy) + (*in).DeepCopyInto(*out) + } + if in.Canary != nil { + in, out := &in.Canary, &out.Canary + *out = new(CanaryStrategy) + (*in).DeepCopyInto(*out) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RolloutStrategy. +func (in *RolloutStrategy) DeepCopy() *RolloutStrategy { + if in == nil { + return nil + } + out := new(RolloutStrategy) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *RolloutTrafficRouting) DeepCopyInto(out *RolloutTrafficRouting) { + *out = *in + if in.Istio != nil { + in, out := &in.Istio, &out.Istio + *out = new(IstioTrafficRouting) + (*in).DeepCopyInto(*out) + } + if in.Nginx != nil { + in, out := &in.Nginx, &out.Nginx + *out = new(NginxTrafficRouting) + (*in).DeepCopyInto(*out) + } + if in.ALB != nil { + in, out := &in.ALB, &out.ALB + *out = new(ALBTrafficRouting) + (*in).DeepCopyInto(*out) + } + if in.SMI != nil { + in, out := &in.SMI, &out.SMI + *out = new(SMITrafficRouting) + **out = **in + } + if in.Ambassador != nil { + in, out := &in.Ambassador, &out.Ambassador + *out = new(AmbassadorTrafficRouting) + (*in).DeepCopyInto(*out) + } + if in.AppMesh != nil { + in, out := &in.AppMesh, &out.AppMesh + *out = new(AppMeshTrafficRouting) + (*in).DeepCopyInto(*out) + } + if in.Traefik != nil { + in, out := &in.Traefik, &out.Traefik + *out = new(TraefikTrafficRouting) + **out = **in + } + if in.ManagedRoutes != nil { + in, out := &in.ManagedRoutes, &out.ManagedRoutes + *out = make([]MangedRoutes, len(*in)) + copy(*out, *in) + } + if in.Apisix != nil { + in, out := &in.Apisix, &out.Apisix + *out = new(ApisixTrafficRouting) + (*in).DeepCopyInto(*out) + } + if in.Plugins != nil { + in, out := &in.Plugins, &out.Plugins + *out = make(map[string]json.RawMessage, len(*in)) + for key, val := range *in { + var outVal []byte + if val == nil { + (*out)[key] = nil + } else { + in, out := &val, &outVal + *out = make(json.RawMessage, len(*in)) + copy(*out, *in) + } + (*out)[key] = outVal + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RolloutTrafficRouting. +func (in *RolloutTrafficRouting) DeepCopy() *RolloutTrafficRouting { + if in == nil { + return nil + } + out := new(RolloutTrafficRouting) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *RouteMatch) DeepCopyInto(out *RouteMatch) { + *out = *in + if in.Method != nil { + in, out := &in.Method, &out.Method + *out = new(StringMatch) + **out = **in + } + if in.Path != nil { + in, out := &in.Path, &out.Path + *out = new(StringMatch) + **out = **in + } + if in.Headers != nil { + in, out := &in.Headers, &out.Headers + *out = make(map[string]StringMatch, len(*in)) + for key, val := range *in { + (*out)[key] = val + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RouteMatch. +func (in *RouteMatch) DeepCopy() *RouteMatch { + if in == nil { + return nil + } + out := new(RouteMatch) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *RunSummary) DeepCopyInto(out *RunSummary) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RunSummary. +func (in *RunSummary) DeepCopy() *RunSummary { + if in == nil { + return nil + } + out := new(RunSummary) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *SMITrafficRouting) DeepCopyInto(out *SMITrafficRouting) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SMITrafficRouting. +func (in *SMITrafficRouting) DeepCopy() *SMITrafficRouting { + if in == nil { + return nil + } + out := new(SMITrafficRouting) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ScopeDetail) DeepCopyInto(out *ScopeDetail) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ScopeDetail. +func (in *ScopeDetail) DeepCopy() *ScopeDetail { + if in == nil { + return nil + } + out := new(ScopeDetail) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *SecretKeyRef) DeepCopyInto(out *SecretKeyRef) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SecretKeyRef. +func (in *SecretKeyRef) DeepCopy() *SecretKeyRef { + if in == nil { + return nil + } + out := new(SecretKeyRef) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *SetCanaryScale) DeepCopyInto(out *SetCanaryScale) { + *out = *in + if in.Weight != nil { + in, out := &in.Weight, &out.Weight + *out = new(int32) + **out = **in + } + if in.Replicas != nil { + in, out := &in.Replicas, &out.Replicas + *out = new(int32) + **out = **in + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SetCanaryScale. +func (in *SetCanaryScale) DeepCopy() *SetCanaryScale { + if in == nil { + return nil + } + out := new(SetCanaryScale) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *SetHeaderRoute) DeepCopyInto(out *SetHeaderRoute) { + *out = *in + if in.Match != nil { + in, out := &in.Match, &out.Match + *out = make([]HeaderRoutingMatch, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SetHeaderRoute. +func (in *SetHeaderRoute) DeepCopy() *SetHeaderRoute { + if in == nil { + return nil + } + out := new(SetHeaderRoute) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *SetMirrorRoute) DeepCopyInto(out *SetMirrorRoute) { + *out = *in + if in.Match != nil { + in, out := &in.Match, &out.Match + *out = make([]RouteMatch, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + if in.Percentage != nil { + in, out := &in.Percentage, &out.Percentage + *out = new(int32) + **out = **in + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SetMirrorRoute. +func (in *SetMirrorRoute) DeepCopy() *SetMirrorRoute { + if in == nil { + return nil + } + out := new(SetMirrorRoute) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *Sigv4Config) DeepCopyInto(out *Sigv4Config) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Sigv4Config. +func (in *Sigv4Config) DeepCopy() *Sigv4Config { + if in == nil { + return nil + } + out := new(Sigv4Config) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *SkyWalkingMetric) DeepCopyInto(out *SkyWalkingMetric) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SkyWalkingMetric. +func (in *SkyWalkingMetric) DeepCopy() *SkyWalkingMetric { + if in == nil { + return nil + } + out := new(SkyWalkingMetric) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *StickinessConfig) DeepCopyInto(out *StickinessConfig) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new StickinessConfig. +func (in *StickinessConfig) DeepCopy() *StickinessConfig { + if in == nil { + return nil + } + out := new(StickinessConfig) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *StringMatch) DeepCopyInto(out *StringMatch) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new StringMatch. +func (in *StringMatch) DeepCopy() *StringMatch { + if in == nil { + return nil + } + out := new(StringMatch) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *TCPRoute) DeepCopyInto(out *TCPRoute) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TCPRoute. +func (in *TCPRoute) DeepCopy() *TCPRoute { + if in == nil { + return nil + } + out := new(TCPRoute) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *TLSRoute) DeepCopyInto(out *TLSRoute) { + *out = *in + if in.SNIHosts != nil { + in, out := &in.SNIHosts, &out.SNIHosts + *out = make([]string, len(*in)) + copy(*out, *in) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TLSRoute. +func (in *TLSRoute) DeepCopy() *TLSRoute { + if in == nil { + return nil + } + out := new(TLSRoute) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *TemplateService) DeepCopyInto(out *TemplateService) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TemplateService. +func (in *TemplateService) DeepCopy() *TemplateService { + if in == nil { + return nil + } + out := new(TemplateService) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *TemplateSpec) DeepCopyInto(out *TemplateSpec) { + *out = *in + if in.Replicas != nil { + in, out := &in.Replicas, &out.Replicas + *out = new(int32) + **out = **in + } + if in.Selector != nil { + in, out := &in.Selector, &out.Selector + *out = new(v1.LabelSelector) + (*in).DeepCopyInto(*out) + } + in.Template.DeepCopyInto(&out.Template) + if in.Service != nil { + in, out := &in.Service, &out.Service + *out = new(TemplateService) + **out = **in + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TemplateSpec. +func (in *TemplateSpec) DeepCopy() *TemplateSpec { + if in == nil { + return nil + } + out := new(TemplateSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *TemplateStatus) DeepCopyInto(out *TemplateStatus) { + *out = *in + if in.CollisionCount != nil { + in, out := &in.CollisionCount, &out.CollisionCount + *out = new(int32) + **out = **in + } + if in.LastTransitionTime != nil { + in, out := &in.LastTransitionTime, &out.LastTransitionTime + *out = (*in).DeepCopy() + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TemplateStatus. +func (in *TemplateStatus) DeepCopy() *TemplateStatus { + if in == nil { + return nil + } + out := new(TemplateStatus) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *TraefikTrafficRouting) DeepCopyInto(out *TraefikTrafficRouting) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TraefikTrafficRouting. +func (in *TraefikTrafficRouting) DeepCopy() *TraefikTrafficRouting { + if in == nil { + return nil + } + out := new(TraefikTrafficRouting) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *TrafficWeights) DeepCopyInto(out *TrafficWeights) { + *out = *in + out.Canary = in.Canary + out.Stable = in.Stable + if in.Additional != nil { + in, out := &in.Additional, &out.Additional + *out = make([]WeightDestination, len(*in)) + copy(*out, *in) + } + if in.Verified != nil { + in, out := &in.Verified, &out.Verified + *out = new(bool) + **out = **in + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TrafficWeights. +func (in *TrafficWeights) DeepCopy() *TrafficWeights { + if in == nil { + return nil + } + out := new(TrafficWeights) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ValueFrom) DeepCopyInto(out *ValueFrom) { + *out = *in + if in.SecretKeyRef != nil { + in, out := &in.SecretKeyRef, &out.SecretKeyRef + *out = new(SecretKeyRef) + **out = **in + } + if in.FieldRef != nil { + in, out := &in.FieldRef, &out.FieldRef + *out = new(FieldRef) + **out = **in + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ValueFrom. +func (in *ValueFrom) DeepCopy() *ValueFrom { + if in == nil { + return nil + } + out := new(ValueFrom) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *WavefrontMetric) DeepCopyInto(out *WavefrontMetric) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new WavefrontMetric. +func (in *WavefrontMetric) DeepCopy() *WavefrontMetric { + if in == nil { + return nil + } + out := new(WavefrontMetric) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *WebMetric) DeepCopyInto(out *WebMetric) { + *out = *in + if in.Headers != nil { + in, out := &in.Headers, &out.Headers + *out = make([]WebMetricHeader, len(*in)) + copy(*out, *in) + } + if in.JSONBody != nil { + in, out := &in.JSONBody, &out.JSONBody + *out = make(json.RawMessage, len(*in)) + copy(*out, *in) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new WebMetric. +func (in *WebMetric) DeepCopy() *WebMetric { + if in == nil { + return nil + } + out := new(WebMetric) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *WebMetricHeader) DeepCopyInto(out *WebMetricHeader) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new WebMetricHeader. +func (in *WebMetricHeader) DeepCopy() *WebMetricHeader { + if in == nil { + return nil + } + out := new(WebMetricHeader) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *WeightDestination) DeepCopyInto(out *WeightDestination) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new WeightDestination. +func (in *WeightDestination) DeepCopy() *WeightDestination { + if in == nil { + return nil + } + out := new(WeightDestination) + in.DeepCopyInto(out) + return out +} diff --git a/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/clientset.go b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/clientset.go new file mode 100644 index 000000000000..fef1aaafe442 --- /dev/null +++ b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/clientset.go @@ -0,0 +1,121 @@ +/* +Copyright The Kubernetes 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 client-gen. DO NOT EDIT. + +package versioned + +import ( + "fmt" + "net/http" + + argoprojv1alpha1 "github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/typed/rollouts/v1alpha1" + discovery "k8s.io/client-go/discovery" + rest "k8s.io/client-go/rest" + flowcontrol "k8s.io/client-go/util/flowcontrol" +) + +type Interface interface { + Discovery() discovery.DiscoveryInterface + ArgoprojV1alpha1() argoprojv1alpha1.ArgoprojV1alpha1Interface +} + +// Clientset contains the clients for groups. Each group has exactly one +// version included in a Clientset. +type Clientset struct { + *discovery.DiscoveryClient + argoprojV1alpha1 *argoprojv1alpha1.ArgoprojV1alpha1Client +} + +// ArgoprojV1alpha1 retrieves the ArgoprojV1alpha1Client +func (c *Clientset) ArgoprojV1alpha1() argoprojv1alpha1.ArgoprojV1alpha1Interface { + return c.argoprojV1alpha1 +} + +// Discovery retrieves the DiscoveryClient +func (c *Clientset) Discovery() discovery.DiscoveryInterface { + if c == nil { + return nil + } + return c.DiscoveryClient +} + +// NewForConfig creates a new Clientset for the given config. +// If config's RateLimiter is not set and QPS and Burst are acceptable, +// NewForConfig will generate a rate-limiter in configShallowCopy. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). +func NewForConfig(c *rest.Config) (*Clientset, error) { + configShallowCopy := *c + + if configShallowCopy.UserAgent == "" { + configShallowCopy.UserAgent = rest.DefaultKubernetesUserAgent() + } + + // share the transport between all clients + httpClient, err := rest.HTTPClientFor(&configShallowCopy) + if err != nil { + return nil, err + } + + return NewForConfigAndClient(&configShallowCopy, httpClient) +} + +// NewForConfigAndClient creates a new Clientset for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +// If config's RateLimiter is not set and QPS and Burst are acceptable, +// NewForConfigAndClient will generate a rate-limiter in configShallowCopy. +func NewForConfigAndClient(c *rest.Config, httpClient *http.Client) (*Clientset, error) { + configShallowCopy := *c + if configShallowCopy.RateLimiter == nil && configShallowCopy.QPS > 0 { + if configShallowCopy.Burst <= 0 { + return nil, fmt.Errorf("burst is required to be greater than 0 when RateLimiter is not set and QPS is set to greater than 0") + } + configShallowCopy.RateLimiter = flowcontrol.NewTokenBucketRateLimiter(configShallowCopy.QPS, configShallowCopy.Burst) + } + + var cs Clientset + var err error + cs.argoprojV1alpha1, err = argoprojv1alpha1.NewForConfigAndClient(&configShallowCopy, httpClient) + if err != nil { + return nil, err + } + + cs.DiscoveryClient, err = discovery.NewDiscoveryClientForConfigAndClient(&configShallowCopy, httpClient) + if err != nil { + return nil, err + } + return &cs, nil +} + +// NewForConfigOrDie creates a new Clientset for the given config and +// panics if there is an error in the config. +func NewForConfigOrDie(c *rest.Config) *Clientset { + cs, err := NewForConfig(c) + if err != nil { + panic(err) + } + return cs +} + +// New creates a new Clientset for the given RESTClient. +func New(c rest.Interface) *Clientset { + var cs Clientset + cs.argoprojV1alpha1 = argoprojv1alpha1.New(c) + + cs.DiscoveryClient = discovery.NewDiscoveryClient(c) + return &cs +} diff --git a/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/doc.go b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/doc.go new file mode 100644 index 000000000000..41721ca52d44 --- /dev/null +++ b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/doc.go @@ -0,0 +1,20 @@ +/* +Copyright The Kubernetes 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 client-gen. DO NOT EDIT. + +// This package has the automatically generated clientset. +package versioned diff --git a/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/scheme/doc.go b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/scheme/doc.go new file mode 100644 index 000000000000..7dc3756168fa --- /dev/null +++ b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/scheme/doc.go @@ -0,0 +1,20 @@ +/* +Copyright The Kubernetes 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 client-gen. DO NOT EDIT. + +// This package contains the scheme of the automatically generated clientset. +package scheme diff --git a/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/scheme/register.go b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/scheme/register.go new file mode 100644 index 000000000000..ddfe37336bd5 --- /dev/null +++ b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/scheme/register.go @@ -0,0 +1,56 @@ +/* +Copyright The Kubernetes 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 client-gen. DO NOT EDIT. + +package scheme + +import ( + argoprojv1alpha1 "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + runtime "k8s.io/apimachinery/pkg/runtime" + schema "k8s.io/apimachinery/pkg/runtime/schema" + serializer "k8s.io/apimachinery/pkg/runtime/serializer" + utilruntime "k8s.io/apimachinery/pkg/util/runtime" +) + +var Scheme = runtime.NewScheme() +var Codecs = serializer.NewCodecFactory(Scheme) +var ParameterCodec = runtime.NewParameterCodec(Scheme) +var localSchemeBuilder = runtime.SchemeBuilder{ + argoprojv1alpha1.AddToScheme, +} + +// AddToScheme adds all types of this clientset into the given scheme. This allows composition +// of clientsets, like in: +// +// import ( +// "k8s.io/client-go/kubernetes" +// clientsetscheme "k8s.io/client-go/kubernetes/scheme" +// aggregatorclientsetscheme "k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/scheme" +// ) +// +// kclientset, _ := kubernetes.NewForConfig(c) +// _ = aggregatorclientsetscheme.AddToScheme(clientsetscheme.Scheme) +// +// After this, RawExtensions in Kubernetes types will serialize kube-aggregator types +// correctly. +var AddToScheme = localSchemeBuilder.AddToScheme + +func init() { + v1.AddToGroupVersion(Scheme, schema.GroupVersion{Version: "v1"}) + utilruntime.Must(AddToScheme(Scheme)) +} diff --git a/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/typed/rollouts/v1alpha1/analysisrun.go b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/typed/rollouts/v1alpha1/analysisrun.go new file mode 100644 index 000000000000..d7cf6f0abee5 --- /dev/null +++ b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/typed/rollouts/v1alpha1/analysisrun.go @@ -0,0 +1,195 @@ +/* +Copyright The Kubernetes 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 client-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + "context" + "time" + + v1alpha1 "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1" + scheme "github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/scheme" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + rest "k8s.io/client-go/rest" +) + +// AnalysisRunsGetter has a method to return a AnalysisRunInterface. +// A group's client should implement this interface. +type AnalysisRunsGetter interface { + AnalysisRuns(namespace string) AnalysisRunInterface +} + +// AnalysisRunInterface has methods to work with AnalysisRun resources. +type AnalysisRunInterface interface { + Create(ctx context.Context, analysisRun *v1alpha1.AnalysisRun, opts v1.CreateOptions) (*v1alpha1.AnalysisRun, error) + Update(ctx context.Context, analysisRun *v1alpha1.AnalysisRun, opts v1.UpdateOptions) (*v1alpha1.AnalysisRun, error) + UpdateStatus(ctx context.Context, analysisRun *v1alpha1.AnalysisRun, opts v1.UpdateOptions) (*v1alpha1.AnalysisRun, error) + Delete(ctx context.Context, name string, opts v1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error + Get(ctx context.Context, name string, opts v1.GetOptions) (*v1alpha1.AnalysisRun, error) + List(ctx context.Context, opts v1.ListOptions) (*v1alpha1.AnalysisRunList, error) + Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha1.AnalysisRun, err error) + AnalysisRunExpansion +} + +// analysisRuns implements AnalysisRunInterface +type analysisRuns struct { + client rest.Interface + ns string +} + +// newAnalysisRuns returns a AnalysisRuns +func newAnalysisRuns(c *ArgoprojV1alpha1Client, namespace string) *analysisRuns { + return &analysisRuns{ + client: c.RESTClient(), + ns: namespace, + } +} + +// Get takes name of the analysisRun, and returns the corresponding analysisRun object, and an error if there is any. +func (c *analysisRuns) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1alpha1.AnalysisRun, err error) { + result = &v1alpha1.AnalysisRun{} + err = c.client.Get(). + Namespace(c.ns). + Resource("analysisruns"). + Name(name). + VersionedParams(&options, scheme.ParameterCodec). + Do(ctx). + Into(result) + return +} + +// List takes label and field selectors, and returns the list of AnalysisRuns that match those selectors. +func (c *analysisRuns) List(ctx context.Context, opts v1.ListOptions) (result *v1alpha1.AnalysisRunList, err error) { + var timeout time.Duration + if opts.TimeoutSeconds != nil { + timeout = time.Duration(*opts.TimeoutSeconds) * time.Second + } + result = &v1alpha1.AnalysisRunList{} + err = c.client.Get(). + Namespace(c.ns). + Resource("analysisruns"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Do(ctx). + Into(result) + return +} + +// Watch returns a watch.Interface that watches the requested analysisRuns. +func (c *analysisRuns) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + var timeout time.Duration + if opts.TimeoutSeconds != nil { + timeout = time.Duration(*opts.TimeoutSeconds) * time.Second + } + opts.Watch = true + return c.client.Get(). + Namespace(c.ns). + Resource("analysisruns"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Watch(ctx) +} + +// Create takes the representation of a analysisRun and creates it. Returns the server's representation of the analysisRun, and an error, if there is any. +func (c *analysisRuns) Create(ctx context.Context, analysisRun *v1alpha1.AnalysisRun, opts v1.CreateOptions) (result *v1alpha1.AnalysisRun, err error) { + result = &v1alpha1.AnalysisRun{} + err = c.client.Post(). + Namespace(c.ns). + Resource("analysisruns"). + VersionedParams(&opts, scheme.ParameterCodec). + Body(analysisRun). + Do(ctx). + Into(result) + return +} + +// Update takes the representation of a analysisRun and updates it. Returns the server's representation of the analysisRun, and an error, if there is any. +func (c *analysisRuns) Update(ctx context.Context, analysisRun *v1alpha1.AnalysisRun, opts v1.UpdateOptions) (result *v1alpha1.AnalysisRun, err error) { + result = &v1alpha1.AnalysisRun{} + err = c.client.Put(). + Namespace(c.ns). + Resource("analysisruns"). + Name(analysisRun.Name). + VersionedParams(&opts, scheme.ParameterCodec). + Body(analysisRun). + Do(ctx). + Into(result) + return +} + +// UpdateStatus was generated because the type contains a Status member. +// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). +func (c *analysisRuns) UpdateStatus(ctx context.Context, analysisRun *v1alpha1.AnalysisRun, opts v1.UpdateOptions) (result *v1alpha1.AnalysisRun, err error) { + result = &v1alpha1.AnalysisRun{} + err = c.client.Put(). + Namespace(c.ns). + Resource("analysisruns"). + Name(analysisRun.Name). + SubResource("status"). + VersionedParams(&opts, scheme.ParameterCodec). + Body(analysisRun). + Do(ctx). + Into(result) + return +} + +// Delete takes name of the analysisRun and deletes it. Returns an error if one occurs. +func (c *analysisRuns) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + return c.client.Delete(). + Namespace(c.ns). + Resource("analysisruns"). + Name(name). + Body(&opts). + Do(ctx). + Error() +} + +// DeleteCollection deletes a collection of objects. +func (c *analysisRuns) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + var timeout time.Duration + if listOpts.TimeoutSeconds != nil { + timeout = time.Duration(*listOpts.TimeoutSeconds) * time.Second + } + return c.client.Delete(). + Namespace(c.ns). + Resource("analysisruns"). + VersionedParams(&listOpts, scheme.ParameterCodec). + Timeout(timeout). + Body(&opts). + Do(ctx). + Error() +} + +// Patch applies the patch and returns the patched analysisRun. +func (c *analysisRuns) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha1.AnalysisRun, err error) { + result = &v1alpha1.AnalysisRun{} + err = c.client.Patch(pt). + Namespace(c.ns). + Resource("analysisruns"). + Name(name). + SubResource(subresources...). + VersionedParams(&opts, scheme.ParameterCodec). + Body(data). + Do(ctx). + Into(result) + return +} diff --git a/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/typed/rollouts/v1alpha1/analysistemplate.go b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/typed/rollouts/v1alpha1/analysistemplate.go new file mode 100644 index 000000000000..7581193578c4 --- /dev/null +++ b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/typed/rollouts/v1alpha1/analysistemplate.go @@ -0,0 +1,178 @@ +/* +Copyright The Kubernetes 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 client-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + "context" + "time" + + v1alpha1 "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1" + scheme "github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/scheme" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + rest "k8s.io/client-go/rest" +) + +// AnalysisTemplatesGetter has a method to return a AnalysisTemplateInterface. +// A group's client should implement this interface. +type AnalysisTemplatesGetter interface { + AnalysisTemplates(namespace string) AnalysisTemplateInterface +} + +// AnalysisTemplateInterface has methods to work with AnalysisTemplate resources. +type AnalysisTemplateInterface interface { + Create(ctx context.Context, analysisTemplate *v1alpha1.AnalysisTemplate, opts v1.CreateOptions) (*v1alpha1.AnalysisTemplate, error) + Update(ctx context.Context, analysisTemplate *v1alpha1.AnalysisTemplate, opts v1.UpdateOptions) (*v1alpha1.AnalysisTemplate, error) + Delete(ctx context.Context, name string, opts v1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error + Get(ctx context.Context, name string, opts v1.GetOptions) (*v1alpha1.AnalysisTemplate, error) + List(ctx context.Context, opts v1.ListOptions) (*v1alpha1.AnalysisTemplateList, error) + Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha1.AnalysisTemplate, err error) + AnalysisTemplateExpansion +} + +// analysisTemplates implements AnalysisTemplateInterface +type analysisTemplates struct { + client rest.Interface + ns string +} + +// newAnalysisTemplates returns a AnalysisTemplates +func newAnalysisTemplates(c *ArgoprojV1alpha1Client, namespace string) *analysisTemplates { + return &analysisTemplates{ + client: c.RESTClient(), + ns: namespace, + } +} + +// Get takes name of the analysisTemplate, and returns the corresponding analysisTemplate object, and an error if there is any. +func (c *analysisTemplates) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1alpha1.AnalysisTemplate, err error) { + result = &v1alpha1.AnalysisTemplate{} + err = c.client.Get(). + Namespace(c.ns). + Resource("analysistemplates"). + Name(name). + VersionedParams(&options, scheme.ParameterCodec). + Do(ctx). + Into(result) + return +} + +// List takes label and field selectors, and returns the list of AnalysisTemplates that match those selectors. +func (c *analysisTemplates) List(ctx context.Context, opts v1.ListOptions) (result *v1alpha1.AnalysisTemplateList, err error) { + var timeout time.Duration + if opts.TimeoutSeconds != nil { + timeout = time.Duration(*opts.TimeoutSeconds) * time.Second + } + result = &v1alpha1.AnalysisTemplateList{} + err = c.client.Get(). + Namespace(c.ns). + Resource("analysistemplates"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Do(ctx). + Into(result) + return +} + +// Watch returns a watch.Interface that watches the requested analysisTemplates. +func (c *analysisTemplates) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + var timeout time.Duration + if opts.TimeoutSeconds != nil { + timeout = time.Duration(*opts.TimeoutSeconds) * time.Second + } + opts.Watch = true + return c.client.Get(). + Namespace(c.ns). + Resource("analysistemplates"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Watch(ctx) +} + +// Create takes the representation of a analysisTemplate and creates it. Returns the server's representation of the analysisTemplate, and an error, if there is any. +func (c *analysisTemplates) Create(ctx context.Context, analysisTemplate *v1alpha1.AnalysisTemplate, opts v1.CreateOptions) (result *v1alpha1.AnalysisTemplate, err error) { + result = &v1alpha1.AnalysisTemplate{} + err = c.client.Post(). + Namespace(c.ns). + Resource("analysistemplates"). + VersionedParams(&opts, scheme.ParameterCodec). + Body(analysisTemplate). + Do(ctx). + Into(result) + return +} + +// Update takes the representation of a analysisTemplate and updates it. Returns the server's representation of the analysisTemplate, and an error, if there is any. +func (c *analysisTemplates) Update(ctx context.Context, analysisTemplate *v1alpha1.AnalysisTemplate, opts v1.UpdateOptions) (result *v1alpha1.AnalysisTemplate, err error) { + result = &v1alpha1.AnalysisTemplate{} + err = c.client.Put(). + Namespace(c.ns). + Resource("analysistemplates"). + Name(analysisTemplate.Name). + VersionedParams(&opts, scheme.ParameterCodec). + Body(analysisTemplate). + Do(ctx). + Into(result) + return +} + +// Delete takes name of the analysisTemplate and deletes it. Returns an error if one occurs. +func (c *analysisTemplates) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + return c.client.Delete(). + Namespace(c.ns). + Resource("analysistemplates"). + Name(name). + Body(&opts). + Do(ctx). + Error() +} + +// DeleteCollection deletes a collection of objects. +func (c *analysisTemplates) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + var timeout time.Duration + if listOpts.TimeoutSeconds != nil { + timeout = time.Duration(*listOpts.TimeoutSeconds) * time.Second + } + return c.client.Delete(). + Namespace(c.ns). + Resource("analysistemplates"). + VersionedParams(&listOpts, scheme.ParameterCodec). + Timeout(timeout). + Body(&opts). + Do(ctx). + Error() +} + +// Patch applies the patch and returns the patched analysisTemplate. +func (c *analysisTemplates) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha1.AnalysisTemplate, err error) { + result = &v1alpha1.AnalysisTemplate{} + err = c.client.Patch(pt). + Namespace(c.ns). + Resource("analysistemplates"). + Name(name). + SubResource(subresources...). + VersionedParams(&opts, scheme.ParameterCodec). + Body(data). + Do(ctx). + Into(result) + return +} diff --git a/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/typed/rollouts/v1alpha1/clusteranalysistemplate.go b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/typed/rollouts/v1alpha1/clusteranalysistemplate.go new file mode 100644 index 000000000000..4be2fe05b4f8 --- /dev/null +++ b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/typed/rollouts/v1alpha1/clusteranalysistemplate.go @@ -0,0 +1,168 @@ +/* +Copyright The Kubernetes 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 client-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + "context" + "time" + + v1alpha1 "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1" + scheme "github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/scheme" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + rest "k8s.io/client-go/rest" +) + +// ClusterAnalysisTemplatesGetter has a method to return a ClusterAnalysisTemplateInterface. +// A group's client should implement this interface. +type ClusterAnalysisTemplatesGetter interface { + ClusterAnalysisTemplates() ClusterAnalysisTemplateInterface +} + +// ClusterAnalysisTemplateInterface has methods to work with ClusterAnalysisTemplate resources. +type ClusterAnalysisTemplateInterface interface { + Create(ctx context.Context, clusterAnalysisTemplate *v1alpha1.ClusterAnalysisTemplate, opts v1.CreateOptions) (*v1alpha1.ClusterAnalysisTemplate, error) + Update(ctx context.Context, clusterAnalysisTemplate *v1alpha1.ClusterAnalysisTemplate, opts v1.UpdateOptions) (*v1alpha1.ClusterAnalysisTemplate, error) + Delete(ctx context.Context, name string, opts v1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error + Get(ctx context.Context, name string, opts v1.GetOptions) (*v1alpha1.ClusterAnalysisTemplate, error) + List(ctx context.Context, opts v1.ListOptions) (*v1alpha1.ClusterAnalysisTemplateList, error) + Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha1.ClusterAnalysisTemplate, err error) + ClusterAnalysisTemplateExpansion +} + +// clusterAnalysisTemplates implements ClusterAnalysisTemplateInterface +type clusterAnalysisTemplates struct { + client rest.Interface +} + +// newClusterAnalysisTemplates returns a ClusterAnalysisTemplates +func newClusterAnalysisTemplates(c *ArgoprojV1alpha1Client) *clusterAnalysisTemplates { + return &clusterAnalysisTemplates{ + client: c.RESTClient(), + } +} + +// Get takes name of the clusterAnalysisTemplate, and returns the corresponding clusterAnalysisTemplate object, and an error if there is any. +func (c *clusterAnalysisTemplates) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1alpha1.ClusterAnalysisTemplate, err error) { + result = &v1alpha1.ClusterAnalysisTemplate{} + err = c.client.Get(). + Resource("clusteranalysistemplates"). + Name(name). + VersionedParams(&options, scheme.ParameterCodec). + Do(ctx). + Into(result) + return +} + +// List takes label and field selectors, and returns the list of ClusterAnalysisTemplates that match those selectors. +func (c *clusterAnalysisTemplates) List(ctx context.Context, opts v1.ListOptions) (result *v1alpha1.ClusterAnalysisTemplateList, err error) { + var timeout time.Duration + if opts.TimeoutSeconds != nil { + timeout = time.Duration(*opts.TimeoutSeconds) * time.Second + } + result = &v1alpha1.ClusterAnalysisTemplateList{} + err = c.client.Get(). + Resource("clusteranalysistemplates"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Do(ctx). + Into(result) + return +} + +// Watch returns a watch.Interface that watches the requested clusterAnalysisTemplates. +func (c *clusterAnalysisTemplates) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + var timeout time.Duration + if opts.TimeoutSeconds != nil { + timeout = time.Duration(*opts.TimeoutSeconds) * time.Second + } + opts.Watch = true + return c.client.Get(). + Resource("clusteranalysistemplates"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Watch(ctx) +} + +// Create takes the representation of a clusterAnalysisTemplate and creates it. Returns the server's representation of the clusterAnalysisTemplate, and an error, if there is any. +func (c *clusterAnalysisTemplates) Create(ctx context.Context, clusterAnalysisTemplate *v1alpha1.ClusterAnalysisTemplate, opts v1.CreateOptions) (result *v1alpha1.ClusterAnalysisTemplate, err error) { + result = &v1alpha1.ClusterAnalysisTemplate{} + err = c.client.Post(). + Resource("clusteranalysistemplates"). + VersionedParams(&opts, scheme.ParameterCodec). + Body(clusterAnalysisTemplate). + Do(ctx). + Into(result) + return +} + +// Update takes the representation of a clusterAnalysisTemplate and updates it. Returns the server's representation of the clusterAnalysisTemplate, and an error, if there is any. +func (c *clusterAnalysisTemplates) Update(ctx context.Context, clusterAnalysisTemplate *v1alpha1.ClusterAnalysisTemplate, opts v1.UpdateOptions) (result *v1alpha1.ClusterAnalysisTemplate, err error) { + result = &v1alpha1.ClusterAnalysisTemplate{} + err = c.client.Put(). + Resource("clusteranalysistemplates"). + Name(clusterAnalysisTemplate.Name). + VersionedParams(&opts, scheme.ParameterCodec). + Body(clusterAnalysisTemplate). + Do(ctx). + Into(result) + return +} + +// Delete takes name of the clusterAnalysisTemplate and deletes it. Returns an error if one occurs. +func (c *clusterAnalysisTemplates) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + return c.client.Delete(). + Resource("clusteranalysistemplates"). + Name(name). + Body(&opts). + Do(ctx). + Error() +} + +// DeleteCollection deletes a collection of objects. +func (c *clusterAnalysisTemplates) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + var timeout time.Duration + if listOpts.TimeoutSeconds != nil { + timeout = time.Duration(*listOpts.TimeoutSeconds) * time.Second + } + return c.client.Delete(). + Resource("clusteranalysistemplates"). + VersionedParams(&listOpts, scheme.ParameterCodec). + Timeout(timeout). + Body(&opts). + Do(ctx). + Error() +} + +// Patch applies the patch and returns the patched clusterAnalysisTemplate. +func (c *clusterAnalysisTemplates) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha1.ClusterAnalysisTemplate, err error) { + result = &v1alpha1.ClusterAnalysisTemplate{} + err = c.client.Patch(pt). + Resource("clusteranalysistemplates"). + Name(name). + SubResource(subresources...). + VersionedParams(&opts, scheme.ParameterCodec). + Body(data). + Do(ctx). + Into(result) + return +} diff --git a/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/typed/rollouts/v1alpha1/doc.go b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/typed/rollouts/v1alpha1/doc.go new file mode 100644 index 000000000000..df51baa4d4c1 --- /dev/null +++ b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/typed/rollouts/v1alpha1/doc.go @@ -0,0 +1,20 @@ +/* +Copyright The Kubernetes 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 client-gen. DO NOT EDIT. + +// This package has the automatically generated typed clients. +package v1alpha1 diff --git a/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/typed/rollouts/v1alpha1/experiment.go b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/typed/rollouts/v1alpha1/experiment.go new file mode 100644 index 000000000000..7143d756550d --- /dev/null +++ b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/typed/rollouts/v1alpha1/experiment.go @@ -0,0 +1,195 @@ +/* +Copyright The Kubernetes 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 client-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + "context" + "time" + + v1alpha1 "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1" + scheme "github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/scheme" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + rest "k8s.io/client-go/rest" +) + +// ExperimentsGetter has a method to return a ExperimentInterface. +// A group's client should implement this interface. +type ExperimentsGetter interface { + Experiments(namespace string) ExperimentInterface +} + +// ExperimentInterface has methods to work with Experiment resources. +type ExperimentInterface interface { + Create(ctx context.Context, experiment *v1alpha1.Experiment, opts v1.CreateOptions) (*v1alpha1.Experiment, error) + Update(ctx context.Context, experiment *v1alpha1.Experiment, opts v1.UpdateOptions) (*v1alpha1.Experiment, error) + UpdateStatus(ctx context.Context, experiment *v1alpha1.Experiment, opts v1.UpdateOptions) (*v1alpha1.Experiment, error) + Delete(ctx context.Context, name string, opts v1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error + Get(ctx context.Context, name string, opts v1.GetOptions) (*v1alpha1.Experiment, error) + List(ctx context.Context, opts v1.ListOptions) (*v1alpha1.ExperimentList, error) + Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha1.Experiment, err error) + ExperimentExpansion +} + +// experiments implements ExperimentInterface +type experiments struct { + client rest.Interface + ns string +} + +// newExperiments returns a Experiments +func newExperiments(c *ArgoprojV1alpha1Client, namespace string) *experiments { + return &experiments{ + client: c.RESTClient(), + ns: namespace, + } +} + +// Get takes name of the experiment, and returns the corresponding experiment object, and an error if there is any. +func (c *experiments) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1alpha1.Experiment, err error) { + result = &v1alpha1.Experiment{} + err = c.client.Get(). + Namespace(c.ns). + Resource("experiments"). + Name(name). + VersionedParams(&options, scheme.ParameterCodec). + Do(ctx). + Into(result) + return +} + +// List takes label and field selectors, and returns the list of Experiments that match those selectors. +func (c *experiments) List(ctx context.Context, opts v1.ListOptions) (result *v1alpha1.ExperimentList, err error) { + var timeout time.Duration + if opts.TimeoutSeconds != nil { + timeout = time.Duration(*opts.TimeoutSeconds) * time.Second + } + result = &v1alpha1.ExperimentList{} + err = c.client.Get(). + Namespace(c.ns). + Resource("experiments"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Do(ctx). + Into(result) + return +} + +// Watch returns a watch.Interface that watches the requested experiments. +func (c *experiments) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + var timeout time.Duration + if opts.TimeoutSeconds != nil { + timeout = time.Duration(*opts.TimeoutSeconds) * time.Second + } + opts.Watch = true + return c.client.Get(). + Namespace(c.ns). + Resource("experiments"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Watch(ctx) +} + +// Create takes the representation of a experiment and creates it. Returns the server's representation of the experiment, and an error, if there is any. +func (c *experiments) Create(ctx context.Context, experiment *v1alpha1.Experiment, opts v1.CreateOptions) (result *v1alpha1.Experiment, err error) { + result = &v1alpha1.Experiment{} + err = c.client.Post(). + Namespace(c.ns). + Resource("experiments"). + VersionedParams(&opts, scheme.ParameterCodec). + Body(experiment). + Do(ctx). + Into(result) + return +} + +// Update takes the representation of a experiment and updates it. Returns the server's representation of the experiment, and an error, if there is any. +func (c *experiments) Update(ctx context.Context, experiment *v1alpha1.Experiment, opts v1.UpdateOptions) (result *v1alpha1.Experiment, err error) { + result = &v1alpha1.Experiment{} + err = c.client.Put(). + Namespace(c.ns). + Resource("experiments"). + Name(experiment.Name). + VersionedParams(&opts, scheme.ParameterCodec). + Body(experiment). + Do(ctx). + Into(result) + return +} + +// UpdateStatus was generated because the type contains a Status member. +// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). +func (c *experiments) UpdateStatus(ctx context.Context, experiment *v1alpha1.Experiment, opts v1.UpdateOptions) (result *v1alpha1.Experiment, err error) { + result = &v1alpha1.Experiment{} + err = c.client.Put(). + Namespace(c.ns). + Resource("experiments"). + Name(experiment.Name). + SubResource("status"). + VersionedParams(&opts, scheme.ParameterCodec). + Body(experiment). + Do(ctx). + Into(result) + return +} + +// Delete takes name of the experiment and deletes it. Returns an error if one occurs. +func (c *experiments) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + return c.client.Delete(). + Namespace(c.ns). + Resource("experiments"). + Name(name). + Body(&opts). + Do(ctx). + Error() +} + +// DeleteCollection deletes a collection of objects. +func (c *experiments) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + var timeout time.Duration + if listOpts.TimeoutSeconds != nil { + timeout = time.Duration(*listOpts.TimeoutSeconds) * time.Second + } + return c.client.Delete(). + Namespace(c.ns). + Resource("experiments"). + VersionedParams(&listOpts, scheme.ParameterCodec). + Timeout(timeout). + Body(&opts). + Do(ctx). + Error() +} + +// Patch applies the patch and returns the patched experiment. +func (c *experiments) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha1.Experiment, err error) { + result = &v1alpha1.Experiment{} + err = c.client.Patch(pt). + Namespace(c.ns). + Resource("experiments"). + Name(name). + SubResource(subresources...). + VersionedParams(&opts, scheme.ParameterCodec). + Body(data). + Do(ctx). + Into(result) + return +} diff --git a/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/typed/rollouts/v1alpha1/generated_expansion.go b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/typed/rollouts/v1alpha1/generated_expansion.go new file mode 100644 index 000000000000..6ec232ab9a8e --- /dev/null +++ b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/typed/rollouts/v1alpha1/generated_expansion.go @@ -0,0 +1,29 @@ +/* +Copyright The Kubernetes 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 client-gen. DO NOT EDIT. + +package v1alpha1 + +type AnalysisRunExpansion interface{} + +type AnalysisTemplateExpansion interface{} + +type ClusterAnalysisTemplateExpansion interface{} + +type ExperimentExpansion interface{} + +type RolloutExpansion interface{} diff --git a/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/typed/rollouts/v1alpha1/rollout.go b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/typed/rollouts/v1alpha1/rollout.go new file mode 100644 index 000000000000..bc38f6affa64 --- /dev/null +++ b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/typed/rollouts/v1alpha1/rollout.go @@ -0,0 +1,195 @@ +/* +Copyright The Kubernetes 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 client-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + "context" + "time" + + v1alpha1 "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1" + scheme "github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/scheme" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + rest "k8s.io/client-go/rest" +) + +// RolloutsGetter has a method to return a RolloutInterface. +// A group's client should implement this interface. +type RolloutsGetter interface { + Rollouts(namespace string) RolloutInterface +} + +// RolloutInterface has methods to work with Rollout resources. +type RolloutInterface interface { + Create(ctx context.Context, rollout *v1alpha1.Rollout, opts v1.CreateOptions) (*v1alpha1.Rollout, error) + Update(ctx context.Context, rollout *v1alpha1.Rollout, opts v1.UpdateOptions) (*v1alpha1.Rollout, error) + UpdateStatus(ctx context.Context, rollout *v1alpha1.Rollout, opts v1.UpdateOptions) (*v1alpha1.Rollout, error) + Delete(ctx context.Context, name string, opts v1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error + Get(ctx context.Context, name string, opts v1.GetOptions) (*v1alpha1.Rollout, error) + List(ctx context.Context, opts v1.ListOptions) (*v1alpha1.RolloutList, error) + Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha1.Rollout, err error) + RolloutExpansion +} + +// rollouts implements RolloutInterface +type rollouts struct { + client rest.Interface + ns string +} + +// newRollouts returns a Rollouts +func newRollouts(c *ArgoprojV1alpha1Client, namespace string) *rollouts { + return &rollouts{ + client: c.RESTClient(), + ns: namespace, + } +} + +// Get takes name of the rollout, and returns the corresponding rollout object, and an error if there is any. +func (c *rollouts) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1alpha1.Rollout, err error) { + result = &v1alpha1.Rollout{} + err = c.client.Get(). + Namespace(c.ns). + Resource("rollouts"). + Name(name). + VersionedParams(&options, scheme.ParameterCodec). + Do(ctx). + Into(result) + return +} + +// List takes label and field selectors, and returns the list of Rollouts that match those selectors. +func (c *rollouts) List(ctx context.Context, opts v1.ListOptions) (result *v1alpha1.RolloutList, err error) { + var timeout time.Duration + if opts.TimeoutSeconds != nil { + timeout = time.Duration(*opts.TimeoutSeconds) * time.Second + } + result = &v1alpha1.RolloutList{} + err = c.client.Get(). + Namespace(c.ns). + Resource("rollouts"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Do(ctx). + Into(result) + return +} + +// Watch returns a watch.Interface that watches the requested rollouts. +func (c *rollouts) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + var timeout time.Duration + if opts.TimeoutSeconds != nil { + timeout = time.Duration(*opts.TimeoutSeconds) * time.Second + } + opts.Watch = true + return c.client.Get(). + Namespace(c.ns). + Resource("rollouts"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Watch(ctx) +} + +// Create takes the representation of a rollout and creates it. Returns the server's representation of the rollout, and an error, if there is any. +func (c *rollouts) Create(ctx context.Context, rollout *v1alpha1.Rollout, opts v1.CreateOptions) (result *v1alpha1.Rollout, err error) { + result = &v1alpha1.Rollout{} + err = c.client.Post(). + Namespace(c.ns). + Resource("rollouts"). + VersionedParams(&opts, scheme.ParameterCodec). + Body(rollout). + Do(ctx). + Into(result) + return +} + +// Update takes the representation of a rollout and updates it. Returns the server's representation of the rollout, and an error, if there is any. +func (c *rollouts) Update(ctx context.Context, rollout *v1alpha1.Rollout, opts v1.UpdateOptions) (result *v1alpha1.Rollout, err error) { + result = &v1alpha1.Rollout{} + err = c.client.Put(). + Namespace(c.ns). + Resource("rollouts"). + Name(rollout.Name). + VersionedParams(&opts, scheme.ParameterCodec). + Body(rollout). + Do(ctx). + Into(result) + return +} + +// UpdateStatus was generated because the type contains a Status member. +// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). +func (c *rollouts) UpdateStatus(ctx context.Context, rollout *v1alpha1.Rollout, opts v1.UpdateOptions) (result *v1alpha1.Rollout, err error) { + result = &v1alpha1.Rollout{} + err = c.client.Put(). + Namespace(c.ns). + Resource("rollouts"). + Name(rollout.Name). + SubResource("status"). + VersionedParams(&opts, scheme.ParameterCodec). + Body(rollout). + Do(ctx). + Into(result) + return +} + +// Delete takes name of the rollout and deletes it. Returns an error if one occurs. +func (c *rollouts) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + return c.client.Delete(). + Namespace(c.ns). + Resource("rollouts"). + Name(name). + Body(&opts). + Do(ctx). + Error() +} + +// DeleteCollection deletes a collection of objects. +func (c *rollouts) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + var timeout time.Duration + if listOpts.TimeoutSeconds != nil { + timeout = time.Duration(*listOpts.TimeoutSeconds) * time.Second + } + return c.client.Delete(). + Namespace(c.ns). + Resource("rollouts"). + VersionedParams(&listOpts, scheme.ParameterCodec). + Timeout(timeout). + Body(&opts). + Do(ctx). + Error() +} + +// Patch applies the patch and returns the patched rollout. +func (c *rollouts) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha1.Rollout, err error) { + result = &v1alpha1.Rollout{} + err = c.client.Patch(pt). + Namespace(c.ns). + Resource("rollouts"). + Name(name). + SubResource(subresources...). + VersionedParams(&opts, scheme.ParameterCodec). + Body(data). + Do(ctx). + Into(result) + return +} diff --git a/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/typed/rollouts/v1alpha1/rollouts_client.go b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/typed/rollouts/v1alpha1/rollouts_client.go new file mode 100644 index 000000000000..61e7ef417033 --- /dev/null +++ b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/typed/rollouts/v1alpha1/rollouts_client.go @@ -0,0 +1,127 @@ +/* +Copyright The Kubernetes 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 client-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + "net/http" + + v1alpha1 "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1" + "github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/scheme" + rest "k8s.io/client-go/rest" +) + +type ArgoprojV1alpha1Interface interface { + RESTClient() rest.Interface + AnalysisRunsGetter + AnalysisTemplatesGetter + ClusterAnalysisTemplatesGetter + ExperimentsGetter + RolloutsGetter +} + +// ArgoprojV1alpha1Client is used to interact with features provided by the argoproj.io group. +type ArgoprojV1alpha1Client struct { + restClient rest.Interface +} + +func (c *ArgoprojV1alpha1Client) AnalysisRuns(namespace string) AnalysisRunInterface { + return newAnalysisRuns(c, namespace) +} + +func (c *ArgoprojV1alpha1Client) AnalysisTemplates(namespace string) AnalysisTemplateInterface { + return newAnalysisTemplates(c, namespace) +} + +func (c *ArgoprojV1alpha1Client) ClusterAnalysisTemplates() ClusterAnalysisTemplateInterface { + return newClusterAnalysisTemplates(c) +} + +func (c *ArgoprojV1alpha1Client) Experiments(namespace string) ExperimentInterface { + return newExperiments(c, namespace) +} + +func (c *ArgoprojV1alpha1Client) Rollouts(namespace string) RolloutInterface { + return newRollouts(c, namespace) +} + +// NewForConfig creates a new ArgoprojV1alpha1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). +func NewForConfig(c *rest.Config) (*ArgoprojV1alpha1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new ArgoprojV1alpha1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*ArgoprojV1alpha1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) + if err != nil { + return nil, err + } + return &ArgoprojV1alpha1Client{client}, nil +} + +// NewForConfigOrDie creates a new ArgoprojV1alpha1Client for the given config and +// panics if there is an error in the config. +func NewForConfigOrDie(c *rest.Config) *ArgoprojV1alpha1Client { + client, err := NewForConfig(c) + if err != nil { + panic(err) + } + return client +} + +// New creates a new ArgoprojV1alpha1Client for the given RESTClient. +func New(c rest.Interface) *ArgoprojV1alpha1Client { + return &ArgoprojV1alpha1Client{c} +} + +func setConfigDefaults(config *rest.Config) error { + gv := v1alpha1.SchemeGroupVersion + config.GroupVersion = &gv + config.APIPath = "/apis" + config.NegotiatedSerializer = scheme.Codecs.WithoutConversion() + + if config.UserAgent == "" { + config.UserAgent = rest.DefaultKubernetesUserAgent() + } + + return nil +} + +// RESTClient returns a RESTClient that is used to communicate +// with API server by this client implementation. +func (c *ArgoprojV1alpha1Client) RESTClient() rest.Interface { + if c == nil { + return nil + } + return c.restClient +} diff --git a/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/factory.go b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/factory.go new file mode 100644 index 000000000000..ad38e29a8825 --- /dev/null +++ b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/factory.go @@ -0,0 +1,180 @@ +/* +Copyright The Kubernetes 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 informer-gen. DO NOT EDIT. + +package externalversions + +import ( + reflect "reflect" + sync "sync" + time "time" + + versioned "github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned" + internalinterfaces "github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/internalinterfaces" + rollouts "github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/rollouts" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + runtime "k8s.io/apimachinery/pkg/runtime" + schema "k8s.io/apimachinery/pkg/runtime/schema" + cache "k8s.io/client-go/tools/cache" +) + +// SharedInformerOption defines the functional option type for SharedInformerFactory. +type SharedInformerOption func(*sharedInformerFactory) *sharedInformerFactory + +type sharedInformerFactory struct { + client versioned.Interface + namespace string + tweakListOptions internalinterfaces.TweakListOptionsFunc + lock sync.Mutex + defaultResync time.Duration + customResync map[reflect.Type]time.Duration + + informers map[reflect.Type]cache.SharedIndexInformer + // startedInformers is used for tracking which informers have been started. + // This allows Start() to be called multiple times safely. + startedInformers map[reflect.Type]bool +} + +// WithCustomResyncConfig sets a custom resync period for the specified informer types. +func WithCustomResyncConfig(resyncConfig map[v1.Object]time.Duration) SharedInformerOption { + return func(factory *sharedInformerFactory) *sharedInformerFactory { + for k, v := range resyncConfig { + factory.customResync[reflect.TypeOf(k)] = v + } + return factory + } +} + +// WithTweakListOptions sets a custom filter on all listers of the configured SharedInformerFactory. +func WithTweakListOptions(tweakListOptions internalinterfaces.TweakListOptionsFunc) SharedInformerOption { + return func(factory *sharedInformerFactory) *sharedInformerFactory { + factory.tweakListOptions = tweakListOptions + return factory + } +} + +// WithNamespace limits the SharedInformerFactory to the specified namespace. +func WithNamespace(namespace string) SharedInformerOption { + return func(factory *sharedInformerFactory) *sharedInformerFactory { + factory.namespace = namespace + return factory + } +} + +// NewSharedInformerFactory constructs a new instance of sharedInformerFactory for all namespaces. +func NewSharedInformerFactory(client versioned.Interface, defaultResync time.Duration) SharedInformerFactory { + return NewSharedInformerFactoryWithOptions(client, defaultResync) +} + +// NewFilteredSharedInformerFactory constructs a new instance of sharedInformerFactory. +// Listers obtained via this SharedInformerFactory will be subject to the same filters +// as specified here. +// Deprecated: Please use NewSharedInformerFactoryWithOptions instead +func NewFilteredSharedInformerFactory(client versioned.Interface, defaultResync time.Duration, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) SharedInformerFactory { + return NewSharedInformerFactoryWithOptions(client, defaultResync, WithNamespace(namespace), WithTweakListOptions(tweakListOptions)) +} + +// NewSharedInformerFactoryWithOptions constructs a new instance of a SharedInformerFactory with additional options. +func NewSharedInformerFactoryWithOptions(client versioned.Interface, defaultResync time.Duration, options ...SharedInformerOption) SharedInformerFactory { + factory := &sharedInformerFactory{ + client: client, + namespace: v1.NamespaceAll, + defaultResync: defaultResync, + informers: make(map[reflect.Type]cache.SharedIndexInformer), + startedInformers: make(map[reflect.Type]bool), + customResync: make(map[reflect.Type]time.Duration), + } + + // Apply all options + for _, opt := range options { + factory = opt(factory) + } + + return factory +} + +// Start initializes all requested informers. +func (f *sharedInformerFactory) Start(stopCh <-chan struct{}) { + f.lock.Lock() + defer f.lock.Unlock() + + for informerType, informer := range f.informers { + if !f.startedInformers[informerType] { + go informer.Run(stopCh) + f.startedInformers[informerType] = true + } + } +} + +// WaitForCacheSync waits for all started informers' cache were synced. +func (f *sharedInformerFactory) WaitForCacheSync(stopCh <-chan struct{}) map[reflect.Type]bool { + informers := func() map[reflect.Type]cache.SharedIndexInformer { + f.lock.Lock() + defer f.lock.Unlock() + + informers := map[reflect.Type]cache.SharedIndexInformer{} + for informerType, informer := range f.informers { + if f.startedInformers[informerType] { + informers[informerType] = informer + } + } + return informers + }() + + res := map[reflect.Type]bool{} + for informType, informer := range informers { + res[informType] = cache.WaitForCacheSync(stopCh, informer.HasSynced) + } + return res +} + +// InternalInformerFor returns the SharedIndexInformer for obj using an internal +// client. +func (f *sharedInformerFactory) InformerFor(obj runtime.Object, newFunc internalinterfaces.NewInformerFunc) cache.SharedIndexInformer { + f.lock.Lock() + defer f.lock.Unlock() + + informerType := reflect.TypeOf(obj) + informer, exists := f.informers[informerType] + if exists { + return informer + } + + resyncPeriod, exists := f.customResync[informerType] + if !exists { + resyncPeriod = f.defaultResync + } + + informer = newFunc(f.client, resyncPeriod) + f.informers[informerType] = informer + + return informer +} + +// SharedInformerFactory provides shared informers for resources in all known +// API group versions. +type SharedInformerFactory interface { + internalinterfaces.SharedInformerFactory + ForResource(resource schema.GroupVersionResource) (GenericInformer, error) + WaitForCacheSync(stopCh <-chan struct{}) map[reflect.Type]bool + + Argoproj() rollouts.Interface +} + +func (f *sharedInformerFactory) Argoproj() rollouts.Interface { + return rollouts.New(f, f.namespace, f.tweakListOptions) +} diff --git a/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/generic.go b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/generic.go new file mode 100644 index 000000000000..8a4023feb7dd --- /dev/null +++ b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/generic.go @@ -0,0 +1,70 @@ +/* +Copyright The Kubernetes 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 informer-gen. DO NOT EDIT. + +package externalversions + +import ( + "fmt" + + v1alpha1 "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1" + schema "k8s.io/apimachinery/pkg/runtime/schema" + cache "k8s.io/client-go/tools/cache" +) + +// GenericInformer is type of SharedIndexInformer which will locate and delegate to other +// sharedInformers based on type +type GenericInformer interface { + Informer() cache.SharedIndexInformer + Lister() cache.GenericLister +} + +type genericInformer struct { + informer cache.SharedIndexInformer + resource schema.GroupResource +} + +// Informer returns the SharedIndexInformer. +func (f *genericInformer) Informer() cache.SharedIndexInformer { + return f.informer +} + +// Lister returns the GenericLister. +func (f *genericInformer) Lister() cache.GenericLister { + return cache.NewGenericLister(f.Informer().GetIndexer(), f.resource) +} + +// ForResource gives generic access to a shared informer of the matching type +// TODO extend this to unknown resources with a client pool +func (f *sharedInformerFactory) ForResource(resource schema.GroupVersionResource) (GenericInformer, error) { + switch resource { + // Group=argoproj.io, Version=v1alpha1 + case v1alpha1.SchemeGroupVersion.WithResource("analysisruns"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Argoproj().V1alpha1().AnalysisRuns().Informer()}, nil + case v1alpha1.SchemeGroupVersion.WithResource("analysistemplates"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Argoproj().V1alpha1().AnalysisTemplates().Informer()}, nil + case v1alpha1.SchemeGroupVersion.WithResource("clusteranalysistemplates"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Argoproj().V1alpha1().ClusterAnalysisTemplates().Informer()}, nil + case v1alpha1.SchemeGroupVersion.WithResource("experiments"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Argoproj().V1alpha1().Experiments().Informer()}, nil + case v1alpha1.SchemeGroupVersion.WithResource("rollouts"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Argoproj().V1alpha1().Rollouts().Informer()}, nil + + } + + return nil, fmt.Errorf("no informer found for %v", resource) +} diff --git a/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/internalinterfaces/factory_interfaces.go b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/internalinterfaces/factory_interfaces.go new file mode 100644 index 000000000000..174588ef01c6 --- /dev/null +++ b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/internalinterfaces/factory_interfaces.go @@ -0,0 +1,40 @@ +/* +Copyright The Kubernetes 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 informer-gen. DO NOT EDIT. + +package internalinterfaces + +import ( + time "time" + + versioned "github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + runtime "k8s.io/apimachinery/pkg/runtime" + cache "k8s.io/client-go/tools/cache" +) + +// NewInformerFunc takes versioned.Interface and time.Duration to return a SharedIndexInformer. +type NewInformerFunc func(versioned.Interface, time.Duration) cache.SharedIndexInformer + +// SharedInformerFactory a small interface to allow for adding an informer without an import cycle +type SharedInformerFactory interface { + Start(stopCh <-chan struct{}) + InformerFor(obj runtime.Object, newFunc NewInformerFunc) cache.SharedIndexInformer +} + +// TweakListOptionsFunc is a function that transforms a v1.ListOptions. +type TweakListOptionsFunc func(*v1.ListOptions) diff --git a/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/rollouts/interface.go b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/rollouts/interface.go new file mode 100644 index 000000000000..4b6082ac45a6 --- /dev/null +++ b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/rollouts/interface.go @@ -0,0 +1,46 @@ +/* +Copyright The Kubernetes 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 informer-gen. DO NOT EDIT. + +package rollouts + +import ( + internalinterfaces "github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/internalinterfaces" + v1alpha1 "github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/rollouts/v1alpha1" +) + +// Interface provides access to each of this group's versions. +type Interface interface { + // V1alpha1 provides access to shared informers for resources in V1alpha1. + V1alpha1() v1alpha1.Interface +} + +type group struct { + factory internalinterfaces.SharedInformerFactory + namespace string + tweakListOptions internalinterfaces.TweakListOptionsFunc +} + +// New returns a new Interface. +func New(f internalinterfaces.SharedInformerFactory, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) Interface { + return &group{factory: f, namespace: namespace, tweakListOptions: tweakListOptions} +} + +// V1alpha1 returns a new v1alpha1.Interface. +func (g *group) V1alpha1() v1alpha1.Interface { + return v1alpha1.New(g.factory, g.namespace, g.tweakListOptions) +} diff --git a/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/rollouts/v1alpha1/analysisrun.go b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/rollouts/v1alpha1/analysisrun.go new file mode 100644 index 000000000000..7e297d0de85e --- /dev/null +++ b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/rollouts/v1alpha1/analysisrun.go @@ -0,0 +1,90 @@ +/* +Copyright The Kubernetes 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 informer-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + "context" + time "time" + + rolloutsv1alpha1 "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1" + versioned "github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned" + internalinterfaces "github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/internalinterfaces" + v1alpha1 "github.com/argoproj/argo-rollouts/pkg/client/listers/rollouts/v1alpha1" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + runtime "k8s.io/apimachinery/pkg/runtime" + watch "k8s.io/apimachinery/pkg/watch" + cache "k8s.io/client-go/tools/cache" +) + +// AnalysisRunInformer provides access to a shared informer and lister for +// AnalysisRuns. +type AnalysisRunInformer interface { + Informer() cache.SharedIndexInformer + Lister() v1alpha1.AnalysisRunLister +} + +type analysisRunInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc + namespace string +} + +// NewAnalysisRunInformer constructs a new informer for AnalysisRun type. +// Always prefer using an informer factory to get a shared informer instead of getting an independent +// one. This reduces memory footprint and number of connections to the server. +func NewAnalysisRunInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredAnalysisRunInformer(client, namespace, resyncPeriod, indexers, nil) +} + +// NewFilteredAnalysisRunInformer constructs a new informer for AnalysisRun type. +// Always prefer using an informer factory to get a shared informer instead of getting an independent +// one. This reduces memory footprint and number of connections to the server. +func NewFilteredAnalysisRunInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer { + return cache.NewSharedIndexInformer( + &cache.ListWatch{ + ListFunc: func(options v1.ListOptions) (runtime.Object, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.ArgoprojV1alpha1().AnalysisRuns(namespace).List(context.TODO(), options) + }, + WatchFunc: func(options v1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.ArgoprojV1alpha1().AnalysisRuns(namespace).Watch(context.TODO(), options) + }, + }, + &rolloutsv1alpha1.AnalysisRun{}, + resyncPeriod, + indexers, + ) +} + +func (f *analysisRunInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredAnalysisRunInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *analysisRunInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&rolloutsv1alpha1.AnalysisRun{}, f.defaultInformer) +} + +func (f *analysisRunInformer) Lister() v1alpha1.AnalysisRunLister { + return v1alpha1.NewAnalysisRunLister(f.Informer().GetIndexer()) +} diff --git a/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/rollouts/v1alpha1/analysistemplate.go b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/rollouts/v1alpha1/analysistemplate.go new file mode 100644 index 000000000000..31cd5220b76c --- /dev/null +++ b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/rollouts/v1alpha1/analysistemplate.go @@ -0,0 +1,90 @@ +/* +Copyright The Kubernetes 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 informer-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + "context" + time "time" + + rolloutsv1alpha1 "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1" + versioned "github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned" + internalinterfaces "github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/internalinterfaces" + v1alpha1 "github.com/argoproj/argo-rollouts/pkg/client/listers/rollouts/v1alpha1" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + runtime "k8s.io/apimachinery/pkg/runtime" + watch "k8s.io/apimachinery/pkg/watch" + cache "k8s.io/client-go/tools/cache" +) + +// AnalysisTemplateInformer provides access to a shared informer and lister for +// AnalysisTemplates. +type AnalysisTemplateInformer interface { + Informer() cache.SharedIndexInformer + Lister() v1alpha1.AnalysisTemplateLister +} + +type analysisTemplateInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc + namespace string +} + +// NewAnalysisTemplateInformer constructs a new informer for AnalysisTemplate type. +// Always prefer using an informer factory to get a shared informer instead of getting an independent +// one. This reduces memory footprint and number of connections to the server. +func NewAnalysisTemplateInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredAnalysisTemplateInformer(client, namespace, resyncPeriod, indexers, nil) +} + +// NewFilteredAnalysisTemplateInformer constructs a new informer for AnalysisTemplate type. +// Always prefer using an informer factory to get a shared informer instead of getting an independent +// one. This reduces memory footprint and number of connections to the server. +func NewFilteredAnalysisTemplateInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer { + return cache.NewSharedIndexInformer( + &cache.ListWatch{ + ListFunc: func(options v1.ListOptions) (runtime.Object, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.ArgoprojV1alpha1().AnalysisTemplates(namespace).List(context.TODO(), options) + }, + WatchFunc: func(options v1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.ArgoprojV1alpha1().AnalysisTemplates(namespace).Watch(context.TODO(), options) + }, + }, + &rolloutsv1alpha1.AnalysisTemplate{}, + resyncPeriod, + indexers, + ) +} + +func (f *analysisTemplateInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredAnalysisTemplateInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *analysisTemplateInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&rolloutsv1alpha1.AnalysisTemplate{}, f.defaultInformer) +} + +func (f *analysisTemplateInformer) Lister() v1alpha1.AnalysisTemplateLister { + return v1alpha1.NewAnalysisTemplateLister(f.Informer().GetIndexer()) +} diff --git a/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/rollouts/v1alpha1/clusteranalysistemplate.go b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/rollouts/v1alpha1/clusteranalysistemplate.go new file mode 100644 index 000000000000..25c5d8e10a7b --- /dev/null +++ b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/rollouts/v1alpha1/clusteranalysistemplate.go @@ -0,0 +1,89 @@ +/* +Copyright The Kubernetes 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 informer-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + "context" + time "time" + + rolloutsv1alpha1 "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1" + versioned "github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned" + internalinterfaces "github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/internalinterfaces" + v1alpha1 "github.com/argoproj/argo-rollouts/pkg/client/listers/rollouts/v1alpha1" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + runtime "k8s.io/apimachinery/pkg/runtime" + watch "k8s.io/apimachinery/pkg/watch" + cache "k8s.io/client-go/tools/cache" +) + +// ClusterAnalysisTemplateInformer provides access to a shared informer and lister for +// ClusterAnalysisTemplates. +type ClusterAnalysisTemplateInformer interface { + Informer() cache.SharedIndexInformer + Lister() v1alpha1.ClusterAnalysisTemplateLister +} + +type clusterAnalysisTemplateInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc +} + +// NewClusterAnalysisTemplateInformer constructs a new informer for ClusterAnalysisTemplate type. +// Always prefer using an informer factory to get a shared informer instead of getting an independent +// one. This reduces memory footprint and number of connections to the server. +func NewClusterAnalysisTemplateInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredClusterAnalysisTemplateInformer(client, resyncPeriod, indexers, nil) +} + +// NewFilteredClusterAnalysisTemplateInformer constructs a new informer for ClusterAnalysisTemplate type. +// Always prefer using an informer factory to get a shared informer instead of getting an independent +// one. This reduces memory footprint and number of connections to the server. +func NewFilteredClusterAnalysisTemplateInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer { + return cache.NewSharedIndexInformer( + &cache.ListWatch{ + ListFunc: func(options v1.ListOptions) (runtime.Object, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.ArgoprojV1alpha1().ClusterAnalysisTemplates().List(context.TODO(), options) + }, + WatchFunc: func(options v1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.ArgoprojV1alpha1().ClusterAnalysisTemplates().Watch(context.TODO(), options) + }, + }, + &rolloutsv1alpha1.ClusterAnalysisTemplate{}, + resyncPeriod, + indexers, + ) +} + +func (f *clusterAnalysisTemplateInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredClusterAnalysisTemplateInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *clusterAnalysisTemplateInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&rolloutsv1alpha1.ClusterAnalysisTemplate{}, f.defaultInformer) +} + +func (f *clusterAnalysisTemplateInformer) Lister() v1alpha1.ClusterAnalysisTemplateLister { + return v1alpha1.NewClusterAnalysisTemplateLister(f.Informer().GetIndexer()) +} diff --git a/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/rollouts/v1alpha1/experiment.go b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/rollouts/v1alpha1/experiment.go new file mode 100644 index 000000000000..b2b87b20a926 --- /dev/null +++ b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/rollouts/v1alpha1/experiment.go @@ -0,0 +1,90 @@ +/* +Copyright The Kubernetes 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 informer-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + "context" + time "time" + + rolloutsv1alpha1 "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1" + versioned "github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned" + internalinterfaces "github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/internalinterfaces" + v1alpha1 "github.com/argoproj/argo-rollouts/pkg/client/listers/rollouts/v1alpha1" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + runtime "k8s.io/apimachinery/pkg/runtime" + watch "k8s.io/apimachinery/pkg/watch" + cache "k8s.io/client-go/tools/cache" +) + +// ExperimentInformer provides access to a shared informer and lister for +// Experiments. +type ExperimentInformer interface { + Informer() cache.SharedIndexInformer + Lister() v1alpha1.ExperimentLister +} + +type experimentInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc + namespace string +} + +// NewExperimentInformer constructs a new informer for Experiment type. +// Always prefer using an informer factory to get a shared informer instead of getting an independent +// one. This reduces memory footprint and number of connections to the server. +func NewExperimentInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredExperimentInformer(client, namespace, resyncPeriod, indexers, nil) +} + +// NewFilteredExperimentInformer constructs a new informer for Experiment type. +// Always prefer using an informer factory to get a shared informer instead of getting an independent +// one. This reduces memory footprint and number of connections to the server. +func NewFilteredExperimentInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer { + return cache.NewSharedIndexInformer( + &cache.ListWatch{ + ListFunc: func(options v1.ListOptions) (runtime.Object, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.ArgoprojV1alpha1().Experiments(namespace).List(context.TODO(), options) + }, + WatchFunc: func(options v1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.ArgoprojV1alpha1().Experiments(namespace).Watch(context.TODO(), options) + }, + }, + &rolloutsv1alpha1.Experiment{}, + resyncPeriod, + indexers, + ) +} + +func (f *experimentInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredExperimentInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *experimentInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&rolloutsv1alpha1.Experiment{}, f.defaultInformer) +} + +func (f *experimentInformer) Lister() v1alpha1.ExperimentLister { + return v1alpha1.NewExperimentLister(f.Informer().GetIndexer()) +} diff --git a/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/rollouts/v1alpha1/interface.go b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/rollouts/v1alpha1/interface.go new file mode 100644 index 000000000000..2778a39bbc1d --- /dev/null +++ b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/rollouts/v1alpha1/interface.go @@ -0,0 +1,73 @@ +/* +Copyright The Kubernetes 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 informer-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + internalinterfaces "github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/internalinterfaces" +) + +// Interface provides access to all the informers in this group version. +type Interface interface { + // AnalysisRuns returns a AnalysisRunInformer. + AnalysisRuns() AnalysisRunInformer + // AnalysisTemplates returns a AnalysisTemplateInformer. + AnalysisTemplates() AnalysisTemplateInformer + // ClusterAnalysisTemplates returns a ClusterAnalysisTemplateInformer. + ClusterAnalysisTemplates() ClusterAnalysisTemplateInformer + // Experiments returns a ExperimentInformer. + Experiments() ExperimentInformer + // Rollouts returns a RolloutInformer. + Rollouts() RolloutInformer +} + +type version struct { + factory internalinterfaces.SharedInformerFactory + namespace string + tweakListOptions internalinterfaces.TweakListOptionsFunc +} + +// New returns a new Interface. +func New(f internalinterfaces.SharedInformerFactory, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) Interface { + return &version{factory: f, namespace: namespace, tweakListOptions: tweakListOptions} +} + +// AnalysisRuns returns a AnalysisRunInformer. +func (v *version) AnalysisRuns() AnalysisRunInformer { + return &analysisRunInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions} +} + +// AnalysisTemplates returns a AnalysisTemplateInformer. +func (v *version) AnalysisTemplates() AnalysisTemplateInformer { + return &analysisTemplateInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions} +} + +// ClusterAnalysisTemplates returns a ClusterAnalysisTemplateInformer. +func (v *version) ClusterAnalysisTemplates() ClusterAnalysisTemplateInformer { + return &clusterAnalysisTemplateInformer{factory: v.factory, tweakListOptions: v.tweakListOptions} +} + +// Experiments returns a ExperimentInformer. +func (v *version) Experiments() ExperimentInformer { + return &experimentInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions} +} + +// Rollouts returns a RolloutInformer. +func (v *version) Rollouts() RolloutInformer { + return &rolloutInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions} +} diff --git a/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/rollouts/v1alpha1/rollout.go b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/rollouts/v1alpha1/rollout.go new file mode 100644 index 000000000000..8e6bc4a7aa80 --- /dev/null +++ b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/rollouts/v1alpha1/rollout.go @@ -0,0 +1,90 @@ +/* +Copyright The Kubernetes 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 informer-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + "context" + time "time" + + rolloutsv1alpha1 "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1" + versioned "github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned" + internalinterfaces "github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/internalinterfaces" + v1alpha1 "github.com/argoproj/argo-rollouts/pkg/client/listers/rollouts/v1alpha1" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + runtime "k8s.io/apimachinery/pkg/runtime" + watch "k8s.io/apimachinery/pkg/watch" + cache "k8s.io/client-go/tools/cache" +) + +// RolloutInformer provides access to a shared informer and lister for +// Rollouts. +type RolloutInformer interface { + Informer() cache.SharedIndexInformer + Lister() v1alpha1.RolloutLister +} + +type rolloutInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc + namespace string +} + +// NewRolloutInformer constructs a new informer for Rollout type. +// Always prefer using an informer factory to get a shared informer instead of getting an independent +// one. This reduces memory footprint and number of connections to the server. +func NewRolloutInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredRolloutInformer(client, namespace, resyncPeriod, indexers, nil) +} + +// NewFilteredRolloutInformer constructs a new informer for Rollout type. +// Always prefer using an informer factory to get a shared informer instead of getting an independent +// one. This reduces memory footprint and number of connections to the server. +func NewFilteredRolloutInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer { + return cache.NewSharedIndexInformer( + &cache.ListWatch{ + ListFunc: func(options v1.ListOptions) (runtime.Object, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.ArgoprojV1alpha1().Rollouts(namespace).List(context.TODO(), options) + }, + WatchFunc: func(options v1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.ArgoprojV1alpha1().Rollouts(namespace).Watch(context.TODO(), options) + }, + }, + &rolloutsv1alpha1.Rollout{}, + resyncPeriod, + indexers, + ) +} + +func (f *rolloutInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredRolloutInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *rolloutInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&rolloutsv1alpha1.Rollout{}, f.defaultInformer) +} + +func (f *rolloutInformer) Lister() v1alpha1.RolloutLister { + return v1alpha1.NewRolloutLister(f.Informer().GetIndexer()) +} diff --git a/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/listers/rollouts/v1alpha1/analysisrun.go b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/listers/rollouts/v1alpha1/analysisrun.go new file mode 100644 index 000000000000..7557f5bf6079 --- /dev/null +++ b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/listers/rollouts/v1alpha1/analysisrun.go @@ -0,0 +1,99 @@ +/* +Copyright The Kubernetes 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 lister-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + v1alpha1 "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1" + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/client-go/tools/cache" +) + +// AnalysisRunLister helps list AnalysisRuns. +// All objects returned here must be treated as read-only. +type AnalysisRunLister interface { + // List lists all AnalysisRuns in the indexer. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v1alpha1.AnalysisRun, err error) + // AnalysisRuns returns an object that can list and get AnalysisRuns. + AnalysisRuns(namespace string) AnalysisRunNamespaceLister + AnalysisRunListerExpansion +} + +// analysisRunLister implements the AnalysisRunLister interface. +type analysisRunLister struct { + indexer cache.Indexer +} + +// NewAnalysisRunLister returns a new AnalysisRunLister. +func NewAnalysisRunLister(indexer cache.Indexer) AnalysisRunLister { + return &analysisRunLister{indexer: indexer} +} + +// List lists all AnalysisRuns in the indexer. +func (s *analysisRunLister) List(selector labels.Selector) (ret []*v1alpha1.AnalysisRun, err error) { + err = cache.ListAll(s.indexer, selector, func(m interface{}) { + ret = append(ret, m.(*v1alpha1.AnalysisRun)) + }) + return ret, err +} + +// AnalysisRuns returns an object that can list and get AnalysisRuns. +func (s *analysisRunLister) AnalysisRuns(namespace string) AnalysisRunNamespaceLister { + return analysisRunNamespaceLister{indexer: s.indexer, namespace: namespace} +} + +// AnalysisRunNamespaceLister helps list and get AnalysisRuns. +// All objects returned here must be treated as read-only. +type AnalysisRunNamespaceLister interface { + // List lists all AnalysisRuns in the indexer for a given namespace. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v1alpha1.AnalysisRun, err error) + // Get retrieves the AnalysisRun from the indexer for a given namespace and name. + // Objects returned here must be treated as read-only. + Get(name string) (*v1alpha1.AnalysisRun, error) + AnalysisRunNamespaceListerExpansion +} + +// analysisRunNamespaceLister implements the AnalysisRunNamespaceLister +// interface. +type analysisRunNamespaceLister struct { + indexer cache.Indexer + namespace string +} + +// List lists all AnalysisRuns in the indexer for a given namespace. +func (s analysisRunNamespaceLister) List(selector labels.Selector) (ret []*v1alpha1.AnalysisRun, err error) { + err = cache.ListAllByNamespace(s.indexer, s.namespace, selector, func(m interface{}) { + ret = append(ret, m.(*v1alpha1.AnalysisRun)) + }) + return ret, err +} + +// Get retrieves the AnalysisRun from the indexer for a given namespace and name. +func (s analysisRunNamespaceLister) Get(name string) (*v1alpha1.AnalysisRun, error) { + obj, exists, err := s.indexer.GetByKey(s.namespace + "/" + name) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(v1alpha1.Resource("analysisrun"), name) + } + return obj.(*v1alpha1.AnalysisRun), nil +} diff --git a/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/listers/rollouts/v1alpha1/analysistemplate.go b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/listers/rollouts/v1alpha1/analysistemplate.go new file mode 100644 index 000000000000..2d171e86ecce --- /dev/null +++ b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/listers/rollouts/v1alpha1/analysistemplate.go @@ -0,0 +1,99 @@ +/* +Copyright The Kubernetes 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 lister-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + v1alpha1 "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1" + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/client-go/tools/cache" +) + +// AnalysisTemplateLister helps list AnalysisTemplates. +// All objects returned here must be treated as read-only. +type AnalysisTemplateLister interface { + // List lists all AnalysisTemplates in the indexer. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v1alpha1.AnalysisTemplate, err error) + // AnalysisTemplates returns an object that can list and get AnalysisTemplates. + AnalysisTemplates(namespace string) AnalysisTemplateNamespaceLister + AnalysisTemplateListerExpansion +} + +// analysisTemplateLister implements the AnalysisTemplateLister interface. +type analysisTemplateLister struct { + indexer cache.Indexer +} + +// NewAnalysisTemplateLister returns a new AnalysisTemplateLister. +func NewAnalysisTemplateLister(indexer cache.Indexer) AnalysisTemplateLister { + return &analysisTemplateLister{indexer: indexer} +} + +// List lists all AnalysisTemplates in the indexer. +func (s *analysisTemplateLister) List(selector labels.Selector) (ret []*v1alpha1.AnalysisTemplate, err error) { + err = cache.ListAll(s.indexer, selector, func(m interface{}) { + ret = append(ret, m.(*v1alpha1.AnalysisTemplate)) + }) + return ret, err +} + +// AnalysisTemplates returns an object that can list and get AnalysisTemplates. +func (s *analysisTemplateLister) AnalysisTemplates(namespace string) AnalysisTemplateNamespaceLister { + return analysisTemplateNamespaceLister{indexer: s.indexer, namespace: namespace} +} + +// AnalysisTemplateNamespaceLister helps list and get AnalysisTemplates. +// All objects returned here must be treated as read-only. +type AnalysisTemplateNamespaceLister interface { + // List lists all AnalysisTemplates in the indexer for a given namespace. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v1alpha1.AnalysisTemplate, err error) + // Get retrieves the AnalysisTemplate from the indexer for a given namespace and name. + // Objects returned here must be treated as read-only. + Get(name string) (*v1alpha1.AnalysisTemplate, error) + AnalysisTemplateNamespaceListerExpansion +} + +// analysisTemplateNamespaceLister implements the AnalysisTemplateNamespaceLister +// interface. +type analysisTemplateNamespaceLister struct { + indexer cache.Indexer + namespace string +} + +// List lists all AnalysisTemplates in the indexer for a given namespace. +func (s analysisTemplateNamespaceLister) List(selector labels.Selector) (ret []*v1alpha1.AnalysisTemplate, err error) { + err = cache.ListAllByNamespace(s.indexer, s.namespace, selector, func(m interface{}) { + ret = append(ret, m.(*v1alpha1.AnalysisTemplate)) + }) + return ret, err +} + +// Get retrieves the AnalysisTemplate from the indexer for a given namespace and name. +func (s analysisTemplateNamespaceLister) Get(name string) (*v1alpha1.AnalysisTemplate, error) { + obj, exists, err := s.indexer.GetByKey(s.namespace + "/" + name) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(v1alpha1.Resource("analysistemplate"), name) + } + return obj.(*v1alpha1.AnalysisTemplate), nil +} diff --git a/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/listers/rollouts/v1alpha1/clusteranalysistemplate.go b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/listers/rollouts/v1alpha1/clusteranalysistemplate.go new file mode 100644 index 000000000000..96cb8b0772d0 --- /dev/null +++ b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/listers/rollouts/v1alpha1/clusteranalysistemplate.go @@ -0,0 +1,68 @@ +/* +Copyright The Kubernetes 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 lister-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + v1alpha1 "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1" + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/client-go/tools/cache" +) + +// ClusterAnalysisTemplateLister helps list ClusterAnalysisTemplates. +// All objects returned here must be treated as read-only. +type ClusterAnalysisTemplateLister interface { + // List lists all ClusterAnalysisTemplates in the indexer. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v1alpha1.ClusterAnalysisTemplate, err error) + // Get retrieves the ClusterAnalysisTemplate from the index for a given name. + // Objects returned here must be treated as read-only. + Get(name string) (*v1alpha1.ClusterAnalysisTemplate, error) + ClusterAnalysisTemplateListerExpansion +} + +// clusterAnalysisTemplateLister implements the ClusterAnalysisTemplateLister interface. +type clusterAnalysisTemplateLister struct { + indexer cache.Indexer +} + +// NewClusterAnalysisTemplateLister returns a new ClusterAnalysisTemplateLister. +func NewClusterAnalysisTemplateLister(indexer cache.Indexer) ClusterAnalysisTemplateLister { + return &clusterAnalysisTemplateLister{indexer: indexer} +} + +// List lists all ClusterAnalysisTemplates in the indexer. +func (s *clusterAnalysisTemplateLister) List(selector labels.Selector) (ret []*v1alpha1.ClusterAnalysisTemplate, err error) { + err = cache.ListAll(s.indexer, selector, func(m interface{}) { + ret = append(ret, m.(*v1alpha1.ClusterAnalysisTemplate)) + }) + return ret, err +} + +// Get retrieves the ClusterAnalysisTemplate from the index for a given name. +func (s *clusterAnalysisTemplateLister) Get(name string) (*v1alpha1.ClusterAnalysisTemplate, error) { + obj, exists, err := s.indexer.GetByKey(name) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(v1alpha1.Resource("clusteranalysistemplate"), name) + } + return obj.(*v1alpha1.ClusterAnalysisTemplate), nil +} diff --git a/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/listers/rollouts/v1alpha1/expansion_generated.go b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/listers/rollouts/v1alpha1/expansion_generated.go new file mode 100644 index 000000000000..fef6f81d3c02 --- /dev/null +++ b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/listers/rollouts/v1alpha1/expansion_generated.go @@ -0,0 +1,55 @@ +/* +Copyright The Kubernetes 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 lister-gen. DO NOT EDIT. + +package v1alpha1 + +// AnalysisRunListerExpansion allows custom methods to be added to +// AnalysisRunLister. +type AnalysisRunListerExpansion interface{} + +// AnalysisRunNamespaceListerExpansion allows custom methods to be added to +// AnalysisRunNamespaceLister. +type AnalysisRunNamespaceListerExpansion interface{} + +// AnalysisTemplateListerExpansion allows custom methods to be added to +// AnalysisTemplateLister. +type AnalysisTemplateListerExpansion interface{} + +// AnalysisTemplateNamespaceListerExpansion allows custom methods to be added to +// AnalysisTemplateNamespaceLister. +type AnalysisTemplateNamespaceListerExpansion interface{} + +// ClusterAnalysisTemplateListerExpansion allows custom methods to be added to +// ClusterAnalysisTemplateLister. +type ClusterAnalysisTemplateListerExpansion interface{} + +// ExperimentListerExpansion allows custom methods to be added to +// ExperimentLister. +type ExperimentListerExpansion interface{} + +// ExperimentNamespaceListerExpansion allows custom methods to be added to +// ExperimentNamespaceLister. +type ExperimentNamespaceListerExpansion interface{} + +// RolloutListerExpansion allows custom methods to be added to +// RolloutLister. +type RolloutListerExpansion interface{} + +// RolloutNamespaceListerExpansion allows custom methods to be added to +// RolloutNamespaceLister. +type RolloutNamespaceListerExpansion interface{} diff --git a/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/listers/rollouts/v1alpha1/experiment.go b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/listers/rollouts/v1alpha1/experiment.go new file mode 100644 index 000000000000..7c6be6569cff --- /dev/null +++ b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/listers/rollouts/v1alpha1/experiment.go @@ -0,0 +1,99 @@ +/* +Copyright The Kubernetes 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 lister-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + v1alpha1 "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1" + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/client-go/tools/cache" +) + +// ExperimentLister helps list Experiments. +// All objects returned here must be treated as read-only. +type ExperimentLister interface { + // List lists all Experiments in the indexer. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v1alpha1.Experiment, err error) + // Experiments returns an object that can list and get Experiments. + Experiments(namespace string) ExperimentNamespaceLister + ExperimentListerExpansion +} + +// experimentLister implements the ExperimentLister interface. +type experimentLister struct { + indexer cache.Indexer +} + +// NewExperimentLister returns a new ExperimentLister. +func NewExperimentLister(indexer cache.Indexer) ExperimentLister { + return &experimentLister{indexer: indexer} +} + +// List lists all Experiments in the indexer. +func (s *experimentLister) List(selector labels.Selector) (ret []*v1alpha1.Experiment, err error) { + err = cache.ListAll(s.indexer, selector, func(m interface{}) { + ret = append(ret, m.(*v1alpha1.Experiment)) + }) + return ret, err +} + +// Experiments returns an object that can list and get Experiments. +func (s *experimentLister) Experiments(namespace string) ExperimentNamespaceLister { + return experimentNamespaceLister{indexer: s.indexer, namespace: namespace} +} + +// ExperimentNamespaceLister helps list and get Experiments. +// All objects returned here must be treated as read-only. +type ExperimentNamespaceLister interface { + // List lists all Experiments in the indexer for a given namespace. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v1alpha1.Experiment, err error) + // Get retrieves the Experiment from the indexer for a given namespace and name. + // Objects returned here must be treated as read-only. + Get(name string) (*v1alpha1.Experiment, error) + ExperimentNamespaceListerExpansion +} + +// experimentNamespaceLister implements the ExperimentNamespaceLister +// interface. +type experimentNamespaceLister struct { + indexer cache.Indexer + namespace string +} + +// List lists all Experiments in the indexer for a given namespace. +func (s experimentNamespaceLister) List(selector labels.Selector) (ret []*v1alpha1.Experiment, err error) { + err = cache.ListAllByNamespace(s.indexer, s.namespace, selector, func(m interface{}) { + ret = append(ret, m.(*v1alpha1.Experiment)) + }) + return ret, err +} + +// Get retrieves the Experiment from the indexer for a given namespace and name. +func (s experimentNamespaceLister) Get(name string) (*v1alpha1.Experiment, error) { + obj, exists, err := s.indexer.GetByKey(s.namespace + "/" + name) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(v1alpha1.Resource("experiment"), name) + } + return obj.(*v1alpha1.Experiment), nil +} diff --git a/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/listers/rollouts/v1alpha1/rollout.go b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/listers/rollouts/v1alpha1/rollout.go new file mode 100644 index 000000000000..9ec741769f1b --- /dev/null +++ b/vertical-pod-autoscaler/vendor/github.com/argoproj/argo-rollouts/pkg/client/listers/rollouts/v1alpha1/rollout.go @@ -0,0 +1,99 @@ +/* +Copyright The Kubernetes 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 lister-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + v1alpha1 "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1" + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/client-go/tools/cache" +) + +// RolloutLister helps list Rollouts. +// All objects returned here must be treated as read-only. +type RolloutLister interface { + // List lists all Rollouts in the indexer. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v1alpha1.Rollout, err error) + // Rollouts returns an object that can list and get Rollouts. + Rollouts(namespace string) RolloutNamespaceLister + RolloutListerExpansion +} + +// rolloutLister implements the RolloutLister interface. +type rolloutLister struct { + indexer cache.Indexer +} + +// NewRolloutLister returns a new RolloutLister. +func NewRolloutLister(indexer cache.Indexer) RolloutLister { + return &rolloutLister{indexer: indexer} +} + +// List lists all Rollouts in the indexer. +func (s *rolloutLister) List(selector labels.Selector) (ret []*v1alpha1.Rollout, err error) { + err = cache.ListAll(s.indexer, selector, func(m interface{}) { + ret = append(ret, m.(*v1alpha1.Rollout)) + }) + return ret, err +} + +// Rollouts returns an object that can list and get Rollouts. +func (s *rolloutLister) Rollouts(namespace string) RolloutNamespaceLister { + return rolloutNamespaceLister{indexer: s.indexer, namespace: namespace} +} + +// RolloutNamespaceLister helps list and get Rollouts. +// All objects returned here must be treated as read-only. +type RolloutNamespaceLister interface { + // List lists all Rollouts in the indexer for a given namespace. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v1alpha1.Rollout, err error) + // Get retrieves the Rollout from the indexer for a given namespace and name. + // Objects returned here must be treated as read-only. + Get(name string) (*v1alpha1.Rollout, error) + RolloutNamespaceListerExpansion +} + +// rolloutNamespaceLister implements the RolloutNamespaceLister +// interface. +type rolloutNamespaceLister struct { + indexer cache.Indexer + namespace string +} + +// List lists all Rollouts in the indexer for a given namespace. +func (s rolloutNamespaceLister) List(selector labels.Selector) (ret []*v1alpha1.Rollout, err error) { + err = cache.ListAllByNamespace(s.indexer, s.namespace, selector, func(m interface{}) { + ret = append(ret, m.(*v1alpha1.Rollout)) + }) + return ret, err +} + +// Get retrieves the Rollout from the indexer for a given namespace and name. +func (s rolloutNamespaceLister) Get(name string) (*v1alpha1.Rollout, error) { + obj, exists, err := s.indexer.GetByKey(s.namespace + "/" + name) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(v1alpha1.Resource("rollout"), name) + } + return obj.(*v1alpha1.Rollout), nil +} diff --git a/vertical-pod-autoscaler/vendor/github.com/evanphx/json-patch/patch.go b/vertical-pod-autoscaler/vendor/github.com/evanphx/json-patch/patch.go index dc2b7e51e60b..4bce5936d502 100644 --- a/vertical-pod-autoscaler/vendor/github.com/evanphx/json-patch/patch.go +++ b/vertical-pod-autoscaler/vendor/github.com/evanphx/json-patch/patch.go @@ -568,29 +568,6 @@ func (p Patch) replace(doc *container, op Operation) error { return errors.Wrapf(err, "replace operation failed to decode path") } - if path == "" { - val := op.value() - - if val.which == eRaw { - if !val.tryDoc() { - if !val.tryAry() { - return errors.Wrapf(err, "replace operation value must be object or array") - } - } - } - - switch val.which { - case eAry: - *doc = &val.ary - case eDoc: - *doc = &val.doc - case eRaw: - return errors.Wrapf(err, "replace operation hit impossible case") - } - - return nil - } - con, key := findObject(doc, path) if con == nil { @@ -657,25 +634,6 @@ func (p Patch) test(doc *container, op Operation) error { return errors.Wrapf(err, "test operation failed to decode path") } - if path == "" { - var self lazyNode - - switch sv := (*doc).(type) { - case *partialDoc: - self.doc = *sv - self.which = eDoc - case *partialArray: - self.ary = *sv - self.which = eAry - } - - if self.equal(op.value()) { - return nil - } - - return errors.Wrapf(ErrTestFailed, "testing value %s failed", path) - } - con, key := findObject(doc, path) if con == nil { diff --git a/vertical-pod-autoscaler/vendor/github.com/imdario/mergo/.deepsource.toml b/vertical-pod-autoscaler/vendor/github.com/imdario/mergo/.deepsource.toml new file mode 100644 index 000000000000..8a0681af8559 --- /dev/null +++ b/vertical-pod-autoscaler/vendor/github.com/imdario/mergo/.deepsource.toml @@ -0,0 +1,12 @@ +version = 1 + +test_patterns = [ + "*_test.go" +] + +[[analyzers]] +name = "go" +enabled = true + + [analyzers.meta] + import_path = "github.com/imdario/mergo" \ No newline at end of file diff --git a/vertical-pod-autoscaler/vendor/github.com/imdario/mergo/.travis.yml b/vertical-pod-autoscaler/vendor/github.com/imdario/mergo/.travis.yml index b13a50ed1fb8..d324c43ba4df 100644 --- a/vertical-pod-autoscaler/vendor/github.com/imdario/mergo/.travis.yml +++ b/vertical-pod-autoscaler/vendor/github.com/imdario/mergo/.travis.yml @@ -1,7 +1,12 @@ language: go +arch: + - amd64 + - ppc64le install: - go get -t - go get golang.org/x/tools/cmd/cover - go get github.com/mattn/goveralls script: + - go test -race -v ./... +after_script: - $HOME/gopath/bin/goveralls -service=travis-ci -repotoken $COVERALLS_TOKEN diff --git a/vertical-pod-autoscaler/vendor/github.com/imdario/mergo/README.md b/vertical-pod-autoscaler/vendor/github.com/imdario/mergo/README.md index 8b76f1fbf33a..7e6f7aeee82e 100644 --- a/vertical-pod-autoscaler/vendor/github.com/imdario/mergo/README.md +++ b/vertical-pod-autoscaler/vendor/github.com/imdario/mergo/README.md @@ -1,51 +1,61 @@ # Mergo -A helper to merge structs and maps in Golang. Useful for configuration default values, avoiding messy if-statements. - -Also a lovely [comune](http://en.wikipedia.org/wiki/Mergo) (municipality) in the Province of Ancona in the Italian region of Marche. - -## Status - -It is ready for production use. [It is used in several projects by Docker, Google, The Linux Foundation, VMWare, Shopify, etc](https://github.com/imdario/mergo#mergo-in-the-wild). [![GoDoc][3]][4] -[![GoCard][5]][6] +[![GitHub release][5]][6] +[![GoCard][7]][8] [![Build Status][1]][2] -[![Coverage Status][7]][8] -[![Sourcegraph][9]][10] +[![Coverage Status][9]][10] +[![Sourcegraph][11]][12] +[![FOSSA Status][13]][14] +[![Become my sponsor][15]][16] [1]: https://travis-ci.org/imdario/mergo.png [2]: https://travis-ci.org/imdario/mergo [3]: https://godoc.org/github.com/imdario/mergo?status.svg [4]: https://godoc.org/github.com/imdario/mergo -[5]: https://goreportcard.com/badge/imdario/mergo -[6]: https://goreportcard.com/report/github.com/imdario/mergo -[7]: https://coveralls.io/repos/github/imdario/mergo/badge.svg?branch=master -[8]: https://coveralls.io/github/imdario/mergo?branch=master -[9]: https://sourcegraph.com/github.com/imdario/mergo/-/badge.svg -[10]: https://sourcegraph.com/github.com/imdario/mergo?badge +[5]: https://img.shields.io/github/release/imdario/mergo.svg +[6]: https://github.com/imdario/mergo/releases +[7]: https://goreportcard.com/badge/imdario/mergo +[8]: https://goreportcard.com/report/github.com/imdario/mergo +[9]: https://coveralls.io/repos/github/imdario/mergo/badge.svg?branch=master +[10]: https://coveralls.io/github/imdario/mergo?branch=master +[11]: https://sourcegraph.com/github.com/imdario/mergo/-/badge.svg +[12]: https://sourcegraph.com/github.com/imdario/mergo?badge +[13]: https://app.fossa.io/api/projects/git%2Bgithub.com%2Fimdario%2Fmergo.svg?type=shield +[14]: https://app.fossa.io/projects/git%2Bgithub.com%2Fimdario%2Fmergo?ref=badge_shield +[15]: https://img.shields.io/github/sponsors/imdario +[16]: https://github.com/sponsors/imdario + +A helper to merge structs and maps in Golang. Useful for configuration default values, avoiding messy if-statements. -### Latest release +Mergo merges same-type structs and maps by setting default values in zero-value fields. Mergo won't merge unexported (private) fields. It will do recursively any exported one. It also won't merge structs inside maps (because they are not addressable using Go reflection). -[Release v0.3.6](https://github.com/imdario/mergo/releases/tag/v0.3.6). +Also a lovely [comune](http://en.wikipedia.org/wiki/Mergo) (municipality) in the Province of Ancona in the Italian region of Marche. + +## Status + +It is ready for production use. [It is used in several projects by Docker, Google, The Linux Foundation, VMWare, Shopify, Microsoft, etc](https://github.com/imdario/mergo#mergo-in-the-wild). ### Important note -Please keep in mind that in [0.3.2](//github.com/imdario/mergo/releases/tag/0.3.2) Mergo changed `Merge()`and `Map()` signatures to support [transformers](#transformers). An optional/variadic argument has been added, so it won't break existing code. +Please keep in mind that a problematic PR broke [0.3.9](//github.com/imdario/mergo/releases/tag/0.3.9). I reverted it in [0.3.10](//github.com/imdario/mergo/releases/tag/0.3.10), and I consider it stable but not bug-free. Also, this version adds support for go modules. + +Keep in mind that in [0.3.2](//github.com/imdario/mergo/releases/tag/0.3.2), Mergo changed `Merge()`and `Map()` signatures to support [transformers](#transformers). I added an optional/variadic argument so that it won't break the existing code. -If you were using Mergo **before** April 6th 2015, please check your project works as intended after updating your local copy with ```go get -u github.com/imdario/mergo```. I apologize for any issue caused by its previous behavior and any future bug that Mergo could cause (I hope it won't!) in existing projects after the change (release 0.2.0). +If you were using Mergo before April 6th, 2015, please check your project works as intended after updating your local copy with ```go get -u github.com/imdario/mergo```. I apologize for any issue caused by its previous behavior and any future bug that Mergo could cause in existing projects after the change (release 0.2.0). ### Donations -If Mergo is useful to you, consider buying me a coffee, a beer or making a monthly donation so I can keep building great free software. :heart_eyes: +If Mergo is useful to you, consider buying me a coffee, a beer, or making a monthly donation to allow me to keep building great free software. :heart_eyes: Buy Me a Coffee at ko-fi.com -[![Beerpay](https://beerpay.io/imdario/mergo/badge.svg)](https://beerpay.io/imdario/mergo) -[![Beerpay](https://beerpay.io/imdario/mergo/make-wish.svg)](https://beerpay.io/imdario/mergo) Donate using Liberapay +Become my sponsor ### Mergo in the wild +- [cli/cli](https://github.com/cli/cli) - [moby/moby](https://github.com/moby/moby) - [kubernetes/kubernetes](https://github.com/kubernetes/kubernetes) - [vmware/dispatch](https://github.com/vmware/dispatch) @@ -86,8 +96,11 @@ If Mergo is useful to you, consider buying me a coffee, a beer or making a month - [mantasmatelis/whooplist-server](https://github.com/mantasmatelis/whooplist-server) - [jnuthong/item_search](https://github.com/jnuthong/item_search) - [bukalapak/snowboard](https://github.com/bukalapak/snowboard) +- [containerssh/containerssh](https://github.com/containerssh/containerssh) +- [goreleaser/goreleaser](https://github.com/goreleaser/goreleaser) +- [tjpnz/structbot](https://github.com/tjpnz/structbot) -## Installation +## Install go get github.com/imdario/mergo @@ -98,7 +111,7 @@ If Mergo is useful to you, consider buying me a coffee, a beer or making a month ## Usage -You can only merge same-type structs with exported fields initialized as zero value of their type and same-types maps. Mergo won't merge unexported (private) fields but will do recursively any exported one. It won't merge empty structs value as [they are not considered zero values](https://golang.org/ref/spec#The_zero_value) either. Also maps will be merged recursively except for structs inside maps (because they are not addressable using Go reflection). +You can only merge same-type structs with exported fields initialized as zero value of their type and same-types maps. Mergo won't merge unexported (private) fields but will do recursively any exported one. It won't merge empty structs value as [they are zero values](https://golang.org/ref/spec#The_zero_value) too. Also, maps will be merged recursively except for structs inside maps (because they are not addressable using Go reflection). ```go if err := mergo.Merge(&dst, src); err != nil { @@ -124,9 +137,7 @@ if err := mergo.Map(&dst, srcMap); err != nil { Warning: if you map a struct to map, it won't do it recursively. Don't expect Mergo to map struct members of your struct as `map[string]interface{}`. They will be just assigned as values. -More information and examples in [godoc documentation](http://godoc.org/github.com/imdario/mergo). - -### Nice example +Here is a nice example: ```go package main @@ -158,7 +169,7 @@ func main() { Note: if test are failing due missing package, please execute: - go get gopkg.in/yaml.v2 + go get gopkg.in/yaml.v3 ### Transformers @@ -174,10 +185,10 @@ import ( "time" ) -type timeTransfomer struct { +type timeTransformer struct { } -func (t timeTransfomer) Transformer(typ reflect.Type) func(dst, src reflect.Value) error { +func (t timeTransformer) Transformer(typ reflect.Type) func(dst, src reflect.Value) error { if typ == reflect.TypeOf(time.Time{}) { return func(dst, src reflect.Value) error { if dst.CanSet() { @@ -201,14 +212,13 @@ type Snapshot struct { func main() { src := Snapshot{time.Now()} dest := Snapshot{} - mergo.Merge(&dest, src, mergo.WithTransformers(timeTransfomer{})) + mergo.Merge(&dest, src, mergo.WithTransformers(timeTransformer{})) fmt.Println(dest) // Will print // { 2018-01-12 01:15:00 +0000 UTC m=+0.000000001 } } ``` - ## Contact me If I can help you, you have an idea or you are using Mergo in your projects, don't hesitate to drop me a line (or a pull request): [@im_dario](https://twitter.com/im_dario) @@ -220,3 +230,6 @@ Written by [Dario Castañé](http://dario.im). ## License [BSD 3-Clause](http://opensource.org/licenses/BSD-3-Clause) license, as [Go language](http://golang.org/LICENSE). + + +[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fimdario%2Fmergo.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2Fimdario%2Fmergo?ref=badge_large) diff --git a/vertical-pod-autoscaler/vendor/github.com/imdario/mergo/doc.go b/vertical-pod-autoscaler/vendor/github.com/imdario/mergo/doc.go index 6e9aa7baf354..fcd985f995dc 100644 --- a/vertical-pod-autoscaler/vendor/github.com/imdario/mergo/doc.go +++ b/vertical-pod-autoscaler/vendor/github.com/imdario/mergo/doc.go @@ -4,41 +4,140 @@ // license that can be found in the LICENSE file. /* -Package mergo merges same-type structs and maps by setting default values in zero-value fields. +A helper to merge structs and maps in Golang. Useful for configuration default values, avoiding messy if-statements. -Mergo won't merge unexported (private) fields but will do recursively any exported one. It also won't merge structs inside maps (because they are not addressable using Go reflection). +Mergo merges same-type structs and maps by setting default values in zero-value fields. Mergo won't merge unexported (private) fields. It will do recursively any exported one. It also won't merge structs inside maps (because they are not addressable using Go reflection). + +Status + +It is ready for production use. It is used in several projects by Docker, Google, The Linux Foundation, VMWare, Shopify, etc. + +Important note + +Please keep in mind that a problematic PR broke 0.3.9. We reverted it in 0.3.10. We consider 0.3.10 as stable but not bug-free. . Also, this version adds suppot for go modules. + +Keep in mind that in 0.3.2, Mergo changed Merge() and Map() signatures to support transformers. We added an optional/variadic argument so that it won't break the existing code. + +If you were using Mergo before April 6th, 2015, please check your project works as intended after updating your local copy with go get -u github.com/imdario/mergo. I apologize for any issue caused by its previous behavior and any future bug that Mergo could cause in existing projects after the change (release 0.2.0). + +Install + +Do your usual installation procedure: + + go get github.com/imdario/mergo + + // use in your .go code + import ( + "github.com/imdario/mergo" + ) Usage -From my own work-in-progress project: +You can only merge same-type structs with exported fields initialized as zero value of their type and same-types maps. Mergo won't merge unexported (private) fields but will do recursively any exported one. It won't merge empty structs value as they are zero values too. Also, maps will be merged recursively except for structs inside maps (because they are not addressable using Go reflection). + + if err := mergo.Merge(&dst, src); err != nil { + // ... + } + +Also, you can merge overwriting values using the transformer WithOverride. + + if err := mergo.Merge(&dst, src, mergo.WithOverride); err != nil { + // ... + } + +Additionally, you can map a map[string]interface{} to a struct (and otherwise, from struct to map), following the same restrictions as in Merge(). Keys are capitalized to find each corresponding exported field. + + if err := mergo.Map(&dst, srcMap); err != nil { + // ... + } + +Warning: if you map a struct to map, it won't do it recursively. Don't expect Mergo to map struct members of your struct as map[string]interface{}. They will be just assigned as values. + +Here is a nice example: + + package main + + import ( + "fmt" + "github.com/imdario/mergo" + ) - type networkConfig struct { - Protocol string - Address string - ServerType string `json: "server_type"` - Port uint16 + type Foo struct { + A string + B int64 } - type FssnConfig struct { - Network networkConfig + func main() { + src := Foo{ + A: "one", + B: 2, + } + dest := Foo{ + A: "two", + } + mergo.Merge(&dest, src) + fmt.Println(dest) + // Will print + // {two 2} } - var fssnDefault = FssnConfig { - networkConfig { - "tcp", - "127.0.0.1", - "http", - 31560, - }, +Transformers + +Transformers allow to merge specific types differently than in the default behavior. In other words, now you can customize how some types are merged. For example, time.Time is a struct; it doesn't have zero value but IsZero can return true because it has fields with zero value. How can we merge a non-zero time.Time? + + package main + + import ( + "fmt" + "github.com/imdario/mergo" + "reflect" + "time" + ) + + type timeTransformer struct { } - // Inside a function [...] + func (t timeTransformer) Transformer(typ reflect.Type) func(dst, src reflect.Value) error { + if typ == reflect.TypeOf(time.Time{}) { + return func(dst, src reflect.Value) error { + if dst.CanSet() { + isZero := dst.MethodByName("IsZero") + result := isZero.Call([]reflect.Value{}) + if result[0].Bool() { + dst.Set(src) + } + } + return nil + } + } + return nil + } + + type Snapshot struct { + Time time.Time + // ... + } - if err := mergo.Merge(&config, fssnDefault); err != nil { - log.Fatal(err) + func main() { + src := Snapshot{time.Now()} + dest := Snapshot{} + mergo.Merge(&dest, src, mergo.WithTransformers(timeTransformer{})) + fmt.Println(dest) + // Will print + // { 2018-01-12 01:15:00 +0000 UTC m=+0.000000001 } } - // More code [...] +Contact me + +If I can help you, you have an idea or you are using Mergo in your projects, don't hesitate to drop me a line (or a pull request): https://twitter.com/im_dario + +About + +Written by Dario Castañé: https://da.rio.hn + +License + +BSD 3-Clause license, as Go language. */ package mergo diff --git a/vertical-pod-autoscaler/vendor/github.com/imdario/mergo/map.go b/vertical-pod-autoscaler/vendor/github.com/imdario/mergo/map.go index 6ea38e636b64..a13a7ee46c77 100644 --- a/vertical-pod-autoscaler/vendor/github.com/imdario/mergo/map.go +++ b/vertical-pod-autoscaler/vendor/github.com/imdario/mergo/map.go @@ -72,6 +72,7 @@ func deepMap(dst, src reflect.Value, visited map[uintptr]*visit, depth int, conf case reflect.Struct: srcMap := src.Interface().(map[string]interface{}) for key := range srcMap { + config.overwriteWithEmptyValue = true srcValue := srcMap[key] fieldName := changeInitialCase(key, unicode.ToUpper) dstElement := dst.FieldByName(fieldName) @@ -140,6 +141,9 @@ func MapWithOverwrite(dst, src interface{}, opts ...func(*Config)) error { } func _map(dst, src interface{}, opts ...func(*Config)) error { + if dst != nil && reflect.ValueOf(dst).Kind() != reflect.Ptr { + return ErrNonPointerAgument + } var ( vDst, vSrc reflect.Value err error diff --git a/vertical-pod-autoscaler/vendor/github.com/imdario/mergo/merge.go b/vertical-pod-autoscaler/vendor/github.com/imdario/mergo/merge.go index 44f70a89d919..8b4e2f47a08c 100644 --- a/vertical-pod-autoscaler/vendor/github.com/imdario/mergo/merge.go +++ b/vertical-pod-autoscaler/vendor/github.com/imdario/mergo/merge.go @@ -13,22 +13,39 @@ import ( "reflect" ) -func hasExportedField(dst reflect.Value) (exported bool) { +func hasMergeableFields(dst reflect.Value) (exported bool) { for i, n := 0, dst.NumField(); i < n; i++ { field := dst.Type().Field(i) if field.Anonymous && dst.Field(i).Kind() == reflect.Struct { - exported = exported || hasExportedField(dst.Field(i)) - } else { + exported = exported || hasMergeableFields(dst.Field(i)) + } else if isExportedComponent(&field) { exported = exported || len(field.PkgPath) == 0 } } return } +func isExportedComponent(field *reflect.StructField) bool { + pkgPath := field.PkgPath + if len(pkgPath) > 0 { + return false + } + c := field.Name[0] + if 'a' <= c && c <= 'z' || c == '_' { + return false + } + return true +} + type Config struct { - Overwrite bool - AppendSlice bool - Transformers Transformers + Overwrite bool + AppendSlice bool + TypeCheck bool + Transformers Transformers + overwriteWithEmptyValue bool + overwriteSliceWithEmptyValue bool + sliceDeepCopy bool + debug bool } type Transformers interface { @@ -40,6 +57,10 @@ type Transformers interface { // short circuiting on recursive types. func deepMerge(dst, src reflect.Value, visited map[uintptr]*visit, depth int, config *Config) (err error) { overwrite := config.Overwrite + typeCheck := config.TypeCheck + overwriteWithEmptySrc := config.overwriteWithEmptyValue + overwriteSliceWithEmptySrc := config.overwriteSliceWithEmptyValue + sliceDeepCopy := config.sliceDeepCopy if !src.IsValid() { return @@ -58,7 +79,7 @@ func deepMerge(dst, src reflect.Value, visited map[uintptr]*visit, depth int, co visited[h] = &visit{addr, typ, seen} } - if config.Transformers != nil && !isEmptyValue(dst) { + if config.Transformers != nil && !isReflectNil(dst) && dst.IsValid() { if fn := config.Transformers.Transformer(dst.Type()); fn != nil { err = fn(dst, src) return @@ -67,21 +88,34 @@ func deepMerge(dst, src reflect.Value, visited map[uintptr]*visit, depth int, co switch dst.Kind() { case reflect.Struct: - if hasExportedField(dst) { + if hasMergeableFields(dst) { for i, n := 0, dst.NumField(); i < n; i++ { if err = deepMerge(dst.Field(i), src.Field(i), visited, depth+1, config); err != nil { return } } } else { - if dst.CanSet() && !isEmptyValue(src) && (overwrite || isEmptyValue(dst)) { + if dst.CanSet() && (isReflectNil(dst) || overwrite) && (!isEmptyValue(src) || overwriteWithEmptySrc) { dst.Set(src) } } case reflect.Map: if dst.IsNil() && !src.IsNil() { - dst.Set(reflect.MakeMap(dst.Type())) + if dst.CanSet() { + dst.Set(reflect.MakeMap(dst.Type())) + } else { + dst = src + return + } } + + if src.Kind() != reflect.Map { + if overwrite { + dst.Set(src) + } + return + } + for _, key := range src.MapKeys() { srcElement := src.MapIndex(key) if !srcElement.IsValid() { @@ -91,6 +125,9 @@ func deepMerge(dst, src reflect.Value, visited map[uintptr]*visit, depth int, co switch srcElement.Kind() { case reflect.Chan, reflect.Func, reflect.Map, reflect.Interface, reflect.Slice: if srcElement.IsNil() { + if overwrite { + dst.SetMapIndex(key, srcElement) + } continue } fallthrough @@ -125,22 +162,43 @@ func deepMerge(dst, src reflect.Value, visited map[uintptr]*visit, depth int, co dstSlice = reflect.ValueOf(dstElement.Interface()) } - if !isEmptyValue(src) && (overwrite || isEmptyValue(dst)) && !config.AppendSlice { + if (!isEmptyValue(src) || overwriteWithEmptySrc || overwriteSliceWithEmptySrc) && (overwrite || isEmptyValue(dst)) && !config.AppendSlice && !sliceDeepCopy { + if typeCheck && srcSlice.Type() != dstSlice.Type() { + return fmt.Errorf("cannot override two slices with different type (%s, %s)", srcSlice.Type(), dstSlice.Type()) + } dstSlice = srcSlice } else if config.AppendSlice { if srcSlice.Type() != dstSlice.Type() { - return fmt.Errorf("cannot append two slice with different type (%s, %s)", srcSlice.Type(), dstSlice.Type()) + return fmt.Errorf("cannot append two slices with different type (%s, %s)", srcSlice.Type(), dstSlice.Type()) } dstSlice = reflect.AppendSlice(dstSlice, srcSlice) + } else if sliceDeepCopy { + i := 0 + for ; i < srcSlice.Len() && i < dstSlice.Len(); i++ { + srcElement := srcSlice.Index(i) + dstElement := dstSlice.Index(i) + + if srcElement.CanInterface() { + srcElement = reflect.ValueOf(srcElement.Interface()) + } + if dstElement.CanInterface() { + dstElement = reflect.ValueOf(dstElement.Interface()) + } + + if err = deepMerge(dstElement, srcElement, visited, depth+1, config); err != nil { + return + } + } + } dst.SetMapIndex(key, dstSlice) } } - if dstElement.IsValid() && reflect.TypeOf(srcElement.Interface()).Kind() == reflect.Map { + if dstElement.IsValid() && !isEmptyValue(dstElement) && (reflect.TypeOf(srcElement.Interface()).Kind() == reflect.Map || reflect.TypeOf(srcElement.Interface()).Kind() == reflect.Slice) { continue } - if srcElement.IsValid() && (overwrite || (!dstElement.IsValid() || isEmptyValue(dstElement))) { + if srcElement.IsValid() && ((srcElement.Kind() != reflect.Ptr && overwrite) || !dstElement.IsValid() || isEmptyValue(dstElement)) { if dst.IsNil() { dst.Set(reflect.MakeMap(dst.Type())) } @@ -151,22 +209,41 @@ func deepMerge(dst, src reflect.Value, visited map[uintptr]*visit, depth int, co if !dst.CanSet() { break } - if !isEmptyValue(src) && (overwrite || isEmptyValue(dst)) && !config.AppendSlice { + if (!isEmptyValue(src) || overwriteWithEmptySrc || overwriteSliceWithEmptySrc) && (overwrite || isEmptyValue(dst)) && !config.AppendSlice && !sliceDeepCopy { dst.Set(src) } else if config.AppendSlice { if src.Type() != dst.Type() { return fmt.Errorf("cannot append two slice with different type (%s, %s)", src.Type(), dst.Type()) } dst.Set(reflect.AppendSlice(dst, src)) + } else if sliceDeepCopy { + for i := 0; i < src.Len() && i < dst.Len(); i++ { + srcElement := src.Index(i) + dstElement := dst.Index(i) + if srcElement.CanInterface() { + srcElement = reflect.ValueOf(srcElement.Interface()) + } + if dstElement.CanInterface() { + dstElement = reflect.ValueOf(dstElement.Interface()) + } + + if err = deepMerge(dstElement, srcElement, visited, depth+1, config); err != nil { + return + } + } } case reflect.Ptr: fallthrough case reflect.Interface: - if src.IsNil() { + if isReflectNil(src) { + if overwriteWithEmptySrc && dst.CanSet() && src.Type().AssignableTo(dst.Type()) { + dst.Set(src) + } break } + if src.Kind() != reflect.Interface { - if dst.IsNil() || overwrite { + if dst.IsNil() || (src.Kind() != reflect.Ptr && overwrite) { if dst.CanSet() && (overwrite || isEmptyValue(dst)) { dst.Set(src) } @@ -183,18 +260,31 @@ func deepMerge(dst, src reflect.Value, visited map[uintptr]*visit, depth int, co } break } + if dst.IsNil() || overwrite { if dst.CanSet() && (overwrite || isEmptyValue(dst)) { dst.Set(src) } - } else if err = deepMerge(dst.Elem(), src.Elem(), visited, depth+1, config); err != nil { - return + break + } + + if dst.Elem().Kind() == src.Elem().Kind() { + if err = deepMerge(dst.Elem(), src.Elem(), visited, depth+1, config); err != nil { + return + } + break } default: - if dst.CanSet() && !isEmptyValue(src) && (overwrite || isEmptyValue(dst)) { - dst.Set(src) + mustSet := (isEmptyValue(dst) || overwrite) && (!isEmptyValue(src) || overwriteWithEmptySrc) + if mustSet { + if dst.CanSet() { + dst.Set(src) + } else { + dst = src + } } } + return } @@ -206,7 +296,7 @@ func Merge(dst, src interface{}, opts ...func(*Config)) error { return merge(dst, src, opts...) } -// MergeWithOverwrite will do the same as Merge except that non-empty dst attributes will be overriden by +// MergeWithOverwrite will do the same as Merge except that non-empty dst attributes will be overridden by // non-empty src attribute values. // Deprecated: use Merge(…) with WithOverride func MergeWithOverwrite(dst, src interface{}, opts ...func(*Config)) error { @@ -225,12 +315,37 @@ func WithOverride(config *Config) { config.Overwrite = true } -// WithAppendSlice will make merge append slices instead of overwriting it +// WithOverwriteWithEmptyValue will make merge override non empty dst attributes with empty src attributes values. +func WithOverwriteWithEmptyValue(config *Config) { + config.Overwrite = true + config.overwriteWithEmptyValue = true +} + +// WithOverrideEmptySlice will make merge override empty dst slice with empty src slice. +func WithOverrideEmptySlice(config *Config) { + config.overwriteSliceWithEmptyValue = true +} + +// WithAppendSlice will make merge append slices instead of overwriting it. func WithAppendSlice(config *Config) { config.AppendSlice = true } +// WithTypeCheck will make merge check types while overwriting it (must be used with WithOverride). +func WithTypeCheck(config *Config) { + config.TypeCheck = true +} + +// WithSliceDeepCopy will merge slice element one by one with Overwrite flag. +func WithSliceDeepCopy(config *Config) { + config.sliceDeepCopy = true + config.Overwrite = true +} + func merge(dst, src interface{}, opts ...func(*Config)) error { + if dst != nil && reflect.ValueOf(dst).Kind() != reflect.Ptr { + return ErrNonPointerAgument + } var ( vDst, vSrc reflect.Value err error @@ -250,3 +365,16 @@ func merge(dst, src interface{}, opts ...func(*Config)) error { } return deepMerge(vDst, vSrc, make(map[uintptr]*visit), 0, config) } + +// IsReflectNil is the reflect value provided nil +func isReflectNil(v reflect.Value) bool { + k := v.Kind() + switch k { + case reflect.Interface, reflect.Slice, reflect.Chan, reflect.Func, reflect.Map, reflect.Ptr: + // Both interface and slice are nil if first word is 0. + // Both are always bigger than a word; assume flagIndir. + return v.IsNil() + default: + return false + } +} diff --git a/vertical-pod-autoscaler/vendor/github.com/imdario/mergo/mergo.go b/vertical-pod-autoscaler/vendor/github.com/imdario/mergo/mergo.go index a82fea2fdccc..9fe362d476aa 100644 --- a/vertical-pod-autoscaler/vendor/github.com/imdario/mergo/mergo.go +++ b/vertical-pod-autoscaler/vendor/github.com/imdario/mergo/mergo.go @@ -17,9 +17,10 @@ import ( var ( ErrNilArguments = errors.New("src and dst must not be nil") ErrDifferentArgumentsTypes = errors.New("src and dst must be of same type") - ErrNotSupported = errors.New("only structs and maps are supported") + ErrNotSupported = errors.New("only structs, maps, and slices are supported") ErrExpectedMapAsDestination = errors.New("dst was expected to be a map") ErrExpectedStructAsDestination = errors.New("dst was expected to be a struct") + ErrNonPointerAgument = errors.New("dst must be a pointer") ) // During deepMerge, must keep track of checks that are @@ -64,7 +65,7 @@ func resolveValues(dst, src interface{}) (vDst, vSrc reflect.Value, err error) { return } vDst = reflect.ValueOf(dst).Elem() - if vDst.Kind() != reflect.Struct && vDst.Kind() != reflect.Map { + if vDst.Kind() != reflect.Struct && vDst.Kind() != reflect.Map && vDst.Kind() != reflect.Slice { err = ErrNotSupported return } @@ -75,23 +76,3 @@ func resolveValues(dst, src interface{}) (vDst, vSrc reflect.Value, err error) { } return } - -// Traverses recursively both values, assigning src's fields values to dst. -// The map argument tracks comparisons that have already been seen, which allows -// short circuiting on recursive types. -func deeper(dst, src reflect.Value, visited map[uintptr]*visit, depth int) (err error) { - if dst.CanAddr() { - addr := dst.UnsafeAddr() - h := 17 * addr - seen := visited[h] - typ := dst.Type() - for p := seen; p != nil; p = p.next { - if p.ptr == addr && p.typ == typ { - return nil - } - } - // Remember, remember... - visited[h] = &visit{addr, typ, seen} - } - return // TODO refactor -} diff --git a/vertical-pod-autoscaler/vendor/github.com/stretchr/testify/assert/assertion_compare.go b/vertical-pod-autoscaler/vendor/github.com/stretchr/testify/assert/assertion_compare.go index 95d8e59da69b..b774da88d86c 100644 --- a/vertical-pod-autoscaler/vendor/github.com/stretchr/testify/assert/assertion_compare.go +++ b/vertical-pod-autoscaler/vendor/github.com/stretchr/testify/assert/assertion_compare.go @@ -352,9 +352,9 @@ func compare(obj1, obj2 interface{}, kind reflect.Kind) (CompareType, bool) { // Greater asserts that the first element is greater than the second // -// assert.Greater(t, 2, 1) -// assert.Greater(t, float64(2), float64(1)) -// assert.Greater(t, "b", "a") +// assert.Greater(t, 2, 1) +// assert.Greater(t, float64(2), float64(1)) +// assert.Greater(t, "b", "a") func Greater(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -364,10 +364,10 @@ func Greater(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface // GreaterOrEqual asserts that the first element is greater than or equal to the second // -// assert.GreaterOrEqual(t, 2, 1) -// assert.GreaterOrEqual(t, 2, 2) -// assert.GreaterOrEqual(t, "b", "a") -// assert.GreaterOrEqual(t, "b", "b") +// assert.GreaterOrEqual(t, 2, 1) +// assert.GreaterOrEqual(t, 2, 2) +// assert.GreaterOrEqual(t, "b", "a") +// assert.GreaterOrEqual(t, "b", "b") func GreaterOrEqual(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -377,9 +377,9 @@ func GreaterOrEqual(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...in // Less asserts that the first element is less than the second // -// assert.Less(t, 1, 2) -// assert.Less(t, float64(1), float64(2)) -// assert.Less(t, "a", "b") +// assert.Less(t, 1, 2) +// assert.Less(t, float64(1), float64(2)) +// assert.Less(t, "a", "b") func Less(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -389,10 +389,10 @@ func Less(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) // LessOrEqual asserts that the first element is less than or equal to the second // -// assert.LessOrEqual(t, 1, 2) -// assert.LessOrEqual(t, 2, 2) -// assert.LessOrEqual(t, "a", "b") -// assert.LessOrEqual(t, "b", "b") +// assert.LessOrEqual(t, 1, 2) +// assert.LessOrEqual(t, 2, 2) +// assert.LessOrEqual(t, "a", "b") +// assert.LessOrEqual(t, "b", "b") func LessOrEqual(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -402,8 +402,8 @@ func LessOrEqual(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...inter // Positive asserts that the specified element is positive // -// assert.Positive(t, 1) -// assert.Positive(t, 1.23) +// assert.Positive(t, 1) +// assert.Positive(t, 1.23) func Positive(t TestingT, e interface{}, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -414,8 +414,8 @@ func Positive(t TestingT, e interface{}, msgAndArgs ...interface{}) bool { // Negative asserts that the specified element is negative // -// assert.Negative(t, -1) -// assert.Negative(t, -1.23) +// assert.Negative(t, -1) +// assert.Negative(t, -1.23) func Negative(t TestingT, e interface{}, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() diff --git a/vertical-pod-autoscaler/vendor/github.com/stretchr/testify/assert/assertion_format.go b/vertical-pod-autoscaler/vendor/github.com/stretchr/testify/assert/assertion_format.go index 7880b8f94333..84dbd6c790b9 100644 --- a/vertical-pod-autoscaler/vendor/github.com/stretchr/testify/assert/assertion_format.go +++ b/vertical-pod-autoscaler/vendor/github.com/stretchr/testify/assert/assertion_format.go @@ -22,9 +22,9 @@ func Conditionf(t TestingT, comp Comparison, msg string, args ...interface{}) bo // Containsf asserts that the specified string, list(array, slice...) or map contains the // specified substring or element. // -// assert.Containsf(t, "Hello World", "World", "error message %s", "formatted") -// assert.Containsf(t, ["Hello", "World"], "World", "error message %s", "formatted") -// assert.Containsf(t, {"Hello": "World"}, "Hello", "error message %s", "formatted") +// assert.Containsf(t, "Hello World", "World", "error message %s", "formatted") +// assert.Containsf(t, ["Hello", "World"], "World", "error message %s", "formatted") +// assert.Containsf(t, {"Hello": "World"}, "Hello", "error message %s", "formatted") func Containsf(t TestingT, s interface{}, contains interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -56,7 +56,7 @@ func ElementsMatchf(t TestingT, listA interface{}, listB interface{}, msg string // Emptyf asserts that the specified object is empty. I.e. nil, "", false, 0 or either // a slice or a channel with len == 0. // -// assert.Emptyf(t, obj, "error message %s", "formatted") +// assert.Emptyf(t, obj, "error message %s", "formatted") func Emptyf(t TestingT, object interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -66,7 +66,7 @@ func Emptyf(t TestingT, object interface{}, msg string, args ...interface{}) boo // Equalf asserts that two objects are equal. // -// assert.Equalf(t, 123, 123, "error message %s", "formatted") +// assert.Equalf(t, 123, 123, "error message %s", "formatted") // // Pointer variable equality is determined based on the equality of the // referenced values (as opposed to the memory addresses). Function equality @@ -81,8 +81,8 @@ func Equalf(t TestingT, expected interface{}, actual interface{}, msg string, ar // EqualErrorf asserts that a function returned an error (i.e. not `nil`) // and that it is equal to the provided error. // -// actualObj, err := SomeFunction() -// assert.EqualErrorf(t, err, expectedErrorString, "error message %s", "formatted") +// actualObj, err := SomeFunction() +// assert.EqualErrorf(t, err, expectedErrorString, "error message %s", "formatted") func EqualErrorf(t TestingT, theError error, errString string, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -90,10 +90,27 @@ func EqualErrorf(t TestingT, theError error, errString string, msg string, args return EqualError(t, theError, errString, append([]interface{}{msg}, args...)...) } +// EqualExportedValuesf asserts that the types of two objects are equal and their public +// fields are also equal. This is useful for comparing structs that have private fields +// that could potentially differ. +// +// type S struct { +// Exported int +// notExported int +// } +// assert.EqualExportedValuesf(t, S{1, 2}, S{1, 3}, "error message %s", "formatted") => true +// assert.EqualExportedValuesf(t, S{1, 2}, S{2, 3}, "error message %s", "formatted") => false +func EqualExportedValuesf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return EqualExportedValues(t, expected, actual, append([]interface{}{msg}, args...)...) +} + // EqualValuesf asserts that two objects are equal or convertable to the same types // and equal. // -// assert.EqualValuesf(t, uint32(123), int32(123), "error message %s", "formatted") +// assert.EqualValuesf(t, uint32(123), int32(123), "error message %s", "formatted") func EqualValuesf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -103,10 +120,10 @@ func EqualValuesf(t TestingT, expected interface{}, actual interface{}, msg stri // Errorf asserts that a function returned an error (i.e. not `nil`). // -// actualObj, err := SomeFunction() -// if assert.Errorf(t, err, "error message %s", "formatted") { -// assert.Equal(t, expectedErrorf, err) -// } +// actualObj, err := SomeFunction() +// if assert.Errorf(t, err, "error message %s", "formatted") { +// assert.Equal(t, expectedErrorf, err) +// } func Errorf(t TestingT, err error, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -126,8 +143,8 @@ func ErrorAsf(t TestingT, err error, target interface{}, msg string, args ...int // ErrorContainsf asserts that a function returned an error (i.e. not `nil`) // and that the error contains the specified substring. // -// actualObj, err := SomeFunction() -// assert.ErrorContainsf(t, err, expectedErrorSubString, "error message %s", "formatted") +// actualObj, err := SomeFunction() +// assert.ErrorContainsf(t, err, expectedErrorSubString, "error message %s", "formatted") func ErrorContainsf(t TestingT, theError error, contains string, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -147,7 +164,7 @@ func ErrorIsf(t TestingT, err error, target error, msg string, args ...interface // Eventuallyf asserts that given condition will be met in waitFor time, // periodically checking target function each tick. // -// assert.Eventuallyf(t, func() bool { return true; }, time.Second, 10*time.Millisecond, "error message %s", "formatted") +// assert.Eventuallyf(t, func() bool { return true; }, time.Second, 10*time.Millisecond, "error message %s", "formatted") func Eventuallyf(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -155,9 +172,34 @@ func Eventuallyf(t TestingT, condition func() bool, waitFor time.Duration, tick return Eventually(t, condition, waitFor, tick, append([]interface{}{msg}, args...)...) } +// EventuallyWithTf asserts that given condition will be met in waitFor time, +// periodically checking target function each tick. In contrast to Eventually, +// it supplies a CollectT to the condition function, so that the condition +// function can use the CollectT to call other assertions. +// The condition is considered "met" if no errors are raised in a tick. +// The supplied CollectT collects all errors from one tick (if there are any). +// If the condition is not met before waitFor, the collected errors of +// the last tick are copied to t. +// +// externalValue := false +// go func() { +// time.Sleep(8*time.Second) +// externalValue = true +// }() +// assert.EventuallyWithTf(t, func(c *assert.CollectT, "error message %s", "formatted") { +// // add assertions as needed; any assertion failure will fail the current tick +// assert.True(c, externalValue, "expected 'externalValue' to be true") +// }, 1*time.Second, 10*time.Second, "external state has not changed to 'true'; still false") +func EventuallyWithTf(t TestingT, condition func(collect *CollectT), waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return EventuallyWithT(t, condition, waitFor, tick, append([]interface{}{msg}, args...)...) +} + // Exactlyf asserts that two objects are equal in value and type. // -// assert.Exactlyf(t, int32(123), int64(123), "error message %s", "formatted") +// assert.Exactlyf(t, int32(123), int64(123), "error message %s", "formatted") func Exactlyf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -183,7 +225,7 @@ func FailNowf(t TestingT, failureMessage string, msg string, args ...interface{} // Falsef asserts that the specified value is false. // -// assert.Falsef(t, myBool, "error message %s", "formatted") +// assert.Falsef(t, myBool, "error message %s", "formatted") func Falsef(t TestingT, value bool, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -202,9 +244,9 @@ func FileExistsf(t TestingT, path string, msg string, args ...interface{}) bool // Greaterf asserts that the first element is greater than the second // -// assert.Greaterf(t, 2, 1, "error message %s", "formatted") -// assert.Greaterf(t, float64(2), float64(1), "error message %s", "formatted") -// assert.Greaterf(t, "b", "a", "error message %s", "formatted") +// assert.Greaterf(t, 2, 1, "error message %s", "formatted") +// assert.Greaterf(t, float64(2), float64(1), "error message %s", "formatted") +// assert.Greaterf(t, "b", "a", "error message %s", "formatted") func Greaterf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -214,10 +256,10 @@ func Greaterf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...in // GreaterOrEqualf asserts that the first element is greater than or equal to the second // -// assert.GreaterOrEqualf(t, 2, 1, "error message %s", "formatted") -// assert.GreaterOrEqualf(t, 2, 2, "error message %s", "formatted") -// assert.GreaterOrEqualf(t, "b", "a", "error message %s", "formatted") -// assert.GreaterOrEqualf(t, "b", "b", "error message %s", "formatted") +// assert.GreaterOrEqualf(t, 2, 1, "error message %s", "formatted") +// assert.GreaterOrEqualf(t, 2, 2, "error message %s", "formatted") +// assert.GreaterOrEqualf(t, "b", "a", "error message %s", "formatted") +// assert.GreaterOrEqualf(t, "b", "b", "error message %s", "formatted") func GreaterOrEqualf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -228,7 +270,7 @@ func GreaterOrEqualf(t TestingT, e1 interface{}, e2 interface{}, msg string, arg // HTTPBodyContainsf asserts that a specified handler returns a // body that contains a string. // -// assert.HTTPBodyContainsf(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted") +// assert.HTTPBodyContainsf(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted") // // Returns whether the assertion was successful (true) or not (false). func HTTPBodyContainsf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) bool { @@ -241,7 +283,7 @@ func HTTPBodyContainsf(t TestingT, handler http.HandlerFunc, method string, url // HTTPBodyNotContainsf asserts that a specified handler returns a // body that does not contain a string. // -// assert.HTTPBodyNotContainsf(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted") +// assert.HTTPBodyNotContainsf(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted") // // Returns whether the assertion was successful (true) or not (false). func HTTPBodyNotContainsf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) bool { @@ -253,7 +295,7 @@ func HTTPBodyNotContainsf(t TestingT, handler http.HandlerFunc, method string, u // HTTPErrorf asserts that a specified handler returns an error status code. // -// assert.HTTPErrorf(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}} +// assert.HTTPErrorf(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}} // // Returns whether the assertion was successful (true) or not (false). func HTTPErrorf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool { @@ -265,7 +307,7 @@ func HTTPErrorf(t TestingT, handler http.HandlerFunc, method string, url string, // HTTPRedirectf asserts that a specified handler returns a redirect status code. // -// assert.HTTPRedirectf(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}} +// assert.HTTPRedirectf(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}} // // Returns whether the assertion was successful (true) or not (false). func HTTPRedirectf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool { @@ -277,7 +319,7 @@ func HTTPRedirectf(t TestingT, handler http.HandlerFunc, method string, url stri // HTTPStatusCodef asserts that a specified handler returns a specified status code. // -// assert.HTTPStatusCodef(t, myHandler, "GET", "/notImplemented", nil, 501, "error message %s", "formatted") +// assert.HTTPStatusCodef(t, myHandler, "GET", "/notImplemented", nil, 501, "error message %s", "formatted") // // Returns whether the assertion was successful (true) or not (false). func HTTPStatusCodef(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msg string, args ...interface{}) bool { @@ -289,7 +331,7 @@ func HTTPStatusCodef(t TestingT, handler http.HandlerFunc, method string, url st // HTTPSuccessf asserts that a specified handler returns a success status code. // -// assert.HTTPSuccessf(t, myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted") +// assert.HTTPSuccessf(t, myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted") // // Returns whether the assertion was successful (true) or not (false). func HTTPSuccessf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool { @@ -301,7 +343,7 @@ func HTTPSuccessf(t TestingT, handler http.HandlerFunc, method string, url strin // Implementsf asserts that an object is implemented by the specified interface. // -// assert.Implementsf(t, (*MyInterface)(nil), new(MyObject), "error message %s", "formatted") +// assert.Implementsf(t, (*MyInterface)(nil), new(MyObject), "error message %s", "formatted") func Implementsf(t TestingT, interfaceObject interface{}, object interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -311,7 +353,7 @@ func Implementsf(t TestingT, interfaceObject interface{}, object interface{}, ms // InDeltaf asserts that the two numerals are within delta of each other. // -// assert.InDeltaf(t, math.Pi, 22/7.0, 0.01, "error message %s", "formatted") +// assert.InDeltaf(t, math.Pi, 22/7.0, 0.01, "error message %s", "formatted") func InDeltaf(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -353,9 +395,9 @@ func InEpsilonSlicef(t TestingT, expected interface{}, actual interface{}, epsil // IsDecreasingf asserts that the collection is decreasing // -// assert.IsDecreasingf(t, []int{2, 1, 0}, "error message %s", "formatted") -// assert.IsDecreasingf(t, []float{2, 1}, "error message %s", "formatted") -// assert.IsDecreasingf(t, []string{"b", "a"}, "error message %s", "formatted") +// assert.IsDecreasingf(t, []int{2, 1, 0}, "error message %s", "formatted") +// assert.IsDecreasingf(t, []float{2, 1}, "error message %s", "formatted") +// assert.IsDecreasingf(t, []string{"b", "a"}, "error message %s", "formatted") func IsDecreasingf(t TestingT, object interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -365,9 +407,9 @@ func IsDecreasingf(t TestingT, object interface{}, msg string, args ...interface // IsIncreasingf asserts that the collection is increasing // -// assert.IsIncreasingf(t, []int{1, 2, 3}, "error message %s", "formatted") -// assert.IsIncreasingf(t, []float{1, 2}, "error message %s", "formatted") -// assert.IsIncreasingf(t, []string{"a", "b"}, "error message %s", "formatted") +// assert.IsIncreasingf(t, []int{1, 2, 3}, "error message %s", "formatted") +// assert.IsIncreasingf(t, []float{1, 2}, "error message %s", "formatted") +// assert.IsIncreasingf(t, []string{"a", "b"}, "error message %s", "formatted") func IsIncreasingf(t TestingT, object interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -377,9 +419,9 @@ func IsIncreasingf(t TestingT, object interface{}, msg string, args ...interface // IsNonDecreasingf asserts that the collection is not decreasing // -// assert.IsNonDecreasingf(t, []int{1, 1, 2}, "error message %s", "formatted") -// assert.IsNonDecreasingf(t, []float{1, 2}, "error message %s", "formatted") -// assert.IsNonDecreasingf(t, []string{"a", "b"}, "error message %s", "formatted") +// assert.IsNonDecreasingf(t, []int{1, 1, 2}, "error message %s", "formatted") +// assert.IsNonDecreasingf(t, []float{1, 2}, "error message %s", "formatted") +// assert.IsNonDecreasingf(t, []string{"a", "b"}, "error message %s", "formatted") func IsNonDecreasingf(t TestingT, object interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -389,9 +431,9 @@ func IsNonDecreasingf(t TestingT, object interface{}, msg string, args ...interf // IsNonIncreasingf asserts that the collection is not increasing // -// assert.IsNonIncreasingf(t, []int{2, 1, 1}, "error message %s", "formatted") -// assert.IsNonIncreasingf(t, []float{2, 1}, "error message %s", "formatted") -// assert.IsNonIncreasingf(t, []string{"b", "a"}, "error message %s", "formatted") +// assert.IsNonIncreasingf(t, []int{2, 1, 1}, "error message %s", "formatted") +// assert.IsNonIncreasingf(t, []float{2, 1}, "error message %s", "formatted") +// assert.IsNonIncreasingf(t, []string{"b", "a"}, "error message %s", "formatted") func IsNonIncreasingf(t TestingT, object interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -409,7 +451,7 @@ func IsTypef(t TestingT, expectedType interface{}, object interface{}, msg strin // JSONEqf asserts that two JSON strings are equivalent. // -// assert.JSONEqf(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted") +// assert.JSONEqf(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted") func JSONEqf(t TestingT, expected string, actual string, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -420,7 +462,7 @@ func JSONEqf(t TestingT, expected string, actual string, msg string, args ...int // Lenf asserts that the specified object has specific length. // Lenf also fails if the object has a type that len() not accept. // -// assert.Lenf(t, mySlice, 3, "error message %s", "formatted") +// assert.Lenf(t, mySlice, 3, "error message %s", "formatted") func Lenf(t TestingT, object interface{}, length int, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -430,9 +472,9 @@ func Lenf(t TestingT, object interface{}, length int, msg string, args ...interf // Lessf asserts that the first element is less than the second // -// assert.Lessf(t, 1, 2, "error message %s", "formatted") -// assert.Lessf(t, float64(1), float64(2), "error message %s", "formatted") -// assert.Lessf(t, "a", "b", "error message %s", "formatted") +// assert.Lessf(t, 1, 2, "error message %s", "formatted") +// assert.Lessf(t, float64(1), float64(2), "error message %s", "formatted") +// assert.Lessf(t, "a", "b", "error message %s", "formatted") func Lessf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -442,10 +484,10 @@ func Lessf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...inter // LessOrEqualf asserts that the first element is less than or equal to the second // -// assert.LessOrEqualf(t, 1, 2, "error message %s", "formatted") -// assert.LessOrEqualf(t, 2, 2, "error message %s", "formatted") -// assert.LessOrEqualf(t, "a", "b", "error message %s", "formatted") -// assert.LessOrEqualf(t, "b", "b", "error message %s", "formatted") +// assert.LessOrEqualf(t, 1, 2, "error message %s", "formatted") +// assert.LessOrEqualf(t, 2, 2, "error message %s", "formatted") +// assert.LessOrEqualf(t, "a", "b", "error message %s", "formatted") +// assert.LessOrEqualf(t, "b", "b", "error message %s", "formatted") func LessOrEqualf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -455,8 +497,8 @@ func LessOrEqualf(t TestingT, e1 interface{}, e2 interface{}, msg string, args . // Negativef asserts that the specified element is negative // -// assert.Negativef(t, -1, "error message %s", "formatted") -// assert.Negativef(t, -1.23, "error message %s", "formatted") +// assert.Negativef(t, -1, "error message %s", "formatted") +// assert.Negativef(t, -1.23, "error message %s", "formatted") func Negativef(t TestingT, e interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -467,7 +509,7 @@ func Negativef(t TestingT, e interface{}, msg string, args ...interface{}) bool // Neverf asserts that the given condition doesn't satisfy in waitFor time, // periodically checking the target function each tick. // -// assert.Neverf(t, func() bool { return false; }, time.Second, 10*time.Millisecond, "error message %s", "formatted") +// assert.Neverf(t, func() bool { return false; }, time.Second, 10*time.Millisecond, "error message %s", "formatted") func Neverf(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -477,7 +519,7 @@ func Neverf(t TestingT, condition func() bool, waitFor time.Duration, tick time. // Nilf asserts that the specified object is nil. // -// assert.Nilf(t, err, "error message %s", "formatted") +// assert.Nilf(t, err, "error message %s", "formatted") func Nilf(t TestingT, object interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -496,10 +538,10 @@ func NoDirExistsf(t TestingT, path string, msg string, args ...interface{}) bool // NoErrorf asserts that a function returned no error (i.e. `nil`). // -// actualObj, err := SomeFunction() -// if assert.NoErrorf(t, err, "error message %s", "formatted") { -// assert.Equal(t, expectedObj, actualObj) -// } +// actualObj, err := SomeFunction() +// if assert.NoErrorf(t, err, "error message %s", "formatted") { +// assert.Equal(t, expectedObj, actualObj) +// } func NoErrorf(t TestingT, err error, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -519,9 +561,9 @@ func NoFileExistsf(t TestingT, path string, msg string, args ...interface{}) boo // NotContainsf asserts that the specified string, list(array, slice...) or map does NOT contain the // specified substring or element. // -// assert.NotContainsf(t, "Hello World", "Earth", "error message %s", "formatted") -// assert.NotContainsf(t, ["Hello", "World"], "Earth", "error message %s", "formatted") -// assert.NotContainsf(t, {"Hello": "World"}, "Earth", "error message %s", "formatted") +// assert.NotContainsf(t, "Hello World", "Earth", "error message %s", "formatted") +// assert.NotContainsf(t, ["Hello", "World"], "Earth", "error message %s", "formatted") +// assert.NotContainsf(t, {"Hello": "World"}, "Earth", "error message %s", "formatted") func NotContainsf(t TestingT, s interface{}, contains interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -532,9 +574,9 @@ func NotContainsf(t TestingT, s interface{}, contains interface{}, msg string, a // NotEmptyf asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either // a slice or a channel with len == 0. // -// if assert.NotEmptyf(t, obj, "error message %s", "formatted") { -// assert.Equal(t, "two", obj[1]) -// } +// if assert.NotEmptyf(t, obj, "error message %s", "formatted") { +// assert.Equal(t, "two", obj[1]) +// } func NotEmptyf(t TestingT, object interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -544,7 +586,7 @@ func NotEmptyf(t TestingT, object interface{}, msg string, args ...interface{}) // NotEqualf asserts that the specified values are NOT equal. // -// assert.NotEqualf(t, obj1, obj2, "error message %s", "formatted") +// assert.NotEqualf(t, obj1, obj2, "error message %s", "formatted") // // Pointer variable equality is determined based on the equality of the // referenced values (as opposed to the memory addresses). @@ -557,7 +599,7 @@ func NotEqualf(t TestingT, expected interface{}, actual interface{}, msg string, // NotEqualValuesf asserts that two objects are not equal even when converted to the same type // -// assert.NotEqualValuesf(t, obj1, obj2, "error message %s", "formatted") +// assert.NotEqualValuesf(t, obj1, obj2, "error message %s", "formatted") func NotEqualValuesf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -576,7 +618,7 @@ func NotErrorIsf(t TestingT, err error, target error, msg string, args ...interf // NotNilf asserts that the specified object is not nil. // -// assert.NotNilf(t, err, "error message %s", "formatted") +// assert.NotNilf(t, err, "error message %s", "formatted") func NotNilf(t TestingT, object interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -586,7 +628,7 @@ func NotNilf(t TestingT, object interface{}, msg string, args ...interface{}) bo // NotPanicsf asserts that the code inside the specified PanicTestFunc does NOT panic. // -// assert.NotPanicsf(t, func(){ RemainCalm() }, "error message %s", "formatted") +// assert.NotPanicsf(t, func(){ RemainCalm() }, "error message %s", "formatted") func NotPanicsf(t TestingT, f PanicTestFunc, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -596,8 +638,8 @@ func NotPanicsf(t TestingT, f PanicTestFunc, msg string, args ...interface{}) bo // NotRegexpf asserts that a specified regexp does not match a string. // -// assert.NotRegexpf(t, regexp.MustCompile("starts"), "it's starting", "error message %s", "formatted") -// assert.NotRegexpf(t, "^start", "it's not starting", "error message %s", "formatted") +// assert.NotRegexpf(t, regexp.MustCompile("starts"), "it's starting", "error message %s", "formatted") +// assert.NotRegexpf(t, "^start", "it's not starting", "error message %s", "formatted") func NotRegexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -607,7 +649,7 @@ func NotRegexpf(t TestingT, rx interface{}, str interface{}, msg string, args .. // NotSamef asserts that two pointers do not reference the same object. // -// assert.NotSamef(t, ptr1, ptr2, "error message %s", "formatted") +// assert.NotSamef(t, ptr1, ptr2, "error message %s", "formatted") // // Both arguments must be pointer variables. Pointer variable sameness is // determined based on the equality of both type and value. @@ -621,7 +663,7 @@ func NotSamef(t TestingT, expected interface{}, actual interface{}, msg string, // NotSubsetf asserts that the specified list(array, slice...) contains not all // elements given in the specified subset(array, slice...). // -// assert.NotSubsetf(t, [1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted") +// assert.NotSubsetf(t, [1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted") func NotSubsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -639,7 +681,7 @@ func NotZerof(t TestingT, i interface{}, msg string, args ...interface{}) bool { // Panicsf asserts that the code inside the specified PanicTestFunc panics. // -// assert.Panicsf(t, func(){ GoCrazy() }, "error message %s", "formatted") +// assert.Panicsf(t, func(){ GoCrazy() }, "error message %s", "formatted") func Panicsf(t TestingT, f PanicTestFunc, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -651,7 +693,7 @@ func Panicsf(t TestingT, f PanicTestFunc, msg string, args ...interface{}) bool // panics, and that the recovered panic value is an error that satisfies the // EqualError comparison. // -// assert.PanicsWithErrorf(t, "crazy error", func(){ GoCrazy() }, "error message %s", "formatted") +// assert.PanicsWithErrorf(t, "crazy error", func(){ GoCrazy() }, "error message %s", "formatted") func PanicsWithErrorf(t TestingT, errString string, f PanicTestFunc, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -662,7 +704,7 @@ func PanicsWithErrorf(t TestingT, errString string, f PanicTestFunc, msg string, // PanicsWithValuef asserts that the code inside the specified PanicTestFunc panics, and that // the recovered panic value equals the expected panic value. // -// assert.PanicsWithValuef(t, "crazy error", func(){ GoCrazy() }, "error message %s", "formatted") +// assert.PanicsWithValuef(t, "crazy error", func(){ GoCrazy() }, "error message %s", "formatted") func PanicsWithValuef(t TestingT, expected interface{}, f PanicTestFunc, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -672,8 +714,8 @@ func PanicsWithValuef(t TestingT, expected interface{}, f PanicTestFunc, msg str // Positivef asserts that the specified element is positive // -// assert.Positivef(t, 1, "error message %s", "formatted") -// assert.Positivef(t, 1.23, "error message %s", "formatted") +// assert.Positivef(t, 1, "error message %s", "formatted") +// assert.Positivef(t, 1.23, "error message %s", "formatted") func Positivef(t TestingT, e interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -683,8 +725,8 @@ func Positivef(t TestingT, e interface{}, msg string, args ...interface{}) bool // Regexpf asserts that a specified regexp matches a string. // -// assert.Regexpf(t, regexp.MustCompile("start"), "it's starting", "error message %s", "formatted") -// assert.Regexpf(t, "start...$", "it's not starting", "error message %s", "formatted") +// assert.Regexpf(t, regexp.MustCompile("start"), "it's starting", "error message %s", "formatted") +// assert.Regexpf(t, "start...$", "it's not starting", "error message %s", "formatted") func Regexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -694,7 +736,7 @@ func Regexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...in // Samef asserts that two pointers reference the same object. // -// assert.Samef(t, ptr1, ptr2, "error message %s", "formatted") +// assert.Samef(t, ptr1, ptr2, "error message %s", "formatted") // // Both arguments must be pointer variables. Pointer variable sameness is // determined based on the equality of both type and value. @@ -708,7 +750,7 @@ func Samef(t TestingT, expected interface{}, actual interface{}, msg string, arg // Subsetf asserts that the specified list(array, slice...) contains all // elements given in the specified subset(array, slice...). // -// assert.Subsetf(t, [1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted") +// assert.Subsetf(t, [1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted") func Subsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -718,7 +760,7 @@ func Subsetf(t TestingT, list interface{}, subset interface{}, msg string, args // Truef asserts that the specified value is true. // -// assert.Truef(t, myBool, "error message %s", "formatted") +// assert.Truef(t, myBool, "error message %s", "formatted") func Truef(t TestingT, value bool, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -728,7 +770,7 @@ func Truef(t TestingT, value bool, msg string, args ...interface{}) bool { // WithinDurationf asserts that the two times are within duration delta of each other. // -// assert.WithinDurationf(t, time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted") +// assert.WithinDurationf(t, time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted") func WithinDurationf(t TestingT, expected time.Time, actual time.Time, delta time.Duration, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -738,7 +780,7 @@ func WithinDurationf(t TestingT, expected time.Time, actual time.Time, delta tim // WithinRangef asserts that a time is within a time range (inclusive). // -// assert.WithinRangef(t, time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second), "error message %s", "formatted") +// assert.WithinRangef(t, time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second), "error message %s", "formatted") func WithinRangef(t TestingT, actual time.Time, start time.Time, end time.Time, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() diff --git a/vertical-pod-autoscaler/vendor/github.com/stretchr/testify/assert/assertion_forward.go b/vertical-pod-autoscaler/vendor/github.com/stretchr/testify/assert/assertion_forward.go index 339515b8bfb9..b1d94aec53cc 100644 --- a/vertical-pod-autoscaler/vendor/github.com/stretchr/testify/assert/assertion_forward.go +++ b/vertical-pod-autoscaler/vendor/github.com/stretchr/testify/assert/assertion_forward.go @@ -30,9 +30,9 @@ func (a *Assertions) Conditionf(comp Comparison, msg string, args ...interface{} // Contains asserts that the specified string, list(array, slice...) or map contains the // specified substring or element. // -// a.Contains("Hello World", "World") -// a.Contains(["Hello", "World"], "World") -// a.Contains({"Hello": "World"}, "Hello") +// a.Contains("Hello World", "World") +// a.Contains(["Hello", "World"], "World") +// a.Contains({"Hello": "World"}, "Hello") func (a *Assertions) Contains(s interface{}, contains interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -43,9 +43,9 @@ func (a *Assertions) Contains(s interface{}, contains interface{}, msgAndArgs .. // Containsf asserts that the specified string, list(array, slice...) or map contains the // specified substring or element. // -// a.Containsf("Hello World", "World", "error message %s", "formatted") -// a.Containsf(["Hello", "World"], "World", "error message %s", "formatted") -// a.Containsf({"Hello": "World"}, "Hello", "error message %s", "formatted") +// a.Containsf("Hello World", "World", "error message %s", "formatted") +// a.Containsf(["Hello", "World"], "World", "error message %s", "formatted") +// a.Containsf({"Hello": "World"}, "Hello", "error message %s", "formatted") func (a *Assertions) Containsf(s interface{}, contains interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -98,7 +98,7 @@ func (a *Assertions) ElementsMatchf(listA interface{}, listB interface{}, msg st // Empty asserts that the specified object is empty. I.e. nil, "", false, 0 or either // a slice or a channel with len == 0. // -// a.Empty(obj) +// a.Empty(obj) func (a *Assertions) Empty(object interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -109,7 +109,7 @@ func (a *Assertions) Empty(object interface{}, msgAndArgs ...interface{}) bool { // Emptyf asserts that the specified object is empty. I.e. nil, "", false, 0 or either // a slice or a channel with len == 0. // -// a.Emptyf(obj, "error message %s", "formatted") +// a.Emptyf(obj, "error message %s", "formatted") func (a *Assertions) Emptyf(object interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -119,7 +119,7 @@ func (a *Assertions) Emptyf(object interface{}, msg string, args ...interface{}) // Equal asserts that two objects are equal. // -// a.Equal(123, 123) +// a.Equal(123, 123) // // Pointer variable equality is determined based on the equality of the // referenced values (as opposed to the memory addresses). Function equality @@ -134,8 +134,8 @@ func (a *Assertions) Equal(expected interface{}, actual interface{}, msgAndArgs // EqualError asserts that a function returned an error (i.e. not `nil`) // and that it is equal to the provided error. // -// actualObj, err := SomeFunction() -// a.EqualError(err, expectedErrorString) +// actualObj, err := SomeFunction() +// a.EqualError(err, expectedErrorString) func (a *Assertions) EqualError(theError error, errString string, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -146,8 +146,8 @@ func (a *Assertions) EqualError(theError error, errString string, msgAndArgs ... // EqualErrorf asserts that a function returned an error (i.e. not `nil`) // and that it is equal to the provided error. // -// actualObj, err := SomeFunction() -// a.EqualErrorf(err, expectedErrorString, "error message %s", "formatted") +// actualObj, err := SomeFunction() +// a.EqualErrorf(err, expectedErrorString, "error message %s", "formatted") func (a *Assertions) EqualErrorf(theError error, errString string, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -155,10 +155,44 @@ func (a *Assertions) EqualErrorf(theError error, errString string, msg string, a return EqualErrorf(a.t, theError, errString, msg, args...) } +// EqualExportedValues asserts that the types of two objects are equal and their public +// fields are also equal. This is useful for comparing structs that have private fields +// that could potentially differ. +// +// type S struct { +// Exported int +// notExported int +// } +// a.EqualExportedValues(S{1, 2}, S{1, 3}) => true +// a.EqualExportedValues(S{1, 2}, S{2, 3}) => false +func (a *Assertions) EqualExportedValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return EqualExportedValues(a.t, expected, actual, msgAndArgs...) +} + +// EqualExportedValuesf asserts that the types of two objects are equal and their public +// fields are also equal. This is useful for comparing structs that have private fields +// that could potentially differ. +// +// type S struct { +// Exported int +// notExported int +// } +// a.EqualExportedValuesf(S{1, 2}, S{1, 3}, "error message %s", "formatted") => true +// a.EqualExportedValuesf(S{1, 2}, S{2, 3}, "error message %s", "formatted") => false +func (a *Assertions) EqualExportedValuesf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return EqualExportedValuesf(a.t, expected, actual, msg, args...) +} + // EqualValues asserts that two objects are equal or convertable to the same types // and equal. // -// a.EqualValues(uint32(123), int32(123)) +// a.EqualValues(uint32(123), int32(123)) func (a *Assertions) EqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -169,7 +203,7 @@ func (a *Assertions) EqualValues(expected interface{}, actual interface{}, msgAn // EqualValuesf asserts that two objects are equal or convertable to the same types // and equal. // -// a.EqualValuesf(uint32(123), int32(123), "error message %s", "formatted") +// a.EqualValuesf(uint32(123), int32(123), "error message %s", "formatted") func (a *Assertions) EqualValuesf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -179,7 +213,7 @@ func (a *Assertions) EqualValuesf(expected interface{}, actual interface{}, msg // Equalf asserts that two objects are equal. // -// a.Equalf(123, 123, "error message %s", "formatted") +// a.Equalf(123, 123, "error message %s", "formatted") // // Pointer variable equality is determined based on the equality of the // referenced values (as opposed to the memory addresses). Function equality @@ -193,10 +227,10 @@ func (a *Assertions) Equalf(expected interface{}, actual interface{}, msg string // Error asserts that a function returned an error (i.e. not `nil`). // -// actualObj, err := SomeFunction() -// if a.Error(err) { -// assert.Equal(t, expectedError, err) -// } +// actualObj, err := SomeFunction() +// if a.Error(err) { +// assert.Equal(t, expectedError, err) +// } func (a *Assertions) Error(err error, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -225,8 +259,8 @@ func (a *Assertions) ErrorAsf(err error, target interface{}, msg string, args .. // ErrorContains asserts that a function returned an error (i.e. not `nil`) // and that the error contains the specified substring. // -// actualObj, err := SomeFunction() -// a.ErrorContains(err, expectedErrorSubString) +// actualObj, err := SomeFunction() +// a.ErrorContains(err, expectedErrorSubString) func (a *Assertions) ErrorContains(theError error, contains string, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -237,8 +271,8 @@ func (a *Assertions) ErrorContains(theError error, contains string, msgAndArgs . // ErrorContainsf asserts that a function returned an error (i.e. not `nil`) // and that the error contains the specified substring. // -// actualObj, err := SomeFunction() -// a.ErrorContainsf(err, expectedErrorSubString, "error message %s", "formatted") +// actualObj, err := SomeFunction() +// a.ErrorContainsf(err, expectedErrorSubString, "error message %s", "formatted") func (a *Assertions) ErrorContainsf(theError error, contains string, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -266,10 +300,10 @@ func (a *Assertions) ErrorIsf(err error, target error, msg string, args ...inter // Errorf asserts that a function returned an error (i.e. not `nil`). // -// actualObj, err := SomeFunction() -// if a.Errorf(err, "error message %s", "formatted") { -// assert.Equal(t, expectedErrorf, err) -// } +// actualObj, err := SomeFunction() +// if a.Errorf(err, "error message %s", "formatted") { +// assert.Equal(t, expectedErrorf, err) +// } func (a *Assertions) Errorf(err error, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -280,7 +314,7 @@ func (a *Assertions) Errorf(err error, msg string, args ...interface{}) bool { // Eventually asserts that given condition will be met in waitFor time, // periodically checking target function each tick. // -// a.Eventually(func() bool { return true; }, time.Second, 10*time.Millisecond) +// a.Eventually(func() bool { return true; }, time.Second, 10*time.Millisecond) func (a *Assertions) Eventually(condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -288,10 +322,60 @@ func (a *Assertions) Eventually(condition func() bool, waitFor time.Duration, ti return Eventually(a.t, condition, waitFor, tick, msgAndArgs...) } +// EventuallyWithT asserts that given condition will be met in waitFor time, +// periodically checking target function each tick. In contrast to Eventually, +// it supplies a CollectT to the condition function, so that the condition +// function can use the CollectT to call other assertions. +// The condition is considered "met" if no errors are raised in a tick. +// The supplied CollectT collects all errors from one tick (if there are any). +// If the condition is not met before waitFor, the collected errors of +// the last tick are copied to t. +// +// externalValue := false +// go func() { +// time.Sleep(8*time.Second) +// externalValue = true +// }() +// a.EventuallyWithT(func(c *assert.CollectT) { +// // add assertions as needed; any assertion failure will fail the current tick +// assert.True(c, externalValue, "expected 'externalValue' to be true") +// }, 1*time.Second, 10*time.Second, "external state has not changed to 'true'; still false") +func (a *Assertions) EventuallyWithT(condition func(collect *CollectT), waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return EventuallyWithT(a.t, condition, waitFor, tick, msgAndArgs...) +} + +// EventuallyWithTf asserts that given condition will be met in waitFor time, +// periodically checking target function each tick. In contrast to Eventually, +// it supplies a CollectT to the condition function, so that the condition +// function can use the CollectT to call other assertions. +// The condition is considered "met" if no errors are raised in a tick. +// The supplied CollectT collects all errors from one tick (if there are any). +// If the condition is not met before waitFor, the collected errors of +// the last tick are copied to t. +// +// externalValue := false +// go func() { +// time.Sleep(8*time.Second) +// externalValue = true +// }() +// a.EventuallyWithTf(func(c *assert.CollectT, "error message %s", "formatted") { +// // add assertions as needed; any assertion failure will fail the current tick +// assert.True(c, externalValue, "expected 'externalValue' to be true") +// }, 1*time.Second, 10*time.Second, "external state has not changed to 'true'; still false") +func (a *Assertions) EventuallyWithTf(condition func(collect *CollectT), waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return EventuallyWithTf(a.t, condition, waitFor, tick, msg, args...) +} + // Eventuallyf asserts that given condition will be met in waitFor time, // periodically checking target function each tick. // -// a.Eventuallyf(func() bool { return true; }, time.Second, 10*time.Millisecond, "error message %s", "formatted") +// a.Eventuallyf(func() bool { return true; }, time.Second, 10*time.Millisecond, "error message %s", "formatted") func (a *Assertions) Eventuallyf(condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -301,7 +385,7 @@ func (a *Assertions) Eventuallyf(condition func() bool, waitFor time.Duration, t // Exactly asserts that two objects are equal in value and type. // -// a.Exactly(int32(123), int64(123)) +// a.Exactly(int32(123), int64(123)) func (a *Assertions) Exactly(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -311,7 +395,7 @@ func (a *Assertions) Exactly(expected interface{}, actual interface{}, msgAndArg // Exactlyf asserts that two objects are equal in value and type. // -// a.Exactlyf(int32(123), int64(123), "error message %s", "formatted") +// a.Exactlyf(int32(123), int64(123), "error message %s", "formatted") func (a *Assertions) Exactlyf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -353,7 +437,7 @@ func (a *Assertions) Failf(failureMessage string, msg string, args ...interface{ // False asserts that the specified value is false. // -// a.False(myBool) +// a.False(myBool) func (a *Assertions) False(value bool, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -363,7 +447,7 @@ func (a *Assertions) False(value bool, msgAndArgs ...interface{}) bool { // Falsef asserts that the specified value is false. // -// a.Falsef(myBool, "error message %s", "formatted") +// a.Falsef(myBool, "error message %s", "formatted") func (a *Assertions) Falsef(value bool, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -391,9 +475,9 @@ func (a *Assertions) FileExistsf(path string, msg string, args ...interface{}) b // Greater asserts that the first element is greater than the second // -// a.Greater(2, 1) -// a.Greater(float64(2), float64(1)) -// a.Greater("b", "a") +// a.Greater(2, 1) +// a.Greater(float64(2), float64(1)) +// a.Greater("b", "a") func (a *Assertions) Greater(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -403,10 +487,10 @@ func (a *Assertions) Greater(e1 interface{}, e2 interface{}, msgAndArgs ...inter // GreaterOrEqual asserts that the first element is greater than or equal to the second // -// a.GreaterOrEqual(2, 1) -// a.GreaterOrEqual(2, 2) -// a.GreaterOrEqual("b", "a") -// a.GreaterOrEqual("b", "b") +// a.GreaterOrEqual(2, 1) +// a.GreaterOrEqual(2, 2) +// a.GreaterOrEqual("b", "a") +// a.GreaterOrEqual("b", "b") func (a *Assertions) GreaterOrEqual(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -416,10 +500,10 @@ func (a *Assertions) GreaterOrEqual(e1 interface{}, e2 interface{}, msgAndArgs . // GreaterOrEqualf asserts that the first element is greater than or equal to the second // -// a.GreaterOrEqualf(2, 1, "error message %s", "formatted") -// a.GreaterOrEqualf(2, 2, "error message %s", "formatted") -// a.GreaterOrEqualf("b", "a", "error message %s", "formatted") -// a.GreaterOrEqualf("b", "b", "error message %s", "formatted") +// a.GreaterOrEqualf(2, 1, "error message %s", "formatted") +// a.GreaterOrEqualf(2, 2, "error message %s", "formatted") +// a.GreaterOrEqualf("b", "a", "error message %s", "formatted") +// a.GreaterOrEqualf("b", "b", "error message %s", "formatted") func (a *Assertions) GreaterOrEqualf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -429,9 +513,9 @@ func (a *Assertions) GreaterOrEqualf(e1 interface{}, e2 interface{}, msg string, // Greaterf asserts that the first element is greater than the second // -// a.Greaterf(2, 1, "error message %s", "formatted") -// a.Greaterf(float64(2), float64(1), "error message %s", "formatted") -// a.Greaterf("b", "a", "error message %s", "formatted") +// a.Greaterf(2, 1, "error message %s", "formatted") +// a.Greaterf(float64(2), float64(1), "error message %s", "formatted") +// a.Greaterf("b", "a", "error message %s", "formatted") func (a *Assertions) Greaterf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -442,7 +526,7 @@ func (a *Assertions) Greaterf(e1 interface{}, e2 interface{}, msg string, args . // HTTPBodyContains asserts that a specified handler returns a // body that contains a string. // -// a.HTTPBodyContains(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky") +// a.HTTPBodyContains(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky") // // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) HTTPBodyContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) bool { @@ -455,7 +539,7 @@ func (a *Assertions) HTTPBodyContains(handler http.HandlerFunc, method string, u // HTTPBodyContainsf asserts that a specified handler returns a // body that contains a string. // -// a.HTTPBodyContainsf(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted") +// a.HTTPBodyContainsf(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted") // // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) HTTPBodyContainsf(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) bool { @@ -468,7 +552,7 @@ func (a *Assertions) HTTPBodyContainsf(handler http.HandlerFunc, method string, // HTTPBodyNotContains asserts that a specified handler returns a // body that does not contain a string. // -// a.HTTPBodyNotContains(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky") +// a.HTTPBodyNotContains(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky") // // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) HTTPBodyNotContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) bool { @@ -481,7 +565,7 @@ func (a *Assertions) HTTPBodyNotContains(handler http.HandlerFunc, method string // HTTPBodyNotContainsf asserts that a specified handler returns a // body that does not contain a string. // -// a.HTTPBodyNotContainsf(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted") +// a.HTTPBodyNotContainsf(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted") // // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) HTTPBodyNotContainsf(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) bool { @@ -493,7 +577,7 @@ func (a *Assertions) HTTPBodyNotContainsf(handler http.HandlerFunc, method strin // HTTPError asserts that a specified handler returns an error status code. // -// a.HTTPError(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}} +// a.HTTPError(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}} // // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) HTTPError(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) bool { @@ -505,7 +589,7 @@ func (a *Assertions) HTTPError(handler http.HandlerFunc, method string, url stri // HTTPErrorf asserts that a specified handler returns an error status code. // -// a.HTTPErrorf(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}} +// a.HTTPErrorf(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}} // // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) HTTPErrorf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool { @@ -517,7 +601,7 @@ func (a *Assertions) HTTPErrorf(handler http.HandlerFunc, method string, url str // HTTPRedirect asserts that a specified handler returns a redirect status code. // -// a.HTTPRedirect(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}} +// a.HTTPRedirect(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}} // // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) HTTPRedirect(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) bool { @@ -529,7 +613,7 @@ func (a *Assertions) HTTPRedirect(handler http.HandlerFunc, method string, url s // HTTPRedirectf asserts that a specified handler returns a redirect status code. // -// a.HTTPRedirectf(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}} +// a.HTTPRedirectf(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}} // // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) HTTPRedirectf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool { @@ -541,7 +625,7 @@ func (a *Assertions) HTTPRedirectf(handler http.HandlerFunc, method string, url // HTTPStatusCode asserts that a specified handler returns a specified status code. // -// a.HTTPStatusCode(myHandler, "GET", "/notImplemented", nil, 501) +// a.HTTPStatusCode(myHandler, "GET", "/notImplemented", nil, 501) // // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) HTTPStatusCode(handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msgAndArgs ...interface{}) bool { @@ -553,7 +637,7 @@ func (a *Assertions) HTTPStatusCode(handler http.HandlerFunc, method string, url // HTTPStatusCodef asserts that a specified handler returns a specified status code. // -// a.HTTPStatusCodef(myHandler, "GET", "/notImplemented", nil, 501, "error message %s", "formatted") +// a.HTTPStatusCodef(myHandler, "GET", "/notImplemented", nil, 501, "error message %s", "formatted") // // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) HTTPStatusCodef(handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msg string, args ...interface{}) bool { @@ -565,7 +649,7 @@ func (a *Assertions) HTTPStatusCodef(handler http.HandlerFunc, method string, ur // HTTPSuccess asserts that a specified handler returns a success status code. // -// a.HTTPSuccess(myHandler, "POST", "http://www.google.com", nil) +// a.HTTPSuccess(myHandler, "POST", "http://www.google.com", nil) // // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) HTTPSuccess(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) bool { @@ -577,7 +661,7 @@ func (a *Assertions) HTTPSuccess(handler http.HandlerFunc, method string, url st // HTTPSuccessf asserts that a specified handler returns a success status code. // -// a.HTTPSuccessf(myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted") +// a.HTTPSuccessf(myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted") // // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) HTTPSuccessf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool { @@ -589,7 +673,7 @@ func (a *Assertions) HTTPSuccessf(handler http.HandlerFunc, method string, url s // Implements asserts that an object is implemented by the specified interface. // -// a.Implements((*MyInterface)(nil), new(MyObject)) +// a.Implements((*MyInterface)(nil), new(MyObject)) func (a *Assertions) Implements(interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -599,7 +683,7 @@ func (a *Assertions) Implements(interfaceObject interface{}, object interface{}, // Implementsf asserts that an object is implemented by the specified interface. // -// a.Implementsf((*MyInterface)(nil), new(MyObject), "error message %s", "formatted") +// a.Implementsf((*MyInterface)(nil), new(MyObject), "error message %s", "formatted") func (a *Assertions) Implementsf(interfaceObject interface{}, object interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -609,7 +693,7 @@ func (a *Assertions) Implementsf(interfaceObject interface{}, object interface{} // InDelta asserts that the two numerals are within delta of each other. // -// a.InDelta(math.Pi, 22/7.0, 0.01) +// a.InDelta(math.Pi, 22/7.0, 0.01) func (a *Assertions) InDelta(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -651,7 +735,7 @@ func (a *Assertions) InDeltaSlicef(expected interface{}, actual interface{}, del // InDeltaf asserts that the two numerals are within delta of each other. // -// a.InDeltaf(math.Pi, 22/7.0, 0.01, "error message %s", "formatted") +// a.InDeltaf(math.Pi, 22/7.0, 0.01, "error message %s", "formatted") func (a *Assertions) InDeltaf(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -693,9 +777,9 @@ func (a *Assertions) InEpsilonf(expected interface{}, actual interface{}, epsilo // IsDecreasing asserts that the collection is decreasing // -// a.IsDecreasing([]int{2, 1, 0}) -// a.IsDecreasing([]float{2, 1}) -// a.IsDecreasing([]string{"b", "a"}) +// a.IsDecreasing([]int{2, 1, 0}) +// a.IsDecreasing([]float{2, 1}) +// a.IsDecreasing([]string{"b", "a"}) func (a *Assertions) IsDecreasing(object interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -705,9 +789,9 @@ func (a *Assertions) IsDecreasing(object interface{}, msgAndArgs ...interface{}) // IsDecreasingf asserts that the collection is decreasing // -// a.IsDecreasingf([]int{2, 1, 0}, "error message %s", "formatted") -// a.IsDecreasingf([]float{2, 1}, "error message %s", "formatted") -// a.IsDecreasingf([]string{"b", "a"}, "error message %s", "formatted") +// a.IsDecreasingf([]int{2, 1, 0}, "error message %s", "formatted") +// a.IsDecreasingf([]float{2, 1}, "error message %s", "formatted") +// a.IsDecreasingf([]string{"b", "a"}, "error message %s", "formatted") func (a *Assertions) IsDecreasingf(object interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -717,9 +801,9 @@ func (a *Assertions) IsDecreasingf(object interface{}, msg string, args ...inter // IsIncreasing asserts that the collection is increasing // -// a.IsIncreasing([]int{1, 2, 3}) -// a.IsIncreasing([]float{1, 2}) -// a.IsIncreasing([]string{"a", "b"}) +// a.IsIncreasing([]int{1, 2, 3}) +// a.IsIncreasing([]float{1, 2}) +// a.IsIncreasing([]string{"a", "b"}) func (a *Assertions) IsIncreasing(object interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -729,9 +813,9 @@ func (a *Assertions) IsIncreasing(object interface{}, msgAndArgs ...interface{}) // IsIncreasingf asserts that the collection is increasing // -// a.IsIncreasingf([]int{1, 2, 3}, "error message %s", "formatted") -// a.IsIncreasingf([]float{1, 2}, "error message %s", "formatted") -// a.IsIncreasingf([]string{"a", "b"}, "error message %s", "formatted") +// a.IsIncreasingf([]int{1, 2, 3}, "error message %s", "formatted") +// a.IsIncreasingf([]float{1, 2}, "error message %s", "formatted") +// a.IsIncreasingf([]string{"a", "b"}, "error message %s", "formatted") func (a *Assertions) IsIncreasingf(object interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -741,9 +825,9 @@ func (a *Assertions) IsIncreasingf(object interface{}, msg string, args ...inter // IsNonDecreasing asserts that the collection is not decreasing // -// a.IsNonDecreasing([]int{1, 1, 2}) -// a.IsNonDecreasing([]float{1, 2}) -// a.IsNonDecreasing([]string{"a", "b"}) +// a.IsNonDecreasing([]int{1, 1, 2}) +// a.IsNonDecreasing([]float{1, 2}) +// a.IsNonDecreasing([]string{"a", "b"}) func (a *Assertions) IsNonDecreasing(object interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -753,9 +837,9 @@ func (a *Assertions) IsNonDecreasing(object interface{}, msgAndArgs ...interface // IsNonDecreasingf asserts that the collection is not decreasing // -// a.IsNonDecreasingf([]int{1, 1, 2}, "error message %s", "formatted") -// a.IsNonDecreasingf([]float{1, 2}, "error message %s", "formatted") -// a.IsNonDecreasingf([]string{"a", "b"}, "error message %s", "formatted") +// a.IsNonDecreasingf([]int{1, 1, 2}, "error message %s", "formatted") +// a.IsNonDecreasingf([]float{1, 2}, "error message %s", "formatted") +// a.IsNonDecreasingf([]string{"a", "b"}, "error message %s", "formatted") func (a *Assertions) IsNonDecreasingf(object interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -765,9 +849,9 @@ func (a *Assertions) IsNonDecreasingf(object interface{}, msg string, args ...in // IsNonIncreasing asserts that the collection is not increasing // -// a.IsNonIncreasing([]int{2, 1, 1}) -// a.IsNonIncreasing([]float{2, 1}) -// a.IsNonIncreasing([]string{"b", "a"}) +// a.IsNonIncreasing([]int{2, 1, 1}) +// a.IsNonIncreasing([]float{2, 1}) +// a.IsNonIncreasing([]string{"b", "a"}) func (a *Assertions) IsNonIncreasing(object interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -777,9 +861,9 @@ func (a *Assertions) IsNonIncreasing(object interface{}, msgAndArgs ...interface // IsNonIncreasingf asserts that the collection is not increasing // -// a.IsNonIncreasingf([]int{2, 1, 1}, "error message %s", "formatted") -// a.IsNonIncreasingf([]float{2, 1}, "error message %s", "formatted") -// a.IsNonIncreasingf([]string{"b", "a"}, "error message %s", "formatted") +// a.IsNonIncreasingf([]int{2, 1, 1}, "error message %s", "formatted") +// a.IsNonIncreasingf([]float{2, 1}, "error message %s", "formatted") +// a.IsNonIncreasingf([]string{"b", "a"}, "error message %s", "formatted") func (a *Assertions) IsNonIncreasingf(object interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -805,7 +889,7 @@ func (a *Assertions) IsTypef(expectedType interface{}, object interface{}, msg s // JSONEq asserts that two JSON strings are equivalent. // -// a.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) +// a.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) func (a *Assertions) JSONEq(expected string, actual string, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -815,7 +899,7 @@ func (a *Assertions) JSONEq(expected string, actual string, msgAndArgs ...interf // JSONEqf asserts that two JSON strings are equivalent. // -// a.JSONEqf(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted") +// a.JSONEqf(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted") func (a *Assertions) JSONEqf(expected string, actual string, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -826,7 +910,7 @@ func (a *Assertions) JSONEqf(expected string, actual string, msg string, args .. // Len asserts that the specified object has specific length. // Len also fails if the object has a type that len() not accept. // -// a.Len(mySlice, 3) +// a.Len(mySlice, 3) func (a *Assertions) Len(object interface{}, length int, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -837,7 +921,7 @@ func (a *Assertions) Len(object interface{}, length int, msgAndArgs ...interface // Lenf asserts that the specified object has specific length. // Lenf also fails if the object has a type that len() not accept. // -// a.Lenf(mySlice, 3, "error message %s", "formatted") +// a.Lenf(mySlice, 3, "error message %s", "formatted") func (a *Assertions) Lenf(object interface{}, length int, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -847,9 +931,9 @@ func (a *Assertions) Lenf(object interface{}, length int, msg string, args ...in // Less asserts that the first element is less than the second // -// a.Less(1, 2) -// a.Less(float64(1), float64(2)) -// a.Less("a", "b") +// a.Less(1, 2) +// a.Less(float64(1), float64(2)) +// a.Less("a", "b") func (a *Assertions) Less(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -859,10 +943,10 @@ func (a *Assertions) Less(e1 interface{}, e2 interface{}, msgAndArgs ...interfac // LessOrEqual asserts that the first element is less than or equal to the second // -// a.LessOrEqual(1, 2) -// a.LessOrEqual(2, 2) -// a.LessOrEqual("a", "b") -// a.LessOrEqual("b", "b") +// a.LessOrEqual(1, 2) +// a.LessOrEqual(2, 2) +// a.LessOrEqual("a", "b") +// a.LessOrEqual("b", "b") func (a *Assertions) LessOrEqual(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -872,10 +956,10 @@ func (a *Assertions) LessOrEqual(e1 interface{}, e2 interface{}, msgAndArgs ...i // LessOrEqualf asserts that the first element is less than or equal to the second // -// a.LessOrEqualf(1, 2, "error message %s", "formatted") -// a.LessOrEqualf(2, 2, "error message %s", "formatted") -// a.LessOrEqualf("a", "b", "error message %s", "formatted") -// a.LessOrEqualf("b", "b", "error message %s", "formatted") +// a.LessOrEqualf(1, 2, "error message %s", "formatted") +// a.LessOrEqualf(2, 2, "error message %s", "formatted") +// a.LessOrEqualf("a", "b", "error message %s", "formatted") +// a.LessOrEqualf("b", "b", "error message %s", "formatted") func (a *Assertions) LessOrEqualf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -885,9 +969,9 @@ func (a *Assertions) LessOrEqualf(e1 interface{}, e2 interface{}, msg string, ar // Lessf asserts that the first element is less than the second // -// a.Lessf(1, 2, "error message %s", "formatted") -// a.Lessf(float64(1), float64(2), "error message %s", "formatted") -// a.Lessf("a", "b", "error message %s", "formatted") +// a.Lessf(1, 2, "error message %s", "formatted") +// a.Lessf(float64(1), float64(2), "error message %s", "formatted") +// a.Lessf("a", "b", "error message %s", "formatted") func (a *Assertions) Lessf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -897,8 +981,8 @@ func (a *Assertions) Lessf(e1 interface{}, e2 interface{}, msg string, args ...i // Negative asserts that the specified element is negative // -// a.Negative(-1) -// a.Negative(-1.23) +// a.Negative(-1) +// a.Negative(-1.23) func (a *Assertions) Negative(e interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -908,8 +992,8 @@ func (a *Assertions) Negative(e interface{}, msgAndArgs ...interface{}) bool { // Negativef asserts that the specified element is negative // -// a.Negativef(-1, "error message %s", "formatted") -// a.Negativef(-1.23, "error message %s", "formatted") +// a.Negativef(-1, "error message %s", "formatted") +// a.Negativef(-1.23, "error message %s", "formatted") func (a *Assertions) Negativef(e interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -920,7 +1004,7 @@ func (a *Assertions) Negativef(e interface{}, msg string, args ...interface{}) b // Never asserts that the given condition doesn't satisfy in waitFor time, // periodically checking the target function each tick. // -// a.Never(func() bool { return false; }, time.Second, 10*time.Millisecond) +// a.Never(func() bool { return false; }, time.Second, 10*time.Millisecond) func (a *Assertions) Never(condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -931,7 +1015,7 @@ func (a *Assertions) Never(condition func() bool, waitFor time.Duration, tick ti // Neverf asserts that the given condition doesn't satisfy in waitFor time, // periodically checking the target function each tick. // -// a.Neverf(func() bool { return false; }, time.Second, 10*time.Millisecond, "error message %s", "formatted") +// a.Neverf(func() bool { return false; }, time.Second, 10*time.Millisecond, "error message %s", "formatted") func (a *Assertions) Neverf(condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -941,7 +1025,7 @@ func (a *Assertions) Neverf(condition func() bool, waitFor time.Duration, tick t // Nil asserts that the specified object is nil. // -// a.Nil(err) +// a.Nil(err) func (a *Assertions) Nil(object interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -951,7 +1035,7 @@ func (a *Assertions) Nil(object interface{}, msgAndArgs ...interface{}) bool { // Nilf asserts that the specified object is nil. // -// a.Nilf(err, "error message %s", "formatted") +// a.Nilf(err, "error message %s", "formatted") func (a *Assertions) Nilf(object interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -979,10 +1063,10 @@ func (a *Assertions) NoDirExistsf(path string, msg string, args ...interface{}) // NoError asserts that a function returned no error (i.e. `nil`). // -// actualObj, err := SomeFunction() -// if a.NoError(err) { -// assert.Equal(t, expectedObj, actualObj) -// } +// actualObj, err := SomeFunction() +// if a.NoError(err) { +// assert.Equal(t, expectedObj, actualObj) +// } func (a *Assertions) NoError(err error, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -992,10 +1076,10 @@ func (a *Assertions) NoError(err error, msgAndArgs ...interface{}) bool { // NoErrorf asserts that a function returned no error (i.e. `nil`). // -// actualObj, err := SomeFunction() -// if a.NoErrorf(err, "error message %s", "formatted") { -// assert.Equal(t, expectedObj, actualObj) -// } +// actualObj, err := SomeFunction() +// if a.NoErrorf(err, "error message %s", "formatted") { +// assert.Equal(t, expectedObj, actualObj) +// } func (a *Assertions) NoErrorf(err error, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -1024,9 +1108,9 @@ func (a *Assertions) NoFileExistsf(path string, msg string, args ...interface{}) // NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the // specified substring or element. // -// a.NotContains("Hello World", "Earth") -// a.NotContains(["Hello", "World"], "Earth") -// a.NotContains({"Hello": "World"}, "Earth") +// a.NotContains("Hello World", "Earth") +// a.NotContains(["Hello", "World"], "Earth") +// a.NotContains({"Hello": "World"}, "Earth") func (a *Assertions) NotContains(s interface{}, contains interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -1037,9 +1121,9 @@ func (a *Assertions) NotContains(s interface{}, contains interface{}, msgAndArgs // NotContainsf asserts that the specified string, list(array, slice...) or map does NOT contain the // specified substring or element. // -// a.NotContainsf("Hello World", "Earth", "error message %s", "formatted") -// a.NotContainsf(["Hello", "World"], "Earth", "error message %s", "formatted") -// a.NotContainsf({"Hello": "World"}, "Earth", "error message %s", "formatted") +// a.NotContainsf("Hello World", "Earth", "error message %s", "formatted") +// a.NotContainsf(["Hello", "World"], "Earth", "error message %s", "formatted") +// a.NotContainsf({"Hello": "World"}, "Earth", "error message %s", "formatted") func (a *Assertions) NotContainsf(s interface{}, contains interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -1050,9 +1134,9 @@ func (a *Assertions) NotContainsf(s interface{}, contains interface{}, msg strin // NotEmpty asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either // a slice or a channel with len == 0. // -// if a.NotEmpty(obj) { -// assert.Equal(t, "two", obj[1]) -// } +// if a.NotEmpty(obj) { +// assert.Equal(t, "two", obj[1]) +// } func (a *Assertions) NotEmpty(object interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -1063,9 +1147,9 @@ func (a *Assertions) NotEmpty(object interface{}, msgAndArgs ...interface{}) boo // NotEmptyf asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either // a slice or a channel with len == 0. // -// if a.NotEmptyf(obj, "error message %s", "formatted") { -// assert.Equal(t, "two", obj[1]) -// } +// if a.NotEmptyf(obj, "error message %s", "formatted") { +// assert.Equal(t, "two", obj[1]) +// } func (a *Assertions) NotEmptyf(object interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -1075,7 +1159,7 @@ func (a *Assertions) NotEmptyf(object interface{}, msg string, args ...interface // NotEqual asserts that the specified values are NOT equal. // -// a.NotEqual(obj1, obj2) +// a.NotEqual(obj1, obj2) // // Pointer variable equality is determined based on the equality of the // referenced values (as opposed to the memory addresses). @@ -1088,7 +1172,7 @@ func (a *Assertions) NotEqual(expected interface{}, actual interface{}, msgAndAr // NotEqualValues asserts that two objects are not equal even when converted to the same type // -// a.NotEqualValues(obj1, obj2) +// a.NotEqualValues(obj1, obj2) func (a *Assertions) NotEqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -1098,7 +1182,7 @@ func (a *Assertions) NotEqualValues(expected interface{}, actual interface{}, ms // NotEqualValuesf asserts that two objects are not equal even when converted to the same type // -// a.NotEqualValuesf(obj1, obj2, "error message %s", "formatted") +// a.NotEqualValuesf(obj1, obj2, "error message %s", "formatted") func (a *Assertions) NotEqualValuesf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -1108,7 +1192,7 @@ func (a *Assertions) NotEqualValuesf(expected interface{}, actual interface{}, m // NotEqualf asserts that the specified values are NOT equal. // -// a.NotEqualf(obj1, obj2, "error message %s", "formatted") +// a.NotEqualf(obj1, obj2, "error message %s", "formatted") // // Pointer variable equality is determined based on the equality of the // referenced values (as opposed to the memory addresses). @@ -1139,7 +1223,7 @@ func (a *Assertions) NotErrorIsf(err error, target error, msg string, args ...in // NotNil asserts that the specified object is not nil. // -// a.NotNil(err) +// a.NotNil(err) func (a *Assertions) NotNil(object interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -1149,7 +1233,7 @@ func (a *Assertions) NotNil(object interface{}, msgAndArgs ...interface{}) bool // NotNilf asserts that the specified object is not nil. // -// a.NotNilf(err, "error message %s", "formatted") +// a.NotNilf(err, "error message %s", "formatted") func (a *Assertions) NotNilf(object interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -1159,7 +1243,7 @@ func (a *Assertions) NotNilf(object interface{}, msg string, args ...interface{} // NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic. // -// a.NotPanics(func(){ RemainCalm() }) +// a.NotPanics(func(){ RemainCalm() }) func (a *Assertions) NotPanics(f PanicTestFunc, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -1169,7 +1253,7 @@ func (a *Assertions) NotPanics(f PanicTestFunc, msgAndArgs ...interface{}) bool // NotPanicsf asserts that the code inside the specified PanicTestFunc does NOT panic. // -// a.NotPanicsf(func(){ RemainCalm() }, "error message %s", "formatted") +// a.NotPanicsf(func(){ RemainCalm() }, "error message %s", "formatted") func (a *Assertions) NotPanicsf(f PanicTestFunc, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -1179,8 +1263,8 @@ func (a *Assertions) NotPanicsf(f PanicTestFunc, msg string, args ...interface{} // NotRegexp asserts that a specified regexp does not match a string. // -// a.NotRegexp(regexp.MustCompile("starts"), "it's starting") -// a.NotRegexp("^start", "it's not starting") +// a.NotRegexp(regexp.MustCompile("starts"), "it's starting") +// a.NotRegexp("^start", "it's not starting") func (a *Assertions) NotRegexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -1190,8 +1274,8 @@ func (a *Assertions) NotRegexp(rx interface{}, str interface{}, msgAndArgs ...in // NotRegexpf asserts that a specified regexp does not match a string. // -// a.NotRegexpf(regexp.MustCompile("starts"), "it's starting", "error message %s", "formatted") -// a.NotRegexpf("^start", "it's not starting", "error message %s", "formatted") +// a.NotRegexpf(regexp.MustCompile("starts"), "it's starting", "error message %s", "formatted") +// a.NotRegexpf("^start", "it's not starting", "error message %s", "formatted") func (a *Assertions) NotRegexpf(rx interface{}, str interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -1201,7 +1285,7 @@ func (a *Assertions) NotRegexpf(rx interface{}, str interface{}, msg string, arg // NotSame asserts that two pointers do not reference the same object. // -// a.NotSame(ptr1, ptr2) +// a.NotSame(ptr1, ptr2) // // Both arguments must be pointer variables. Pointer variable sameness is // determined based on the equality of both type and value. @@ -1214,7 +1298,7 @@ func (a *Assertions) NotSame(expected interface{}, actual interface{}, msgAndArg // NotSamef asserts that two pointers do not reference the same object. // -// a.NotSamef(ptr1, ptr2, "error message %s", "formatted") +// a.NotSamef(ptr1, ptr2, "error message %s", "formatted") // // Both arguments must be pointer variables. Pointer variable sameness is // determined based on the equality of both type and value. @@ -1228,7 +1312,7 @@ func (a *Assertions) NotSamef(expected interface{}, actual interface{}, msg stri // NotSubset asserts that the specified list(array, slice...) contains not all // elements given in the specified subset(array, slice...). // -// a.NotSubset([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]") +// a.NotSubset([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]") func (a *Assertions) NotSubset(list interface{}, subset interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -1239,7 +1323,7 @@ func (a *Assertions) NotSubset(list interface{}, subset interface{}, msgAndArgs // NotSubsetf asserts that the specified list(array, slice...) contains not all // elements given in the specified subset(array, slice...). // -// a.NotSubsetf([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted") +// a.NotSubsetf([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted") func (a *Assertions) NotSubsetf(list interface{}, subset interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -1265,7 +1349,7 @@ func (a *Assertions) NotZerof(i interface{}, msg string, args ...interface{}) bo // Panics asserts that the code inside the specified PanicTestFunc panics. // -// a.Panics(func(){ GoCrazy() }) +// a.Panics(func(){ GoCrazy() }) func (a *Assertions) Panics(f PanicTestFunc, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -1277,7 +1361,7 @@ func (a *Assertions) Panics(f PanicTestFunc, msgAndArgs ...interface{}) bool { // panics, and that the recovered panic value is an error that satisfies the // EqualError comparison. // -// a.PanicsWithError("crazy error", func(){ GoCrazy() }) +// a.PanicsWithError("crazy error", func(){ GoCrazy() }) func (a *Assertions) PanicsWithError(errString string, f PanicTestFunc, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -1289,7 +1373,7 @@ func (a *Assertions) PanicsWithError(errString string, f PanicTestFunc, msgAndAr // panics, and that the recovered panic value is an error that satisfies the // EqualError comparison. // -// a.PanicsWithErrorf("crazy error", func(){ GoCrazy() }, "error message %s", "formatted") +// a.PanicsWithErrorf("crazy error", func(){ GoCrazy() }, "error message %s", "formatted") func (a *Assertions) PanicsWithErrorf(errString string, f PanicTestFunc, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -1300,7 +1384,7 @@ func (a *Assertions) PanicsWithErrorf(errString string, f PanicTestFunc, msg str // PanicsWithValue asserts that the code inside the specified PanicTestFunc panics, and that // the recovered panic value equals the expected panic value. // -// a.PanicsWithValue("crazy error", func(){ GoCrazy() }) +// a.PanicsWithValue("crazy error", func(){ GoCrazy() }) func (a *Assertions) PanicsWithValue(expected interface{}, f PanicTestFunc, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -1311,7 +1395,7 @@ func (a *Assertions) PanicsWithValue(expected interface{}, f PanicTestFunc, msgA // PanicsWithValuef asserts that the code inside the specified PanicTestFunc panics, and that // the recovered panic value equals the expected panic value. // -// a.PanicsWithValuef("crazy error", func(){ GoCrazy() }, "error message %s", "formatted") +// a.PanicsWithValuef("crazy error", func(){ GoCrazy() }, "error message %s", "formatted") func (a *Assertions) PanicsWithValuef(expected interface{}, f PanicTestFunc, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -1321,7 +1405,7 @@ func (a *Assertions) PanicsWithValuef(expected interface{}, f PanicTestFunc, msg // Panicsf asserts that the code inside the specified PanicTestFunc panics. // -// a.Panicsf(func(){ GoCrazy() }, "error message %s", "formatted") +// a.Panicsf(func(){ GoCrazy() }, "error message %s", "formatted") func (a *Assertions) Panicsf(f PanicTestFunc, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -1331,8 +1415,8 @@ func (a *Assertions) Panicsf(f PanicTestFunc, msg string, args ...interface{}) b // Positive asserts that the specified element is positive // -// a.Positive(1) -// a.Positive(1.23) +// a.Positive(1) +// a.Positive(1.23) func (a *Assertions) Positive(e interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -1342,8 +1426,8 @@ func (a *Assertions) Positive(e interface{}, msgAndArgs ...interface{}) bool { // Positivef asserts that the specified element is positive // -// a.Positivef(1, "error message %s", "formatted") -// a.Positivef(1.23, "error message %s", "formatted") +// a.Positivef(1, "error message %s", "formatted") +// a.Positivef(1.23, "error message %s", "formatted") func (a *Assertions) Positivef(e interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -1353,8 +1437,8 @@ func (a *Assertions) Positivef(e interface{}, msg string, args ...interface{}) b // Regexp asserts that a specified regexp matches a string. // -// a.Regexp(regexp.MustCompile("start"), "it's starting") -// a.Regexp("start...$", "it's not starting") +// a.Regexp(regexp.MustCompile("start"), "it's starting") +// a.Regexp("start...$", "it's not starting") func (a *Assertions) Regexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -1364,8 +1448,8 @@ func (a *Assertions) Regexp(rx interface{}, str interface{}, msgAndArgs ...inter // Regexpf asserts that a specified regexp matches a string. // -// a.Regexpf(regexp.MustCompile("start"), "it's starting", "error message %s", "formatted") -// a.Regexpf("start...$", "it's not starting", "error message %s", "formatted") +// a.Regexpf(regexp.MustCompile("start"), "it's starting", "error message %s", "formatted") +// a.Regexpf("start...$", "it's not starting", "error message %s", "formatted") func (a *Assertions) Regexpf(rx interface{}, str interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -1375,7 +1459,7 @@ func (a *Assertions) Regexpf(rx interface{}, str interface{}, msg string, args . // Same asserts that two pointers reference the same object. // -// a.Same(ptr1, ptr2) +// a.Same(ptr1, ptr2) // // Both arguments must be pointer variables. Pointer variable sameness is // determined based on the equality of both type and value. @@ -1388,7 +1472,7 @@ func (a *Assertions) Same(expected interface{}, actual interface{}, msgAndArgs . // Samef asserts that two pointers reference the same object. // -// a.Samef(ptr1, ptr2, "error message %s", "formatted") +// a.Samef(ptr1, ptr2, "error message %s", "formatted") // // Both arguments must be pointer variables. Pointer variable sameness is // determined based on the equality of both type and value. @@ -1402,7 +1486,7 @@ func (a *Assertions) Samef(expected interface{}, actual interface{}, msg string, // Subset asserts that the specified list(array, slice...) contains all // elements given in the specified subset(array, slice...). // -// a.Subset([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]") +// a.Subset([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]") func (a *Assertions) Subset(list interface{}, subset interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -1413,7 +1497,7 @@ func (a *Assertions) Subset(list interface{}, subset interface{}, msgAndArgs ... // Subsetf asserts that the specified list(array, slice...) contains all // elements given in the specified subset(array, slice...). // -// a.Subsetf([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted") +// a.Subsetf([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted") func (a *Assertions) Subsetf(list interface{}, subset interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -1423,7 +1507,7 @@ func (a *Assertions) Subsetf(list interface{}, subset interface{}, msg string, a // True asserts that the specified value is true. // -// a.True(myBool) +// a.True(myBool) func (a *Assertions) True(value bool, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -1433,7 +1517,7 @@ func (a *Assertions) True(value bool, msgAndArgs ...interface{}) bool { // Truef asserts that the specified value is true. // -// a.Truef(myBool, "error message %s", "formatted") +// a.Truef(myBool, "error message %s", "formatted") func (a *Assertions) Truef(value bool, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -1443,7 +1527,7 @@ func (a *Assertions) Truef(value bool, msg string, args ...interface{}) bool { // WithinDuration asserts that the two times are within duration delta of each other. // -// a.WithinDuration(time.Now(), time.Now(), 10*time.Second) +// a.WithinDuration(time.Now(), time.Now(), 10*time.Second) func (a *Assertions) WithinDuration(expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -1453,7 +1537,7 @@ func (a *Assertions) WithinDuration(expected time.Time, actual time.Time, delta // WithinDurationf asserts that the two times are within duration delta of each other. // -// a.WithinDurationf(time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted") +// a.WithinDurationf(time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted") func (a *Assertions) WithinDurationf(expected time.Time, actual time.Time, delta time.Duration, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -1463,7 +1547,7 @@ func (a *Assertions) WithinDurationf(expected time.Time, actual time.Time, delta // WithinRange asserts that a time is within a time range (inclusive). // -// a.WithinRange(time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second)) +// a.WithinRange(time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second)) func (a *Assertions) WithinRange(actual time.Time, start time.Time, end time.Time, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() @@ -1473,7 +1557,7 @@ func (a *Assertions) WithinRange(actual time.Time, start time.Time, end time.Tim // WithinRangef asserts that a time is within a time range (inclusive). // -// a.WithinRangef(time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second), "error message %s", "formatted") +// a.WithinRangef(time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second), "error message %s", "formatted") func (a *Assertions) WithinRangef(actual time.Time, start time.Time, end time.Time, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() diff --git a/vertical-pod-autoscaler/vendor/github.com/stretchr/testify/assert/assertion_order.go b/vertical-pod-autoscaler/vendor/github.com/stretchr/testify/assert/assertion_order.go index 759448783585..00df62a05992 100644 --- a/vertical-pod-autoscaler/vendor/github.com/stretchr/testify/assert/assertion_order.go +++ b/vertical-pod-autoscaler/vendor/github.com/stretchr/testify/assert/assertion_order.go @@ -46,36 +46,36 @@ func isOrdered(t TestingT, object interface{}, allowedComparesResults []CompareT // IsIncreasing asserts that the collection is increasing // -// assert.IsIncreasing(t, []int{1, 2, 3}) -// assert.IsIncreasing(t, []float{1, 2}) -// assert.IsIncreasing(t, []string{"a", "b"}) +// assert.IsIncreasing(t, []int{1, 2, 3}) +// assert.IsIncreasing(t, []float{1, 2}) +// assert.IsIncreasing(t, []string{"a", "b"}) func IsIncreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) bool { return isOrdered(t, object, []CompareType{compareLess}, "\"%v\" is not less than \"%v\"", msgAndArgs...) } // IsNonIncreasing asserts that the collection is not increasing // -// assert.IsNonIncreasing(t, []int{2, 1, 1}) -// assert.IsNonIncreasing(t, []float{2, 1}) -// assert.IsNonIncreasing(t, []string{"b", "a"}) +// assert.IsNonIncreasing(t, []int{2, 1, 1}) +// assert.IsNonIncreasing(t, []float{2, 1}) +// assert.IsNonIncreasing(t, []string{"b", "a"}) func IsNonIncreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) bool { return isOrdered(t, object, []CompareType{compareEqual, compareGreater}, "\"%v\" is not greater than or equal to \"%v\"", msgAndArgs...) } // IsDecreasing asserts that the collection is decreasing // -// assert.IsDecreasing(t, []int{2, 1, 0}) -// assert.IsDecreasing(t, []float{2, 1}) -// assert.IsDecreasing(t, []string{"b", "a"}) +// assert.IsDecreasing(t, []int{2, 1, 0}) +// assert.IsDecreasing(t, []float{2, 1}) +// assert.IsDecreasing(t, []string{"b", "a"}) func IsDecreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) bool { return isOrdered(t, object, []CompareType{compareGreater}, "\"%v\" is not greater than \"%v\"", msgAndArgs...) } // IsNonDecreasing asserts that the collection is not decreasing // -// assert.IsNonDecreasing(t, []int{1, 1, 2}) -// assert.IsNonDecreasing(t, []float{1, 2}) -// assert.IsNonDecreasing(t, []string{"a", "b"}) +// assert.IsNonDecreasing(t, []int{1, 1, 2}) +// assert.IsNonDecreasing(t, []float{1, 2}) +// assert.IsNonDecreasing(t, []string{"a", "b"}) func IsNonDecreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) bool { return isOrdered(t, object, []CompareType{compareLess, compareEqual}, "\"%v\" is not less than or equal to \"%v\"", msgAndArgs...) } diff --git a/vertical-pod-autoscaler/vendor/github.com/stretchr/testify/assert/assertions.go b/vertical-pod-autoscaler/vendor/github.com/stretchr/testify/assert/assertions.go index 2924cf3a1492..a55d1bba926c 100644 --- a/vertical-pod-autoscaler/vendor/github.com/stretchr/testify/assert/assertions.go +++ b/vertical-pod-autoscaler/vendor/github.com/stretchr/testify/assert/assertions.go @@ -75,6 +75,77 @@ func ObjectsAreEqual(expected, actual interface{}) bool { return bytes.Equal(exp, act) } +// copyExportedFields iterates downward through nested data structures and creates a copy +// that only contains the exported struct fields. +func copyExportedFields(expected interface{}) interface{} { + if isNil(expected) { + return expected + } + + expectedType := reflect.TypeOf(expected) + expectedKind := expectedType.Kind() + expectedValue := reflect.ValueOf(expected) + + switch expectedKind { + case reflect.Struct: + result := reflect.New(expectedType).Elem() + for i := 0; i < expectedType.NumField(); i++ { + field := expectedType.Field(i) + isExported := field.IsExported() + if isExported { + fieldValue := expectedValue.Field(i) + if isNil(fieldValue) || isNil(fieldValue.Interface()) { + continue + } + newValue := copyExportedFields(fieldValue.Interface()) + result.Field(i).Set(reflect.ValueOf(newValue)) + } + } + return result.Interface() + + case reflect.Ptr: + result := reflect.New(expectedType.Elem()) + unexportedRemoved := copyExportedFields(expectedValue.Elem().Interface()) + result.Elem().Set(reflect.ValueOf(unexportedRemoved)) + return result.Interface() + + case reflect.Array, reflect.Slice: + result := reflect.MakeSlice(expectedType, expectedValue.Len(), expectedValue.Len()) + for i := 0; i < expectedValue.Len(); i++ { + index := expectedValue.Index(i) + if isNil(index) { + continue + } + unexportedRemoved := copyExportedFields(index.Interface()) + result.Index(i).Set(reflect.ValueOf(unexportedRemoved)) + } + return result.Interface() + + case reflect.Map: + result := reflect.MakeMap(expectedType) + for _, k := range expectedValue.MapKeys() { + index := expectedValue.MapIndex(k) + unexportedRemoved := copyExportedFields(index.Interface()) + result.SetMapIndex(k, reflect.ValueOf(unexportedRemoved)) + } + return result.Interface() + + default: + return expected + } +} + +// ObjectsExportedFieldsAreEqual determines if the exported (public) fields of two objects are +// considered equal. This comparison of only exported fields is applied recursively to nested data +// structures. +// +// This function does no assertion of any kind. +func ObjectsExportedFieldsAreEqual(expected, actual interface{}) bool { + expectedCleaned := copyExportedFields(expected) + actualCleaned := copyExportedFields(actual) + return ObjectsAreEqualValues(expectedCleaned, actualCleaned) +} + // ObjectsAreEqualValues gets whether two objects are equal, or if their // values are equal. func ObjectsAreEqualValues(expected, actual interface{}) bool { @@ -271,7 +342,7 @@ type labeledContent struct { // labeledOutput returns a string consisting of the provided labeledContent. Each labeled output is appended in the following manner: // -// \t{{label}}:{{align_spaces}}\t{{content}}\n +// \t{{label}}:{{align_spaces}}\t{{content}}\n // // The initial carriage return is required to undo/erase any padding added by testing.T.Errorf. The "\t{{label}}:" is for the label. // If a label is shorter than the longest label provided, padding spaces are added to make all the labels match in length. Once this @@ -294,7 +365,7 @@ func labeledOutput(content ...labeledContent) string { // Implements asserts that an object is implemented by the specified interface. // -// assert.Implements(t, (*MyInterface)(nil), new(MyObject)) +// assert.Implements(t, (*MyInterface)(nil), new(MyObject)) func Implements(t TestingT, interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -326,7 +397,7 @@ func IsType(t TestingT, expectedType interface{}, object interface{}, msgAndArgs // Equal asserts that two objects are equal. // -// assert.Equal(t, 123, 123) +// assert.Equal(t, 123, 123) // // Pointer variable equality is determined based on the equality of the // referenced values (as opposed to the memory addresses). Function equality @@ -367,7 +438,7 @@ func validateEqualArgs(expected, actual interface{}) error { // Same asserts that two pointers reference the same object. // -// assert.Same(t, ptr1, ptr2) +// assert.Same(t, ptr1, ptr2) // // Both arguments must be pointer variables. Pointer variable sameness is // determined based on the equality of both type and value. @@ -387,7 +458,7 @@ func Same(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) b // NotSame asserts that two pointers do not reference the same object. // -// assert.NotSame(t, ptr1, ptr2) +// assert.NotSame(t, ptr1, ptr2) // // Both arguments must be pointer variables. Pointer variable sameness is // determined based on the equality of both type and value. @@ -455,7 +526,7 @@ func truncatingFormat(data interface{}) string { // EqualValues asserts that two objects are equal or convertable to the same types // and equal. // -// assert.EqualValues(t, uint32(123), int32(123)) +// assert.EqualValues(t, uint32(123), int32(123)) func EqualValues(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -473,9 +544,53 @@ func EqualValues(t TestingT, expected, actual interface{}, msgAndArgs ...interfa } +// EqualExportedValues asserts that the types of two objects are equal and their public +// fields are also equal. This is useful for comparing structs that have private fields +// that could potentially differ. +// +// type S struct { +// Exported int +// notExported int +// } +// assert.EqualExportedValues(t, S{1, 2}, S{1, 3}) => true +// assert.EqualExportedValues(t, S{1, 2}, S{2, 3}) => false +func EqualExportedValues(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + + aType := reflect.TypeOf(expected) + bType := reflect.TypeOf(actual) + + if aType != bType { + return Fail(t, fmt.Sprintf("Types expected to match exactly\n\t%v != %v", aType, bType), msgAndArgs...) + } + + if aType.Kind() != reflect.Struct { + return Fail(t, fmt.Sprintf("Types expected to both be struct \n\t%v != %v", aType.Kind(), reflect.Struct), msgAndArgs...) + } + + if bType.Kind() != reflect.Struct { + return Fail(t, fmt.Sprintf("Types expected to both be struct \n\t%v != %v", bType.Kind(), reflect.Struct), msgAndArgs...) + } + + expected = copyExportedFields(expected) + actual = copyExportedFields(actual) + + if !ObjectsAreEqualValues(expected, actual) { + diff := diff(expected, actual) + expected, actual = formatUnequalValues(expected, actual) + return Fail(t, fmt.Sprintf("Not equal (comparing only exported fields): \n"+ + "expected: %s\n"+ + "actual : %s%s", expected, actual, diff), msgAndArgs...) + } + + return true +} + // Exactly asserts that two objects are equal in value and type. // -// assert.Exactly(t, int32(123), int64(123)) +// assert.Exactly(t, int32(123), int64(123)) func Exactly(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -494,7 +609,7 @@ func Exactly(t TestingT, expected, actual interface{}, msgAndArgs ...interface{} // NotNil asserts that the specified object is not nil. // -// assert.NotNil(t, err) +// assert.NotNil(t, err) func NotNil(t TestingT, object interface{}, msgAndArgs ...interface{}) bool { if !isNil(object) { return true @@ -540,7 +655,7 @@ func isNil(object interface{}) bool { // Nil asserts that the specified object is nil. // -// assert.Nil(t, err) +// assert.Nil(t, err) func Nil(t TestingT, object interface{}, msgAndArgs ...interface{}) bool { if isNil(object) { return true @@ -583,7 +698,7 @@ func isEmpty(object interface{}) bool { // Empty asserts that the specified object is empty. I.e. nil, "", false, 0 or either // a slice or a channel with len == 0. // -// assert.Empty(t, obj) +// assert.Empty(t, obj) func Empty(t TestingT, object interface{}, msgAndArgs ...interface{}) bool { pass := isEmpty(object) if !pass { @@ -600,9 +715,9 @@ func Empty(t TestingT, object interface{}, msgAndArgs ...interface{}) bool { // NotEmpty asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either // a slice or a channel with len == 0. // -// if assert.NotEmpty(t, obj) { -// assert.Equal(t, "two", obj[1]) -// } +// if assert.NotEmpty(t, obj) { +// assert.Equal(t, "two", obj[1]) +// } func NotEmpty(t TestingT, object interface{}, msgAndArgs ...interface{}) bool { pass := !isEmpty(object) if !pass { @@ -631,7 +746,7 @@ func getLen(x interface{}) (ok bool, length int) { // Len asserts that the specified object has specific length. // Len also fails if the object has a type that len() not accept. // -// assert.Len(t, mySlice, 3) +// assert.Len(t, mySlice, 3) func Len(t TestingT, object interface{}, length int, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -649,7 +764,7 @@ func Len(t TestingT, object interface{}, length int, msgAndArgs ...interface{}) // True asserts that the specified value is true. // -// assert.True(t, myBool) +// assert.True(t, myBool) func True(t TestingT, value bool, msgAndArgs ...interface{}) bool { if !value { if h, ok := t.(tHelper); ok { @@ -664,7 +779,7 @@ func True(t TestingT, value bool, msgAndArgs ...interface{}) bool { // False asserts that the specified value is false. // -// assert.False(t, myBool) +// assert.False(t, myBool) func False(t TestingT, value bool, msgAndArgs ...interface{}) bool { if value { if h, ok := t.(tHelper); ok { @@ -679,7 +794,7 @@ func False(t TestingT, value bool, msgAndArgs ...interface{}) bool { // NotEqual asserts that the specified values are NOT equal. // -// assert.NotEqual(t, obj1, obj2) +// assert.NotEqual(t, obj1, obj2) // // Pointer variable equality is determined based on the equality of the // referenced values (as opposed to the memory addresses). @@ -702,7 +817,7 @@ func NotEqual(t TestingT, expected, actual interface{}, msgAndArgs ...interface{ // NotEqualValues asserts that two objects are not equal even when converted to the same type // -// assert.NotEqualValues(t, obj1, obj2) +// assert.NotEqualValues(t, obj1, obj2) func NotEqualValues(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -761,9 +876,9 @@ func containsElement(list interface{}, element interface{}) (ok, found bool) { // Contains asserts that the specified string, list(array, slice...) or map contains the // specified substring or element. // -// assert.Contains(t, "Hello World", "World") -// assert.Contains(t, ["Hello", "World"], "World") -// assert.Contains(t, {"Hello": "World"}, "Hello") +// assert.Contains(t, "Hello World", "World") +// assert.Contains(t, ["Hello", "World"], "World") +// assert.Contains(t, {"Hello": "World"}, "Hello") func Contains(t TestingT, s, contains interface{}, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -784,9 +899,9 @@ func Contains(t TestingT, s, contains interface{}, msgAndArgs ...interface{}) bo // NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the // specified substring or element. // -// assert.NotContains(t, "Hello World", "Earth") -// assert.NotContains(t, ["Hello", "World"], "Earth") -// assert.NotContains(t, {"Hello": "World"}, "Earth") +// assert.NotContains(t, "Hello World", "Earth") +// assert.NotContains(t, ["Hello", "World"], "Earth") +// assert.NotContains(t, {"Hello": "World"}, "Earth") func NotContains(t TestingT, s, contains interface{}, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -794,10 +909,10 @@ func NotContains(t TestingT, s, contains interface{}, msgAndArgs ...interface{}) ok, found := containsElement(s, contains) if !ok { - return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", s), msgAndArgs...) + return Fail(t, fmt.Sprintf("%#v could not be applied builtin len()", s), msgAndArgs...) } if found { - return Fail(t, fmt.Sprintf("\"%s\" should not contain \"%s\"", s, contains), msgAndArgs...) + return Fail(t, fmt.Sprintf("%#v should not contain %#v", s, contains), msgAndArgs...) } return true @@ -807,7 +922,7 @@ func NotContains(t TestingT, s, contains interface{}, msgAndArgs ...interface{}) // Subset asserts that the specified list(array, slice...) contains all // elements given in the specified subset(array, slice...). // -// assert.Subset(t, [1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]") +// assert.Subset(t, [1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]") func Subset(t TestingT, list, subset interface{}, msgAndArgs ...interface{}) (ok bool) { if h, ok := t.(tHelper); ok { h.Helper() @@ -863,7 +978,7 @@ func Subset(t TestingT, list, subset interface{}, msgAndArgs ...interface{}) (ok // NotSubset asserts that the specified list(array, slice...) contains not all // elements given in the specified subset(array, slice...). // -// assert.NotSubset(t, [1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]") +// assert.NotSubset(t, [1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]") func NotSubset(t TestingT, list, subset interface{}, msgAndArgs ...interface{}) (ok bool) { if h, ok := t.(tHelper); ok { h.Helper() @@ -1048,7 +1163,7 @@ func didPanic(f PanicTestFunc) (didPanic bool, message interface{}, stack string // Panics asserts that the code inside the specified PanicTestFunc panics. // -// assert.Panics(t, func(){ GoCrazy() }) +// assert.Panics(t, func(){ GoCrazy() }) func Panics(t TestingT, f PanicTestFunc, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -1064,7 +1179,7 @@ func Panics(t TestingT, f PanicTestFunc, msgAndArgs ...interface{}) bool { // PanicsWithValue asserts that the code inside the specified PanicTestFunc panics, and that // the recovered panic value equals the expected panic value. // -// assert.PanicsWithValue(t, "crazy error", func(){ GoCrazy() }) +// assert.PanicsWithValue(t, "crazy error", func(){ GoCrazy() }) func PanicsWithValue(t TestingT, expected interface{}, f PanicTestFunc, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -1085,7 +1200,7 @@ func PanicsWithValue(t TestingT, expected interface{}, f PanicTestFunc, msgAndAr // panics, and that the recovered panic value is an error that satisfies the // EqualError comparison. // -// assert.PanicsWithError(t, "crazy error", func(){ GoCrazy() }) +// assert.PanicsWithError(t, "crazy error", func(){ GoCrazy() }) func PanicsWithError(t TestingT, errString string, f PanicTestFunc, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -1105,7 +1220,7 @@ func PanicsWithError(t TestingT, errString string, f PanicTestFunc, msgAndArgs . // NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic. // -// assert.NotPanics(t, func(){ RemainCalm() }) +// assert.NotPanics(t, func(){ RemainCalm() }) func NotPanics(t TestingT, f PanicTestFunc, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -1120,7 +1235,7 @@ func NotPanics(t TestingT, f PanicTestFunc, msgAndArgs ...interface{}) bool { // WithinDuration asserts that the two times are within duration delta of each other. // -// assert.WithinDuration(t, time.Now(), time.Now(), 10*time.Second) +// assert.WithinDuration(t, time.Now(), time.Now(), 10*time.Second) func WithinDuration(t TestingT, expected, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -1136,7 +1251,7 @@ func WithinDuration(t TestingT, expected, actual time.Time, delta time.Duration, // WithinRange asserts that a time is within a time range (inclusive). // -// assert.WithinRange(t, time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second)) +// assert.WithinRange(t, time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second)) func WithinRange(t TestingT, actual, start, end time.Time, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -1195,7 +1310,7 @@ func toFloat(x interface{}) (float64, bool) { // InDelta asserts that the two numerals are within delta of each other. // -// assert.InDelta(t, math.Pi, 22/7.0, 0.01) +// assert.InDelta(t, math.Pi, 22/7.0, 0.01) func InDelta(t TestingT, expected, actual interface{}, delta float64, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -1368,10 +1483,10 @@ func InEpsilonSlice(t TestingT, expected, actual interface{}, epsilon float64, m // NoError asserts that a function returned no error (i.e. `nil`). // -// actualObj, err := SomeFunction() -// if assert.NoError(t, err) { -// assert.Equal(t, expectedObj, actualObj) -// } +// actualObj, err := SomeFunction() +// if assert.NoError(t, err) { +// assert.Equal(t, expectedObj, actualObj) +// } func NoError(t TestingT, err error, msgAndArgs ...interface{}) bool { if err != nil { if h, ok := t.(tHelper); ok { @@ -1385,10 +1500,10 @@ func NoError(t TestingT, err error, msgAndArgs ...interface{}) bool { // Error asserts that a function returned an error (i.e. not `nil`). // -// actualObj, err := SomeFunction() -// if assert.Error(t, err) { -// assert.Equal(t, expectedError, err) -// } +// actualObj, err := SomeFunction() +// if assert.Error(t, err) { +// assert.Equal(t, expectedError, err) +// } func Error(t TestingT, err error, msgAndArgs ...interface{}) bool { if err == nil { if h, ok := t.(tHelper); ok { @@ -1403,8 +1518,8 @@ func Error(t TestingT, err error, msgAndArgs ...interface{}) bool { // EqualError asserts that a function returned an error (i.e. not `nil`) // and that it is equal to the provided error. // -// actualObj, err := SomeFunction() -// assert.EqualError(t, err, expectedErrorString) +// actualObj, err := SomeFunction() +// assert.EqualError(t, err, expectedErrorString) func EqualError(t TestingT, theError error, errString string, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -1426,8 +1541,8 @@ func EqualError(t TestingT, theError error, errString string, msgAndArgs ...inte // ErrorContains asserts that a function returned an error (i.e. not `nil`) // and that the error contains the specified substring. // -// actualObj, err := SomeFunction() -// assert.ErrorContains(t, err, expectedErrorSubString) +// actualObj, err := SomeFunction() +// assert.ErrorContains(t, err, expectedErrorSubString) func ErrorContains(t TestingT, theError error, contains string, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -1460,8 +1575,8 @@ func matchRegexp(rx interface{}, str interface{}) bool { // Regexp asserts that a specified regexp matches a string. // -// assert.Regexp(t, regexp.MustCompile("start"), "it's starting") -// assert.Regexp(t, "start...$", "it's not starting") +// assert.Regexp(t, regexp.MustCompile("start"), "it's starting") +// assert.Regexp(t, "start...$", "it's not starting") func Regexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -1478,8 +1593,8 @@ func Regexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface // NotRegexp asserts that a specified regexp does not match a string. // -// assert.NotRegexp(t, regexp.MustCompile("starts"), "it's starting") -// assert.NotRegexp(t, "^start", "it's not starting") +// assert.NotRegexp(t, regexp.MustCompile("starts"), "it's starting") +// assert.NotRegexp(t, "^start", "it's not starting") func NotRegexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -1591,7 +1706,7 @@ func NoDirExists(t TestingT, path string, msgAndArgs ...interface{}) bool { // JSONEq asserts that two JSON strings are equivalent. // -// assert.JSONEq(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) +// assert.JSONEq(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) func JSONEq(t TestingT, expected string, actual string, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -1714,7 +1829,7 @@ type tHelper interface { // Eventually asserts that given condition will be met in waitFor time, // periodically checking target function each tick. // -// assert.Eventually(t, func() bool { return true; }, time.Second, 10*time.Millisecond) +// assert.Eventually(t, func() bool { return true; }, time.Second, 10*time.Millisecond) func Eventually(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() @@ -1744,10 +1859,93 @@ func Eventually(t TestingT, condition func() bool, waitFor time.Duration, tick t } } +// CollectT implements the TestingT interface and collects all errors. +type CollectT struct { + errors []error +} + +// Errorf collects the error. +func (c *CollectT) Errorf(format string, args ...interface{}) { + c.errors = append(c.errors, fmt.Errorf(format, args...)) +} + +// FailNow panics. +func (c *CollectT) FailNow() { + panic("Assertion failed") +} + +// Reset clears the collected errors. +func (c *CollectT) Reset() { + c.errors = nil +} + +// Copy copies the collected errors to the supplied t. +func (c *CollectT) Copy(t TestingT) { + if tt, ok := t.(tHelper); ok { + tt.Helper() + } + for _, err := range c.errors { + t.Errorf("%v", err) + } +} + +// EventuallyWithT asserts that given condition will be met in waitFor time, +// periodically checking target function each tick. In contrast to Eventually, +// it supplies a CollectT to the condition function, so that the condition +// function can use the CollectT to call other assertions. +// The condition is considered "met" if no errors are raised in a tick. +// The supplied CollectT collects all errors from one tick (if there are any). +// If the condition is not met before waitFor, the collected errors of +// the last tick are copied to t. +// +// externalValue := false +// go func() { +// time.Sleep(8*time.Second) +// externalValue = true +// }() +// assert.EventuallyWithT(t, func(c *assert.CollectT) { +// // add assertions as needed; any assertion failure will fail the current tick +// assert.True(c, externalValue, "expected 'externalValue' to be true") +// }, 1*time.Second, 10*time.Second, "external state has not changed to 'true'; still false") +func EventuallyWithT(t TestingT, condition func(collect *CollectT), waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + + collect := new(CollectT) + ch := make(chan bool, 1) + + timer := time.NewTimer(waitFor) + defer timer.Stop() + + ticker := time.NewTicker(tick) + defer ticker.Stop() + + for tick := ticker.C; ; { + select { + case <-timer.C: + collect.Copy(t) + return Fail(t, "Condition never satisfied", msgAndArgs...) + case <-tick: + tick = nil + collect.Reset() + go func() { + condition(collect) + ch <- len(collect.errors) == 0 + }() + case v := <-ch: + if v { + return true + } + tick = ticker.C + } + } +} + // Never asserts that the given condition doesn't satisfy in waitFor time, // periodically checking the target function each tick. // -// assert.Never(t, func() bool { return false; }, time.Second, 10*time.Millisecond) +// assert.Never(t, func() bool { return false; }, time.Second, 10*time.Millisecond) func Never(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() diff --git a/vertical-pod-autoscaler/vendor/github.com/stretchr/testify/assert/doc.go b/vertical-pod-autoscaler/vendor/github.com/stretchr/testify/assert/doc.go index c9dccc4d6cd0..4953981d3878 100644 --- a/vertical-pod-autoscaler/vendor/github.com/stretchr/testify/assert/doc.go +++ b/vertical-pod-autoscaler/vendor/github.com/stretchr/testify/assert/doc.go @@ -1,39 +1,40 @@ // Package assert provides a set of comprehensive testing tools for use with the normal Go testing system. // -// Example Usage +// # Example Usage // // The following is a complete example using assert in a standard test function: -// import ( -// "testing" -// "github.com/stretchr/testify/assert" -// ) // -// func TestSomething(t *testing.T) { +// import ( +// "testing" +// "github.com/stretchr/testify/assert" +// ) // -// var a string = "Hello" -// var b string = "Hello" +// func TestSomething(t *testing.T) { // -// assert.Equal(t, a, b, "The two words should be the same.") +// var a string = "Hello" +// var b string = "Hello" // -// } +// assert.Equal(t, a, b, "The two words should be the same.") +// +// } // // if you assert many times, use the format below: // -// import ( -// "testing" -// "github.com/stretchr/testify/assert" -// ) +// import ( +// "testing" +// "github.com/stretchr/testify/assert" +// ) // -// func TestSomething(t *testing.T) { -// assert := assert.New(t) +// func TestSomething(t *testing.T) { +// assert := assert.New(t) // -// var a string = "Hello" -// var b string = "Hello" +// var a string = "Hello" +// var b string = "Hello" // -// assert.Equal(a, b, "The two words should be the same.") -// } +// assert.Equal(a, b, "The two words should be the same.") +// } // -// Assertions +// # Assertions // // Assertions allow you to easily write test code, and are global funcs in the `assert` package. // All assertion functions take, as the first argument, the `*testing.T` object provided by the diff --git a/vertical-pod-autoscaler/vendor/github.com/stretchr/testify/assert/http_assertions.go b/vertical-pod-autoscaler/vendor/github.com/stretchr/testify/assert/http_assertions.go index 4ed341dd2893..d8038c28a758 100644 --- a/vertical-pod-autoscaler/vendor/github.com/stretchr/testify/assert/http_assertions.go +++ b/vertical-pod-autoscaler/vendor/github.com/stretchr/testify/assert/http_assertions.go @@ -23,7 +23,7 @@ func httpCode(handler http.HandlerFunc, method, url string, values url.Values) ( // HTTPSuccess asserts that a specified handler returns a success status code. // -// assert.HTTPSuccess(t, myHandler, "POST", "http://www.google.com", nil) +// assert.HTTPSuccess(t, myHandler, "POST", "http://www.google.com", nil) // // Returns whether the assertion was successful (true) or not (false). func HTTPSuccess(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, msgAndArgs ...interface{}) bool { @@ -45,7 +45,7 @@ func HTTPSuccess(t TestingT, handler http.HandlerFunc, method, url string, value // HTTPRedirect asserts that a specified handler returns a redirect status code. // -// assert.HTTPRedirect(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}} +// assert.HTTPRedirect(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}} // // Returns whether the assertion was successful (true) or not (false). func HTTPRedirect(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, msgAndArgs ...interface{}) bool { @@ -67,7 +67,7 @@ func HTTPRedirect(t TestingT, handler http.HandlerFunc, method, url string, valu // HTTPError asserts that a specified handler returns an error status code. // -// assert.HTTPError(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}} +// assert.HTTPError(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}} // // Returns whether the assertion was successful (true) or not (false). func HTTPError(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, msgAndArgs ...interface{}) bool { @@ -89,7 +89,7 @@ func HTTPError(t TestingT, handler http.HandlerFunc, method, url string, values // HTTPStatusCode asserts that a specified handler returns a specified status code. // -// assert.HTTPStatusCode(t, myHandler, "GET", "/notImplemented", nil, 501) +// assert.HTTPStatusCode(t, myHandler, "GET", "/notImplemented", nil, 501) // // Returns whether the assertion was successful (true) or not (false). func HTTPStatusCode(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, statuscode int, msgAndArgs ...interface{}) bool { @@ -124,7 +124,7 @@ func HTTPBody(handler http.HandlerFunc, method, url string, values url.Values) s // HTTPBodyContains asserts that a specified handler returns a // body that contains a string. // -// assert.HTTPBodyContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky") +// assert.HTTPBodyContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky") // // Returns whether the assertion was successful (true) or not (false). func HTTPBodyContains(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) bool { @@ -144,7 +144,7 @@ func HTTPBodyContains(t TestingT, handler http.HandlerFunc, method, url string, // HTTPBodyNotContains asserts that a specified handler returns a // body that does not contain a string. // -// assert.HTTPBodyNotContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky") +// assert.HTTPBodyNotContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky") // // Returns whether the assertion was successful (true) or not (false). func HTTPBodyNotContains(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) bool { diff --git a/vertical-pod-autoscaler/vendor/github.com/stretchr/testify/mock/doc.go b/vertical-pod-autoscaler/vendor/github.com/stretchr/testify/mock/doc.go index 7324128ef19c..d6b3c844cc8b 100644 --- a/vertical-pod-autoscaler/vendor/github.com/stretchr/testify/mock/doc.go +++ b/vertical-pod-autoscaler/vendor/github.com/stretchr/testify/mock/doc.go @@ -1,17 +1,17 @@ // Package mock provides a system by which it is possible to mock your objects // and verify calls are happening as expected. // -// Example Usage +// # Example Usage // // The mock package provides an object, Mock, that tracks activity on another object. It is usually // embedded into a test object as shown below: // -// type MyTestObject struct { -// // add a Mock object instance -// mock.Mock +// type MyTestObject struct { +// // add a Mock object instance +// mock.Mock // -// // other fields go here as normal -// } +// // other fields go here as normal +// } // // When implementing the methods of an interface, you wire your functions up // to call the Mock.Called(args...) method, and return the appropriate values. @@ -19,25 +19,25 @@ // For example, to mock a method that saves the name and age of a person and returns // the year of their birth or an error, you might write this: // -// func (o *MyTestObject) SavePersonDetails(firstname, lastname string, age int) (int, error) { -// args := o.Called(firstname, lastname, age) -// return args.Int(0), args.Error(1) -// } +// func (o *MyTestObject) SavePersonDetails(firstname, lastname string, age int) (int, error) { +// args := o.Called(firstname, lastname, age) +// return args.Int(0), args.Error(1) +// } // // The Int, Error and Bool methods are examples of strongly typed getters that take the argument // index position. Given this argument list: // -// (12, true, "Something") +// (12, true, "Something") // // You could read them out strongly typed like this: // -// args.Int(0) -// args.Bool(1) -// args.String(2) +// args.Int(0) +// args.Bool(1) +// args.String(2) // // For objects of your own type, use the generic Arguments.Get(index) method and make a type assertion: // -// return args.Get(0).(*MyObject), args.Get(1).(*AnotherObjectOfMine) +// return args.Get(0).(*MyObject), args.Get(1).(*AnotherObjectOfMine) // // This may cause a panic if the object you are getting is nil (the type assertion will fail), in those // cases you should check for nil first. diff --git a/vertical-pod-autoscaler/vendor/github.com/stretchr/testify/mock/mock.go b/vertical-pod-autoscaler/vendor/github.com/stretchr/testify/mock/mock.go index e6ff8dfeb201..f4b42e44ffe9 100644 --- a/vertical-pod-autoscaler/vendor/github.com/stretchr/testify/mock/mock.go +++ b/vertical-pod-autoscaler/vendor/github.com/stretchr/testify/mock/mock.go @@ -3,6 +3,7 @@ package mock import ( "errors" "fmt" + "path" "reflect" "regexp" "runtime" @@ -13,6 +14,7 @@ import ( "github.com/davecgh/go-spew/spew" "github.com/pmezard/go-difflib/difflib" "github.com/stretchr/objx" + "github.com/stretchr/testify/assert" ) @@ -99,7 +101,7 @@ func (c *Call) unlock() { // Return specifies the return arguments for the expectation. // -// Mock.On("DoSomething").Return(errors.New("failed")) +// Mock.On("DoSomething").Return(errors.New("failed")) func (c *Call) Return(returnArguments ...interface{}) *Call { c.lock() defer c.unlock() @@ -111,7 +113,7 @@ func (c *Call) Return(returnArguments ...interface{}) *Call { // Panic specifies if the functon call should fail and the panic message // -// Mock.On("DoSomething").Panic("test panic") +// Mock.On("DoSomething").Panic("test panic") func (c *Call) Panic(msg string) *Call { c.lock() defer c.unlock() @@ -123,14 +125,14 @@ func (c *Call) Panic(msg string) *Call { // Once indicates that that the mock should only return the value once. // -// Mock.On("MyMethod", arg1, arg2).Return(returnArg1, returnArg2).Once() +// Mock.On("MyMethod", arg1, arg2).Return(returnArg1, returnArg2).Once() func (c *Call) Once() *Call { return c.Times(1) } // Twice indicates that that the mock should only return the value twice. // -// Mock.On("MyMethod", arg1, arg2).Return(returnArg1, returnArg2).Twice() +// Mock.On("MyMethod", arg1, arg2).Return(returnArg1, returnArg2).Twice() func (c *Call) Twice() *Call { return c.Times(2) } @@ -138,7 +140,7 @@ func (c *Call) Twice() *Call { // Times indicates that that the mock should only return the indicated number // of times. // -// Mock.On("MyMethod", arg1, arg2).Return(returnArg1, returnArg2).Times(5) +// Mock.On("MyMethod", arg1, arg2).Return(returnArg1, returnArg2).Times(5) func (c *Call) Times(i int) *Call { c.lock() defer c.unlock() @@ -149,7 +151,7 @@ func (c *Call) Times(i int) *Call { // WaitUntil sets the channel that will block the mock's return until its closed // or a message is received. // -// Mock.On("MyMethod", arg1, arg2).WaitUntil(time.After(time.Second)) +// Mock.On("MyMethod", arg1, arg2).WaitUntil(time.After(time.Second)) func (c *Call) WaitUntil(w <-chan time.Time) *Call { c.lock() defer c.unlock() @@ -159,7 +161,7 @@ func (c *Call) WaitUntil(w <-chan time.Time) *Call { // After sets how long to block until the call returns // -// Mock.On("MyMethod", arg1, arg2).After(time.Second) +// Mock.On("MyMethod", arg1, arg2).After(time.Second) func (c *Call) After(d time.Duration) *Call { c.lock() defer c.unlock() @@ -171,10 +173,10 @@ func (c *Call) After(d time.Duration) *Call { // mocking a method (such as an unmarshaler) that takes a pointer to a struct and // sets properties in such struct // -// Mock.On("Unmarshal", AnythingOfType("*map[string]interface{}")).Return().Run(func(args Arguments) { -// arg := args.Get(0).(*map[string]interface{}) -// arg["foo"] = "bar" -// }) +// Mock.On("Unmarshal", AnythingOfType("*map[string]interface{}")).Return().Run(func(args Arguments) { +// arg := args.Get(0).(*map[string]interface{}) +// arg["foo"] = "bar" +// }) func (c *Call) Run(fn func(args Arguments)) *Call { c.lock() defer c.unlock() @@ -194,16 +196,18 @@ func (c *Call) Maybe() *Call { // On chains a new expectation description onto the mocked interface. This // allows syntax like. // -// Mock. -// On("MyMethod", 1).Return(nil). -// On("MyOtherMethod", 'a', 'b', 'c').Return(errors.New("Some Error")) +// Mock. +// On("MyMethod", 1).Return(nil). +// On("MyOtherMethod", 'a', 'b', 'c').Return(errors.New("Some Error")) +// //go:noinline func (c *Call) On(methodName string, arguments ...interface{}) *Call { return c.Parent.On(methodName, arguments...) } // Unset removes a mock handler from being called. -// test.On("func", mock.Anything).Unset() +// +// test.On("func", mock.Anything).Unset() func (c *Call) Unset() *Call { var unlockOnce sync.Once @@ -249,9 +253,9 @@ func (c *Call) Unset() *Call { // calls have been called as expected. The referenced calls may be from the // same mock instance and/or other mock instances. // -// Mock.On("Do").Return(nil).Notbefore( -// Mock.On("Init").Return(nil) -// ) +// Mock.On("Do").Return(nil).Notbefore( +// Mock.On("Init").Return(nil) +// ) func (c *Call) NotBefore(calls ...*Call) *Call { c.lock() defer c.unlock() @@ -334,7 +338,7 @@ func (m *Mock) fail(format string, args ...interface{}) { // On starts a description of an expectation of the specified method // being called. // -// Mock.On("MyMethod", arg1, arg2) +// Mock.On("MyMethod", arg1, arg2) func (m *Mock) On(methodName string, arguments ...interface{}) *Call { for _, arg := range arguments { if v := reflect.ValueOf(arg); v.Kind() == reflect.Func { @@ -424,6 +428,10 @@ func callString(method string, arguments Arguments, includeArgumentValues bool) if includeArgumentValues { var argVals []string for argIndex, arg := range arguments { + if _, ok := arg.(*FunctionalOptionsArgument); ok { + argVals = append(argVals, fmt.Sprintf("%d: %s", argIndex, arg)) + continue + } argVals = append(argVals, fmt.Sprintf("%d: %#v", argIndex, arg)) } argValsString = fmt.Sprintf("\n\t\t%s", strings.Join(argVals, "\n\t\t")) @@ -758,6 +766,7 @@ type AnythingOfTypeArgument string // name of the type to check for. Used in Diff and Assert. // // For example: +// // Assert(t, AnythingOfType("string"), AnythingOfType("int")) func AnythingOfType(t string) AnythingOfTypeArgument { return AnythingOfTypeArgument(t) @@ -780,6 +789,34 @@ func IsType(t interface{}) *IsTypeArgument { return &IsTypeArgument{t: t} } +// FunctionalOptionsArgument is a struct that contains the type and value of an functional option argument +// for use when type checking. +type FunctionalOptionsArgument struct { + value interface{} +} + +// String returns the string representation of FunctionalOptionsArgument +func (f *FunctionalOptionsArgument) String() string { + var name string + tValue := reflect.ValueOf(f.value) + if tValue.Len() > 0 { + name = "[]" + reflect.TypeOf(tValue.Index(0).Interface()).String() + } + + return strings.Replace(fmt.Sprintf("%#v", f.value), "[]interface {}", name, 1) +} + +// FunctionalOptions returns an FunctionalOptionsArgument object containing the functional option type +// and the values to check of +// +// For example: +// Assert(t, FunctionalOptions("[]foo.FunctionalOption", foo.Opt1(), foo.Opt2())) +func FunctionalOptions(value ...interface{}) *FunctionalOptionsArgument { + return &FunctionalOptionsArgument{ + value: value, + } +} + // argumentMatcher performs custom argument matching, returning whether or // not the argument is matched by the expectation fixture function. type argumentMatcher struct { @@ -926,6 +963,29 @@ func (args Arguments) Diff(objects []interface{}) (string, int) { differences++ output = fmt.Sprintf("%s\t%d: FAIL: type %s != type %s - %s\n", output, i, reflect.TypeOf(t).Name(), reflect.TypeOf(actual).Name(), actualFmt) } + } else if reflect.TypeOf(expected) == reflect.TypeOf((*FunctionalOptionsArgument)(nil)) { + t := expected.(*FunctionalOptionsArgument).value + + var name string + tValue := reflect.ValueOf(t) + if tValue.Len() > 0 { + name = "[]" + reflect.TypeOf(tValue.Index(0).Interface()).String() + } + + tName := reflect.TypeOf(t).Name() + if name != reflect.TypeOf(actual).String() && tValue.Len() != 0 { + differences++ + output = fmt.Sprintf("%s\t%d: FAIL: type %s != type %s - %s\n", output, i, tName, reflect.TypeOf(actual).Name(), actualFmt) + } else { + if ef, af := assertOpts(t, actual); ef == "" && af == "" { + // match + output = fmt.Sprintf("%s\t%d: PASS: %s == %s\n", output, i, tName, tName) + } else { + // not match + differences++ + output = fmt.Sprintf("%s\t%d: FAIL: %s != %s\n", output, i, af, ef) + } + } } else { // normal checking @@ -1102,3 +1162,65 @@ var spewConfig = spew.ConfigState{ type tHelper interface { Helper() } + +func assertOpts(expected, actual interface{}) (expectedFmt, actualFmt string) { + expectedOpts := reflect.ValueOf(expected) + actualOpts := reflect.ValueOf(actual) + var expectedNames []string + for i := 0; i < expectedOpts.Len(); i++ { + expectedNames = append(expectedNames, funcName(expectedOpts.Index(i).Interface())) + } + var actualNames []string + for i := 0; i < actualOpts.Len(); i++ { + actualNames = append(actualNames, funcName(actualOpts.Index(i).Interface())) + } + if !assert.ObjectsAreEqual(expectedNames, actualNames) { + expectedFmt = fmt.Sprintf("%v", expectedNames) + actualFmt = fmt.Sprintf("%v", actualNames) + return + } + + for i := 0; i < expectedOpts.Len(); i++ { + expectedOpt := expectedOpts.Index(i).Interface() + actualOpt := actualOpts.Index(i).Interface() + + expectedFunc := expectedNames[i] + actualFunc := actualNames[i] + if expectedFunc != actualFunc { + expectedFmt = expectedFunc + actualFmt = actualFunc + return + } + + ot := reflect.TypeOf(expectedOpt) + var expectedValues []reflect.Value + var actualValues []reflect.Value + if ot.NumIn() == 0 { + return + } + + for i := 0; i < ot.NumIn(); i++ { + vt := ot.In(i).Elem() + expectedValues = append(expectedValues, reflect.New(vt)) + actualValues = append(actualValues, reflect.New(vt)) + } + + reflect.ValueOf(expectedOpt).Call(expectedValues) + reflect.ValueOf(actualOpt).Call(actualValues) + + for i := 0; i < ot.NumIn(); i++ { + if !assert.ObjectsAreEqual(expectedValues[i].Interface(), actualValues[i].Interface()) { + expectedFmt = fmt.Sprintf("%s %+v", expectedNames[i], expectedValues[i].Interface()) + actualFmt = fmt.Sprintf("%s %+v", expectedNames[i], actualValues[i].Interface()) + return + } + } + } + + return "", "" +} + +func funcName(opt interface{}) string { + n := runtime.FuncForPC(reflect.ValueOf(opt).Pointer()).Name() + return strings.TrimSuffix(path.Base(n), path.Ext(n)) +} diff --git a/vertical-pod-autoscaler/vendor/modules.txt b/vertical-pod-autoscaler/vendor/modules.txt index 26c7aa8b0cc0..af75dac0719b 100644 --- a/vertical-pod-autoscaler/vendor/modules.txt +++ b/vertical-pod-autoscaler/vendor/modules.txt @@ -1,3 +1,15 @@ +# github.com/argoproj/argo-rollouts v1.6.6 +## explicit; go 1.20 +github.com/argoproj/argo-rollouts/pkg/apis/rollouts +github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1 +github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned +github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/scheme +github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned/typed/rollouts/v1alpha1 +github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions +github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/internalinterfaces +github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/rollouts +github.com/argoproj/argo-rollouts/pkg/client/informers/externalversions/rollouts/v1alpha1 +github.com/argoproj/argo-rollouts/pkg/client/listers/rollouts/v1alpha1 # github.com/beorn7/perks v1.0.1 ## explicit; go 1.11 github.com/beorn7/perks/quantile @@ -14,7 +26,7 @@ github.com/davecgh/go-spew/spew ## explicit; go 1.13 github.com/emicklei/go-restful/v3 github.com/emicklei/go-restful/v3/log -# github.com/evanphx/json-patch v4.12.0+incompatible +# github.com/evanphx/json-patch v5.6.0+incompatible ## explicit github.com/evanphx/json-patch # github.com/fsnotify/fsnotify v1.7.0 @@ -71,8 +83,8 @@ github.com/google/gofuzz/bytesource # github.com/google/uuid v1.3.0 ## explicit github.com/google/uuid -# github.com/imdario/mergo v0.3.6 -## explicit +# github.com/imdario/mergo v0.3.13 +## explicit; go 1.13 github.com/imdario/mergo # github.com/inconshreveable/mousetrap v1.1.0 ## explicit; go 1.18 @@ -136,8 +148,8 @@ github.com/spf13/pflag # github.com/stretchr/objx v0.5.0 ## explicit; go 1.12 github.com/stretchr/objx -# github.com/stretchr/testify v1.8.2 -## explicit; go 1.13 +# github.com/stretchr/testify v1.8.4 +## explicit; go 1.20 github.com/stretchr/testify/assert github.com/stretchr/testify/mock # golang.org/x/mod v0.10.0 @@ -152,7 +164,7 @@ golang.org/x/net/http/httpguts golang.org/x/net/http2 golang.org/x/net/http2/hpack golang.org/x/net/idna -# golang.org/x/oauth2 v0.8.0 +# golang.org/x/oauth2 v0.10.0 ## explicit; go 1.17 golang.org/x/oauth2 golang.org/x/oauth2/internal