From 693b2151faea4ba90c10b7166836407473de09ad Mon Sep 17 00:00:00 2001 From: Matt Groot Date: Wed, 17 Aug 2022 00:06:27 -0500 Subject: [PATCH 1/3] [ISSUE-9437] add appset progressive rollout feature Signed-off-by: Matt Groot --- USERS.md | 1 + .../controllers/applicationset_controller.go | 379 +++++ .../applicationset_controller_test.go | 1407 +++++++++++++++++ .../applicationset/Progressive-Rollouts.md | 95 ++ manifests/core-install.yaml | 52 + manifests/crds/applicationset-crd.yaml | 52 + manifests/ha/install.yaml | 52 + manifests/install.yaml | 52 + mkdocs.yml | 1 + .../v1alpha1/applicationset_types.go | 57 +- .../v1alpha1/zz_generated.deepcopy.go | 121 ++ 11 files changed, 2268 insertions(+), 1 deletion(-) create mode 100644 docs/operator-manual/applicationset/Progressive-Rollouts.md diff --git a/USERS.md b/USERS.md index 9133bd8124d82..f42f3ee78f1c6 100644 --- a/USERS.md +++ b/USERS.md @@ -86,6 +86,7 @@ Currently, the following organizations are **officially** using Argo CD: 1. [Ibotta](https://home.ibotta.com) 1. [IITS-Consulting](https://iits-consulting.de) 1. [imaware](https://imaware.health) +1. [Indeed](https://indeed.com) 1. [Index Exchange](https://www.indexexchange.com/) 1. [InsideBoard](https://www.insideboard.com) 1. [Intuit](https://www.intuit.com/) diff --git a/applicationset/controllers/applicationset_controller.go b/applicationset/controllers/applicationset_controller.go index 209bf426da579..baeb95e647088 100644 --- a/applicationset/controllers/applicationset_controller.go +++ b/applicationset/controllers/applicationset_controller.go @@ -23,6 +23,7 @@ import ( corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/types" + "k8s.io/apimachinery/pkg/util/intstr" "k8s.io/client-go/kubernetes" "k8s.io/client-go/tools/record" "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil" @@ -133,6 +134,36 @@ func (r *ApplicationSetReconciler) Reconcile(ctx context.Context, req ctrl.Reque return ctrl.Result{RequeueAfter: ReconcileRequeueOnValidationError}, nil } + applications, err := r.getCurrentApplications(ctx, applicationSetInfo) + if err != nil { + return ctrl.Result{}, err + } + + _, err = r.updateApplicationSetApplicationStatus(ctx, &applicationSetInfo, applications) + if err != nil { + return ctrl.Result{}, err + } + + appDependencyList, appStepMap, err := r.buildAppDependencyList(ctx, applicationSetInfo, desiredApplications) + if err != nil { + return ctrl.Result{}, err + } + + appSyncMap, err := r.buildAppSyncMap(ctx, applicationSetInfo, appDependencyList) + if err != nil { + return ctrl.Result{}, err + } + + _, err = r.updateApplicationSetApplicationStatusProgress(ctx, &applicationSetInfo, appSyncMap, appStepMap) + if err != nil { + return ctrl.Result{}, err + } + + _, err = r.updateApplicationSetApplicationStatusConditions(ctx, &applicationSetInfo) + if err != nil { + return ctrl.Result{}, err + } + var validApps []argov1alpha1.Application for i := range desiredApplications { if validateErrors[i] == nil { @@ -161,6 +192,21 @@ func (r *ApplicationSetReconciler) Reconcile(ctx context.Context, req ctrl.Reque ) } + // filter down valid applications if rollout strategy is enabled + strategy := applicationSetInfo.Spec.Strategy + if strategy != nil && strategy.Type == "RollingUpdate" { + var rolloutApps []argov1alpha1.Application + for i := range validApps { + // check appSyncMap to determine which Applications are ready to be updated and which should be skipped + if !appSyncMap[validApps[i].Name] { + log.Infof("skipping application generation, waiting for previous rollouts to complete before updating: %v", validApps[i].Name) + continue + } + rolloutApps = append(rolloutApps, validApps[i]) + } + validApps = rolloutApps + } + if r.Policy.Update() { err = r.createOrUpdateInCluster(ctx, applicationSetInfo, validApps) if err != nil { @@ -349,6 +395,65 @@ func (r *ApplicationSetReconciler) setApplicationSetStatusCondition(ctx context. return nil } +func findApplicationStatusIndex(appStatuses []argoprojiov1alpha1.ApplicationSetApplicationStatus, application string) int { + for i := range appStatuses { + if appStatuses[i].Application == application { + return i + } + } + return -1 +} + +func (r *ApplicationSetReconciler) setApplicationSetApplicationStatus(ctx context.Context, applicationSet *argoprojiov1alpha1.ApplicationSet, applicationStatuses []argoprojiov1alpha1.ApplicationSetApplicationStatus) error { + + needToUpdateStatus := false + for i := range applicationStatuses { + appStatus := applicationStatuses[i] + idx := findApplicationStatusIndex(applicationSet.Status.ApplicationStatus, appStatus.Application) + if idx == -1 { + needToUpdateStatus = true + break + } + currentStatus := applicationSet.Status.ApplicationStatus[idx] + if currentStatus.Message != appStatus.Message || currentStatus.Status != appStatus.Status || currentStatus.ObservedGeneration != appStatus.ObservedGeneration { + needToUpdateStatus = true + break + } + } + + if needToUpdateStatus { + // fetch updated Application Set object before updating it + namespacedName := types.NamespacedName{Namespace: applicationSet.Namespace, Name: applicationSet.Name} + if err := r.Get(ctx, namespacedName, applicationSet); err != nil { + if client.IgnoreNotFound(err) != nil { + return nil + } + return fmt.Errorf("error fetching updated application set: %v", err) + } + + for i := range applicationStatuses { + applicationSet.Status.SetApplicationStatus(applicationStatuses[i]) + } + + // Update the newly fetched object with new set of ApplicationStatus + err := r.Client.Status().Update(ctx, applicationSet) + if err != nil { + + log.Errorf("unable to set application set status: %v", err) + return fmt.Errorf("unable to set application set status: %v", err) + } + + if err := r.Get(ctx, namespacedName, applicationSet); err != nil { + if client.IgnoreNotFound(err) != nil { + return nil + } + return fmt.Errorf("error fetching updated application set: %v", err) + } + } + + return nil +} + // validateGeneratedApplications uses the Argo CD validation functions to verify the correctness of the // generated applications. func (r *ApplicationSetReconciler) validateGeneratedApplications(ctx context.Context, desiredApplications []argov1alpha1.Application, applicationSetInfo argoprojiov1alpha1.ApplicationSet, namespace string) (map[int]error, error) { @@ -721,4 +826,278 @@ func (r *ApplicationSetReconciler) removeFinalizerOnInvalidDestination(ctx conte return nil } +// this list tracks which Applications belong to each RollingUpdate step +func (r *ApplicationSetReconciler) buildAppDependencyList(ctx context.Context, applicationSet argoprojiov1alpha1.ApplicationSet, applications []argov1alpha1.Application) ([][]string, map[string]int, error) { + + if applicationSet.Spec.Strategy == nil || applicationSet.Spec.Strategy.RollingUpdate == nil { + return [][]string{}, map[string]int{}, nil + } + steps := applicationSet.Spec.Strategy.RollingUpdate.Steps + + appDependencyList := make([][]string, 0) + for range steps { + appDependencyList = append(appDependencyList, make([]string, 0)) + } + + appStepMap := map[string]int{} + + // use applicationLabelSelectors to filter generated Applications into steps and status by name + for _, app := range applications { + for i, step := range steps { + + selected := true // default to true, assuming the current Application is a match for the given step matchExpression + for _, matchExpression := range step.MatchExpressions { + + if val, ok := app.Labels[matchExpression.Key]; ok { + if matchExpression.Operator == "In" { + valueMatched := false + for _, value := range matchExpression.Values { + if val == value { + valueMatched = true + break + } + } + // none of the matchExpression values was a match with the Applications labels + if !valueMatched { + selected = false + break + } + // handle invalid operator selection + } else { + log.Warnf("skipping AppSet rollingUpdate step Application selection for '%v', invalid matchExpression operate provided: '%v' ", applicationSet.Name, matchExpression.Operator) + selected = false + break + } + // no matching label key found for the current Application + } else { + selected = false + break + } + } + + if selected { + appDependencyList[i] = append(appDependencyList[i], app.Name) + if val, ok := appStepMap[app.Name]; ok { + log.Warnf("AppSet '%v' has a invalid matchExpression that selects Application '%v' label twice, in steps %v and %v", applicationSet.Name, app.Name, val, i) + } else { + appStepMap[app.Name] = i + } + } + } + } + + return appDependencyList, appStepMap, nil +} + +// this map is used to determine which stage of Applications are ready to be updated in the reconciler loop +func (r *ApplicationSetReconciler) buildAppSyncMap(ctx context.Context, applicationSet argoprojiov1alpha1.ApplicationSet, appDependencyList [][]string) (map[string]bool, error) { + appSyncMap := map[string]bool{} + syncEnabled := true + + // healthy stages and the first non-healthy stage should have sync enabled + // every stage after should have sync disabled + + for i := range appDependencyList { + // set the syncEnabled boolean for every Application in the current step + for _, appName := range appDependencyList[i] { + appSyncMap[appName] = syncEnabled + } + + // detect if we need to halt before progressing to the next step + for _, appName := range appDependencyList[i] { + idx := findApplicationStatusIndex(applicationSet.Status.ApplicationStatus, appName) + if idx == -1 { + // no Application status found, likely because the Application is being newly created + syncEnabled = false + break + } + appStatus := applicationSet.Status.ApplicationStatus[idx] + if appStatus.Status != "Healthy" || appStatus.ObservedGeneration != applicationSet.Generation { + syncEnabled = false + break + } + } + } + + return appSyncMap, nil +} + +// check the status of each Application's status and promote Applications to the next status if needed +func (r *ApplicationSetReconciler) updateApplicationSetApplicationStatus(ctx context.Context, applicationSet *argoprojiov1alpha1.ApplicationSet, applications []argov1alpha1.Application) ([]argoprojiov1alpha1.ApplicationSetApplicationStatus, error) { + + now := metav1.Now() + appStatuses := make([]argoprojiov1alpha1.ApplicationSetApplicationStatus, 0, len(applications)) + + for _, app := range applications { + + statusString := string(app.Status.Health.Status) + idx := findApplicationStatusIndex(applicationSet.Status.ApplicationStatus, app.Name) + + if idx == -1 { + // AppStatus not found, set default status of "Waiting" + appStatuses = append(appStatuses, argoprojiov1alpha1.ApplicationSetApplicationStatus{ + Application: app.Name, + LastTransitionTime: &now, + Message: "No Application status found, defaulting status to Waiting.", + ObservedGeneration: applicationSet.Generation, // TODO: this should probably not be set to the current generation, maybe -1 instead? + Status: "Waiting", + }) + } else { + // we have an existing AppStatus + currentAppStatus := applicationSet.Status.ApplicationStatus[idx] + + if currentAppStatus.ObservedGeneration < applicationSet.Generation { + currentAppStatus.LastTransitionTime = &now + currentAppStatus.Status = "Waiting" + currentAppStatus.Message = "Application is out of date with the current AppSet generation, setting status to Waiting." + } + + if currentAppStatus.Status == "Pending" { + if statusString == "Progressing" { + log.Infof("Application %v has entered Progressing status, updating its ApplciationSet status to Progressing", app.Name) + currentAppStatus.LastTransitionTime = &now + currentAppStatus.Status = statusString + currentAppStatus.Message = "Application resource became Progressing, updating status from Pending to Progressing." + } else { + duration := now.Sub(currentAppStatus.LastTransitionTime.Time) + log.Infof("%v pending duration minutes = %v", app.Name, duration.Minutes()) + // handle timeout case where Application never proceeds to "Progressing", set status back to "Healthy" + if duration.Minutes() > 5 { + log.Infof("Application %v has been in Pending status for >5min, moving back to Healthy", app.Name) + currentAppStatus.LastTransitionTime = &now + currentAppStatus.Status = "Healthy" + currentAppStatus.Message = "Application Pending status timed out while waiting to become Progressing, reset status to Healthy." + } + } + } + + if currentAppStatus.Status == "Progressing" && statusString == "Healthy" { + log.Infof("Application %v has completed Progressing status, updating its ApplicationSet status to Healthy", app.Name) + currentAppStatus.LastTransitionTime = &now + currentAppStatus.Status = statusString + currentAppStatus.Message = "Application resource became Healthy, updating status from Progressing to Healthy." + } + + appStatuses = append(appStatuses, currentAppStatus) + } + } + + err := r.setApplicationSetApplicationStatus(ctx, applicationSet, appStatuses) + if err != nil { + return nil, err + } + + return appStatuses, nil +} + +// check Applications that are in Waiting status and promote them to Pending if needed +func (r *ApplicationSetReconciler) updateApplicationSetApplicationStatusProgress(ctx context.Context, applicationSet *argoprojiov1alpha1.ApplicationSet, appSyncMap map[string]bool, appStepMap map[string]int) ([]argoprojiov1alpha1.ApplicationSetApplicationStatus, error) { + now := metav1.Now() + + appStatuses := make([]argoprojiov1alpha1.ApplicationSetApplicationStatus, 0, len(applicationSet.Status.ApplicationStatus)) + + // if we have no RollingUpdate steps, clear out the existing ApplicationStatus entries + if applicationSet.Spec.Strategy != nil && applicationSet.Spec.Strategy.RollingUpdate != nil { + updateCountMap := []int{} + totalCountMap := []int{} + for s := 0; s < len(applicationSet.Spec.Strategy.RollingUpdate.Steps); s++ { + updateCountMap = append(updateCountMap, 0) + totalCountMap = append(totalCountMap, 0) + } + + // populate updateCountMap with counts of existing Pending and Progressing Applications + for _, appStatus := range applicationSet.Status.ApplicationStatus { + totalCountMap[appStepMap[appStatus.Application]] += 1 + if appStatus.ObservedGeneration == applicationSet.Generation && (appStatus.Status == "Pending" || appStatus.Status == "Progressing") { + updateCountMap[appStepMap[appStatus.Application]] += 1 + } + } + + for _, appStatus := range applicationSet.Status.ApplicationStatus { + + maxUpdateAllowed := true + maxUpdate := applicationSet.Spec.Strategy.RollingUpdate.Steps[appStepMap[appStatus.Application]].MaxUpdate + + // allow any updates if maxUpdate is unset or explicitly 0 + if maxUpdate != nil && !(maxUpdate.Type == intstr.Int && maxUpdate.IntVal == 0) { + maxUpdateVal, err := intstr.GetScaledValueFromIntOrPercent(maxUpdate, totalCountMap[appStepMap[appStatus.Application]], false) + if err != nil { + log.Warnf("AppSet '%v' has a invalid maxUpdate value '%+v', ignoring maxUpdate logic for this step: %v", applicationSet.Name, maxUpdate, err) + } + + // ensure non-zero values always floor to 1, even while rounding down + if maxUpdateVal == 0 { + maxUpdateVal = 1 + } + + if updateCountMap[appStepMap[appStatus.Application]] >= maxUpdateVal { + maxUpdateAllowed = false + } + } + + if appStatus.Status == "Waiting" && appSyncMap[appStatus.Application] && maxUpdateAllowed { + log.Infof("Application %v moved to Pending status, watching for the Application to start Progressing", appStatus.Application) + appStatus.LastTransitionTime = &now + appStatus.Status = "Pending" + appStatus.ObservedGeneration = applicationSet.Generation + appStatus.Message = "Application moved to Pending status, watching for the Application resource to start Progressing." + + updateCountMap[appStepMap[appStatus.Application]] += 1 + } + + appStatuses = append(appStatuses, appStatus) + } + } + + err := r.setApplicationSetApplicationStatus(ctx, applicationSet, appStatuses) + if err != nil { + return nil, err + } + + return appStatuses, nil +} + +func (r *ApplicationSetReconciler) updateApplicationSetApplicationStatusConditions(ctx context.Context, applicationSet *argoprojiov1alpha1.ApplicationSet) ([]argoprojiov1alpha1.ApplicationSetCondition, error) { + + appSetProgressing := false + for _, appStatus := range applicationSet.Status.ApplicationStatus { + if appStatus.Status != "Healthy" { + appSetProgressing = true + break + } + } + + appSetConditionProgressing := false + for _, appSetCondition := range applicationSet.Status.Conditions { + if appSetCondition.Type == argoprojiov1alpha1.ApplicationSetConditionRolloutProgressing && appSetCondition.Status == argoprojiov1alpha1.ApplicationSetConditionStatusTrue { + appSetConditionProgressing = true + break + } + } + + if appSetProgressing && !appSetConditionProgressing { + _ = r.setApplicationSetStatusCondition(ctx, + applicationSet, + argoprojiov1alpha1.ApplicationSetCondition{ + Type: argoprojiov1alpha1.ApplicationSetConditionRolloutProgressing, + Message: "ApplicationSet Rollout Rollout started", + Reason: argoprojiov1alpha1.ApplicationSetReasonApplicationSetModified, + Status: argoprojiov1alpha1.ApplicationSetConditionStatusTrue, + }, false, + ) + } else if !appSetProgressing && appSetConditionProgressing { + _ = r.setApplicationSetStatusCondition(ctx, + applicationSet, + argoprojiov1alpha1.ApplicationSetCondition{ + Type: argoprojiov1alpha1.ApplicationSetConditionRolloutProgressing, + Message: "ApplicationSet Rollout Rollout complete", + Reason: argoprojiov1alpha1.ApplicationSetReasonApplicationSetRolloutComplete, + Status: argoprojiov1alpha1.ApplicationSetConditionStatusFalse, + }, false, + ) + } + + return applicationSet.Status.Conditions, nil +} + var _ handler.EventHandler = &clusterSecretEventHandler{} diff --git a/applicationset/controllers/applicationset_controller_test.go b/applicationset/controllers/applicationset_controller_test.go index a945365470012..e31bcb892f896 100644 --- a/applicationset/controllers/applicationset_controller_test.go +++ b/applicationset/controllers/applicationset_controller_test.go @@ -16,6 +16,7 @@ import ( metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/types" + "k8s.io/apimachinery/pkg/util/intstr" "k8s.io/client-go/tools/record" ctrl "sigs.k8s.io/controller-runtime" crtclient "sigs.k8s.io/controller-runtime/pkg/client" @@ -25,6 +26,7 @@ import ( "github.com/argoproj/argo-cd/v2/applicationset/generators" "github.com/argoproj/argo-cd/v2/applicationset/utils" argov1alpha1 "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1" + "github.com/argoproj/gitops-engine/pkg/health" apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1" kubefake "k8s.io/client-go/kubernetes/fake" @@ -1926,3 +1928,1408 @@ func TestSetApplicationSetStatusCondition(t *testing.T) { assert.Len(t, appSet.Status.Conditions, 3) } + +func TestSetApplicationSetApplicationStatus(t *testing.T) { + scheme := runtime.NewScheme() + err := argoprojiov1alpha1.AddToScheme(scheme) + assert.Nil(t, err) + err = argov1alpha1.AddToScheme(scheme) + assert.Nil(t, err) + + appSet := argoprojiov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argoprojiov1alpha1.ApplicationSetSpec{ + Generators: []argoprojiov1alpha1.ApplicationSetGenerator{ + {List: &argoprojiov1alpha1.ListGenerator{ + Elements: []apiextensionsv1.JSON{{ + Raw: []byte(`{"cluster": "my-cluster","url": "https://kubernetes.default.svc"}`), + }}, + }}, + }, + Template: argoprojiov1alpha1.ApplicationSetTemplate{}, + }, + } + + appStatuses := []argoprojiov1alpha1.ApplicationSetApplicationStatus{ + argoprojiov1alpha1.ApplicationSetApplicationStatus{ + Application: "my-application", + LastTransitionTime: &metav1.Time{}, + Message: "testing SetApplicationSetApplicationStatus to Healthy", + ObservedGeneration: 1, + Status: "Healthy", + }, + } + + kubeclientset := kubefake.NewSimpleClientset([]runtime.Object{}...) + argoDBMock := dbmocks.ArgoDB{} + argoObjs := []runtime.Object{} + + client := fake.NewClientBuilder().WithScheme(scheme).WithObjects(&appSet).Build() + + r := ApplicationSetReconciler{ + Log: ctrl.Log.WithName("controllers").WithName("ApplicationSet"), + Client: client, + Scheme: scheme, + Renderer: &utils.Render{}, + Recorder: record.NewFakeRecorder(1), + Generators: map[string]generators.Generator{ + "List": generators.NewListGenerator(), + }, + ArgoDB: &argoDBMock, + ArgoAppClientset: appclientset.NewSimpleClientset(argoObjs...), + KubeClientset: kubeclientset, + } + + err = r.setApplicationSetApplicationStatus(context.TODO(), &appSet, appStatuses) + assert.Nil(t, err) + + assert.Len(t, appSet.Status.ApplicationStatus, 1) +} + +func TestBuildAppDependencyList(t *testing.T) { + + scheme := runtime.NewScheme() + err := argoprojiov1alpha1.AddToScheme(scheme) + assert.Nil(t, err) + + err = argov1alpha1.AddToScheme(scheme) + assert.Nil(t, err) + + client := fake.NewClientBuilder().WithScheme(scheme).Build() + + for _, cc := range []struct { + name string + appSet argoprojiov1alpha1.ApplicationSet + apps []argov1alpha1.Application + expectedList [][]string + expectedStepMap map[string]int + }{ + { + name: "handles an empty set of applications and no strategy", + appSet: argoprojiov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argoprojiov1alpha1.ApplicationSetSpec{}, + }, + apps: []argov1alpha1.Application{}, + expectedList: [][]string{}, + expectedStepMap: map[string]int{}, + }, + { + name: "handles an empty set of applications and ignores AllAtOnce strategy", + appSet: argoprojiov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argoprojiov1alpha1.ApplicationSetSpec{ + Strategy: &argoprojiov1alpha1.ApplicationSetStrategy{ + Type: "AllAtOnce", + }, + }, + }, + apps: []argov1alpha1.Application{}, + expectedList: [][]string{}, + expectedStepMap: map[string]int{}, + }, + { + name: "handles an empty set of applications with good selectors", + appSet: argoprojiov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argoprojiov1alpha1.ApplicationSetSpec{ + Strategy: &argoprojiov1alpha1.ApplicationSetStrategy{ + Type: "RollingUpdate", + RollingUpdate: &argoprojiov1alpha1.ApplicationSetRollingUpdateStrategy{ + Steps: []argoprojiov1alpha1.ApplicationSetRollingUpdateStep{ + { + MatchExpressions: []argoprojiov1alpha1.ApplicationMatchExpression{ + { + Key: "env", + Operator: "In", + Values: []string{ + "dev", + }, + }, + }, + }, + }, + }, + }, + }, + }, + apps: []argov1alpha1.Application{}, + expectedList: [][]string{ + {}, + }, + expectedStepMap: map[string]int{}, + }, + { + name: "handles selecting 1 application with 1 selector", + appSet: argoprojiov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argoprojiov1alpha1.ApplicationSetSpec{ + Strategy: &argoprojiov1alpha1.ApplicationSetStrategy{ + Type: "RollingUpdate", + RollingUpdate: &argoprojiov1alpha1.ApplicationSetRollingUpdateStrategy{ + Steps: []argoprojiov1alpha1.ApplicationSetRollingUpdateStep{ + { + MatchExpressions: []argoprojiov1alpha1.ApplicationMatchExpression{ + { + Key: "env", + Operator: "In", + Values: []string{ + "dev", + }, + }, + }, + }, + }, + }, + }, + }, + }, + apps: []argov1alpha1.Application{ + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app-dev", + Labels: map[string]string{ + "env": "dev", + }, + }, + }, + }, + expectedList: [][]string{ + {"app-dev"}, + }, + expectedStepMap: map[string]int{ + "app-dev": 0, + }, + }, + { + name: "handles selectors that select no applications", + appSet: argoprojiov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argoprojiov1alpha1.ApplicationSetSpec{ + Strategy: &argoprojiov1alpha1.ApplicationSetStrategy{ + Type: "RollingUpdate", + RollingUpdate: &argoprojiov1alpha1.ApplicationSetRollingUpdateStrategy{ + Steps: []argoprojiov1alpha1.ApplicationSetRollingUpdateStep{ + { + MatchExpressions: []argoprojiov1alpha1.ApplicationMatchExpression{ + { + Key: "env", + Operator: "In", + Values: []string{ + "dev", + }, + }, + }, + }, + { + MatchExpressions: []argoprojiov1alpha1.ApplicationMatchExpression{ + { + Key: "env", + Operator: "In", + Values: []string{ + "qa", + }, + }, + }, + }, + { + MatchExpressions: []argoprojiov1alpha1.ApplicationMatchExpression{ + { + Key: "env", + Operator: "In", + Values: []string{ + "prod", + }, + }, + }, + }, + }, + }, + }, + }, + }, + apps: []argov1alpha1.Application{ + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app-qa", + Labels: map[string]string{ + "env": "qa", + }, + }, + }, + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app-prod", + Labels: map[string]string{ + "env": "prod", + }, + }, + }, + }, + expectedList: [][]string{ + {}, + {"app-qa"}, + {"app-prod"}, + }, + expectedStepMap: map[string]int{ + "app-qa": 1, + "app-prod": 2, + }, + }, + { + name: "handles multiple selectors in the same matchExpression", + appSet: argoprojiov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argoprojiov1alpha1.ApplicationSetSpec{ + Strategy: &argoprojiov1alpha1.ApplicationSetStrategy{ + Type: "RollingUpdate", + RollingUpdate: &argoprojiov1alpha1.ApplicationSetRollingUpdateStrategy{ + Steps: []argoprojiov1alpha1.ApplicationSetRollingUpdateStep{ + { + MatchExpressions: []argoprojiov1alpha1.ApplicationMatchExpression{ + { + Key: "region", + Operator: "In", + Values: []string{ + "us-east-2", + }, + }, + { + Key: "env", + Operator: "In", + Values: []string{ + "qa", + }, + }, + }, + }, + }, + }, + }, + }, + }, + apps: []argov1alpha1.Application{ + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app-qa1", + Labels: map[string]string{ + "env": "qa", + }, + }, + }, + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app-qa2", + Labels: map[string]string{ + "env": "qa", + "region": "us-east-2", + }, + }, + }, + }, + expectedList: [][]string{ + {"app-qa2"}, + }, + expectedStepMap: map[string]int{ + "app-qa2": 0, + }, + }, + { + name: "handles multiple values in the same matchExpression", + appSet: argoprojiov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argoprojiov1alpha1.ApplicationSetSpec{ + Strategy: &argoprojiov1alpha1.ApplicationSetStrategy{ + Type: "RollingUpdate", + RollingUpdate: &argoprojiov1alpha1.ApplicationSetRollingUpdateStrategy{ + Steps: []argoprojiov1alpha1.ApplicationSetRollingUpdateStep{ + { + MatchExpressions: []argoprojiov1alpha1.ApplicationMatchExpression{ + { + Key: "env", + Operator: "In", + Values: []string{ + "qa", + "prod", + }, + }, + }, + }, + }, + }, + }, + }, + }, + apps: []argov1alpha1.Application{ + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app-dev", + Labels: map[string]string{ + "env": "dev", + }, + }, + }, + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app-qa", + Labels: map[string]string{ + "env": "qa", + }, + }, + }, + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app-prod", + Labels: map[string]string{ + "env": "prod", + "region": "us-east-2", + }, + }, + }, + }, + expectedList: [][]string{ + {"app-qa", "app-prod"}, + }, + expectedStepMap: map[string]int{ + "app-qa": 0, + "app-prod": 0, + }, + }, + } { + + t.Run(cc.name, func(t *testing.T) { + + kubeclientset := kubefake.NewSimpleClientset([]runtime.Object{}...) + argoDBMock := dbmocks.ArgoDB{} + argoObjs := []runtime.Object{} + + r := ApplicationSetReconciler{ + Client: client, + Scheme: scheme, + Recorder: record.NewFakeRecorder(1), + Generators: map[string]generators.Generator{}, + ArgoDB: &argoDBMock, + ArgoAppClientset: appclientset.NewSimpleClientset(argoObjs...), + KubeClientset: kubeclientset, + } + + appDependencyList, appStepMap, err := r.buildAppDependencyList(context.TODO(), cc.appSet, cc.apps) + assert.Equal(t, err, nil, "expected no errors, but errors occured") + assert.Equal(t, cc.expectedList, appDependencyList, "expected appDependencyList did not match actual") + assert.Equal(t, cc.expectedStepMap, appStepMap, "expected appStepMap did not match actual") + }) + } +} + +func TestBuildAppSyncMap(t *testing.T) { + + scheme := runtime.NewScheme() + err := argoprojiov1alpha1.AddToScheme(scheme) + assert.Nil(t, err) + + err = argov1alpha1.AddToScheme(scheme) + assert.Nil(t, err) + + client := fake.NewClientBuilder().WithScheme(scheme).Build() + + for _, cc := range []struct { + name string + appSet argoprojiov1alpha1.ApplicationSet + appDependencyList [][]string + expectedMap map[string]bool + }{ + { + name: "handles an empty app dependency list", + appSet: argoprojiov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argoprojiov1alpha1.ApplicationSetSpec{}, + }, + appDependencyList: [][]string{}, + expectedMap: map[string]bool{}, + }, + { + name: "handles two applications with no statuses", + appSet: argoprojiov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argoprojiov1alpha1.ApplicationSetSpec{}, + }, + appDependencyList: [][]string{ + {"app1"}, + {"app2"}, + }, + expectedMap: map[string]bool{ + "app1": true, + "app2": false, + }, + }, + { + name: "handles applications after an empty selection", + appSet: argoprojiov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argoprojiov1alpha1.ApplicationSetSpec{}, + }, + appDependencyList: [][]string{ + {}, + {"app1", "app2"}, + }, + expectedMap: map[string]bool{ + "app1": true, + "app2": true, + }, + }, + { + name: "handles applications that are healthy and match the appset generation", + appSet: argoprojiov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + Generation: 1, + }, + Spec: argoprojiov1alpha1.ApplicationSetSpec{}, + Status: argoprojiov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + ObservedGeneration: 1, + Status: "Healthy", + }, + { + Application: "app2", + ObservedGeneration: 1, + Status: "Healthy", + }, + }, + }, + }, + appDependencyList: [][]string{ + {"app1"}, + {"app2"}, + }, + expectedMap: map[string]bool{ + "app1": true, + "app2": true, + }, + }, + { + name: "handles applications that are healthy but out of date", + appSet: argoprojiov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + Generation: 2, + }, + Spec: argoprojiov1alpha1.ApplicationSetSpec{}, + Status: argoprojiov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + ObservedGeneration: 1, + Status: "Healthy", + }, + { + Application: "app2", + ObservedGeneration: 1, + Status: "Healthy", + }, + }, + }, + }, + appDependencyList: [][]string{ + {"app1"}, + {"app2"}, + }, + expectedMap: map[string]bool{ + "app1": true, + "app2": false, + }, + }, + { + name: "handles applications that are up to date, but not healthy", + appSet: argoprojiov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + Generation: 2, + }, + Spec: argoprojiov1alpha1.ApplicationSetSpec{}, + Status: argoprojiov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + ObservedGeneration: 2, + Status: "Progressing", + }, + { + Application: "app2", + ObservedGeneration: 2, + Status: "Progressing", + }, + }, + }, + }, + appDependencyList: [][]string{ + {"app1"}, + {"app2"}, + }, + expectedMap: map[string]bool{ + "app1": true, + "app2": false, + }, + }, + { + name: "handles a lot of applications", + appSet: argoprojiov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + Generation: 2, + }, + Spec: argoprojiov1alpha1.ApplicationSetSpec{}, + Status: argoprojiov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + ObservedGeneration: 2, + Status: "Healthy", + }, + { + Application: "app2", + ObservedGeneration: 2, + Status: "Healthy", + }, + { + Application: "app4", + ObservedGeneration: 2, + Status: "Healthy", + }, + { + Application: "app7", + ObservedGeneration: 2, + Status: "Healthy", + }, + }, + }, + }, + appDependencyList: [][]string{ + {"app1", "app4", "app7"}, + {"app2", "app5", "app8"}, + {"app3", "app6", "app9"}, + }, + expectedMap: map[string]bool{ + "app1": true, + "app2": true, + "app3": false, + "app4": true, + "app5": true, + "app6": false, + "app7": true, + "app8": true, + "app9": false, + }, + }, + } { + + t.Run(cc.name, func(t *testing.T) { + + kubeclientset := kubefake.NewSimpleClientset([]runtime.Object{}...) + argoDBMock := dbmocks.ArgoDB{} + argoObjs := []runtime.Object{} + + r := ApplicationSetReconciler{ + Client: client, + Scheme: scheme, + Recorder: record.NewFakeRecorder(1), + Generators: map[string]generators.Generator{}, + ArgoDB: &argoDBMock, + ArgoAppClientset: appclientset.NewSimpleClientset(argoObjs...), + KubeClientset: kubeclientset, + } + + appSyncMap, err := r.buildAppSyncMap(context.TODO(), cc.appSet, cc.appDependencyList) + assert.Equal(t, err, nil, "expected no errors, but errors occured") + assert.Equal(t, cc.expectedMap, appSyncMap, "expected appSyncMap did not match actual") + }) + } +} + +func TestUpdateApplicationSetApplicationStatus(t *testing.T) { + + scheme := runtime.NewScheme() + err := argoprojiov1alpha1.AddToScheme(scheme) + assert.Nil(t, err) + + err = argov1alpha1.AddToScheme(scheme) + assert.Nil(t, err) + + for _, cc := range []struct { + name string + appSet argoprojiov1alpha1.ApplicationSet + apps []argov1alpha1.Application + expectedAppStatus []argoprojiov1alpha1.ApplicationSetApplicationStatus + }{ + { + name: "handles a nil list of statuses and no applications", + appSet: argoprojiov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + // Status: argoprojiov1alpha1.ApplicationSetStatus{ + // ApplicationStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{}, + // }, + }, + apps: []argov1alpha1.Application{}, + expectedAppStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{}, + }, + { + name: "handles a nil list of statuses with a healthy application", + appSet: argoprojiov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + }, + apps: []argov1alpha1.Application{ + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app1", + }, + Status: argov1alpha1.ApplicationStatus{ + Health: argov1alpha1.HealthStatus{ + Status: health.HealthStatusHealthy, + }, + }, + }, + }, + expectedAppStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Message: "No Application status found, defaulting status to Waiting.", + ObservedGeneration: 0, + Status: "Waiting", + }, + }, + }, + { + name: "handles an empty list of statuses with a healthy application", + appSet: argoprojiov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Status: argoprojiov1alpha1.ApplicationSetStatus{}, + }, + apps: []argov1alpha1.Application{ + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app1", + }, + Status: argov1alpha1.ApplicationStatus{ + Health: argov1alpha1.HealthStatus{ + Status: health.HealthStatusHealthy, + }, + }, + }, + }, + expectedAppStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Message: "No Application status found, defaulting status to Waiting.", + ObservedGeneration: 0, + Status: "Waiting", + }, + }, + }, + { + name: "progresses an out of date healthy application to waiting", + appSet: argoprojiov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + Generation: 2, + }, + Status: argoprojiov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Message: "", + ObservedGeneration: 1, + Status: "Healthy", + }, + }, + }, + }, + apps: []argov1alpha1.Application{ + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app1", + }, + Status: argov1alpha1.ApplicationStatus{ + Health: argov1alpha1.HealthStatus{ + Status: health.HealthStatusHealthy, + }, + }, + }, + }, + expectedAppStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + ObservedGeneration: 1, + Status: "Waiting", + }, + }, + }, + { + name: "progresses a pending application to progressing", + appSet: argoprojiov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + Generation: 2, + }, + Status: argoprojiov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Message: "", + ObservedGeneration: 2, + Status: "Pending", + }, + }, + }, + }, + apps: []argov1alpha1.Application{ + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app1", + }, + Status: argov1alpha1.ApplicationStatus{ + Health: argov1alpha1.HealthStatus{ + Status: health.HealthStatusProgressing, + }, + }, + }, + }, + expectedAppStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Message: "Application resource became Progressing, updating status from Pending to Progressing.", + ObservedGeneration: 2, + Status: "Progressing", + }, + }, + }, + { + name: "progresses a pending application to healthy on timeout", + appSet: argoprojiov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + Generation: 2, + }, + Status: argoprojiov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + LastTransitionTime: &metav1.Time{}, + Message: "", + ObservedGeneration: 2, + Status: "Pending", + }, + }, + }, + }, + apps: []argov1alpha1.Application{ + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app1", + }, + Status: argov1alpha1.ApplicationStatus{ + Health: argov1alpha1.HealthStatus{ + Status: health.HealthStatusHealthy, + }, + }, + }, + }, + expectedAppStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Message: "Application Pending status timed out while waiting to become Progressing, reset status to Healthy.", + ObservedGeneration: 2, + Status: "Healthy", + }, + }, + }, + { + name: "progresses a progressing application to healthy", + appSet: argoprojiov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + Generation: 2, + }, + Status: argoprojiov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Message: "", + ObservedGeneration: 2, + Status: "Progressing", + }, + }, + }, + }, + apps: []argov1alpha1.Application{ + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app1", + }, + Status: argov1alpha1.ApplicationStatus{ + Health: argov1alpha1.HealthStatus{ + Status: health.HealthStatusHealthy, + }, + }, + }, + }, + expectedAppStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Message: "Application resource became Healthy, updating status from Progressing to Healthy.", + ObservedGeneration: 2, + Status: "Healthy", + }, + }, + }, + } { + + t.Run(cc.name, func(t *testing.T) { + + kubeclientset := kubefake.NewSimpleClientset([]runtime.Object{}...) + argoDBMock := dbmocks.ArgoDB{} + argoObjs := []runtime.Object{} + + client := fake.NewClientBuilder().WithScheme(scheme).WithObjects(&cc.appSet).Build() + + r := ApplicationSetReconciler{ + Client: client, + Scheme: scheme, + Recorder: record.NewFakeRecorder(1), + Generators: map[string]generators.Generator{}, + ArgoDB: &argoDBMock, + ArgoAppClientset: appclientset.NewSimpleClientset(argoObjs...), + KubeClientset: kubeclientset, + } + + appStatuses, err := r.updateApplicationSetApplicationStatus(context.TODO(), &cc.appSet, cc.apps) + + // opt out of testing the LastTransitionTime is accurate + for i := range appStatuses { + appStatuses[i].LastTransitionTime = nil + } + + assert.Equal(t, err, nil, "expected no errors, but errors occured") + assert.Equal(t, cc.expectedAppStatus, appStatuses, "expected appStatuses did not match actual") + }) + } +} + +func TestUpdateApplicationSetApplicationStatusProgress(t *testing.T) { + + scheme := runtime.NewScheme() + err := argoprojiov1alpha1.AddToScheme(scheme) + assert.Nil(t, err) + + err = argov1alpha1.AddToScheme(scheme) + assert.Nil(t, err) + + for _, cc := range []struct { + name string + appSet argoprojiov1alpha1.ApplicationSet + appSyncMap map[string]bool + appStepMap map[string]int + expectedAppStatus []argoprojiov1alpha1.ApplicationSetApplicationStatus + }{ + { + name: "handles an empty appSync and appStepMap", + appSet: argoprojiov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argoprojiov1alpha1.ApplicationSetSpec{ + Strategy: &argoprojiov1alpha1.ApplicationSetStrategy{ + Type: "RollingUpdate", + RollingUpdate: &argoprojiov1alpha1.ApplicationSetRollingUpdateStrategy{ + Steps: []argoprojiov1alpha1.ApplicationSetRollingUpdateStep{ + { + MatchExpressions: []argoprojiov1alpha1.ApplicationMatchExpression{}, + }, + { + MatchExpressions: []argoprojiov1alpha1.ApplicationMatchExpression{}, + }, + }, + }, + }, + }, + Status: argoprojiov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{}, + }, + }, + appSyncMap: map[string]bool{}, + appStepMap: map[string]int{}, + expectedAppStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{}, + }, + { + name: "handles an empty strategy", + appSet: argoprojiov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argoprojiov1alpha1.ApplicationSetSpec{}, + Status: argoprojiov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{}, + }, + }, + appSyncMap: map[string]bool{}, + appStepMap: map[string]int{}, + expectedAppStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{}, + }, + { + name: "handles an empty rollingUpdate", + appSet: argoprojiov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argoprojiov1alpha1.ApplicationSetSpec{ + Strategy: &argoprojiov1alpha1.ApplicationSetStrategy{}, + }, + Status: argoprojiov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{}, + }, + }, + appSyncMap: map[string]bool{}, + appStepMap: map[string]int{}, + expectedAppStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{}, + }, + { + name: "handles an appSyncMap with no existing statuses", + appSet: argoprojiov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Status: argoprojiov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{}, + }, + }, + appSyncMap: map[string]bool{ + "app1": true, + "app2": false, + }, + appStepMap: map[string]int{ + "app1": 0, + "app2": 1, + }, + expectedAppStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{}, + }, + { + name: "handles updating a status from Waiting to Pending", + appSet: argoprojiov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + Generation: 2, + }, + Spec: argoprojiov1alpha1.ApplicationSetSpec{ + Strategy: &argoprojiov1alpha1.ApplicationSetStrategy{ + Type: "RollingUpdate", + RollingUpdate: &argoprojiov1alpha1.ApplicationSetRollingUpdateStrategy{ + Steps: []argoprojiov1alpha1.ApplicationSetRollingUpdateStep{ + { + MatchExpressions: []argoprojiov1alpha1.ApplicationMatchExpression{}, + }, + { + MatchExpressions: []argoprojiov1alpha1.ApplicationMatchExpression{}, + }, + }, + }, + }, + }, + Status: argoprojiov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + ObservedGeneration: 1, + Status: "Waiting", + }, + }, + }, + }, + appSyncMap: map[string]bool{ + "app1": true, + }, + appStepMap: map[string]int{ + "app1": 0, + }, + expectedAppStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + LastTransitionTime: nil, + Message: "Application moved to Pending status, watching for the Application resource to start Progressing.", + ObservedGeneration: 2, + Status: "Pending", + }, + }, + }, + { + name: "does not update a status if appSyncMap is false", + appSet: argoprojiov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + Generation: 2, + }, + Spec: argoprojiov1alpha1.ApplicationSetSpec{ + Strategy: &argoprojiov1alpha1.ApplicationSetStrategy{ + Type: "RollingUpdate", + RollingUpdate: &argoprojiov1alpha1.ApplicationSetRollingUpdateStrategy{ + Steps: []argoprojiov1alpha1.ApplicationSetRollingUpdateStep{ + { + MatchExpressions: []argoprojiov1alpha1.ApplicationMatchExpression{}, + }, + { + MatchExpressions: []argoprojiov1alpha1.ApplicationMatchExpression{}, + }, + }, + }, + }, + }, + Status: argoprojiov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + ObservedGeneration: 1, + Status: "Waiting", + }, + }, + }, + }, + appSyncMap: map[string]bool{ + "app1": false, + }, + appStepMap: map[string]int{ + "app1": 0, + }, + expectedAppStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + LastTransitionTime: nil, + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + ObservedGeneration: 1, + Status: "Waiting", + }, + }, + }, + { + name: "does not update a status if status is not pending", + appSet: argoprojiov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + Generation: 2, + }, + Spec: argoprojiov1alpha1.ApplicationSetSpec{ + Strategy: &argoprojiov1alpha1.ApplicationSetStrategy{ + Type: "RollingUpdate", + RollingUpdate: &argoprojiov1alpha1.ApplicationSetRollingUpdateStrategy{ + Steps: []argoprojiov1alpha1.ApplicationSetRollingUpdateStep{ + { + MatchExpressions: []argoprojiov1alpha1.ApplicationMatchExpression{}, + }, + { + MatchExpressions: []argoprojiov1alpha1.ApplicationMatchExpression{}, + }, + }, + }, + }, + }, + Status: argoprojiov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Message: "Application Pending status timed out while waiting to become Progressing, reset status to Healthy.", + ObservedGeneration: 1, + Status: "Healthy", + }, + }, + }, + }, + appSyncMap: map[string]bool{ + "app1": true, + }, + appStepMap: map[string]int{ + "app1": 0, + }, + expectedAppStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + LastTransitionTime: nil, + Message: "Application Pending status timed out while waiting to become Progressing, reset status to Healthy.", + ObservedGeneration: 1, + Status: "Healthy", + }, + }, + }, + { + name: "does not update a status if maxUpdate has already been reached", + appSet: argoprojiov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + Generation: 2, + }, + Spec: argoprojiov1alpha1.ApplicationSetSpec{ + Strategy: &argoprojiov1alpha1.ApplicationSetStrategy{ + Type: "RollingUpdate", + RollingUpdate: &argoprojiov1alpha1.ApplicationSetRollingUpdateStrategy{ + Steps: []argoprojiov1alpha1.ApplicationSetRollingUpdateStep{ + { + MatchExpressions: []argoprojiov1alpha1.ApplicationMatchExpression{}, + MaxUpdate: &intstr.IntOrString{ + Type: intstr.Int, + IntVal: 3, + }, + }, + { + MatchExpressions: []argoprojiov1alpha1.ApplicationMatchExpression{}, + }, + }, + }, + }, + }, + Status: argoprojiov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Message: "Application resource became Progressing, updating status from Pending to Progressing.", + ObservedGeneration: 2, + Status: "Progressing", + }, + { + Application: "app2", + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + ObservedGeneration: 1, + Status: "Waiting", + }, + { + Application: "app3", + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + ObservedGeneration: 1, + Status: "Waiting", + }, + { + Application: "app4", + Message: "Application moved to Pending status, watching for the Application resource to start Progressing.", + ObservedGeneration: 2, + Status: "Pending", + }, + }, + }, + }, + appSyncMap: map[string]bool{ + "app1": true, + "app2": true, + "app3": true, + "app4": true, + }, + appStepMap: map[string]int{ + "app1": 0, + "app2": 0, + "app3": 0, + "app4": 0, + }, + expectedAppStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + LastTransitionTime: nil, + Message: "Application resource became Progressing, updating status from Pending to Progressing.", + ObservedGeneration: 2, + Status: "Progressing", + }, + { + Application: "app2", + LastTransitionTime: nil, + Message: "Application moved to Pending status, watching for the Application resource to start Progressing.", + ObservedGeneration: 2, + Status: "Pending", + }, + { + Application: "app3", + LastTransitionTime: nil, + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + ObservedGeneration: 1, + Status: "Waiting", + }, + { + Application: "app4", + LastTransitionTime: nil, + Message: "Application moved to Pending status, watching for the Application resource to start Progressing.", + ObservedGeneration: 2, + Status: "Pending", + }, + }, + }, + { + name: "handles maxUpdate set to percentage string", + appSet: argoprojiov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + Generation: 2, + }, + Spec: argoprojiov1alpha1.ApplicationSetSpec{ + Strategy: &argoprojiov1alpha1.ApplicationSetStrategy{ + Type: "RollingUpdate", + RollingUpdate: &argoprojiov1alpha1.ApplicationSetRollingUpdateStrategy{ + Steps: []argoprojiov1alpha1.ApplicationSetRollingUpdateStep{ + { + MatchExpressions: []argoprojiov1alpha1.ApplicationMatchExpression{}, + MaxUpdate: &intstr.IntOrString{ + Type: intstr.String, + StrVal: "50%", + }, + }, + { + MatchExpressions: []argoprojiov1alpha1.ApplicationMatchExpression{}, + }, + }, + }, + }, + }, + Status: argoprojiov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + ObservedGeneration: 1, + Status: "Waiting", + }, + { + Application: "app2", + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + ObservedGeneration: 1, + Status: "Waiting", + }, + { + Application: "app3", + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + ObservedGeneration: 1, + Status: "Waiting", + }, + }, + }, + }, + appSyncMap: map[string]bool{ + "app1": true, + "app2": true, + "app3": true, + }, + appStepMap: map[string]int{ + "app1": 0, + "app2": 0, + "app3": 0, + }, + expectedAppStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + LastTransitionTime: nil, + Message: "Application moved to Pending status, watching for the Application resource to start Progressing.", + ObservedGeneration: 2, + Status: "Pending", + }, + { + Application: "app2", + LastTransitionTime: nil, + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + ObservedGeneration: 1, + Status: "Waiting", + }, + { + Application: "app3", + LastTransitionTime: nil, + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + ObservedGeneration: 1, + Status: "Waiting", + }, + }, + }, + } { + + t.Run(cc.name, func(t *testing.T) { + + kubeclientset := kubefake.NewSimpleClientset([]runtime.Object{}...) + argoDBMock := dbmocks.ArgoDB{} + argoObjs := []runtime.Object{} + + client := fake.NewClientBuilder().WithScheme(scheme).WithObjects(&cc.appSet).Build() + + r := ApplicationSetReconciler{ + Client: client, + Scheme: scheme, + Recorder: record.NewFakeRecorder(1), + Generators: map[string]generators.Generator{}, + ArgoDB: &argoDBMock, + ArgoAppClientset: appclientset.NewSimpleClientset(argoObjs...), + KubeClientset: kubeclientset, + } + + appStatuses, err := r.updateApplicationSetApplicationStatusProgress(context.TODO(), &cc.appSet, cc.appSyncMap, cc.appStepMap) + + // opt out of testing the LastTransitionTime is accurate + for i := range appStatuses { + appStatuses[i].LastTransitionTime = nil + } + + assert.Equal(t, err, nil, "expected no errors, but errors occured") + assert.Equal(t, cc.expectedAppStatus, appStatuses, "expected appStatuses did not match actual") + }) + } +} diff --git a/docs/operator-manual/applicationset/Progressive-Rollouts.md b/docs/operator-manual/applicationset/Progressive-Rollouts.md new file mode 100644 index 0000000000000..39ad6a495bcc5 --- /dev/null +++ b/docs/operator-manual/applicationset/Progressive-Rollouts.md @@ -0,0 +1,95 @@ +# Progressive Rollouts + +This feature allows you to control the order that the ApplicationSet controller will use to create or update the Applications owned by an ApplicationSet resource. + +## Use Cases +The Progressive Rollouts feature set is intended to be light and flexible. The feature is intended to only interact with the health of managed Applications. It is not intended to support direct integrations with other Rollout controllers (such as the native ReplicaSet controller or Argo Rollouts). + +* Progressive Rollouts watch for the managed Application resources to become "Healthy" before proceeding to the next stage. +* Deployments, Daemonsets, StatefulSets, and [Argo Rollouts](https://argoproj.github.io/argo-rollouts/) are all supported, because the Application enters a "Progressing" state while pods are being rolled out. +* [Argo CD Resource Hooks](../../user-guide/resource_hooks.md) are supported. We recommend this approach for users that need advanced functionality when an Argo Rollout cannot be used, such as smoke testing after a Daemonset change. + +## Strategies + +* AllAtOnce (default) +* RollingUpdate + +### AllAtOnce +This default Application update behavior is unchanged from the original ApplicationSet implementation. + +All Applications managed by the ApplicationSet resource are updated simultaneously when the ApplicationSet is updated. + +### RollingUpdate +This update strategy allows you to group Applications by labels present on the generated Application resources. +When the ApplicationSet changes, the changes will be applied to each group of Application resources sequentially. + +* Application groups are selected by `matchExpressions`. +* All `matchExpressions` must be true for an Application to be selected (AND behavior). +* The `In` operator must match at least one value to be considered true (OR behavior). +* All Applications in each group must become Healthy before the ApplicationSet controller will proceed to update the next group of Applications. +* The number of simultaneous Application updates in a group will not exceed its `maxUpdate` parameter (0 or undefined means unbounded). + +#### Example +The following example illustrates how to stage a progressive rollout over Applications with explicitly configured environment labels. +``` +--- +apiVersion: argoproj.io/v1alpha1 +kind: ApplicationSet +metadata: + name: guestbook +spec: + generators: + - list: + elements: + - cluster: engineering-dev + url: https://1.2.3.4 + env: dev + - cluster: engineering-qa + url: https://2.4.6.8 + env: qa + - cluster: engineering-prod + url: https://9.8.7.6/ + env: prod + strategy: + type: RollingUpdate + rollingUpdate: + steps: + - matchExpressions: + - key: env + operator: In + values: + - dev + maxUpdate: 0 # if undefined or 0, all applications matched are updated together + - matchExpressions: + - key: env + operator: In + values: + - qa + - matchExpressions: + - key: env + operator: In + values: + - prod + maxUpdate: 1 # maxUpdate supports both integer and percentage string values + template: + metadata: + name: '{{cluster}}-guestbook' + labels: + env: '{{env}}' + spec: + source: + repoURL: https://github.com/infra-team/cluster-deployments.git + targetRevision: HEAD + path: guestbook/{{cluster}} + destination: + server: '{{url}}' + namespace: guestbook +``` + +#### Limitations +The RollingUpdate strategy does not enforce sync order for external changes. Basically, if the ApplicationSet spec does not change, the RollingUpdate strategy has no mechanism available to control the sync order of the Applications it manages. The managed Applications will sync on their own (if autosync is enabled), and your desired rollingUpdate spec will be ignored. + +This includes: + +* Updates to manifests in a directory watched by the generated Application. +* Updates to an unversioned helm chart watched by the generated Application (including versioned upstream chart dependencies in the unversioned Chart.yaml). diff --git a/manifests/core-install.yaml b/manifests/core-install.yaml index 5543bc9d10705..92c1064d481d3 100644 --- a/manifests/core-install.yaml +++ b/manifests/core-install.yaml @@ -8605,6 +8605,37 @@ spec: type: array goTemplate: type: boolean + strategy: + properties: + rollingUpdate: + properties: + steps: + items: + properties: + matchExpressions: + items: + properties: + key: + type: string + operator: + type: string + values: + items: + type: string + type: array + type: object + type: array + maxUpdate: + anyOf: + - type: integer + - type: string + x-kubernetes-int-or-string: true + type: object + type: array + type: object + type: + type: string + type: object syncPolicy: properties: preserveResourcesOnDeletion: @@ -8871,6 +8902,27 @@ spec: type: object status: properties: + applicationStatus: + items: + properties: + application: + type: string + lastTransitionTime: + format: date-time + type: string + message: + type: string + observedGeneration: + format: int64 + type: integer + status: + type: string + required: + - application + - message + - status + type: object + type: array conditions: items: properties: diff --git a/manifests/crds/applicationset-crd.yaml b/manifests/crds/applicationset-crd.yaml index 3a73bbdccacee..a84cd5417fa73 100644 --- a/manifests/crds/applicationset-crd.yaml +++ b/manifests/crds/applicationset-crd.yaml @@ -6449,6 +6449,37 @@ spec: type: array goTemplate: type: boolean + strategy: + properties: + rollingUpdate: + properties: + steps: + items: + properties: + matchExpressions: + items: + properties: + key: + type: string + operator: + type: string + values: + items: + type: string + type: array + type: object + type: array + maxUpdate: + anyOf: + - type: integer + - type: string + x-kubernetes-int-or-string: true + type: object + type: array + type: object + type: + type: string + type: object syncPolicy: properties: preserveResourcesOnDeletion: @@ -6715,6 +6746,27 @@ spec: type: object status: properties: + applicationStatus: + items: + properties: + application: + type: string + lastTransitionTime: + format: date-time + type: string + message: + type: string + observedGeneration: + format: int64 + type: integer + status: + type: string + required: + - application + - message + - status + type: object + type: array conditions: items: properties: diff --git a/manifests/ha/install.yaml b/manifests/ha/install.yaml index 84392fe8a6437..df39b7db2f12f 100644 --- a/manifests/ha/install.yaml +++ b/manifests/ha/install.yaml @@ -8605,6 +8605,37 @@ spec: type: array goTemplate: type: boolean + strategy: + properties: + rollingUpdate: + properties: + steps: + items: + properties: + matchExpressions: + items: + properties: + key: + type: string + operator: + type: string + values: + items: + type: string + type: array + type: object + type: array + maxUpdate: + anyOf: + - type: integer + - type: string + x-kubernetes-int-or-string: true + type: object + type: array + type: object + type: + type: string + type: object syncPolicy: properties: preserveResourcesOnDeletion: @@ -8871,6 +8902,27 @@ spec: type: object status: properties: + applicationStatus: + items: + properties: + application: + type: string + lastTransitionTime: + format: date-time + type: string + message: + type: string + observedGeneration: + format: int64 + type: integer + status: + type: string + required: + - application + - message + - status + type: object + type: array conditions: items: properties: diff --git a/manifests/install.yaml b/manifests/install.yaml index 2ed7eee23e824..7534ea09b7209 100644 --- a/manifests/install.yaml +++ b/manifests/install.yaml @@ -8605,6 +8605,37 @@ spec: type: array goTemplate: type: boolean + strategy: + properties: + rollingUpdate: + properties: + steps: + items: + properties: + matchExpressions: + items: + properties: + key: + type: string + operator: + type: string + values: + items: + type: string + type: array + type: object + type: array + maxUpdate: + anyOf: + - type: integer + - type: string + x-kubernetes-int-or-string: true + type: object + type: array + type: object + type: + type: string + type: object syncPolicy: properties: preserveResourcesOnDeletion: @@ -8871,6 +8902,27 @@ spec: type: object status: properties: + applicationStatus: + items: + properties: + application: + type: string + lastTransitionTime: + format: date-time + type: string + message: + type: string + observedGeneration: + format: int64 + type: integer + status: + type: string + required: + - application + - message + - status + type: object + type: array conditions: items: properties: diff --git a/mkdocs.yml b/mkdocs.yml index 81103a0eb7a15..24e243e8af8ab 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -96,6 +96,7 @@ nav: - operator-manual/applicationset/GoTemplate.md - Controlling Resource Modification: operator-manual/applicationset/Controlling-Resource-Modification.md - Application Pruning & Resource Deletion: operator-manual/applicationset/Application-Deletion.md + - Progressive Rollouts: operator-manual/applicationset/Progressive-Rollouts.md - Server Configuration Parameters: - operator-manual/server-commands/argocd-server.md - operator-manual/server-commands/argocd-application-controller.md diff --git a/pkg/apis/applicationset/v1alpha1/applicationset_types.go b/pkg/apis/applicationset/v1alpha1/applicationset_types.go index 93516a1df7cb3..a2f46403bd827 100644 --- a/pkg/apis/applicationset/v1alpha1/applicationset_types.go +++ b/pkg/apis/applicationset/v1alpha1/applicationset_types.go @@ -25,6 +25,7 @@ import ( apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/util/intstr" "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1" ) @@ -54,6 +55,28 @@ type ApplicationSetSpec struct { Generators []ApplicationSetGenerator `json:"generators"` Template ApplicationSetTemplate `json:"template"` SyncPolicy *ApplicationSetSyncPolicy `json:"syncPolicy,omitempty"` + Strategy *ApplicationSetStrategy `json:"strategy,omitempty"` +} + +// ApplicationSetStrategy configures how generated Applications are updated in sequence. +type ApplicationSetStrategy struct { + Type string `json:"type,omitempty"` + RollingUpdate *ApplicationSetRollingUpdateStrategy `json:"rollingUpdate,omitempty"` +} +type ApplicationSetRollingUpdateStrategy struct { + Steps []ApplicationSetRollingUpdateStep `json:"steps,omitempty"` +} + +type ApplicationSetRollingUpdateStep struct { + MatchExpressions []ApplicationMatchExpression `json:"matchExpressions,omitempty"` + MaxUpdate *intstr.IntOrString `json:"maxUpdate,omitempty" protobuf:"bytes,6,opt,name=maxUpdate"` + // MaxUpdate *int32 `json:"maxUpdate,omitempty" protobuf:"varint,3,opt,name=maxUpdate"` +} + +type ApplicationMatchExpression struct { + Key string `json:"key,omitempty"` + Operator string `json:"operator,omitempty"` + Values []string `json:"values,omitempty"` } // ApplicationSetSyncPolicy configures how generated Applications will relate to their @@ -499,7 +522,8 @@ type PullRequestGeneratorFilter struct { type ApplicationSetStatus struct { // INSERT ADDITIONAL STATUS FIELD - define observed state of cluster // Important: Run "make" to regenerate code after modifying this file - Conditions []ApplicationSetCondition `json:"conditions,omitempty"` + Conditions []ApplicationSetCondition `json:"conditions,omitempty"` + ApplicationStatus []ApplicationSetApplicationStatus `json:"applicationStatus,omitempty"` } // ApplicationSetCondition contains details about an applicationset condition, which is usally an error or warning @@ -540,8 +564,24 @@ const ( ApplicationSetConditionErrorOccurred ApplicationSetConditionType = "ErrorOccurred" ApplicationSetConditionParametersGenerated ApplicationSetConditionType = "ParametersGenerated" ApplicationSetConditionResourcesUpToDate ApplicationSetConditionType = "ResourcesUpToDate" + ApplicationSetConditionRolloutProgressing ApplicationSetConditionType = "RolloutProgressing" ) +// ApplicationSetApplicationCondition contains details about each Application managed by the ApplicationSet +type ApplicationSetApplicationStatus struct { + // Application contains the name of the Application resource + Application string `json:"application" protobuf:"bytes,2,opt,name=application"` + // LastTransitionTime is the time the status was last updated + LastTransitionTime *metav1.Time `json:"lastTransitionTime,omitempty" protobuf:"bytes,4,opt,name=lastTransitionTime"` + // Message contains human-readable message indicating details about the status + Message string `json:"message" protobuf:"bytes,3,opt,name=message"` + // ObservedGeneration contains the ApplicationSet generation used to create the current version of the Application resource + ObservedGeneration int64 `json:"observedGeneration,omitempty"` + // Status contains the AppSet's perceived status of the managed Application resource: (Waiting, Pending, Progressing, Healthy) + Status string `json:"status" protobuf:"bytes,3,opt,name=status"` + // Status health.HealthStatusCode `json:"status" protobuf:"bytes,5,opt,name=status"` # not usable because we need custom statuses like "Waiting" and "Pending" +} + type ApplicationSetReasonType string const ( @@ -556,6 +596,8 @@ const ( ApplicationSetReasonDeleteApplicationError = "DeleteApplicationError" ApplicationSetReasonRefreshApplicationError = "RefreshApplicationError" ApplicationSetReasonApplicationValidationError = "ApplicationValidationError" + ApplicationSetReasonApplicationSetModified = "ApplicationSetModified" + ApplicationSetReasonApplicationSetRolloutComplete = "ApplicationSetRolloutComplete" ) // ApplicationSetList contains a list of ApplicationSet @@ -614,3 +656,16 @@ func findConditionIndex(conditions []ApplicationSetCondition, t ApplicationSetCo } return -1 } + +func (status *ApplicationSetStatus) SetApplicationStatus(newStatus ApplicationSetApplicationStatus) { + // now := metav1.Now() + // newStatus.LastTransitionTime = &now + for i := range status.ApplicationStatus { + appStatus := status.ApplicationStatus[i] + if appStatus.Application == newStatus.Application { + status.ApplicationStatus[i] = newStatus + return + } + } + status.ApplicationStatus = append(status.ApplicationStatus, newStatus) +} diff --git a/pkg/apis/applicationset/v1alpha1/zz_generated.deepcopy.go b/pkg/apis/applicationset/v1alpha1/zz_generated.deepcopy.go index 3b9f4d6b1fcae..1f3e0c3adc8f8 100644 --- a/pkg/apis/applicationset/v1alpha1/zz_generated.deepcopy.go +++ b/pkg/apis/applicationset/v1alpha1/zz_generated.deepcopy.go @@ -23,8 +23,29 @@ import ( apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1" "k8s.io/apimachinery/pkg/apis/meta/v1" runtime "k8s.io/apimachinery/pkg/runtime" + "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 *ApplicationMatchExpression) DeepCopyInto(out *ApplicationMatchExpression) { + *out = *in + if in.Values != nil { + in, out := &in.Values, &out.Values + *out = make([]string, len(*in)) + copy(*out, *in) + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ApplicationMatchExpression. +func (in *ApplicationMatchExpression) DeepCopy() *ApplicationMatchExpression { + if in == nil { + return nil + } + out := new(ApplicationMatchExpression) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *ApplicationSet) DeepCopyInto(out *ApplicationSet) { *out = *in @@ -52,6 +73,25 @@ func (in *ApplicationSet) DeepCopyObject() runtime.Object { return nil } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ApplicationSetApplicationStatus) DeepCopyInto(out *ApplicationSetApplicationStatus) { + *out = *in + if in.LastTransitionTime != nil { + in, out := &in.LastTransitionTime, &out.LastTransitionTime + *out = (*in).DeepCopy() + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ApplicationSetApplicationStatus. +func (in *ApplicationSetApplicationStatus) DeepCopy() *ApplicationSetApplicationStatus { + if in == nil { + return nil + } + out := new(ApplicationSetApplicationStatus) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *ApplicationSetCondition) DeepCopyInto(out *ApplicationSetCondition) { *out = *in @@ -244,6 +284,55 @@ func (in ApplicationSetNestedGenerators) DeepCopy() ApplicationSetNestedGenerato return *out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ApplicationSetRollingUpdateStep) DeepCopyInto(out *ApplicationSetRollingUpdateStep) { + *out = *in + if in.MatchExpressions != nil { + in, out := &in.MatchExpressions, &out.MatchExpressions + *out = make([]ApplicationMatchExpression, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + if in.MaxUpdate != nil { + in, out := &in.MaxUpdate, &out.MaxUpdate + *out = new(intstr.IntOrString) + **out = **in + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ApplicationSetRollingUpdateStep. +func (in *ApplicationSetRollingUpdateStep) DeepCopy() *ApplicationSetRollingUpdateStep { + if in == nil { + return nil + } + out := new(ApplicationSetRollingUpdateStep) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ApplicationSetRollingUpdateStrategy) DeepCopyInto(out *ApplicationSetRollingUpdateStrategy) { + *out = *in + if in.Steps != nil { + in, out := &in.Steps, &out.Steps + *out = make([]ApplicationSetRollingUpdateStep, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ApplicationSetRollingUpdateStrategy. +func (in *ApplicationSetRollingUpdateStrategy) DeepCopy() *ApplicationSetRollingUpdateStrategy { + if in == nil { + return nil + } + out := new(ApplicationSetRollingUpdateStrategy) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *ApplicationSetSpec) DeepCopyInto(out *ApplicationSetSpec) { *out = *in @@ -260,6 +349,11 @@ func (in *ApplicationSetSpec) DeepCopyInto(out *ApplicationSetSpec) { *out = new(ApplicationSetSyncPolicy) **out = **in } + if in.Strategy != nil { + in, out := &in.Strategy, &out.Strategy + *out = new(ApplicationSetStrategy) + (*in).DeepCopyInto(*out) + } } // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ApplicationSetSpec. @@ -282,6 +376,13 @@ func (in *ApplicationSetStatus) DeepCopyInto(out *ApplicationSetStatus) { (*in)[i].DeepCopyInto(&(*out)[i]) } } + if in.ApplicationStatus != nil { + in, out := &in.ApplicationStatus, &out.ApplicationStatus + *out = make([]ApplicationSetApplicationStatus, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } } // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ApplicationSetStatus. @@ -294,6 +395,26 @@ func (in *ApplicationSetStatus) DeepCopy() *ApplicationSetStatus { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ApplicationSetStrategy) DeepCopyInto(out *ApplicationSetStrategy) { + *out = *in + if in.RollingUpdate != nil { + in, out := &in.RollingUpdate, &out.RollingUpdate + *out = new(ApplicationSetRollingUpdateStrategy) + (*in).DeepCopyInto(*out) + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ApplicationSetStrategy. +func (in *ApplicationSetStrategy) DeepCopy() *ApplicationSetStrategy { + if in == nil { + return nil + } + out := new(ApplicationSetStrategy) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *ApplicationSetSyncPolicy) DeepCopyInto(out *ApplicationSetSyncPolicy) { *out = *in From a2f4d7e92cba736be9bd8df7f4c30003b88d9fd4 Mon Sep 17 00:00:00 2001 From: Matt Groot Date: Wed, 17 Aug 2022 00:32:44 -0500 Subject: [PATCH 2/3] [ISSUE-9437] track application changes by hash, gate progressive rollouts behind experimental switch Signed-off-by: Matt Groot --- .../controllers/applicationset_controller.go | 135 ++-- .../applicationset_controller_test.go | 589 +++++++++++++----- .../commands/applicationset_controller.go | 50 +- .../applicationset/Progressive-Rollouts.md | 5 + .../operator-manual/argocd-cmd-params-cm.yaml | 11 +- ...-applicationset-controller-deployment.yaml | 8 +- manifests/core-install.yaml | 11 +- manifests/crds/applicationset-crd.yaml | 5 +- manifests/ha/install.yaml | 11 +- manifests/ha/namespace-install.yaml | 6 + manifests/install.yaml | 11 +- manifests/namespace-install.yaml | 6 + .../v1alpha1/applicationset_types.go | 6 +- 13 files changed, 604 insertions(+), 250 deletions(-) diff --git a/applicationset/controllers/applicationset_controller.go b/applicationset/controllers/applicationset_controller.go index baeb95e647088..3054ce4d0b9c2 100644 --- a/applicationset/controllers/applicationset_controller.go +++ b/applicationset/controllers/applicationset_controller.go @@ -16,6 +16,9 @@ package controllers import ( "context" + "crypto/md5" + "encoding/hex" + "encoding/json" "fmt" "time" @@ -68,6 +71,8 @@ type ApplicationSetReconciler struct { KubeClientset kubernetes.Interface utils.Policy utils.Renderer + EnableProgressiveRollouts bool + ApplicationProgressingTimeout uint } // +kubebuilder:rbac:groups=argoproj.io,resources=applicationsets,verbs=get;list;watch;create;update;patch;delete @@ -139,29 +144,42 @@ func (r *ApplicationSetReconciler) Reconcile(ctx context.Context, req ctrl.Reque return ctrl.Result{}, err } - _, err = r.updateApplicationSetApplicationStatus(ctx, &applicationSetInfo, applications) - if err != nil { - return ctrl.Result{}, err - } + appSyncMap := map[string]bool{} - appDependencyList, appStepMap, err := r.buildAppDependencyList(ctx, applicationSetInfo, desiredApplications) - if err != nil { - return ctrl.Result{}, err - } + if r.EnableProgressiveRollouts { + appHashMap := map[string]string{} + for _, app := range applications { + hash, err := hashApplicaton(app) + if err != nil { + log.Warnf("could not compute a hash value for Application '%v', will have to assume that the Application had changes", app.Name) + } + appHashMap[app.Name] = hash + } - appSyncMap, err := r.buildAppSyncMap(ctx, applicationSetInfo, appDependencyList) - if err != nil { - return ctrl.Result{}, err - } + _, err = r.updateApplicationSetApplicationStatus(ctx, &applicationSetInfo, applications, appHashMap) + if err != nil { + return ctrl.Result{}, err + } - _, err = r.updateApplicationSetApplicationStatusProgress(ctx, &applicationSetInfo, appSyncMap, appStepMap) - if err != nil { - return ctrl.Result{}, err - } + appDependencyList, appStepMap, err := r.buildAppDependencyList(ctx, applicationSetInfo, desiredApplications) + if err != nil { + return ctrl.Result{}, err + } - _, err = r.updateApplicationSetApplicationStatusConditions(ctx, &applicationSetInfo) - if err != nil { - return ctrl.Result{}, err + appSyncMap, err = r.buildAppSyncMap(ctx, applicationSetInfo, appDependencyList, appHashMap) + if err != nil { + return ctrl.Result{}, err + } + + _, err = r.updateApplicationSetApplicationStatusProgress(ctx, &applicationSetInfo, appSyncMap, appStepMap, appHashMap) + if err != nil { + return ctrl.Result{}, err + } + + _, err = r.updateApplicationSetApplicationStatusConditions(ctx, &applicationSetInfo) + if err != nil { + return ctrl.Result{}, err + } } var validApps []argov1alpha1.Application @@ -192,19 +210,21 @@ func (r *ApplicationSetReconciler) Reconcile(ctx context.Context, req ctrl.Reque ) } - // filter down valid applications if rollout strategy is enabled - strategy := applicationSetInfo.Spec.Strategy - if strategy != nil && strategy.Type == "RollingUpdate" { - var rolloutApps []argov1alpha1.Application - for i := range validApps { - // check appSyncMap to determine which Applications are ready to be updated and which should be skipped - if !appSyncMap[validApps[i].Name] { - log.Infof("skipping application generation, waiting for previous rollouts to complete before updating: %v", validApps[i].Name) - continue + if r.EnableProgressiveRollouts { + // filter down valid applications if rollout strategy is enabled + strategy := applicationSetInfo.Spec.Strategy + if strategy != nil && strategy.Type == "RollingUpdate" { + var rolloutApps []argov1alpha1.Application + for i := range validApps { + // check appSyncMap to determine which Applications are ready to be updated and which should be skipped + if !appSyncMap[validApps[i].Name] { + log.Infof("skipping application generation, waiting for previous rollouts to complete before updating: %v", validApps[i].Name) + continue + } + rolloutApps = append(rolloutApps, validApps[i]) } - rolloutApps = append(rolloutApps, validApps[i]) + validApps = rolloutApps } - validApps = rolloutApps } if r.Policy.Update() { @@ -415,7 +435,7 @@ func (r *ApplicationSetReconciler) setApplicationSetApplicationStatus(ctx contex break } currentStatus := applicationSet.Status.ApplicationStatus[idx] - if currentStatus.Message != appStatus.Message || currentStatus.Status != appStatus.Status || currentStatus.ObservedGeneration != appStatus.ObservedGeneration { + if currentStatus.Message != appStatus.Message || currentStatus.Status != appStatus.Status || currentStatus.ObservedHash != appStatus.ObservedHash { needToUpdateStatus = true break } @@ -826,6 +846,26 @@ func (r *ApplicationSetReconciler) removeFinalizerOnInvalidDestination(ctx conte return nil } +// computes a deterministic hash representing the Application spec +func hashApplicaton(application argov1alpha1.Application) (string, error) { + // ensure that the status and other dynamic fields are not included in the hash + appToHash := argov1alpha1.Application{} + appToHash.Annotations = application.Annotations + appToHash.Labels = application.Labels + appToHash.Name = application.Name + appToHash.Namespace = application.Namespace + appToHash.Spec = application.Spec + + jsonString, err := json.Marshal(appToHash) + if err != nil { + return "", err + } + + hash := md5.Sum(jsonString) + hashString := hex.EncodeToString(hash[:]) + return hashString, nil +} + // this list tracks which Applications belong to each RollingUpdate step func (r *ApplicationSetReconciler) buildAppDependencyList(ctx context.Context, applicationSet argoprojiov1alpha1.ApplicationSet, applications []argov1alpha1.Application) ([][]string, map[string]int, error) { @@ -890,7 +930,7 @@ func (r *ApplicationSetReconciler) buildAppDependencyList(ctx context.Context, a } // this map is used to determine which stage of Applications are ready to be updated in the reconciler loop -func (r *ApplicationSetReconciler) buildAppSyncMap(ctx context.Context, applicationSet argoprojiov1alpha1.ApplicationSet, appDependencyList [][]string) (map[string]bool, error) { +func (r *ApplicationSetReconciler) buildAppSyncMap(ctx context.Context, applicationSet argoprojiov1alpha1.ApplicationSet, appDependencyList [][]string, appHashMap map[string]string) (map[string]bool, error) { appSyncMap := map[string]bool{} syncEnabled := true @@ -911,8 +951,11 @@ func (r *ApplicationSetReconciler) buildAppSyncMap(ctx context.Context, applicat syncEnabled = false break } + appStatus := applicationSet.Status.ApplicationStatus[idx] - if appStatus.Status != "Healthy" || appStatus.ObservedGeneration != applicationSet.Generation { + // we still need to complete the current step if the Application is not yet Healthy or there are still pending Application changes + hashOutdated := appHashMap[appName] != appStatus.ObservedHash || appHashMap[appName] == "" + if appStatus.Status != "Healthy" || hashOutdated { syncEnabled = false break } @@ -923,7 +966,7 @@ func (r *ApplicationSetReconciler) buildAppSyncMap(ctx context.Context, applicat } // check the status of each Application's status and promote Applications to the next status if needed -func (r *ApplicationSetReconciler) updateApplicationSetApplicationStatus(ctx context.Context, applicationSet *argoprojiov1alpha1.ApplicationSet, applications []argov1alpha1.Application) ([]argoprojiov1alpha1.ApplicationSetApplicationStatus, error) { +func (r *ApplicationSetReconciler) updateApplicationSetApplicationStatus(ctx context.Context, applicationSet *argoprojiov1alpha1.ApplicationSet, applications []argov1alpha1.Application, appHashMap map[string]string) ([]argoprojiov1alpha1.ApplicationSetApplicationStatus, error) { now := metav1.Now() appStatuses := make([]argoprojiov1alpha1.ApplicationSetApplicationStatus, 0, len(applications)) @@ -939,17 +982,19 @@ func (r *ApplicationSetReconciler) updateApplicationSetApplicationStatus(ctx con Application: app.Name, LastTransitionTime: &now, Message: "No Application status found, defaulting status to Waiting.", - ObservedGeneration: applicationSet.Generation, // TODO: this should probably not be set to the current generation, maybe -1 instead? + ObservedHash: "", Status: "Waiting", }) } else { // we have an existing AppStatus currentAppStatus := applicationSet.Status.ApplicationStatus[idx] - if currentAppStatus.ObservedGeneration < applicationSet.Generation { + hashOutdated := appHashMap[app.Name] != currentAppStatus.ObservedHash || appHashMap[app.Name] == "" + if hashOutdated && currentAppStatus.Status != "Waiting" { + log.Infof("Application %v is outdated, updating its ApplciationSet status to Waiting", app.Name) currentAppStatus.LastTransitionTime = &now currentAppStatus.Status = "Waiting" - currentAppStatus.Message = "Application is out of date with the current AppSet generation, setting status to Waiting." + currentAppStatus.Message = "Application has pending changes, setting status to Waiting." } if currentAppStatus.Status == "Pending" { @@ -960,13 +1005,13 @@ func (r *ApplicationSetReconciler) updateApplicationSetApplicationStatus(ctx con currentAppStatus.Message = "Application resource became Progressing, updating status from Pending to Progressing." } else { duration := now.Sub(currentAppStatus.LastTransitionTime.Time) - log.Infof("%v pending duration minutes = %v", app.Name, duration.Minutes()) + log.Infof("%v pending duration seconds = %v", app.Name, duration.Seconds()) // handle timeout case where Application never proceeds to "Progressing", set status back to "Healthy" - if duration.Minutes() > 5 { - log.Infof("Application %v has been in Pending status for >5min, moving back to Healthy", app.Name) + if duration.Seconds() > float64(r.ApplicationProgressingTimeout) { + log.Infof("Application %v has been in Pending status for >%v seconds, moving back to Healthy", app.Name, r.ApplicationProgressingTimeout) currentAppStatus.LastTransitionTime = &now currentAppStatus.Status = "Healthy" - currentAppStatus.Message = "Application Pending status timed out while waiting to become Progressing, reset status to Healthy." + currentAppStatus.Message = fmt.Sprintf("Application Pending status timed out after waiting %v seconds to become Progressing, reset status to Healthy.", r.ApplicationProgressingTimeout) } } } @@ -991,7 +1036,7 @@ func (r *ApplicationSetReconciler) updateApplicationSetApplicationStatus(ctx con } // check Applications that are in Waiting status and promote them to Pending if needed -func (r *ApplicationSetReconciler) updateApplicationSetApplicationStatusProgress(ctx context.Context, applicationSet *argoprojiov1alpha1.ApplicationSet, appSyncMap map[string]bool, appStepMap map[string]int) ([]argoprojiov1alpha1.ApplicationSetApplicationStatus, error) { +func (r *ApplicationSetReconciler) updateApplicationSetApplicationStatusProgress(ctx context.Context, applicationSet *argoprojiov1alpha1.ApplicationSet, appSyncMap map[string]bool, appStepMap map[string]int, appHashMap map[string]string) ([]argoprojiov1alpha1.ApplicationSetApplicationStatus, error) { now := metav1.Now() appStatuses := make([]argoprojiov1alpha1.ApplicationSetApplicationStatus, 0, len(applicationSet.Status.ApplicationStatus)) @@ -1008,7 +1053,9 @@ func (r *ApplicationSetReconciler) updateApplicationSetApplicationStatusProgress // populate updateCountMap with counts of existing Pending and Progressing Applications for _, appStatus := range applicationSet.Status.ApplicationStatus { totalCountMap[appStepMap[appStatus.Application]] += 1 - if appStatus.ObservedGeneration == applicationSet.Generation && (appStatus.Status == "Pending" || appStatus.Status == "Progressing") { + + hashOutdated := appHashMap[appStatus.Application] != appStatus.ObservedHash || appHashMap[appStatus.Application] == "" + if hashOutdated && (appStatus.Status == "Pending" || appStatus.Status == "Progressing") { updateCountMap[appStepMap[appStatus.Application]] += 1 } } @@ -1039,7 +1086,7 @@ func (r *ApplicationSetReconciler) updateApplicationSetApplicationStatusProgress log.Infof("Application %v moved to Pending status, watching for the Application to start Progressing", appStatus.Application) appStatus.LastTransitionTime = &now appStatus.Status = "Pending" - appStatus.ObservedGeneration = applicationSet.Generation + appStatus.ObservedHash = appHashMap[appStatus.Application] appStatus.Message = "Application moved to Pending status, watching for the Application resource to start Progressing." updateCountMap[appStepMap[appStatus.Application]] += 1 diff --git a/applicationset/controllers/applicationset_controller_test.go b/applicationset/controllers/applicationset_controller_test.go index e31bcb892f896..05bdd92704517 100644 --- a/applicationset/controllers/applicationset_controller_test.go +++ b/applicationset/controllers/applicationset_controller_test.go @@ -1958,7 +1958,7 @@ func TestSetApplicationSetApplicationStatus(t *testing.T) { Application: "my-application", LastTransitionTime: &metav1.Time{}, Message: "testing SetApplicationSetApplicationStatus to Healthy", - ObservedGeneration: 1, + ObservedHash: "1", Status: "Healthy", }, } @@ -1988,6 +1988,98 @@ func TestSetApplicationSetApplicationStatus(t *testing.T) { assert.Len(t, appSet.Status.ApplicationStatus, 1) } +func TestHashApplicaton(t *testing.T) { + + for _, cc := range []struct { + name string + app argov1alpha1.Application + expectedHash string + }{ + { + name: "handles an empty application", + app: argov1alpha1.Application{}, + expectedHash: "a5225141462ae4d3ed1c341033e57fd5", + }, + { + name: "handles a basic application", + app: argov1alpha1.Application{ + ObjectMeta: metav1.ObjectMeta{ + Name: "app-dev", + Labels: map[string]string{ + "env": "dev", + }, + }, + Spec: argov1alpha1.ApplicationSpec{ + Source: argov1alpha1.ApplicationSource{ + RepoURL: "https://example.com", + }, + Destination: argov1alpha1.ApplicationDestination{ + Name: "in-cluster", + }, + }, + }, + expectedHash: "1aedc739ac4aa446c656994a7e8e3b80", + }, + { + name: "handles a different application", + app: argov1alpha1.Application{ + ObjectMeta: metav1.ObjectMeta{ + Name: "app-dev", + Labels: map[string]string{ + "env": "dev", + }, + }, + Spec: argov1alpha1.ApplicationSpec{ + Source: argov1alpha1.ApplicationSource{ + RepoURL: "https://bad-example.com", + }, + Destination: argov1alpha1.ApplicationDestination{ + Name: "out-cluster", + }, + }, + }, + expectedHash: "863b6d5713d302cec90bf547e1ae9281", + }, + { + name: "ignores the status and operation fields", + app: argov1alpha1.Application{ + ObjectMeta: metav1.ObjectMeta{ + Name: "app-dev", + Labels: map[string]string{ + "env": "dev", + }, + }, + Spec: argov1alpha1.ApplicationSpec{ + Source: argov1alpha1.ApplicationSource{ + RepoURL: "https://example.com", + }, + Destination: argov1alpha1.ApplicationDestination{ + Name: "in-cluster", + }, + }, + Status: argov1alpha1.ApplicationStatus{ + Health: argov1alpha1.HealthStatus{ + Status: health.HealthStatusHealthy, + Message: "the app is healthy", + }, + }, + Operation: &argov1alpha1.Operation{ + InitiatedBy: argov1alpha1.OperationInitiator{ + Username: "test-user", + Automated: false, + }, + }, + }, + expectedHash: "1aedc739ac4aa446c656994a7e8e3b80", + }, + } { + t.Run(cc.name, func(t *testing.T) { + hash, err := hashApplicaton(cc.app) + assert.Equal(t, err, nil, "expected no errors, but errors occured") + assert.Equal(t, cc.expectedHash, hash, "expected hash did not match actual") + }) + } +} func TestBuildAppDependencyList(t *testing.T) { @@ -2360,6 +2452,7 @@ func TestBuildAppSyncMap(t *testing.T) { name string appSet argoprojiov1alpha1.ApplicationSet appDependencyList [][]string + appHashMap map[string]string expectedMap map[string]bool }{ { @@ -2387,6 +2480,10 @@ func TestBuildAppSyncMap(t *testing.T) { {"app1"}, {"app2"}, }, + appHashMap: map[string]string{ + "app1": "11", + "app2": "22", + }, expectedMap: map[string]bool{ "app1": true, "app2": false, @@ -2411,25 +2508,24 @@ func TestBuildAppSyncMap(t *testing.T) { }, }, { - name: "handles applications that are healthy and match the appset generation", + name: "handles applications that are healthy and have no changes", appSet: argoprojiov1alpha1.ApplicationSet{ ObjectMeta: metav1.ObjectMeta{ - Name: "name", - Namespace: "argocd", - Generation: 1, + Name: "name", + Namespace: "argocd", }, Spec: argoprojiov1alpha1.ApplicationSetSpec{}, Status: argoprojiov1alpha1.ApplicationSetStatus{ ApplicationStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ { - Application: "app1", - ObservedGeneration: 1, - Status: "Healthy", + Application: "app1", + ObservedHash: "1", + Status: "Healthy", }, { - Application: "app2", - ObservedGeneration: 1, - Status: "Healthy", + Application: "app2", + ObservedHash: "2", + Status: "Healthy", }, }, }, @@ -2438,31 +2534,34 @@ func TestBuildAppSyncMap(t *testing.T) { {"app1"}, {"app2"}, }, + appHashMap: map[string]string{ + "app1": "1", + "app2": "2", + }, expectedMap: map[string]bool{ "app1": true, "app2": true, }, }, { - name: "handles applications that are healthy but out of date", + name: "handles applications that are healthy, but out of date", appSet: argoprojiov1alpha1.ApplicationSet{ ObjectMeta: metav1.ObjectMeta{ - Name: "name", - Namespace: "argocd", - Generation: 2, + Name: "name", + Namespace: "argocd", }, Spec: argoprojiov1alpha1.ApplicationSetSpec{}, Status: argoprojiov1alpha1.ApplicationSetStatus{ ApplicationStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ { - Application: "app1", - ObservedGeneration: 1, - Status: "Healthy", + Application: "app1", + ObservedHash: "1", + Status: "Healthy", }, { - Application: "app2", - ObservedGeneration: 1, - Status: "Healthy", + Application: "app2", + ObservedHash: "2", + Status: "Healthy", }, }, }, @@ -2471,6 +2570,46 @@ func TestBuildAppSyncMap(t *testing.T) { {"app1"}, {"app2"}, }, + appHashMap: map[string]string{ + "app1": "11", + "app2": "22", + }, + expectedMap: map[string]bool{ + "app1": true, + "app2": false, + }, + }, + { + name: "handles applications that are healthy, but have an empty hash", + appSet: argoprojiov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argoprojiov1alpha1.ApplicationSetSpec{}, + Status: argoprojiov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + ObservedHash: "1", + Status: "Healthy", + }, + { + Application: "app2", + ObservedHash: "2", + Status: "Healthy", + }, + }, + }, + }, + appDependencyList: [][]string{ + {"app1"}, + {"app2"}, + }, + appHashMap: map[string]string{ + "app1": "", + "app2": "", + }, expectedMap: map[string]bool{ "app1": true, "app2": false, @@ -2480,22 +2619,21 @@ func TestBuildAppSyncMap(t *testing.T) { name: "handles applications that are up to date, but not healthy", appSet: argoprojiov1alpha1.ApplicationSet{ ObjectMeta: metav1.ObjectMeta{ - Name: "name", - Namespace: "argocd", - Generation: 2, + Name: "name", + Namespace: "argocd", }, Spec: argoprojiov1alpha1.ApplicationSetSpec{}, Status: argoprojiov1alpha1.ApplicationSetStatus{ ApplicationStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ { - Application: "app1", - ObservedGeneration: 2, - Status: "Progressing", + Application: "app1", + ObservedHash: "11", + Status: "Progressing", }, { - Application: "app2", - ObservedGeneration: 2, - Status: "Progressing", + Application: "app2", + ObservedHash: "22", + Status: "Progressing", }, }, }, @@ -2504,6 +2642,10 @@ func TestBuildAppSyncMap(t *testing.T) { {"app1"}, {"app2"}, }, + appHashMap: map[string]string{ + "app1": "11", + "app2": "22", + }, expectedMap: map[string]bool{ "app1": true, "app2": false, @@ -2513,32 +2655,36 @@ func TestBuildAppSyncMap(t *testing.T) { name: "handles a lot of applications", appSet: argoprojiov1alpha1.ApplicationSet{ ObjectMeta: metav1.ObjectMeta{ - Name: "name", - Namespace: "argocd", - Generation: 2, + Name: "name", + Namespace: "argocd", }, Spec: argoprojiov1alpha1.ApplicationSetSpec{}, Status: argoprojiov1alpha1.ApplicationSetStatus{ ApplicationStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ { - Application: "app1", - ObservedGeneration: 2, - Status: "Healthy", + Application: "app1", + ObservedHash: "1", + Status: "Healthy", }, { - Application: "app2", - ObservedGeneration: 2, - Status: "Healthy", + Application: "app2", + ObservedHash: "2", + Status: "Healthy", }, { - Application: "app4", - ObservedGeneration: 2, - Status: "Healthy", + Application: "app4", + ObservedHash: "4", + Status: "Healthy", }, { - Application: "app7", - ObservedGeneration: 2, - Status: "Healthy", + Application: "app5", + ObservedHash: "5", + Status: "Healthy", + }, + { + Application: "app7", + ObservedHash: "7", + Status: "Healthy", }, }, }, @@ -2548,6 +2694,12 @@ func TestBuildAppSyncMap(t *testing.T) { {"app2", "app5", "app8"}, {"app3", "app6", "app9"}, }, + appHashMap: map[string]string{ + "app1": "1", + "app2": "2", + "app4": "4", + "app7": "7", + }, expectedMap: map[string]bool{ "app1": true, "app2": true, @@ -2578,7 +2730,7 @@ func TestBuildAppSyncMap(t *testing.T) { KubeClientset: kubeclientset, } - appSyncMap, err := r.buildAppSyncMap(context.TODO(), cc.appSet, cc.appDependencyList) + appSyncMap, err := r.buildAppSyncMap(context.TODO(), cc.appSet, cc.appDependencyList, cc.appHashMap) assert.Equal(t, err, nil, "expected no errors, but errors occured") assert.Equal(t, cc.expectedMap, appSyncMap, "expected appSyncMap did not match actual") }) @@ -2598,6 +2750,7 @@ func TestUpdateApplicationSetApplicationStatus(t *testing.T) { name string appSet argoprojiov1alpha1.ApplicationSet apps []argov1alpha1.Application + appHashMap map[string]string expectedAppStatus []argoprojiov1alpha1.ApplicationSetApplicationStatus }{ { @@ -2607,9 +2760,6 @@ func TestUpdateApplicationSetApplicationStatus(t *testing.T) { Name: "name", Namespace: "argocd", }, - // Status: argoprojiov1alpha1.ApplicationSetStatus{ - // ApplicationStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{}, - // }, }, apps: []argov1alpha1.Application{}, expectedAppStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{}, @@ -2636,10 +2786,10 @@ func TestUpdateApplicationSetApplicationStatus(t *testing.T) { }, expectedAppStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ { - Application: "app1", - Message: "No Application status found, defaulting status to Waiting.", - ObservedGeneration: 0, - Status: "Waiting", + Application: "app1", + Message: "No Application status found, defaulting status to Waiting.", + ObservedHash: "", + Status: "Waiting", }, }, }, @@ -2666,15 +2816,57 @@ func TestUpdateApplicationSetApplicationStatus(t *testing.T) { }, expectedAppStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ { - Application: "app1", - Message: "No Application status found, defaulting status to Waiting.", - ObservedGeneration: 0, - Status: "Waiting", + Application: "app1", + Message: "No Application status found, defaulting status to Waiting.", + ObservedHash: "", + Status: "Waiting", + }, + }, + }, + { + name: "progresses an out of date application to waiting", + appSet: argoprojiov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Status: argoprojiov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Message: "", + ObservedHash: "1", + Status: "Healthy", + }, + }, + }, + }, + apps: []argov1alpha1.Application{ + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app1", + }, + Status: argov1alpha1.ApplicationStatus{ + Health: argov1alpha1.HealthStatus{ + Status: health.HealthStatusHealthy, + }, + }, + }, + }, + appHashMap: map[string]string{ + "app1": "11", + }, + expectedAppStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Message: "Application has pending changes, setting status to Waiting.", + ObservedHash: "1", + Status: "Waiting", }, }, }, { - name: "progresses an out of date healthy application to waiting", + name: "progresses an out of date application with no hash to waiting", appSet: argoprojiov1alpha1.ApplicationSet{ ObjectMeta: metav1.ObjectMeta{ Name: "name", @@ -2684,10 +2876,9 @@ func TestUpdateApplicationSetApplicationStatus(t *testing.T) { Status: argoprojiov1alpha1.ApplicationSetStatus{ ApplicationStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ { - Application: "app1", - Message: "", - ObservedGeneration: 1, - Status: "Healthy", + Application: "app1", + Message: "", + Status: "Healthy", }, }, }, @@ -2704,12 +2895,98 @@ func TestUpdateApplicationSetApplicationStatus(t *testing.T) { }, }, }, + appHashMap: map[string]string{ + "app1": "", + }, expectedAppStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ { - Application: "app1", - Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", - ObservedGeneration: 1, - Status: "Waiting", + Application: "app1", + Message: "Application has pending changes, setting status to Waiting.", + Status: "Waiting", + }, + }, + }, + { + name: "does not progress an unchanged application to waiting", + appSet: argoprojiov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Status: argoprojiov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Message: "", + ObservedHash: "1", + Status: "Healthy", + }, + }, + }, + }, + apps: []argov1alpha1.Application{ + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app1", + }, + Status: argov1alpha1.ApplicationStatus{ + Health: argov1alpha1.HealthStatus{ + Status: health.HealthStatusHealthy, + }, + }, + }, + }, + appHashMap: map[string]string{ + "app1": "1", + }, + expectedAppStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Message: "", + ObservedHash: "1", + Status: "Healthy", + }, + }, + }, + { + name: "does not progress a waiting application to waiting", + appSet: argoprojiov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Status: argoprojiov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Message: "", + ObservedHash: "1", + Status: "Waiting", + }, + }, + }, + }, + apps: []argov1alpha1.Application{ + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app1", + }, + Status: argov1alpha1.ApplicationStatus{ + Health: argov1alpha1.HealthStatus{ + Status: health.HealthStatusHealthy, + }, + }, + }, + }, + appHashMap: map[string]string{ + "app1": "1", + }, + expectedAppStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Message: "", + ObservedHash: "1", + Status: "Waiting", }, }, }, @@ -2717,17 +2994,16 @@ func TestUpdateApplicationSetApplicationStatus(t *testing.T) { name: "progresses a pending application to progressing", appSet: argoprojiov1alpha1.ApplicationSet{ ObjectMeta: metav1.ObjectMeta{ - Name: "name", - Namespace: "argocd", - Generation: 2, + Name: "name", + Namespace: "argocd", }, Status: argoprojiov1alpha1.ApplicationSetStatus{ ApplicationStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ { - Application: "app1", - Message: "", - ObservedGeneration: 2, - Status: "Pending", + Application: "app1", + Message: "", + ObservedHash: "1", + Status: "Pending", }, }, }, @@ -2744,12 +3020,15 @@ func TestUpdateApplicationSetApplicationStatus(t *testing.T) { }, }, }, + appHashMap: map[string]string{ + "app1": "1", + }, expectedAppStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ { - Application: "app1", - Message: "Application resource became Progressing, updating status from Pending to Progressing.", - ObservedGeneration: 2, - Status: "Progressing", + Application: "app1", + Message: "Application resource became Progressing, updating status from Pending to Progressing.", + ObservedHash: "1", + Status: "Progressing", }, }, }, @@ -2757,9 +3036,8 @@ func TestUpdateApplicationSetApplicationStatus(t *testing.T) { name: "progresses a pending application to healthy on timeout", appSet: argoprojiov1alpha1.ApplicationSet{ ObjectMeta: metav1.ObjectMeta{ - Name: "name", - Namespace: "argocd", - Generation: 2, + Name: "name", + Namespace: "argocd", }, Status: argoprojiov1alpha1.ApplicationSetStatus{ ApplicationStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ @@ -2767,7 +3045,7 @@ func TestUpdateApplicationSetApplicationStatus(t *testing.T) { Application: "app1", LastTransitionTime: &metav1.Time{}, Message: "", - ObservedGeneration: 2, + ObservedHash: "1", Status: "Pending", }, }, @@ -2785,12 +3063,15 @@ func TestUpdateApplicationSetApplicationStatus(t *testing.T) { }, }, }, + appHashMap: map[string]string{ + "app1": "1", + }, expectedAppStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ { - Application: "app1", - Message: "Application Pending status timed out while waiting to become Progressing, reset status to Healthy.", - ObservedGeneration: 2, - Status: "Healthy", + Application: "app1", + Message: "Application Pending status timed out after waiting 0 seconds to become Progressing, reset status to Healthy.", + ObservedHash: "1", + Status: "Healthy", }, }, }, @@ -2798,17 +3079,16 @@ func TestUpdateApplicationSetApplicationStatus(t *testing.T) { name: "progresses a progressing application to healthy", appSet: argoprojiov1alpha1.ApplicationSet{ ObjectMeta: metav1.ObjectMeta{ - Name: "name", - Namespace: "argocd", - Generation: 2, + Name: "name", + Namespace: "argocd", }, Status: argoprojiov1alpha1.ApplicationSetStatus{ ApplicationStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ { - Application: "app1", - Message: "", - ObservedGeneration: 2, - Status: "Progressing", + Application: "app1", + Message: "", + ObservedHash: "1", + Status: "Progressing", }, }, }, @@ -2825,12 +3105,15 @@ func TestUpdateApplicationSetApplicationStatus(t *testing.T) { }, }, }, + appHashMap: map[string]string{ + "app1": "1", + }, expectedAppStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ { - Application: "app1", - Message: "Application resource became Healthy, updating status from Progressing to Healthy.", - ObservedGeneration: 2, - Status: "Healthy", + Application: "app1", + Message: "Application resource became Healthy, updating status from Progressing to Healthy.", + ObservedHash: "1", + Status: "Healthy", }, }, }, @@ -2854,7 +3137,7 @@ func TestUpdateApplicationSetApplicationStatus(t *testing.T) { KubeClientset: kubeclientset, } - appStatuses, err := r.updateApplicationSetApplicationStatus(context.TODO(), &cc.appSet, cc.apps) + appStatuses, err := r.updateApplicationSetApplicationStatus(context.TODO(), &cc.appSet, cc.apps, cc.appHashMap) // opt out of testing the LastTransitionTime is accurate for i := range appStatuses { @@ -2881,6 +3164,7 @@ func TestUpdateApplicationSetApplicationStatusProgress(t *testing.T) { appSet argoprojiov1alpha1.ApplicationSet appSyncMap map[string]bool appStepMap map[string]int + appHashMap map[string]string expectedAppStatus []argoprojiov1alpha1.ApplicationSetApplicationStatus }{ { @@ -2972,9 +3256,8 @@ func TestUpdateApplicationSetApplicationStatusProgress(t *testing.T) { name: "handles updating a status from Waiting to Pending", appSet: argoprojiov1alpha1.ApplicationSet{ ObjectMeta: metav1.ObjectMeta{ - Name: "name", - Namespace: "argocd", - Generation: 2, + Name: "name", + Namespace: "argocd", }, Spec: argoprojiov1alpha1.ApplicationSetSpec{ Strategy: &argoprojiov1alpha1.ApplicationSetStrategy{ @@ -2994,10 +3277,9 @@ func TestUpdateApplicationSetApplicationStatusProgress(t *testing.T) { Status: argoprojiov1alpha1.ApplicationSetStatus{ ApplicationStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ { - Application: "app1", - Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", - ObservedGeneration: 1, - Status: "Waiting", + Application: "app1", + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + Status: "Waiting", }, }, }, @@ -3008,12 +3290,15 @@ func TestUpdateApplicationSetApplicationStatusProgress(t *testing.T) { appStepMap: map[string]int{ "app1": 0, }, + appHashMap: map[string]string{ + "app1": "1", + }, expectedAppStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ { Application: "app1", LastTransitionTime: nil, Message: "Application moved to Pending status, watching for the Application resource to start Progressing.", - ObservedGeneration: 2, + ObservedHash: "1", Status: "Pending", }, }, @@ -3022,9 +3307,8 @@ func TestUpdateApplicationSetApplicationStatusProgress(t *testing.T) { name: "does not update a status if appSyncMap is false", appSet: argoprojiov1alpha1.ApplicationSet{ ObjectMeta: metav1.ObjectMeta{ - Name: "name", - Namespace: "argocd", - Generation: 2, + Name: "name", + Namespace: "argocd", }, Spec: argoprojiov1alpha1.ApplicationSetSpec{ Strategy: &argoprojiov1alpha1.ApplicationSetStrategy{ @@ -3044,10 +3328,9 @@ func TestUpdateApplicationSetApplicationStatusProgress(t *testing.T) { Status: argoprojiov1alpha1.ApplicationSetStatus{ ApplicationStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ { - Application: "app1", - Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", - ObservedGeneration: 1, - Status: "Waiting", + Application: "app1", + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + Status: "Waiting", }, }, }, @@ -3063,7 +3346,6 @@ func TestUpdateApplicationSetApplicationStatusProgress(t *testing.T) { Application: "app1", LastTransitionTime: nil, Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", - ObservedGeneration: 1, Status: "Waiting", }, }, @@ -3072,9 +3354,8 @@ func TestUpdateApplicationSetApplicationStatusProgress(t *testing.T) { name: "does not update a status if status is not pending", appSet: argoprojiov1alpha1.ApplicationSet{ ObjectMeta: metav1.ObjectMeta{ - Name: "name", - Namespace: "argocd", - Generation: 2, + Name: "name", + Namespace: "argocd", }, Spec: argoprojiov1alpha1.ApplicationSetSpec{ Strategy: &argoprojiov1alpha1.ApplicationSetStrategy{ @@ -3094,10 +3375,9 @@ func TestUpdateApplicationSetApplicationStatusProgress(t *testing.T) { Status: argoprojiov1alpha1.ApplicationSetStatus{ ApplicationStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ { - Application: "app1", - Message: "Application Pending status timed out while waiting to become Progressing, reset status to Healthy.", - ObservedGeneration: 1, - Status: "Healthy", + Application: "app1", + Message: "Application Pending status timed out while waiting to become Progressing, reset status to Healthy.", + Status: "Healthy", }, }, }, @@ -3113,7 +3393,6 @@ func TestUpdateApplicationSetApplicationStatusProgress(t *testing.T) { Application: "app1", LastTransitionTime: nil, Message: "Application Pending status timed out while waiting to become Progressing, reset status to Healthy.", - ObservedGeneration: 1, Status: "Healthy", }, }, @@ -3122,9 +3401,8 @@ func TestUpdateApplicationSetApplicationStatusProgress(t *testing.T) { name: "does not update a status if maxUpdate has already been reached", appSet: argoprojiov1alpha1.ApplicationSet{ ObjectMeta: metav1.ObjectMeta{ - Name: "name", - Namespace: "argocd", - Generation: 2, + Name: "name", + Namespace: "argocd", }, Spec: argoprojiov1alpha1.ApplicationSetSpec{ Strategy: &argoprojiov1alpha1.ApplicationSetStrategy{ @@ -3148,28 +3426,24 @@ func TestUpdateApplicationSetApplicationStatusProgress(t *testing.T) { Status: argoprojiov1alpha1.ApplicationSetStatus{ ApplicationStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ { - Application: "app1", - Message: "Application resource became Progressing, updating status from Pending to Progressing.", - ObservedGeneration: 2, - Status: "Progressing", + Application: "app1", + Message: "Application resource became Progressing, updating status from Pending to Progressing.", + Status: "Progressing", }, { - Application: "app2", - Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", - ObservedGeneration: 1, - Status: "Waiting", + Application: "app2", + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + Status: "Waiting", }, { - Application: "app3", - Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", - ObservedGeneration: 1, - Status: "Waiting", + Application: "app3", + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + Status: "Waiting", }, { - Application: "app4", - Message: "Application moved to Pending status, watching for the Application resource to start Progressing.", - ObservedGeneration: 2, - Status: "Pending", + Application: "app4", + Message: "Application moved to Pending status, watching for the Application resource to start Progressing.", + Status: "Pending", }, }, }, @@ -3191,28 +3465,24 @@ func TestUpdateApplicationSetApplicationStatusProgress(t *testing.T) { Application: "app1", LastTransitionTime: nil, Message: "Application resource became Progressing, updating status from Pending to Progressing.", - ObservedGeneration: 2, Status: "Progressing", }, { Application: "app2", LastTransitionTime: nil, Message: "Application moved to Pending status, watching for the Application resource to start Progressing.", - ObservedGeneration: 2, Status: "Pending", }, { Application: "app3", LastTransitionTime: nil, Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", - ObservedGeneration: 1, Status: "Waiting", }, { Application: "app4", LastTransitionTime: nil, Message: "Application moved to Pending status, watching for the Application resource to start Progressing.", - ObservedGeneration: 2, Status: "Pending", }, }, @@ -3221,9 +3491,8 @@ func TestUpdateApplicationSetApplicationStatusProgress(t *testing.T) { name: "handles maxUpdate set to percentage string", appSet: argoprojiov1alpha1.ApplicationSet{ ObjectMeta: metav1.ObjectMeta{ - Name: "name", - Namespace: "argocd", - Generation: 2, + Name: "name", + Namespace: "argocd", }, Spec: argoprojiov1alpha1.ApplicationSetSpec{ Strategy: &argoprojiov1alpha1.ApplicationSetStrategy{ @@ -3247,22 +3516,19 @@ func TestUpdateApplicationSetApplicationStatusProgress(t *testing.T) { Status: argoprojiov1alpha1.ApplicationSetStatus{ ApplicationStatus: []argoprojiov1alpha1.ApplicationSetApplicationStatus{ { - Application: "app1", - Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", - ObservedGeneration: 1, - Status: "Waiting", + Application: "app1", + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + Status: "Waiting", }, { - Application: "app2", - Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", - ObservedGeneration: 1, - Status: "Waiting", + Application: "app2", + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + Status: "Waiting", }, { - Application: "app3", - Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", - ObservedGeneration: 1, - Status: "Waiting", + Application: "app3", + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + Status: "Waiting", }, }, }, @@ -3282,21 +3548,18 @@ func TestUpdateApplicationSetApplicationStatusProgress(t *testing.T) { Application: "app1", LastTransitionTime: nil, Message: "Application moved to Pending status, watching for the Application resource to start Progressing.", - ObservedGeneration: 2, Status: "Pending", }, { Application: "app2", LastTransitionTime: nil, Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", - ObservedGeneration: 1, Status: "Waiting", }, { Application: "app3", LastTransitionTime: nil, Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", - ObservedGeneration: 1, Status: "Waiting", }, }, @@ -3321,7 +3584,7 @@ func TestUpdateApplicationSetApplicationStatusProgress(t *testing.T) { KubeClientset: kubeclientset, } - appStatuses, err := r.updateApplicationSetApplicationStatusProgress(context.TODO(), &cc.appSet, cc.appSyncMap, cc.appStepMap) + appStatuses, err := r.updateApplicationSetApplicationStatusProgress(context.TODO(), &cc.appSet, cc.appSyncMap, cc.appStepMap, cc.appHashMap) // opt out of testing the LastTransitionTime is accurate for i := range appStatuses { diff --git a/cmd/argocd-applicationset-controller/commands/applicationset_controller.go b/cmd/argocd-applicationset-controller/commands/applicationset_controller.go index 8b6d1e1595ca0..128662b830854 100644 --- a/cmd/argocd-applicationset-controller/commands/applicationset_controller.go +++ b/cmd/argocd-applicationset-controller/commands/applicationset_controller.go @@ -45,18 +45,20 @@ func getSubmoduleEnabled() bool { func NewCommand() *cobra.Command { var ( - clientConfig clientcmd.ClientConfig - metricsAddr string - probeBindAddr string - webhookAddr string - enableLeaderElection bool - namespace string - argocdRepoServer string - policy string - debugLog bool - dryRun bool - logFormat string - logLevel string + clientConfig clientcmd.ClientConfig + metricsAddr string + probeBindAddr string + webhookAddr string + enableLeaderElection bool + namespace string + argocdRepoServer string + policy string + debugLog bool + dryRun bool + logFormat string + logLevel string + enableProgressiveRollouts bool + applicationProgressingTimeout uint ) scheme := runtime.NewScheme() _ = clientgoscheme.AddToScheme(scheme) @@ -178,16 +180,18 @@ func NewCommand() *cobra.Command { go func() { errors.CheckError(askPassServer.Run(askpass.SocketPath)) }() if err = (&controllers.ApplicationSetReconciler{ - Generators: topLevelGenerators, - Client: mgr.GetClient(), - Log: ctrl.Log.WithName("controllers").WithName("ApplicationSet"), - Scheme: mgr.GetScheme(), - Recorder: mgr.GetEventRecorderFor("applicationset-controller"), - Renderer: &utils.Render{}, - Policy: policyObj, - ArgoAppClientset: appSetConfig, - KubeClientset: k8sClient, - ArgoDB: argoCDDB, + Generators: topLevelGenerators, + Client: mgr.GetClient(), + Log: ctrl.Log.WithName("controllers").WithName("ApplicationSet"), + Scheme: mgr.GetScheme(), + Recorder: mgr.GetEventRecorderFor("applicationset-controller"), + Renderer: &utils.Render{}, + Policy: policyObj, + ArgoAppClientset: appSetConfig, + KubeClientset: k8sClient, + ArgoDB: argoCDDB, + EnableProgressiveRollouts: enableProgressiveRollouts, + ApplicationProgressingTimeout: applicationProgressingTimeout, }).SetupWithManager(mgr); err != nil { log.Error(err, "unable to create controller", "controller", "ApplicationSet") os.Exit(1) @@ -216,6 +220,8 @@ func NewCommand() *cobra.Command { command.Flags().StringVar(&logLevel, "loglevel", "info", "Set the logging level. One of: debug|info|warn|error") command.Flags().BoolVar(&dryRun, "dry-run", false, "Enable dry run mode") command.Flags().StringVar(&logFormat, "logformat", "text", "Set the logging format. One of: text|json") + command.Flags().BoolVar(&enableProgressiveRollouts, "enable-progressive-rollouts", env.ParseBoolFromEnv("ARGOCD_APPLICATIONSET_ENABLE_PROGRESSIVE_ROLLOUTS", false), "Enable use of the experimental progressive rollouts feature.") + command.Flags().UintVar(&applicationProgressingTimeout, "application-progressing-timeout", 300, "When Progressive Rollouts is enabled, automatically move a Pending Application to Healthy after this many seconds.") return &command } diff --git a/docs/operator-manual/applicationset/Progressive-Rollouts.md b/docs/operator-manual/applicationset/Progressive-Rollouts.md index 39ad6a495bcc5..a7ae690286ea8 100644 --- a/docs/operator-manual/applicationset/Progressive-Rollouts.md +++ b/docs/operator-manual/applicationset/Progressive-Rollouts.md @@ -9,6 +9,11 @@ The Progressive Rollouts feature set is intended to be light and flexible. The f * Deployments, Daemonsets, StatefulSets, and [Argo Rollouts](https://argoproj.github.io/argo-rollouts/) are all supported, because the Application enters a "Progressing" state while pods are being rolled out. * [Argo CD Resource Hooks](../../user-guide/resource_hooks.md) are supported. We recommend this approach for users that need advanced functionality when an Argo Rollout cannot be used, such as smoke testing after a Daemonset change. +## Enabling Progressive Rollouts +As an experimental feature, progressive rollouts must be explicitly enabled, in one of two ways. +1. Pass `--enable-progressive-rollouts` to the ApplicationSet controller args. +1. Set `ARGOCD_APPLICATIONSET_ENABLE_PROGRESSIVE_ROLLOUTS=true` in the ApplicationSet controller environment variables. + ## Strategies * AllAtOnce (default) diff --git a/docs/operator-manual/argocd-cmd-params-cm.yaml b/docs/operator-manual/argocd-cmd-params-cm.yaml index 32388ee65d0be..24e71024b3a25 100644 --- a/docs/operator-manual/argocd-cmd-params-cm.yaml +++ b/docs/operator-manual/argocd-cmd-params-cm.yaml @@ -8,7 +8,7 @@ metadata: data: # Repo server address. (default "argocd-repo-server:8081") repo.server: "argocd-repo-server:8081" - + # Dex server address (default "http://argocd-dex-server:5556") dex.server: "http://argocd-dex-server:5556" @@ -58,6 +58,9 @@ data: # Cache expiration default (default 24h0m0s) controller.default.cache.expiration: "24h0m0s" + # Enables use of the Progressive Rollouts capability for ApplicationSets + applicationset.enable.progressive.rollouts: "false" + ## Server properties # Run server without TLS server.insecure: "false" @@ -131,14 +134,14 @@ data: reposerver.max.combined.directory.manifests.size: '10M' # Paths to be excluded from the tarball streamed to plugins. Separate with ; reposerver.plugin.tar.exclusions: "" - # Allow repositories to contain symlinks that leave the boundaries of the repository. - # Changing this to "true" will not allow _all_ out-of-bounds symlinks. Those will still be blocked for things like values + # Allow repositories to contain symlinks that leave the boundaries of the repository. + # Changing this to "true" will not allow _all_ out-of-bounds symlinks. Those will still be blocked for things like values # files in Helm charts. But symlinks which are not explicitly blocked by other checks will be allowed. reposerver.allow.oob.symlinks: "false" # Maximum size of tarball when streaming manifests to the repo server for generation reposerver.streamed.manifest.max.tar.size: "100M" # Maximum size of extracted manifests when streaming manifests to the repo server for generation reposerver.streamed.manifest.max.extracted.size: "1G" - + # Disable TLS on the HTTP endpoint dexserver.disable.tls: "false" diff --git a/manifests/base/applicationset-controller/argocd-applicationset-controller-deployment.yaml b/manifests/base/applicationset-controller/argocd-applicationset-controller-deployment.yaml index c27d77b2921ff..29fdfa4bbc206 100644 --- a/manifests/base/applicationset-controller/argocd-applicationset-controller-deployment.yaml +++ b/manifests/base/applicationset-controller/argocd-applicationset-controller-deployment.yaml @@ -32,6 +32,12 @@ spec: valueFrom: fieldRef: fieldPath: metadata.namespace + - name: ARGOCD_APPLICATIONSET_ENABLE_PROGRESSIVE_ROLLOUTS + valueFrom: + configMapKeyRef: + name: argocd-cmd-params-cm + key: applicationset.enable.progressive.rollouts + optional: true volumeMounts: - mountPath: /app/config/ssh name: ssh-known-hosts @@ -48,7 +54,7 @@ spec: drop: - ALL allowPrivilegeEscalation: false - readOnlyRootFilesystem: true + readOnlyRootFilesystem: true runAsNonRoot: true seccompProfile: type: RuntimeDefault diff --git a/manifests/core-install.yaml b/manifests/core-install.yaml index 92c1064d481d3..ec3d145c5792d 100644 --- a/manifests/core-install.yaml +++ b/manifests/core-install.yaml @@ -8912,9 +8912,8 @@ spec: type: string message: type: string - observedGeneration: - format: int64 - type: integer + observedHash: + type: string status: type: string required: @@ -9668,6 +9667,12 @@ spec: valueFrom: fieldRef: fieldPath: metadata.namespace + - name: ARGOCD_APPLICATIONSET_ENABLE_PROGRESSIVE_ROLLOUTS + valueFrom: + configMapKeyRef: + key: applicationset.enable.progressive.rollouts + name: argocd-cmd-params-cm + optional: true image: quay.io/argoproj/argocd:latest imagePullPolicy: Always name: argocd-applicationset-controller diff --git a/manifests/crds/applicationset-crd.yaml b/manifests/crds/applicationset-crd.yaml index a84cd5417fa73..89e9a7367a745 100644 --- a/manifests/crds/applicationset-crd.yaml +++ b/manifests/crds/applicationset-crd.yaml @@ -6756,9 +6756,8 @@ spec: type: string message: type: string - observedGeneration: - format: int64 - type: integer + observedHash: + type: string status: type: string required: diff --git a/manifests/ha/install.yaml b/manifests/ha/install.yaml index df39b7db2f12f..a9fa5bdc9c824 100644 --- a/manifests/ha/install.yaml +++ b/manifests/ha/install.yaml @@ -8912,9 +8912,8 @@ spec: type: string message: type: string - observedGeneration: - format: int64 - type: integer + observedHash: + type: string status: type: string required: @@ -10916,6 +10915,12 @@ spec: valueFrom: fieldRef: fieldPath: metadata.namespace + - name: ARGOCD_APPLICATIONSET_ENABLE_PROGRESSIVE_ROLLOUTS + valueFrom: + configMapKeyRef: + key: applicationset.enable.progressive.rollouts + name: argocd-cmd-params-cm + optional: true image: quay.io/argoproj/argocd:latest imagePullPolicy: Always name: argocd-applicationset-controller diff --git a/manifests/ha/namespace-install.yaml b/manifests/ha/namespace-install.yaml index 93c3f88461733..411c0edf3473c 100644 --- a/manifests/ha/namespace-install.yaml +++ b/manifests/ha/namespace-install.yaml @@ -1549,6 +1549,12 @@ spec: valueFrom: fieldRef: fieldPath: metadata.namespace + - name: ARGOCD_APPLICATIONSET_ENABLE_PROGRESSIVE_ROLLOUTS + valueFrom: + configMapKeyRef: + key: applicationset.enable.progressive.rollouts + name: argocd-cmd-params-cm + optional: true image: quay.io/argoproj/argocd:latest imagePullPolicy: Always name: argocd-applicationset-controller diff --git a/manifests/install.yaml b/manifests/install.yaml index 7534ea09b7209..0caee02b9121b 100644 --- a/manifests/install.yaml +++ b/manifests/install.yaml @@ -8912,9 +8912,8 @@ spec: type: string message: type: string - observedGeneration: - format: int64 - type: integer + observedHash: + type: string status: type: string required: @@ -9987,6 +9986,12 @@ spec: valueFrom: fieldRef: fieldPath: metadata.namespace + - name: ARGOCD_APPLICATIONSET_ENABLE_PROGRESSIVE_ROLLOUTS + valueFrom: + configMapKeyRef: + key: applicationset.enable.progressive.rollouts + name: argocd-cmd-params-cm + optional: true image: quay.io/argoproj/argocd:latest imagePullPolicy: Always name: argocd-applicationset-controller diff --git a/manifests/namespace-install.yaml b/manifests/namespace-install.yaml index 13e0b10772ed7..44fe98dbc7498 100644 --- a/manifests/namespace-install.yaml +++ b/manifests/namespace-install.yaml @@ -620,6 +620,12 @@ spec: valueFrom: fieldRef: fieldPath: metadata.namespace + - name: ARGOCD_APPLICATIONSET_ENABLE_PROGRESSIVE_ROLLOUTS + valueFrom: + configMapKeyRef: + key: applicationset.enable.progressive.rollouts + name: argocd-cmd-params-cm + optional: true image: quay.io/argoproj/argocd:latest imagePullPolicy: Always name: argocd-applicationset-controller diff --git a/pkg/apis/applicationset/v1alpha1/applicationset_types.go b/pkg/apis/applicationset/v1alpha1/applicationset_types.go index a2f46403bd827..d6fac02ee5841 100644 --- a/pkg/apis/applicationset/v1alpha1/applicationset_types.go +++ b/pkg/apis/applicationset/v1alpha1/applicationset_types.go @@ -70,7 +70,6 @@ type ApplicationSetRollingUpdateStrategy struct { type ApplicationSetRollingUpdateStep struct { MatchExpressions []ApplicationMatchExpression `json:"matchExpressions,omitempty"` MaxUpdate *intstr.IntOrString `json:"maxUpdate,omitempty" protobuf:"bytes,6,opt,name=maxUpdate"` - // MaxUpdate *int32 `json:"maxUpdate,omitempty" protobuf:"varint,3,opt,name=maxUpdate"` } type ApplicationMatchExpression struct { @@ -575,11 +574,10 @@ type ApplicationSetApplicationStatus struct { LastTransitionTime *metav1.Time `json:"lastTransitionTime,omitempty" protobuf:"bytes,4,opt,name=lastTransitionTime"` // Message contains human-readable message indicating details about the status Message string `json:"message" protobuf:"bytes,3,opt,name=message"` - // ObservedGeneration contains the ApplicationSet generation used to create the current version of the Application resource - ObservedGeneration int64 `json:"observedGeneration,omitempty"` + // ObservedHash contains the last applied hash of the generated Application resource + ObservedHash string `json:"observedHash,omitempty"` // Status contains the AppSet's perceived status of the managed Application resource: (Waiting, Pending, Progressing, Healthy) Status string `json:"status" protobuf:"bytes,3,opt,name=status"` - // Status health.HealthStatusCode `json:"status" protobuf:"bytes,5,opt,name=status"` # not usable because we need custom statuses like "Waiting" and "Pending" } type ApplicationSetReasonType string From 64de0de8d073abad03badea367e63f7387dc58ab Mon Sep 17 00:00:00 2001 From: Matt Groot Date: Tue, 4 Oct 2022 14:04:41 -0500 Subject: [PATCH 3/3] fix --- .../controllers/applicationset_controller.go | 38 +- assets/swagger.json | 106 + pkg/apis/api-rules/violation_exceptions.list | 4 + pkg/apis/application/v1alpha1/generated.pb.go | 3344 ++++++++++++----- pkg/apis/application/v1alpha1/generated.proto | 48 + .../application/v1alpha1/openapi_generated.go | 203 +- .../v1alpha1/zz_generated.deepcopy.go | 126 + 7 files changed, 2846 insertions(+), 1023 deletions(-) diff --git a/applicationset/controllers/applicationset_controller.go b/applicationset/controllers/applicationset_controller.go index 0f06658aeba7f..a2b1362b6bad6 100644 --- a/applicationset/controllers/applicationset_controller.go +++ b/applicationset/controllers/applicationset_controller.go @@ -419,7 +419,7 @@ func (r *ApplicationSetReconciler) setApplicationSetStatusCondition(ctx context. return nil } -func findApplicationStatusIndex(appStatuses []argoprojiov1alpha1.ApplicationSetApplicationStatus, application string) int { +func findApplicationStatusIndex(appStatuses []argov1alpha1.ApplicationSetApplicationStatus, application string) int { for i := range appStatuses { if appStatuses[i].Application == application { return i @@ -428,7 +428,7 @@ func findApplicationStatusIndex(appStatuses []argoprojiov1alpha1.ApplicationSetA return -1 } -func (r *ApplicationSetReconciler) setApplicationSetApplicationStatus(ctx context.Context, applicationSet *argoprojiov1alpha1.ApplicationSet, applicationStatuses []argoprojiov1alpha1.ApplicationSetApplicationStatus) error { +func (r *ApplicationSetReconciler) setApplicationSetApplicationStatus(ctx context.Context, applicationSet *argov1alpha1.ApplicationSet, applicationStatuses []argov1alpha1.ApplicationSetApplicationStatus) error { needToUpdateStatus := false for i := range applicationStatuses { @@ -875,7 +875,7 @@ func hashApplicaton(application argov1alpha1.Application) (string, error) { } // this list tracks which Applications belong to each RollingUpdate step -func (r *ApplicationSetReconciler) buildAppDependencyList(ctx context.Context, applicationSet argoprojiov1alpha1.ApplicationSet, applications []argov1alpha1.Application) ([][]string, map[string]int, error) { +func (r *ApplicationSetReconciler) buildAppDependencyList(ctx context.Context, applicationSet argov1alpha1.ApplicationSet, applications []argov1alpha1.Application) ([][]string, map[string]int, error) { if applicationSet.Spec.Strategy == nil || applicationSet.Spec.Strategy.RollingUpdate == nil { return [][]string{}, map[string]int{}, nil @@ -938,7 +938,7 @@ func (r *ApplicationSetReconciler) buildAppDependencyList(ctx context.Context, a } // this map is used to determine which stage of Applications are ready to be updated in the reconciler loop -func (r *ApplicationSetReconciler) buildAppSyncMap(ctx context.Context, applicationSet argoprojiov1alpha1.ApplicationSet, appDependencyList [][]string, appHashMap map[string]string) (map[string]bool, error) { +func (r *ApplicationSetReconciler) buildAppSyncMap(ctx context.Context, applicationSet argov1alpha1.ApplicationSet, appDependencyList [][]string, appHashMap map[string]string) (map[string]bool, error) { appSyncMap := map[string]bool{} syncEnabled := true @@ -974,10 +974,10 @@ func (r *ApplicationSetReconciler) buildAppSyncMap(ctx context.Context, applicat } // check the status of each Application's status and promote Applications to the next status if needed -func (r *ApplicationSetReconciler) updateApplicationSetApplicationStatus(ctx context.Context, applicationSet *argoprojiov1alpha1.ApplicationSet, applications []argov1alpha1.Application, appHashMap map[string]string) ([]argoprojiov1alpha1.ApplicationSetApplicationStatus, error) { +func (r *ApplicationSetReconciler) updateApplicationSetApplicationStatus(ctx context.Context, applicationSet *argov1alpha1.ApplicationSet, applications []argov1alpha1.Application, appHashMap map[string]string) ([]argov1alpha1.ApplicationSetApplicationStatus, error) { now := metav1.Now() - appStatuses := make([]argoprojiov1alpha1.ApplicationSetApplicationStatus, 0, len(applications)) + appStatuses := make([]argov1alpha1.ApplicationSetApplicationStatus, 0, len(applications)) for _, app := range applications { @@ -986,7 +986,7 @@ func (r *ApplicationSetReconciler) updateApplicationSetApplicationStatus(ctx con if idx == -1 { // AppStatus not found, set default status of "Waiting" - appStatuses = append(appStatuses, argoprojiov1alpha1.ApplicationSetApplicationStatus{ + appStatuses = append(appStatuses, argov1alpha1.ApplicationSetApplicationStatus{ Application: app.Name, LastTransitionTime: &now, Message: "No Application status found, defaulting status to Waiting.", @@ -1044,10 +1044,10 @@ func (r *ApplicationSetReconciler) updateApplicationSetApplicationStatus(ctx con } // check Applications that are in Waiting status and promote them to Pending if needed -func (r *ApplicationSetReconciler) updateApplicationSetApplicationStatusProgress(ctx context.Context, applicationSet *argoprojiov1alpha1.ApplicationSet, appSyncMap map[string]bool, appStepMap map[string]int, appHashMap map[string]string) ([]argoprojiov1alpha1.ApplicationSetApplicationStatus, error) { +func (r *ApplicationSetReconciler) updateApplicationSetApplicationStatusProgress(ctx context.Context, applicationSet *argov1alpha1.ApplicationSet, appSyncMap map[string]bool, appStepMap map[string]int, appHashMap map[string]string) ([]argov1alpha1.ApplicationSetApplicationStatus, error) { now := metav1.Now() - appStatuses := make([]argoprojiov1alpha1.ApplicationSetApplicationStatus, 0, len(applicationSet.Status.ApplicationStatus)) + appStatuses := make([]argov1alpha1.ApplicationSetApplicationStatus, 0, len(applicationSet.Status.ApplicationStatus)) // if we have no RollingUpdate steps, clear out the existing ApplicationStatus entries if applicationSet.Spec.Strategy != nil && applicationSet.Spec.Strategy.RollingUpdate != nil { @@ -1112,7 +1112,7 @@ func (r *ApplicationSetReconciler) updateApplicationSetApplicationStatusProgress return appStatuses, nil } -func (r *ApplicationSetReconciler) updateApplicationSetApplicationStatusConditions(ctx context.Context, applicationSet *argoprojiov1alpha1.ApplicationSet) ([]argoprojiov1alpha1.ApplicationSetCondition, error) { +func (r *ApplicationSetReconciler) updateApplicationSetApplicationStatusConditions(ctx context.Context, applicationSet *argov1alpha1.ApplicationSet) ([]argov1alpha1.ApplicationSetCondition, error) { appSetProgressing := false for _, appStatus := range applicationSet.Status.ApplicationStatus { @@ -1124,7 +1124,7 @@ func (r *ApplicationSetReconciler) updateApplicationSetApplicationStatusConditio appSetConditionProgressing := false for _, appSetCondition := range applicationSet.Status.Conditions { - if appSetCondition.Type == argoprojiov1alpha1.ApplicationSetConditionRolloutProgressing && appSetCondition.Status == argoprojiov1alpha1.ApplicationSetConditionStatusTrue { + if appSetCondition.Type == argov1alpha1.ApplicationSetConditionRolloutProgressing && appSetCondition.Status == argov1alpha1.ApplicationSetConditionStatusTrue { appSetConditionProgressing = true break } @@ -1133,21 +1133,21 @@ func (r *ApplicationSetReconciler) updateApplicationSetApplicationStatusConditio if appSetProgressing && !appSetConditionProgressing { _ = r.setApplicationSetStatusCondition(ctx, applicationSet, - argoprojiov1alpha1.ApplicationSetCondition{ - Type: argoprojiov1alpha1.ApplicationSetConditionRolloutProgressing, + argov1alpha1.ApplicationSetCondition{ + Type: argov1alpha1.ApplicationSetConditionRolloutProgressing, Message: "ApplicationSet Rollout Rollout started", - Reason: argoprojiov1alpha1.ApplicationSetReasonApplicationSetModified, - Status: argoprojiov1alpha1.ApplicationSetConditionStatusTrue, + Reason: argov1alpha1.ApplicationSetReasonApplicationSetModified, + Status: argov1alpha1.ApplicationSetConditionStatusTrue, }, false, ) } else if !appSetProgressing && appSetConditionProgressing { _ = r.setApplicationSetStatusCondition(ctx, applicationSet, - argoprojiov1alpha1.ApplicationSetCondition{ - Type: argoprojiov1alpha1.ApplicationSetConditionRolloutProgressing, + argov1alpha1.ApplicationSetCondition{ + Type: argov1alpha1.ApplicationSetConditionRolloutProgressing, Message: "ApplicationSet Rollout Rollout complete", - Reason: argoprojiov1alpha1.ApplicationSetReasonApplicationSetRolloutComplete, - Status: argoprojiov1alpha1.ApplicationSetConditionStatusFalse, + Reason: argov1alpha1.ApplicationSetReasonApplicationSetRolloutComplete, + Status: argov1alpha1.ApplicationSetConditionStatusFalse, }, false, ) } diff --git a/assets/swagger.json b/assets/swagger.json index 324319e28258c..f634afff2b038 100644 --- a/assets/swagger.json +++ b/assets/swagger.json @@ -4197,6 +4197,24 @@ "type": "object", "title": "Generic (empty) response for GPG public key CRUD requests" }, + "intstrIntOrString": { + "description": "+protobuf=true\n+protobuf.options.(gogoproto.goproto_stringer)=false\n+k8s:openapi-gen=true", + "type": "object", + "title": "IntOrString is a type that can hold an int32 or a string. When used in\nJSON or YAML marshalling and unmarshalling, it produces or consumes the\ninner type. This allows you to have, for example, a JSON field that can\naccept a name or number.\nTODO: Rename to Int32OrString", + "properties": { + "intVal": { + "type": "integer", + "format": "int32" + }, + "strVal": { + "type": "string" + }, + "type": { + "type": "string", + "format": "int64" + } + } + }, "notificationService": { "type": "object", "properties": { @@ -5373,6 +5391,23 @@ } } }, + "v1alpha1ApplicationMatchExpression": { + "type": "object", + "properties": { + "key": { + "type": "string" + }, + "operator": { + "type": "string" + }, + "values": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "v1alpha1ApplicationSet": { "type": "object", "title": "ApplicationSet is a set of Application resources\n+genclient\n+genclient:noStatus\n+k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object\n+kubebuilder:resource:path=applicationsets,shortName=appset;appsets\n+kubebuilder:subresource:status", @@ -5388,6 +5423,31 @@ } } }, + "v1alpha1ApplicationSetApplicationStatus": { + "type": "object", + "title": "ApplicationSetApplicationCondition contains details about each Application managed by the ApplicationSet", + "properties": { + "application": { + "type": "string", + "title": "Application contains the name of the Application resource" + }, + "lastTransitionTime": { + "$ref": "#/definitions/v1Time" + }, + "message": { + "type": "string", + "title": "Message contains human-readable message indicating details about the status" + }, + "observedHash": { + "type": "string", + "title": "ObservedHash contains the last applied hash of the generated Application resource" + }, + "status": { + "type": "string", + "title": "Status contains the AppSet's perceived status of the managed Application resource: (Waiting, Pending, Progressing, Healthy)" + } + } + }, "v1alpha1ApplicationSetCondition": { "type": "object", "title": "ApplicationSetCondition contains details about an applicationset condition, which is usally an error or warning", @@ -5494,6 +5554,31 @@ } } }, + "v1alpha1ApplicationSetRollingUpdateStep": { + "type": "object", + "properties": { + "matchExpressions": { + "type": "array", + "items": { + "$ref": "#/definitions/v1alpha1ApplicationMatchExpression" + } + }, + "maxUpdate": { + "$ref": "#/definitions/intstrIntOrString" + } + } + }, + "v1alpha1ApplicationSetRollingUpdateStrategy": { + "type": "object", + "properties": { + "steps": { + "type": "array", + "items": { + "$ref": "#/definitions/v1alpha1ApplicationSetRollingUpdateStep" + } + } + } + }, "v1alpha1ApplicationSetSpec": { "description": "ApplicationSetSpec represents a class of application set state.", "type": "object", @@ -5507,6 +5592,9 @@ "goTemplate": { "type": "boolean" }, + "strategy": { + "$ref": "#/definitions/v1alpha1ApplicationSetStrategy" + }, "syncPolicy": { "$ref": "#/definitions/v1alpha1ApplicationSetSyncPolicy" }, @@ -5519,6 +5607,12 @@ "type": "object", "title": "ApplicationSetStatus defines the observed state of ApplicationSet", "properties": { + "applicationStatus": { + "type": "array", + "items": { + "$ref": "#/definitions/v1alpha1ApplicationSetApplicationStatus" + } + }, "conditions": { "type": "array", "title": "INSERT ADDITIONAL STATUS FIELD - define observed state of cluster\nImportant: Run \"make\" to regenerate code after modifying this file", @@ -5528,6 +5622,18 @@ } } }, + "v1alpha1ApplicationSetStrategy": { + "description": "ApplicationSetStrategy configures how generated Applications are updated in sequence.", + "type": "object", + "properties": { + "rollingUpdate": { + "$ref": "#/definitions/v1alpha1ApplicationSetRollingUpdateStrategy" + }, + "type": { + "type": "string" + } + } + }, "v1alpha1ApplicationSetSyncPolicy": { "description": "ApplicationSetSyncPolicy configures how generated Applications will relate to their\nApplicationSet.", "type": "object", diff --git a/pkg/apis/api-rules/violation_exceptions.list b/pkg/apis/api-rules/violation_exceptions.list index 1f625c07e730b..49732cd284004 100644 --- a/pkg/apis/api-rules/violation_exceptions.list +++ b/pkg/apis/api-rules/violation_exceptions.list @@ -7,7 +7,11 @@ API rule violation: list_type_missing,github.com/argoproj/argo-cd/v2/pkg/apis/ap API rule violation: list_type_missing,github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1,AppProjectSpec,SignatureKeys API rule violation: list_type_missing,github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1,AppProjectSpec,SourceNamespaces API rule violation: list_type_missing,github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1,AppProjectSpec,SourceRepos +API rule violation: list_type_missing,github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1,ApplicationMatchExpression,Values +API rule violation: list_type_missing,github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1,ApplicationSetRollingUpdateStep,MatchExpressions +API rule violation: list_type_missing,github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1,ApplicationSetRollingUpdateStrategy,Steps API rule violation: list_type_missing,github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1,ApplicationSetSpec,Generators +API rule violation: list_type_missing,github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1,ApplicationSetStatus,ApplicationStatus API rule violation: list_type_missing,github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1,ApplicationSetStatus,Conditions API rule violation: list_type_missing,github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1,ApplicationSetTemplateMeta,Finalizers API rule violation: list_type_missing,github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1,ApplicationSourceHelm,FileParameters diff --git a/pkg/apis/application/v1alpha1/generated.pb.go b/pkg/apis/application/v1alpha1/generated.pb.go index 4532e57820249..46ba915230f9c 100644 --- a/pkg/apis/application/v1alpha1/generated.pb.go +++ b/pkg/apis/application/v1alpha1/generated.pb.go @@ -23,6 +23,7 @@ import ( reflect "reflect" strings "strings" + intstr "k8s.io/apimachinery/pkg/util/intstr" k8s_io_apimachinery_pkg_watch "k8s.io/apimachinery/pkg/watch" ) @@ -289,10 +290,38 @@ func (m *ApplicationList) XXX_DiscardUnknown() { var xxx_messageInfo_ApplicationList proto.InternalMessageInfo +func (m *ApplicationMatchExpression) Reset() { *m = ApplicationMatchExpression{} } +func (*ApplicationMatchExpression) ProtoMessage() {} +func (*ApplicationMatchExpression) Descriptor() ([]byte, []int) { + return fileDescriptor_030104ce3b95bcac, []int{9} +} +func (m *ApplicationMatchExpression) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ApplicationMatchExpression) 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 *ApplicationMatchExpression) XXX_Merge(src proto.Message) { + xxx_messageInfo_ApplicationMatchExpression.Merge(m, src) +} +func (m *ApplicationMatchExpression) XXX_Size() int { + return m.Size() +} +func (m *ApplicationMatchExpression) XXX_DiscardUnknown() { + xxx_messageInfo_ApplicationMatchExpression.DiscardUnknown(m) +} + +var xxx_messageInfo_ApplicationMatchExpression proto.InternalMessageInfo + func (m *ApplicationSet) Reset() { *m = ApplicationSet{} } func (*ApplicationSet) ProtoMessage() {} func (*ApplicationSet) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{9} + return fileDescriptor_030104ce3b95bcac, []int{10} } func (m *ApplicationSet) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -317,10 +346,38 @@ func (m *ApplicationSet) XXX_DiscardUnknown() { var xxx_messageInfo_ApplicationSet proto.InternalMessageInfo +func (m *ApplicationSetApplicationStatus) Reset() { *m = ApplicationSetApplicationStatus{} } +func (*ApplicationSetApplicationStatus) ProtoMessage() {} +func (*ApplicationSetApplicationStatus) Descriptor() ([]byte, []int) { + return fileDescriptor_030104ce3b95bcac, []int{11} +} +func (m *ApplicationSetApplicationStatus) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ApplicationSetApplicationStatus) 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 *ApplicationSetApplicationStatus) XXX_Merge(src proto.Message) { + xxx_messageInfo_ApplicationSetApplicationStatus.Merge(m, src) +} +func (m *ApplicationSetApplicationStatus) XXX_Size() int { + return m.Size() +} +func (m *ApplicationSetApplicationStatus) XXX_DiscardUnknown() { + xxx_messageInfo_ApplicationSetApplicationStatus.DiscardUnknown(m) +} + +var xxx_messageInfo_ApplicationSetApplicationStatus proto.InternalMessageInfo + func (m *ApplicationSetCondition) Reset() { *m = ApplicationSetCondition{} } func (*ApplicationSetCondition) ProtoMessage() {} func (*ApplicationSetCondition) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{10} + return fileDescriptor_030104ce3b95bcac, []int{12} } func (m *ApplicationSetCondition) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -348,7 +405,7 @@ var xxx_messageInfo_ApplicationSetCondition proto.InternalMessageInfo func (m *ApplicationSetGenerator) Reset() { *m = ApplicationSetGenerator{} } func (*ApplicationSetGenerator) ProtoMessage() {} func (*ApplicationSetGenerator) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{11} + return fileDescriptor_030104ce3b95bcac, []int{13} } func (m *ApplicationSetGenerator) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -376,7 +433,7 @@ var xxx_messageInfo_ApplicationSetGenerator proto.InternalMessageInfo func (m *ApplicationSetList) Reset() { *m = ApplicationSetList{} } func (*ApplicationSetList) ProtoMessage() {} func (*ApplicationSetList) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{12} + return fileDescriptor_030104ce3b95bcac, []int{14} } func (m *ApplicationSetList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -404,7 +461,7 @@ var xxx_messageInfo_ApplicationSetList proto.InternalMessageInfo func (m *ApplicationSetNestedGenerator) Reset() { *m = ApplicationSetNestedGenerator{} } func (*ApplicationSetNestedGenerator) ProtoMessage() {} func (*ApplicationSetNestedGenerator) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{13} + return fileDescriptor_030104ce3b95bcac, []int{15} } func (m *ApplicationSetNestedGenerator) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -429,10 +486,66 @@ func (m *ApplicationSetNestedGenerator) XXX_DiscardUnknown() { var xxx_messageInfo_ApplicationSetNestedGenerator proto.InternalMessageInfo +func (m *ApplicationSetRollingUpdateStep) Reset() { *m = ApplicationSetRollingUpdateStep{} } +func (*ApplicationSetRollingUpdateStep) ProtoMessage() {} +func (*ApplicationSetRollingUpdateStep) Descriptor() ([]byte, []int) { + return fileDescriptor_030104ce3b95bcac, []int{16} +} +func (m *ApplicationSetRollingUpdateStep) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ApplicationSetRollingUpdateStep) 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 *ApplicationSetRollingUpdateStep) XXX_Merge(src proto.Message) { + xxx_messageInfo_ApplicationSetRollingUpdateStep.Merge(m, src) +} +func (m *ApplicationSetRollingUpdateStep) XXX_Size() int { + return m.Size() +} +func (m *ApplicationSetRollingUpdateStep) XXX_DiscardUnknown() { + xxx_messageInfo_ApplicationSetRollingUpdateStep.DiscardUnknown(m) +} + +var xxx_messageInfo_ApplicationSetRollingUpdateStep proto.InternalMessageInfo + +func (m *ApplicationSetRollingUpdateStrategy) Reset() { *m = ApplicationSetRollingUpdateStrategy{} } +func (*ApplicationSetRollingUpdateStrategy) ProtoMessage() {} +func (*ApplicationSetRollingUpdateStrategy) Descriptor() ([]byte, []int) { + return fileDescriptor_030104ce3b95bcac, []int{17} +} +func (m *ApplicationSetRollingUpdateStrategy) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ApplicationSetRollingUpdateStrategy) 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 *ApplicationSetRollingUpdateStrategy) XXX_Merge(src proto.Message) { + xxx_messageInfo_ApplicationSetRollingUpdateStrategy.Merge(m, src) +} +func (m *ApplicationSetRollingUpdateStrategy) XXX_Size() int { + return m.Size() +} +func (m *ApplicationSetRollingUpdateStrategy) XXX_DiscardUnknown() { + xxx_messageInfo_ApplicationSetRollingUpdateStrategy.DiscardUnknown(m) +} + +var xxx_messageInfo_ApplicationSetRollingUpdateStrategy proto.InternalMessageInfo + func (m *ApplicationSetSpec) Reset() { *m = ApplicationSetSpec{} } func (*ApplicationSetSpec) ProtoMessage() {} func (*ApplicationSetSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{14} + return fileDescriptor_030104ce3b95bcac, []int{18} } func (m *ApplicationSetSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -460,7 +573,7 @@ var xxx_messageInfo_ApplicationSetSpec proto.InternalMessageInfo func (m *ApplicationSetStatus) Reset() { *m = ApplicationSetStatus{} } func (*ApplicationSetStatus) ProtoMessage() {} func (*ApplicationSetStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{15} + return fileDescriptor_030104ce3b95bcac, []int{19} } func (m *ApplicationSetStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -485,10 +598,38 @@ func (m *ApplicationSetStatus) XXX_DiscardUnknown() { var xxx_messageInfo_ApplicationSetStatus proto.InternalMessageInfo +func (m *ApplicationSetStrategy) Reset() { *m = ApplicationSetStrategy{} } +func (*ApplicationSetStrategy) ProtoMessage() {} +func (*ApplicationSetStrategy) Descriptor() ([]byte, []int) { + return fileDescriptor_030104ce3b95bcac, []int{20} +} +func (m *ApplicationSetStrategy) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ApplicationSetStrategy) 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 *ApplicationSetStrategy) XXX_Merge(src proto.Message) { + xxx_messageInfo_ApplicationSetStrategy.Merge(m, src) +} +func (m *ApplicationSetStrategy) XXX_Size() int { + return m.Size() +} +func (m *ApplicationSetStrategy) XXX_DiscardUnknown() { + xxx_messageInfo_ApplicationSetStrategy.DiscardUnknown(m) +} + +var xxx_messageInfo_ApplicationSetStrategy proto.InternalMessageInfo + func (m *ApplicationSetSyncPolicy) Reset() { *m = ApplicationSetSyncPolicy{} } func (*ApplicationSetSyncPolicy) ProtoMessage() {} func (*ApplicationSetSyncPolicy) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{16} + return fileDescriptor_030104ce3b95bcac, []int{21} } func (m *ApplicationSetSyncPolicy) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -516,7 +657,7 @@ var xxx_messageInfo_ApplicationSetSyncPolicy proto.InternalMessageInfo func (m *ApplicationSetTemplate) Reset() { *m = ApplicationSetTemplate{} } func (*ApplicationSetTemplate) ProtoMessage() {} func (*ApplicationSetTemplate) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{17} + return fileDescriptor_030104ce3b95bcac, []int{22} } func (m *ApplicationSetTemplate) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -544,7 +685,7 @@ var xxx_messageInfo_ApplicationSetTemplate proto.InternalMessageInfo func (m *ApplicationSetTemplateMeta) Reset() { *m = ApplicationSetTemplateMeta{} } func (*ApplicationSetTemplateMeta) ProtoMessage() {} func (*ApplicationSetTemplateMeta) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{18} + return fileDescriptor_030104ce3b95bcac, []int{23} } func (m *ApplicationSetTemplateMeta) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -572,7 +713,7 @@ var xxx_messageInfo_ApplicationSetTemplateMeta proto.InternalMessageInfo func (m *ApplicationSetTerminalGenerator) Reset() { *m = ApplicationSetTerminalGenerator{} } func (*ApplicationSetTerminalGenerator) ProtoMessage() {} func (*ApplicationSetTerminalGenerator) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{19} + return fileDescriptor_030104ce3b95bcac, []int{24} } func (m *ApplicationSetTerminalGenerator) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -600,7 +741,7 @@ var xxx_messageInfo_ApplicationSetTerminalGenerator proto.InternalMessageInfo func (m *ApplicationSource) Reset() { *m = ApplicationSource{} } func (*ApplicationSource) ProtoMessage() {} func (*ApplicationSource) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{20} + return fileDescriptor_030104ce3b95bcac, []int{25} } func (m *ApplicationSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -628,7 +769,7 @@ var xxx_messageInfo_ApplicationSource proto.InternalMessageInfo func (m *ApplicationSourceDirectory) Reset() { *m = ApplicationSourceDirectory{} } func (*ApplicationSourceDirectory) ProtoMessage() {} func (*ApplicationSourceDirectory) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{21} + return fileDescriptor_030104ce3b95bcac, []int{26} } func (m *ApplicationSourceDirectory) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -656,7 +797,7 @@ var xxx_messageInfo_ApplicationSourceDirectory proto.InternalMessageInfo func (m *ApplicationSourceHelm) Reset() { *m = ApplicationSourceHelm{} } func (*ApplicationSourceHelm) ProtoMessage() {} func (*ApplicationSourceHelm) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{22} + return fileDescriptor_030104ce3b95bcac, []int{27} } func (m *ApplicationSourceHelm) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -684,7 +825,7 @@ var xxx_messageInfo_ApplicationSourceHelm proto.InternalMessageInfo func (m *ApplicationSourceJsonnet) Reset() { *m = ApplicationSourceJsonnet{} } func (*ApplicationSourceJsonnet) ProtoMessage() {} func (*ApplicationSourceJsonnet) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{23} + return fileDescriptor_030104ce3b95bcac, []int{28} } func (m *ApplicationSourceJsonnet) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -712,7 +853,7 @@ var xxx_messageInfo_ApplicationSourceJsonnet proto.InternalMessageInfo func (m *ApplicationSourceKustomize) Reset() { *m = ApplicationSourceKustomize{} } func (*ApplicationSourceKustomize) ProtoMessage() {} func (*ApplicationSourceKustomize) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{24} + return fileDescriptor_030104ce3b95bcac, []int{29} } func (m *ApplicationSourceKustomize) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -740,7 +881,7 @@ var xxx_messageInfo_ApplicationSourceKustomize proto.InternalMessageInfo func (m *ApplicationSourcePlugin) Reset() { *m = ApplicationSourcePlugin{} } func (*ApplicationSourcePlugin) ProtoMessage() {} func (*ApplicationSourcePlugin) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{25} + return fileDescriptor_030104ce3b95bcac, []int{30} } func (m *ApplicationSourcePlugin) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -768,7 +909,7 @@ var xxx_messageInfo_ApplicationSourcePlugin proto.InternalMessageInfo func (m *ApplicationSpec) Reset() { *m = ApplicationSpec{} } func (*ApplicationSpec) ProtoMessage() {} func (*ApplicationSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{26} + return fileDescriptor_030104ce3b95bcac, []int{31} } func (m *ApplicationSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -796,7 +937,7 @@ var xxx_messageInfo_ApplicationSpec proto.InternalMessageInfo func (m *ApplicationStatus) Reset() { *m = ApplicationStatus{} } func (*ApplicationStatus) ProtoMessage() {} func (*ApplicationStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{27} + return fileDescriptor_030104ce3b95bcac, []int{32} } func (m *ApplicationStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -824,7 +965,7 @@ var xxx_messageInfo_ApplicationStatus proto.InternalMessageInfo func (m *ApplicationSummary) Reset() { *m = ApplicationSummary{} } func (*ApplicationSummary) ProtoMessage() {} func (*ApplicationSummary) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{28} + return fileDescriptor_030104ce3b95bcac, []int{33} } func (m *ApplicationSummary) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -852,7 +993,7 @@ var xxx_messageInfo_ApplicationSummary proto.InternalMessageInfo func (m *ApplicationTree) Reset() { *m = ApplicationTree{} } func (*ApplicationTree) ProtoMessage() {} func (*ApplicationTree) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{29} + return fileDescriptor_030104ce3b95bcac, []int{34} } func (m *ApplicationTree) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -880,7 +1021,7 @@ var xxx_messageInfo_ApplicationTree proto.InternalMessageInfo func (m *ApplicationWatchEvent) Reset() { *m = ApplicationWatchEvent{} } func (*ApplicationWatchEvent) ProtoMessage() {} func (*ApplicationWatchEvent) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{30} + return fileDescriptor_030104ce3b95bcac, []int{35} } func (m *ApplicationWatchEvent) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -908,7 +1049,7 @@ var xxx_messageInfo_ApplicationWatchEvent proto.InternalMessageInfo func (m *Backoff) Reset() { *m = Backoff{} } func (*Backoff) ProtoMessage() {} func (*Backoff) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{31} + return fileDescriptor_030104ce3b95bcac, []int{36} } func (m *Backoff) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -936,7 +1077,7 @@ var xxx_messageInfo_Backoff proto.InternalMessageInfo func (m *BasicAuthBitbucketServer) Reset() { *m = BasicAuthBitbucketServer{} } func (*BasicAuthBitbucketServer) ProtoMessage() {} func (*BasicAuthBitbucketServer) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{32} + return fileDescriptor_030104ce3b95bcac, []int{37} } func (m *BasicAuthBitbucketServer) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -964,7 +1105,7 @@ var xxx_messageInfo_BasicAuthBitbucketServer proto.InternalMessageInfo func (m *Cluster) Reset() { *m = Cluster{} } func (*Cluster) ProtoMessage() {} func (*Cluster) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{33} + return fileDescriptor_030104ce3b95bcac, []int{38} } func (m *Cluster) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -992,7 +1133,7 @@ var xxx_messageInfo_Cluster proto.InternalMessageInfo func (m *ClusterCacheInfo) Reset() { *m = ClusterCacheInfo{} } func (*ClusterCacheInfo) ProtoMessage() {} func (*ClusterCacheInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{34} + return fileDescriptor_030104ce3b95bcac, []int{39} } func (m *ClusterCacheInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1020,7 +1161,7 @@ var xxx_messageInfo_ClusterCacheInfo proto.InternalMessageInfo func (m *ClusterConfig) Reset() { *m = ClusterConfig{} } func (*ClusterConfig) ProtoMessage() {} func (*ClusterConfig) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{35} + return fileDescriptor_030104ce3b95bcac, []int{40} } func (m *ClusterConfig) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1048,7 +1189,7 @@ var xxx_messageInfo_ClusterConfig proto.InternalMessageInfo func (m *ClusterGenerator) Reset() { *m = ClusterGenerator{} } func (*ClusterGenerator) ProtoMessage() {} func (*ClusterGenerator) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{36} + return fileDescriptor_030104ce3b95bcac, []int{41} } func (m *ClusterGenerator) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1076,7 +1217,7 @@ var xxx_messageInfo_ClusterGenerator proto.InternalMessageInfo func (m *ClusterInfo) Reset() { *m = ClusterInfo{} } func (*ClusterInfo) ProtoMessage() {} func (*ClusterInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{37} + return fileDescriptor_030104ce3b95bcac, []int{42} } func (m *ClusterInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1104,7 +1245,7 @@ var xxx_messageInfo_ClusterInfo proto.InternalMessageInfo func (m *ClusterList) Reset() { *m = ClusterList{} } func (*ClusterList) ProtoMessage() {} func (*ClusterList) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{38} + return fileDescriptor_030104ce3b95bcac, []int{43} } func (m *ClusterList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1132,7 +1273,7 @@ var xxx_messageInfo_ClusterList proto.InternalMessageInfo func (m *Command) Reset() { *m = Command{} } func (*Command) ProtoMessage() {} func (*Command) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{39} + return fileDescriptor_030104ce3b95bcac, []int{44} } func (m *Command) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1160,7 +1301,7 @@ var xxx_messageInfo_Command proto.InternalMessageInfo func (m *ComparedTo) Reset() { *m = ComparedTo{} } func (*ComparedTo) ProtoMessage() {} func (*ComparedTo) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{40} + return fileDescriptor_030104ce3b95bcac, []int{45} } func (m *ComparedTo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1188,7 +1329,7 @@ var xxx_messageInfo_ComparedTo proto.InternalMessageInfo func (m *ComponentParameter) Reset() { *m = ComponentParameter{} } func (*ComponentParameter) ProtoMessage() {} func (*ComponentParameter) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{41} + return fileDescriptor_030104ce3b95bcac, []int{46} } func (m *ComponentParameter) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1216,7 +1357,7 @@ var xxx_messageInfo_ComponentParameter proto.InternalMessageInfo func (m *ConfigManagementPlugin) Reset() { *m = ConfigManagementPlugin{} } func (*ConfigManagementPlugin) ProtoMessage() {} func (*ConfigManagementPlugin) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{42} + return fileDescriptor_030104ce3b95bcac, []int{47} } func (m *ConfigManagementPlugin) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1244,7 +1385,7 @@ var xxx_messageInfo_ConfigManagementPlugin proto.InternalMessageInfo func (m *ConnectionState) Reset() { *m = ConnectionState{} } func (*ConnectionState) ProtoMessage() {} func (*ConnectionState) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{43} + return fileDescriptor_030104ce3b95bcac, []int{48} } func (m *ConnectionState) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1272,7 +1413,7 @@ var xxx_messageInfo_ConnectionState proto.InternalMessageInfo func (m *DuckTypeGenerator) Reset() { *m = DuckTypeGenerator{} } func (*DuckTypeGenerator) ProtoMessage() {} func (*DuckTypeGenerator) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{44} + return fileDescriptor_030104ce3b95bcac, []int{49} } func (m *DuckTypeGenerator) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1300,7 +1441,7 @@ var xxx_messageInfo_DuckTypeGenerator proto.InternalMessageInfo func (m *EnvEntry) Reset() { *m = EnvEntry{} } func (*EnvEntry) ProtoMessage() {} func (*EnvEntry) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{45} + return fileDescriptor_030104ce3b95bcac, []int{50} } func (m *EnvEntry) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1328,7 +1469,7 @@ var xxx_messageInfo_EnvEntry proto.InternalMessageInfo func (m *ExecProviderConfig) Reset() { *m = ExecProviderConfig{} } func (*ExecProviderConfig) ProtoMessage() {} func (*ExecProviderConfig) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{46} + return fileDescriptor_030104ce3b95bcac, []int{51} } func (m *ExecProviderConfig) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1356,7 +1497,7 @@ var xxx_messageInfo_ExecProviderConfig proto.InternalMessageInfo func (m *GitDirectoryGeneratorItem) Reset() { *m = GitDirectoryGeneratorItem{} } func (*GitDirectoryGeneratorItem) ProtoMessage() {} func (*GitDirectoryGeneratorItem) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{47} + return fileDescriptor_030104ce3b95bcac, []int{52} } func (m *GitDirectoryGeneratorItem) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1384,7 +1525,7 @@ var xxx_messageInfo_GitDirectoryGeneratorItem proto.InternalMessageInfo func (m *GitFileGeneratorItem) Reset() { *m = GitFileGeneratorItem{} } func (*GitFileGeneratorItem) ProtoMessage() {} func (*GitFileGeneratorItem) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{48} + return fileDescriptor_030104ce3b95bcac, []int{53} } func (m *GitFileGeneratorItem) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1412,7 +1553,7 @@ var xxx_messageInfo_GitFileGeneratorItem proto.InternalMessageInfo func (m *GitGenerator) Reset() { *m = GitGenerator{} } func (*GitGenerator) ProtoMessage() {} func (*GitGenerator) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{49} + return fileDescriptor_030104ce3b95bcac, []int{54} } func (m *GitGenerator) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1440,7 +1581,7 @@ var xxx_messageInfo_GitGenerator proto.InternalMessageInfo func (m *GnuPGPublicKey) Reset() { *m = GnuPGPublicKey{} } func (*GnuPGPublicKey) ProtoMessage() {} func (*GnuPGPublicKey) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{50} + return fileDescriptor_030104ce3b95bcac, []int{55} } func (m *GnuPGPublicKey) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1468,7 +1609,7 @@ var xxx_messageInfo_GnuPGPublicKey proto.InternalMessageInfo func (m *GnuPGPublicKeyList) Reset() { *m = GnuPGPublicKeyList{} } func (*GnuPGPublicKeyList) ProtoMessage() {} func (*GnuPGPublicKeyList) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{51} + return fileDescriptor_030104ce3b95bcac, []int{56} } func (m *GnuPGPublicKeyList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1496,7 +1637,7 @@ var xxx_messageInfo_GnuPGPublicKeyList proto.InternalMessageInfo func (m *HealthStatus) Reset() { *m = HealthStatus{} } func (*HealthStatus) ProtoMessage() {} func (*HealthStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{52} + return fileDescriptor_030104ce3b95bcac, []int{57} } func (m *HealthStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1524,7 +1665,7 @@ var xxx_messageInfo_HealthStatus proto.InternalMessageInfo func (m *HelmFileParameter) Reset() { *m = HelmFileParameter{} } func (*HelmFileParameter) ProtoMessage() {} func (*HelmFileParameter) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{53} + return fileDescriptor_030104ce3b95bcac, []int{58} } func (m *HelmFileParameter) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1552,7 +1693,7 @@ var xxx_messageInfo_HelmFileParameter proto.InternalMessageInfo func (m *HelmOptions) Reset() { *m = HelmOptions{} } func (*HelmOptions) ProtoMessage() {} func (*HelmOptions) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{54} + return fileDescriptor_030104ce3b95bcac, []int{59} } func (m *HelmOptions) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1580,7 +1721,7 @@ var xxx_messageInfo_HelmOptions proto.InternalMessageInfo func (m *HelmParameter) Reset() { *m = HelmParameter{} } func (*HelmParameter) ProtoMessage() {} func (*HelmParameter) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{55} + return fileDescriptor_030104ce3b95bcac, []int{60} } func (m *HelmParameter) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1608,7 +1749,7 @@ var xxx_messageInfo_HelmParameter proto.InternalMessageInfo func (m *HostInfo) Reset() { *m = HostInfo{} } func (*HostInfo) ProtoMessage() {} func (*HostInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{56} + return fileDescriptor_030104ce3b95bcac, []int{61} } func (m *HostInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1636,7 +1777,7 @@ var xxx_messageInfo_HostInfo proto.InternalMessageInfo func (m *HostResourceInfo) Reset() { *m = HostResourceInfo{} } func (*HostResourceInfo) ProtoMessage() {} func (*HostResourceInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{57} + return fileDescriptor_030104ce3b95bcac, []int{62} } func (m *HostResourceInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1664,7 +1805,7 @@ var xxx_messageInfo_HostResourceInfo proto.InternalMessageInfo func (m *Info) Reset() { *m = Info{} } func (*Info) ProtoMessage() {} func (*Info) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{58} + return fileDescriptor_030104ce3b95bcac, []int{63} } func (m *Info) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1692,7 +1833,7 @@ var xxx_messageInfo_Info proto.InternalMessageInfo func (m *InfoItem) Reset() { *m = InfoItem{} } func (*InfoItem) ProtoMessage() {} func (*InfoItem) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{59} + return fileDescriptor_030104ce3b95bcac, []int{64} } func (m *InfoItem) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1720,7 +1861,7 @@ var xxx_messageInfo_InfoItem proto.InternalMessageInfo func (m *JWTToken) Reset() { *m = JWTToken{} } func (*JWTToken) ProtoMessage() {} func (*JWTToken) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{60} + return fileDescriptor_030104ce3b95bcac, []int{65} } func (m *JWTToken) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1748,7 +1889,7 @@ var xxx_messageInfo_JWTToken proto.InternalMessageInfo func (m *JWTTokens) Reset() { *m = JWTTokens{} } func (*JWTTokens) ProtoMessage() {} func (*JWTTokens) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{61} + return fileDescriptor_030104ce3b95bcac, []int{66} } func (m *JWTTokens) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1776,7 +1917,7 @@ var xxx_messageInfo_JWTTokens proto.InternalMessageInfo func (m *JsonnetVar) Reset() { *m = JsonnetVar{} } func (*JsonnetVar) ProtoMessage() {} func (*JsonnetVar) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{62} + return fileDescriptor_030104ce3b95bcac, []int{67} } func (m *JsonnetVar) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1804,7 +1945,7 @@ var xxx_messageInfo_JsonnetVar proto.InternalMessageInfo func (m *KnownTypeField) Reset() { *m = KnownTypeField{} } func (*KnownTypeField) ProtoMessage() {} func (*KnownTypeField) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{63} + return fileDescriptor_030104ce3b95bcac, []int{68} } func (m *KnownTypeField) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1832,7 +1973,7 @@ var xxx_messageInfo_KnownTypeField proto.InternalMessageInfo func (m *KustomizeOptions) Reset() { *m = KustomizeOptions{} } func (*KustomizeOptions) ProtoMessage() {} func (*KustomizeOptions) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{64} + return fileDescriptor_030104ce3b95bcac, []int{69} } func (m *KustomizeOptions) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1860,7 +2001,7 @@ var xxx_messageInfo_KustomizeOptions proto.InternalMessageInfo func (m *ListGenerator) Reset() { *m = ListGenerator{} } func (*ListGenerator) ProtoMessage() {} func (*ListGenerator) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{65} + return fileDescriptor_030104ce3b95bcac, []int{70} } func (m *ListGenerator) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1888,7 +2029,7 @@ var xxx_messageInfo_ListGenerator proto.InternalMessageInfo func (m *MatrixGenerator) Reset() { *m = MatrixGenerator{} } func (*MatrixGenerator) ProtoMessage() {} func (*MatrixGenerator) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{66} + return fileDescriptor_030104ce3b95bcac, []int{71} } func (m *MatrixGenerator) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1916,7 +2057,7 @@ var xxx_messageInfo_MatrixGenerator proto.InternalMessageInfo func (m *MergeGenerator) Reset() { *m = MergeGenerator{} } func (*MergeGenerator) ProtoMessage() {} func (*MergeGenerator) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{67} + return fileDescriptor_030104ce3b95bcac, []int{72} } func (m *MergeGenerator) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1944,7 +2085,7 @@ var xxx_messageInfo_MergeGenerator proto.InternalMessageInfo func (m *NestedMatrixGenerator) Reset() { *m = NestedMatrixGenerator{} } func (*NestedMatrixGenerator) ProtoMessage() {} func (*NestedMatrixGenerator) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{68} + return fileDescriptor_030104ce3b95bcac, []int{73} } func (m *NestedMatrixGenerator) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1972,7 +2113,7 @@ var xxx_messageInfo_NestedMatrixGenerator proto.InternalMessageInfo func (m *NestedMergeGenerator) Reset() { *m = NestedMergeGenerator{} } func (*NestedMergeGenerator) ProtoMessage() {} func (*NestedMergeGenerator) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{69} + return fileDescriptor_030104ce3b95bcac, []int{74} } func (m *NestedMergeGenerator) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2000,7 +2141,7 @@ var xxx_messageInfo_NestedMergeGenerator proto.InternalMessageInfo func (m *Operation) Reset() { *m = Operation{} } func (*Operation) ProtoMessage() {} func (*Operation) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{70} + return fileDescriptor_030104ce3b95bcac, []int{75} } func (m *Operation) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2028,7 +2169,7 @@ var xxx_messageInfo_Operation proto.InternalMessageInfo func (m *OperationInitiator) Reset() { *m = OperationInitiator{} } func (*OperationInitiator) ProtoMessage() {} func (*OperationInitiator) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{71} + return fileDescriptor_030104ce3b95bcac, []int{76} } func (m *OperationInitiator) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2056,7 +2197,7 @@ var xxx_messageInfo_OperationInitiator proto.InternalMessageInfo func (m *OperationState) Reset() { *m = OperationState{} } func (*OperationState) ProtoMessage() {} func (*OperationState) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{72} + return fileDescriptor_030104ce3b95bcac, []int{77} } func (m *OperationState) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2084,7 +2225,7 @@ var xxx_messageInfo_OperationState proto.InternalMessageInfo func (m *OrphanedResourceKey) Reset() { *m = OrphanedResourceKey{} } func (*OrphanedResourceKey) ProtoMessage() {} func (*OrphanedResourceKey) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{73} + return fileDescriptor_030104ce3b95bcac, []int{78} } func (m *OrphanedResourceKey) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2112,7 +2253,7 @@ var xxx_messageInfo_OrphanedResourceKey proto.InternalMessageInfo func (m *OrphanedResourcesMonitorSettings) Reset() { *m = OrphanedResourcesMonitorSettings{} } func (*OrphanedResourcesMonitorSettings) ProtoMessage() {} func (*OrphanedResourcesMonitorSettings) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{74} + return fileDescriptor_030104ce3b95bcac, []int{79} } func (m *OrphanedResourcesMonitorSettings) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2140,7 +2281,7 @@ var xxx_messageInfo_OrphanedResourcesMonitorSettings proto.InternalMessageInfo func (m *OverrideIgnoreDiff) Reset() { *m = OverrideIgnoreDiff{} } func (*OverrideIgnoreDiff) ProtoMessage() {} func (*OverrideIgnoreDiff) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{75} + return fileDescriptor_030104ce3b95bcac, []int{80} } func (m *OverrideIgnoreDiff) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2168,7 +2309,7 @@ var xxx_messageInfo_OverrideIgnoreDiff proto.InternalMessageInfo func (m *ProjectRole) Reset() { *m = ProjectRole{} } func (*ProjectRole) ProtoMessage() {} func (*ProjectRole) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{76} + return fileDescriptor_030104ce3b95bcac, []int{81} } func (m *ProjectRole) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2196,7 +2337,7 @@ var xxx_messageInfo_ProjectRole proto.InternalMessageInfo func (m *PullRequestGenerator) Reset() { *m = PullRequestGenerator{} } func (*PullRequestGenerator) ProtoMessage() {} func (*PullRequestGenerator) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{77} + return fileDescriptor_030104ce3b95bcac, []int{82} } func (m *PullRequestGenerator) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2224,7 +2365,7 @@ var xxx_messageInfo_PullRequestGenerator proto.InternalMessageInfo func (m *PullRequestGeneratorBitbucketServer) Reset() { *m = PullRequestGeneratorBitbucketServer{} } func (*PullRequestGeneratorBitbucketServer) ProtoMessage() {} func (*PullRequestGeneratorBitbucketServer) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{78} + return fileDescriptor_030104ce3b95bcac, []int{83} } func (m *PullRequestGeneratorBitbucketServer) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2252,7 +2393,7 @@ var xxx_messageInfo_PullRequestGeneratorBitbucketServer proto.InternalMessageInf func (m *PullRequestGeneratorFilter) Reset() { *m = PullRequestGeneratorFilter{} } func (*PullRequestGeneratorFilter) ProtoMessage() {} func (*PullRequestGeneratorFilter) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{79} + return fileDescriptor_030104ce3b95bcac, []int{84} } func (m *PullRequestGeneratorFilter) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2280,7 +2421,7 @@ var xxx_messageInfo_PullRequestGeneratorFilter proto.InternalMessageInfo func (m *PullRequestGeneratorGitLab) Reset() { *m = PullRequestGeneratorGitLab{} } func (*PullRequestGeneratorGitLab) ProtoMessage() {} func (*PullRequestGeneratorGitLab) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{80} + return fileDescriptor_030104ce3b95bcac, []int{85} } func (m *PullRequestGeneratorGitLab) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2308,7 +2449,7 @@ var xxx_messageInfo_PullRequestGeneratorGitLab proto.InternalMessageInfo func (m *PullRequestGeneratorGitea) Reset() { *m = PullRequestGeneratorGitea{} } func (*PullRequestGeneratorGitea) ProtoMessage() {} func (*PullRequestGeneratorGitea) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{81} + return fileDescriptor_030104ce3b95bcac, []int{86} } func (m *PullRequestGeneratorGitea) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2336,7 +2477,7 @@ var xxx_messageInfo_PullRequestGeneratorGitea proto.InternalMessageInfo func (m *PullRequestGeneratorGithub) Reset() { *m = PullRequestGeneratorGithub{} } func (*PullRequestGeneratorGithub) ProtoMessage() {} func (*PullRequestGeneratorGithub) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{82} + return fileDescriptor_030104ce3b95bcac, []int{87} } func (m *PullRequestGeneratorGithub) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2364,7 +2505,7 @@ var xxx_messageInfo_PullRequestGeneratorGithub proto.InternalMessageInfo func (m *RepoCreds) Reset() { *m = RepoCreds{} } func (*RepoCreds) ProtoMessage() {} func (*RepoCreds) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{83} + return fileDescriptor_030104ce3b95bcac, []int{88} } func (m *RepoCreds) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2392,7 +2533,7 @@ var xxx_messageInfo_RepoCreds proto.InternalMessageInfo func (m *RepoCredsList) Reset() { *m = RepoCredsList{} } func (*RepoCredsList) ProtoMessage() {} func (*RepoCredsList) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{84} + return fileDescriptor_030104ce3b95bcac, []int{89} } func (m *RepoCredsList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2420,7 +2561,7 @@ var xxx_messageInfo_RepoCredsList proto.InternalMessageInfo func (m *Repository) Reset() { *m = Repository{} } func (*Repository) ProtoMessage() {} func (*Repository) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{85} + return fileDescriptor_030104ce3b95bcac, []int{90} } func (m *Repository) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2448,7 +2589,7 @@ var xxx_messageInfo_Repository proto.InternalMessageInfo func (m *RepositoryCertificate) Reset() { *m = RepositoryCertificate{} } func (*RepositoryCertificate) ProtoMessage() {} func (*RepositoryCertificate) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{86} + return fileDescriptor_030104ce3b95bcac, []int{91} } func (m *RepositoryCertificate) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2476,7 +2617,7 @@ var xxx_messageInfo_RepositoryCertificate proto.InternalMessageInfo func (m *RepositoryCertificateList) Reset() { *m = RepositoryCertificateList{} } func (*RepositoryCertificateList) ProtoMessage() {} func (*RepositoryCertificateList) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{87} + return fileDescriptor_030104ce3b95bcac, []int{92} } func (m *RepositoryCertificateList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2504,7 +2645,7 @@ var xxx_messageInfo_RepositoryCertificateList proto.InternalMessageInfo func (m *RepositoryList) Reset() { *m = RepositoryList{} } func (*RepositoryList) ProtoMessage() {} func (*RepositoryList) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{88} + return fileDescriptor_030104ce3b95bcac, []int{93} } func (m *RepositoryList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2532,7 +2673,7 @@ var xxx_messageInfo_RepositoryList proto.InternalMessageInfo func (m *ResourceAction) Reset() { *m = ResourceAction{} } func (*ResourceAction) ProtoMessage() {} func (*ResourceAction) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{89} + return fileDescriptor_030104ce3b95bcac, []int{94} } func (m *ResourceAction) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2560,7 +2701,7 @@ var xxx_messageInfo_ResourceAction proto.InternalMessageInfo func (m *ResourceActionDefinition) Reset() { *m = ResourceActionDefinition{} } func (*ResourceActionDefinition) ProtoMessage() {} func (*ResourceActionDefinition) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{90} + return fileDescriptor_030104ce3b95bcac, []int{95} } func (m *ResourceActionDefinition) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2588,7 +2729,7 @@ var xxx_messageInfo_ResourceActionDefinition proto.InternalMessageInfo func (m *ResourceActionParam) Reset() { *m = ResourceActionParam{} } func (*ResourceActionParam) ProtoMessage() {} func (*ResourceActionParam) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{91} + return fileDescriptor_030104ce3b95bcac, []int{96} } func (m *ResourceActionParam) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2616,7 +2757,7 @@ var xxx_messageInfo_ResourceActionParam proto.InternalMessageInfo func (m *ResourceActions) Reset() { *m = ResourceActions{} } func (*ResourceActions) ProtoMessage() {} func (*ResourceActions) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{92} + return fileDescriptor_030104ce3b95bcac, []int{97} } func (m *ResourceActions) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2644,7 +2785,7 @@ var xxx_messageInfo_ResourceActions proto.InternalMessageInfo func (m *ResourceDiff) Reset() { *m = ResourceDiff{} } func (*ResourceDiff) ProtoMessage() {} func (*ResourceDiff) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{93} + return fileDescriptor_030104ce3b95bcac, []int{98} } func (m *ResourceDiff) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2672,7 +2813,7 @@ var xxx_messageInfo_ResourceDiff proto.InternalMessageInfo func (m *ResourceIgnoreDifferences) Reset() { *m = ResourceIgnoreDifferences{} } func (*ResourceIgnoreDifferences) ProtoMessage() {} func (*ResourceIgnoreDifferences) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{94} + return fileDescriptor_030104ce3b95bcac, []int{99} } func (m *ResourceIgnoreDifferences) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2700,7 +2841,7 @@ var xxx_messageInfo_ResourceIgnoreDifferences proto.InternalMessageInfo func (m *ResourceNetworkingInfo) Reset() { *m = ResourceNetworkingInfo{} } func (*ResourceNetworkingInfo) ProtoMessage() {} func (*ResourceNetworkingInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{95} + return fileDescriptor_030104ce3b95bcac, []int{100} } func (m *ResourceNetworkingInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2728,7 +2869,7 @@ var xxx_messageInfo_ResourceNetworkingInfo proto.InternalMessageInfo func (m *ResourceNode) Reset() { *m = ResourceNode{} } func (*ResourceNode) ProtoMessage() {} func (*ResourceNode) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{96} + return fileDescriptor_030104ce3b95bcac, []int{101} } func (m *ResourceNode) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2756,7 +2897,7 @@ var xxx_messageInfo_ResourceNode proto.InternalMessageInfo func (m *ResourceOverride) Reset() { *m = ResourceOverride{} } func (*ResourceOverride) ProtoMessage() {} func (*ResourceOverride) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{97} + return fileDescriptor_030104ce3b95bcac, []int{102} } func (m *ResourceOverride) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2784,7 +2925,7 @@ var xxx_messageInfo_ResourceOverride proto.InternalMessageInfo func (m *ResourceRef) Reset() { *m = ResourceRef{} } func (*ResourceRef) ProtoMessage() {} func (*ResourceRef) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{98} + return fileDescriptor_030104ce3b95bcac, []int{103} } func (m *ResourceRef) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2812,7 +2953,7 @@ var xxx_messageInfo_ResourceRef proto.InternalMessageInfo func (m *ResourceResult) Reset() { *m = ResourceResult{} } func (*ResourceResult) ProtoMessage() {} func (*ResourceResult) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{99} + return fileDescriptor_030104ce3b95bcac, []int{104} } func (m *ResourceResult) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2840,7 +2981,7 @@ var xxx_messageInfo_ResourceResult proto.InternalMessageInfo func (m *ResourceStatus) Reset() { *m = ResourceStatus{} } func (*ResourceStatus) ProtoMessage() {} func (*ResourceStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{100} + return fileDescriptor_030104ce3b95bcac, []int{105} } func (m *ResourceStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2868,7 +3009,7 @@ var xxx_messageInfo_ResourceStatus proto.InternalMessageInfo func (m *RetryStrategy) Reset() { *m = RetryStrategy{} } func (*RetryStrategy) ProtoMessage() {} func (*RetryStrategy) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{101} + return fileDescriptor_030104ce3b95bcac, []int{106} } func (m *RetryStrategy) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2896,7 +3037,7 @@ var xxx_messageInfo_RetryStrategy proto.InternalMessageInfo func (m *RevisionHistory) Reset() { *m = RevisionHistory{} } func (*RevisionHistory) ProtoMessage() {} func (*RevisionHistory) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{102} + return fileDescriptor_030104ce3b95bcac, []int{107} } func (m *RevisionHistory) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2924,7 +3065,7 @@ var xxx_messageInfo_RevisionHistory proto.InternalMessageInfo func (m *RevisionMetadata) Reset() { *m = RevisionMetadata{} } func (*RevisionMetadata) ProtoMessage() {} func (*RevisionMetadata) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{103} + return fileDescriptor_030104ce3b95bcac, []int{108} } func (m *RevisionMetadata) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2952,7 +3093,7 @@ var xxx_messageInfo_RevisionMetadata proto.InternalMessageInfo func (m *SCMProviderGenerator) Reset() { *m = SCMProviderGenerator{} } func (*SCMProviderGenerator) ProtoMessage() {} func (*SCMProviderGenerator) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{104} + return fileDescriptor_030104ce3b95bcac, []int{109} } func (m *SCMProviderGenerator) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2980,7 +3121,7 @@ var xxx_messageInfo_SCMProviderGenerator proto.InternalMessageInfo func (m *SCMProviderGeneratorAzureDevOps) Reset() { *m = SCMProviderGeneratorAzureDevOps{} } func (*SCMProviderGeneratorAzureDevOps) ProtoMessage() {} func (*SCMProviderGeneratorAzureDevOps) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{105} + return fileDescriptor_030104ce3b95bcac, []int{110} } func (m *SCMProviderGeneratorAzureDevOps) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3008,7 +3149,7 @@ var xxx_messageInfo_SCMProviderGeneratorAzureDevOps proto.InternalMessageInfo func (m *SCMProviderGeneratorBitbucket) Reset() { *m = SCMProviderGeneratorBitbucket{} } func (*SCMProviderGeneratorBitbucket) ProtoMessage() {} func (*SCMProviderGeneratorBitbucket) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{106} + return fileDescriptor_030104ce3b95bcac, []int{111} } func (m *SCMProviderGeneratorBitbucket) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3036,7 +3177,7 @@ var xxx_messageInfo_SCMProviderGeneratorBitbucket proto.InternalMessageInfo func (m *SCMProviderGeneratorBitbucketServer) Reset() { *m = SCMProviderGeneratorBitbucketServer{} } func (*SCMProviderGeneratorBitbucketServer) ProtoMessage() {} func (*SCMProviderGeneratorBitbucketServer) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{107} + return fileDescriptor_030104ce3b95bcac, []int{112} } func (m *SCMProviderGeneratorBitbucketServer) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3064,7 +3205,7 @@ var xxx_messageInfo_SCMProviderGeneratorBitbucketServer proto.InternalMessageInf func (m *SCMProviderGeneratorFilter) Reset() { *m = SCMProviderGeneratorFilter{} } func (*SCMProviderGeneratorFilter) ProtoMessage() {} func (*SCMProviderGeneratorFilter) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{108} + return fileDescriptor_030104ce3b95bcac, []int{113} } func (m *SCMProviderGeneratorFilter) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3092,7 +3233,7 @@ var xxx_messageInfo_SCMProviderGeneratorFilter proto.InternalMessageInfo func (m *SCMProviderGeneratorGitea) Reset() { *m = SCMProviderGeneratorGitea{} } func (*SCMProviderGeneratorGitea) ProtoMessage() {} func (*SCMProviderGeneratorGitea) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{109} + return fileDescriptor_030104ce3b95bcac, []int{114} } func (m *SCMProviderGeneratorGitea) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3120,7 +3261,7 @@ var xxx_messageInfo_SCMProviderGeneratorGitea proto.InternalMessageInfo func (m *SCMProviderGeneratorGithub) Reset() { *m = SCMProviderGeneratorGithub{} } func (*SCMProviderGeneratorGithub) ProtoMessage() {} func (*SCMProviderGeneratorGithub) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{110} + return fileDescriptor_030104ce3b95bcac, []int{115} } func (m *SCMProviderGeneratorGithub) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3148,7 +3289,7 @@ var xxx_messageInfo_SCMProviderGeneratorGithub proto.InternalMessageInfo func (m *SCMProviderGeneratorGitlab) Reset() { *m = SCMProviderGeneratorGitlab{} } func (*SCMProviderGeneratorGitlab) ProtoMessage() {} func (*SCMProviderGeneratorGitlab) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{111} + return fileDescriptor_030104ce3b95bcac, []int{116} } func (m *SCMProviderGeneratorGitlab) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3176,7 +3317,7 @@ var xxx_messageInfo_SCMProviderGeneratorGitlab proto.InternalMessageInfo func (m *SecretRef) Reset() { *m = SecretRef{} } func (*SecretRef) ProtoMessage() {} func (*SecretRef) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{112} + return fileDescriptor_030104ce3b95bcac, []int{117} } func (m *SecretRef) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3204,7 +3345,7 @@ var xxx_messageInfo_SecretRef proto.InternalMessageInfo func (m *SignatureKey) Reset() { *m = SignatureKey{} } func (*SignatureKey) ProtoMessage() {} func (*SignatureKey) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{113} + return fileDescriptor_030104ce3b95bcac, []int{118} } func (m *SignatureKey) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3232,7 +3373,7 @@ var xxx_messageInfo_SignatureKey proto.InternalMessageInfo func (m *SyncOperation) Reset() { *m = SyncOperation{} } func (*SyncOperation) ProtoMessage() {} func (*SyncOperation) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{114} + return fileDescriptor_030104ce3b95bcac, []int{119} } func (m *SyncOperation) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3260,7 +3401,7 @@ var xxx_messageInfo_SyncOperation proto.InternalMessageInfo func (m *SyncOperationResource) Reset() { *m = SyncOperationResource{} } func (*SyncOperationResource) ProtoMessage() {} func (*SyncOperationResource) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{115} + return fileDescriptor_030104ce3b95bcac, []int{120} } func (m *SyncOperationResource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3288,7 +3429,7 @@ var xxx_messageInfo_SyncOperationResource proto.InternalMessageInfo func (m *SyncOperationResult) Reset() { *m = SyncOperationResult{} } func (*SyncOperationResult) ProtoMessage() {} func (*SyncOperationResult) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{116} + return fileDescriptor_030104ce3b95bcac, []int{121} } func (m *SyncOperationResult) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3316,7 +3457,7 @@ var xxx_messageInfo_SyncOperationResult proto.InternalMessageInfo func (m *SyncPolicy) Reset() { *m = SyncPolicy{} } func (*SyncPolicy) ProtoMessage() {} func (*SyncPolicy) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{117} + return fileDescriptor_030104ce3b95bcac, []int{122} } func (m *SyncPolicy) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3344,7 +3485,7 @@ var xxx_messageInfo_SyncPolicy proto.InternalMessageInfo func (m *SyncPolicyAutomated) Reset() { *m = SyncPolicyAutomated{} } func (*SyncPolicyAutomated) ProtoMessage() {} func (*SyncPolicyAutomated) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{118} + return fileDescriptor_030104ce3b95bcac, []int{123} } func (m *SyncPolicyAutomated) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3372,7 +3513,7 @@ var xxx_messageInfo_SyncPolicyAutomated proto.InternalMessageInfo func (m *SyncStatus) Reset() { *m = SyncStatus{} } func (*SyncStatus) ProtoMessage() {} func (*SyncStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{119} + return fileDescriptor_030104ce3b95bcac, []int{124} } func (m *SyncStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3400,7 +3541,7 @@ var xxx_messageInfo_SyncStatus proto.InternalMessageInfo func (m *SyncStrategy) Reset() { *m = SyncStrategy{} } func (*SyncStrategy) ProtoMessage() {} func (*SyncStrategy) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{120} + return fileDescriptor_030104ce3b95bcac, []int{125} } func (m *SyncStrategy) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3428,7 +3569,7 @@ var xxx_messageInfo_SyncStrategy proto.InternalMessageInfo func (m *SyncStrategyApply) Reset() { *m = SyncStrategyApply{} } func (*SyncStrategyApply) ProtoMessage() {} func (*SyncStrategyApply) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{121} + return fileDescriptor_030104ce3b95bcac, []int{126} } func (m *SyncStrategyApply) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3456,7 +3597,7 @@ var xxx_messageInfo_SyncStrategyApply proto.InternalMessageInfo func (m *SyncStrategyHook) Reset() { *m = SyncStrategyHook{} } func (*SyncStrategyHook) ProtoMessage() {} func (*SyncStrategyHook) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{122} + return fileDescriptor_030104ce3b95bcac, []int{127} } func (m *SyncStrategyHook) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3484,7 +3625,7 @@ var xxx_messageInfo_SyncStrategyHook proto.InternalMessageInfo func (m *SyncWindow) Reset() { *m = SyncWindow{} } func (*SyncWindow) ProtoMessage() {} func (*SyncWindow) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{123} + return fileDescriptor_030104ce3b95bcac, []int{128} } func (m *SyncWindow) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3512,7 +3653,7 @@ var xxx_messageInfo_SyncWindow proto.InternalMessageInfo func (m *TLSClientConfig) Reset() { *m = TLSClientConfig{} } func (*TLSClientConfig) ProtoMessage() {} func (*TLSClientConfig) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{124} + return fileDescriptor_030104ce3b95bcac, []int{129} } func (m *TLSClientConfig) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3548,13 +3689,18 @@ func init() { proto.RegisterType((*ApplicationCondition)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.ApplicationCondition") proto.RegisterType((*ApplicationDestination)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.ApplicationDestination") proto.RegisterType((*ApplicationList)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.ApplicationList") + proto.RegisterType((*ApplicationMatchExpression)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.ApplicationMatchExpression") proto.RegisterType((*ApplicationSet)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.ApplicationSet") + proto.RegisterType((*ApplicationSetApplicationStatus)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.ApplicationSetApplicationStatus") proto.RegisterType((*ApplicationSetCondition)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.ApplicationSetCondition") proto.RegisterType((*ApplicationSetGenerator)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.ApplicationSetGenerator") proto.RegisterType((*ApplicationSetList)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.ApplicationSetList") proto.RegisterType((*ApplicationSetNestedGenerator)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.ApplicationSetNestedGenerator") + proto.RegisterType((*ApplicationSetRollingUpdateStep)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.ApplicationSetRollingUpdateStep") + proto.RegisterType((*ApplicationSetRollingUpdateStrategy)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.ApplicationSetRollingUpdateStrategy") proto.RegisterType((*ApplicationSetSpec)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.ApplicationSetSpec") proto.RegisterType((*ApplicationSetStatus)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.ApplicationSetStatus") + proto.RegisterType((*ApplicationSetStrategy)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.ApplicationSetStrategy") proto.RegisterType((*ApplicationSetSyncPolicy)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.ApplicationSetSyncPolicy") proto.RegisterType((*ApplicationSetTemplate)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.ApplicationSetTemplate") proto.RegisterType((*ApplicationSetTemplateMeta)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.ApplicationSetTemplateMeta") @@ -3682,566 +3828,585 @@ func init() { } var fileDescriptor_030104ce3b95bcac = []byte{ - // 8937 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x7d, 0x6d, 0x6c, 0x1c, 0x49, - 0x76, 0xd8, 0xf6, 0x0c, 0x87, 0x9c, 0x79, 0xfc, 0x90, 0x58, 0x92, 0x76, 0xb9, 0xda, 0x5d, 0x51, - 0xe8, 0x85, 0xef, 0xd6, 0xb9, 0x5d, 0x32, 0x2b, 0xef, 0x5d, 0x36, 0x5e, 0x7b, 0xcf, 0x1c, 0x52, - 0xa2, 0x28, 0xf1, 0x6b, 0x8b, 0x94, 0xe4, 0xdb, 0xf3, 0x7d, 0x34, 0x7b, 0x6a, 0x86, 0x2d, 0xf6, - 0x74, 0x8f, 0xba, 0x7b, 0x28, 0xce, 0xfa, 0xeb, 0xee, 0x6c, 0xc7, 0x17, 0xdc, 0x67, 0x7c, 0x01, - 0x72, 0x06, 0x82, 0xe4, 0x72, 0x36, 0x8c, 0x18, 0xc9, 0x21, 0xc9, 0xaf, 0x7c, 0x21, 0x3f, 0x6c, - 0xe7, 0xc7, 0x05, 0x09, 0x90, 0x03, 0x62, 0xf8, 0x9c, 0x38, 0xa1, 0xef, 0x98, 0x04, 0x4e, 0x0c, - 0xc4, 0x41, 0x1c, 0xff, 0x89, 0x90, 0x1f, 0x46, 0x7d, 0x57, 0xf7, 0xcc, 0x88, 0x33, 0x62, 0x53, - 0x92, 0x0f, 0xfb, 0x6f, 0xe6, 0xbd, 0xd7, 0xef, 0xbd, 0xae, 0xae, 0x7a, 0xf5, 0xaa, 0xde, 0xab, - 0x57, 0xb0, 0xda, 0xf0, 0x92, 0xdd, 0xf6, 0xce, 0x9c, 0x1b, 0x36, 0xe7, 0x9d, 0xa8, 0x11, 0xb6, - 0xa2, 0xf0, 0x2e, 0xfb, 0xf1, 0x9a, 0x5b, 0x9b, 0xdf, 0xbf, 0x32, 0xdf, 0xda, 0x6b, 0xcc, 0x3b, - 0x2d, 0x2f, 0x9e, 0x77, 0x5a, 0x2d, 0xdf, 0x73, 0x9d, 0xc4, 0x0b, 0x83, 0xf9, 0xfd, 0xd7, 0x1d, - 0xbf, 0xb5, 0xeb, 0xbc, 0x3e, 0xdf, 0x20, 0x01, 0x89, 0x9c, 0x84, 0xd4, 0xe6, 0x5a, 0x51, 0x98, - 0x84, 0xe8, 0xc7, 0x34, 0xb7, 0x39, 0xc9, 0x8d, 0xfd, 0xf8, 0x94, 0x5b, 0x9b, 0xdb, 0xbf, 0x32, - 0xd7, 0xda, 0x6b, 0xcc, 0x51, 0x6e, 0x73, 0x06, 0xb7, 0x39, 0xc9, 0xed, 0xe2, 0x6b, 0x86, 0x2e, - 0x8d, 0xb0, 0x11, 0xce, 0x33, 0xa6, 0x3b, 0xed, 0x3a, 0xfb, 0xc7, 0xfe, 0xb0, 0x5f, 0x5c, 0xd8, - 0x45, 0x7b, 0xef, 0xcd, 0x78, 0xce, 0x0b, 0xa9, 0x7a, 0xf3, 0x6e, 0x18, 0x91, 0xf9, 0xfd, 0x2e, - 0x85, 0x2e, 0x5e, 0xd7, 0x34, 0xe4, 0x20, 0x21, 0x41, 0xec, 0x85, 0x41, 0xfc, 0x1a, 0x55, 0x81, - 0x44, 0xfb, 0x24, 0x32, 0x5f, 0xcf, 0x20, 0xe8, 0xc5, 0xe9, 0x0d, 0xcd, 0xa9, 0xe9, 0xb8, 0xbb, - 0x5e, 0x40, 0xa2, 0x8e, 0x7e, 0xbc, 0x49, 0x12, 0xa7, 0xd7, 0x53, 0xf3, 0xfd, 0x9e, 0x8a, 0xda, - 0x41, 0xe2, 0x35, 0x49, 0xd7, 0x03, 0x1f, 0x39, 0xee, 0x81, 0xd8, 0xdd, 0x25, 0x4d, 0x27, 0xfb, - 0x9c, 0x7d, 0x0f, 0x26, 0x17, 0xee, 0x6c, 0x2d, 0xb4, 0x93, 0xdd, 0xc5, 0x30, 0xa8, 0x7b, 0x0d, - 0xf4, 0x61, 0x18, 0x77, 0xfd, 0x76, 0x9c, 0x90, 0x68, 0xdd, 0x69, 0x92, 0x19, 0xeb, 0xb2, 0xf5, - 0x4a, 0xa5, 0x7a, 0xee, 0xdb, 0x87, 0xb3, 0xcf, 0x1c, 0x1d, 0xce, 0x8e, 0x2f, 0x6a, 0x14, 0x36, - 0xe9, 0xd0, 0x0f, 0xc3, 0x58, 0x14, 0xfa, 0x64, 0x01, 0xaf, 0xcf, 0x14, 0xd8, 0x23, 0x67, 0xc4, - 0x23, 0x63, 0x98, 0x83, 0xb1, 0xc4, 0xdb, 0xbf, 0x57, 0x00, 0x58, 0x68, 0xb5, 0x36, 0xa3, 0xf0, - 0x2e, 0x71, 0x13, 0xf4, 0x69, 0x28, 0xd3, 0x56, 0xa8, 0x39, 0x89, 0xc3, 0xa4, 0x8d, 0x5f, 0xf9, - 0xcb, 0x73, 0xfc, 0x65, 0xe6, 0xcc, 0x97, 0xd1, 0x7d, 0x80, 0x52, 0xcf, 0xed, 0xbf, 0x3e, 0xb7, - 0xb1, 0x43, 0x9f, 0x5f, 0x23, 0x89, 0x53, 0x45, 0x42, 0x18, 0x68, 0x18, 0x56, 0x5c, 0x51, 0x00, - 0x23, 0x71, 0x8b, 0xb8, 0x4c, 0xb1, 0xf1, 0x2b, 0xab, 0x73, 0x27, 0xe9, 0x6c, 0x73, 0x5a, 0xf3, - 0xad, 0x16, 0x71, 0xab, 0x13, 0x42, 0xf2, 0x08, 0xfd, 0x87, 0x99, 0x1c, 0xb4, 0x0f, 0xa3, 0x71, - 0xe2, 0x24, 0xed, 0x78, 0xa6, 0xc8, 0x24, 0xae, 0xe7, 0x26, 0x91, 0x71, 0xad, 0x4e, 0x09, 0x99, - 0xa3, 0xfc, 0x3f, 0x16, 0xd2, 0xec, 0xff, 0x62, 0xc1, 0x94, 0x26, 0x5e, 0xf5, 0xe2, 0x04, 0xfd, - 0x54, 0x57, 0xe3, 0xce, 0x0d, 0xd6, 0xb8, 0xf4, 0x69, 0xd6, 0xb4, 0x67, 0x85, 0xb0, 0xb2, 0x84, - 0x18, 0x0d, 0xdb, 0x84, 0x92, 0x97, 0x90, 0x66, 0x3c, 0x53, 0xb8, 0x5c, 0x7c, 0x65, 0xfc, 0xca, - 0xf5, 0xbc, 0xde, 0xb3, 0x3a, 0x29, 0x84, 0x96, 0x56, 0x28, 0x7b, 0xcc, 0xa5, 0xd8, 0xbf, 0x39, - 0x61, 0xbe, 0x1f, 0x6d, 0x70, 0xf4, 0x3a, 0x8c, 0xc7, 0x61, 0x3b, 0x72, 0x09, 0x26, 0xad, 0x30, - 0x9e, 0xb1, 0x2e, 0x17, 0x69, 0xd7, 0xa3, 0x3d, 0x75, 0x4b, 0x83, 0xb1, 0x49, 0x83, 0xbe, 0x6c, - 0xc1, 0x44, 0x8d, 0xc4, 0x89, 0x17, 0x30, 0xf9, 0x52, 0xf9, 0xed, 0x13, 0x2b, 0x2f, 0x81, 0x4b, - 0x9a, 0x79, 0xf5, 0xbc, 0x78, 0x91, 0x09, 0x03, 0x18, 0xe3, 0x94, 0x7c, 0x3a, 0xe2, 0x6a, 0x24, - 0x76, 0x23, 0xaf, 0x45, 0xff, 0xb3, 0x3e, 0x63, 0x8c, 0xb8, 0x25, 0x8d, 0xc2, 0x26, 0x1d, 0x0a, - 0xa0, 0x44, 0x47, 0x54, 0x3c, 0x33, 0xc2, 0xf4, 0x5f, 0x39, 0x99, 0xfe, 0xa2, 0x51, 0xe9, 0x60, - 0xd5, 0xad, 0x4f, 0xff, 0xc5, 0x98, 0x8b, 0x41, 0x5f, 0xb2, 0x60, 0x46, 0x8c, 0x78, 0x4c, 0x78, - 0x83, 0xde, 0xd9, 0xf5, 0x12, 0xe2, 0x7b, 0x71, 0x32, 0x53, 0x62, 0x3a, 0xcc, 0x0f, 0xd6, 0xb7, - 0x96, 0xa3, 0xb0, 0xdd, 0xba, 0xe9, 0x05, 0xb5, 0xea, 0x65, 0x21, 0x69, 0x66, 0xb1, 0x0f, 0x63, - 0xdc, 0x57, 0x24, 0xfa, 0x9a, 0x05, 0x17, 0x03, 0xa7, 0x49, 0xe2, 0x96, 0x43, 0x3f, 0x2d, 0x47, - 0x57, 0x7d, 0xc7, 0xdd, 0x63, 0x1a, 0x8d, 0x3e, 0x9a, 0x46, 0xb6, 0xd0, 0xe8, 0xe2, 0x7a, 0x5f, - 0xd6, 0xf8, 0x21, 0x62, 0xd1, 0xaf, 0x59, 0x30, 0x1d, 0x46, 0xad, 0x5d, 0x27, 0x20, 0x35, 0x89, - 0x8d, 0x67, 0xc6, 0xd8, 0xd0, 0xfb, 0xe4, 0xc9, 0x3e, 0xd1, 0x46, 0x96, 0xed, 0x5a, 0x18, 0x78, - 0x49, 0x18, 0x6d, 0x91, 0x24, 0xf1, 0x82, 0x46, 0x5c, 0xbd, 0x70, 0x74, 0x38, 0x3b, 0xdd, 0x45, - 0x85, 0xbb, 0xf5, 0x41, 0x3f, 0x0d, 0xe3, 0x71, 0x27, 0x70, 0xef, 0x78, 0x41, 0x2d, 0xbc, 0x1f, - 0xcf, 0x94, 0xf3, 0x18, 0xbe, 0x5b, 0x8a, 0xa1, 0x18, 0x80, 0x5a, 0x00, 0x36, 0xa5, 0xf5, 0xfe, - 0x70, 0xba, 0x2b, 0x55, 0xf2, 0xfe, 0x70, 0xba, 0x33, 0x3d, 0x44, 0x2c, 0xfa, 0x65, 0x0b, 0x26, - 0x63, 0xaf, 0x11, 0x38, 0x49, 0x3b, 0x22, 0x37, 0x49, 0x27, 0x9e, 0x01, 0xa6, 0xc8, 0x8d, 0x13, - 0xb6, 0x8a, 0xc1, 0xb2, 0x7a, 0x41, 0xe8, 0x38, 0x69, 0x42, 0x63, 0x9c, 0x96, 0xdb, 0x6b, 0xa0, - 0xe9, 0x6e, 0x3d, 0x9e, 0xef, 0x40, 0xd3, 0x9d, 0xba, 0xaf, 0x48, 0xf4, 0x13, 0x70, 0x96, 0x83, - 0x54, 0xcb, 0xc6, 0x33, 0x13, 0xcc, 0xd0, 0x9e, 0x3f, 0x3a, 0x9c, 0x3d, 0xbb, 0x95, 0xc1, 0xe1, - 0x2e, 0x6a, 0x74, 0x0f, 0x66, 0x5b, 0x24, 0x6a, 0x7a, 0xc9, 0x46, 0xe0, 0x77, 0xa4, 0xf9, 0x76, - 0xc3, 0x16, 0xa9, 0x09, 0x75, 0xe2, 0x99, 0xc9, 0xcb, 0xd6, 0x2b, 0xe5, 0xea, 0x07, 0x85, 0x9a, - 0xb3, 0x9b, 0x0f, 0x27, 0xc7, 0xc7, 0xf1, 0xb3, 0xff, 0x4d, 0x01, 0xce, 0x66, 0x27, 0x4e, 0xf4, - 0x1b, 0x16, 0x9c, 0xb9, 0x7b, 0x3f, 0xd9, 0x0e, 0xf7, 0x48, 0x10, 0x57, 0x3b, 0xd4, 0xbc, 0xb1, - 0x29, 0x63, 0xfc, 0x8a, 0x9b, 0xef, 0x14, 0x3d, 0x77, 0x23, 0x2d, 0xe5, 0x6a, 0x90, 0x44, 0x9d, - 0xea, 0x73, 0xe2, 0xed, 0xce, 0xdc, 0xb8, 0xb3, 0x6d, 0x62, 0x71, 0x56, 0xa9, 0x8b, 0x5f, 0xb0, - 0xe0, 0x7c, 0x2f, 0x16, 0xe8, 0x2c, 0x14, 0xf7, 0x48, 0x87, 0x7b, 0x65, 0x98, 0xfe, 0x44, 0x9f, - 0x80, 0xd2, 0xbe, 0xe3, 0xb7, 0x89, 0xf0, 0x6e, 0x96, 0x4f, 0xf6, 0x22, 0x4a, 0x33, 0xcc, 0xb9, - 0xfe, 0x68, 0xe1, 0x4d, 0xcb, 0xfe, 0xf7, 0x45, 0x18, 0x37, 0xe6, 0xb7, 0xc7, 0xe0, 0xb1, 0x85, - 0x29, 0x8f, 0x6d, 0x2d, 0xb7, 0xa9, 0xb9, 0xaf, 0xcb, 0x76, 0x3f, 0xe3, 0xb2, 0x6d, 0xe4, 0x27, - 0xf2, 0xa1, 0x3e, 0x1b, 0x4a, 0xa0, 0x12, 0xb6, 0xa8, 0x47, 0x4e, 0xa7, 0xfe, 0x91, 0x3c, 0x3e, - 0xe1, 0x86, 0x64, 0x57, 0x9d, 0x3c, 0x3a, 0x9c, 0xad, 0xa8, 0xbf, 0x58, 0x0b, 0xb2, 0xbf, 0x6b, - 0xc1, 0x79, 0x43, 0xc7, 0xc5, 0x30, 0xa8, 0x79, 0xec, 0xd3, 0x5e, 0x86, 0x91, 0xa4, 0xd3, 0x92, - 0x6e, 0xbf, 0x6a, 0xa9, 0xed, 0x4e, 0x8b, 0x60, 0x86, 0xa1, 0x8e, 0x7e, 0x93, 0xc4, 0xb1, 0xd3, - 0x20, 0x59, 0x47, 0x7f, 0x8d, 0x83, 0xb1, 0xc4, 0xa3, 0x08, 0x90, 0xef, 0xc4, 0xc9, 0x76, 0xe4, - 0x04, 0x31, 0x63, 0xbf, 0xed, 0x35, 0x89, 0x68, 0xe0, 0xbf, 0x34, 0x58, 0x8f, 0xa1, 0x4f, 0x54, - 0x9f, 0x3d, 0x3a, 0x9c, 0x45, 0xab, 0x5d, 0x9c, 0x70, 0x0f, 0xee, 0xf6, 0xd7, 0x2c, 0x78, 0xb6, - 0xb7, 0x2f, 0x86, 0x3e, 0x00, 0xa3, 0x7c, 0xf5, 0x26, 0xde, 0x4e, 0x7f, 0x12, 0x06, 0xc5, 0x02, - 0x8b, 0xe6, 0xa1, 0xa2, 0xe6, 0x09, 0xf1, 0x8e, 0xd3, 0x82, 0xb4, 0xa2, 0x27, 0x17, 0x4d, 0x43, - 0x1b, 0x8d, 0xfe, 0x11, 0x9e, 0x9b, 0x6a, 0x34, 0xb6, 0x48, 0x62, 0x18, 0xfb, 0x0f, 0x2d, 0x38, - 0x63, 0x68, 0xf5, 0x18, 0x5c, 0xf3, 0x20, 0xed, 0x9a, 0xaf, 0xe4, 0xd6, 0x9f, 0xfb, 0xf8, 0xe6, - 0x47, 0x05, 0xe6, 0x9b, 0xab, 0x5e, 0x4f, 0x1e, 0xc7, 0xc2, 0x2e, 0x4a, 0x99, 0x89, 0xcd, 0xfc, - 0xc6, 0x2c, 0xe9, 0xbf, 0xb8, 0x7b, 0x2f, 0x63, 0x29, 0x70, 0xae, 0x52, 0x1f, 0xbe, 0xc0, 0xfb, - 0xe3, 0x02, 0x3c, 0x97, 0x7e, 0x40, 0x8f, 0xdc, 0x8f, 0xa6, 0x46, 0xee, 0x87, 0xcc, 0x91, 0xfb, - 0xe0, 0x70, 0xf6, 0x85, 0x3e, 0x8f, 0xfd, 0x85, 0x19, 0xd8, 0x68, 0x59, 0xb5, 0xfb, 0x08, 0xd3, - 0x6e, 0x3e, 0xdd, 0x46, 0x0f, 0x0e, 0x67, 0x5f, 0xea, 0xf3, 0x8e, 0x19, 0x8b, 0xfb, 0x01, 0x18, - 0x8d, 0x88, 0x13, 0x87, 0xc1, 0x4c, 0x29, 0x6d, 0x06, 0x30, 0x83, 0x62, 0x81, 0xb5, 0xff, 0xb0, - 0x9c, 0x6d, 0xec, 0x65, 0xbe, 0x77, 0x12, 0x46, 0xc8, 0x83, 0x11, 0xe6, 0x8d, 0xf1, 0x6e, 0x7d, - 0xf3, 0x64, 0x5d, 0x80, 0x8e, 0x5e, 0xc5, 0xba, 0x5a, 0xa6, 0x5f, 0x8d, 0x82, 0x30, 0x13, 0x81, - 0x0e, 0xa0, 0xec, 0x4a, 0x27, 0xa9, 0x90, 0xc7, 0x76, 0x82, 0x70, 0x91, 0xb4, 0xc4, 0x09, 0x6a, - 0x42, 0x94, 0x67, 0xa5, 0xa4, 0x21, 0x02, 0xc5, 0x86, 0x97, 0x88, 0xcf, 0x7a, 0x42, 0x37, 0x78, - 0xd9, 0x33, 0x5e, 0x71, 0xec, 0xe8, 0x70, 0xb6, 0xb8, 0xec, 0x25, 0x98, 0xf2, 0x47, 0xbf, 0x64, - 0xc1, 0x78, 0xec, 0x36, 0x37, 0xa3, 0x70, 0xdf, 0xab, 0x91, 0x48, 0x4c, 0x82, 0x27, 0x1c, 0x56, - 0x5b, 0x8b, 0x6b, 0x92, 0xa1, 0x96, 0xcb, 0x97, 0x25, 0x1a, 0x83, 0x4d, 0xb9, 0xd4, 0x39, 0x7c, - 0x4e, 0xbc, 0xfb, 0x12, 0x71, 0xbd, 0x98, 0x4e, 0x99, 0xc2, 0x17, 0x66, 0x3d, 0xe5, 0xc4, 0x4e, - 0xc1, 0x52, 0xdb, 0xdd, 0xa3, 0xe3, 0x4d, 0x2b, 0xf4, 0xc2, 0xd1, 0xe1, 0xec, 0x73, 0x8b, 0xbd, - 0x65, 0xe2, 0x7e, 0xca, 0xb0, 0x06, 0x6b, 0xb5, 0x7d, 0x1f, 0x93, 0x7b, 0x6d, 0xc2, 0x56, 0xba, - 0x39, 0x34, 0xd8, 0xa6, 0x66, 0x98, 0x69, 0x30, 0x03, 0x83, 0x4d, 0xb9, 0xe8, 0x1e, 0x8c, 0x36, - 0x9d, 0x24, 0xf2, 0x0e, 0xc4, 0xf2, 0xf6, 0x84, 0x6e, 0xda, 0x1a, 0xe3, 0xa5, 0x85, 0x03, 0x1d, - 0x93, 0x1c, 0x88, 0x85, 0x20, 0xd4, 0x84, 0x52, 0x93, 0x44, 0x0d, 0x32, 0x53, 0xce, 0x63, 0x2b, - 0x6f, 0x8d, 0xb2, 0xd2, 0x02, 0x2b, 0x74, 0x52, 0x63, 0x30, 0xcc, 0xa5, 0xa0, 0x4f, 0x40, 0x39, - 0x26, 0x3e, 0x71, 0x93, 0x30, 0x9a, 0xa9, 0x30, 0x89, 0x3f, 0x32, 0xe0, 0x14, 0xed, 0xec, 0x10, - 0x7f, 0x4b, 0x3c, 0xca, 0x07, 0x98, 0xfc, 0x87, 0x15, 0x4b, 0xfb, 0xbf, 0x5b, 0x80, 0xd2, 0x16, - 0xe6, 0x31, 0x38, 0x06, 0xf7, 0xd2, 0x8e, 0xc1, 0x6a, 0x9e, 0xd3, 0x57, 0x1f, 0xdf, 0xe0, 0xdb, - 0x65, 0xc8, 0xd8, 0xe6, 0x75, 0x12, 0x27, 0xa4, 0xf6, 0xbe, 0x3d, 0x7d, 0xdf, 0x9e, 0xbe, 0x6f, - 0x4f, 0x95, 0x3d, 0xdd, 0xc9, 0xd8, 0xd3, 0xb7, 0x8d, 0x51, 0xaf, 0x63, 0x4c, 0x9f, 0x52, 0x41, - 0x28, 0x53, 0x03, 0x83, 0x80, 0x5a, 0x82, 0x1b, 0x5b, 0x1b, 0xeb, 0x3d, 0x0d, 0xe8, 0xa7, 0xd2, - 0x06, 0xf4, 0xa4, 0x22, 0x1e, 0xbb, 0xc9, 0x3c, 0x2a, 0x66, 0x4d, 0x26, 0x0b, 0x03, 0x5c, 0x01, - 0x68, 0x84, 0xdb, 0xa4, 0xd9, 0xf2, 0x9d, 0x84, 0xbb, 0xc0, 0x65, 0xbd, 0x74, 0x58, 0x56, 0x18, - 0x6c, 0x50, 0xa1, 0xbf, 0x6e, 0x01, 0x34, 0xe4, 0xa7, 0x91, 0xe6, 0xf0, 0x56, 0x9e, 0xe6, 0x50, - 0x7f, 0x78, 0xad, 0x8b, 0x12, 0x88, 0x0d, 0xe1, 0xe8, 0x73, 0x16, 0x94, 0x13, 0xa9, 0x3e, 0x37, - 0x10, 0xdb, 0x79, 0x6a, 0x22, 0x5f, 0x5a, 0xcf, 0x0c, 0xaa, 0x49, 0x94, 0x5c, 0xf4, 0xd7, 0x2c, - 0x80, 0xb8, 0x13, 0xb8, 0x9b, 0xa1, 0xef, 0xb9, 0x1d, 0x61, 0x37, 0x6e, 0xe7, 0xba, 0xbc, 0x51, - 0xdc, 0xab, 0x53, 0xb4, 0x35, 0xf4, 0x7f, 0x6c, 0x48, 0xb6, 0xbf, 0x99, 0xde, 0x9d, 0x50, 0xeb, - 0x22, 0xf6, 0xc9, 0x5c, 0xe9, 0xd6, 0xc7, 0x62, 0xeb, 0x2e, 0xd7, 0x4f, 0xa6, 0x16, 0x0d, 0xfa, - 0x93, 0x29, 0x50, 0x8c, 0x0d, 0xe1, 0xf6, 0x67, 0x2d, 0x98, 0xe9, 0xf7, 0x76, 0x88, 0xc0, 0x0b, - 0xad, 0x88, 0xb0, 0x31, 0xa4, 0x36, 0xdd, 0x37, 0x82, 0x25, 0xe2, 0x13, 0xb6, 0xcf, 0xc3, 0x3b, - 0xe8, 0xcb, 0x42, 0xc2, 0x0b, 0x9b, 0xfd, 0x49, 0xf1, 0xc3, 0xf8, 0xd8, 0xbf, 0x5e, 0x48, 0x6d, - 0x76, 0x18, 0x1f, 0x1a, 0x7d, 0xdd, 0xea, 0xf2, 0x22, 0x7e, 0xf2, 0x34, 0x7a, 0x14, 0xf3, 0x37, - 0xd4, 0xde, 0x7b, 0x7f, 0x9a, 0x27, 0xb8, 0xb9, 0x67, 0xff, 0xbb, 0x11, 0x78, 0x88, 0x66, 0x6a, - 0xfb, 0xc6, 0xea, 0xb7, 0x7d, 0x33, 0xfc, 0x8e, 0xd0, 0x17, 0x2d, 0x18, 0xf5, 0xa9, 0x41, 0x8b, - 0x67, 0x8a, 0xac, 0x93, 0xd6, 0x4e, 0xab, 0xed, 0xb9, 0xdd, 0x8c, 0xf9, 0x06, 0xb3, 0x5a, 0xca, - 0x72, 0x20, 0x16, 0x3a, 0xa0, 0x6f, 0x58, 0x30, 0xee, 0x04, 0x41, 0x98, 0x88, 0x88, 0x27, 0x8f, - 0x18, 0x7a, 0xa7, 0xa6, 0xd3, 0x82, 0x96, 0xc5, 0x15, 0x53, 0xd1, 0x4c, 0x03, 0x83, 0x4d, 0x95, - 0xd0, 0x1c, 0x40, 0xdd, 0x0b, 0x1c, 0xdf, 0x7b, 0x8f, 0x3a, 0x66, 0x25, 0x16, 0x5e, 0x60, 0x36, - 0xe2, 0x9a, 0x82, 0x62, 0x83, 0xe2, 0xe2, 0x5f, 0x85, 0x71, 0xe3, 0xcd, 0x7b, 0xec, 0x8b, 0x9f, - 0x37, 0xf7, 0xc5, 0x2b, 0xc6, 0x76, 0xf6, 0xc5, 0xb7, 0xe1, 0x6c, 0x56, 0xc1, 0x61, 0x9e, 0xb7, - 0x7f, 0x63, 0x14, 0x66, 0xb3, 0x2f, 0x1f, 0x35, 0xa9, 0x6a, 0xef, 0x3b, 0xb4, 0xef, 0x3b, 0xb4, - 0xef, 0x3b, 0xb4, 0xf2, 0x8f, 0xfd, 0x3b, 0x25, 0x98, 0x36, 0x07, 0x0a, 0xd7, 0xee, 0x87, 0x61, - 0x2c, 0x22, 0xad, 0xf0, 0x16, 0x5e, 0x15, 0x16, 0x57, 0x67, 0x0a, 0x71, 0x30, 0x96, 0x78, 0x6a, - 0x99, 0x5b, 0x4e, 0xb2, 0x2b, 0x4c, 0xae, 0xb2, 0xcc, 0x9b, 0x4e, 0xb2, 0x8b, 0x19, 0x06, 0xbd, - 0x0d, 0x53, 0x89, 0x13, 0x35, 0x48, 0x82, 0xc9, 0x3e, 0x6b, 0x04, 0xb1, 0x3b, 0xf8, 0xac, 0xa0, - 0x9d, 0xda, 0x4e, 0x61, 0x71, 0x86, 0x1a, 0xdd, 0x83, 0x91, 0x5d, 0xe2, 0x37, 0x85, 0xc7, 0xbd, - 0x95, 0x9f, 0x45, 0x64, 0xef, 0x7a, 0x9d, 0xf8, 0x4d, 0x3e, 0x5e, 0xe9, 0x2f, 0xcc, 0x44, 0xd1, - 0xaf, 0x53, 0xd9, 0x6b, 0xc7, 0x49, 0xd8, 0xf4, 0xde, 0x93, 0x7e, 0xf8, 0x4f, 0xe6, 0x2c, 0xf8, - 0xa6, 0xe4, 0xcf, 0x63, 0x40, 0xea, 0x2f, 0xd6, 0x92, 0x99, 0x1e, 0x35, 0x2f, 0x62, 0x7e, 0x75, - 0x67, 0x06, 0x4e, 0x45, 0x8f, 0x25, 0xc9, 0x9f, 0xeb, 0xa1, 0xfe, 0x62, 0x2d, 0x19, 0x75, 0x60, - 0xb4, 0xe5, 0xb7, 0x1b, 0x5e, 0x30, 0x33, 0xce, 0x74, 0xb8, 0x95, 0xb3, 0x0e, 0x9b, 0x8c, 0x39, - 0x5f, 0x0d, 0xf1, 0xdf, 0x58, 0x08, 0x44, 0x2f, 0x43, 0xc9, 0xdd, 0x75, 0xa2, 0x64, 0x66, 0x82, - 0x75, 0x1a, 0xb5, 0x7b, 0xb1, 0x48, 0x81, 0x98, 0xe3, 0xec, 0xbf, 0x57, 0x48, 0x7b, 0x0f, 0xe9, - 0x17, 0xe3, 0xdd, 0xd9, 0x6d, 0x47, 0xb1, 0x5c, 0x77, 0x18, 0xdd, 0x99, 0x81, 0xb1, 0xc4, 0xa3, - 0xcf, 0x5a, 0x30, 0x76, 0x37, 0x0e, 0x83, 0x80, 0x24, 0xc2, 0x52, 0xdf, 0xce, 0xf9, 0x5d, 0x6f, - 0x70, 0xee, 0x5a, 0x07, 0x01, 0xc0, 0x52, 0x2e, 0x55, 0x97, 0x1c, 0xb8, 0x7e, 0xbb, 0x26, 0xc3, - 0x55, 0x8a, 0xf4, 0x2a, 0x07, 0x63, 0x89, 0xa7, 0xa4, 0x5e, 0xc0, 0x49, 0x47, 0xd2, 0xa4, 0x2b, - 0x81, 0x20, 0x15, 0x78, 0xfb, 0x1f, 0x97, 0xe0, 0x42, 0xcf, 0xde, 0x4f, 0xe7, 0x75, 0x36, 0x73, - 0x5e, 0xf3, 0x7c, 0x22, 0xf3, 0xb3, 0xd8, 0xbc, 0x7e, 0x5b, 0x41, 0xb1, 0x41, 0x81, 0x7e, 0x1e, - 0xa0, 0xe5, 0x44, 0x4e, 0x93, 0x88, 0xf9, 0xac, 0x78, 0xf2, 0xe9, 0x93, 0xea, 0xb1, 0x29, 0x79, - 0x6a, 0xbf, 0x5e, 0x81, 0x62, 0x6c, 0x88, 0x44, 0x1f, 0x86, 0xf1, 0x88, 0xf8, 0xc4, 0x89, 0x59, - 0x02, 0x43, 0x36, 0x1b, 0x0b, 0x6b, 0x14, 0x36, 0xe9, 0xd0, 0x07, 0x60, 0x94, 0xbd, 0x85, 0x0c, - 0x4f, 0x28, 0x57, 0x8c, 0xbd, 0x67, 0x8c, 0x05, 0x16, 0x7d, 0xc5, 0x82, 0xa9, 0xba, 0xe7, 0x13, - 0x2d, 0x5d, 0xe4, 0x4e, 0x6d, 0x9c, 0xfc, 0x25, 0xaf, 0x99, 0x7c, 0xb5, 0x09, 0x4c, 0x81, 0x63, - 0x9c, 0x11, 0x4f, 0x3f, 0xf3, 0x3e, 0x89, 0x98, 0xed, 0x1c, 0x4d, 0x7f, 0xe6, 0xdb, 0x1c, 0x8c, - 0x25, 0x1e, 0x2d, 0xc0, 0x99, 0x96, 0x13, 0xc7, 0x8b, 0x11, 0xa9, 0x91, 0x20, 0xf1, 0x1c, 0x9f, - 0x67, 0x36, 0x95, 0x75, 0x66, 0xc3, 0x66, 0x1a, 0x8d, 0xb3, 0xf4, 0xe8, 0x63, 0xf0, 0x9c, 0xd7, - 0x08, 0xc2, 0x88, 0xac, 0x79, 0x71, 0xec, 0x05, 0x0d, 0xdd, 0x0d, 0x98, 0x29, 0x2c, 0x57, 0x67, - 0x05, 0xab, 0xe7, 0x56, 0x7a, 0x93, 0xe1, 0x7e, 0xcf, 0xa3, 0x57, 0xa1, 0x1c, 0xef, 0x79, 0xad, - 0xc5, 0xa8, 0x16, 0xb3, 0xad, 0x87, 0xb2, 0x5e, 0xed, 0x6e, 0x09, 0x38, 0x56, 0x14, 0xf6, 0xaf, - 0x16, 0xd2, 0xeb, 0x37, 0x73, 0xfc, 0xa0, 0x98, 0x8e, 0x92, 0xe4, 0xb6, 0x13, 0xc9, 0x45, 0xe6, - 0x09, 0x73, 0xa3, 0x04, 0xdf, 0xdb, 0x4e, 0x64, 0x8e, 0x37, 0x26, 0x00, 0x4b, 0x49, 0xe8, 0x2e, - 0x8c, 0x24, 0xbe, 0x93, 0x53, 0x32, 0xa5, 0x21, 0x51, 0x47, 0xf1, 0x57, 0x17, 0x62, 0xcc, 0x64, - 0xa0, 0x17, 0xa9, 0x7f, 0xba, 0xc3, 0x57, 0x27, 0x15, 0xe9, 0x52, 0xee, 0xc4, 0x98, 0x41, 0xed, - 0xff, 0x3d, 0xda, 0xc3, 0xe4, 0xa9, 0x49, 0x04, 0x5d, 0x01, 0xa0, 0x4b, 0x9d, 0xcd, 0x88, 0xd4, - 0xbd, 0x03, 0x31, 0x89, 0xab, 0x61, 0xb5, 0xae, 0x30, 0xd8, 0xa0, 0x92, 0xcf, 0x6c, 0xb5, 0xeb, - 0xf4, 0x99, 0x42, 0xf7, 0x33, 0x1c, 0x83, 0x0d, 0x2a, 0xf4, 0x06, 0x8c, 0x7a, 0x4d, 0xa7, 0x41, - 0xa4, 0x9a, 0x2f, 0xd2, 0xf1, 0xb4, 0xc2, 0x20, 0x0f, 0x0e, 0x67, 0xa7, 0x94, 0x42, 0x0c, 0x84, - 0x05, 0x2d, 0xfa, 0x75, 0x0b, 0x26, 0xdc, 0xb0, 0xd9, 0x0c, 0x03, 0xbe, 0x40, 0x10, 0xab, 0x9d, - 0xbb, 0xa7, 0x35, 0xc5, 0xce, 0x2d, 0x1a, 0xc2, 0xf8, 0x72, 0x47, 0x65, 0x7d, 0x9a, 0x28, 0x9c, - 0xd2, 0xca, 0x1c, 0x76, 0xa5, 0x63, 0x86, 0xdd, 0x3f, 0xb3, 0x60, 0x9a, 0x3f, 0x6b, 0xac, 0x5b, - 0x44, 0x82, 0x63, 0x78, 0xca, 0xaf, 0xd5, 0xb5, 0x94, 0x7b, 0x5e, 0xa8, 0x39, 0xdd, 0x85, 0xc7, - 0xdd, 0x4a, 0xa2, 0x65, 0x98, 0xae, 0x87, 0x91, 0x4b, 0xcc, 0x86, 0x10, 0x36, 0x43, 0x31, 0xba, - 0x96, 0x25, 0xc0, 0xdd, 0xcf, 0xa0, 0xdb, 0xf0, 0xac, 0x01, 0x34, 0xdb, 0x81, 0x9b, 0x8d, 0x4b, - 0x82, 0xdb, 0xb3, 0xd7, 0x7a, 0x52, 0xe1, 0x3e, 0x4f, 0x5f, 0xfc, 0x28, 0x4c, 0x77, 0x7d, 0xbf, - 0xa1, 0x56, 0x93, 0x4b, 0xf0, 0x6c, 0xef, 0x96, 0x1a, 0x6a, 0x4d, 0xf9, 0x77, 0xac, 0x74, 0xb0, - 0xd9, 0xf0, 0x5c, 0x06, 0xd8, 0x9f, 0x70, 0xa0, 0x48, 0x82, 0x7d, 0x61, 0x38, 0xae, 0x9d, 0xac, - 0x47, 0x5c, 0x0d, 0xf6, 0xf9, 0x87, 0x66, 0x8b, 0xb0, 0xab, 0xc1, 0x3e, 0xa6, 0xbc, 0xed, 0xbf, - 0x39, 0x9a, 0xca, 0x60, 0xd9, 0x92, 0x49, 0x53, 0x7c, 0xf9, 0x63, 0xe5, 0x9d, 0x34, 0xc5, 0x53, - 0x10, 0x75, 0x1e, 0x04, 0x5f, 0xf1, 0x08, 0x71, 0xe8, 0x0b, 0x16, 0x4b, 0x99, 0x96, 0x99, 0x3d, - 0xc2, 0x99, 0x3a, 0x9d, 0x0c, 0x6e, 0x33, 0x11, 0x5b, 0x02, 0xb1, 0x29, 0x9d, 0x8e, 0xe4, 0x16, - 0x4f, 0xfe, 0xcb, 0xba, 0x54, 0x32, 0xa9, 0x5a, 0xe2, 0xd1, 0x41, 0x8f, 0x1d, 0xd6, 0x1c, 0xd2, - 0x6e, 0x8f, 0xdf, 0x53, 0x45, 0xdf, 0xb0, 0x60, 0x9a, 0x4f, 0x9c, 0x4b, 0x5e, 0xbd, 0x4e, 0x22, - 0x12, 0xb8, 0x44, 0xba, 0x1e, 0x77, 0x4e, 0xa6, 0x81, 0x5c, 0x77, 0xae, 0x64, 0xd9, 0xeb, 0x21, - 0xde, 0x85, 0xc2, 0xdd, 0xca, 0xa0, 0x1a, 0x8c, 0x78, 0x41, 0x3d, 0x14, 0x86, 0xad, 0x7a, 0x32, - 0xa5, 0x56, 0x82, 0x7a, 0xa8, 0xc7, 0x0a, 0xfd, 0x87, 0x19, 0x77, 0xb4, 0x0a, 0xe7, 0x23, 0xb1, - 0xfa, 0xbb, 0xee, 0xc5, 0xd4, 0x85, 0x5f, 0xf5, 0x9a, 0x5e, 0xc2, 0x8c, 0x52, 0xb1, 0x3a, 0x73, - 0x74, 0x38, 0x7b, 0x1e, 0xf7, 0xc0, 0xe3, 0x9e, 0x4f, 0xd9, 0x7f, 0x56, 0x49, 0x2f, 0x71, 0xf9, - 0x3e, 0xf5, 0xcf, 0x42, 0x25, 0x52, 0xb9, 0xdf, 0x56, 0x1e, 0x71, 0x56, 0xd9, 0xc6, 0x22, 0x41, - 0x48, 0xed, 0x3e, 0xea, 0x2c, 0x6f, 0x2d, 0x91, 0x3a, 0x12, 0xf4, 0xcb, 0x8b, 0x61, 0x91, 0x43, - 0xff, 0x12, 0x52, 0xf5, 0xde, 0x6a, 0x27, 0x70, 0x31, 0x93, 0x81, 0x22, 0x18, 0xdd, 0x25, 0x8e, - 0x9f, 0xec, 0xe6, 0xb3, 0x0d, 0x74, 0x9d, 0xf1, 0xca, 0xa6, 0x41, 0x71, 0x28, 0x16, 0x92, 0xd0, - 0x01, 0x8c, 0xed, 0xf2, 0x8f, 0x20, 0xe6, 0xf6, 0xb5, 0x93, 0x36, 0x6e, 0xea, 0xcb, 0xea, 0xf1, - 0x2b, 0x00, 0x58, 0x8a, 0x63, 0x21, 0x12, 0x23, 0x00, 0xc1, 0x87, 0x4f, 0x7e, 0x19, 0x60, 0x03, - 0x47, 0x1f, 0xd0, 0xa7, 0x61, 0x22, 0x22, 0x6e, 0x18, 0xb8, 0x9e, 0x4f, 0x6a, 0x0b, 0x72, 0x8b, - 0x67, 0x98, 0xdc, 0xab, 0xb3, 0xd4, 0x3f, 0xc1, 0x06, 0x0f, 0x9c, 0xe2, 0x88, 0x3e, 0x6f, 0xc1, - 0x94, 0x4a, 0x18, 0xa5, 0x1f, 0x84, 0x88, 0x4d, 0x92, 0xd5, 0x9c, 0xd2, 0x53, 0x19, 0xcf, 0x2a, - 0xa2, 0x2b, 0x94, 0x34, 0x0c, 0x67, 0xe4, 0xa2, 0x77, 0x01, 0xc2, 0x1d, 0x16, 0x04, 0xa1, 0xaf, - 0x5a, 0x1e, 0xfa, 0x55, 0xa7, 0x78, 0x02, 0xa1, 0xe4, 0x80, 0x0d, 0x6e, 0xe8, 0x26, 0x00, 0x1f, - 0x36, 0xdb, 0x9d, 0x16, 0x61, 0xcb, 0x06, 0x9d, 0x3c, 0x07, 0x5b, 0x0a, 0xf3, 0xe0, 0x70, 0xb6, - 0x7b, 0x81, 0xcb, 0x92, 0xe7, 0x8c, 0xc7, 0xd1, 0x4f, 0xc3, 0x58, 0xdc, 0x6e, 0x36, 0x1d, 0xb5, - 0x9f, 0x92, 0x63, 0x4a, 0x22, 0xe7, 0xab, 0xfb, 0xa6, 0x00, 0x60, 0x29, 0x11, 0xdd, 0xa5, 0x86, - 0x2d, 0x16, 0x2b, 0x6f, 0x36, 0x8a, 0xf8, 0xdc, 0x3c, 0xce, 0xde, 0xe9, 0x23, 0xe2, 0xb9, 0xf3, - 0xb8, 0x07, 0xcd, 0x83, 0xc3, 0xd9, 0x67, 0xd3, 0xf0, 0xd5, 0x90, 0x8b, 0xc5, 0x3d, 0x79, 0xda, - 0x41, 0x3a, 0x0a, 0x2b, 0x34, 0x78, 0x03, 0x26, 0xc8, 0x41, 0x42, 0xa2, 0xc0, 0xf1, 0x6f, 0xe1, - 0x55, 0xb9, 0xda, 0x67, 0x1d, 0xed, 0xaa, 0x01, 0xc7, 0x29, 0x2a, 0x64, 0x2b, 0x2f, 0xbf, 0xc0, - 0xe8, 0x41, 0x7b, 0xf9, 0xd2, 0xa7, 0xb7, 0xff, 0x5f, 0x21, 0xe5, 0x7d, 0x6c, 0x47, 0x84, 0xa0, - 0x10, 0x4a, 0x41, 0x58, 0x53, 0x06, 0xf6, 0x46, 0x3e, 0x06, 0x76, 0x3d, 0xac, 0x19, 0x07, 0xa0, - 0xe8, 0xbf, 0x18, 0x73, 0x39, 0xec, 0x84, 0x88, 0x3c, 0x4a, 0xc3, 0x10, 0xc2, 0xe1, 0xca, 0x53, - 0xb2, 0x3a, 0x21, 0xb2, 0x61, 0x0a, 0xc2, 0x69, 0xb9, 0x68, 0x0f, 0x4a, 0xbb, 0x61, 0x9c, 0xc8, - 0xe0, 0xd2, 0x09, 0x3d, 0xbe, 0xeb, 0x61, 0x9c, 0xb0, 0xe9, 0x52, 0xbd, 0x36, 0x85, 0xc4, 0x98, - 0xcb, 0xb0, 0xff, 0xc8, 0x4a, 0xed, 0xed, 0xdc, 0x71, 0x12, 0x77, 0xf7, 0xea, 0x3e, 0x09, 0xe8, - 0xd8, 0x31, 0x53, 0x4e, 0xff, 0x4a, 0x26, 0xe5, 0xf4, 0x83, 0xfd, 0x4e, 0xa4, 0xde, 0xa7, 0x1c, - 0xe6, 0x18, 0x0b, 0x23, 0xfd, 0xf4, 0x33, 0x16, 0x8c, 0x1b, 0xea, 0x89, 0xc9, 0x2b, 0xc7, 0xbc, - 0x65, 0x1d, 0x83, 0xd2, 0x40, 0x6c, 0x8a, 0xb4, 0x7f, 0xc5, 0x82, 0xb1, 0xaa, 0xe3, 0xee, 0x85, - 0xf5, 0x3a, 0x7a, 0x15, 0xca, 0xb5, 0xb6, 0x48, 0xcb, 0xe7, 0xef, 0xa7, 0x36, 0x13, 0x96, 0x04, - 0x1c, 0x2b, 0x0a, 0xda, 0x87, 0xeb, 0x0e, 0xcb, 0x79, 0x28, 0x30, 0x37, 0x82, 0xf5, 0xe1, 0x6b, - 0x0c, 0x82, 0x05, 0x06, 0x7d, 0x18, 0xc6, 0x9b, 0xce, 0x81, 0x7c, 0x38, 0xbb, 0xb1, 0xb4, 0xa6, - 0x51, 0xd8, 0xa4, 0xb3, 0xff, 0xb5, 0x05, 0x33, 0x55, 0x27, 0xf6, 0xdc, 0x85, 0x76, 0xb2, 0x5b, - 0xf5, 0x92, 0x9d, 0xb6, 0xbb, 0x47, 0x12, 0x9e, 0xb2, 0x4e, 0xb5, 0x6c, 0xc7, 0x74, 0x28, 0xa9, - 0xe5, 0x81, 0xd2, 0xf2, 0x96, 0x80, 0x63, 0x45, 0x81, 0xde, 0x83, 0xf1, 0x96, 0x13, 0xc7, 0xf7, - 0xc3, 0xa8, 0x86, 0x49, 0x3d, 0x9f, 0x03, 0x23, 0x5b, 0xc4, 0x8d, 0x48, 0x82, 0x49, 0x5d, 0xc4, - 0x02, 0x34, 0x7f, 0x6c, 0x0a, 0xb3, 0x7f, 0xab, 0x02, 0x63, 0x22, 0x90, 0x31, 0x70, 0x22, 0xbe, - 0x5c, 0xf8, 0x14, 0xfa, 0x2e, 0x7c, 0x62, 0x18, 0x75, 0xd9, 0xb1, 0x65, 0xe1, 0x7d, 0xdc, 0xcc, - 0x25, 0xf2, 0xc5, 0x4f, 0x42, 0x6b, 0xb5, 0xf8, 0x7f, 0x2c, 0x44, 0xa1, 0xaf, 0x5a, 0x70, 0xc6, - 0x0d, 0x83, 0x80, 0xb8, 0x7a, 0x6a, 0x1c, 0xc9, 0x23, 0x96, 0xbd, 0x98, 0x66, 0xaa, 0x77, 0xd5, - 0x32, 0x08, 0x9c, 0x15, 0x8f, 0xde, 0x82, 0x49, 0xde, 0x66, 0xb7, 0x53, 0x5b, 0x0a, 0xfa, 0xbc, - 0x99, 0x89, 0xc4, 0x69, 0x5a, 0x34, 0xc7, 0xb7, 0x66, 0xc4, 0xc9, 0xae, 0x51, 0xbd, 0x45, 0x6b, - 0x9c, 0xe9, 0x32, 0x28, 0x50, 0x04, 0x28, 0x22, 0xf5, 0x88, 0xc4, 0xbb, 0x22, 0xd0, 0xc3, 0xa6, - 0xe5, 0xb1, 0x47, 0xcb, 0xfe, 0xc6, 0x5d, 0x9c, 0x70, 0x0f, 0xee, 0x68, 0x4f, 0xac, 0x0d, 0xca, - 0x79, 0x58, 0x05, 0xf1, 0x99, 0xfb, 0x2e, 0x11, 0x66, 0xa1, 0x14, 0xef, 0x3a, 0x51, 0x8d, 0xb9, - 0x03, 0x45, 0x9e, 0xe4, 0xb4, 0x45, 0x01, 0x98, 0xc3, 0xd1, 0x12, 0x9c, 0xcd, 0x9c, 0x96, 0x8b, - 0xd9, 0x84, 0x5f, 0xae, 0xce, 0x08, 0x76, 0x67, 0x33, 0xe7, 0xec, 0x62, 0xdc, 0xf5, 0x84, 0xb9, - 0x6e, 0x1c, 0x3f, 0x66, 0xdd, 0xd8, 0x51, 0xe9, 0x04, 0x13, 0xcc, 0xe2, 0xbf, 0x93, 0x4b, 0x03, - 0x0c, 0x94, 0x3b, 0xf0, 0xa5, 0x4c, 0xee, 0xc0, 0x24, 0x53, 0xe0, 0x76, 0x3e, 0x0a, 0x0c, 0x9f, - 0x28, 0xf0, 0x24, 0x03, 0xff, 0x7f, 0x66, 0x81, 0xfc, 0xae, 0x8b, 0x8e, 0xbb, 0x4b, 0x68, 0x97, - 0x41, 0x6f, 0xc3, 0x94, 0x5a, 0x79, 0x2d, 0x86, 0xed, 0x80, 0xc7, 0xfc, 0x8b, 0x7a, 0xfb, 0x1d, - 0xa7, 0xb0, 0x38, 0x43, 0x8d, 0xe6, 0xa1, 0x42, 0xdb, 0x89, 0x3f, 0xca, 0x67, 0x0f, 0xb5, 0xba, - 0x5b, 0xd8, 0x5c, 0x11, 0x4f, 0x69, 0x1a, 0x14, 0xc2, 0xb4, 0xef, 0xc4, 0x09, 0xd3, 0x80, 0x2e, - 0xc4, 0x1e, 0xf1, 0xec, 0x05, 0x3b, 0x2c, 0xbc, 0x9a, 0x65, 0x84, 0xbb, 0x79, 0xdb, 0xdf, 0x1d, - 0x81, 0xc9, 0x94, 0x65, 0x1c, 0x72, 0xda, 0x79, 0x15, 0xca, 0x72, 0x26, 0x10, 0xa6, 0x5c, 0x51, - 0xab, 0xe9, 0x42, 0x51, 0xd0, 0x69, 0x72, 0x87, 0x38, 0x11, 0x89, 0xd8, 0x39, 0xc4, 0xec, 0x34, - 0x59, 0xd5, 0x28, 0x6c, 0xd2, 0x31, 0xa3, 0x9c, 0xf8, 0xf1, 0xa2, 0xef, 0x91, 0x20, 0xe1, 0x6a, - 0xe6, 0x63, 0x94, 0xb7, 0x57, 0xb7, 0x4c, 0xa6, 0xda, 0x28, 0x67, 0x10, 0x38, 0x2b, 0x1e, 0xfd, - 0xa2, 0x05, 0x93, 0xce, 0xfd, 0x58, 0xd7, 0xd6, 0x10, 0x59, 0x02, 0x27, 0x9c, 0xa4, 0x52, 0xe5, - 0x3a, 0xaa, 0xd3, 0xd4, 0xbc, 0xa7, 0x40, 0x38, 0x2d, 0x14, 0x7d, 0xdd, 0x02, 0x44, 0x0e, 0x88, - 0x2b, 0xf3, 0x18, 0x84, 0x2e, 0xa3, 0x79, 0x2c, 0x50, 0xae, 0x76, 0xf1, 0xe5, 0x56, 0xbd, 0x1b, - 0x8e, 0x7b, 0xe8, 0x60, 0xff, 0x8b, 0xa2, 0x1a, 0x50, 0x3a, 0x75, 0xc6, 0x31, 0x32, 0x48, 0xad, - 0x47, 0xcf, 0x20, 0xd5, 0xb1, 0x9f, 0xae, 0x2c, 0xd2, 0x74, 0xba, 0x65, 0xe1, 0x09, 0xa5, 0x5b, - 0x7e, 0xce, 0x52, 0x21, 0x43, 0xee, 0xc6, 0xbf, 0x9b, 0x6f, 0xda, 0xce, 0x1c, 0x8f, 0x3c, 0x66, - 0xac, 0x7b, 0x3a, 0x1c, 0x49, 0xad, 0xa9, 0x41, 0x36, 0x94, 0x35, 0xfc, 0x4f, 0x45, 0x18, 0x37, - 0x66, 0xd2, 0x9e, 0x6e, 0x91, 0xf5, 0x94, 0xb9, 0x45, 0x85, 0x21, 0xdc, 0xa2, 0x9f, 0x87, 0x8a, - 0x2b, 0xad, 0x7c, 0x3e, 0x85, 0x5c, 0xb2, 0x73, 0x87, 0x36, 0xf4, 0x0a, 0x84, 0xb5, 0x4c, 0xb4, - 0x0c, 0xd3, 0x06, 0x1b, 0x31, 0x43, 0x8c, 0xb0, 0x19, 0x42, 0x6d, 0xac, 0x2e, 0x64, 0x09, 0x70, - 0xf7, 0x33, 0xe8, 0x75, 0xba, 0xb2, 0xf2, 0xc4, 0x7b, 0xc9, 0xe4, 0x3a, 0xe6, 0xae, 0x2f, 0x6c, - 0xae, 0x48, 0x30, 0x36, 0x69, 0xec, 0xef, 0x5a, 0xea, 0xe3, 0x3e, 0x86, 0x33, 0x29, 0x77, 0xd3, - 0x67, 0x52, 0xae, 0xe6, 0xd2, 0xcc, 0x7d, 0x0e, 0xa3, 0xac, 0xc3, 0xd8, 0x62, 0xd8, 0x6c, 0x3a, - 0x41, 0x0d, 0xfd, 0x10, 0x8c, 0xb9, 0xfc, 0xa7, 0xd8, 0xaa, 0x18, 0xa7, 0xce, 0x97, 0xc0, 0x62, - 0x89, 0x43, 0x2f, 0xc2, 0x88, 0x13, 0x35, 0xe4, 0xf6, 0x04, 0x8b, 0x95, 0x2e, 0x44, 0x8d, 0x18, - 0x33, 0xa8, 0xfd, 0xb5, 0x02, 0xc0, 0x62, 0xd8, 0x6c, 0x39, 0x11, 0xa9, 0x6d, 0x87, 0xef, 0xc7, - 0x44, 0xf8, 0xaa, 0xf5, 0x8b, 0x16, 0x20, 0xda, 0x2a, 0x61, 0x40, 0x82, 0x44, 0x25, 0x1b, 0x50, - 0x67, 0xc7, 0x95, 0x50, 0xe1, 0x39, 0xe8, 0x31, 0x20, 0x11, 0x58, 0xd3, 0x0c, 0xb0, 0x04, 0x7c, - 0x59, 0x1a, 0xa8, 0x62, 0x3a, 0x87, 0x87, 0x99, 0x35, 0x61, 0xaf, 0xec, 0xdf, 0x2e, 0xc0, 0xb3, - 0x7c, 0xce, 0x59, 0x73, 0x02, 0xa7, 0x41, 0x9a, 0x54, 0xab, 0x41, 0xa3, 0x6b, 0x2e, 0x5d, 0x7b, - 0x78, 0x32, 0x65, 0xe7, 0xa4, 0x9d, 0x93, 0x77, 0x2a, 0xde, 0x8d, 0x56, 0x02, 0x2f, 0xc1, 0x8c, - 0x39, 0x8a, 0xa1, 0x2c, 0x4b, 0x73, 0x09, 0x63, 0x93, 0x93, 0x20, 0x35, 0xee, 0xc4, 0xc4, 0x40, - 0xb0, 0x12, 0x44, 0x3d, 0x33, 0x3f, 0x74, 0xf7, 0x30, 0x69, 0x85, 0xcc, 0xb0, 0x18, 0x19, 0x13, - 0xab, 0x02, 0x8e, 0x15, 0x85, 0xfd, 0xdb, 0x16, 0x64, 0x4d, 0x2e, 0x5b, 0xca, 0xf3, 0x53, 0xb9, - 0xd9, 0xa5, 0x7c, 0xfa, 0xd0, 0xed, 0x10, 0x87, 0x8b, 0x7f, 0x0a, 0xc6, 0x9d, 0x84, 0xce, 0x92, - 0x7c, 0x5d, 0x59, 0x7c, 0xb4, 0xed, 0xde, 0xb5, 0xb0, 0xe6, 0xd5, 0x3d, 0xb6, 0x9e, 0x34, 0xd9, - 0xd9, 0x7f, 0x3a, 0x02, 0xd3, 0x5d, 0x79, 0x96, 0xe8, 0x4d, 0x98, 0x70, 0x45, 0xf7, 0x68, 0x61, - 0x52, 0x17, 0x2f, 0x63, 0x84, 0xf1, 0x35, 0x0e, 0xa7, 0x28, 0x07, 0xe8, 0xa0, 0x2b, 0x70, 0x2e, - 0xa2, 0x2b, 0xd9, 0x36, 0x59, 0xa8, 0x27, 0x24, 0xda, 0x22, 0x6e, 0x18, 0xd4, 0xf8, 0xe9, 0xf1, - 0x62, 0xf5, 0xb9, 0xa3, 0xc3, 0xd9, 0x73, 0xb8, 0x1b, 0x8d, 0x7b, 0x3d, 0x83, 0x5a, 0x30, 0xe9, - 0x9b, 0x4e, 0x8e, 0xf0, 0x70, 0x1f, 0xc9, 0x3f, 0x52, 0x93, 0x60, 0x0a, 0x8c, 0xd3, 0x02, 0xd2, - 0x9e, 0x52, 0xe9, 0x09, 0x79, 0x4a, 0xbf, 0xa0, 0x3d, 0x25, 0x1e, 0x1b, 0xfc, 0x78, 0xce, 0x79, - 0xb6, 0xa7, 0xed, 0x2a, 0xbd, 0x03, 0x65, 0x19, 0x56, 0x1f, 0xc0, 0xde, 0xbc, 0x9c, 0xe2, 0xd3, - 0xc7, 0xa2, 0x3d, 0x28, 0x40, 0x0f, 0x2f, 0x9b, 0x8e, 0x33, 0x3d, 0xa5, 0xa5, 0xc6, 0xd9, 0x70, - 0xd3, 0x1a, 0x3a, 0xe0, 0x29, 0x05, 0xdc, 0x33, 0xfd, 0x58, 0xde, 0xab, 0x04, 0x9d, 0x65, 0x30, - 0x2e, 0xf4, 0x53, 0x99, 0x06, 0xe8, 0x0a, 0x80, 0xf6, 0x44, 0x44, 0x36, 0x9d, 0x0a, 0x87, 0x69, - 0x87, 0x05, 0x1b, 0x54, 0x74, 0xd1, 0xe8, 0x05, 0x71, 0xe2, 0xf8, 0xfe, 0x75, 0x2f, 0x48, 0xc4, - 0xee, 0x97, 0x9a, 0xa5, 0x56, 0x34, 0x0a, 0x9b, 0x74, 0x17, 0x3f, 0x62, 0x7c, 0x97, 0x61, 0xbe, - 0xe7, 0x2e, 0x3c, 0xbf, 0xec, 0x25, 0x2a, 0x07, 0x54, 0xf5, 0x23, 0xea, 0x68, 0xa8, 0xa4, 0x65, - 0xab, 0x6f, 0xd2, 0xb2, 0x91, 0x83, 0x59, 0x48, 0xa7, 0x8c, 0x66, 0x73, 0x30, 0xed, 0x37, 0xe1, - 0xfc, 0xb2, 0x97, 0x5c, 0xf3, 0x7c, 0x32, 0xa4, 0x10, 0xfb, 0xb7, 0x46, 0x60, 0xc2, 0x4c, 0xaa, - 0x1f, 0x26, 0xef, 0xfa, 0xcb, 0xd4, 0x97, 0x10, 0x6f, 0xe7, 0xa9, 0x38, 0xc7, 0x9d, 0x13, 0x67, - 0xf8, 0xf7, 0x6e, 0x31, 0xc3, 0x9d, 0xd0, 0x32, 0xb1, 0xa9, 0x00, 0xba, 0x0f, 0xa5, 0x3a, 0xcb, - 0x11, 0x2c, 0xe6, 0x11, 0x71, 0xed, 0xd5, 0xa2, 0x7a, 0x98, 0xf1, 0x2c, 0x43, 0x2e, 0x8f, 0xce, - 0x90, 0x51, 0x3a, 0xb3, 0x5c, 0x19, 0x2a, 0x95, 0x53, 0xae, 0x28, 0xfa, 0x99, 0xfa, 0xd2, 0x23, - 0x98, 0xfa, 0x94, 0xe1, 0x1d, 0x7d, 0x32, 0x86, 0xd7, 0xfe, 0x62, 0x01, 0xa6, 0x96, 0x83, 0xf6, - 0xe6, 0xf2, 0x66, 0x7b, 0xc7, 0xf7, 0xdc, 0x9b, 0xa4, 0x43, 0x8d, 0xd3, 0x1e, 0xe9, 0xac, 0x2c, - 0x89, 0x3e, 0xa4, 0x5a, 0xed, 0x26, 0x05, 0x62, 0x8e, 0xa3, 0xc3, 0xb1, 0xee, 0x05, 0x0d, 0x12, - 0xb5, 0x22, 0x4f, 0xec, 0x6a, 0x19, 0xc3, 0xf1, 0x9a, 0x46, 0x61, 0x93, 0x8e, 0xf2, 0x0e, 0xef, - 0x07, 0x24, 0xca, 0xba, 0x72, 0x1b, 0x14, 0x88, 0x39, 0x8e, 0x12, 0x25, 0x51, 0x3b, 0x4e, 0xc4, - 0xe7, 0x50, 0x44, 0xdb, 0x14, 0x88, 0x39, 0x8e, 0xf6, 0xf5, 0xb8, 0xbd, 0xc3, 0x42, 0xba, 0x99, - 0xe4, 0xba, 0x2d, 0x0e, 0xc6, 0x12, 0x4f, 0x49, 0xf7, 0x48, 0x67, 0x89, 0x2e, 0x6c, 0x32, 0xe9, - 0xaf, 0x37, 0x39, 0x18, 0x4b, 0x3c, 0x3b, 0xaf, 0x9f, 0x6e, 0x8e, 0xbf, 0x70, 0xe7, 0xf5, 0xd3, - 0xea, 0xf7, 0x59, 0x22, 0x7d, 0xd3, 0x82, 0x09, 0x33, 0x11, 0x03, 0x35, 0x32, 0x5e, 0xde, 0x46, - 0x57, 0xed, 0x95, 0x1f, 0xef, 0x55, 0x0e, 0xb8, 0xe1, 0x25, 0x61, 0x2b, 0x7e, 0x8d, 0x04, 0x0d, - 0x2f, 0x20, 0x2c, 0xf4, 0xc7, 0x13, 0x38, 0x52, 0x59, 0x1e, 0x8b, 0x61, 0x8d, 0x3c, 0x82, 0x9b, - 0x68, 0xdf, 0x81, 0xe9, 0xae, 0x9c, 0xe7, 0x01, 0x26, 0xd7, 0x63, 0x8f, 0x94, 0xd8, 0x18, 0xc6, - 0x29, 0xe3, 0x8d, 0x16, 0xcf, 0xb4, 0x58, 0x84, 0x69, 0xee, 0x00, 0x50, 0x49, 0x5b, 0xee, 0x2e, - 0x69, 0xaa, 0x3c, 0x76, 0xb6, 0x85, 0x7a, 0x3b, 0x8b, 0xc4, 0xdd, 0xf4, 0xf6, 0x97, 0x2c, 0x98, - 0x4c, 0xa5, 0xa1, 0xe7, 0xe4, 0x06, 0xb0, 0x91, 0x16, 0xb2, 0xbc, 0xa0, 0xc8, 0x0b, 0x78, 0x14, - 0xac, 0x6c, 0x8c, 0x34, 0x8d, 0xc2, 0x26, 0x9d, 0xfd, 0x2b, 0x05, 0x28, 0xcb, 0xb0, 0xef, 0x00, - 0xaa, 0x7c, 0xc1, 0x82, 0x49, 0xb5, 0x6d, 0xcd, 0xf6, 0x43, 0x78, 0x67, 0x5c, 0x3f, 0x79, 0xe0, - 0x59, 0x25, 0x8f, 0x05, 0xf5, 0x50, 0xfb, 0xa4, 0xd8, 0x14, 0x86, 0xd3, 0xb2, 0xd1, 0x6d, 0x80, - 0xb8, 0x13, 0x27, 0xa4, 0x69, 0xec, 0xcc, 0xd8, 0xc6, 0x88, 0x9b, 0x73, 0xc3, 0x88, 0xd0, 0xf1, - 0xb5, 0x1e, 0xd6, 0xc8, 0x96, 0xa2, 0xd4, 0x4e, 0x84, 0x86, 0x61, 0x83, 0x93, 0xfd, 0x8f, 0x0a, - 0x70, 0x36, 0xab, 0x12, 0xfa, 0x38, 0x4c, 0x48, 0xe9, 0x46, 0x3d, 0x64, 0x19, 0xeb, 0x9e, 0xc0, - 0x06, 0xee, 0xc1, 0xe1, 0xec, 0x6c, 0x77, 0x69, 0xe9, 0x39, 0x93, 0x04, 0xa7, 0x98, 0xf1, 0xd8, - 0x81, 0x08, 0x72, 0x55, 0x3b, 0x0b, 0xad, 0x96, 0x08, 0x00, 0x18, 0xb1, 0x03, 0x13, 0x8b, 0x33, - 0xd4, 0x68, 0x13, 0xce, 0x1b, 0x90, 0x75, 0xe2, 0x35, 0x76, 0x77, 0xc2, 0x48, 0xae, 0x2d, 0x5e, - 0xd4, 0x29, 0x1f, 0xdd, 0x34, 0xb8, 0xe7, 0x93, 0x74, 0xbe, 0x73, 0x9d, 0x96, 0xe3, 0x7a, 0x49, - 0x47, 0x6c, 0x35, 0x29, 0xdb, 0xb4, 0x28, 0xe0, 0x58, 0x51, 0xd8, 0x6b, 0x30, 0x32, 0x60, 0x0f, - 0x1a, 0xc8, 0xa7, 0x7d, 0x07, 0xca, 0x94, 0x9d, 0x74, 0x70, 0xf2, 0x60, 0x19, 0x42, 0x59, 0x96, - 0x34, 0x44, 0x36, 0x14, 0x3d, 0x47, 0x86, 0x67, 0xd4, 0x6b, 0xad, 0xc4, 0x71, 0x9b, 0x2d, 0x13, - 0x29, 0x12, 0xbd, 0x0c, 0x45, 0x72, 0xd0, 0xca, 0xc6, 0x61, 0xae, 0x1e, 0xb4, 0xbc, 0x88, 0xc4, - 0x94, 0x88, 0x1c, 0xb4, 0xd0, 0x45, 0x28, 0x78, 0x35, 0x31, 0x49, 0x81, 0xa0, 0x29, 0xac, 0x2c, - 0xe1, 0x82, 0x57, 0xb3, 0x0f, 0xa0, 0xa2, 0x6a, 0x28, 0xa2, 0x3d, 0x69, 0xbb, 0xad, 0x3c, 0xf2, - 0x34, 0x24, 0xdf, 0x3e, 0x56, 0xbb, 0x0d, 0xa0, 0x93, 0xfe, 0xf3, 0xb2, 0x2f, 0x97, 0x61, 0xc4, - 0x0d, 0xc5, 0x59, 0xa1, 0xb2, 0x66, 0xc3, 0x8c, 0x36, 0xc3, 0xd8, 0x77, 0x60, 0xea, 0x66, 0x10, - 0xde, 0x67, 0x95, 0xc4, 0xae, 0x79, 0xc4, 0xaf, 0x51, 0xc6, 0x75, 0xfa, 0x23, 0xeb, 0x22, 0x30, - 0x2c, 0xe6, 0x38, 0x55, 0x68, 0xb0, 0xd0, 0xaf, 0xd0, 0xa0, 0xfd, 0x19, 0x0b, 0xce, 0xaa, 0x6c, - 0x74, 0x69, 0x8d, 0xdf, 0x84, 0x89, 0x9d, 0xb6, 0xe7, 0xd7, 0xc4, 0xff, 0xec, 0x42, 0xbd, 0x6a, - 0xe0, 0x70, 0x8a, 0x92, 0x2e, 0x2b, 0x76, 0xbc, 0xc0, 0x89, 0x3a, 0x9b, 0xda, 0xfc, 0x2b, 0x8b, - 0x50, 0x55, 0x18, 0x6c, 0x50, 0xd9, 0x9f, 0x2b, 0xc0, 0x64, 0xea, 0xf0, 0x2d, 0xf2, 0xa1, 0x4c, - 0x7c, 0xb6, 0x7d, 0x24, 0x3f, 0xea, 0x49, 0x4b, 0x68, 0xa8, 0x8e, 0x78, 0x55, 0xf0, 0xc5, 0x4a, - 0xc2, 0x53, 0x11, 0xa7, 0xb0, 0xff, 0x7e, 0x01, 0xce, 0x64, 0x6a, 0x33, 0xa1, 0xaf, 0xa4, 0x6b, - 0x67, 0x58, 0x79, 0xac, 0xca, 0x1f, 0x5a, 0x21, 0x68, 0xb8, 0x0a, 0x1a, 0x4f, 0xaa, 0xa9, 0x7e, - 0xb7, 0x00, 0x53, 0xe9, 0xa2, 0x52, 0x4f, 0x61, 0x4b, 0x7d, 0x08, 0x2a, 0xac, 0x54, 0x0b, 0xab, - 0x71, 0xcc, 0x17, 0xff, 0xec, 0x70, 0xe6, 0x9a, 0x04, 0x62, 0x8d, 0x7f, 0x2a, 0x0a, 0x93, 0xd8, - 0xff, 0xc0, 0x82, 0x0b, 0xfc, 0x2d, 0xb3, 0xfd, 0xf0, 0x6f, 0xf4, 0x6a, 0xdd, 0x4f, 0xe4, 0xab, - 0x60, 0xe6, 0x68, 0xff, 0x71, 0xed, 0xcb, 0x6a, 0xab, 0x0a, 0x6d, 0xd3, 0x5d, 0xe1, 0x29, 0x54, - 0x76, 0xa8, 0xce, 0x60, 0xff, 0x6e, 0x11, 0x74, 0x39, 0x59, 0xe4, 0x89, 0x2c, 0xf3, 0x5c, 0x4a, - 0x1c, 0x6c, 0x75, 0x02, 0x57, 0x17, 0xae, 0x2d, 0x67, 0x92, 0xcc, 0x7f, 0xd9, 0x82, 0x71, 0x2f, - 0xf0, 0x12, 0xcf, 0x61, 0xee, 0x4a, 0x3e, 0xf5, 0x3e, 0x95, 0xb8, 0x15, 0xce, 0x39, 0x8c, 0xcc, - 0x1d, 0x23, 0x25, 0x0c, 0x9b, 0x92, 0xd1, 0xa7, 0x45, 0x1e, 0x52, 0x31, 0xb7, 0x33, 0x0a, 0xe5, - 0x4c, 0xf2, 0x51, 0x0b, 0x4a, 0x11, 0x49, 0x22, 0x79, 0x3a, 0xe4, 0xe6, 0x49, 0x93, 0x4b, 0x93, - 0xa8, 0xb3, 0x95, 0x44, 0x4e, 0x42, 0x1a, 0xc6, 0x72, 0x8f, 0x81, 0x31, 0x17, 0x64, 0xc7, 0x80, - 0xba, 0xdb, 0x62, 0xc8, 0x1c, 0x8f, 0x79, 0xa8, 0x38, 0xed, 0x24, 0x6c, 0xd2, 0x66, 0x12, 0x9b, - 0x5a, 0x3a, 0x8b, 0x45, 0x22, 0xb0, 0xa6, 0xb1, 0xbf, 0x52, 0x82, 0x4c, 0xda, 0x37, 0x3a, 0x30, - 0x4b, 0x21, 0x5b, 0xf9, 0x96, 0x42, 0x56, 0xca, 0xf4, 0x2a, 0x87, 0x8c, 0x1a, 0x50, 0x6a, 0xed, - 0x3a, 0xb1, 0xf4, 0x46, 0xde, 0x91, 0xcd, 0xb4, 0x49, 0x81, 0x0f, 0x0e, 0x67, 0x7f, 0x62, 0xb0, - 0xd5, 0x2d, 0xed, 0xab, 0xf3, 0xfc, 0x0c, 0x9c, 0x16, 0xcd, 0x78, 0x60, 0xce, 0xdf, 0x5c, 0xdf, - 0x16, 0x8f, 0x09, 0x83, 0x7c, 0x56, 0x54, 0x63, 0xc2, 0x24, 0x6e, 0xfb, 0x89, 0xe8, 0x0d, 0xef, - 0xe4, 0x38, 0xca, 0x38, 0x63, 0x7d, 0x68, 0x88, 0xff, 0xc7, 0x86, 0x50, 0xf4, 0x71, 0xa8, 0xc4, - 0x89, 0x13, 0x25, 0x8f, 0x78, 0xc4, 0x40, 0x35, 0xfa, 0x96, 0x64, 0x82, 0x35, 0x3f, 0xf4, 0x2e, - 0xab, 0xf8, 0xe2, 0xc5, 0xbb, 0x8f, 0x98, 0x3e, 0x28, 0xab, 0xc3, 0x08, 0x0e, 0xd8, 0xe0, 0x46, - 0x9d, 0x3d, 0xd6, 0xb7, 0x79, 0xcc, 0xbc, 0xcc, 0xbc, 0x79, 0x65, 0x0a, 0xb1, 0xc2, 0x60, 0x83, - 0xca, 0xfe, 0x39, 0x38, 0x97, 0xbd, 0x3b, 0x41, 0x6c, 0x78, 0x35, 0xa2, 0xb0, 0xdd, 0xca, 0x7a, - 0xb3, 0xac, 0xb6, 0x3e, 0xe6, 0x38, 0xea, 0xcd, 0xee, 0x79, 0x41, 0x2d, 0xeb, 0xcd, 0xde, 0xf4, - 0x82, 0x1a, 0x66, 0x98, 0x01, 0x6a, 0x44, 0xff, 0x4b, 0x0b, 0x2e, 0x1f, 0x77, 0xc5, 0x03, 0x7a, - 0x11, 0x46, 0xee, 0x3b, 0x91, 0xac, 0x20, 0xc5, 0x6c, 0xc7, 0x1d, 0x27, 0x0a, 0x30, 0x83, 0xa2, - 0x0e, 0x8c, 0xf2, 0x63, 0x55, 0x62, 0x7d, 0xfe, 0x4e, 0xbe, 0x17, 0x4e, 0xdc, 0x24, 0x46, 0x74, - 0x84, 0x1f, 0xe9, 0xc2, 0x42, 0xa0, 0xfd, 0x3d, 0x0b, 0xd0, 0xc6, 0x3e, 0x89, 0x22, 0xaf, 0x66, - 0x1c, 0x04, 0x43, 0x6f, 0xc0, 0xc4, 0xdd, 0xad, 0x8d, 0xf5, 0xcd, 0xd0, 0x0b, 0xd8, 0x59, 0x77, - 0xe3, 0x48, 0xc0, 0x0d, 0x03, 0x8e, 0x53, 0x54, 0x68, 0x11, 0xa6, 0xef, 0xde, 0xa3, 0x1e, 0xf8, - 0xd5, 0x83, 0x56, 0x44, 0xe2, 0x58, 0x5d, 0xd3, 0x22, 0xf6, 0x5c, 0x6e, 0xbc, 0x93, 0x41, 0xe2, - 0x6e, 0x7a, 0xb4, 0x01, 0x17, 0x9a, 0x2c, 0xd8, 0x5b, 0x63, 0x0b, 0x8f, 0x98, 0x47, 0x7e, 0x23, - 0x79, 0x98, 0xf8, 0xf9, 0xa3, 0xc3, 0xd9, 0x0b, 0x6b, 0xbd, 0x08, 0x70, 0xef, 0xe7, 0xec, 0x6f, - 0x15, 0x60, 0xdc, 0xb8, 0x26, 0x65, 0x80, 0x25, 0x56, 0xe6, 0x66, 0x97, 0xc2, 0x80, 0x37, 0xbb, - 0xbc, 0x02, 0xe5, 0x56, 0xe8, 0x7b, 0xae, 0xa7, 0x4e, 0x3e, 0xb3, 0x0a, 0x3c, 0x9b, 0x02, 0x86, - 0x15, 0x16, 0xdd, 0x87, 0x8a, 0xba, 0x3a, 0x40, 0x9c, 0x85, 0xca, 0x6b, 0x91, 0xa9, 0x06, 0xaf, - 0xbe, 0x12, 0x40, 0xcb, 0x42, 0x36, 0x8c, 0xb2, 0x9e, 0x2f, 0xb3, 0x49, 0x58, 0xc2, 0x3b, 0x1b, - 0x12, 0x31, 0x16, 0x18, 0xfb, 0x97, 0xc6, 0xe0, 0x7c, 0xaf, 0xaa, 0x31, 0xe8, 0x67, 0x60, 0x94, - 0xeb, 0x98, 0x4f, 0x61, 0xb2, 0x5e, 0x32, 0x96, 0x19, 0x43, 0xa1, 0x16, 0xfb, 0x8d, 0x85, 0x4c, - 0x21, 0xdd, 0x77, 0x76, 0x84, 0x1b, 0x71, 0x3a, 0xd2, 0x57, 0x1d, 0x2d, 0x7d, 0xd5, 0xe1, 0xd2, - 0x7d, 0x67, 0x07, 0x1d, 0x40, 0xa9, 0xe1, 0x25, 0xc4, 0x11, 0xce, 0xf4, 0x9d, 0x53, 0x11, 0x4e, - 0x1c, 0x9e, 0xb4, 0xcc, 0x7e, 0x62, 0x2e, 0x10, 0x7d, 0xc3, 0x82, 0x33, 0x3b, 0xe9, 0xf3, 0x03, - 0x62, 0x56, 0x71, 0x4e, 0xa1, 0x32, 0x50, 0x5a, 0x50, 0xf5, 0xdc, 0xd1, 0xe1, 0xec, 0x99, 0x0c, - 0x10, 0x67, 0xd5, 0x41, 0xbf, 0x60, 0xc1, 0x58, 0xdd, 0xf3, 0x8d, 0xaa, 0x18, 0xa7, 0xf0, 0x71, - 0xae, 0x31, 0x01, 0x7a, 0xe6, 0xe5, 0xff, 0x63, 0x2c, 0x25, 0xf7, 0x8b, 0xe2, 0x8c, 0x9e, 0x34, - 0x8a, 0x33, 0xf6, 0x84, 0x96, 0x4f, 0x7f, 0xab, 0x00, 0x2f, 0x0f, 0xf0, 0x8d, 0xcc, 0x7c, 0x74, - 0xeb, 0x98, 0x7c, 0xf4, 0xcb, 0x30, 0x12, 0x91, 0x56, 0x98, 0x9d, 0xef, 0x58, 0xc2, 0x08, 0xc3, - 0xa0, 0x97, 0xa0, 0xe8, 0xb4, 0x3c, 0x31, 0xdd, 0xa9, 0x20, 0xef, 0xc2, 0xe6, 0x0a, 0xa6, 0x70, - 0xfa, 0xa5, 0x2b, 0x3b, 0xf2, 0x54, 0x4b, 0x3e, 0xa5, 0x26, 0xfb, 0x1d, 0x92, 0xe1, 0x0b, 0x1a, - 0x85, 0xc5, 0x5a, 0xae, 0xbd, 0x01, 0x17, 0xfb, 0xf7, 0x10, 0xf4, 0x3a, 0x8c, 0xef, 0x44, 0x4e, - 0xe0, 0xee, 0xae, 0x39, 0x89, 0x2b, 0x43, 0xad, 0x2c, 0x6d, 0xae, 0xaa, 0xc1, 0xd8, 0xa4, 0xb1, - 0x7f, 0xa7, 0xd0, 0x9b, 0x23, 0x37, 0x02, 0xc3, 0xb4, 0xb0, 0x68, 0xbf, 0x42, 0x9f, 0xf6, 0xbb, - 0x07, 0xe5, 0x84, 0x25, 0x41, 0x93, 0xba, 0xb0, 0x24, 0xb9, 0x9d, 0xe3, 0x61, 0x73, 0xcd, 0xb6, - 0x60, 0x8e, 0x95, 0x18, 0x6a, 0xf2, 0x7d, 0x5d, 0x50, 0x43, 0x98, 0xfc, 0xcc, 0x61, 0x81, 0x25, - 0x38, 0x6b, 0x14, 0x00, 0xe3, 0x39, 0xa0, 0x3c, 0x00, 0xa7, 0x0e, 0x46, 0x6c, 0x66, 0xf0, 0xb8, - 0xeb, 0x09, 0xfb, 0x9b, 0x05, 0x78, 0xbe, 0xaf, 0x65, 0xd3, 0x51, 0x42, 0xeb, 0x21, 0x51, 0xc2, - 0x13, 0x77, 0x50, 0xb3, 0x81, 0x47, 0x1e, 0x4f, 0x03, 0xbf, 0x0a, 0x65, 0x2f, 0x88, 0x89, 0xdb, - 0x8e, 0x78, 0xa3, 0x19, 0xd9, 0x58, 0x2b, 0x02, 0x8e, 0x15, 0x85, 0xfd, 0x7b, 0xfd, 0xbb, 0x1a, - 0x9d, 0xe5, 0x7e, 0x60, 0x5b, 0xe9, 0x2d, 0x98, 0x74, 0x5a, 0x2d, 0x4e, 0xc7, 0x22, 0x32, 0x99, - 0xa3, 0x4e, 0x0b, 0x26, 0x12, 0xa7, 0x69, 0x8d, 0x3e, 0x3c, 0xda, 0xaf, 0x0f, 0xdb, 0x7f, 0x5c, - 0x82, 0x0a, 0x6d, 0x81, 0xc5, 0x88, 0xd4, 0x62, 0xda, 0x00, 0xed, 0xc8, 0x17, 0xad, 0xa8, 0x1a, - 0xe0, 0x16, 0x5e, 0xc5, 0x14, 0x9e, 0x5a, 0x25, 0x17, 0x86, 0x3a, 0x09, 0x51, 0x3c, 0xf6, 0x24, - 0xc4, 0x5b, 0x30, 0x19, 0xc7, 0xbb, 0x9b, 0x91, 0xb7, 0xef, 0x24, 0xd4, 0xf7, 0x16, 0x11, 0x6f, - 0x9d, 0xbd, 0xbc, 0x75, 0x5d, 0x23, 0x71, 0x9a, 0x16, 0x2d, 0xc3, 0xb4, 0x3e, 0x8f, 0x40, 0xa2, - 0x84, 0x05, 0xb8, 0x79, 0x53, 0xa9, 0xe4, 0x61, 0x7d, 0x82, 0x41, 0x10, 0xe0, 0xee, 0x67, 0xe8, - 0x90, 0x4e, 0x01, 0xa9, 0x22, 0xa3, 0xe9, 0x21, 0x9d, 0xe2, 0x43, 0x75, 0xe9, 0x7a, 0x02, 0xad, - 0xc1, 0x39, 0xde, 0x2f, 0xd8, 0x4d, 0x59, 0xea, 0x8d, 0xc6, 0x18, 0xa3, 0x17, 0x04, 0xa3, 0x73, - 0xcb, 0xdd, 0x24, 0xb8, 0xd7, 0x73, 0xd4, 0xb1, 0x56, 0xe0, 0x95, 0x25, 0xb1, 0xc0, 0x53, 0x8e, - 0xb5, 0x62, 0xb3, 0x52, 0xc3, 0x26, 0x1d, 0xfa, 0x18, 0x3c, 0xa7, 0xff, 0xf2, 0x3c, 0x20, 0xbe, - 0xeb, 0xb1, 0x24, 0x8e, 0x7a, 0xa9, 0xe2, 0x53, 0xcb, 0x3d, 0xc9, 0x6a, 0xb8, 0xdf, 0xf3, 0x68, - 0x07, 0x2e, 0x2a, 0xd4, 0x55, 0xba, 0x8a, 0x69, 0x45, 0x5e, 0x4c, 0xaa, 0x4e, 0x4c, 0x6e, 0x45, - 0x3e, 0x3b, 0x1c, 0x56, 0xd1, 0x65, 0x72, 0x97, 0xbd, 0xe4, 0x7a, 0x2f, 0x4a, 0xbc, 0x8a, 0x1f, - 0xc2, 0x05, 0xcd, 0x43, 0x85, 0x04, 0xce, 0x8e, 0x4f, 0x36, 0x16, 0x57, 0xd8, 0x91, 0x31, 0x63, - 0x93, 0xe5, 0xaa, 0x44, 0x60, 0x4d, 0xa3, 0x82, 0x2c, 0x13, 0x7d, 0x83, 0x2c, 0x7f, 0x60, 0xc1, - 0xa4, 0xea, 0xec, 0x8f, 0x21, 0x9b, 0xc1, 0x4f, 0x67, 0x33, 0x2c, 0x9f, 0x74, 0x77, 0x4b, 0x68, - 0xde, 0x27, 0x24, 0xf6, 0x47, 0x15, 0x00, 0x76, 0xe9, 0xa7, 0xc7, 0xaa, 0x37, 0x48, 0x73, 0x67, - 0xf5, 0x35, 0x77, 0x4f, 0xed, 0x70, 0xee, 0x75, 0xb8, 0xa2, 0xf4, 0x64, 0x0f, 0x57, 0x6c, 0xc1, - 0x05, 0x39, 0x19, 0xf1, 0x05, 0xff, 0xf5, 0x30, 0x56, 0xd6, 0xa1, 0x5c, 0x7d, 0x49, 0x30, 0xba, - 0xb0, 0xd2, 0x8b, 0x08, 0xf7, 0x7e, 0x36, 0x35, 0x07, 0x8e, 0x1d, 0x37, 0x07, 0xea, 0x01, 0xb1, - 0x5a, 0x97, 0x75, 0xa0, 0x32, 0x03, 0x62, 0xf5, 0xda, 0x16, 0xd6, 0x34, 0xbd, 0xad, 0x62, 0x25, - 0x27, 0xab, 0x08, 0x43, 0x5b, 0x45, 0x39, 0x3e, 0xc7, 0xfb, 0xde, 0xb6, 0x26, 0xf7, 0x18, 0x26, - 0xfa, 0xee, 0x31, 0xbc, 0x0d, 0x53, 0x5e, 0xb0, 0x4b, 0x22, 0x2f, 0x21, 0x35, 0x36, 0x16, 0xc4, - 0x55, 0x8a, 0x2a, 0x87, 0x60, 0x25, 0x85, 0xc5, 0x19, 0xea, 0xb4, 0x51, 0x99, 0x1a, 0xc0, 0xa8, - 0xf4, 0x31, 0xe5, 0x67, 0xf2, 0x31, 0xe5, 0x67, 0x4f, 0x6e, 0xca, 0xa7, 0x4f, 0xd5, 0x94, 0xa3, - 0x5c, 0x4c, 0xf9, 0xcb, 0x50, 0x6a, 0x45, 0xe1, 0x41, 0x67, 0xe6, 0x5c, 0xda, 0x3d, 0xdb, 0xa4, - 0x40, 0xcc, 0x71, 0xe6, 0x72, 0xe1, 0xfc, 0xc3, 0x97, 0x0b, 0xf6, 0xe7, 0x0b, 0x70, 0x41, 0x5b, - 0x3a, 0xda, 0xbf, 0xbc, 0x3a, 0x1d, 0xeb, 0xac, 0x58, 0x1f, 0x0f, 0x44, 0x1b, 0xe9, 0x2b, 0x3a, - 0x13, 0x46, 0x61, 0xb0, 0x41, 0xc5, 0xb2, 0x40, 0x48, 0xc4, 0xaa, 0x33, 0x64, 0xcd, 0xe0, 0xa2, - 0x80, 0x63, 0x45, 0xc1, 0x6e, 0x0c, 0x27, 0x51, 0x22, 0x32, 0xeb, 0xb2, 0x27, 0x36, 0x17, 0x35, - 0x0a, 0x9b, 0x74, 0xe8, 0x15, 0x2e, 0x84, 0x0d, 0x41, 0x6a, 0x0a, 0x27, 0x44, 0x9d, 0x69, 0x39, - 0xea, 0x14, 0x56, 0xaa, 0xc3, 0xd2, 0x7d, 0x4a, 0xdd, 0xea, 0xb0, 0xe0, 0x89, 0xa2, 0xb0, 0xff, - 0xaf, 0x05, 0xcf, 0xf7, 0x6c, 0x8a, 0xc7, 0x30, 0xbd, 0x1d, 0xa4, 0xa7, 0xb7, 0xad, 0x93, 0x4f, - 0x6f, 0x5d, 0x6f, 0xd1, 0x67, 0xaa, 0xfb, 0x8f, 0x16, 0x4c, 0x69, 0xfa, 0xc7, 0xf0, 0xaa, 0x5e, - 0xae, 0x77, 0x7f, 0x6b, 0xd5, 0xf9, 0xce, 0x55, 0xea, 0xdd, 0xfe, 0x80, 0xbd, 0x1b, 0xdf, 0x83, - 0x5e, 0x70, 0xe5, 0x3d, 0x95, 0xc7, 0xec, 0xbd, 0x76, 0x60, 0x94, 0x55, 0x75, 0x8d, 0xf3, 0xd9, - 0x0b, 0x4f, 0xcb, 0x67, 0x79, 0x7c, 0x7a, 0x2f, 0x9c, 0xfd, 0x8d, 0xb1, 0x10, 0xc8, 0x6a, 0x87, - 0x78, 0x31, 0xb5, 0x97, 0x35, 0x91, 0x38, 0xa3, 0x6b, 0x87, 0x08, 0x38, 0x56, 0x14, 0x76, 0x13, - 0x66, 0xd2, 0xcc, 0x97, 0x48, 0x9d, 0x85, 0x1c, 0x07, 0x7a, 0xcd, 0x79, 0xa8, 0x38, 0xec, 0xa9, - 0xd5, 0xb6, 0x93, 0xbd, 0x9a, 0x60, 0x41, 0x22, 0xb0, 0xa6, 0xb1, 0x7f, 0xd3, 0x82, 0x73, 0x3d, - 0x5e, 0x26, 0xc7, 0x84, 0xa1, 0x44, 0x5b, 0x81, 0x3e, 0x17, 0x88, 0xd6, 0x48, 0xdd, 0x91, 0x41, - 0x2d, 0xc3, 0xaa, 0x2d, 0x71, 0x30, 0x96, 0x78, 0xfb, 0x7f, 0x59, 0x70, 0x26, 0xad, 0x6b, 0x8c, - 0x6e, 0x00, 0xe2, 0x2f, 0xb3, 0xe4, 0xc5, 0x6e, 0xb8, 0x4f, 0xa2, 0x0e, 0x7d, 0x73, 0xae, 0xf5, - 0x45, 0xc1, 0x09, 0x2d, 0x74, 0x51, 0xe0, 0x1e, 0x4f, 0xb1, 0xda, 0x06, 0x35, 0xd5, 0xda, 0xb2, - 0xa7, 0xdc, 0xce, 0xb3, 0xa7, 0xe8, 0x8f, 0x69, 0x6e, 0xfc, 0x2b, 0x91, 0xd8, 0x94, 0x6f, 0x7f, - 0x6f, 0x04, 0x54, 0x46, 0x21, 0x0b, 0x9f, 0xe4, 0x14, 0x7c, 0x4a, 0xdd, 0x5f, 0x51, 0x1c, 0xe2, - 0x46, 0xd3, 0x91, 0x87, 0x85, 0x36, 0x78, 0x29, 0x75, 0x73, 0x93, 0x47, 0xbd, 0xe1, 0xb6, 0x46, - 0x61, 0x93, 0x8e, 0x6a, 0xe2, 0x7b, 0xfb, 0x84, 0x3f, 0x34, 0x9a, 0xd6, 0x64, 0x55, 0x22, 0xb0, - 0xa6, 0xa1, 0x9a, 0xd4, 0xbc, 0x7a, 0x5d, 0xac, 0x14, 0x95, 0x26, 0xb4, 0x75, 0x30, 0xc3, 0x50, - 0x8a, 0xdd, 0x30, 0xdc, 0x13, 0xfe, 0x9f, 0xa2, 0xb8, 0x1e, 0x86, 0x7b, 0x98, 0x61, 0xa8, 0xc7, - 0x12, 0x84, 0x51, 0x93, 0x5d, 0x1d, 0x51, 0x53, 0x52, 0x84, 0xdf, 0xa7, 0x3c, 0x96, 0xf5, 0x6e, - 0x12, 0xdc, 0xeb, 0x39, 0xda, 0x03, 0x5b, 0x11, 0xa9, 0x79, 0x6e, 0x62, 0x72, 0x83, 0x74, 0x0f, - 0xdc, 0xec, 0xa2, 0xc0, 0x3d, 0x9e, 0x42, 0x0b, 0x70, 0x46, 0x66, 0x84, 0xca, 0x13, 0x2f, 0xdc, - 0x19, 0x54, 0x7e, 0x38, 0x4e, 0xa3, 0x71, 0x96, 0x9e, 0x5a, 0x9b, 0xa6, 0x38, 0xec, 0xc6, 0xdc, - 0x44, 0xc3, 0xda, 0xc8, 0x43, 0x70, 0x58, 0x51, 0xd8, 0x9f, 0x2d, 0xd2, 0xd9, 0xb1, 0x4f, 0xc1, - 0xc6, 0xc7, 0x16, 0xec, 0x4c, 0xf7, 0xc8, 0x91, 0x01, 0x7a, 0xe4, 0x1b, 0x30, 0x71, 0x37, 0x0e, - 0x03, 0x15, 0x48, 0x2c, 0xf5, 0x0d, 0x24, 0x1a, 0x54, 0xbd, 0x03, 0x89, 0xa3, 0x79, 0x05, 0x12, - 0xc7, 0x1e, 0x31, 0x90, 0xf8, 0x6f, 0x4b, 0xa0, 0xca, 0xad, 0xad, 0x93, 0xe4, 0x7e, 0x18, 0xed, - 0x79, 0x41, 0x83, 0x65, 0xd2, 0x7e, 0xc3, 0x82, 0x09, 0x3e, 0x5e, 0x44, 0xad, 0x5c, 0x9e, 0x25, - 0x54, 0xcf, 0xa9, 0xc4, 0x58, 0x4a, 0xd8, 0xdc, 0xb6, 0x21, 0x28, 0x53, 0xb8, 0xd8, 0x44, 0xe1, - 0x94, 0x46, 0xe8, 0x67, 0x01, 0xe4, 0x25, 0x0a, 0xf5, 0x9c, 0xae, 0x17, 0x56, 0x57, 0x5a, 0x90, - 0xba, 0xf6, 0x4d, 0xb7, 0x95, 0x10, 0x6c, 0x08, 0x44, 0x9f, 0xcf, 0x5e, 0xad, 0xf3, 0xe9, 0x53, - 0x69, 0x9b, 0x41, 0x4a, 0xe3, 0x60, 0x18, 0xf3, 0x82, 0x06, 0xed, 0x27, 0x22, 0xf6, 0xfa, 0xc1, - 0x5e, 0x59, 0xe8, 0xab, 0xa1, 0x53, 0xab, 0x3a, 0xbe, 0x13, 0xb8, 0x24, 0x5a, 0xe1, 0xe4, 0x66, - 0x25, 0x7d, 0x06, 0xc0, 0x92, 0x51, 0x57, 0x0d, 0xbd, 0xd2, 0x20, 0x35, 0xf4, 0x2e, 0x7e, 0x14, - 0xa6, 0xbb, 0x3e, 0xe6, 0x50, 0xa5, 0x71, 0x1e, 0xbd, 0xaa, 0x8e, 0xfd, 0xaf, 0x46, 0xf5, 0xa4, - 0xb5, 0x1e, 0xd6, 0x78, 0x25, 0xb7, 0x48, 0x7f, 0x51, 0xe1, 0x7b, 0xe6, 0xd8, 0x45, 0x8c, 0x6a, - 0xfc, 0x0a, 0x88, 0x4d, 0x91, 0xb4, 0x8f, 0xb6, 0x9c, 0x88, 0x04, 0xa7, 0xdd, 0x47, 0x37, 0x95, - 0x10, 0x6c, 0x08, 0x44, 0xbb, 0xa9, 0x2c, 0xb1, 0x6b, 0x27, 0xcf, 0x12, 0x63, 0x27, 0xd4, 0x7a, - 0x95, 0xaa, 0xfa, 0xaa, 0x05, 0x53, 0x41, 0xaa, 0xe7, 0x8a, 0x7d, 0xf8, 0xed, 0xd3, 0x18, 0x15, - 0xbc, 0x5a, 0x67, 0x1a, 0x86, 0x33, 0xf2, 0x7b, 0x4d, 0x69, 0xa5, 0x21, 0xa7, 0x34, 0x5d, 0x12, - 0x72, 0xb4, 0x5f, 0x49, 0x48, 0x14, 0xa8, 0xc2, 0xb3, 0x63, 0xb9, 0x17, 0x9e, 0x85, 0x1e, 0x45, - 0x67, 0xef, 0x40, 0xc5, 0x8d, 0x88, 0x93, 0x3c, 0x62, 0x0d, 0x52, 0x16, 0x84, 0x5c, 0x94, 0x0c, - 0xb0, 0xe6, 0x65, 0xff, 0x87, 0x22, 0x9c, 0x95, 0x2d, 0x22, 0x33, 0x68, 0xe8, 0xfc, 0xc8, 0xe5, - 0x6a, 0xe7, 0x56, 0xcd, 0x8f, 0xd7, 0x25, 0x02, 0x6b, 0x1a, 0xea, 0x8f, 0xb5, 0x63, 0xb2, 0xd1, - 0x22, 0xc1, 0xaa, 0xb7, 0x13, 0x8b, 0xf8, 0x91, 0x1a, 0x28, 0xb7, 0x34, 0x0a, 0x9b, 0x74, 0xd4, - 0x19, 0xe7, 0x7e, 0x71, 0x9c, 0x4d, 0x48, 0x13, 0xfe, 0x36, 0x96, 0x78, 0xf4, 0xab, 0x3d, 0x2b, - 0x48, 0xe7, 0x93, 0x8a, 0xd9, 0x95, 0x38, 0x34, 0x64, 0xe9, 0xe8, 0xaf, 0x58, 0x70, 0x66, 0x2f, - 0x75, 0x0a, 0x41, 0x9a, 0xe4, 0x13, 0x9e, 0x97, 0x4b, 0x1f, 0x6d, 0xd0, 0x5d, 0x38, 0x0d, 0x8f, - 0x71, 0x56, 0xba, 0xfd, 0x7f, 0x2c, 0x30, 0xcd, 0xd3, 0x60, 0x9e, 0x95, 0x71, 0x27, 0x40, 0xe1, - 0x98, 0x3b, 0x01, 0xa4, 0x13, 0x56, 0x1c, 0xcc, 0xe9, 0x1f, 0x19, 0xc2, 0xe9, 0x2f, 0xf5, 0xf5, - 0xda, 0x5e, 0x82, 0x62, 0xdb, 0xab, 0x09, 0xbf, 0x5d, 0x07, 0xc3, 0x56, 0x96, 0x30, 0x85, 0xdb, - 0xff, 0xbc, 0xa4, 0xd7, 0xe9, 0x22, 0x83, 0xf0, 0x07, 0xe2, 0xb5, 0xeb, 0xea, 0xf8, 0x23, 0x7f, - 0xf3, 0xf5, 0xae, 0xe3, 0x8f, 0x3f, 0x36, 0x7c, 0x82, 0x28, 0x6f, 0xa0, 0x7e, 0xa7, 0x1f, 0xc7, - 0x8e, 0xc9, 0x0e, 0xbd, 0x0b, 0x65, 0xba, 0xb4, 0x61, 0x1b, 0x6e, 0xe5, 0x94, 0x52, 0xe5, 0xeb, - 0x02, 0xfe, 0xe0, 0x70, 0xf6, 0x47, 0x87, 0x57, 0x4b, 0x3e, 0x8d, 0x15, 0x7f, 0x14, 0x43, 0x85, - 0xfe, 0x66, 0x89, 0xac, 0x62, 0xd1, 0x74, 0x4b, 0xd9, 0x22, 0x89, 0xc8, 0x25, 0x4b, 0x56, 0xcb, - 0x41, 0x01, 0x54, 0x58, 0xf5, 0x7a, 0x26, 0x94, 0xaf, 0xad, 0x36, 0x55, 0x3a, 0xa9, 0x44, 0x3c, - 0x38, 0x9c, 0x7d, 0x6b, 0x78, 0xa1, 0xea, 0x71, 0xac, 0x45, 0xd8, 0xff, 0xad, 0xa8, 0xfb, 0xae, - 0x38, 0xf5, 0xfa, 0x03, 0xd1, 0x77, 0xdf, 0xcc, 0xf4, 0xdd, 0xcb, 0x5d, 0x7d, 0x77, 0x4a, 0x57, - 0x78, 0x4f, 0xf5, 0xc6, 0xc7, 0x3d, 0xc1, 0x1e, 0xbf, 0x8e, 0x67, 0x9e, 0xc5, 0xbd, 0xb6, 0x17, - 0x91, 0x78, 0x33, 0x6a, 0x07, 0x5e, 0xd0, 0x10, 0xf7, 0xfc, 0x18, 0x9e, 0x45, 0x0a, 0x8d, 0xb3, - 0xf4, 0xf6, 0xb7, 0x58, 0xbc, 0xd3, 0xc8, 0x89, 0xa7, 0x5f, 0xd9, 0x67, 0x17, 0x00, 0xf0, 0x73, - 0x81, 0xea, 0x2b, 0xf3, 0xaa, 0xff, 0x1c, 0x87, 0xee, 0xc3, 0xd8, 0x0e, 0x2f, 0x0c, 0x9c, 0x4f, - 0x15, 0x20, 0x51, 0x65, 0x98, 0x15, 0xcb, 0x93, 0x25, 0x87, 0x1f, 0xe8, 0x9f, 0x58, 0x4a, 0xb3, - 0xff, 0x6e, 0x11, 0xce, 0x64, 0xca, 0xd3, 0xa7, 0x6a, 0x12, 0x14, 0x8e, 0xad, 0x49, 0xf0, 0x49, - 0x80, 0x1a, 0x69, 0xf9, 0x61, 0x87, 0x39, 0x2e, 0x23, 0x43, 0x3b, 0x2e, 0xca, 0xd7, 0x5d, 0x52, - 0x5c, 0xb0, 0xc1, 0x51, 0x1c, 0x86, 0xe4, 0x25, 0x0e, 0x32, 0x87, 0x21, 0x8d, 0x62, 0x58, 0xa3, - 0x8f, 0xb7, 0x18, 0x96, 0x07, 0x67, 0xb8, 0x8a, 0x2a, 0xf3, 0xfc, 0x11, 0x12, 0xcc, 0x59, 0xce, - 0xe2, 0x52, 0x9a, 0x0d, 0xce, 0xf2, 0xb5, 0xbf, 0x5c, 0xa0, 0xee, 0x1b, 0x6f, 0xec, 0x35, 0xb9, - 0x39, 0xfe, 0x01, 0x18, 0x75, 0xda, 0xc9, 0x6e, 0xd8, 0x55, 0xe1, 0x78, 0x81, 0x41, 0xb1, 0xc0, - 0xa2, 0x55, 0x18, 0xa9, 0xe9, 0x03, 0x6b, 0xc3, 0x28, 0xa7, 0x77, 0xc2, 0x9c, 0x84, 0x60, 0xc6, - 0x05, 0xbd, 0x08, 0x23, 0x89, 0xd3, 0x48, 0x5d, 0xea, 0xb4, 0xed, 0x34, 0x62, 0xcc, 0xa0, 0xe6, - 0xec, 0x32, 0x72, 0xcc, 0xec, 0xf2, 0x16, 0x4c, 0xc6, 0x5e, 0x23, 0x70, 0x92, 0x76, 0x44, 0x8c, - 0xa8, 0x8b, 0x0e, 0x55, 0x9b, 0x48, 0x9c, 0xa6, 0xb5, 0xbf, 0x57, 0x81, 0xf3, 0xbd, 0x6e, 0xd7, - 0xcc, 0x3b, 0xed, 0xb7, 0x97, 0x8c, 0xc7, 0x97, 0xf6, 0xdb, 0x47, 0xba, 0x6f, 0xa4, 0xfd, 0xfa, - 0x46, 0xda, 0xef, 0xe7, 0x2d, 0xa8, 0xa8, 0x6c, 0x57, 0x91, 0xb1, 0xf7, 0xf1, 0x53, 0xb8, 0xc1, - 0x54, 0x8a, 0x10, 0x49, 0x8f, 0xf2, 0x2f, 0xd6, 0xc2, 0x4f, 0x2f, 0x0f, 0xf8, 0xa1, 0x0a, 0x0d, - 0x95, 0x07, 0xac, 0x92, 0xa4, 0x4b, 0x79, 0x24, 0x49, 0xf7, 0xf9, 0x54, 0x3d, 0x93, 0xa4, 0xbf, - 0x6a, 0xc1, 0xb8, 0xf3, 0x5e, 0x3b, 0x22, 0x4b, 0x64, 0x7f, 0xa3, 0x15, 0x0b, 0xbb, 0xf5, 0x89, - 0xfc, 0x15, 0x58, 0xd0, 0x42, 0x44, 0x29, 0x46, 0x0d, 0xc0, 0xa6, 0x0a, 0xa9, 0xa4, 0xe8, 0xb1, - 0x3c, 0x92, 0xa2, 0x7b, 0xa9, 0x73, 0x6c, 0x52, 0xf4, 0x5b, 0x30, 0xe9, 0xfa, 0x61, 0x40, 0x36, - 0xa3, 0x30, 0x09, 0xdd, 0xd0, 0x17, 0x5e, 0xa7, 0x32, 0x09, 0x8b, 0x26, 0x12, 0xa7, 0x69, 0xfb, - 0x65, 0x54, 0x57, 0x4e, 0x9a, 0x51, 0x0d, 0x4f, 0x28, 0xa3, 0xfa, 0x4f, 0x0a, 0x30, 0x7b, 0xcc, - 0x47, 0x45, 0x6f, 0xc2, 0x44, 0x18, 0x35, 0x9c, 0xc0, 0x7b, 0x8f, 0x1f, 0x68, 0x2b, 0xa5, 0x4f, - 0xaa, 0x6f, 0x18, 0x38, 0x9c, 0xa2, 0x94, 0x39, 0x97, 0xa3, 0x7d, 0x72, 0x2e, 0x3f, 0x0c, 0xe3, - 0x09, 0x71, 0x9a, 0x22, 0x05, 0x40, 0xac, 0x14, 0x74, 0xe4, 0x45, 0xa3, 0xb0, 0x49, 0x47, 0xbb, - 0xd1, 0x94, 0xe3, 0xba, 0x24, 0x8e, 0x65, 0x52, 0xa5, 0xd8, 0xc5, 0xc8, 0x2d, 0x63, 0x93, 0x6d, - 0x0e, 0x2d, 0xa4, 0x44, 0xe0, 0x8c, 0x48, 0xaa, 0xbc, 0xe3, 0xfb, 0x3c, 0x7f, 0x9a, 0xc8, 0x6b, - 0x1a, 0x75, 0xd1, 0x6f, 0x8d, 0xc2, 0x26, 0x9d, 0xfd, 0x6b, 0x05, 0x78, 0xe9, 0xa1, 0xe6, 0x65, - 0xe0, 0x7c, 0xd7, 0x76, 0x4c, 0xa2, 0x6c, 0xe4, 0xe2, 0x56, 0x4c, 0x22, 0xcc, 0x30, 0xbc, 0x95, - 0x5a, 0x2d, 0xe3, 0x1a, 0x83, 0xbc, 0xd3, 0xab, 0x79, 0x2b, 0xa5, 0x44, 0xe0, 0x8c, 0xc8, 0x6c, - 0x2b, 0x8d, 0x0c, 0xd8, 0x4a, 0xff, 0xb0, 0x00, 0x2f, 0x0f, 0x60, 0x84, 0x73, 0x4c, 0x43, 0x4f, - 0xa7, 0xf1, 0x17, 0x9f, 0x4c, 0x1a, 0xff, 0xa3, 0x36, 0xd7, 0xb7, 0x0a, 0x70, 0xb1, 0xbf, 0x2d, - 0x44, 0x3f, 0x4e, 0x57, 0x1b, 0x32, 0x2b, 0xc1, 0x3c, 0x02, 0x70, 0x8e, 0xaf, 0x34, 0x52, 0x28, - 0x9c, 0xa5, 0x45, 0x73, 0x00, 0x2d, 0x27, 0xd9, 0x8d, 0xaf, 0x1e, 0x78, 0x71, 0x22, 0x0e, 0xaf, - 0x4d, 0xf1, 0x3d, 0x63, 0x09, 0xc5, 0x06, 0x05, 0x15, 0xc7, 0xfe, 0x2d, 0x85, 0xeb, 0x61, 0xc2, - 0x1f, 0xe2, 0x7e, 0xdc, 0x39, 0x7e, 0xaf, 0x6a, 0x0a, 0x85, 0xb3, 0xb4, 0x54, 0x1c, 0x8b, 0x4a, - 0x70, 0x45, 0xc5, 0x1d, 0xb4, 0x54, 0xdc, 0xaa, 0x82, 0x62, 0x83, 0x22, 0x7b, 0xb8, 0xa1, 0x34, - 0xc0, 0xe1, 0x86, 0x7f, 0x5a, 0x80, 0xe7, 0xfb, 0xce, 0xa5, 0x83, 0x0d, 0xc0, 0xa7, 0xef, 0x54, - 0xc3, 0xa3, 0xf5, 0x9d, 0x21, 0x73, 0xf5, 0xff, 0x73, 0x9f, 0x9e, 0x26, 0x72, 0xf5, 0xb3, 0x53, - 0x85, 0x35, 0xec, 0x54, 0xf1, 0x14, 0xb5, 0x67, 0x57, 0x7a, 0xfe, 0xc8, 0x10, 0xe9, 0xf9, 0x99, - 0x8f, 0x51, 0x1a, 0x70, 0x20, 0x7f, 0xa7, 0x7f, 0xf3, 0x52, 0xdf, 0x7b, 0xa0, 0x7d, 0x9c, 0x25, - 0x38, 0x2b, 0x2e, 0xb3, 0xde, 0x6a, 0xef, 0x88, 0xa3, 0x8d, 0x85, 0xf4, 0x95, 0x1e, 0x2b, 0x19, - 0x3c, 0xee, 0x7a, 0xe2, 0x29, 0x3c, 0x2e, 0xf1, 0x88, 0x4d, 0xfa, 0x49, 0xa8, 0x28, 0xde, 0x3c, - 0x85, 0x50, 0x7d, 0xd0, 0xae, 0x14, 0x42, 0xf5, 0x35, 0x0d, 0x2a, 0xda, 0x12, 0x7b, 0xa4, 0x93, - 0xed, 0x99, 0x37, 0x49, 0x87, 0x85, 0x13, 0xed, 0x1f, 0x81, 0x09, 0xb5, 0x88, 0x1c, 0xb4, 0xac, - 0xa0, 0xfd, 0x3f, 0x47, 0x60, 0x32, 0x75, 0x84, 0x3d, 0xb5, 0x15, 0x62, 0x1d, 0xbb, 0x15, 0xc2, - 0x92, 0x2e, 0xdb, 0x81, 0xac, 0xba, 0x69, 0x24, 0x5d, 0xb6, 0x03, 0x82, 0x39, 0x8e, 0x2e, 0xdd, - 0x6b, 0x51, 0x07, 0xb7, 0x03, 0x91, 0xba, 0xa5, 0x96, 0xee, 0x4b, 0x0c, 0x8a, 0x05, 0x16, 0x7d, - 0xc6, 0x82, 0x89, 0x98, 0xed, 0x9c, 0xf1, 0x8d, 0x24, 0xf1, 0x41, 0x6f, 0xe4, 0x71, 0xdb, 0xa2, - 0x28, 0xd7, 0xc0, 0xa2, 0xbe, 0x26, 0x04, 0xa7, 0x24, 0xa2, 0x5f, 0xb4, 0xcc, 0x7b, 0x26, 0x47, - 0xf3, 0x48, 0x39, 0xcc, 0x56, 0x08, 0xe0, 0xdb, 0x2c, 0x0f, 0xbf, 0x6e, 0x32, 0x56, 0xbb, 0x3c, - 0x63, 0xa7, 0xb3, 0xcb, 0x03, 0x3d, 0x76, 0x78, 0x3e, 0x04, 0x95, 0xa6, 0x13, 0x78, 0x75, 0x12, - 0x27, 0xf1, 0x4c, 0xd9, 0x28, 0x5c, 0x22, 0x81, 0x58, 0xe3, 0xe9, 0x64, 0x17, 0xb3, 0x17, 0xe3, - 0x91, 0xae, 0x8a, 0x2e, 0x80, 0xbf, 0xa5, 0xc1, 0xd8, 0xa4, 0xb1, 0xff, 0x89, 0x05, 0x17, 0x7a, - 0x36, 0xc6, 0xd3, 0x9b, 0x23, 0x43, 0x27, 0xe8, 0x73, 0x3d, 0x4a, 0x3c, 0xa0, 0xce, 0xa9, 0x5d, - 0x47, 0x2a, 0x6a, 0x48, 0x4c, 0xf6, 0xed, 0x1b, 0xc3, 0xed, 0x55, 0xea, 0xfd, 0xc2, 0xe2, 0x63, - 0xdd, 0x2f, 0xa4, 0xae, 0xa0, 0x71, 0x71, 0x2e, 0xfa, 0x39, 0xb3, 0x9a, 0x89, 0x95, 0x57, 0xe5, - 0x0d, 0xce, 0x5c, 0x55, 0x43, 0xe1, 0xad, 0xd6, 0xab, 0x38, 0x4a, 0xb6, 0xbf, 0x16, 0x8e, 0xef, - 0xaf, 0xc8, 0x97, 0x65, 0x63, 0x8a, 0xf9, 0x97, 0x8d, 0xa9, 0x74, 0x95, 0x8c, 0xf9, 0xdb, 0x16, - 0xef, 0x69, 0x99, 0x57, 0xd2, 0x16, 0xd6, 0x7a, 0x88, 0x85, 0x7d, 0x95, 0x5d, 0xf0, 0x52, 0xbf, - 0x4e, 0x1c, 0x5f, 0x58, 0x62, 0xf3, 0xae, 0x16, 0x06, 0xc7, 0x8a, 0x82, 0x95, 0x83, 0xf6, 0xfd, - 0xf0, 0xfe, 0xd5, 0x66, 0x2b, 0xe9, 0x08, 0x9b, 0xac, 0xcb, 0x41, 0x2b, 0x0c, 0x36, 0xa8, 0xec, - 0x3f, 0xb5, 0xf8, 0xe7, 0x14, 0x81, 0x9c, 0x37, 0x33, 0xe5, 0x4b, 0x07, 0x8f, 0x81, 0xfc, 0x0c, - 0x80, 0xab, 0xee, 0x76, 0xc8, 0xe7, 0x3e, 0x5d, 0x7d, 0x57, 0x84, 0x79, 0xc9, 0xab, 0x84, 0x61, - 0x43, 0x5e, 0x6a, 0xf0, 0x14, 0x8f, 0x1b, 0x3c, 0xf6, 0x9f, 0x58, 0x90, 0x9a, 0x2c, 0x50, 0x0b, - 0x4a, 0x54, 0x83, 0x4e, 0x3e, 0x37, 0x51, 0x98, 0xac, 0xe9, 0xc0, 0x12, 0xdd, 0x82, 0xfd, 0xc4, - 0x5c, 0x10, 0xf2, 0x45, 0x08, 0xa7, 0x90, 0xc7, 0x6d, 0x29, 0xa6, 0xc0, 0xeb, 0x61, 0xb8, 0xc7, - 0x37, 0xb4, 0x75, 0x38, 0xc8, 0x7e, 0x13, 0xa6, 0xbb, 0x94, 0x62, 0xc5, 0x07, 0x43, 0x79, 0xfd, - 0x86, 0xd1, 0x03, 0x59, 0x29, 0x54, 0xcc, 0x71, 0xf6, 0xb7, 0x2c, 0x38, 0x9b, 0x65, 0x8f, 0xbe, - 0x6e, 0xc1, 0x74, 0x9c, 0xe5, 0x77, 0x5a, 0x6d, 0xa7, 0xd2, 0x1b, 0xba, 0x50, 0xb8, 0x5b, 0x09, - 0xfb, 0xff, 0x0b, 0xf3, 0x74, 0xc7, 0x0b, 0x6a, 0xe1, 0x7d, 0x35, 0xb9, 0x58, 0x7d, 0x27, 0x17, - 0x3a, 0xc4, 0xdc, 0x5d, 0x52, 0x6b, 0xfb, 0x5d, 0x07, 0x38, 0xb6, 0x04, 0x1c, 0x2b, 0x8a, 0xd4, - 0x5d, 0x97, 0xc5, 0x63, 0xef, 0xba, 0x7c, 0x03, 0x26, 0xcc, 0x2b, 0x66, 0xc4, 0x69, 0x70, 0xe6, - 0xab, 0x98, 0xb7, 0xd1, 0xe0, 0x14, 0x55, 0xe6, 0x92, 0xc1, 0xd2, 0xb1, 0x97, 0x0c, 0xbe, 0x02, - 0x65, 0x71, 0x61, 0x9e, 0x4c, 0x02, 0xe2, 0xa7, 0x43, 0x04, 0x0c, 0x2b, 0x2c, 0x35, 0x10, 0x4d, - 0x27, 0x68, 0x3b, 0x3e, 0x6d, 0x21, 0x71, 0x68, 0x4c, 0x8d, 0xac, 0x35, 0x85, 0xc1, 0x06, 0x15, - 0x7d, 0xe3, 0xc4, 0x6b, 0x92, 0x77, 0xc3, 0x40, 0x86, 0xcf, 0xf5, 0x76, 0x9f, 0x80, 0x63, 0x45, - 0x61, 0xff, 0x0f, 0x0b, 0xb2, 0xb7, 0x7d, 0xa5, 0x16, 0x80, 0xd6, 0xb1, 0x07, 0xd5, 0xd2, 0x87, - 0x70, 0x0a, 0x03, 0x1d, 0xc2, 0x31, 0xcf, 0xc7, 0x14, 0x1f, 0x7a, 0x3e, 0xe6, 0x87, 0x74, 0x09, - 0x6b, 0x7e, 0x90, 0x66, 0xbc, 0x57, 0xf9, 0x6a, 0x64, 0xc3, 0xa8, 0xeb, 0xa8, 0x73, 0xc0, 0x13, - 0xdc, 0xad, 0x5a, 0x5c, 0x60, 0x44, 0x02, 0x53, 0xdd, 0xf9, 0xf6, 0xf7, 0x2f, 0x3d, 0xf3, 0x9d, - 0xef, 0x5f, 0x7a, 0xe6, 0xf7, 0xbf, 0x7f, 0xe9, 0x99, 0xcf, 0x1c, 0x5d, 0xb2, 0xbe, 0x7d, 0x74, - 0xc9, 0xfa, 0xce, 0xd1, 0x25, 0xeb, 0xf7, 0x8f, 0x2e, 0x59, 0xdf, 0x3b, 0xba, 0x64, 0x7d, 0xf5, - 0xbf, 0x5e, 0x7a, 0xe6, 0xdd, 0x9e, 0xe9, 0x0e, 0xf4, 0xc7, 0x6b, 0x6e, 0x6d, 0x7e, 0xff, 0x0a, - 0x8b, 0xb8, 0xd3, 0xd1, 0x30, 0x6f, 0x74, 0x81, 0x79, 0x39, 0x1a, 0xfe, 0x3c, 0x00, 0x00, 0xff, - 0xff, 0x3f, 0xca, 0xc8, 0x75, 0x3b, 0xb2, 0x00, 0x00, + // 9237 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x7d, 0x6d, 0x70, 0x1c, 0xc9, + 0x75, 0xd8, 0xcd, 0x2e, 0x16, 0xd8, 0x7d, 0xf8, 0x20, 0xd1, 0x24, 0xef, 0x70, 0xbc, 0x3b, 0x82, + 0x35, 0x57, 0x96, 0xce, 0xd1, 0x1d, 0x90, 0xa3, 0x4e, 0x0a, 0xe3, 0xb3, 0x4f, 0xc6, 0x02, 0x24, + 0x08, 0x12, 0x20, 0x70, 0x0d, 0x90, 0x94, 0x4e, 0x3e, 0x49, 0x83, 0xd9, 0xde, 0xc5, 0x10, 0xb3, + 0x33, 0x7b, 0x33, 0xb3, 0x20, 0xf6, 0x6c, 0xcb, 0x92, 0x6c, 0xc7, 0x4a, 0xe9, 0x33, 0x56, 0xaa, + 0x22, 0xa7, 0x52, 0x8e, 0xfc, 0x51, 0xae, 0x38, 0x89, 0x2a, 0xc9, 0xaf, 0x7c, 0x55, 0x7e, 0xd8, + 0xce, 0x0f, 0xa5, 0x9c, 0xaa, 0xa8, 0x2a, 0x2e, 0xcb, 0x8e, 0x13, 0x58, 0x62, 0x92, 0x72, 0xe2, + 0xaa, 0x38, 0x15, 0xc7, 0x7f, 0xc2, 0xca, 0x0f, 0x57, 0x7f, 0xf7, 0xcc, 0xee, 0x02, 0xbb, 0xc4, + 0x80, 0xa4, 0x54, 0xf7, 0x6f, 0xb7, 0xdf, 0x9b, 0xf7, 0xde, 0xf4, 0x74, 0xbf, 0x7e, 0xaf, 0xfb, + 0xbd, 0xd7, 0xb0, 0xda, 0xf0, 0x92, 0x9d, 0xf6, 0xf6, 0x9c, 0x1b, 0x36, 0xe7, 0x9d, 0xa8, 0x11, + 0xb6, 0xa2, 0xf0, 0x2e, 0xfb, 0xf1, 0x8a, 0x5b, 0x9b, 0xdf, 0xbb, 0x34, 0xdf, 0xda, 0x6d, 0xcc, + 0x3b, 0x2d, 0x2f, 0x9e, 0x77, 0x5a, 0x2d, 0xdf, 0x73, 0x9d, 0xc4, 0x0b, 0x83, 0xf9, 0xbd, 0x57, + 0x1d, 0xbf, 0xb5, 0xe3, 0xbc, 0x3a, 0xdf, 0x20, 0x01, 0x89, 0x9c, 0x84, 0xd4, 0xe6, 0x5a, 0x51, + 0x98, 0x84, 0xe8, 0x47, 0x35, 0xb5, 0x39, 0x49, 0x8d, 0xfd, 0xf8, 0xa4, 0x5b, 0x9b, 0xdb, 0xbb, + 0x34, 0xd7, 0xda, 0x6d, 0xcc, 0x51, 0x6a, 0x73, 0x06, 0xb5, 0x39, 0x49, 0xed, 0xfc, 0x2b, 0x86, + 0x2c, 0x8d, 0xb0, 0x11, 0xce, 0x33, 0xa2, 0xdb, 0xed, 0x3a, 0xfb, 0xc7, 0xfe, 0xb0, 0x5f, 0x9c, + 0xd9, 0x79, 0x7b, 0xf7, 0x72, 0x3c, 0xe7, 0x85, 0x54, 0xbc, 0x79, 0x37, 0x8c, 0xc8, 0xfc, 0x5e, + 0x97, 0x40, 0xe7, 0xaf, 0x69, 0x1c, 0xb2, 0x9f, 0x90, 0x20, 0xf6, 0xc2, 0x20, 0x7e, 0x85, 0x8a, + 0x40, 0xa2, 0x3d, 0x12, 0x99, 0xaf, 0x67, 0x20, 0xf4, 0xa2, 0xf4, 0x9a, 0xa6, 0xd4, 0x74, 0xdc, + 0x1d, 0x2f, 0x20, 0x51, 0x47, 0x3f, 0xde, 0x24, 0x89, 0xd3, 0xeb, 0xa9, 0xf9, 0x7e, 0x4f, 0x45, + 0xed, 0x20, 0xf1, 0x9a, 0xa4, 0xeb, 0x81, 0x0f, 0x1f, 0xf5, 0x40, 0xec, 0xee, 0x90, 0xa6, 0xd3, + 0xf5, 0xdc, 0x07, 0xfb, 0x3d, 0xd7, 0x4e, 0x3c, 0x7f, 0xde, 0x0b, 0x92, 0x38, 0x89, 0xb2, 0x0f, + 0xd9, 0xef, 0xc0, 0xe4, 0xc2, 0x9d, 0xcd, 0x85, 0x76, 0xb2, 0xb3, 0x18, 0x06, 0x75, 0xaf, 0x81, + 0x3e, 0x04, 0xe3, 0xae, 0xdf, 0x8e, 0x13, 0x12, 0xdd, 0x74, 0x9a, 0x64, 0xc6, 0xba, 0x68, 0xbd, + 0x54, 0xa9, 0x9e, 0xf9, 0xd6, 0xc1, 0xec, 0x53, 0xf7, 0x0f, 0x66, 0xc7, 0x17, 0x35, 0x08, 0x9b, + 0x78, 0xe8, 0x87, 0x61, 0x2c, 0x0a, 0x7d, 0xb2, 0x80, 0x6f, 0xce, 0x14, 0xd8, 0x23, 0xa7, 0xc4, + 0x23, 0x63, 0x98, 0x37, 0x63, 0x09, 0xb7, 0x7f, 0xbf, 0x00, 0xb0, 0xd0, 0x6a, 0x6d, 0x44, 0xe1, + 0x5d, 0xe2, 0x26, 0xe8, 0x53, 0x50, 0xa6, 0x5d, 0x57, 0x73, 0x12, 0x87, 0x71, 0x1b, 0xbf, 0xf4, + 0x57, 0xe7, 0xf8, 0x9b, 0xcc, 0x99, 0x6f, 0xa2, 0x07, 0x0e, 0xc5, 0x9e, 0xdb, 0x7b, 0x75, 0x6e, + 0x7d, 0x9b, 0x3e, 0xbf, 0x46, 0x12, 0xa7, 0x8a, 0x04, 0x33, 0xd0, 0x6d, 0x58, 0x51, 0x45, 0x01, + 0x8c, 0xc4, 0x2d, 0xe2, 0x32, 0xc1, 0xc6, 0x2f, 0xad, 0xce, 0x1d, 0x67, 0x84, 0xce, 0x69, 0xc9, + 0x37, 0x5b, 0xc4, 0xad, 0x4e, 0x08, 0xce, 0x23, 0xf4, 0x1f, 0x66, 0x7c, 0xd0, 0x1e, 0x8c, 0xc6, + 0x89, 0x93, 0xb4, 0xe3, 0x99, 0x22, 0xe3, 0x78, 0x33, 0x37, 0x8e, 0x8c, 0x6a, 0x75, 0x4a, 0xf0, + 0x1c, 0xe5, 0xff, 0xb1, 0xe0, 0x66, 0xff, 0x17, 0x0b, 0xa6, 0x34, 0xf2, 0xaa, 0x17, 0x27, 0xe8, + 0x27, 0xba, 0x3a, 0x77, 0x6e, 0xb0, 0xce, 0xa5, 0x4f, 0xb3, 0xae, 0x3d, 0x2d, 0x98, 0x95, 0x65, + 0x8b, 0xd1, 0xb1, 0x4d, 0x28, 0x79, 0x09, 0x69, 0xc6, 0x33, 0x85, 0x8b, 0xc5, 0x97, 0xc6, 0x2f, + 0x5d, 0xcb, 0xeb, 0x3d, 0xab, 0x93, 0x82, 0x69, 0x69, 0x85, 0x92, 0xc7, 0x9c, 0x8b, 0xfd, 0x9b, + 0x13, 0xe6, 0xfb, 0xd1, 0x0e, 0x47, 0xaf, 0xc2, 0x78, 0x1c, 0xb6, 0x23, 0x97, 0x60, 0xd2, 0x0a, + 0xe3, 0x19, 0xeb, 0x62, 0x91, 0x0e, 0x3d, 0x3a, 0x52, 0x37, 0x75, 0x33, 0x36, 0x71, 0xd0, 0x97, + 0x2d, 0x98, 0xa8, 0x91, 0x38, 0xf1, 0x02, 0xc6, 0x5f, 0x0a, 0xbf, 0x75, 0x6c, 0xe1, 0x65, 0xe3, + 0x92, 0x26, 0x5e, 0x3d, 0x2b, 0x5e, 0x64, 0xc2, 0x68, 0x8c, 0x71, 0x8a, 0x3f, 0x9d, 0x71, 0x35, + 0x12, 0xbb, 0x91, 0xd7, 0xa2, 0xff, 0xd9, 0x98, 0x31, 0x66, 0xdc, 0x92, 0x06, 0x61, 0x13, 0x0f, + 0x05, 0x50, 0xa2, 0x33, 0x2a, 0x9e, 0x19, 0x61, 0xf2, 0xaf, 0x1c, 0x4f, 0x7e, 0xd1, 0xa9, 0x74, + 0xb2, 0xea, 0xde, 0xa7, 0xff, 0x62, 0xcc, 0xd9, 0xa0, 0x2f, 0x59, 0x30, 0x23, 0x66, 0x3c, 0x26, + 0xbc, 0x43, 0xef, 0xec, 0x78, 0x09, 0xf1, 0xbd, 0x38, 0x99, 0x29, 0x31, 0x19, 0xe6, 0x07, 0x1b, + 0x5b, 0xcb, 0x51, 0xd8, 0x6e, 0xdd, 0xf0, 0x82, 0x5a, 0xf5, 0xa2, 0xe0, 0x34, 0xb3, 0xd8, 0x87, + 0x30, 0xee, 0xcb, 0x12, 0x7d, 0xcd, 0x82, 0xf3, 0x81, 0xd3, 0x24, 0x71, 0xcb, 0xa1, 0x9f, 0x96, + 0x83, 0xab, 0xbe, 0xe3, 0xee, 0x32, 0x89, 0x46, 0x1f, 0x4e, 0x22, 0x5b, 0x48, 0x74, 0xfe, 0x66, + 0x5f, 0xd2, 0xf8, 0x10, 0xb6, 0xe8, 0xd7, 0x2c, 0x98, 0x0e, 0xa3, 0xd6, 0x8e, 0x13, 0x90, 0x9a, + 0x84, 0xc6, 0x33, 0x63, 0x6c, 0xea, 0x7d, 0xe2, 0x78, 0x9f, 0x68, 0x3d, 0x4b, 0x76, 0x2d, 0x0c, + 0xbc, 0x24, 0x8c, 0x36, 0x49, 0x92, 0x78, 0x41, 0x23, 0xae, 0x9e, 0xbb, 0x7f, 0x30, 0x3b, 0xdd, + 0x85, 0x85, 0xbb, 0xe5, 0x41, 0x3f, 0x09, 0xe3, 0x71, 0x27, 0x70, 0xef, 0x78, 0x41, 0x2d, 0xbc, + 0x17, 0xcf, 0x94, 0xf3, 0x98, 0xbe, 0x9b, 0x8a, 0xa0, 0x98, 0x80, 0x9a, 0x01, 0x36, 0xb9, 0xf5, + 0xfe, 0x70, 0x7a, 0x28, 0x55, 0xf2, 0xfe, 0x70, 0x7a, 0x30, 0x1d, 0xc2, 0x16, 0xfd, 0x82, 0x05, + 0x93, 0xb1, 0xd7, 0x08, 0x9c, 0xa4, 0x1d, 0x91, 0x1b, 0xa4, 0x13, 0xcf, 0x00, 0x13, 0xe4, 0xfa, + 0x31, 0x7b, 0xc5, 0x20, 0x59, 0x3d, 0x27, 0x64, 0x9c, 0x34, 0x5b, 0x63, 0x9c, 0xe6, 0xdb, 0x6b, + 0xa2, 0xe9, 0x61, 0x3d, 0x9e, 0xef, 0x44, 0xd3, 0x83, 0xba, 0x2f, 0x4b, 0xf4, 0xe3, 0x70, 0x9a, + 0x37, 0xa9, 0x9e, 0x8d, 0x67, 0x26, 0x98, 0xa2, 0x3d, 0x7b, 0xff, 0x60, 0xf6, 0xf4, 0x66, 0x06, + 0x86, 0xbb, 0xb0, 0xd1, 0x3b, 0x30, 0xdb, 0x22, 0x51, 0xd3, 0x4b, 0xd6, 0x03, 0xbf, 0x23, 0xd5, + 0xb7, 0x1b, 0xb6, 0x48, 0x4d, 0x88, 0x13, 0xcf, 0x4c, 0x5e, 0xb4, 0x5e, 0x2a, 0x57, 0xdf, 0x2f, + 0xc4, 0x9c, 0xdd, 0x38, 0x1c, 0x1d, 0x1f, 0x45, 0xcf, 0xfe, 0x77, 0x05, 0x38, 0x9d, 0x5d, 0x38, + 0xd1, 0x6f, 0x58, 0x70, 0xea, 0xee, 0xbd, 0x64, 0x2b, 0xdc, 0x25, 0x41, 0x5c, 0xed, 0x50, 0xf5, + 0xc6, 0x96, 0x8c, 0xf1, 0x4b, 0x6e, 0xbe, 0x4b, 0xf4, 0xdc, 0xf5, 0x34, 0x97, 0x2b, 0x41, 0x12, + 0x75, 0xaa, 0xcf, 0x88, 0xb7, 0x3b, 0x75, 0xfd, 0xce, 0x96, 0x09, 0xc5, 0x59, 0xa1, 0xce, 0x7f, + 0xc1, 0x82, 0xb3, 0xbd, 0x48, 0xa0, 0xd3, 0x50, 0xdc, 0x25, 0x1d, 0x6e, 0x95, 0x61, 0xfa, 0x13, + 0xbd, 0x0d, 0xa5, 0x3d, 0xc7, 0x6f, 0x13, 0x61, 0xdd, 0x2c, 0x1f, 0xef, 0x45, 0x94, 0x64, 0x98, + 0x53, 0xfd, 0x91, 0xc2, 0x65, 0xcb, 0xfe, 0x0f, 0x45, 0x18, 0x37, 0xd6, 0xb7, 0x47, 0x60, 0xb1, + 0x85, 0x29, 0x8b, 0x6d, 0x2d, 0xb7, 0xa5, 0xb9, 0xaf, 0xc9, 0x76, 0x2f, 0x63, 0xb2, 0xad, 0xe7, + 0xc7, 0xf2, 0x50, 0x9b, 0x0d, 0x25, 0x50, 0x09, 0x5b, 0xd4, 0x22, 0xa7, 0x4b, 0xff, 0x48, 0x1e, + 0x9f, 0x70, 0x5d, 0x92, 0xab, 0x4e, 0xde, 0x3f, 0x98, 0xad, 0xa8, 0xbf, 0x58, 0x33, 0xb2, 0xbf, + 0x63, 0xc1, 0x59, 0x43, 0xc6, 0xc5, 0x30, 0xa8, 0x79, 0xec, 0xd3, 0x5e, 0x84, 0x91, 0xa4, 0xd3, + 0x92, 0x66, 0xbf, 0xea, 0xa9, 0xad, 0x4e, 0x8b, 0x60, 0x06, 0xa1, 0x86, 0x7e, 0x93, 0xc4, 0xb1, + 0xd3, 0x20, 0x59, 0x43, 0x7f, 0x8d, 0x37, 0x63, 0x09, 0x47, 0x11, 0x20, 0xdf, 0x89, 0x93, 0xad, + 0xc8, 0x09, 0x62, 0x46, 0x7e, 0xcb, 0x6b, 0x12, 0xd1, 0xc1, 0x7f, 0x65, 0xb0, 0x11, 0x43, 0x9f, + 0xa8, 0x3e, 0x7d, 0xff, 0x60, 0x16, 0xad, 0x76, 0x51, 0xc2, 0x3d, 0xa8, 0xdb, 0x5f, 0xb3, 0xe0, + 0xe9, 0xde, 0xb6, 0x18, 0x7a, 0x1f, 0x8c, 0x72, 0x97, 0x4f, 0xbc, 0x9d, 0xfe, 0x24, 0xac, 0x15, + 0x0b, 0x28, 0x9a, 0x87, 0x8a, 0x5a, 0x27, 0xc4, 0x3b, 0x4e, 0x0b, 0xd4, 0x8a, 0x5e, 0x5c, 0x34, + 0x0e, 0xed, 0x34, 0xfa, 0x47, 0x58, 0x6e, 0xaa, 0xd3, 0x98, 0x93, 0xc4, 0x20, 0xf6, 0x1f, 0x5b, + 0x70, 0xca, 0x90, 0xea, 0x11, 0x98, 0xe6, 0x41, 0xda, 0x34, 0x5f, 0xc9, 0x6d, 0x3c, 0xf7, 0xb1, + 0xcd, 0xbf, 0x64, 0xc1, 0x79, 0x03, 0x6b, 0xcd, 0x49, 0xdc, 0x9d, 0x2b, 0xfb, 0xad, 0x88, 0xc4, + 0xd4, 0x9d, 0x46, 0x2f, 0x18, 0x7a, 0xab, 0x3a, 0x2e, 0x28, 0x14, 0x6f, 0x90, 0x0e, 0x57, 0x62, + 0x2f, 0x43, 0x99, 0x0f, 0xce, 0x30, 0x12, 0x3d, 0xae, 0xde, 0x6d, 0x5d, 0xb4, 0x63, 0x85, 0x81, + 0x6c, 0x18, 0x65, 0xca, 0x89, 0x4e, 0x56, 0xba, 0x0c, 0x01, 0xfd, 0x88, 0xb7, 0x59, 0x0b, 0x16, + 0x10, 0xfb, 0x7e, 0x81, 0xf9, 0x0a, 0x6a, 0x16, 0x92, 0x47, 0xe1, 0x68, 0x46, 0x29, 0xb5, 0xb5, + 0x91, 0x9f, 0x0e, 0x21, 0xfd, 0x9d, 0xcd, 0x77, 0x33, 0x9a, 0x0b, 0xe7, 0xca, 0xf5, 0x70, 0x87, + 0xf3, 0x0f, 0x0b, 0x30, 0x9b, 0x7e, 0xa0, 0x4b, 0xf1, 0x51, 0xef, 0xc6, 0x60, 0x94, 0xdd, 0x4f, + 0x30, 0xf0, 0xb1, 0x89, 0xd7, 0x47, 0x77, 0x14, 0x4e, 0x52, 0x77, 0x98, 0xaa, 0xad, 0x78, 0x84, + 0x6a, 0xbb, 0x0c, 0x13, 0xe1, 0x36, 0xd3, 0x17, 0xb5, 0x6b, 0x4e, 0xbc, 0xc3, 0x34, 0x77, 0x45, + 0x7b, 0x7b, 0xeb, 0x06, 0x0c, 0xa7, 0x30, 0x99, 0x16, 0xe2, 0xdf, 0xab, 0x94, 0xd1, 0x42, 0xe9, + 0xbe, 0xfd, 0xd3, 0x02, 0x3c, 0x93, 0xee, 0x5b, 0xad, 0xa5, 0x3f, 0x92, 0xd2, 0xd2, 0x1f, 0x30, + 0xb5, 0xf4, 0x83, 0x83, 0xd9, 0xe7, 0xfa, 0x3c, 0xf6, 0x7d, 0xa3, 0xc4, 0xd1, 0xb2, 0xea, 0x23, + 0xde, 0xaf, 0xf3, 0xe9, 0x3e, 0x7a, 0x70, 0x30, 0xfb, 0x42, 0x9f, 0x77, 0xcc, 0xac, 0xae, 0xef, + 0x83, 0xd1, 0x88, 0x38, 0x71, 0x18, 0x64, 0x3b, 0x1b, 0xb3, 0x56, 0x2c, 0xa0, 0xf6, 0x1f, 0x97, + 0xb3, 0x9d, 0xbd, 0xcc, 0xf7, 0xc9, 0xc2, 0x08, 0x79, 0x30, 0xc2, 0x2c, 0x6f, 0xae, 0x32, 0x6e, + 0x1c, 0x6f, 0x7a, 0x51, 0x4d, 0xad, 0x48, 0x57, 0xcb, 0xf4, 0xab, 0xd1, 0x26, 0xcc, 0x58, 0xa0, + 0x7d, 0x28, 0xbb, 0xd2, 0x20, 0x2e, 0xe4, 0xb1, 0x75, 0x24, 0xcc, 0x61, 0xcd, 0x71, 0x82, 0xaa, + 0x54, 0x65, 0x45, 0x2b, 0x6e, 0x88, 0x40, 0xb1, 0xe1, 0x25, 0xe2, 0xb3, 0x1e, 0xd3, 0xe5, 0x59, + 0xf6, 0x8c, 0x57, 0x1c, 0xa3, 0x7a, 0x7e, 0xd9, 0x4b, 0x30, 0xa5, 0x8f, 0x7e, 0xde, 0x82, 0xf1, + 0xd8, 0x6d, 0x6e, 0x44, 0xe1, 0x9e, 0x57, 0x23, 0x91, 0x30, 0x78, 0x8e, 0xa9, 0xb2, 0x36, 0x17, + 0xd7, 0x24, 0x41, 0xcd, 0x97, 0xbb, 0xa0, 0x1a, 0x82, 0x4d, 0xbe, 0xd4, 0x11, 0x78, 0x46, 0xbc, + 0xfb, 0x12, 0x71, 0x3d, 0xba, 0x44, 0x49, 0xbf, 0x87, 0x8d, 0x94, 0x63, 0x1b, 0x80, 0x4b, 0x6d, + 0x77, 0x97, 0xce, 0x37, 0x2d, 0xd0, 0x73, 0xf7, 0x0f, 0x66, 0x9f, 0x59, 0xec, 0xcd, 0x13, 0xf7, + 0x13, 0x86, 0x75, 0x58, 0xab, 0xed, 0xfb, 0x98, 0xbc, 0xd3, 0x26, 0x6c, 0x57, 0x23, 0x87, 0x0e, + 0xdb, 0xd0, 0x04, 0x33, 0x1d, 0x66, 0x40, 0xb0, 0xc9, 0x17, 0xbd, 0x03, 0xa3, 0x4d, 0x27, 0x89, + 0xbc, 0x7d, 0xb1, 0x95, 0x71, 0x4c, 0x93, 0x7c, 0x8d, 0xd1, 0xd2, 0xcc, 0xd9, 0x0a, 0xce, 0x1b, + 0xb1, 0x60, 0x84, 0x9a, 0x50, 0x6a, 0x92, 0xa8, 0x41, 0x66, 0xca, 0x79, 0x6c, 0xdb, 0xae, 0x51, + 0x52, 0x9a, 0x61, 0x85, 0x1a, 0x30, 0xac, 0x0d, 0x73, 0x2e, 0xe8, 0x6d, 0x28, 0xc7, 0xc4, 0x27, + 0x2e, 0x35, 0x41, 0x2a, 0x8c, 0xe3, 0x07, 0x07, 0x34, 0xc7, 0x9c, 0x6d, 0xe2, 0x6f, 0x8a, 0x47, + 0xf9, 0x04, 0x93, 0xff, 0xb0, 0x22, 0x69, 0xff, 0x77, 0x0b, 0x50, 0x5a, 0xc3, 0x3c, 0x02, 0x23, + 0xf0, 0x9d, 0xb4, 0x11, 0xb8, 0x9a, 0xa7, 0x69, 0xd0, 0xc7, 0x0e, 0xfc, 0x56, 0x19, 0x32, 0xba, + 0xf9, 0x26, 0x89, 0x13, 0x52, 0x7b, 0x4f, 0x9f, 0xbe, 0xa7, 0x4f, 0xdf, 0xd3, 0xa7, 0x4a, 0x9f, + 0x6e, 0x67, 0xf4, 0xe9, 0x1b, 0xc6, 0xac, 0xd7, 0x87, 0x90, 0x9f, 0x54, 0xa7, 0x94, 0xa6, 0x04, + 0x06, 0x02, 0xd5, 0x04, 0xd7, 0x37, 0xd7, 0x6f, 0xf6, 0x54, 0xa0, 0x9f, 0x4c, 0x2b, 0xd0, 0xe3, + 0xb2, 0x78, 0xe4, 0x2a, 0xf3, 0x57, 0xba, 0xbc, 0x0b, 0x1c, 0xfa, 0xbe, 0x17, 0x34, 0x6e, 0xb5, + 0x6a, 0x4e, 0x42, 0x36, 0x13, 0xd2, 0x42, 0xbf, 0x6c, 0xc1, 0xe9, 0x66, 0xda, 0xd7, 0x8c, 0xc5, + 0x96, 0xde, 0x47, 0x73, 0xd3, 0x76, 0x19, 0x67, 0xb6, 0x3a, 0x23, 0x34, 0xdf, 0xe9, 0x0c, 0x20, + 0xc6, 0x5d, 0xb2, 0xa0, 0xb7, 0xa1, 0xd2, 0x74, 0xf6, 0xb9, 0xc4, 0x42, 0x07, 0xf5, 0xf7, 0x3a, + 0xdb, 0x89, 0xe7, 0xcf, 0xf1, 0x83, 0xda, 0xb9, 0x95, 0x20, 0x59, 0x8f, 0x36, 0x93, 0xc8, 0x0b, + 0x1a, 0x7c, 0x23, 0x67, 0x4d, 0x92, 0xc1, 0x9a, 0xa2, 0xfd, 0x0f, 0x2d, 0x78, 0xf1, 0xd0, 0x3e, + 0x8a, 0x9c, 0x84, 0x34, 0x3a, 0xe8, 0x73, 0x16, 0x94, 0xe2, 0x84, 0xb4, 0x64, 0xe7, 0xbc, 0x9d, + 0xe7, 0x52, 0xd0, 0xf5, 0x59, 0xf4, 0xda, 0x40, 0xff, 0xc5, 0x98, 0xb3, 0xb6, 0xef, 0x8f, 0x64, + 0xd7, 0x40, 0x76, 0x86, 0x77, 0x09, 0xa0, 0x11, 0x6e, 0x91, 0x66, 0xcb, 0xa7, 0x7d, 0x64, 0xb1, + 0x8d, 0x60, 0xe5, 0x67, 0x2f, 0x2b, 0x08, 0x36, 0xb0, 0xd0, 0xdf, 0xb4, 0x00, 0x1a, 0x72, 0xae, + 0xc9, 0xf5, 0xed, 0x56, 0x9e, 0x2f, 0xa5, 0x67, 0xb2, 0x96, 0x45, 0x31, 0xc4, 0x06, 0x73, 0xda, + 0xb7, 0xe5, 0x44, 0x8a, 0xcf, 0x35, 0xfe, 0x56, 0x9e, 0x92, 0xc8, 0x97, 0xd6, 0x4b, 0xbd, 0xea, + 0x12, 0xc5, 0x17, 0xfd, 0x0d, 0x0b, 0x20, 0xee, 0x04, 0xee, 0x46, 0xe8, 0x7b, 0x6e, 0x47, 0x2c, + 0x04, 0xb7, 0x73, 0xdd, 0x0b, 0x50, 0xd4, 0xab, 0x53, 0xb4, 0x37, 0xf4, 0x7f, 0x6c, 0x70, 0x46, + 0x9f, 0x86, 0x72, 0x2c, 0x46, 0x9d, 0x50, 0xfd, 0x5b, 0xf9, 0xee, 0x48, 0x70, 0xda, 0x42, 0x6b, + 0x88, 0x7f, 0x58, 0xf1, 0xb4, 0x7f, 0xb7, 0x90, 0xda, 0xda, 0x54, 0x9b, 0x18, 0x6c, 0xc8, 0xb8, + 0xd2, 0x4f, 0x94, 0xf3, 0x20, 0xd7, 0x21, 0xa3, 0xbc, 0x50, 0x3d, 0x64, 0x54, 0x53, 0x8c, 0x0d, + 0xe6, 0x74, 0xbd, 0x9c, 0x76, 0xb2, 0x5b, 0x25, 0x62, 0x14, 0xe7, 0x3a, 0x35, 0xbb, 0x37, 0xa2, + 0x9f, 0x15, 0xa2, 0x4d, 0x77, 0x81, 0x70, 0xb7, 0x48, 0xf6, 0x77, 0xd2, 0xdb, 0xa9, 0xc6, 0x07, + 0x18, 0x60, 0xab, 0xf8, 0xef, 0x5a, 0x30, 0x19, 0x99, 0xba, 0x41, 0x28, 0x40, 0xe7, 0x04, 0x95, + 0x8f, 0x18, 0x1d, 0xd3, 0xf7, 0x0f, 0x66, 0x27, 0x53, 0x20, 0x9c, 0x16, 0xc5, 0xfe, 0xac, 0x05, + 0x33, 0xfd, 0x06, 0x38, 0x22, 0xf0, 0x1c, 0x55, 0xe1, 0x74, 0x5d, 0x54, 0x87, 0xa6, 0xeb, 0xc1, + 0x12, 0xf1, 0x89, 0xda, 0xc4, 0x2a, 0x57, 0x5f, 0x14, 0xaf, 0xfc, 0xdc, 0x46, 0x7f, 0x54, 0x7c, + 0x18, 0x1d, 0xfb, 0xd7, 0x0b, 0xd9, 0xde, 0x55, 0x0a, 0xee, 0xeb, 0x56, 0x97, 0x67, 0xf0, 0xd1, + 0x93, 0x50, 0x2a, 0xcc, 0x87, 0x50, 0x67, 0xa7, 0xfd, 0x71, 0x1e, 0xe3, 0xe1, 0x8c, 0xfd, 0xef, + 0x47, 0xe0, 0x10, 0xc9, 0xd4, 0xf6, 0xbb, 0xd5, 0x6f, 0xfb, 0x7d, 0xf8, 0x1d, 0xfd, 0x2f, 0x5a, + 0x30, 0xea, 0x53, 0x23, 0x85, 0x6f, 0x31, 0x8f, 0x5f, 0xaa, 0x9d, 0x54, 0xdf, 0x73, 0x5b, 0x28, + 0xe6, 0x07, 0x84, 0x6a, 0x7b, 0x8a, 0x37, 0x62, 0x21, 0x03, 0xfa, 0x86, 0x05, 0xe3, 0x4e, 0x10, + 0x84, 0x89, 0x88, 0x58, 0xe1, 0x11, 0x1f, 0xde, 0x89, 0xc9, 0xb4, 0xa0, 0x79, 0x71, 0xc1, 0xf4, + 0x7e, 0xad, 0x86, 0x60, 0x53, 0x24, 0x34, 0x07, 0x50, 0xf7, 0x02, 0xc7, 0xf7, 0xde, 0xa5, 0xce, + 0x56, 0x89, 0xed, 0xcb, 0xb3, 0x65, 0xe2, 0xaa, 0x6a, 0xc5, 0x06, 0xc6, 0xf9, 0xbf, 0x0e, 0xe3, + 0xc6, 0x9b, 0xf7, 0x38, 0xd7, 0x3c, 0x6b, 0x9e, 0x6b, 0x56, 0x8c, 0xe3, 0xc8, 0xf3, 0x6f, 0xc0, + 0xe9, 0xac, 0x80, 0xc3, 0x3c, 0x6f, 0xff, 0xc6, 0x68, 0xd6, 0xae, 0xdc, 0x22, 0x51, 0x93, 0x8a, + 0xf6, 0x9e, 0x93, 0xfa, 0x9e, 0x93, 0xfa, 0x9e, 0x93, 0x2a, 0xff, 0xd8, 0xbf, 0x53, 0x82, 0x94, + 0x95, 0xc0, 0xa5, 0xfb, 0x61, 0x18, 0x8b, 0x48, 0x2b, 0xbc, 0x85, 0x57, 0x85, 0xc6, 0xd5, 0x91, + 0x9e, 0xbc, 0x19, 0x4b, 0x38, 0xd5, 0xcc, 0x2d, 0x27, 0xd9, 0x11, 0x2a, 0x57, 0x69, 0xe6, 0x0d, + 0x27, 0xd9, 0xc1, 0x0c, 0x82, 0xde, 0x80, 0xa9, 0xc4, 0x89, 0x1a, 0x24, 0xc1, 0x64, 0x8f, 0x75, + 0x82, 0xd8, 0xf1, 0x7f, 0x5a, 0xe0, 0x4e, 0x6d, 0xa5, 0xa0, 0x38, 0x83, 0x8d, 0xde, 0x81, 0x91, + 0x1d, 0xe2, 0x37, 0x85, 0x17, 0xbd, 0x99, 0x9f, 0x46, 0x64, 0xef, 0x7a, 0x8d, 0xf8, 0x4d, 0x3e, + 0x5f, 0xe9, 0x2f, 0xcc, 0x58, 0xd1, 0xaf, 0x53, 0xd9, 0x6d, 0xc7, 0x49, 0xd8, 0xf4, 0xde, 0x95, + 0xbe, 0xf5, 0x47, 0x73, 0x66, 0x7c, 0x43, 0xd2, 0xe7, 0xae, 0x9f, 0xfa, 0x8b, 0x35, 0x67, 0x26, + 0x47, 0xcd, 0x8b, 0x98, 0xaf, 0xdc, 0x99, 0x81, 0x13, 0x91, 0x63, 0x49, 0xd2, 0xe7, 0x72, 0xa8, + 0xbf, 0x58, 0x73, 0x46, 0x1d, 0x18, 0x6d, 0xf9, 0xed, 0x86, 0x17, 0xcc, 0x8c, 0x33, 0x19, 0x6e, + 0xe5, 0x2c, 0xc3, 0x06, 0x23, 0xce, 0x77, 0x38, 0xf8, 0x6f, 0x2c, 0x18, 0xa2, 0x17, 0xa1, 0xe4, + 0xee, 0x38, 0x51, 0x32, 0x33, 0xc1, 0x06, 0x8d, 0xf2, 0x3a, 0x17, 0x69, 0x23, 0xe6, 0x30, 0xfb, + 0x57, 0x0a, 0x69, 0xeb, 0x21, 0xfd, 0x62, 0x7c, 0x38, 0xbb, 0xed, 0x28, 0x96, 0xae, 0xa7, 0x31, + 0x9c, 0x59, 0x33, 0x96, 0x70, 0xf4, 0x59, 0x0b, 0xc6, 0xee, 0xc6, 0x61, 0x10, 0x90, 0x44, 0x68, + 0xea, 0xdb, 0x39, 0xbf, 0xeb, 0x75, 0x4e, 0x5d, 0xcb, 0x20, 0x1a, 0xb0, 0xe4, 0x4b, 0xc5, 0x25, + 0xfb, 0xae, 0xdf, 0xae, 0x75, 0x9d, 0x51, 0x5e, 0xe1, 0xcd, 0x58, 0xc2, 0x29, 0xaa, 0x17, 0x70, + 0xd4, 0x91, 0x34, 0xea, 0x4a, 0x20, 0x50, 0x05, 0xdc, 0xfe, 0xa7, 0x25, 0x38, 0xd7, 0x73, 0xf4, + 0xd3, 0x75, 0x9d, 0xad, 0x9c, 0x57, 0x3d, 0x9f, 0xc8, 0xf8, 0x5a, 0xb6, 0xae, 0xdf, 0x56, 0xad, + 0xd8, 0xc0, 0x40, 0x3f, 0x03, 0xd0, 0x72, 0x22, 0xa7, 0x49, 0xc4, 0x7a, 0x56, 0x3c, 0xfe, 0xf2, + 0x49, 0xe5, 0xd8, 0x90, 0x34, 0xb5, 0x6b, 0xa5, 0x9a, 0x62, 0x6c, 0xb0, 0x44, 0x1f, 0x82, 0xf1, + 0x88, 0xf8, 0xc4, 0x89, 0x59, 0x00, 0x5a, 0x36, 0x9a, 0x16, 0x6b, 0x10, 0x36, 0xf1, 0xd0, 0xfb, + 0x54, 0x4c, 0xc1, 0x48, 0xfa, 0xa4, 0x30, 0x1d, 0x57, 0x80, 0xbe, 0x62, 0xc1, 0x54, 0xdd, 0xf3, + 0x89, 0xe6, 0x2e, 0x62, 0x5f, 0xd7, 0x8f, 0xff, 0x92, 0x57, 0x4d, 0xba, 0x5a, 0x05, 0xa6, 0x9a, + 0x63, 0x9c, 0x61, 0x4f, 0x3f, 0xf3, 0x1e, 0x89, 0x98, 0xee, 0x1c, 0x4d, 0x7f, 0xe6, 0xdb, 0xbc, + 0x19, 0x4b, 0x38, 0x5a, 0x80, 0x53, 0x2d, 0x27, 0x8e, 0x17, 0x23, 0x52, 0x23, 0x41, 0xe2, 0x39, + 0x3e, 0x8f, 0x4c, 0x2d, 0xeb, 0xc8, 0xb4, 0x8d, 0x34, 0x18, 0x67, 0xf1, 0xd1, 0xc7, 0xe0, 0x19, + 0xaf, 0x11, 0x84, 0x11, 0x59, 0xf3, 0xe2, 0xd8, 0x0b, 0x1a, 0x7a, 0x18, 0x30, 0x55, 0x58, 0xae, + 0xce, 0x0a, 0x52, 0xcf, 0xac, 0xf4, 0x46, 0xc3, 0xfd, 0x9e, 0x47, 0x2f, 0x43, 0x39, 0xde, 0xf5, + 0x5a, 0x8b, 0x51, 0x2d, 0x66, 0xdb, 0x89, 0x65, 0xbd, 0xe1, 0xb1, 0x29, 0xda, 0xb1, 0xc2, 0xb0, + 0x7f, 0xa9, 0x90, 0xf6, 0xdf, 0xcc, 0xf9, 0x83, 0x62, 0x3a, 0x4b, 0x92, 0xdb, 0x4e, 0x24, 0xfd, + 0xfc, 0x63, 0xc6, 0xb6, 0x0a, 0xba, 0xb7, 0x9d, 0xc8, 0x9c, 0x6f, 0x8c, 0x01, 0x96, 0x9c, 0xd0, + 0x5d, 0x18, 0x49, 0x7c, 0x27, 0xa7, 0x60, 0x78, 0x83, 0xa3, 0x76, 0xad, 0x57, 0x17, 0x62, 0xcc, + 0x78, 0xa0, 0xe7, 0xa9, 0x7d, 0xba, 0x2d, 0x03, 0x60, 0x84, 0x49, 0xb9, 0x1d, 0x63, 0xd6, 0x6a, + 0xff, 0xef, 0xd1, 0x1e, 0x2a, 0x4f, 0x2d, 0x22, 0xe8, 0x12, 0x00, 0x75, 0x75, 0x36, 0x22, 0x52, + 0xf7, 0xf6, 0xc5, 0x22, 0xae, 0xa6, 0xd5, 0x4d, 0x05, 0xc1, 0x06, 0x96, 0x7c, 0x66, 0xb3, 0x5d, + 0xa7, 0xcf, 0x14, 0xba, 0x9f, 0xe1, 0x10, 0x6c, 0x60, 0xa1, 0xd7, 0x60, 0xd4, 0x6b, 0x3a, 0x0d, + 0x15, 0xa7, 0xf3, 0x3c, 0x9d, 0x4f, 0x2b, 0xac, 0xe5, 0xc1, 0xc1, 0xec, 0x94, 0x12, 0x88, 0x35, + 0x61, 0x81, 0x8b, 0x7e, 0xdd, 0x82, 0x09, 0x37, 0x6c, 0x36, 0xc3, 0x80, 0x3b, 0x08, 0xc2, 0xdb, + 0xb9, 0x7b, 0x52, 0x4b, 0xec, 0xdc, 0xa2, 0xc1, 0x8c, 0xbb, 0x3b, 0x2a, 0x8e, 0xc3, 0x04, 0xe1, + 0x94, 0x54, 0xe6, 0xb4, 0x2b, 0x1d, 0x31, 0xed, 0xfe, 0x85, 0x05, 0xd3, 0xfc, 0x59, 0xc3, 0x6f, + 0x11, 0x01, 0xea, 0xe1, 0x09, 0xbf, 0x56, 0x97, 0x2b, 0xa7, 0xf6, 0x7f, 0xba, 0xe0, 0xb8, 0x5b, + 0x48, 0xb4, 0x0c, 0xd3, 0xf5, 0x30, 0x72, 0x89, 0xd9, 0x11, 0x42, 0x67, 0x28, 0x42, 0x57, 0xb3, + 0x08, 0xb8, 0xfb, 0x19, 0x74, 0x1b, 0x9e, 0x36, 0x1a, 0xcd, 0x7e, 0xe0, 0x6a, 0xe3, 0x82, 0xa0, + 0xf6, 0xf4, 0xd5, 0x9e, 0x58, 0xb8, 0xcf, 0xd3, 0xe7, 0x3f, 0x02, 0xd3, 0x5d, 0xdf, 0x6f, 0x28, + 0x6f, 0x72, 0x09, 0x9e, 0xee, 0xdd, 0x53, 0x43, 0xf9, 0x94, 0xbf, 0x6c, 0xa5, 0x03, 0x48, 0x0c, + 0xcb, 0x65, 0x80, 0xfd, 0x09, 0x07, 0x8a, 0x24, 0xd8, 0x13, 0x8a, 0xe3, 0xea, 0xf1, 0x46, 0xc4, + 0x95, 0x60, 0x8f, 0x7f, 0x68, 0xe6, 0x84, 0x5d, 0x09, 0xf6, 0x30, 0xa5, 0x6d, 0xff, 0xed, 0xd1, + 0x54, 0x04, 0xe2, 0xa6, 0x0c, 0x7a, 0xe5, 0xee, 0x8f, 0x95, 0x77, 0xd0, 0x2b, 0x0f, 0x21, 0xd7, + 0xb1, 0x4d, 0xdc, 0xe3, 0x11, 0xec, 0xd0, 0x17, 0x2c, 0x96, 0xf2, 0x22, 0x23, 0x33, 0x85, 0x31, + 0x75, 0x32, 0x19, 0x38, 0x66, 0x22, 0x8d, 0x6c, 0xc4, 0x26, 0x77, 0x3a, 0x93, 0x5b, 0x3c, 0x78, + 0x3b, 0x6b, 0x52, 0xc9, 0xa4, 0x18, 0x09, 0x47, 0xfb, 0x3d, 0x36, 0xd9, 0x73, 0x48, 0x9b, 0x18, + 0x60, 0x5b, 0xfd, 0x1b, 0x16, 0x4c, 0xf3, 0x85, 0x73, 0xc9, 0xab, 0xd7, 0x49, 0x44, 0x02, 0x97, + 0x48, 0xd3, 0xe3, 0xce, 0xf1, 0x24, 0x90, 0x7e, 0xe7, 0x4a, 0x96, 0xbc, 0x9e, 0xe2, 0x5d, 0x20, + 0xdc, 0x2d, 0x0c, 0xaa, 0xc1, 0x88, 0x17, 0xd4, 0x43, 0xa1, 0xd8, 0xaa, 0xc7, 0x13, 0x6a, 0x25, + 0xa8, 0x87, 0x7a, 0xae, 0xd0, 0x7f, 0x98, 0x51, 0x47, 0xab, 0x70, 0x36, 0x12, 0xde, 0xdf, 0x35, + 0x2f, 0xa6, 0x26, 0xfc, 0xaa, 0xd7, 0xf4, 0x12, 0xa6, 0x94, 0x8a, 0xd5, 0x99, 0xfb, 0x07, 0xb3, + 0x67, 0x71, 0x0f, 0x38, 0xee, 0xf9, 0x94, 0xfd, 0x17, 0x15, 0xe8, 0xde, 0x08, 0x47, 0x3f, 0x0d, + 0x95, 0x48, 0xe5, 0xee, 0x58, 0x79, 0xc4, 0x4e, 0xc8, 0x3e, 0x16, 0x9b, 0xf0, 0x6a, 0xf7, 0x51, + 0x67, 0xe9, 0x68, 0x8e, 0xd4, 0x90, 0xa0, 0x5f, 0x5e, 0x4c, 0x8b, 0x1c, 0xc6, 0x97, 0xe0, 0xaa, + 0xf7, 0x56, 0x3b, 0x81, 0x8b, 0x19, 0x0f, 0x14, 0xc1, 0xe8, 0x0e, 0x71, 0xfc, 0x64, 0x27, 0x9f, + 0x6d, 0xa0, 0x6b, 0x8c, 0x56, 0x36, 0x6c, 0x94, 0xb7, 0x62, 0xc1, 0x09, 0xed, 0xc3, 0xd8, 0x0e, + 0xff, 0x08, 0x62, 0x6d, 0x5f, 0x3b, 0x6e, 0xe7, 0xa6, 0xbe, 0xac, 0x9e, 0xbf, 0xa2, 0x01, 0x4b, + 0x76, 0xec, 0x94, 0xcc, 0x38, 0x03, 0xe2, 0xd3, 0x27, 0xbf, 0x88, 0xd9, 0xc1, 0x0f, 0x80, 0x3e, + 0x05, 0x13, 0x11, 0x71, 0xc3, 0xc0, 0xf5, 0x7c, 0x52, 0x5b, 0x90, 0x5b, 0x3c, 0xc3, 0xc4, 0x53, + 0x9e, 0xa6, 0xf6, 0x09, 0x36, 0x68, 0xe0, 0x14, 0x45, 0xf4, 0x79, 0x0b, 0xa6, 0x54, 0xc0, 0x3f, + 0xfd, 0x20, 0x44, 0x6c, 0x92, 0xac, 0xe6, 0x94, 0x5e, 0xc0, 0x68, 0x56, 0x11, 0xf5, 0x50, 0xd2, + 0x6d, 0x38, 0xc3, 0x17, 0xbd, 0x05, 0x20, 0x43, 0x60, 0x17, 0x12, 0xb1, 0x63, 0x32, 0xcc, 0xab, + 0x4e, 0xf1, 0x80, 0x6b, 0x49, 0x01, 0x1b, 0xd4, 0xd0, 0x0d, 0x00, 0x3e, 0x6d, 0xb6, 0x3a, 0x2d, + 0xc2, 0xdc, 0x06, 0x1d, 0x10, 0x0b, 0x9b, 0x0a, 0xf2, 0xe0, 0x60, 0xb6, 0xdb, 0xc1, 0x65, 0x47, + 0x55, 0xc6, 0xe3, 0xe8, 0x27, 0x61, 0x2c, 0x6e, 0x37, 0x9b, 0x8e, 0xda, 0x4f, 0xc9, 0x31, 0x84, + 0x9b, 0xd3, 0xd5, 0x63, 0x53, 0x34, 0x60, 0xc9, 0x11, 0xdd, 0xa5, 0x8a, 0x2d, 0x16, 0x9e, 0x37, + 0x9b, 0x45, 0x7c, 0x6d, 0x1e, 0x67, 0xef, 0xf4, 0x61, 0xf1, 0xdc, 0x59, 0xdc, 0x03, 0xe7, 0xc1, + 0xc1, 0xec, 0xd3, 0xe9, 0xf6, 0xd5, 0x50, 0x04, 0x55, 0xf7, 0xa4, 0x69, 0x07, 0xe9, 0x83, 0x78, + 0x21, 0xc1, 0x6b, 0x30, 0x41, 0xf6, 0x13, 0x12, 0x05, 0x8e, 0x7f, 0x0b, 0xaf, 0x4a, 0x6f, 0x9f, + 0x0d, 0xb4, 0x2b, 0x46, 0x3b, 0x4e, 0x61, 0x21, 0x5b, 0x59, 0xf9, 0x05, 0x1d, 0x8d, 0xcf, 0xad, + 0x7c, 0x69, 0xd3, 0xdb, 0xff, 0xaf, 0x90, 0xb2, 0x3e, 0xb6, 0x22, 0x42, 0x50, 0x08, 0xa5, 0x20, + 0xac, 0x29, 0x05, 0x7b, 0x3d, 0x1f, 0x05, 0x7b, 0x33, 0xac, 0x19, 0x09, 0xac, 0xf4, 0x5f, 0x8c, + 0x39, 0x1f, 0x96, 0xe1, 0x27, 0x53, 0x21, 0x19, 0x40, 0x18, 0x5c, 0x79, 0x72, 0x56, 0x19, 0x7e, + 0xeb, 0x26, 0x23, 0x9c, 0xe6, 0x8b, 0x76, 0xa1, 0xb4, 0x13, 0xc6, 0x89, 0x3c, 0x5c, 0x3a, 0xa6, + 0xc5, 0x77, 0x2d, 0x8c, 0x13, 0xb6, 0x5c, 0xaa, 0xd7, 0xa6, 0x2d, 0x31, 0xe6, 0x3c, 0xec, 0x3f, + 0xb1, 0x52, 0x7b, 0x3b, 0x77, 0x58, 0x84, 0xca, 0x1e, 0x09, 0xe8, 0xdc, 0x31, 0x4f, 0x70, 0xff, + 0x5a, 0x26, 0x8c, 0xfc, 0xfd, 0xfd, 0xca, 0x09, 0xdc, 0xa3, 0x14, 0xe6, 0x18, 0x09, 0xe3, 0xb0, + 0xf7, 0x33, 0x56, 0x3a, 0xd0, 0x9f, 0x2f, 0x5e, 0x39, 0xe6, 0x9d, 0x1c, 0x99, 0x33, 0x60, 0xff, + 0xa2, 0x05, 0x63, 0x55, 0xc7, 0xdd, 0x0d, 0xeb, 0x75, 0xf4, 0x32, 0x94, 0x6b, 0xed, 0xc8, 0xcc, + 0x39, 0x50, 0x9b, 0x09, 0x4b, 0xa2, 0x1d, 0x2b, 0x0c, 0x3a, 0x86, 0xeb, 0x8e, 0x2b, 0xb3, 0x4f, + 0x8a, 0x7c, 0x0c, 0x5f, 0x65, 0x2d, 0x58, 0x40, 0xd0, 0x87, 0x60, 0xbc, 0xe9, 0xec, 0xcb, 0x87, + 0xb3, 0x1b, 0x4b, 0x6b, 0x1a, 0x84, 0x4d, 0x3c, 0xfb, 0xdf, 0x5a, 0x30, 0x53, 0x75, 0x62, 0xcf, + 0x5d, 0x68, 0x27, 0x3b, 0x55, 0x2f, 0xd9, 0x6e, 0xbb, 0xbb, 0x24, 0xe1, 0x29, 0x47, 0x54, 0xca, + 0x76, 0x4c, 0xa7, 0x92, 0x72, 0x0f, 0x94, 0x94, 0xb7, 0x44, 0x3b, 0x56, 0x18, 0xe8, 0x5d, 0x18, + 0x6f, 0x39, 0x71, 0x7c, 0x2f, 0x8c, 0x6a, 0x98, 0xd4, 0xf3, 0x49, 0xf8, 0xdb, 0x24, 0x6e, 0x44, + 0x12, 0x4c, 0xea, 0xe2, 0x2c, 0x40, 0xd3, 0xc7, 0x26, 0x33, 0xfb, 0xb7, 0x2a, 0x30, 0x26, 0x0e, + 0x32, 0x06, 0x4e, 0xa4, 0x92, 0x8e, 0x4f, 0xa1, 0xaf, 0xe3, 0x13, 0xc3, 0xa8, 0xcb, 0xca, 0x4e, + 0x08, 0xeb, 0xe3, 0x46, 0x2e, 0x27, 0x5f, 0xbc, 0x92, 0x85, 0x16, 0x8b, 0xff, 0xc7, 0x82, 0x15, + 0xfa, 0xaa, 0x05, 0xa7, 0xdc, 0x30, 0x08, 0x88, 0xab, 0x97, 0xc6, 0x91, 0x3c, 0xce, 0xb2, 0x17, + 0xd3, 0x44, 0xf5, 0xae, 0x5a, 0x06, 0x80, 0xb3, 0xec, 0xd1, 0xeb, 0x30, 0xc9, 0xfb, 0xec, 0x76, + 0x6a, 0x4b, 0x41, 0xe7, 0x0b, 0x9b, 0x40, 0x9c, 0xc6, 0x45, 0x73, 0x7c, 0x6b, 0x46, 0x64, 0xe6, + 0x8e, 0xea, 0x2d, 0x5a, 0x23, 0x27, 0xd7, 0xc0, 0x40, 0x11, 0xa0, 0x88, 0xd4, 0x23, 0x12, 0xef, + 0x88, 0x83, 0x1e, 0xb6, 0x2c, 0x8f, 0x3d, 0x5c, 0x46, 0x07, 0xee, 0xa2, 0x84, 0x7b, 0x50, 0x47, + 0xbb, 0xc2, 0x37, 0x28, 0xe7, 0xa1, 0x15, 0xc4, 0x67, 0xee, 0xeb, 0x22, 0xcc, 0x42, 0x29, 0xde, + 0x71, 0xa2, 0x1a, 0x33, 0x07, 0x8a, 0x3c, 0x70, 0x71, 0x93, 0x36, 0x60, 0xde, 0x8e, 0x96, 0xe0, + 0x74, 0x26, 0xdb, 0x39, 0x66, 0x0b, 0x7e, 0x59, 0x87, 0xf6, 0x65, 0xf2, 0xa4, 0x63, 0xdc, 0xf5, + 0x84, 0xe9, 0x37, 0x8e, 0x1f, 0xe1, 0x37, 0x76, 0x54, 0x38, 0xc1, 0x04, 0xd3, 0xf8, 0x6f, 0xe6, + 0xd2, 0x01, 0x03, 0xc5, 0x0e, 0x7c, 0x29, 0x13, 0x3b, 0x30, 0xc9, 0x04, 0xb8, 0x9d, 0x8f, 0x00, + 0xc3, 0x07, 0x0a, 0x3c, 0xce, 0x83, 0xff, 0xbf, 0xb0, 0x40, 0x7e, 0xd7, 0x45, 0xc7, 0xdd, 0x21, + 0x74, 0xc8, 0xa0, 0x37, 0x60, 0x4a, 0x79, 0x5e, 0x8b, 0x61, 0x3b, 0xe0, 0x67, 0xfe, 0x45, 0xbd, + 0xfd, 0x8e, 0x53, 0x50, 0x9c, 0xc1, 0x46, 0xf3, 0x50, 0xa1, 0xfd, 0xc4, 0x1f, 0xe5, 0xab, 0x87, + 0xf2, 0xee, 0x16, 0x36, 0x56, 0xc4, 0x53, 0x1a, 0x07, 0x85, 0x30, 0xed, 0x3b, 0x71, 0xc2, 0x24, + 0xa0, 0x8e, 0xd8, 0x43, 0xe6, 0x53, 0xb1, 0x62, 0x0f, 0xab, 0x59, 0x42, 0xb8, 0x9b, 0xb6, 0xfd, + 0x9d, 0x11, 0x98, 0x4c, 0x69, 0xc6, 0x21, 0x97, 0x9d, 0x97, 0xa1, 0x2c, 0x57, 0x82, 0x6c, 0x72, + 0xa6, 0x5a, 0x2e, 0x14, 0x06, 0x5d, 0x26, 0xb7, 0x89, 0x13, 0x91, 0x88, 0xe5, 0x91, 0x67, 0x97, + 0xc9, 0xaa, 0x06, 0x61, 0x13, 0x8f, 0x29, 0xe5, 0xc4, 0x8f, 0x17, 0x7d, 0x8f, 0x04, 0x09, 0x17, + 0x33, 0x1f, 0xa5, 0xbc, 0xb5, 0xba, 0x69, 0x12, 0xd5, 0x4a, 0x39, 0x03, 0xc0, 0x59, 0xf6, 0xe8, + 0xe7, 0x2c, 0x98, 0x74, 0xee, 0xc5, 0xba, 0x36, 0x92, 0x88, 0x12, 0x38, 0xe6, 0x22, 0x95, 0x2a, + 0xb7, 0xc4, 0x03, 0xd5, 0x52, 0x4d, 0x38, 0xcd, 0x14, 0x7d, 0xdd, 0x02, 0x44, 0xf6, 0x89, 0x2b, + 0xe3, 0x18, 0x84, 0x2c, 0xa3, 0x79, 0x38, 0x28, 0x57, 0xba, 0xe8, 0x72, 0xad, 0xde, 0xdd, 0x8e, + 0x7b, 0xc8, 0x60, 0xff, 0xab, 0xa2, 0x9a, 0x50, 0x3a, 0x74, 0xc6, 0x31, 0xa2, 0xc2, 0xad, 0x87, + 0x8f, 0x0a, 0xd7, 0x67, 0x3f, 0x5d, 0x91, 0xe1, 0xe9, 0x88, 0xdb, 0xc2, 0x63, 0x8a, 0xb8, 0xfd, + 0x9c, 0x95, 0x4a, 0x43, 0x1e, 0xbf, 0xf4, 0x56, 0xbe, 0x61, 0x3b, 0x73, 0xfc, 0xe4, 0x31, 0xa3, + 0xdd, 0xd3, 0xc7, 0x91, 0x54, 0x9b, 0x1a, 0x68, 0x43, 0x69, 0xc3, 0xff, 0x54, 0x84, 0x71, 0x63, + 0x25, 0xed, 0x69, 0x16, 0x59, 0x4f, 0x98, 0x59, 0x54, 0x18, 0xc2, 0x2c, 0xfa, 0x19, 0xa8, 0xb8, + 0x52, 0xcb, 0xe7, 0x53, 0x88, 0x2b, 0xbb, 0x76, 0x68, 0x45, 0xaf, 0x9a, 0xb0, 0xe6, 0x89, 0x96, + 0x53, 0x31, 0xbe, 0x62, 0x85, 0x18, 0x61, 0x2b, 0x44, 0xaf, 0x20, 0x5c, 0xb1, 0x52, 0x74, 0x3f, + 0x83, 0x5e, 0xa5, 0x9e, 0x95, 0x27, 0xde, 0x4b, 0x06, 0xd7, 0x31, 0x73, 0x7d, 0x61, 0x63, 0x45, + 0x36, 0x63, 0x13, 0xc7, 0xfe, 0x8e, 0xa5, 0x3e, 0xee, 0x23, 0xc8, 0x33, 0xbb, 0x9b, 0xce, 0x33, + 0xbb, 0x92, 0x4b, 0x37, 0xf7, 0x49, 0x30, 0xbb, 0x09, 0x63, 0x8b, 0x61, 0xb3, 0xe9, 0x04, 0x35, + 0xf4, 0x43, 0x30, 0xe6, 0xf2, 0x9f, 0x62, 0xab, 0x62, 0x9c, 0x1a, 0x5f, 0x02, 0x8a, 0x25, 0x0c, + 0x3d, 0x0f, 0x23, 0x4e, 0xd4, 0x90, 0xdb, 0x13, 0xec, 0xac, 0x74, 0x21, 0x6a, 0xc4, 0x98, 0xb5, + 0xda, 0x5f, 0x2b, 0x00, 0x2c, 0x86, 0xcd, 0x96, 0x13, 0x91, 0xda, 0x56, 0xf8, 0xde, 0x99, 0x08, + 0xf7, 0x5a, 0xbf, 0x68, 0x01, 0xa2, 0xbd, 0x12, 0x06, 0x24, 0x48, 0x54, 0xb0, 0x01, 0x35, 0x76, + 0x5c, 0xd9, 0x2a, 0x2c, 0x07, 0x3d, 0x07, 0x24, 0x00, 0x6b, 0x9c, 0x01, 0x5c, 0xc0, 0x17, 0xa5, + 0x82, 0x2a, 0xa6, 0x63, 0x78, 0x98, 0x5a, 0x13, 0xfa, 0xca, 0xfe, 0xed, 0x02, 0x3c, 0xcd, 0xd7, + 0x9c, 0x35, 0x27, 0x70, 0x1a, 0xa4, 0x49, 0xa5, 0x1a, 0xf4, 0x74, 0xcd, 0xa5, 0xbe, 0x87, 0x27, + 0x43, 0x76, 0x8e, 0x3b, 0x38, 0xf9, 0xa0, 0xe2, 0xc3, 0x68, 0x25, 0xf0, 0x12, 0xcc, 0x88, 0xa3, + 0x18, 0xca, 0xb2, 0xb4, 0xa2, 0x50, 0x36, 0x39, 0x31, 0x52, 0xf3, 0x4e, 0x2c, 0x0c, 0x04, 0x2b, + 0x46, 0xd4, 0x32, 0xf3, 0x43, 0x77, 0x17, 0x93, 0x56, 0xc8, 0x14, 0x8b, 0x11, 0x31, 0xb1, 0x2a, + 0xda, 0xb1, 0xc2, 0xb0, 0x7f, 0xdb, 0x82, 0xac, 0xca, 0x35, 0xaa, 0x11, 0x58, 0x87, 0x55, 0x23, + 0x18, 0xa6, 0x60, 0xc0, 0x4f, 0xc0, 0xb8, 0x93, 0xd0, 0x55, 0x92, 0xfb, 0x95, 0xc5, 0x87, 0xdb, + 0xee, 0x5d, 0x0b, 0x6b, 0x5e, 0xdd, 0x63, 0xfe, 0xa4, 0x49, 0xce, 0xfe, 0xf3, 0x11, 0x98, 0xee, + 0x8a, 0xb3, 0x44, 0x97, 0x61, 0xc2, 0x15, 0xc3, 0xa3, 0x85, 0x49, 0x5d, 0xbc, 0x8c, 0x71, 0x8c, + 0xaf, 0x61, 0x38, 0x85, 0x39, 0xc0, 0x00, 0x5d, 0x81, 0x33, 0x11, 0xf5, 0x64, 0xdb, 0x64, 0xa1, + 0x9e, 0x90, 0x68, 0x93, 0xb8, 0x61, 0x50, 0xe3, 0xd5, 0x36, 0x8a, 0xd5, 0x67, 0xee, 0x1f, 0xcc, + 0x9e, 0xc1, 0xdd, 0x60, 0xdc, 0xeb, 0x19, 0xd4, 0x82, 0x49, 0xdf, 0x34, 0x72, 0x84, 0x85, 0xfb, + 0x50, 0xf6, 0x91, 0x5a, 0x04, 0x53, 0xcd, 0x38, 0xcd, 0x20, 0x6d, 0x29, 0x95, 0x1e, 0x93, 0xa5, + 0xf4, 0xb3, 0xda, 0x52, 0xe2, 0x67, 0x83, 0x1f, 0xcf, 0x39, 0xce, 0xf6, 0xa4, 0x4d, 0xa5, 0x37, + 0xa1, 0x2c, 0x8f, 0xd5, 0x07, 0xd0, 0x37, 0x2f, 0xa6, 0xe8, 0xf4, 0xd1, 0x68, 0x0f, 0x0a, 0xd0, + 0xc3, 0xca, 0xa6, 0xf3, 0x4c, 0x2f, 0x69, 0xa9, 0x79, 0x36, 0xdc, 0xb2, 0x86, 0xf6, 0x79, 0x48, + 0x01, 0xb7, 0x4c, 0x3f, 0x96, 0xb7, 0x97, 0xa0, 0xa3, 0x0c, 0x54, 0x2d, 0x1f, 0x19, 0x69, 0x80, + 0x2e, 0x01, 0x68, 0x4b, 0x44, 0x44, 0xd3, 0xa9, 0xe3, 0x30, 0x6d, 0xb0, 0x60, 0x03, 0x8b, 0x3a, + 0x8d, 0x5e, 0x10, 0x27, 0x8e, 0xef, 0x5f, 0xf3, 0x82, 0x44, 0xec, 0x7e, 0xa9, 0x55, 0x6a, 0x45, + 0x83, 0xb0, 0x89, 0x77, 0xfe, 0xc3, 0xc6, 0x77, 0x19, 0xe6, 0x7b, 0xee, 0xc0, 0xb3, 0xcb, 0x5e, + 0xa2, 0x62, 0x40, 0xd5, 0x38, 0xa2, 0x86, 0x86, 0x0a, 0x5a, 0xb6, 0xfa, 0x06, 0x2d, 0x1b, 0x31, + 0x98, 0x85, 0x74, 0xc8, 0x68, 0x36, 0x06, 0xd3, 0xbe, 0x0c, 0x67, 0x97, 0xbd, 0xe4, 0xaa, 0xe7, + 0x93, 0x21, 0x99, 0xd8, 0xbf, 0x35, 0x02, 0x13, 0x66, 0x50, 0xfd, 0x30, 0x71, 0xd7, 0x5f, 0xa6, + 0xb6, 0x84, 0x78, 0x3b, 0x4f, 0x9d, 0x73, 0xdc, 0x39, 0x76, 0x84, 0x7f, 0xef, 0x1e, 0x33, 0xcc, + 0x09, 0xcd, 0x13, 0x9b, 0x02, 0xa0, 0x7b, 0x50, 0xaa, 0xb3, 0x18, 0xc1, 0x62, 0x1e, 0x27, 0xae, + 0xbd, 0x7a, 0x54, 0x4f, 0x33, 0x1e, 0x65, 0xc8, 0xf9, 0xd1, 0x15, 0x32, 0x4a, 0x47, 0x96, 0x2b, + 0x45, 0xa5, 0x62, 0xca, 0x15, 0x46, 0x3f, 0x55, 0x5f, 0x7a, 0x08, 0x55, 0x9f, 0x52, 0xbc, 0xa3, + 0x8f, 0x47, 0xf1, 0xda, 0x5f, 0x2c, 0xc0, 0xd4, 0x72, 0xd0, 0xde, 0x58, 0xde, 0x68, 0x6f, 0xfb, + 0x9e, 0x7b, 0x83, 0x74, 0xa8, 0x72, 0xda, 0x25, 0x9d, 0x95, 0x25, 0x31, 0x86, 0x54, 0xaf, 0xdd, + 0xa0, 0x8d, 0x98, 0xc3, 0xe8, 0x74, 0xac, 0x7b, 0x41, 0x83, 0x44, 0xad, 0xc8, 0x13, 0xbb, 0x5a, + 0xc6, 0x74, 0xbc, 0xaa, 0x41, 0xd8, 0xc4, 0xa3, 0xb4, 0xc3, 0x7b, 0x01, 0x89, 0xb2, 0xa6, 0xdc, + 0x3a, 0x6d, 0xc4, 0x1c, 0x46, 0x91, 0x92, 0xa8, 0x1d, 0x27, 0xe2, 0x73, 0x28, 0xa4, 0x2d, 0xda, + 0x88, 0x39, 0x8c, 0x8e, 0xf5, 0xb8, 0xbd, 0xcd, 0x8e, 0x74, 0x33, 0xc1, 0x75, 0x9b, 0xbc, 0x19, + 0x4b, 0x38, 0x45, 0xdd, 0x25, 0x9d, 0x25, 0xea, 0xd8, 0x64, 0xc2, 0x5f, 0x6f, 0xf0, 0x66, 0x2c, + 0xe1, 0xac, 0x06, 0x47, 0xba, 0x3b, 0xbe, 0xef, 0x6a, 0x70, 0xa4, 0xc5, 0xef, 0xe3, 0x22, 0xfd, + 0xaa, 0x05, 0x13, 0x66, 0x20, 0x06, 0x6a, 0x64, 0xac, 0xbc, 0xf5, 0xae, 0x7a, 0x4a, 0x3f, 0xd6, + 0xab, 0x06, 0x7c, 0xc3, 0x4b, 0xc2, 0x56, 0xfc, 0x0a, 0x09, 0x1a, 0x5e, 0x40, 0xd8, 0xd1, 0x1f, + 0x0f, 0xe0, 0x48, 0x45, 0x79, 0x2c, 0x86, 0x35, 0xf2, 0x10, 0x66, 0xa2, 0x7d, 0x07, 0xa6, 0xbb, + 0x62, 0x9e, 0x07, 0x58, 0x5c, 0x8f, 0x4c, 0x29, 0xb1, 0x31, 0x8c, 0x53, 0xc2, 0xeb, 0x2d, 0x1e, + 0x69, 0xb1, 0x08, 0xd3, 0xdc, 0x00, 0xa0, 0x9c, 0x36, 0xdd, 0x1d, 0xd2, 0x54, 0x71, 0xec, 0x6c, + 0x0b, 0xf5, 0x76, 0x16, 0x88, 0xbb, 0xf1, 0xed, 0x2f, 0x59, 0x30, 0x99, 0x0a, 0x43, 0xcf, 0xc9, + 0x0c, 0x60, 0x33, 0x2d, 0x64, 0x71, 0x41, 0x91, 0x17, 0xf0, 0x53, 0xb0, 0xb2, 0x31, 0xd3, 0x34, + 0x08, 0x9b, 0x78, 0xf6, 0x2f, 0x16, 0xa0, 0x2c, 0x8f, 0x7d, 0x07, 0x10, 0xe5, 0x0b, 0x16, 0x4c, + 0xaa, 0x6d, 0x6b, 0xb6, 0x1f, 0xc2, 0x07, 0xe3, 0xcd, 0xe3, 0x1f, 0x3c, 0xab, 0xe0, 0xb1, 0xa0, + 0x1e, 0x6a, 0x9b, 0x14, 0x9b, 0xcc, 0x70, 0x9a, 0x37, 0xba, 0x0d, 0x10, 0x77, 0xe2, 0x84, 0x34, + 0x8d, 0x9d, 0x19, 0xdb, 0x98, 0x71, 0x73, 0x6e, 0x18, 0x11, 0x3a, 0xbf, 0x6e, 0x86, 0x35, 0xb2, + 0xa9, 0x30, 0xb5, 0x11, 0xa1, 0xdb, 0xb0, 0x41, 0xc9, 0xfe, 0x27, 0x05, 0x38, 0x9d, 0x15, 0x09, + 0x7d, 0x1c, 0x26, 0x24, 0x77, 0xa3, 0x9e, 0xbd, 0x3c, 0xeb, 0x9e, 0xc0, 0x06, 0xec, 0xc1, 0xc1, + 0xec, 0x6c, 0xf7, 0x7d, 0x02, 0x73, 0x26, 0x0a, 0x4e, 0x11, 0xe3, 0x67, 0x07, 0xe2, 0x90, 0xab, + 0xda, 0x59, 0x68, 0xb5, 0xc4, 0x01, 0x80, 0x71, 0x76, 0x60, 0x42, 0x71, 0x06, 0x1b, 0x6d, 0xc0, + 0x59, 0xa3, 0xe5, 0x26, 0xf1, 0x1a, 0x3b, 0xdb, 0x61, 0x24, 0x7d, 0x8b, 0xe7, 0x75, 0xc8, 0x47, + 0x37, 0x0e, 0xee, 0xf9, 0x24, 0x5d, 0xef, 0x5c, 0xa7, 0xe5, 0xb8, 0x5e, 0xd2, 0x11, 0x5b, 0x4d, + 0x4a, 0x37, 0x2d, 0x8a, 0x76, 0xac, 0x30, 0xec, 0x35, 0x18, 0x19, 0x70, 0x04, 0x0d, 0x64, 0xd3, + 0xbe, 0x09, 0x65, 0x4a, 0x4e, 0x1a, 0x38, 0x79, 0x90, 0x0c, 0xa1, 0x2c, 0x4b, 0xd2, 0x22, 0x1b, + 0x8a, 0x9e, 0x23, 0x8f, 0x67, 0xd4, 0x6b, 0xad, 0xc4, 0x71, 0x9b, 0xb9, 0x89, 0x14, 0x88, 0x5e, + 0x84, 0x22, 0xd9, 0x6f, 0x65, 0xcf, 0x61, 0xae, 0xec, 0xb7, 0xbc, 0x88, 0xc4, 0x14, 0x89, 0xec, + 0xb7, 0xd0, 0x79, 0x28, 0x78, 0x35, 0xb1, 0x48, 0x81, 0xc0, 0x29, 0xac, 0x2c, 0xe1, 0x82, 0x57, + 0xb3, 0xf7, 0xa1, 0xa2, 0x6a, 0xe0, 0xa2, 0x5d, 0xa9, 0xbb, 0xad, 0x3c, 0xe2, 0x34, 0x24, 0xdd, + 0x3e, 0x5a, 0xbb, 0x0d, 0xa0, 0x83, 0xfe, 0xf3, 0xd2, 0x2f, 0x17, 0x61, 0xc4, 0x0d, 0x45, 0xae, + 0x50, 0x59, 0x93, 0x61, 0x4a, 0x9b, 0x41, 0xec, 0x3b, 0x30, 0x75, 0x23, 0x08, 0xef, 0xb1, 0xea, + 0x80, 0x57, 0x3d, 0xe2, 0xd7, 0x28, 0xe1, 0x3a, 0xfd, 0x91, 0x35, 0x11, 0x18, 0x14, 0x73, 0x98, + 0xca, 0xfe, 0x2f, 0xf4, 0xcb, 0xfe, 0xb7, 0x3f, 0x63, 0xc1, 0x69, 0x15, 0x8d, 0x2e, 0xb5, 0xf1, + 0x65, 0x98, 0xd8, 0x6e, 0x7b, 0x7e, 0x4d, 0xfc, 0xcf, 0x3a, 0xea, 0x55, 0x03, 0x86, 0x53, 0x98, + 0xd4, 0xad, 0xd8, 0xf6, 0x02, 0x27, 0xea, 0x6c, 0x68, 0xf5, 0xaf, 0x34, 0x42, 0x55, 0x41, 0xb0, + 0x81, 0x65, 0x7f, 0xae, 0x00, 0x93, 0xa9, 0xe4, 0x5b, 0xe4, 0x43, 0x99, 0xf8, 0x6c, 0xfb, 0x48, + 0x7e, 0xd4, 0xe3, 0x96, 0xc5, 0x51, 0x03, 0xf1, 0x8a, 0xa0, 0x8b, 0x15, 0x87, 0x27, 0xe2, 0x9c, + 0xc2, 0xfe, 0x07, 0x05, 0x38, 0x95, 0xa9, 0xb7, 0x86, 0xbe, 0x92, 0x2e, 0x9f, 0x62, 0xe5, 0xe1, + 0x95, 0x1f, 0x5a, 0xf5, 0x6b, 0xb8, 0x22, 0x2a, 0x8f, 0xab, 0xab, 0x7e, 0xaf, 0x00, 0x53, 0xe9, + 0x42, 0x71, 0x4f, 0x60, 0x4f, 0x7d, 0x00, 0x2a, 0xac, 0xfc, 0x12, 0xab, 0x51, 0xcf, 0x9d, 0x7f, + 0x5e, 0x1f, 0x48, 0x36, 0x62, 0x0d, 0x7f, 0x22, 0x6a, 0xd3, 0xd8, 0xff, 0xc8, 0x82, 0x73, 0xfc, + 0x2d, 0xb3, 0xe3, 0xf0, 0x6f, 0xf5, 0xea, 0xdd, 0xb7, 0xf3, 0x15, 0x30, 0x93, 0xda, 0x7f, 0x54, + 0xff, 0xb2, 0xda, 0xd8, 0x42, 0xda, 0xf4, 0x50, 0x78, 0x02, 0x85, 0x1d, 0x6a, 0x30, 0xd8, 0xbf, + 0x57, 0x04, 0x5d, 0x0e, 0x1c, 0x79, 0x22, 0xca, 0x3c, 0x97, 0x12, 0x07, 0x9b, 0x9d, 0xc0, 0xd5, + 0x85, 0xc7, 0xcb, 0x99, 0x20, 0xf3, 0x5f, 0xb0, 0x60, 0xdc, 0x0b, 0xbc, 0xc4, 0x73, 0x98, 0xb9, + 0x92, 0x4f, 0x7d, 0x64, 0xc5, 0x6e, 0x85, 0x53, 0x0e, 0x23, 0x73, 0xc7, 0x48, 0x31, 0xc3, 0x26, + 0x67, 0xf4, 0x29, 0x11, 0x87, 0x54, 0xcc, 0x2d, 0x47, 0xa1, 0x9c, 0x09, 0x3e, 0x6a, 0x41, 0x29, + 0x22, 0x49, 0x24, 0xb3, 0x43, 0x6e, 0x1c, 0x37, 0xb8, 0x34, 0x89, 0x3a, 0xaa, 0xaa, 0x8d, 0xbe, + 0x98, 0x85, 0x36, 0x63, 0xce, 0xc8, 0x8e, 0x01, 0x75, 0xf7, 0xc5, 0x90, 0x31, 0x1e, 0xf3, 0x50, + 0x71, 0xda, 0x49, 0xd8, 0xa4, 0xdd, 0x24, 0x36, 0xb5, 0x74, 0x14, 0x8b, 0x04, 0x60, 0x8d, 0x63, + 0x7f, 0xa5, 0x04, 0x99, 0xb0, 0x6f, 0xb4, 0x6f, 0x96, 0xb2, 0xb7, 0xf2, 0x2d, 0x65, 0xaf, 0x84, + 0xe9, 0x55, 0xce, 0x1e, 0x35, 0xa0, 0xd4, 0xda, 0x71, 0x62, 0x69, 0x8d, 0xbc, 0x29, 0xbb, 0x69, + 0x83, 0x36, 0x3e, 0x38, 0x98, 0xfd, 0xf1, 0xc1, 0xbc, 0x5b, 0x3a, 0x56, 0xe7, 0x79, 0x0e, 0x9c, + 0x66, 0xcd, 0x68, 0x60, 0x4e, 0x7f, 0x98, 0x0a, 0xd1, 0x9f, 0x15, 0x05, 0xb9, 0x30, 0x89, 0xdb, + 0x7e, 0x22, 0x46, 0xc3, 0x9b, 0x39, 0xce, 0x32, 0x4e, 0x58, 0x27, 0x0d, 0xf1, 0xff, 0xd8, 0x60, + 0x8a, 0x3e, 0x0e, 0x95, 0x38, 0x71, 0xa2, 0xe4, 0x21, 0x53, 0x0c, 0x54, 0xa7, 0x6f, 0x4a, 0x22, + 0x58, 0xd3, 0x43, 0x6f, 0xb1, 0x8a, 0x2f, 0x5e, 0xbc, 0xf3, 0x90, 0xe1, 0x83, 0xb2, 0x3a, 0x8c, + 0xa0, 0x80, 0x0d, 0x6a, 0xd4, 0xd8, 0x63, 0x63, 0x9b, 0x9f, 0x99, 0x97, 0x99, 0x35, 0xaf, 0x54, + 0x21, 0x56, 0x10, 0x6c, 0x60, 0xd9, 0x9f, 0x86, 0x33, 0xd9, 0xbb, 0x6f, 0xc4, 0x86, 0x57, 0x23, + 0x0a, 0xdb, 0xad, 0xac, 0x35, 0xcb, 0xee, 0x46, 0xc1, 0x1c, 0x46, 0xad, 0xd9, 0x5d, 0x2f, 0xa8, + 0x65, 0xad, 0xd9, 0x1b, 0x5e, 0x50, 0xc3, 0x0c, 0x32, 0x40, 0x8d, 0xff, 0x7f, 0x6d, 0xc1, 0xc5, + 0xa3, 0xae, 0xe8, 0x41, 0xcf, 0xc3, 0xc8, 0x3d, 0x27, 0x92, 0x15, 0xa4, 0x98, 0xee, 0xb8, 0xe3, + 0x44, 0x01, 0x66, 0xad, 0xa8, 0x03, 0xa3, 0x3c, 0xad, 0x4a, 0xf8, 0xe7, 0x6f, 0xe6, 0x7b, 0x61, + 0xd0, 0x0d, 0x62, 0x9c, 0x8e, 0xf0, 0x94, 0x2e, 0x2c, 0x18, 0xda, 0xdf, 0xb5, 0x00, 0xad, 0xef, + 0x91, 0x28, 0xf2, 0x6a, 0x46, 0x22, 0x18, 0x7a, 0x0d, 0x26, 0xee, 0x6e, 0xae, 0xdf, 0xdc, 0x08, + 0xbd, 0x80, 0xe5, 0xba, 0x1b, 0x29, 0x01, 0xd7, 0x8d, 0x76, 0x9c, 0xc2, 0x42, 0x8b, 0x30, 0x7d, + 0xf7, 0x1d, 0x6a, 0x81, 0x9b, 0x55, 0x19, 0x0b, 0x7a, 0xcf, 0xe5, 0xfa, 0x9b, 0x19, 0x20, 0xee, + 0xc6, 0x47, 0xeb, 0x70, 0xae, 0xc9, 0x0e, 0x7b, 0x6b, 0xcc, 0xf1, 0x88, 0xf9, 0xc9, 0x6f, 0x24, + 0x93, 0x89, 0x9f, 0xbd, 0x7f, 0x30, 0x7b, 0x6e, 0xad, 0x17, 0x02, 0xee, 0xfd, 0x9c, 0xfd, 0xcd, + 0x02, 0x8c, 0x1b, 0xd7, 0x5c, 0x0d, 0xe0, 0x62, 0x65, 0x6e, 0xe6, 0x2a, 0x0c, 0x78, 0x33, 0xd7, + 0x4b, 0x50, 0x6e, 0x85, 0xbe, 0xe7, 0x7a, 0x2a, 0xf3, 0x99, 0x55, 0xe0, 0xd9, 0x10, 0x6d, 0x58, + 0x41, 0xd1, 0x3d, 0xa8, 0xa8, 0xab, 0x5f, 0x44, 0x2e, 0x54, 0x5e, 0x4e, 0xa6, 0x9a, 0xbc, 0xfa, + 0x4a, 0x17, 0xcd, 0x0b, 0xd9, 0x30, 0xca, 0x46, 0xbe, 0x8c, 0x26, 0x61, 0x01, 0xef, 0x6c, 0x4a, + 0xc4, 0x58, 0x40, 0xec, 0x9f, 0x1f, 0x83, 0xb3, 0xbd, 0xaa, 0xc6, 0xa0, 0x9f, 0x82, 0x51, 0x2e, + 0x63, 0x3e, 0x85, 0xc9, 0x7a, 0xf1, 0x58, 0x66, 0x04, 0x85, 0x58, 0xec, 0x37, 0x16, 0x3c, 0x05, + 0x77, 0xdf, 0xd9, 0x16, 0x66, 0xc4, 0xc9, 0x70, 0x5f, 0x75, 0x34, 0xf7, 0x55, 0x87, 0x73, 0xf7, + 0x9d, 0x6d, 0xb4, 0x0f, 0xa5, 0x86, 0x97, 0x10, 0x47, 0x18, 0xd3, 0x77, 0x4e, 0x84, 0x39, 0x71, + 0x78, 0xd0, 0x32, 0xfb, 0x89, 0x39, 0x43, 0xf4, 0x0d, 0x0b, 0x4e, 0x6d, 0xa7, 0xf3, 0x07, 0xc4, + 0xaa, 0xe2, 0x9c, 0x40, 0x65, 0xa0, 0x34, 0xa3, 0xea, 0x99, 0xfb, 0x07, 0xb3, 0xa7, 0x32, 0x8d, + 0x38, 0x2b, 0x0e, 0xfa, 0x59, 0x0b, 0xc6, 0xea, 0x9e, 0x6f, 0x54, 0xc5, 0x38, 0x81, 0x8f, 0x73, + 0x95, 0x31, 0xd0, 0x2b, 0x2f, 0xff, 0x1f, 0x63, 0xc9, 0xb9, 0xdf, 0x29, 0xce, 0xe8, 0x71, 0x4f, + 0x71, 0xc6, 0x1e, 0x93, 0xfb, 0xf4, 0x77, 0x0a, 0xf0, 0xe2, 0x00, 0xdf, 0xc8, 0x8c, 0x47, 0xb7, + 0x8e, 0x88, 0x47, 0xbf, 0x08, 0x23, 0x11, 0x69, 0x85, 0xd9, 0xf5, 0x8e, 0x05, 0x8c, 0x30, 0x08, + 0x7a, 0x01, 0x8a, 0x4e, 0xcb, 0x13, 0xcb, 0x9d, 0x3a, 0xe4, 0x5d, 0xd8, 0x58, 0xc1, 0xb4, 0x9d, + 0x7e, 0xe9, 0xca, 0xb6, 0xcc, 0x6a, 0xc9, 0xa7, 0xda, 0x68, 0xbf, 0x24, 0x19, 0xee, 0xd0, 0x28, + 0x28, 0xd6, 0x7c, 0xed, 0x75, 0x38, 0xdf, 0x7f, 0x84, 0xa0, 0x57, 0x61, 0x7c, 0x3b, 0x72, 0x02, + 0x77, 0x87, 0x95, 0xe9, 0x95, 0x7d, 0xc2, 0xa2, 0x90, 0x75, 0x33, 0x36, 0x71, 0xec, 0xdf, 0x29, + 0xf4, 0xa6, 0xc8, 0x95, 0xc0, 0x30, 0x3d, 0x2c, 0xfa, 0xaf, 0xd0, 0xa7, 0xff, 0xde, 0x81, 0x72, + 0xc2, 0x82, 0xa0, 0x49, 0x5d, 0x68, 0x92, 0xdc, 0xf2, 0x78, 0xd8, 0x5a, 0xb3, 0x25, 0x88, 0x63, + 0xc5, 0x86, 0xaa, 0x7c, 0x5f, 0x17, 0xd4, 0x10, 0x2a, 0x3f, 0x93, 0x2c, 0xb0, 0x04, 0xa7, 0x8d, + 0x02, 0x60, 0x3c, 0x06, 0x94, 0x1f, 0xc0, 0xa9, 0xc4, 0x88, 0x8d, 0x0c, 0x1c, 0x77, 0x3d, 0x61, + 0xff, 0x6a, 0x01, 0x9e, 0xed, 0xab, 0xd9, 0xf4, 0x29, 0xa1, 0x75, 0xc8, 0x29, 0xe1, 0xb1, 0x07, + 0xa8, 0xd9, 0xc1, 0x23, 0x8f, 0xa6, 0x83, 0x5f, 0x86, 0xb2, 0x17, 0xc4, 0xc4, 0x6d, 0x47, 0xbc, + 0xd3, 0x8c, 0x68, 0xac, 0x15, 0xd1, 0x8e, 0x15, 0x86, 0xfd, 0xfb, 0xfd, 0x87, 0x1a, 0x5d, 0xe5, + 0x7e, 0x60, 0x7b, 0xe9, 0x75, 0x98, 0x74, 0x5a, 0x2d, 0x8e, 0xc7, 0x4e, 0x64, 0x32, 0xa9, 0x4e, + 0x0b, 0x26, 0x10, 0xa7, 0x71, 0x8d, 0x31, 0x3c, 0xda, 0x6f, 0x0c, 0xdb, 0x7f, 0x5a, 0x82, 0x0a, + 0xed, 0x81, 0xc5, 0x88, 0xd4, 0x62, 0xda, 0x01, 0xed, 0xc8, 0xcf, 0x5e, 0x3c, 0x75, 0x0b, 0xaf, + 0x62, 0xda, 0x9e, 0xf2, 0x92, 0x0b, 0x43, 0x65, 0x42, 0x14, 0x8f, 0xcc, 0x84, 0x78, 0x1d, 0x26, + 0xe3, 0x78, 0x67, 0x23, 0xf2, 0xf6, 0x9c, 0x84, 0xda, 0xde, 0xe2, 0xc4, 0x5b, 0x47, 0x2f, 0x6f, + 0x5e, 0xd3, 0x40, 0x9c, 0xc6, 0x45, 0xcb, 0x30, 0xad, 0xf3, 0x11, 0x48, 0x94, 0xb0, 0x03, 0x6e, + 0xde, 0x55, 0x2a, 0x78, 0x58, 0x67, 0x30, 0x08, 0x04, 0xdc, 0xfd, 0x0c, 0x9d, 0xd2, 0xa9, 0x46, + 0x2a, 0xc8, 0x68, 0x7a, 0x4a, 0xa7, 0xe8, 0x50, 0x59, 0xba, 0x9e, 0x40, 0x6b, 0x70, 0x86, 0x8f, + 0x0b, 0x76, 0xd3, 0xa1, 0x7a, 0xa3, 0x31, 0x46, 0xe8, 0x39, 0x41, 0xe8, 0xcc, 0x72, 0x37, 0x0a, + 0xee, 0xf5, 0x1c, 0x35, 0xac, 0x55, 0xf3, 0xca, 0x92, 0x70, 0xf0, 0x94, 0x61, 0xad, 0xc8, 0xac, + 0xd4, 0xb0, 0x89, 0x87, 0x3e, 0x06, 0xcf, 0xe8, 0xbf, 0x3c, 0x0e, 0x88, 0xef, 0x7a, 0x2c, 0x89, + 0x54, 0x2f, 0x55, 0x7c, 0x6a, 0xb9, 0x27, 0x5a, 0x0d, 0xf7, 0x7b, 0x1e, 0x6d, 0xc3, 0x79, 0x05, + 0xba, 0x42, 0xbd, 0x98, 0x56, 0xe4, 0xc5, 0xa4, 0xea, 0xc4, 0xe4, 0x56, 0xe4, 0xb3, 0xe4, 0xb0, + 0x8a, 0x2e, 0x93, 0xbb, 0xec, 0x25, 0xd7, 0x7a, 0x61, 0xe2, 0x55, 0x7c, 0x08, 0x15, 0x34, 0x0f, + 0x15, 0x12, 0x38, 0xdb, 0x3e, 0x59, 0x5f, 0x5c, 0x61, 0x29, 0x63, 0xc6, 0x26, 0xcb, 0x15, 0x09, + 0xc0, 0x1a, 0x47, 0x1d, 0xb2, 0x4c, 0xf4, 0x3d, 0x64, 0xf9, 0x23, 0x0b, 0x26, 0xd5, 0x60, 0x7f, + 0x04, 0xd1, 0x0c, 0x7e, 0x3a, 0x9a, 0x61, 0xf9, 0xb8, 0xbb, 0x5b, 0x42, 0xf2, 0x3e, 0x47, 0x62, + 0x7f, 0x52, 0x01, 0x60, 0x97, 0x36, 0x7b, 0xac, 0x7a, 0x83, 0x54, 0x77, 0x56, 0x5f, 0x75, 0xf7, + 0xc4, 0x4e, 0xe7, 0x5e, 0xc9, 0x15, 0xa5, 0xc7, 0x9b, 0x5c, 0xb1, 0x09, 0xe7, 0xe4, 0x62, 0xc4, + 0x1d, 0xfe, 0x6b, 0x61, 0xac, 0xb4, 0x43, 0xb9, 0xfa, 0x82, 0x20, 0x74, 0x6e, 0xa5, 0x17, 0x12, + 0xee, 0xfd, 0x6c, 0x6a, 0x0d, 0x1c, 0x3b, 0x6a, 0x0d, 0xd4, 0x13, 0x62, 0xb5, 0x2e, 0xeb, 0x40, + 0x65, 0x26, 0xc4, 0xea, 0xd5, 0x4d, 0xac, 0x71, 0x7a, 0x6b, 0xc5, 0x4a, 0x4e, 0x5a, 0x11, 0x86, + 0xd6, 0x8a, 0x72, 0x7e, 0x8e, 0xf7, 0x2d, 0x81, 0x2e, 0xf7, 0x18, 0x26, 0xfa, 0xee, 0x31, 0xbc, + 0x01, 0x53, 0x5e, 0xb0, 0x43, 0x22, 0x2f, 0x21, 0x35, 0x36, 0x17, 0xc4, 0x55, 0xb8, 0x2a, 0x86, + 0x60, 0x25, 0x05, 0xc5, 0x19, 0xec, 0xb4, 0x52, 0x99, 0x1a, 0x40, 0xa9, 0xf4, 0x51, 0xe5, 0xa7, + 0xf2, 0x51, 0xe5, 0xa7, 0x8f, 0xaf, 0xca, 0xa7, 0x4f, 0x54, 0x95, 0xa3, 0x5c, 0x54, 0xf9, 0x8b, + 0x50, 0x6a, 0x45, 0xe1, 0x7e, 0x67, 0xe6, 0x4c, 0xda, 0x3c, 0xdb, 0xa0, 0x8d, 0x98, 0xc3, 0x4c, + 0x77, 0xe1, 0xec, 0xe1, 0xee, 0x82, 0xfd, 0xf9, 0x02, 0x9c, 0xd3, 0x9a, 0x8e, 0x8e, 0x2f, 0xaf, + 0x4e, 0xe7, 0x3a, 0x2b, 0xd6, 0xc7, 0x0f, 0xa2, 0x8d, 0xf0, 0x15, 0x1d, 0x09, 0xa3, 0x20, 0xd8, + 0xc0, 0x62, 0x51, 0x20, 0x24, 0x62, 0xd5, 0x19, 0xb2, 0x6a, 0x70, 0x51, 0xb4, 0x63, 0x85, 0x41, + 0xbf, 0x20, 0xfd, 0x2d, 0x22, 0xeb, 0xb2, 0x19, 0x9b, 0x8b, 0x1a, 0x84, 0x4d, 0x3c, 0xf4, 0x12, + 0x67, 0xc2, 0xa6, 0x20, 0x55, 0x85, 0x13, 0xa2, 0xce, 0xb4, 0x9c, 0x75, 0x0a, 0x2a, 0xc5, 0x61, + 0xe1, 0x3e, 0xa5, 0x6e, 0x71, 0xd8, 0xe1, 0x89, 0xc2, 0xb0, 0xff, 0xaf, 0x05, 0xcf, 0xf6, 0xec, + 0x8a, 0x47, 0xb0, 0xbc, 0xed, 0xa7, 0x97, 0xb7, 0xcd, 0xe3, 0x2f, 0x6f, 0x5d, 0x6f, 0xd1, 0x67, + 0xa9, 0xfb, 0x43, 0x0b, 0xa6, 0x34, 0xfe, 0x23, 0x78, 0x55, 0x2f, 0xfd, 0xaa, 0xd7, 0xf2, 0x7a, + 0x55, 0xbe, 0x73, 0x95, 0x7a, 0xb7, 0x3f, 0x62, 0xef, 0xc6, 0xf7, 0xa0, 0x17, 0x5c, 0x79, 0xcf, + 0xf0, 0x11, 0x7b, 0xaf, 0x1d, 0x18, 0x65, 0x55, 0x5d, 0xe3, 0x7c, 0xf6, 0xc2, 0xd3, 0xfc, 0x59, + 0x1c, 0x9f, 0xde, 0x0b, 0x67, 0x7f, 0x63, 0x2c, 0x18, 0xb2, 0xda, 0x21, 0x5e, 0x4c, 0xf5, 0x65, + 0x4d, 0x04, 0xce, 0xe8, 0xda, 0x21, 0xa2, 0x1d, 0x2b, 0x0c, 0xbb, 0x09, 0x33, 0x69, 0xe2, 0x4b, + 0xa4, 0xce, 0x8e, 0x1c, 0x07, 0x7a, 0xcd, 0x79, 0xa8, 0x38, 0xec, 0xa9, 0xd5, 0xb6, 0x93, 0xbd, + 0x9a, 0x60, 0x41, 0x02, 0xb0, 0xc6, 0xb1, 0x7f, 0xd3, 0x82, 0x33, 0x3d, 0x5e, 0x26, 0xc7, 0x80, + 0xa1, 0x44, 0x6b, 0x81, 0x3e, 0x17, 0x40, 0xd7, 0x48, 0xdd, 0x91, 0x87, 0x5a, 0x86, 0x56, 0x5b, + 0xe2, 0xcd, 0x58, 0xc2, 0xed, 0xff, 0x65, 0xc1, 0xa9, 0xb4, 0xac, 0x31, 0xba, 0x0e, 0x88, 0xbf, + 0xcc, 0x92, 0x17, 0xbb, 0xe1, 0x1e, 0x89, 0x3a, 0xf4, 0xcd, 0xb9, 0xd4, 0xe7, 0x05, 0x25, 0xb4, + 0xd0, 0x85, 0x81, 0x7b, 0x3c, 0xc5, 0x6a, 0x1b, 0xd4, 0x54, 0x6f, 0xcb, 0x91, 0x72, 0x3b, 0xcf, + 0x91, 0xa2, 0x3f, 0xa6, 0xb9, 0xf1, 0xaf, 0x58, 0x62, 0x93, 0xbf, 0xfd, 0xdd, 0x11, 0x50, 0x11, + 0x85, 0xec, 0xf8, 0x24, 0xa7, 0xc3, 0xa7, 0xd4, 0xfd, 0x15, 0xc5, 0x21, 0x6e, 0xa4, 0x1e, 0x39, + 0xec, 0x68, 0x83, 0x97, 0x52, 0x37, 0x37, 0x79, 0xd4, 0x1b, 0x6e, 0x69, 0x10, 0x36, 0xf1, 0xa8, + 0x24, 0xbe, 0xb7, 0x47, 0xf8, 0x43, 0xa3, 0x69, 0x49, 0x56, 0x25, 0x00, 0x6b, 0x1c, 0x2a, 0x49, + 0xcd, 0xab, 0xd7, 0x85, 0xa7, 0xa8, 0x24, 0xa1, 0xbd, 0x83, 0x19, 0x84, 0x62, 0xec, 0x84, 0xe1, + 0xae, 0xb0, 0xff, 0x14, 0xc6, 0xb5, 0x30, 0xdc, 0xc5, 0x0c, 0x42, 0x2d, 0x96, 0x20, 0x8c, 0x9a, + 0xec, 0xea, 0x88, 0x9a, 0xe2, 0x22, 0xec, 0x3e, 0x65, 0xb1, 0xdc, 0xec, 0x46, 0xc1, 0xbd, 0x9e, + 0xa3, 0x23, 0xb0, 0x15, 0x91, 0x9a, 0xe7, 0x26, 0x26, 0x35, 0x48, 0x8f, 0xc0, 0x8d, 0x2e, 0x0c, + 0xdc, 0xe3, 0x29, 0xb4, 0x00, 0xa7, 0x64, 0x44, 0xa8, 0xcc, 0x78, 0xe1, 0xc6, 0xa0, 0xb2, 0xc3, + 0x71, 0x1a, 0x8c, 0xb3, 0xf8, 0x54, 0xdb, 0x34, 0x45, 0xb2, 0x1b, 0x33, 0x13, 0x0d, 0x6d, 0x23, + 0x93, 0xe0, 0xb0, 0xc2, 0xb0, 0x3f, 0x5b, 0xa4, 0xab, 0x63, 0x9f, 0x82, 0x8d, 0x8f, 0xec, 0xb0, + 0x33, 0x3d, 0x22, 0x47, 0x06, 0x18, 0x91, 0xaf, 0xc1, 0xc4, 0xdd, 0x38, 0x0c, 0xd4, 0x41, 0x62, + 0xa9, 0xef, 0x41, 0xa2, 0x81, 0xd5, 0xfb, 0x20, 0x71, 0x34, 0xaf, 0x83, 0xc4, 0xb1, 0x87, 0x3c, + 0x48, 0xfc, 0xdd, 0x12, 0xa8, 0x72, 0x6b, 0x37, 0x49, 0x72, 0x2f, 0x8c, 0x76, 0xbd, 0xa0, 0xc1, + 0x22, 0x69, 0xbf, 0x61, 0xc1, 0x04, 0x9f, 0x2f, 0xa2, 0x56, 0x2e, 0x8f, 0x12, 0xaa, 0xe7, 0x54, + 0x62, 0x2c, 0xc5, 0x6c, 0x6e, 0xcb, 0x60, 0x94, 0x29, 0x5c, 0x6c, 0x82, 0x70, 0x4a, 0x22, 0xf4, + 0xd3, 0x00, 0xf2, 0x12, 0x85, 0x7a, 0x4e, 0xd7, 0xc3, 0xab, 0x2b, 0x2d, 0x48, 0x5d, 0xdb, 0xa6, + 0x5b, 0x8a, 0x09, 0x36, 0x18, 0xa2, 0xcf, 0x67, 0xaf, 0xd6, 0xf9, 0xd4, 0x89, 0xf4, 0xcd, 0x20, + 0xa5, 0x71, 0x30, 0x8c, 0x79, 0x41, 0x83, 0x8e, 0x13, 0x71, 0xf6, 0xfa, 0xfe, 0x5e, 0x51, 0xe8, + 0xab, 0xa1, 0x53, 0xab, 0x3a, 0xbe, 0x13, 0xb8, 0x24, 0x5a, 0xe1, 0xe8, 0x66, 0x25, 0x7d, 0xd6, + 0x80, 0x25, 0xa1, 0xae, 0x1a, 0x7a, 0xa5, 0x41, 0x6a, 0xe8, 0x9d, 0xff, 0x08, 0x4c, 0x77, 0x7d, + 0xcc, 0xa1, 0x4a, 0xe3, 0x3c, 0x7c, 0x55, 0x1d, 0xfb, 0xdf, 0x8c, 0xea, 0x45, 0xeb, 0x66, 0x58, + 0xe3, 0x95, 0xdc, 0x22, 0xfd, 0x45, 0x85, 0xed, 0x99, 0xe3, 0x10, 0x31, 0xaa, 0xf1, 0xab, 0x46, + 0x6c, 0xb2, 0xa4, 0x63, 0xb4, 0xe5, 0x44, 0x24, 0x38, 0xe9, 0x31, 0xba, 0xa1, 0x98, 0x60, 0x83, + 0x21, 0xda, 0x49, 0x45, 0x89, 0x5d, 0x3d, 0x7e, 0x94, 0x18, 0xcb, 0x50, 0xeb, 0x55, 0xaa, 0xea, + 0xab, 0x16, 0x4c, 0x05, 0xa9, 0x91, 0x2b, 0xf6, 0xe1, 0xb7, 0x4e, 0x62, 0x56, 0xf0, 0x6a, 0x9d, + 0xe9, 0x36, 0x9c, 0xe1, 0xdf, 0x6b, 0x49, 0x2b, 0x0d, 0xb9, 0xa4, 0xe9, 0x92, 0x90, 0xa3, 0xfd, + 0x4a, 0x42, 0xa2, 0x40, 0x15, 0x9e, 0x1d, 0xcb, 0xbd, 0xf0, 0x2c, 0xf4, 0x28, 0x3a, 0x7b, 0x07, + 0x2a, 0x6e, 0x44, 0x9c, 0xe4, 0x21, 0x6b, 0x90, 0xb2, 0x43, 0xc8, 0x45, 0x49, 0x00, 0x6b, 0x5a, + 0xf6, 0x7f, 0x2c, 0xc2, 0x69, 0xd9, 0x23, 0x32, 0x82, 0x86, 0xae, 0x8f, 0x9c, 0xaf, 0x36, 0x6e, + 0xd5, 0xfa, 0x78, 0x4d, 0x02, 0xb0, 0xc6, 0xa1, 0xf6, 0x58, 0x3b, 0x26, 0xeb, 0x2d, 0x12, 0xac, + 0x7a, 0xdb, 0xb1, 0x38, 0x3f, 0x52, 0x13, 0xe5, 0x96, 0x06, 0x61, 0x13, 0x8f, 0x1a, 0xe3, 0xdc, + 0x2e, 0x8e, 0xb3, 0x01, 0x69, 0xc2, 0xde, 0xc6, 0x12, 0x8e, 0x7e, 0xa9, 0x67, 0x05, 0xe9, 0x7c, + 0x42, 0x31, 0xbb, 0x02, 0x87, 0x86, 0x2c, 0x1d, 0xfd, 0x15, 0x0b, 0x4e, 0xed, 0xa6, 0xb2, 0x10, + 0xa4, 0x4a, 0x3e, 0x66, 0xbe, 0x5c, 0x3a, 0xb5, 0x41, 0x0f, 0xe1, 0x74, 0x7b, 0x8c, 0xb3, 0xdc, + 0xed, 0xff, 0x63, 0x81, 0xa9, 0x9e, 0x06, 0xb3, 0xac, 0x8c, 0x3b, 0x01, 0x0a, 0x47, 0xdc, 0x09, + 0x20, 0x8d, 0xb0, 0xe2, 0x60, 0x46, 0xff, 0xc8, 0x10, 0x46, 0x7f, 0xa9, 0xaf, 0xd5, 0xf6, 0x02, + 0x14, 0xdb, 0x5e, 0x4d, 0xd8, 0xed, 0xfa, 0x30, 0x6c, 0x65, 0x09, 0xd3, 0x76, 0xfb, 0x5f, 0x96, + 0xb4, 0x9f, 0x2e, 0x22, 0x08, 0x7f, 0x20, 0x5e, 0xbb, 0xae, 0xd2, 0x1f, 0xf9, 0x9b, 0xdf, 0xec, + 0x4a, 0x7f, 0xfc, 0xd1, 0xe1, 0x03, 0x44, 0x79, 0x07, 0xf5, 0xcb, 0x7e, 0x1c, 0x3b, 0x22, 0x3a, + 0xf4, 0x2e, 0x94, 0xa9, 0x6b, 0xc3, 0x36, 0xdc, 0xca, 0x29, 0xa1, 0xca, 0xd7, 0x44, 0xfb, 0x83, + 0x83, 0xd9, 0x1f, 0x19, 0x5e, 0x2c, 0xf9, 0x34, 0x56, 0xf4, 0x51, 0x0c, 0x15, 0xfa, 0x9b, 0x05, + 0xb2, 0x0a, 0xa7, 0xe9, 0x96, 0xd2, 0x45, 0x12, 0x90, 0x4b, 0x94, 0xac, 0xe6, 0x83, 0x02, 0xa8, + 0xb0, 0xea, 0xf5, 0x8c, 0x29, 0xf7, 0xad, 0x36, 0x54, 0x38, 0xa9, 0x04, 0x3c, 0x38, 0x98, 0x7d, + 0x7d, 0x78, 0xa6, 0xea, 0x71, 0xac, 0x59, 0xd8, 0xff, 0xad, 0xa8, 0xc7, 0xae, 0xc8, 0x7a, 0xfd, + 0x81, 0x18, 0xbb, 0x97, 0x33, 0x63, 0xf7, 0x62, 0xd7, 0xd8, 0x9d, 0xd2, 0x15, 0xde, 0x53, 0xa3, + 0xf1, 0x51, 0x2f, 0xb0, 0x47, 0xfb, 0xf1, 0xcc, 0xb2, 0x78, 0xa7, 0xed, 0x45, 0x24, 0xde, 0x88, + 0xda, 0x81, 0x17, 0x34, 0xc4, 0x3d, 0x3f, 0x86, 0x65, 0x91, 0x02, 0xe3, 0x2c, 0xbe, 0xfd, 0x4d, + 0x76, 0xde, 0x69, 0xc4, 0xc4, 0xd3, 0xaf, 0xec, 0xb3, 0x0b, 0x00, 0x78, 0x5e, 0xa0, 0xfa, 0xca, + 0xbc, 0xea, 0x3f, 0x87, 0xa1, 0x7b, 0x30, 0xb6, 0xcd, 0x0b, 0x03, 0xe7, 0x53, 0x05, 0x48, 0x54, + 0x19, 0x66, 0xc5, 0xf2, 0x64, 0xc9, 0xe1, 0x07, 0xfa, 0x27, 0x96, 0xdc, 0xec, 0xbf, 0x5f, 0x84, + 0x53, 0x99, 0xf2, 0xf4, 0xa9, 0x9a, 0x04, 0x85, 0x23, 0x6b, 0x12, 0x7c, 0x02, 0xa0, 0x46, 0x5a, + 0x7e, 0xd8, 0x61, 0x86, 0xcb, 0xc8, 0xd0, 0x86, 0x8b, 0xb2, 0x75, 0x97, 0x14, 0x15, 0x6c, 0x50, + 0x14, 0xc9, 0x90, 0xbc, 0xc4, 0x41, 0x26, 0x19, 0xd2, 0x28, 0x86, 0x35, 0xfa, 0x68, 0x8b, 0x61, + 0x79, 0x70, 0x8a, 0x8b, 0xa8, 0x22, 0xcf, 0x1f, 0x22, 0xc0, 0x9c, 0xc5, 0x2c, 0x2e, 0xa5, 0xc9, + 0xe0, 0x2c, 0x5d, 0xfb, 0xcb, 0x05, 0x6a, 0xbe, 0xf1, 0xce, 0x5e, 0x93, 0x9b, 0xe3, 0xef, 0x83, + 0x51, 0xa7, 0x9d, 0xec, 0x84, 0x5d, 0x15, 0x8e, 0x17, 0x58, 0x2b, 0x16, 0x50, 0xb4, 0x0a, 0x23, + 0xc6, 0xbd, 0xc6, 0xc3, 0x08, 0xa7, 0x77, 0xc2, 0x9c, 0x84, 0x60, 0x46, 0x05, 0x3d, 0x0f, 0x23, + 0x89, 0xd3, 0x48, 0x5d, 0xea, 0xb4, 0xe5, 0x34, 0x62, 0xcc, 0x5a, 0xcd, 0xd5, 0x65, 0xe4, 0x88, + 0xd5, 0xe5, 0x75, 0x98, 0x8c, 0xbd, 0x46, 0xe0, 0x24, 0xed, 0x88, 0x18, 0xa7, 0x2e, 0xfa, 0xa8, + 0xda, 0x04, 0xe2, 0x34, 0xae, 0xfd, 0xdd, 0x0a, 0x9c, 0xed, 0x75, 0xbb, 0x66, 0xde, 0x61, 0xbf, + 0xbd, 0x78, 0x3c, 0xba, 0xb0, 0xdf, 0x3e, 0xdc, 0x7d, 0x23, 0xec, 0xd7, 0x37, 0xc2, 0x7e, 0x3f, + 0x6f, 0x41, 0x45, 0x45, 0xbb, 0x8a, 0x88, 0xbd, 0x8f, 0x9f, 0xc0, 0x0d, 0xa6, 0x92, 0x85, 0x08, + 0x7a, 0x94, 0x7f, 0xb1, 0x66, 0x7e, 0x72, 0x71, 0xc0, 0x87, 0x0a, 0x34, 0x54, 0x1c, 0xb0, 0x0a, + 0x92, 0x2e, 0xe5, 0x11, 0x24, 0xdd, 0xe7, 0x53, 0xf5, 0x0c, 0x92, 0xfe, 0xaa, 0x05, 0xe3, 0xce, + 0xbb, 0xed, 0x88, 0x2c, 0x91, 0xbd, 0xf5, 0x56, 0x2c, 0xf4, 0xd6, 0xdb, 0xf9, 0x0b, 0xb0, 0xa0, + 0x99, 0x88, 0x52, 0x8c, 0xba, 0x01, 0x9b, 0x22, 0xa4, 0x82, 0xa2, 0xc7, 0xf2, 0x08, 0x8a, 0xee, + 0x25, 0xce, 0x91, 0x41, 0xd1, 0xaf, 0xc3, 0xa4, 0xeb, 0x87, 0x01, 0xd9, 0x88, 0xc2, 0x24, 0x74, + 0x43, 0x5f, 0x58, 0x9d, 0x4a, 0x25, 0x2c, 0x9a, 0x40, 0x9c, 0xc6, 0xed, 0x17, 0x51, 0x5d, 0x39, + 0x6e, 0x44, 0x35, 0x3c, 0xa6, 0x88, 0xea, 0x3f, 0x2b, 0xc0, 0xec, 0x11, 0x1f, 0x15, 0x5d, 0x86, + 0x89, 0x30, 0x6a, 0x38, 0x81, 0xf7, 0x2e, 0x4f, 0x68, 0x2b, 0xa5, 0x33, 0xd5, 0xd7, 0x0d, 0x18, + 0x4e, 0x61, 0xca, 0x98, 0xcb, 0xd1, 0x3e, 0x31, 0x97, 0x1f, 0x82, 0xf1, 0x84, 0x38, 0x4d, 0x11, + 0x02, 0x20, 0x3c, 0x05, 0x7d, 0xf2, 0xa2, 0x41, 0xd8, 0xc4, 0xa3, 0xc3, 0x68, 0xca, 0x71, 0x5d, + 0x12, 0xc7, 0x32, 0xa8, 0x52, 0xec, 0x62, 0xe4, 0x16, 0xb1, 0xc9, 0x36, 0x87, 0x16, 0x52, 0x2c, + 0x70, 0x86, 0x25, 0x15, 0xde, 0xf1, 0x7d, 0x1e, 0x3f, 0x4d, 0xe4, 0x35, 0x8d, 0xba, 0xe8, 0xb7, + 0x06, 0x61, 0x13, 0xcf, 0xfe, 0xb5, 0x02, 0xbc, 0x70, 0xa8, 0x7a, 0x19, 0x38, 0xde, 0xb5, 0x1d, + 0x93, 0x28, 0x7b, 0x72, 0x71, 0x2b, 0x26, 0x11, 0x66, 0x10, 0xde, 0x4b, 0xad, 0x96, 0x71, 0x8d, + 0x41, 0xde, 0xe1, 0xd5, 0xbc, 0x97, 0x52, 0x2c, 0x70, 0x86, 0x65, 0xb6, 0x97, 0x46, 0x06, 0xec, + 0xa5, 0x7f, 0x5c, 0x80, 0x17, 0x07, 0x50, 0xc2, 0x39, 0x86, 0xa1, 0xa7, 0xc3, 0xf8, 0x8b, 0x8f, + 0x27, 0x8c, 0xff, 0x61, 0xbb, 0xeb, 0x9b, 0x05, 0x38, 0xdf, 0x5f, 0x17, 0xa2, 0x1f, 0xa3, 0xde, + 0x86, 0x8c, 0x4a, 0x30, 0x53, 0x00, 0xce, 0x70, 0x4f, 0x23, 0x05, 0xc2, 0x59, 0x5c, 0x34, 0x07, + 0xd0, 0x72, 0x92, 0x9d, 0xf8, 0xca, 0xbe, 0x17, 0x27, 0x22, 0x79, 0x6d, 0x8a, 0xef, 0x19, 0xcb, + 0x56, 0x6c, 0x60, 0x50, 0x76, 0xec, 0xdf, 0x52, 0x78, 0x33, 0x4c, 0xf8, 0x43, 0xdc, 0x8e, 0x3b, + 0xc3, 0xef, 0x55, 0x4d, 0x81, 0x70, 0x16, 0x97, 0xb2, 0x63, 0xa7, 0x12, 0x5c, 0x50, 0x71, 0x07, + 0x2d, 0x65, 0xb7, 0xaa, 0x5a, 0xb1, 0x81, 0x91, 0x4d, 0x6e, 0x28, 0x0d, 0x90, 0xdc, 0xf0, 0xcf, + 0x0b, 0xf0, 0x6c, 0xdf, 0xb5, 0x74, 0xb0, 0x09, 0xf8, 0xe4, 0x65, 0x35, 0x3c, 0xdc, 0xd8, 0x19, + 0x32, 0x56, 0xff, 0x3f, 0xf7, 0x19, 0x69, 0x22, 0x56, 0x3f, 0xbb, 0x54, 0x58, 0xc3, 0x2e, 0x15, + 0x4f, 0x50, 0x7f, 0x76, 0x85, 0xe7, 0x8f, 0x0c, 0x11, 0x9e, 0x9f, 0xf9, 0x18, 0xa5, 0x01, 0x27, + 0xf2, 0xb7, 0xfb, 0x77, 0x2f, 0xb5, 0xbd, 0x07, 0xda, 0xc7, 0x59, 0x82, 0xd3, 0xe2, 0x32, 0xeb, + 0xcd, 0xf6, 0xb6, 0x48, 0x6d, 0x2c, 0xa4, 0xaf, 0xf4, 0x58, 0xc9, 0xc0, 0x71, 0xd7, 0x13, 0x4f, + 0x60, 0xba, 0xc4, 0x43, 0x76, 0xe9, 0x27, 0xa0, 0xa2, 0x68, 0xf3, 0x10, 0x42, 0xf5, 0x41, 0xbb, + 0x42, 0x08, 0xd5, 0xd7, 0x34, 0xb0, 0x68, 0x4f, 0xec, 0x92, 0x4e, 0x76, 0x64, 0xde, 0x20, 0x1d, + 0x76, 0x9c, 0x68, 0x7f, 0x10, 0x26, 0x94, 0x13, 0x39, 0x68, 0x59, 0x41, 0xfb, 0x7f, 0x8e, 0xc0, + 0x64, 0x2a, 0x85, 0x3d, 0xb5, 0x15, 0x62, 0x1d, 0xb9, 0x15, 0xc2, 0x82, 0x2e, 0xdb, 0x81, 0xac, + 0xba, 0x69, 0x04, 0x5d, 0xb6, 0x03, 0x82, 0x39, 0x8c, 0xba, 0xee, 0xb5, 0xa8, 0x83, 0xdb, 0x81, + 0x08, 0xdd, 0x52, 0xae, 0xfb, 0x12, 0x6b, 0xc5, 0x02, 0x8a, 0x3e, 0x63, 0xc1, 0x44, 0xcc, 0x76, + 0xce, 0xf8, 0x46, 0x92, 0xf8, 0xa0, 0xd7, 0xf3, 0xb8, 0x6d, 0x51, 0x94, 0x6b, 0x60, 0xa7, 0xbe, + 0x66, 0x0b, 0x4e, 0x71, 0x44, 0x3f, 0x67, 0x99, 0xf7, 0x4c, 0x8e, 0xe6, 0x11, 0x72, 0x98, 0xad, + 0x10, 0xc0, 0xb7, 0x59, 0x0e, 0xbf, 0x6e, 0x32, 0x56, 0xbb, 0x3c, 0x63, 0x27, 0xb3, 0xcb, 0x03, + 0x3d, 0x76, 0x78, 0x3e, 0x00, 0x95, 0xa6, 0x13, 0x78, 0x75, 0x12, 0x27, 0xf1, 0x4c, 0xd9, 0x28, + 0x5c, 0x22, 0x1b, 0xb1, 0x86, 0xd3, 0xc5, 0x2e, 0x66, 0x2f, 0xc6, 0x4f, 0xba, 0x2a, 0xba, 0x00, + 0xfe, 0xa6, 0x6e, 0xc6, 0x26, 0x8e, 0xfd, 0xcf, 0x2c, 0x38, 0xd7, 0xb3, 0x33, 0x9e, 0xdc, 0x18, + 0x19, 0xba, 0x40, 0x9f, 0xe9, 0x51, 0xe2, 0x01, 0x75, 0x4e, 0xec, 0x3a, 0x52, 0x51, 0x43, 0x62, + 0xb2, 0xef, 0xd8, 0x18, 0x6e, 0xaf, 0x52, 0xef, 0x17, 0x16, 0x1f, 0xe9, 0x7e, 0x21, 0x35, 0x05, + 0x8d, 0x8b, 0x73, 0xd1, 0xa7, 0xcd, 0x6a, 0x26, 0x56, 0x5e, 0x95, 0x37, 0x38, 0x71, 0x55, 0x0d, + 0x85, 0xf7, 0x5a, 0xaf, 0xe2, 0x28, 0xd9, 0xf1, 0x5a, 0x38, 0x7a, 0xbc, 0x22, 0x5f, 0x96, 0x8d, + 0x29, 0xe6, 0x5f, 0x36, 0xa6, 0xd2, 0x55, 0x32, 0xe6, 0xef, 0x59, 0x7c, 0xa4, 0x65, 0x5e, 0x49, + 0x6b, 0x58, 0xeb, 0x10, 0x0d, 0xfb, 0x32, 0xbb, 0xe0, 0xa5, 0x7e, 0x8d, 0x38, 0xbe, 0xd0, 0xc4, + 0xe6, 0x5d, 0x2d, 0xac, 0x1d, 0x2b, 0x0c, 0x56, 0x0e, 0xda, 0xf7, 0xc3, 0x7b, 0x57, 0x9a, 0xad, + 0xa4, 0x23, 0x74, 0xb2, 0x2e, 0x07, 0xad, 0x20, 0xd8, 0xc0, 0xb2, 0xff, 0xdc, 0xe2, 0x9f, 0x53, + 0x1c, 0xe4, 0x5c, 0xce, 0x94, 0x2f, 0x1d, 0xfc, 0x0c, 0xe4, 0xa7, 0x00, 0x5c, 0x75, 0xb7, 0x43, + 0x3e, 0xf7, 0xe9, 0xea, 0xbb, 0x22, 0xcc, 0x4b, 0x5e, 0x65, 0x1b, 0x36, 0xf8, 0xa5, 0x26, 0x4f, + 0xf1, 0xa8, 0xc9, 0x63, 0xff, 0x99, 0x05, 0xa9, 0xc5, 0x02, 0xb5, 0xa0, 0x44, 0x25, 0xe8, 0xe4, + 0x73, 0x13, 0x85, 0x49, 0x9a, 0x4e, 0x2c, 0x31, 0x2c, 0xd8, 0x4f, 0xcc, 0x19, 0x21, 0x5f, 0x1c, + 0xe1, 0x14, 0xf2, 0xb8, 0x2d, 0xc5, 0x64, 0x78, 0x2d, 0x0c, 0x77, 0xf9, 0x86, 0xb6, 0x3e, 0x0e, + 0xb2, 0x2f, 0xc3, 0x74, 0x97, 0x50, 0xac, 0xf8, 0x60, 0x28, 0xaf, 0xdf, 0x30, 0x46, 0x20, 0x2b, + 0x85, 0x8a, 0x39, 0xcc, 0xfe, 0xa6, 0x05, 0xa7, 0xb3, 0xe4, 0xd1, 0xd7, 0x2d, 0x98, 0x8e, 0xb3, + 0xf4, 0x4e, 0xaa, 0xef, 0x54, 0x78, 0x43, 0x17, 0x08, 0x77, 0x0b, 0x61, 0xff, 0x7f, 0xa1, 0x9e, + 0xee, 0x78, 0x41, 0x2d, 0xbc, 0xa7, 0x16, 0x17, 0xab, 0xef, 0xe2, 0x42, 0xa7, 0x98, 0xbb, 0x43, + 0x6a, 0x6d, 0xbf, 0x2b, 0x81, 0x63, 0x53, 0xb4, 0x63, 0x85, 0x91, 0xba, 0xeb, 0xb2, 0x78, 0xe4, + 0x5d, 0x97, 0xaf, 0xc1, 0x84, 0x79, 0xc5, 0x8c, 0xc8, 0x06, 0x67, 0xb6, 0x8a, 0x79, 0x1b, 0x0d, + 0x4e, 0x61, 0x65, 0x2e, 0x19, 0x2c, 0x1d, 0x79, 0xc9, 0xe0, 0x4b, 0x50, 0x16, 0x17, 0xe6, 0xc9, + 0x20, 0x20, 0x9e, 0x1d, 0x22, 0xda, 0xb0, 0x82, 0x52, 0x05, 0xd1, 0x74, 0x82, 0xb6, 0xe3, 0xd3, + 0x1e, 0x12, 0x49, 0x63, 0x6a, 0x66, 0xad, 0x29, 0x08, 0x36, 0xb0, 0xe8, 0x1b, 0x27, 0x5e, 0x93, + 0xbc, 0x15, 0x06, 0xf2, 0xf8, 0x5c, 0x6f, 0xf7, 0x89, 0x76, 0xac, 0x30, 0xec, 0xff, 0x61, 0x41, + 0xf6, 0xb6, 0xaf, 0x94, 0x03, 0x68, 0x1d, 0x99, 0xa8, 0x96, 0x4e, 0xc2, 0x29, 0x0c, 0x94, 0x84, + 0x63, 0xe6, 0xc7, 0x14, 0x0f, 0xcd, 0x8f, 0xf9, 0x21, 0x5d, 0xc2, 0x9a, 0x27, 0xd2, 0x8c, 0xf7, + 0x2a, 0x5f, 0x8d, 0x6c, 0x18, 0x75, 0x1d, 0x95, 0x07, 0x3c, 0xc1, 0xcd, 0xaa, 0xc5, 0x05, 0x86, + 0x24, 0x20, 0xd5, 0xed, 0x6f, 0x7d, 0xef, 0xc2, 0x53, 0xdf, 0xfe, 0xde, 0x85, 0xa7, 0xfe, 0xe0, + 0x7b, 0x17, 0x9e, 0xfa, 0xcc, 0xfd, 0x0b, 0xd6, 0xb7, 0xee, 0x5f, 0xb0, 0xbe, 0x7d, 0xff, 0x82, + 0xf5, 0x07, 0xf7, 0x2f, 0x58, 0xdf, 0xbd, 0x7f, 0xc1, 0xfa, 0xea, 0x7f, 0xbd, 0xf0, 0xd4, 0x5b, + 0x3d, 0xc3, 0x1d, 0xe8, 0x8f, 0x57, 0xdc, 0xda, 0xfc, 0xde, 0x25, 0x76, 0xe2, 0x4e, 0x67, 0xc3, + 0xbc, 0x31, 0x04, 0xe6, 0xe5, 0x6c, 0xf8, 0xcb, 0x00, 0x00, 0x00, 0xff, 0xff, 0x8c, 0x17, 0xfe, + 0xd8, 0x30, 0xb8, 0x00, 0x00, } func (m *AWSAuthConfig) Marshal() (dAtA []byte, err error) { @@ -4802,6 +4967,48 @@ func (m *ApplicationList) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *ApplicationMatchExpression) 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 *ApplicationMatchExpression) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ApplicationMatchExpression) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Values) > 0 { + for iNdEx := len(m.Values) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Values[iNdEx]) + copy(dAtA[i:], m.Values[iNdEx]) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Values[iNdEx]))) + i-- + dAtA[i] = 0x1a + } + } + i -= len(m.Operator) + copy(dAtA[i:], m.Operator) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Operator))) + 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 *ApplicationSet) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -4855,6 +5062,61 @@ func (m *ApplicationSet) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *ApplicationSetApplicationStatus) 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 *ApplicationSetApplicationStatus) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ApplicationSetApplicationStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.Status) + copy(dAtA[i:], m.Status) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status))) + i-- + dAtA[i] = 0x2a + i -= len(m.ObservedHash) + copy(dAtA[i:], m.ObservedHash) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.ObservedHash))) + i-- + dAtA[i] = 0x22 + i -= len(m.Message) + copy(dAtA[i:], m.Message) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message))) + i-- + dAtA[i] = 0x1a + 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] = 0x12 + } + i -= len(m.Application) + copy(dAtA[i:], m.Application) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Application))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + func (m *ApplicationSetCondition) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -5219,6 +5481,92 @@ func (m *ApplicationSetNestedGenerator) MarshalToSizedBuffer(dAtA []byte) (int, return len(dAtA) - i, nil } +func (m *ApplicationSetRollingUpdateStep) 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 *ApplicationSetRollingUpdateStep) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ApplicationSetRollingUpdateStep) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.MaxUpdate != nil { + { + size, err := m.MaxUpdate.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.MatchExpressions) > 0 { + for iNdEx := len(m.MatchExpressions) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.MatchExpressions[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 *ApplicationSetRollingUpdateStrategy) 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 *ApplicationSetRollingUpdateStrategy) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ApplicationSetRollingUpdateStrategy) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + 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] = 0xa + } + } + return len(dAtA) - i, nil +} + func (m *ApplicationSetSpec) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -5239,6 +5587,18 @@ func (m *ApplicationSetSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if m.Strategy != nil { + { + 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 + } if m.SyncPolicy != nil { { size, err := m.SyncPolicy.MarshalToSizedBuffer(dAtA[:i]) @@ -5306,6 +5666,20 @@ func (m *ApplicationSetStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if len(m.ApplicationStatus) > 0 { + for iNdEx := len(m.ApplicationStatus) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.ApplicationStatus[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.Conditions) > 0 { for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- { { @@ -5323,7 +5697,7 @@ func (m *ApplicationSetStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *ApplicationSetSyncPolicy) Marshal() (dAtA []byte, err error) { +func (m *ApplicationSetStrategy) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -5333,28 +5707,37 @@ func (m *ApplicationSetSyncPolicy) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ApplicationSetSyncPolicy) MarshalTo(dAtA []byte) (int, error) { +func (m *ApplicationSetStrategy) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ApplicationSetSyncPolicy) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ApplicationSetStrategy) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - i-- - if m.PreserveResourcesOnDeletion { - dAtA[i] = 1 - } else { - dAtA[i] = 0 + if m.RollingUpdate != nil { + { + size, err := m.RollingUpdate.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 } + i -= len(m.Type) + copy(dAtA[i:], m.Type) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type))) i-- - dAtA[i] = 0x8 + dAtA[i] = 0xa return len(dAtA) - i, nil } -func (m *ApplicationSetTemplate) Marshal() (dAtA []byte, err error) { +func (m *ApplicationSetSyncPolicy) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -5364,17 +5747,48 @@ func (m *ApplicationSetTemplate) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ApplicationSetTemplate) MarshalTo(dAtA []byte) (int, error) { +func (m *ApplicationSetSyncPolicy) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ApplicationSetTemplate) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ApplicationSetSyncPolicy) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - { + i-- + if m.PreserveResourcesOnDeletion { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x8 + return len(dAtA) - i, nil +} + +func (m *ApplicationSetTemplate) 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 *ApplicationSetTemplate) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ApplicationSetTemplate) 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 @@ -11835,6 +12249,25 @@ func (m *ApplicationList) Size() (n int) { return n } +func (m *ApplicationMatchExpression) 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.Operator) + n += 1 + l + sovGenerated(uint64(l)) + if len(m.Values) > 0 { + for _, s := range m.Values { + l = len(s) + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + func (m *ApplicationSet) Size() (n int) { if m == nil { return 0 @@ -11850,6 +12283,27 @@ func (m *ApplicationSet) Size() (n int) { return n } +func (m *ApplicationSetApplicationStatus) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Application) + n += 1 + l + sovGenerated(uint64(l)) + if m.LastTransitionTime != nil { + l = m.LastTransitionTime.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + l = len(m.Message) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.ObservedHash) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Status) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + func (m *ApplicationSetCondition) Size() (n int) { if m == nil { return 0 @@ -11978,6 +12432,40 @@ func (m *ApplicationSetNestedGenerator) Size() (n int) { return n } +func (m *ApplicationSetRollingUpdateStep) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.MatchExpressions) > 0 { + for _, e := range m.MatchExpressions { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + if m.MaxUpdate != nil { + l = m.MaxUpdate.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + return n +} + +func (m *ApplicationSetRollingUpdateStrategy) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Steps) > 0 { + for _, e := range m.Steps { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + func (m *ApplicationSetSpec) Size() (n int) { if m == nil { return 0 @@ -11997,6 +12485,10 @@ func (m *ApplicationSetSpec) Size() (n int) { l = m.SyncPolicy.Size() n += 1 + l + sovGenerated(uint64(l)) } + if m.Strategy != nil { + l = m.Strategy.Size() + n += 1 + l + sovGenerated(uint64(l)) + } return n } @@ -12012,6 +12504,27 @@ func (m *ApplicationSetStatus) Size() (n int) { n += 1 + l + sovGenerated(uint64(l)) } } + if len(m.ApplicationStatus) > 0 { + for _, e := range m.ApplicationStatus { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + +func (m *ApplicationSetStrategy) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Type) + n += 1 + l + sovGenerated(uint64(l)) + if m.RollingUpdate != nil { + l = m.RollingUpdate.Size() + n += 1 + l + sovGenerated(uint64(l)) + } return n } @@ -14551,6 +15064,18 @@ func (this *ApplicationList) String() string { }, "") return s } +func (this *ApplicationMatchExpression) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ApplicationMatchExpression{`, + `Key:` + fmt.Sprintf("%v", this.Key) + `,`, + `Operator:` + fmt.Sprintf("%v", this.Operator) + `,`, + `Values:` + fmt.Sprintf("%v", this.Values) + `,`, + `}`, + }, "") + return s +} func (this *ApplicationSet) String() string { if this == nil { return "nil" @@ -14563,6 +15088,20 @@ func (this *ApplicationSet) String() string { }, "") return s } +func (this *ApplicationSetApplicationStatus) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ApplicationSetApplicationStatus{`, + `Application:` + fmt.Sprintf("%v", this.Application) + `,`, + `LastTransitionTime:` + strings.Replace(fmt.Sprintf("%v", this.LastTransitionTime), "Time", "v1.Time", 1) + `,`, + `Message:` + fmt.Sprintf("%v", this.Message) + `,`, + `ObservedHash:` + fmt.Sprintf("%v", this.ObservedHash) + `,`, + `Status:` + fmt.Sprintf("%v", this.Status) + `,`, + `}`, + }, "") + return s +} func (this *ApplicationSetCondition) String() string { if this == nil { return "nil" @@ -14629,6 +15168,37 @@ func (this *ApplicationSetNestedGenerator) String() string { }, "") return s } +func (this *ApplicationSetRollingUpdateStep) String() string { + if this == nil { + return "nil" + } + repeatedStringForMatchExpressions := "[]ApplicationMatchExpression{" + for _, f := range this.MatchExpressions { + repeatedStringForMatchExpressions += strings.Replace(strings.Replace(f.String(), "ApplicationMatchExpression", "ApplicationMatchExpression", 1), `&`, ``, 1) + "," + } + repeatedStringForMatchExpressions += "}" + s := strings.Join([]string{`&ApplicationSetRollingUpdateStep{`, + `MatchExpressions:` + repeatedStringForMatchExpressions + `,`, + `MaxUpdate:` + strings.Replace(fmt.Sprintf("%v", this.MaxUpdate), "IntOrString", "intstr.IntOrString", 1) + `,`, + `}`, + }, "") + return s +} +func (this *ApplicationSetRollingUpdateStrategy) String() string { + if this == nil { + return "nil" + } + repeatedStringForSteps := "[]ApplicationSetRollingUpdateStep{" + for _, f := range this.Steps { + repeatedStringForSteps += strings.Replace(strings.Replace(f.String(), "ApplicationSetRollingUpdateStep", "ApplicationSetRollingUpdateStep", 1), `&`, ``, 1) + "," + } + repeatedStringForSteps += "}" + s := strings.Join([]string{`&ApplicationSetRollingUpdateStrategy{`, + `Steps:` + repeatedStringForSteps + `,`, + `}`, + }, "") + return s +} func (this *ApplicationSetSpec) String() string { if this == nil { return "nil" @@ -14643,6 +15213,7 @@ func (this *ApplicationSetSpec) String() string { `Generators:` + repeatedStringForGenerators + `,`, `Template:` + strings.Replace(strings.Replace(this.Template.String(), "ApplicationSetTemplate", "ApplicationSetTemplate", 1), `&`, ``, 1) + `,`, `SyncPolicy:` + strings.Replace(this.SyncPolicy.String(), "ApplicationSetSyncPolicy", "ApplicationSetSyncPolicy", 1) + `,`, + `Strategy:` + strings.Replace(this.Strategy.String(), "ApplicationSetStrategy", "ApplicationSetStrategy", 1) + `,`, `}`, }, "") return s @@ -14656,8 +15227,25 @@ func (this *ApplicationSetStatus) String() string { repeatedStringForConditions += strings.Replace(strings.Replace(f.String(), "ApplicationSetCondition", "ApplicationSetCondition", 1), `&`, ``, 1) + "," } repeatedStringForConditions += "}" + repeatedStringForApplicationStatus := "[]ApplicationSetApplicationStatus{" + for _, f := range this.ApplicationStatus { + repeatedStringForApplicationStatus += strings.Replace(strings.Replace(f.String(), "ApplicationSetApplicationStatus", "ApplicationSetApplicationStatus", 1), `&`, ``, 1) + "," + } + repeatedStringForApplicationStatus += "}" s := strings.Join([]string{`&ApplicationSetStatus{`, `Conditions:` + repeatedStringForConditions + `,`, + `ApplicationStatus:` + repeatedStringForApplicationStatus + `,`, + `}`, + }, "") + return s +} +func (this *ApplicationSetStrategy) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ApplicationSetStrategy{`, + `Type:` + fmt.Sprintf("%v", this.Type) + `,`, + `RollingUpdate:` + strings.Replace(this.RollingUpdate.String(), "ApplicationSetRollingUpdateStrategy", "ApplicationSetRollingUpdateStrategy", 1) + `,`, `}`, }, "") return s @@ -18060,7 +18648,7 @@ func (m *ApplicationList) Unmarshal(dAtA []byte) error { } return nil } -func (m *ApplicationSet) Unmarshal(dAtA []byte) error { +func (m *ApplicationMatchExpression) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -18083,17 +18671,17 @@ func (m *ApplicationSet) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ApplicationSet: wiretype end group for non-group") + return fmt.Errorf("proto: ApplicationMatchExpression: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ApplicationSet: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ApplicationMatchExpression: 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) + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowGenerated @@ -18103,30 +18691,29 @@ func (m *ApplicationSet) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthGenerated } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthGenerated } if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.Key = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Operator", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowGenerated @@ -18136,30 +18723,29 @@ func (m *ApplicationSet) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthGenerated } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthGenerated } if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.Operator = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowGenerated @@ -18169,24 +18755,23 @@ func (m *ApplicationSet) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthGenerated } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthGenerated } if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.Values = append(m.Values, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex default: iNdEx = preIndex @@ -18209,7 +18794,7 @@ func (m *ApplicationSet) Unmarshal(dAtA []byte) error { } return nil } -func (m *ApplicationSetCondition) Unmarshal(dAtA []byte) error { +func (m *ApplicationSet) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -18232,17 +18817,17 @@ func (m *ApplicationSetCondition) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ApplicationSetCondition: wiretype end group for non-group") + return fmt.Errorf("proto: ApplicationSet: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ApplicationSetCondition: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ApplicationSet: 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) + return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowGenerated @@ -18252,29 +18837,30 @@ func (m *ApplicationSetCondition) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthGenerated } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthGenerated } if postIndex > l { return io.ErrUnexpectedEOF } - m.Type = ApplicationSetConditionType(dAtA[iNdEx:postIndex]) + 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 Message", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowGenerated @@ -18284,27 +18870,28 @@ func (m *ApplicationSetCondition) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthGenerated } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthGenerated } if postIndex > l { return io.ErrUnexpectedEOF } - m.Message = string(dAtA[iNdEx:postIndex]) + 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 LastTransitionTime", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -18331,50 +18918,781 @@ func (m *ApplicationSetCondition) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.LastTransitionTime == nil { - m.LastTransitionTime = &v1.Time{} - } - if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGenerated - } - if iNdEx >= l { + 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 *ApplicationSetApplicationStatus) 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: ApplicationSetApplicationStatus: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ApplicationSetApplicationStatus: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + 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 2: + 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 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 + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ObservedHash", 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.ObservedHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + 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 = 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 *ApplicationSetCondition) 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: ApplicationSetCondition: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ApplicationSetCondition: 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 = ApplicationSetConditionType(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 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 4: + 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 = ApplicationSetConditionStatus(dAtA[iNdEx:postIndex]) + 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 + 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 *ApplicationSetGenerator) 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: ApplicationSetGenerator: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ApplicationSetGenerator: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field List", 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.List == nil { + m.List = &ListGenerator{} + } + if err := m.List.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Clusters", 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.Clusters == nil { + m.Clusters = &ClusterGenerator{} + } + if err := m.Clusters.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Git", 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.Git == nil { + m.Git = &GitGenerator{} + } + if err := m.Git.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SCMProvider", 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.SCMProvider == nil { + m.SCMProvider = &SCMProviderGenerator{} + } + if err := m.SCMProvider.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClusterDecisionResource", 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.ClusterDecisionResource == nil { + m.ClusterDecisionResource = &DuckTypeGenerator{} + } + if err := m.ClusterDecisionResource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PullRequest", 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.PullRequest == nil { + m.PullRequest = &PullRequestGenerator{} + } + if err := m.PullRequest.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Matrix", 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.Matrix == nil { + m.Matrix = &MatrixGenerator{} + } + if err := m.Matrix.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Merge", 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++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthGenerated } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthGenerated } if postIndex > l { return io.ErrUnexpectedEOF } - m.Status = ApplicationSetConditionStatus(dAtA[iNdEx:postIndex]) + if m.Merge == nil { + m.Merge = &MergeGenerator{} + } + if err := m.Merge.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex - case 5: + case 9: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowGenerated @@ -18384,23 +19702,27 @@ func (m *ApplicationSetCondition) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthGenerated } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthGenerated } if postIndex > l { return io.ErrUnexpectedEOF } - m.Reason = string(dAtA[iNdEx:postIndex]) + if m.Selector == nil { + m.Selector = &v1.LabelSelector{} + } + if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex default: iNdEx = preIndex @@ -18423,7 +19745,7 @@ func (m *ApplicationSetCondition) Unmarshal(dAtA []byte) error { } return nil } -func (m *ApplicationSetGenerator) Unmarshal(dAtA []byte) error { +func (m *ApplicationSetList) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -18446,10 +19768,127 @@ func (m *ApplicationSetGenerator) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ApplicationSetGenerator: wiretype end group for non-group") + return fmt.Errorf("proto: ApplicationSetList: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ApplicationSetGenerator: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ApplicationSetList: 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, ApplicationSet{}) + 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 *ApplicationSetNestedGenerator) 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: ApplicationSetNestedGenerator: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ApplicationSetNestedGenerator: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -18698,7 +20137,7 @@ func (m *ApplicationSetGenerator) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Matrix == nil { - m.Matrix = &MatrixGenerator{} + m.Matrix = &v11.JSON{} } if err := m.Matrix.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err @@ -18734,7 +20173,7 @@ func (m *ApplicationSetGenerator) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Merge == nil { - m.Merge = &MergeGenerator{} + m.Merge = &v11.JSON{} } if err := m.Merge.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err @@ -18797,7 +20236,7 @@ func (m *ApplicationSetGenerator) Unmarshal(dAtA []byte) error { } return nil } -func (m *ApplicationSetList) Unmarshal(dAtA []byte) error { +func (m *ApplicationSetRollingUpdateStep) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -18820,15 +20259,15 @@ func (m *ApplicationSetList) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ApplicationSetList: wiretype end group for non-group") + return fmt.Errorf("proto: ApplicationSetRollingUpdateStep: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ApplicationSetList: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ApplicationSetRollingUpdateStep: 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) + return fmt.Errorf("proto: wrong wireType = %d for field MatchExpressions", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -18855,13 +20294,14 @@ func (m *ApplicationSetList) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.MatchExpressions = append(m.MatchExpressions, ApplicationMatchExpression{}) + if err := m.MatchExpressions[len(m.MatchExpressions)-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 Items", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field MaxUpdate", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -18888,8 +20328,10 @@ func (m *ApplicationSetList) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Items = append(m.Items, ApplicationSet{}) - if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.MaxUpdate == nil { + m.MaxUpdate = &intstr.IntOrString{} + } + if err := m.MaxUpdate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -18914,7 +20356,7 @@ func (m *ApplicationSetList) Unmarshal(dAtA []byte) error { } return nil } -func (m *ApplicationSetNestedGenerator) Unmarshal(dAtA []byte) error { +func (m *ApplicationSetRollingUpdateStrategy) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -18937,87 +20379,15 @@ func (m *ApplicationSetNestedGenerator) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ApplicationSetNestedGenerator: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: ApplicationSetNestedGenerator: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field List", 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.List == nil { - m.List = &ListGenerator{} - } - if err := m.List.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Clusters", 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.Clusters == nil { - m.Clusters = &ClusterGenerator{} - } - if err := m.Clusters.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: + return fmt.Errorf("proto: ApplicationSetRollingUpdateStrategy: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ApplicationSetRollingUpdateStrategy: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Git", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Steps", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -19044,54 +20414,66 @@ func (m *ApplicationSetNestedGenerator) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Git == nil { - m.Git = &GitGenerator{} - } - if err := m.Git.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.Steps = append(m.Steps, ApplicationSetRollingUpdateStep{}) + 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 SCMProvider", 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 + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err } - postIndex := iNdEx + msglen - if postIndex < 0 { + if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthGenerated } - if postIndex > l { + if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } - if m.SCMProvider == nil { - m.SCMProvider = &SCMProviderGenerator{} + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ApplicationSetSpec) 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 err := m.SCMProvider.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + if iNdEx >= l { + return io.ErrUnexpectedEOF } - iNdEx = postIndex - case 5: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ClusterDecisionResource", wireType) + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break } - var msglen int + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ApplicationSetSpec: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ApplicationSetSpec: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field GoTemplate", wireType) + } + var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowGenerated @@ -19101,31 +20483,15 @@ func (m *ApplicationSetNestedGenerator) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + v |= 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.ClusterDecisionResource == nil { - m.ClusterDecisionResource = &DuckTypeGenerator{} - } - if err := m.ClusterDecisionResource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 6: + m.GoTemplate = bool(v != 0) + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PullRequest", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Generators", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -19152,16 +20518,14 @@ func (m *ApplicationSetNestedGenerator) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.PullRequest == nil { - m.PullRequest = &PullRequestGenerator{} - } - if err := m.PullRequest.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.Generators = append(m.Generators, ApplicationSetGenerator{}) + if err := m.Generators[len(m.Generators)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 7: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Matrix", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -19188,16 +20552,13 @@ func (m *ApplicationSetNestedGenerator) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Matrix == nil { - m.Matrix = &v11.JSON{} - } - if err := m.Matrix.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 8: + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Merge", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SyncPolicy", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -19224,16 +20585,16 @@ func (m *ApplicationSetNestedGenerator) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Merge == nil { - m.Merge = &v11.JSON{} + if m.SyncPolicy == nil { + m.SyncPolicy = &ApplicationSetSyncPolicy{} } - if err := m.Merge.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.SyncPolicy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 9: + case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Strategy", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -19260,10 +20621,10 @@ func (m *ApplicationSetNestedGenerator) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Selector == nil { - m.Selector = &v1.LabelSelector{} + if m.Strategy == nil { + m.Strategy = &ApplicationSetStrategy{} } - if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Strategy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -19288,7 +20649,7 @@ func (m *ApplicationSetNestedGenerator) Unmarshal(dAtA []byte) error { } return nil } -func (m *ApplicationSetSpec) Unmarshal(dAtA []byte) error { +func (m *ApplicationSetStatus) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -19311,69 +20672,15 @@ func (m *ApplicationSetSpec) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ApplicationSetSpec: wiretype end group for non-group") + return fmt.Errorf("proto: ApplicationSetStatus: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ApplicationSetSpec: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ApplicationSetStatus: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field GoTemplate", 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.GoTemplate = bool(v != 0) - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Generators", 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.Generators = append(m.Generators, ApplicationSetGenerator{}) - if err := m.Generators[len(m.Generators)-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 Template", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -19400,13 +20707,14 @@ func (m *ApplicationSetSpec) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.Conditions = append(m.Conditions, ApplicationSetCondition{}) + if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 4: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SyncPolicy", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ApplicationStatus", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -19433,10 +20741,8 @@ func (m *ApplicationSetSpec) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.SyncPolicy == nil { - m.SyncPolicy = &ApplicationSetSyncPolicy{} - } - if err := m.SyncPolicy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.ApplicationStatus = append(m.ApplicationStatus, ApplicationSetApplicationStatus{}) + if err := m.ApplicationStatus[len(m.ApplicationStatus)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -19461,7 +20767,7 @@ func (m *ApplicationSetSpec) Unmarshal(dAtA []byte) error { } return nil } -func (m *ApplicationSetStatus) Unmarshal(dAtA []byte) error { +func (m *ApplicationSetStrategy) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -19484,15 +20790,47 @@ func (m *ApplicationSetStatus) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ApplicationSetStatus: wiretype end group for non-group") + return fmt.Errorf("proto: ApplicationSetStrategy: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ApplicationSetStatus: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ApplicationSetStrategy: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType) + 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 = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RollingUpdate", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -19519,8 +20857,10 @@ func (m *ApplicationSetStatus) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Conditions = append(m.Conditions, ApplicationSetCondition{}) - if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.RollingUpdate == nil { + m.RollingUpdate = &ApplicationSetRollingUpdateStrategy{} + } + if err := m.RollingUpdate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex diff --git a/pkg/apis/application/v1alpha1/generated.proto b/pkg/apis/application/v1alpha1/generated.proto index d898aff52148f..619cbebb64953 100644 --- a/pkg/apis/application/v1alpha1/generated.proto +++ b/pkg/apis/application/v1alpha1/generated.proto @@ -10,6 +10,7 @@ import "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/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-cd/v2/pkg/apis/application/v1alpha1"; @@ -148,6 +149,14 @@ message ApplicationList { repeated Application items = 2; } +message ApplicationMatchExpression { + optional string key = 1; + + optional string operator = 2; + + repeated string values = 3; +} + // ApplicationSet is a set of Application resources // +genclient // +genclient:noStatus @@ -162,6 +171,24 @@ message ApplicationSet { optional ApplicationSetStatus status = 3; } +// ApplicationSetApplicationCondition contains details about each Application managed by the ApplicationSet +message ApplicationSetApplicationStatus { + // Application contains the name of the Application resource + optional string application = 1; + + // LastTransitionTime is the time the status was last updated + optional k8s.io.apimachinery.pkg.apis.meta.v1.Time lastTransitionTime = 2; + + // Message contains human-readable message indicating details about the status + optional string message = 3; + + // ObservedHash contains the last applied hash of the generated Application resource + optional string observedHash = 4; + + // Status contains the AppSet's perceived status of the managed Application resource: (Waiting, Pending, Progressing, Healthy) + optional string status = 5; +} + // ApplicationSetCondition contains details about an applicationset condition, which is usally an error or warning message ApplicationSetCondition { // Type is an applicationset condition type @@ -236,6 +263,16 @@ message ApplicationSetNestedGenerator { optional k8s.io.apimachinery.pkg.apis.meta.v1.LabelSelector selector = 9; } +message ApplicationSetRollingUpdateStep { + repeated ApplicationMatchExpression matchExpressions = 1; + + optional k8s.io.apimachinery.pkg.util.intstr.IntOrString maxUpdate = 2; +} + +message ApplicationSetRollingUpdateStrategy { + repeated ApplicationSetRollingUpdateStep steps = 1; +} + // ApplicationSetSpec represents a class of application set state. message ApplicationSetSpec { optional bool goTemplate = 1; @@ -245,6 +282,8 @@ message ApplicationSetSpec { optional ApplicationSetTemplate template = 3; optional ApplicationSetSyncPolicy syncPolicy = 4; + + optional ApplicationSetStrategy strategy = 5; } // ApplicationSetStatus defines the observed state of ApplicationSet @@ -252,6 +291,15 @@ message ApplicationSetStatus { // INSERT ADDITIONAL STATUS FIELD - define observed state of cluster // Important: Run "make" to regenerate code after modifying this file repeated ApplicationSetCondition conditions = 1; + + repeated ApplicationSetApplicationStatus applicationStatus = 2; +} + +// ApplicationSetStrategy configures how generated Applications are updated in sequence. +message ApplicationSetStrategy { + optional string type = 1; + + optional ApplicationSetRollingUpdateStrategy rollingUpdate = 2; } // ApplicationSetSyncPolicy configures how generated Applications will relate to their diff --git a/pkg/apis/application/v1alpha1/openapi_generated.go b/pkg/apis/application/v1alpha1/openapi_generated.go index 1c8969e32791b..1d1210415bd1c 100644 --- a/pkg/apis/application/v1alpha1/openapi_generated.go +++ b/pkg/apis/application/v1alpha1/openapi_generated.go @@ -23,13 +23,18 @@ func GetOpenAPIDefinitions(ref common.ReferenceCallback) map[string]common.OpenA "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationCondition": schema_pkg_apis_application_v1alpha1_ApplicationCondition(ref), "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationDestination": schema_pkg_apis_application_v1alpha1_ApplicationDestination(ref), "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationList": schema_pkg_apis_application_v1alpha1_ApplicationList(ref), + "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationMatchExpression": schema_pkg_apis_application_v1alpha1_ApplicationMatchExpression(ref), "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSet": schema_pkg_apis_application_v1alpha1_ApplicationSet(ref), + "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetApplicationStatus": schema_pkg_apis_application_v1alpha1_ApplicationSetApplicationStatus(ref), "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetCondition": schema_pkg_apis_application_v1alpha1_ApplicationSetCondition(ref), "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetGenerator": schema_pkg_apis_application_v1alpha1_ApplicationSetGenerator(ref), "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetList": schema_pkg_apis_application_v1alpha1_ApplicationSetList(ref), "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetNestedGenerator": schema_pkg_apis_application_v1alpha1_ApplicationSetNestedGenerator(ref), + "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetRollingUpdateStep": schema_pkg_apis_application_v1alpha1_ApplicationSetRollingUpdateStep(ref), + "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetRollingUpdateStrategy": schema_pkg_apis_application_v1alpha1_ApplicationSetRollingUpdateStrategy(ref), "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetSpec": schema_pkg_apis_application_v1alpha1_ApplicationSetSpec(ref), "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetStatus": schema_pkg_apis_application_v1alpha1_ApplicationSetStatus(ref), + "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetStrategy": schema_pkg_apis_application_v1alpha1_ApplicationSetStrategy(ref), "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetSyncPolicy": schema_pkg_apis_application_v1alpha1_ApplicationSetSyncPolicy(ref), "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetTemplate": schema_pkg_apis_application_v1alpha1_ApplicationSetTemplate(ref), "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetTemplateMeta": schema_pkg_apis_application_v1alpha1_ApplicationSetTemplateMeta(ref), @@ -648,6 +653,44 @@ func schema_pkg_apis_application_v1alpha1_ApplicationList(ref common.ReferenceCa } } +func schema_pkg_apis_application_v1alpha1_ApplicationMatchExpression(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{ + Type: []string{"string"}, + Format: "", + }, + }, + "operator": { + SchemaProps: spec.SchemaProps{ + Type: []string{"string"}, + Format: "", + }, + }, + "values": { + SchemaProps: spec.SchemaProps{ + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + }, + }, + }, + }, + }, + }, + } +} + func schema_pkg_apis_application_v1alpha1_ApplicationSet(ref common.ReferenceCallback) common.OpenAPIDefinition { return common.OpenAPIDefinition{ Schema: spec.Schema{ @@ -696,6 +739,59 @@ func schema_pkg_apis_application_v1alpha1_ApplicationSet(ref common.ReferenceCal } } +func schema_pkg_apis_application_v1alpha1_ApplicationSetApplicationStatus(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "ApplicationSetApplicationCondition contains details about each Application managed by the ApplicationSet", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "application": { + SchemaProps: spec.SchemaProps{ + Description: "Application contains the name of the Application resource", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "lastTransitionTime": { + SchemaProps: spec.SchemaProps{ + Description: "LastTransitionTime is the time the status was last updated", + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.Time"), + }, + }, + "message": { + SchemaProps: spec.SchemaProps{ + Description: "Message contains human-readable message indicating details about the status", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "observedHash": { + SchemaProps: spec.SchemaProps{ + Description: "ObservedHash contains the last applied hash of the generated Application resource", + Type: []string{"string"}, + Format: "", + }, + }, + "status": { + SchemaProps: spec.SchemaProps{ + Description: "Status contains the AppSet's perceived status of the managed Application resource: (Waiting, Pending, Progressing, Healthy)", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + }, + Required: []string{"application", "message", "status"}, + }, + }, + Dependencies: []string{ + "k8s.io/apimachinery/pkg/apis/meta/v1.Time"}, + } +} + func schema_pkg_apis_application_v1alpha1_ApplicationSetCondition(ref common.ReferenceCallback) common.OpenAPIDefinition { return common.OpenAPIDefinition{ Schema: spec.Schema{ @@ -923,6 +1019,65 @@ func schema_pkg_apis_application_v1alpha1_ApplicationSetNestedGenerator(ref comm } } +func schema_pkg_apis_application_v1alpha1_ApplicationSetRollingUpdateStep(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "matchExpressions": { + 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-cd/v2/pkg/apis/application/v1alpha1.ApplicationMatchExpression"), + }, + }, + }, + }, + }, + "maxUpdate": { + SchemaProps: spec.SchemaProps{ + Ref: ref("k8s.io/apimachinery/pkg/util/intstr.IntOrString"), + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationMatchExpression", "k8s.io/apimachinery/pkg/util/intstr.IntOrString"}, + } +} + +func schema_pkg_apis_application_v1alpha1_ApplicationSetRollingUpdateStrategy(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "steps": { + 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-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetRollingUpdateStep"), + }, + }, + }, + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetRollingUpdateStep"}, + } +} + func schema_pkg_apis_application_v1alpha1_ApplicationSetSpec(ref common.ReferenceCallback) common.OpenAPIDefinition { return common.OpenAPIDefinition{ Schema: spec.Schema{ @@ -960,12 +1115,17 @@ func schema_pkg_apis_application_v1alpha1_ApplicationSetSpec(ref common.Referenc Ref: ref("github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetSyncPolicy"), }, }, + "strategy": { + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetStrategy"), + }, + }, }, Required: []string{"generators", "template"}, }, }, Dependencies: []string{ - "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetGenerator", "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetSyncPolicy", "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetTemplate"}, + "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetGenerator", "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetStrategy", "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetSyncPolicy", "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetTemplate"}, } } @@ -990,11 +1150,50 @@ func schema_pkg_apis_application_v1alpha1_ApplicationSetStatus(ref common.Refere }, }, }, + "applicationStatus": { + 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-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetApplicationStatus"), + }, + }, + }, + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetApplicationStatus", "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetCondition"}, + } +} + +func schema_pkg_apis_application_v1alpha1_ApplicationSetStrategy(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "ApplicationSetStrategy configures how generated Applications are updated in sequence.", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "type": { + SchemaProps: spec.SchemaProps{ + Type: []string{"string"}, + Format: "", + }, + }, + "rollingUpdate": { + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetRollingUpdateStrategy"), + }, + }, }, }, }, Dependencies: []string{ - "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetCondition"}, + "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetRollingUpdateStrategy"}, } } diff --git a/pkg/apis/application/v1alpha1/zz_generated.deepcopy.go b/pkg/apis/application/v1alpha1/zz_generated.deepcopy.go index ef7b43bf4869d..54cb6cd4db594 100644 --- a/pkg/apis/application/v1alpha1/zz_generated.deepcopy.go +++ b/pkg/apis/application/v1alpha1/zz_generated.deepcopy.go @@ -10,6 +10,7 @@ import ( apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1" 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. @@ -293,6 +294,27 @@ func (in *ApplicationList) DeepCopyObject() runtime.Object { return nil } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ApplicationMatchExpression) DeepCopyInto(out *ApplicationMatchExpression) { + *out = *in + if in.Values != nil { + in, out := &in.Values, &out.Values + *out = make([]string, len(*in)) + copy(*out, *in) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ApplicationMatchExpression. +func (in *ApplicationMatchExpression) DeepCopy() *ApplicationMatchExpression { + if in == nil { + return nil + } + out := new(ApplicationMatchExpression) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *ApplicationSet) DeepCopyInto(out *ApplicationSet) { *out = *in @@ -321,6 +343,26 @@ func (in *ApplicationSet) DeepCopyObject() runtime.Object { return nil } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ApplicationSetApplicationStatus) DeepCopyInto(out *ApplicationSetApplicationStatus) { + *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 ApplicationSetApplicationStatus. +func (in *ApplicationSetApplicationStatus) DeepCopy() *ApplicationSetApplicationStatus { + if in == nil { + return nil + } + out := new(ApplicationSetApplicationStatus) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *ApplicationSetCondition) DeepCopyInto(out *ApplicationSetCondition) { *out = *in @@ -518,6 +560,57 @@ func (in ApplicationSetNestedGenerators) DeepCopy() ApplicationSetNestedGenerato return *out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ApplicationSetRollingUpdateStep) DeepCopyInto(out *ApplicationSetRollingUpdateStep) { + *out = *in + if in.MatchExpressions != nil { + in, out := &in.MatchExpressions, &out.MatchExpressions + *out = make([]ApplicationMatchExpression, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + if in.MaxUpdate != nil { + in, out := &in.MaxUpdate, &out.MaxUpdate + *out = new(intstr.IntOrString) + **out = **in + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ApplicationSetRollingUpdateStep. +func (in *ApplicationSetRollingUpdateStep) DeepCopy() *ApplicationSetRollingUpdateStep { + if in == nil { + return nil + } + out := new(ApplicationSetRollingUpdateStep) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ApplicationSetRollingUpdateStrategy) DeepCopyInto(out *ApplicationSetRollingUpdateStrategy) { + *out = *in + if in.Steps != nil { + in, out := &in.Steps, &out.Steps + *out = make([]ApplicationSetRollingUpdateStep, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ApplicationSetRollingUpdateStrategy. +func (in *ApplicationSetRollingUpdateStrategy) DeepCopy() *ApplicationSetRollingUpdateStrategy { + if in == nil { + return nil + } + out := new(ApplicationSetRollingUpdateStrategy) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *ApplicationSetSpec) DeepCopyInto(out *ApplicationSetSpec) { *out = *in @@ -534,6 +627,11 @@ func (in *ApplicationSetSpec) DeepCopyInto(out *ApplicationSetSpec) { *out = new(ApplicationSetSyncPolicy) **out = **in } + if in.Strategy != nil { + in, out := &in.Strategy, &out.Strategy + *out = new(ApplicationSetStrategy) + (*in).DeepCopyInto(*out) + } return } @@ -557,6 +655,13 @@ func (in *ApplicationSetStatus) DeepCopyInto(out *ApplicationSetStatus) { (*in)[i].DeepCopyInto(&(*out)[i]) } } + if in.ApplicationStatus != nil { + in, out := &in.ApplicationStatus, &out.ApplicationStatus + *out = make([]ApplicationSetApplicationStatus, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } return } @@ -570,6 +675,27 @@ func (in *ApplicationSetStatus) DeepCopy() *ApplicationSetStatus { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ApplicationSetStrategy) DeepCopyInto(out *ApplicationSetStrategy) { + *out = *in + if in.RollingUpdate != nil { + in, out := &in.RollingUpdate, &out.RollingUpdate + *out = new(ApplicationSetRollingUpdateStrategy) + (*in).DeepCopyInto(*out) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ApplicationSetStrategy. +func (in *ApplicationSetStrategy) DeepCopy() *ApplicationSetStrategy { + if in == nil { + return nil + } + out := new(ApplicationSetStrategy) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *ApplicationSetSyncPolicy) DeepCopyInto(out *ApplicationSetSyncPolicy) { *out = *in