diff --git a/VERSION b/VERSION index 6f4eebdf6f..ac39a106c4 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -0.8.1 +0.9.0 diff --git a/cmd/argocd-application-controller/main.go b/cmd/argocd-application-controller/main.go index ca03a939fc..da6397feec 100644 --- a/cmd/argocd-application-controller/main.go +++ b/cmd/argocd-application-controller/main.go @@ -12,6 +12,7 @@ import ( "github.com/spf13/cobra" "k8s.io/client-go/kubernetes" "k8s.io/client-go/tools/clientcmd" + // load the gcp plugin (required to authenticate against GKE clusters). _ "k8s.io/client-go/plugin/pkg/client/auth/gcp" // load the oidc plugin (required to authenticate with OpenID Connect). @@ -23,8 +24,6 @@ import ( appclientset "github.com/argoproj/argo-cd/pkg/client/clientset/versioned" "github.com/argoproj/argo-cd/reposerver" "github.com/argoproj/argo-cd/util/cli" - "github.com/argoproj/argo-cd/util/db" - "github.com/argoproj/argo-cd/util/kube" "github.com/argoproj/argo-cd/util/stats" ) @@ -67,27 +66,14 @@ func newCommand() *cobra.Command { namespace, _, err := clientConfig.Namespace() errors.CheckError(err) - // TODO (amatyushentsev): Use config map to store controller configuration - controllerConfig := controller.ApplicationControllerConfig{ - Namespace: namespace, - InstanceID: "", - } - db := db.NewDB(namespace, kubeClient) resyncDuration := time.Duration(appResyncPeriod) * time.Second repoClientset := reposerver.NewRepositoryServerClientset(repoServerAddress) - kubectlCmd := kube.KubectlCmd{} - appStateManager := controller.NewAppStateManager(db, appClient, repoClientset, namespace, kubectlCmd) - appController := controller.NewApplicationController( namespace, kubeClient, appClient, repoClientset, - db, - kubectlCmd, - appStateManager, - resyncDuration, - &controllerConfig) + resyncDuration) secretController := controller.NewSecretController(kubeClient, repoClientset, resyncDuration, namespace) ctx, cancel := context.WithCancel(context.Background()) diff --git a/cmd/argocd/commands/app.go b/cmd/argocd/commands/app.go index 8569243d55..d6ea4ed9ff 100644 --- a/cmd/argocd/commands/app.go +++ b/cmd/argocd/commands/app.go @@ -119,6 +119,18 @@ func NewApplicationCreateCommand(clientOpts *argocdclient.ClientOptions) *cobra. if len(appOpts.valuesFiles) > 0 { app.Spec.Source.ValuesFiles = appOpts.valuesFiles } + switch appOpts.syncPolicy { + case "automated": + app.Spec.SyncPolicy = &argoappv1.SyncPolicy{ + Automated: &argoappv1.SyncPolicyAutomated{ + Prune: appOpts.autoPrune, + }, + } + case "none", "": + app.Spec.SyncPolicy = nil + default: + log.Fatalf("Invalid sync-policy: %s", appOpts.syncPolicy) + } conn, appIf := argocdclient.NewClientOrDie(clientOpts).NewApplicationClientOrDie() defer util.Close(conn) appCreateRequest := application.ApplicationCreateRequest{ @@ -182,6 +194,16 @@ func NewApplicationGetCommand(clientOpts *argocdclient.ClientOptions) *cobra.Com if len(app.Spec.Source.ValuesFiles) > 0 { fmt.Printf(printOpFmtStr, "Helm Values:", strings.Join(app.Spec.Source.ValuesFiles, ",")) } + var syncPolicy string + if app.Spec.SyncPolicy != nil && app.Spec.SyncPolicy.Automated != nil { + syncPolicy = "Automated" + if app.Spec.SyncPolicy.Automated.Prune { + syncPolicy += " (Prune)" + } + } else { + syncPolicy = "" + } + fmt.Printf(printOpFmtStr, "Sync Policy:", syncPolicy) if len(app.Status.Conditions) > 0 { fmt.Println() @@ -313,6 +335,17 @@ func NewApplicationSetCommand(clientOpts *argocdclient.ClientOptions) *cobra.Com app.Spec.Destination.Namespace = appOpts.destNamespace case "project": app.Spec.Project = appOpts.project + case "sync-policy": + switch appOpts.syncPolicy { + case "automated": + app.Spec.SyncPolicy = &argoappv1.SyncPolicy{ + Automated: &argoappv1.SyncPolicyAutomated{}, + } + case "none": + app.Spec.SyncPolicy = nil + default: + log.Fatalf("Invalid sync-policy: %s", appOpts.syncPolicy) + } } }) if visited == 0 { @@ -320,6 +353,13 @@ func NewApplicationSetCommand(clientOpts *argocdclient.ClientOptions) *cobra.Com c.HelpFunc()(c, args) os.Exit(1) } + if c.Flags().Changed("auto-prune") { + if app.Spec.SyncPolicy == nil || app.Spec.SyncPolicy.Automated == nil { + log.Fatal("Cannot set --auto-prune: application not configured with automatic sync") + } + app.Spec.SyncPolicy.Automated.Prune = appOpts.autoPrune + } + setParameterOverrides(app, appOpts.parameters) oldOverrides := app.Spec.Source.ComponentParameterOverrides updatedSpec, err := appIf.UpdateSpec(context.Background(), &application.ApplicationUpdateSpecRequest{ @@ -358,6 +398,8 @@ type appOptions struct { parameters []string valuesFiles []string project string + syncPolicy string + autoPrune bool } func addAppFlags(command *cobra.Command, opts *appOptions) { @@ -370,6 +412,8 @@ func addAppFlags(command *cobra.Command, opts *appOptions) { command.Flags().StringArrayVarP(&opts.parameters, "parameter", "p", []string{}, "set a parameter override (e.g. -p guestbook=image=example/guestbook:latest)") command.Flags().StringArrayVar(&opts.valuesFiles, "values", []string{}, "Helm values file(s) to use") command.Flags().StringVar(&opts.project, "project", "", "Application project name") + command.Flags().StringVar(&opts.syncPolicy, "sync-policy", "", "Set the sync policy (one of: automated, none)") + command.Flags().BoolVar(&opts.autoPrune, "auto-prune", false, "Set automatic pruning when sync is automated") } // NewApplicationUnsetCommand returns a new instance of an `argocd app unset` command diff --git a/controller/appcontroller.go b/controller/appcontroller.go index 0bd92f6fcb..18aa48772a 100644 --- a/controller/appcontroller.go +++ b/controller/appcontroller.go @@ -14,9 +14,6 @@ import ( "k8s.io/apimachinery/pkg/api/errors" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" - "k8s.io/apimachinery/pkg/fields" - "k8s.io/apimachinery/pkg/labels" - "k8s.io/apimachinery/pkg/selection" "k8s.io/apimachinery/pkg/types" "k8s.io/apimachinery/pkg/util/runtime" "k8s.io/apimachinery/pkg/util/strategicpatch" @@ -71,30 +68,28 @@ func NewApplicationController( kubeClientset kubernetes.Interface, applicationClientset appclientset.Interface, repoClientset reposerver.Clientset, - db db.ArgoDB, - kubectl kube.Kubectl, - appStateManager AppStateManager, appResyncPeriod time.Duration, - config *ApplicationControllerConfig, ) *ApplicationController { - appRefreshQueue := workqueue.NewRateLimitingQueue(workqueue.DefaultControllerRateLimiter()) - appOperationQueue := workqueue.NewRateLimitingQueue(workqueue.DefaultControllerRateLimiter()) - return &ApplicationController{ + db := db.NewDB(namespace, kubeClientset) + kubectlCmd := kube.KubectlCmd{} + appStateManager := NewAppStateManager(db, applicationClientset, repoClientset, namespace, kubectlCmd) + ctrl := ApplicationController{ namespace: namespace, kubeClientset: kubeClientset, - kubectl: kubectl, + kubectl: kubectlCmd, applicationClientset: applicationClientset, repoClientset: repoClientset, - appRefreshQueue: appRefreshQueue, - appOperationQueue: appOperationQueue, + appRefreshQueue: workqueue.NewRateLimitingQueue(workqueue.DefaultControllerRateLimiter()), + appOperationQueue: workqueue.NewRateLimitingQueue(workqueue.DefaultControllerRateLimiter()), appStateManager: appStateManager, - appInformer: newApplicationInformer(applicationClientset, appRefreshQueue, appOperationQueue, appResyncPeriod, config), db: db, statusRefreshTimeout: appResyncPeriod, forceRefreshApps: make(map[string]bool), forceRefreshAppsMutex: &sync.Mutex{}, auditLogger: argo.NewAuditLogger(namespace, kubeClientset, "application-controller"), } + ctrl.appInformer = ctrl.newApplicationInformer() + return &ctrl } // Run starts the Application CRD controller. @@ -371,11 +366,12 @@ func (ctrl *ApplicationController) setAppCondition(app *appv1.Application, condi } func (ctrl *ApplicationController) processRequestedAppOperation(app *appv1.Application) { + logCtx := log.WithField("application", app.Name) var state *appv1.OperationState // Recover from any unexpected panics and automatically set the status to be failed defer func() { if r := recover(); r != nil { - log.Errorf("Recovered from panic: %+v\n%s", r, debug.Stack()) + logCtx.Errorf("Recovered from panic: %+v\n%s", r, debug.Stack()) state.Phase = appv1.OperationError if rerr, ok := r.(error); ok { state.Message = rerr.Error() @@ -392,20 +388,20 @@ func (ctrl *ApplicationController) processRequestedAppOperation(app *appv1.Appli // again. To detect this, always retrieve the latest version to ensure it is not stale. freshApp, err := ctrl.applicationClientset.ArgoprojV1alpha1().Applications(ctrl.namespace).Get(app.ObjectMeta.Name, metav1.GetOptions{}) if err != nil { - log.Errorf("Failed to retrieve latest application state: %v", err) + logCtx.Errorf("Failed to retrieve latest application state: %v", err) return } if !isOperationInProgress(freshApp) { - log.Infof("Skipping operation on stale application state (%s)", app.ObjectMeta.Name) + logCtx.Infof("Skipping operation on stale application state") return } app = freshApp state = app.Status.OperationState.DeepCopy() - log.Infof("Resuming in-progress operation. app: %s, phase: %s, message: %s", app.ObjectMeta.Name, state.Phase, state.Message) + logCtx.Infof("Resuming in-progress operation. phase: %s, message: %s", state.Phase, state.Message) } else { state = &appv1.OperationState{Phase: appv1.OperationRunning, Operation: *app.Operation, StartedAt: metav1.Now()} ctrl.setOperationState(app, state) - log.Infof("Initialized new operation. app: %s, operation: %v", app.ObjectMeta.Name, *app.Operation) + logCtx.Infof("Initialized new operation: %v", *app.Operation) } ctrl.appStateManager.SyncAppState(app, state) @@ -530,6 +526,12 @@ func (ctrl *ApplicationController) processAppRefreshQueueItem() (processNext boo if err != nil { conditions = append(conditions, appv1.ApplicationCondition{Type: appv1.ApplicationConditionComparisonError, Message: err.Error()}) } + + syncErrCond := ctrl.autoSync(app, comparisonResult) + if syncErrCond != nil { + conditions = append(conditions, *syncErrCond) + } + ctrl.updateAppStatus(app, comparisonResult, healthState, parameters, conditions) return } @@ -588,6 +590,7 @@ func (ctrl *ApplicationController) refreshAppConditions(app *appv1.Application) appv1.ApplicationConditionUnknownError: true, appv1.ApplicationConditionComparisonError: true, appv1.ApplicationConditionSharedResourceWarning: true, + appv1.ApplicationConditionSyncError: true, } appConditions := make([]appv1.ApplicationCondition, 0) for i := 0; i < len(app.Status.Conditions); i++ { @@ -691,33 +694,67 @@ func (ctrl *ApplicationController) updateAppStatus( } } -func newApplicationInformer( - appClientset appclientset.Interface, - appQueue workqueue.RateLimitingInterface, - appOperationQueue workqueue.RateLimitingInterface, - appResyncPeriod time.Duration, - config *ApplicationControllerConfig) cache.SharedIndexInformer { +// autoSync will initiate a sync operation for an application configured with automated sync +func (ctrl *ApplicationController) autoSync(app *appv1.Application, comparisonResult *appv1.ComparisonResult) *appv1.ApplicationCondition { + if app.Spec.SyncPolicy == nil || app.Spec.SyncPolicy.Automated == nil { + return nil + } + logCtx := log.WithFields(log.Fields{"application": app.Name}) + if app.Operation != nil { + logCtx.Infof("Skipping auto-sync: another operation is in progress") + return nil + } + // Only perform auto-sync if we detect OutOfSync status. This is to prevent us from attempting + // a sync when application is already in a Synced or Unknown state + if comparisonResult.Status != appv1.ComparisonStatusOutOfSync { + logCtx.Infof("Skipping auto-sync: application status is %s", comparisonResult.Status) + return nil + } + desiredCommitSHA := comparisonResult.Revision + // It is possible for manifests to remain OutOfSync even after a sync/kubectl apply (e.g. + // auto-sync with pruning disabled). We need to ensure that we do not keep Syncing an + // application in an infinite loop. To detect this, we only attempt the Sync if the revision + // and parameter overrides do *not* appear in the application's most recent history. + historyLen := len(app.Status.History) + if historyLen > 0 { + mostRecent := app.Status.History[historyLen-1] + if mostRecent.Revision == desiredCommitSHA && reflect.DeepEqual(app.Spec.Source.ComponentParameterOverrides, mostRecent.ComponentParameterOverrides) { + logCtx.Infof("Skipping auto-sync: most recent sync already to %s", desiredCommitSHA) + return nil + } + } + // If a sync failed, the revision will not make it's way into application history. We also need + // to check the operationState to see if the last operation was the one we just attempted. + if app.Status.OperationState != nil && app.Status.OperationState.SyncResult != nil { + if app.Status.OperationState.SyncResult.Revision == desiredCommitSHA { + logCtx.Warnf("Skipping auto-sync: failed previous sync attempt to %s", desiredCommitSHA) + message := fmt.Sprintf("Failed sync attempt to %s: %s", desiredCommitSHA, app.Status.OperationState.Message) + return &appv1.ApplicationCondition{Type: appv1.ApplicationConditionSyncError, Message: message} + } + } - appInformerFactory := appinformers.NewFilteredSharedInformerFactory( - appClientset, - appResyncPeriod, - config.Namespace, - func(options *metav1.ListOptions) { - var instanceIDReq *labels.Requirement - var err error - if config.InstanceID != "" { - instanceIDReq, err = labels.NewRequirement(common.LabelKeyApplicationControllerInstanceID, selection.Equals, []string{config.InstanceID}) - } else { - instanceIDReq, err = labels.NewRequirement(common.LabelKeyApplicationControllerInstanceID, selection.DoesNotExist, nil) - } - if err != nil { - panic(err) - } - - options.FieldSelector = fields.Everything().String() - labelSelector := labels.NewSelector().Add(*instanceIDReq) - options.LabelSelector = labelSelector.String() + op := appv1.Operation{ + Sync: &appv1.SyncOperation{ + Revision: desiredCommitSHA, + Prune: app.Spec.SyncPolicy.Automated.Prune, }, + } + appIf := ctrl.applicationClientset.ArgoprojV1alpha1().Applications(app.Namespace) + _, err := argo.SetAppOperation(context.Background(), appIf, ctrl.auditLogger, app.Name, &op) + if err != nil { + logCtx.Errorf("Failed to initiate auto-sync to %s: %v", desiredCommitSHA, err) + return &appv1.ApplicationCondition{Type: appv1.ApplicationConditionSyncError, Message: err.Error()} + } + logCtx.Infof("Initiated auto-sync to %s", desiredCommitSHA) + return nil +} + +func (ctrl *ApplicationController) newApplicationInformer() cache.SharedIndexInformer { + appInformerFactory := appinformers.NewFilteredSharedInformerFactory( + ctrl.applicationClientset, + ctrl.statusRefreshTimeout, + ctrl.namespace, + func(options *metav1.ListOptions) {}, ) informer := appInformerFactory.Argoproj().V1alpha1().Applications().Informer() informer.AddEventHandler( @@ -725,23 +762,32 @@ func newApplicationInformer( AddFunc: func(obj interface{}) { key, err := cache.MetaNamespaceKeyFunc(obj) if err == nil { - appQueue.Add(key) - appOperationQueue.Add(key) + ctrl.appRefreshQueue.Add(key) + ctrl.appOperationQueue.Add(key) } }, UpdateFunc: func(old, new interface{}) { key, err := cache.MetaNamespaceKeyFunc(new) - if err == nil { - appQueue.Add(key) - appOperationQueue.Add(key) + if err != nil { + return } + oldApp, oldOK := old.(*appv1.Application) + newApp, newOK := new.(*appv1.Application) + if oldOK && newOK { + if toggledAutomatedSync(oldApp, newApp) { + log.WithField("application", newApp.Name).Info("Enabled automated sync") + ctrl.forceAppRefresh(newApp.Name) + } + } + ctrl.appRefreshQueue.Add(key) + ctrl.appOperationQueue.Add(key) }, DeleteFunc: func(obj interface{}) { // IndexerInformer uses a delta queue, therefore for deletes we have to use this // key function. key, err := cache.DeletionHandlingMetaNamespaceKeyFunc(obj) if err == nil { - appQueue.Add(key) + ctrl.appRefreshQueue.Add(key) } }, }, @@ -752,3 +798,17 @@ func newApplicationInformer( func isOperationInProgress(app *appv1.Application) bool { return app.Status.OperationState != nil && !app.Status.OperationState.Phase.Completed() } + +// toggledAutomatedSync tests if an app went from auto-sync disabled to enabled. +// if it was toggled to be enabled, the informer handler will force a refresh +func toggledAutomatedSync(old *appv1.Application, new *appv1.Application) bool { + if new.Spec.SyncPolicy == nil || new.Spec.SyncPolicy.Automated == nil { + return false + } + // auto-sync is enabled. check if it was previously disabled + if old.Spec.SyncPolicy == nil || old.Spec.SyncPolicy.Automated == nil { + return true + } + // nothing changed + return false +} diff --git a/controller/appcontroller_test.go b/controller/appcontroller_test.go new file mode 100644 index 0000000000..2f7de5fc46 --- /dev/null +++ b/controller/appcontroller_test.go @@ -0,0 +1,141 @@ +package controller + +import ( + "testing" + "time" + + "github.com/ghodss/yaml" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/client-go/kubernetes/fake" + + argoappv1 "github.com/argoproj/argo-cd/pkg/apis/application/v1alpha1" + appclientset "github.com/argoproj/argo-cd/pkg/client/clientset/versioned/fake" + reposerver "github.com/argoproj/argo-cd/reposerver/mocks" + "github.com/stretchr/testify/assert" +) + +func newFakeController(apps ...runtime.Object) *ApplicationController { + kubeClientset := fake.NewSimpleClientset() + appClientset := appclientset.NewSimpleClientset(apps...) + repoClientset := reposerver.Clientset{} + return NewApplicationController( + "argocd", + kubeClientset, + appClientset, + &repoClientset, + time.Minute, + ) +} + +var fakeApp = ` +apiVersion: argoproj.io/v1alpha1 +kind: Application +metadata: + name: my-app + namespace: argocd +spec: + destination: + namespace: dummy-namespace + server: https://localhost:6443 + project: default + source: + path: some/path + repoURL: https://github.com/argoproj/argocd-example-apps.git + syncPolicy: + automated: {} +status: + history: + - deployedAt: 2018-09-08T09:16:50Z + id: 0 + params: [] + revision: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +` + +func newFakeApp() *argoappv1.Application { + var app argoappv1.Application + err := yaml.Unmarshal([]byte(fakeApp), &app) + if err != nil { + panic(err) + } + return &app +} + +func TestAutoSync(t *testing.T) { + app := newFakeApp() + ctrl := newFakeController(app) + compRes := argoappv1.ComparisonResult{ + Status: argoappv1.ComparisonStatusOutOfSync, + Revision: "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + } + cond := ctrl.autoSync(app, &compRes) + assert.Nil(t, cond) + app, err := ctrl.applicationClientset.ArgoprojV1alpha1().Applications("argocd").Get("my-app", metav1.GetOptions{}) + assert.NoError(t, err) + assert.NotNil(t, app.Operation) + assert.NotNil(t, app.Operation.Sync) + assert.False(t, app.Operation.Sync.Prune) +} + +func TestSkipAutoSync(t *testing.T) { + // Verify we skip when we previously synced to it in our most recent history + // Set current to 'aaaaa', desired to 'aaaa' and mark system OutOfSync + app := newFakeApp() + ctrl := newFakeController(app) + compRes := argoappv1.ComparisonResult{ + Status: argoappv1.ComparisonStatusOutOfSync, + Revision: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + } + cond := ctrl.autoSync(app, &compRes) + assert.Nil(t, cond) + app, err := ctrl.applicationClientset.ArgoprojV1alpha1().Applications("argocd").Get("my-app", metav1.GetOptions{}) + assert.NoError(t, err) + assert.Nil(t, app.Operation) + + // Verify we skip when we are already Synced (even if revision is different) + app = newFakeApp() + ctrl = newFakeController(app) + compRes = argoappv1.ComparisonResult{ + Status: argoappv1.ComparisonStatusSynced, + Revision: "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + } + cond = ctrl.autoSync(app, &compRes) + assert.Nil(t, cond) + app, err = ctrl.applicationClientset.ArgoprojV1alpha1().Applications("argocd").Get("my-app", metav1.GetOptions{}) + assert.NoError(t, err) + assert.Nil(t, app.Operation) + + // Verify we skip when auto-sync is disabled + app = newFakeApp() + app.Spec.SyncPolicy = nil + ctrl = newFakeController(app) + compRes = argoappv1.ComparisonResult{ + Status: argoappv1.ComparisonStatusOutOfSync, + Revision: "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + } + cond = ctrl.autoSync(app, &compRes) + assert.Nil(t, cond) + app, err = ctrl.applicationClientset.ArgoprojV1alpha1().Applications("argocd").Get("my-app", metav1.GetOptions{}) + assert.NoError(t, err) + assert.Nil(t, app.Operation) + + // Verify we skip when previous sync attempt failed and return error condition + // Set current to 'aaaaa', desired to 'bbbbb' and add 'bbbbb' to failure history + app = newFakeApp() + app.Status.OperationState = &argoappv1.OperationState{ + Phase: argoappv1.OperationFailed, + SyncResult: &argoappv1.SyncOperationResult{ + Revision: "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + }, + } + ctrl = newFakeController(app) + compRes = argoappv1.ComparisonResult{ + Status: argoappv1.ComparisonStatusOutOfSync, + Revision: "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + } + cond = ctrl.autoSync(app, &compRes) + assert.NotNil(t, cond) + app, err = ctrl.applicationClientset.ArgoprojV1alpha1().Applications("argocd").Get("my-app", metav1.GetOptions{}) + assert.NoError(t, err) + assert.Nil(t, app.Operation) +} diff --git a/controller/state.go b/controller/state.go index 5ba1ebcbdf..a392435bcd 100644 --- a/controller/state.go +++ b/controller/state.go @@ -318,6 +318,9 @@ func (s *ksonnetAppStateManager) CompareAppState(app *v1alpha1.Application, revi Resources: resources, Status: comparisonStatus, } + if manifestInfo != nil { + compResult.Revision = manifestInfo.Revision + } return &compResult, manifestInfo, conditions, nil } diff --git a/pkg/apis/application/v1alpha1/generated.pb.go b/pkg/apis/application/v1alpha1/generated.pb.go index c5be0bc4bc..d7f82922d0 100644 --- a/pkg/apis/application/v1alpha1/generated.pb.go +++ b/pkg/apis/application/v1alpha1/generated.pb.go @@ -40,6 +40,8 @@ RollbackOperation SyncOperation SyncOperationResult + SyncPolicy + SyncPolicyAutomated SyncStrategy SyncStrategyApply SyncStrategyHook @@ -199,21 +201,29 @@ func (m *SyncOperationResult) Reset() { *m = SyncOperationRes func (*SyncOperationResult) ProtoMessage() {} func (*SyncOperationResult) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{31} } +func (m *SyncPolicy) Reset() { *m = SyncPolicy{} } +func (*SyncPolicy) ProtoMessage() {} +func (*SyncPolicy) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{32} } + +func (m *SyncPolicyAutomated) Reset() { *m = SyncPolicyAutomated{} } +func (*SyncPolicyAutomated) ProtoMessage() {} +func (*SyncPolicyAutomated) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{33} } + func (m *SyncStrategy) Reset() { *m = SyncStrategy{} } func (*SyncStrategy) ProtoMessage() {} -func (*SyncStrategy) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{32} } +func (*SyncStrategy) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{34} } func (m *SyncStrategyApply) Reset() { *m = SyncStrategyApply{} } func (*SyncStrategyApply) ProtoMessage() {} -func (*SyncStrategyApply) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{33} } +func (*SyncStrategyApply) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{35} } func (m *SyncStrategyHook) Reset() { *m = SyncStrategyHook{} } func (*SyncStrategyHook) ProtoMessage() {} -func (*SyncStrategyHook) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{34} } +func (*SyncStrategyHook) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{36} } func (m *TLSClientConfig) Reset() { *m = TLSClientConfig{} } func (*TLSClientConfig) ProtoMessage() {} -func (*TLSClientConfig) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{35} } +func (*TLSClientConfig) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{37} } func init() { proto.RegisterType((*AppProject)(nil), "github.com.argoproj.argo_cd.pkg.apis.application.v1alpha1.AppProject") @@ -248,6 +258,8 @@ func init() { proto.RegisterType((*RollbackOperation)(nil), "github.com.argoproj.argo_cd.pkg.apis.application.v1alpha1.RollbackOperation") proto.RegisterType((*SyncOperation)(nil), "github.com.argoproj.argo_cd.pkg.apis.application.v1alpha1.SyncOperation") proto.RegisterType((*SyncOperationResult)(nil), "github.com.argoproj.argo_cd.pkg.apis.application.v1alpha1.SyncOperationResult") + proto.RegisterType((*SyncPolicy)(nil), "github.com.argoproj.argo_cd.pkg.apis.application.v1alpha1.SyncPolicy") + proto.RegisterType((*SyncPolicyAutomated)(nil), "github.com.argoproj.argo_cd.pkg.apis.application.v1alpha1.SyncPolicyAutomated") proto.RegisterType((*SyncStrategy)(nil), "github.com.argoproj.argo_cd.pkg.apis.application.v1alpha1.SyncStrategy") proto.RegisterType((*SyncStrategyApply)(nil), "github.com.argoproj.argo_cd.pkg.apis.application.v1alpha1.SyncStrategyApply") proto.RegisterType((*SyncStrategyHook)(nil), "github.com.argoproj.argo_cd.pkg.apis.application.v1alpha1.SyncStrategyHook") @@ -624,6 +636,16 @@ func (m *ApplicationSpec) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintGenerated(dAtA, i, uint64(len(m.Project))) i += copy(dAtA[i:], m.Project) + if m.SyncPolicy != nil { + dAtA[i] = 0x22 + i++ + i = encodeVarintGenerated(dAtA, i, uint64(m.SyncPolicy.Size())) + n11, err := m.SyncPolicy.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n11 + } return i, nil } @@ -645,11 +667,11 @@ func (m *ApplicationStatus) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0xa i++ i = encodeVarintGenerated(dAtA, i, uint64(m.ComparisonResult.Size())) - n11, err := m.ComparisonResult.MarshalTo(dAtA[i:]) + n12, err := m.ComparisonResult.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n11 + i += n12 if len(m.History) > 0 { for _, msg := range m.History { dAtA[i] = 0x12 @@ -677,20 +699,20 @@ func (m *ApplicationStatus) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0x22 i++ i = encodeVarintGenerated(dAtA, i, uint64(m.Health.Size())) - n12, err := m.Health.MarshalTo(dAtA[i:]) + n13, err := m.Health.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n12 + i += n13 if m.OperationState != nil { dAtA[i] = 0x2a i++ i = encodeVarintGenerated(dAtA, i, uint64(m.OperationState.Size())) - n13, err := m.OperationState.MarshalTo(dAtA[i:]) + n14, err := m.OperationState.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n13 + i += n14 } if len(m.Conditions) > 0 { for _, msg := range m.Conditions { @@ -729,11 +751,11 @@ func (m *ApplicationWatchEvent) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0x12 i++ i = encodeVarintGenerated(dAtA, i, uint64(m.Application.Size())) - n14, err := m.Application.MarshalTo(dAtA[i:]) + n15, err := m.Application.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n14 + i += n15 return i, nil } @@ -763,19 +785,19 @@ func (m *Cluster) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0x1a i++ i = encodeVarintGenerated(dAtA, i, uint64(m.Config.Size())) - n15, err := m.Config.MarshalTo(dAtA[i:]) - if err != nil { - return 0, err - } - i += n15 - dAtA[i] = 0x22 - i++ - i = encodeVarintGenerated(dAtA, i, uint64(m.ConnectionState.Size())) - n16, err := m.ConnectionState.MarshalTo(dAtA[i:]) + n16, err := m.Config.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n16 + dAtA[i] = 0x22 + i++ + i = encodeVarintGenerated(dAtA, i, uint64(m.ConnectionState.Size())) + n17, err := m.ConnectionState.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n17 return i, nil } @@ -809,11 +831,11 @@ func (m *ClusterConfig) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0x22 i++ i = encodeVarintGenerated(dAtA, i, uint64(m.TLSClientConfig.Size())) - n17, err := m.TLSClientConfig.MarshalTo(dAtA[i:]) + n18, err := m.TLSClientConfig.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n17 + i += n18 return i, nil } @@ -835,11 +857,11 @@ func (m *ClusterList) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0xa i++ i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size())) - n18, err := m.ListMeta.MarshalTo(dAtA[i:]) + n19, err := m.ListMeta.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n18 + i += n19 if len(m.Items) > 0 { for _, msg := range m.Items { dAtA[i] = 0x12 @@ -873,19 +895,19 @@ func (m *ComparisonResult) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0xa i++ i = encodeVarintGenerated(dAtA, i, uint64(m.ComparedAt.Size())) - n19, err := m.ComparedAt.MarshalTo(dAtA[i:]) - if err != nil { - return 0, err - } - i += n19 - dAtA[i] = 0x12 - i++ - i = encodeVarintGenerated(dAtA, i, uint64(m.ComparedTo.Size())) - n20, err := m.ComparedTo.MarshalTo(dAtA[i:]) + n20, err := m.ComparedAt.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n20 + dAtA[i] = 0x12 + i++ + i = encodeVarintGenerated(dAtA, i, uint64(m.ComparedTo.Size())) + n21, err := m.ComparedTo.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n21 dAtA[i] = 0x2a i++ i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status))) @@ -902,6 +924,10 @@ func (m *ComparisonResult) MarshalTo(dAtA []byte) (int, error) { i += n } } + dAtA[i] = 0x3a + i++ + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Revision))) + i += copy(dAtA[i:], m.Revision) return i, nil } @@ -962,11 +988,11 @@ func (m *ConnectionState) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0x1a i++ i = encodeVarintGenerated(dAtA, i, uint64(m.ModifiedAt.Size())) - n21, err := m.ModifiedAt.MarshalTo(dAtA[i:]) + n22, err := m.ModifiedAt.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n21 + i += n22 } return i, nil } @@ -1017,11 +1043,11 @@ func (m *DeploymentInfo) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0x22 i++ i = encodeVarintGenerated(dAtA, i, uint64(m.DeployedAt.Size())) - n22, err := m.DeployedAt.MarshalTo(dAtA[i:]) + n23, err := m.DeployedAt.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n22 + i += n23 dAtA[i] = 0x28 i++ i = encodeVarintGenerated(dAtA, i, uint64(m.ID)) @@ -1139,21 +1165,21 @@ func (m *Operation) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0xa i++ i = encodeVarintGenerated(dAtA, i, uint64(m.Sync.Size())) - n23, err := m.Sync.MarshalTo(dAtA[i:]) + n24, err := m.Sync.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n23 + i += n24 } if m.Rollback != nil { dAtA[i] = 0x12 i++ i = encodeVarintGenerated(dAtA, i, uint64(m.Rollback.Size())) - n24, err := m.Rollback.MarshalTo(dAtA[i:]) + n25, err := m.Rollback.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n24 + i += n25 } return i, nil } @@ -1176,11 +1202,11 @@ func (m *OperationState) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0xa i++ i = encodeVarintGenerated(dAtA, i, uint64(m.Operation.Size())) - n25, err := m.Operation.MarshalTo(dAtA[i:]) + n26, err := m.Operation.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n25 + i += n26 dAtA[i] = 0x12 i++ i = encodeVarintGenerated(dAtA, i, uint64(len(m.Phase))) @@ -1193,39 +1219,39 @@ func (m *OperationState) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0x22 i++ i = encodeVarintGenerated(dAtA, i, uint64(m.SyncResult.Size())) - n26, err := m.SyncResult.MarshalTo(dAtA[i:]) - if err != nil { - return 0, err - } - i += n26 - } - if m.RollbackResult != nil { - dAtA[i] = 0x2a - i++ - i = encodeVarintGenerated(dAtA, i, uint64(m.RollbackResult.Size())) - n27, err := m.RollbackResult.MarshalTo(dAtA[i:]) + n27, err := m.SyncResult.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n27 } + if m.RollbackResult != nil { + dAtA[i] = 0x2a + i++ + i = encodeVarintGenerated(dAtA, i, uint64(m.RollbackResult.Size())) + n28, err := m.RollbackResult.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n28 + } dAtA[i] = 0x32 i++ i = encodeVarintGenerated(dAtA, i, uint64(m.StartedAt.Size())) - n28, err := m.StartedAt.MarshalTo(dAtA[i:]) + n29, err := m.StartedAt.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n28 + i += n29 if m.FinishedAt != nil { dAtA[i] = 0x3a i++ i = encodeVarintGenerated(dAtA, i, uint64(m.FinishedAt.Size())) - n29, err := m.FinishedAt.MarshalTo(dAtA[i:]) + n30, err := m.FinishedAt.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n29 + i += n30 } return i, nil } @@ -1317,11 +1343,11 @@ func (m *Repository) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0x2a i++ i = encodeVarintGenerated(dAtA, i, uint64(m.ConnectionState.Size())) - n30, err := m.ConnectionState.MarshalTo(dAtA[i:]) + n31, err := m.ConnectionState.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n30 + i += n31 return i, nil } @@ -1343,11 +1369,11 @@ func (m *RepositoryList) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0xa i++ i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size())) - n31, err := m.ListMeta.MarshalTo(dAtA[i:]) + n32, err := m.ListMeta.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n31 + i += n32 if len(m.Items) > 0 { for _, msg := range m.Items { dAtA[i] = 0x12 @@ -1477,11 +1503,11 @@ func (m *ResourceState) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0x2a i++ i = encodeVarintGenerated(dAtA, i, uint64(m.Health.Size())) - n32, err := m.Health.MarshalTo(dAtA[i:]) + n33, err := m.Health.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n32 + i += n33 return i, nil } @@ -1561,11 +1587,11 @@ func (m *SyncOperation) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0x22 i++ i = encodeVarintGenerated(dAtA, i, uint64(m.SyncStrategy.Size())) - n33, err := m.SyncStrategy.MarshalTo(dAtA[i:]) + n34, err := m.SyncStrategy.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n33 + i += n34 } return i, nil } @@ -1616,6 +1642,60 @@ func (m *SyncOperationResult) MarshalTo(dAtA []byte) (int, error) { return i, nil } +func (m *SyncPolicy) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SyncPolicy) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Automated != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintGenerated(dAtA, i, uint64(m.Automated.Size())) + n35, err := m.Automated.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n35 + } + return i, nil +} + +func (m *SyncPolicyAutomated) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SyncPolicyAutomated) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + dAtA[i] = 0x8 + i++ + if m.Prune { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i++ + return i, nil +} + func (m *SyncStrategy) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -1635,21 +1715,21 @@ func (m *SyncStrategy) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0xa i++ i = encodeVarintGenerated(dAtA, i, uint64(m.Apply.Size())) - n34, err := m.Apply.MarshalTo(dAtA[i:]) + n36, err := m.Apply.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n34 + i += n36 } if m.Hook != nil { dAtA[i] = 0x12 i++ i = encodeVarintGenerated(dAtA, i, uint64(m.Hook.Size())) - n35, err := m.Hook.MarshalTo(dAtA[i:]) + n37, err := m.Hook.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n35 + i += n37 } return i, nil } @@ -1698,11 +1778,11 @@ func (m *SyncStrategyHook) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0xa i++ i = encodeVarintGenerated(dAtA, i, uint64(m.SyncStrategyApply.Size())) - n36, err := m.SyncStrategyApply.MarshalTo(dAtA[i:]) + n38, err := m.SyncStrategyApply.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n36 + i += n38 return i, nil } @@ -1898,6 +1978,10 @@ func (m *ApplicationSpec) Size() (n int) { n += 1 + l + sovGenerated(uint64(l)) l = len(m.Project) n += 1 + l + sovGenerated(uint64(l)) + if m.SyncPolicy != nil { + l = m.SyncPolicy.Size() + n += 1 + l + sovGenerated(uint64(l)) + } return n } @@ -2000,6 +2084,8 @@ func (m *ComparisonResult) Size() (n int) { n += 1 + l + sovGenerated(uint64(l)) } } + l = len(m.Revision) + n += 1 + l + sovGenerated(uint64(l)) return n } @@ -2273,6 +2359,23 @@ func (m *SyncOperationResult) Size() (n int) { return n } +func (m *SyncPolicy) Size() (n int) { + var l int + _ = l + if m.Automated != nil { + l = m.Automated.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + return n +} + +func (m *SyncPolicyAutomated) Size() (n int) { + var l int + _ = l + n += 2 + return n +} + func (m *SyncStrategy) Size() (n int) { var l int _ = l @@ -2440,6 +2543,7 @@ func (this *ApplicationSpec) String() string { `Source:` + strings.Replace(strings.Replace(this.Source.String(), "ApplicationSource", "ApplicationSource", 1), `&`, ``, 1) + `,`, `Destination:` + strings.Replace(strings.Replace(this.Destination.String(), "ApplicationDestination", "ApplicationDestination", 1), `&`, ``, 1) + `,`, `Project:` + fmt.Sprintf("%v", this.Project) + `,`, + `SyncPolicy:` + strings.Replace(fmt.Sprintf("%v", this.SyncPolicy), "SyncPolicy", "SyncPolicy", 1) + `,`, `}`, }, "") return s @@ -2516,6 +2620,7 @@ func (this *ComparisonResult) String() string { `ComparedTo:` + strings.Replace(strings.Replace(this.ComparedTo.String(), "ApplicationSource", "ApplicationSource", 1), `&`, ``, 1) + `,`, `Status:` + fmt.Sprintf("%v", this.Status) + `,`, `Resources:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Resources), "ResourceState", "ResourceState", 1), `&`, ``, 1) + `,`, + `Revision:` + fmt.Sprintf("%v", this.Revision) + `,`, `}`, }, "") return s @@ -2736,6 +2841,26 @@ func (this *SyncOperationResult) String() string { }, "") return s } +func (this *SyncPolicy) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SyncPolicy{`, + `Automated:` + strings.Replace(fmt.Sprintf("%v", this.Automated), "SyncPolicyAutomated", "SyncPolicyAutomated", 1) + `,`, + `}`, + }, "") + return s +} +func (this *SyncPolicyAutomated) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SyncPolicyAutomated{`, + `Prune:` + fmt.Sprintf("%v", this.Prune) + `,`, + `}`, + }, "") + return s +} func (this *SyncStrategy) String() string { if this == nil { return "nil" @@ -4024,6 +4149,39 @@ func (m *ApplicationSpec) Unmarshal(dAtA []byte) error { } m.Project = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SyncPolicy", 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 > l { + return io.ErrUnexpectedEOF + } + if m.SyncPolicy == nil { + m.SyncPolicy = &SyncPolicy{} + } + if err := m.SyncPolicy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipGenerated(dAtA[iNdEx:]) @@ -4985,6 +5143,35 @@ func (m *ComparisonResult) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Revision", 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 > l { + return io.ErrUnexpectedEOF + } + m.Revision = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipGenerated(dAtA[iNdEx:]) @@ -7657,6 +7844,159 @@ func (m *SyncOperationResult) Unmarshal(dAtA []byte) error { } return nil } +func (m *SyncPolicy) 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: SyncPolicy: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SyncPolicy: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Automated", 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 > l { + return io.ErrUnexpectedEOF + } + if m.Automated == nil { + m.Automated = &SyncPolicyAutomated{} + } + if err := m.Automated.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 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SyncPolicyAutomated) 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: SyncPolicyAutomated: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SyncPolicyAutomated: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Prune", 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.Prune = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *SyncStrategy) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -8225,167 +8565,171 @@ func init() { } var fileDescriptorGenerated = []byte{ - // 2577 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x59, 0x4b, 0x8c, 0x1c, 0x47, - 0xf9, 0x77, 0xcf, 0x6b, 0x67, 0xbe, 0xd9, 0x87, 0x5d, 0x79, 0xfc, 0xf7, 0xef, 0x48, 0xbb, 0xab, - 0x36, 0x0f, 0x83, 0x92, 0x19, 0xbc, 0x10, 0x30, 0x0f, 0x21, 0x79, 0x66, 0xed, 0x78, 0xbd, 0x7e, - 0x2c, 0x35, 0x9b, 0x44, 0x0a, 0x51, 0xa0, 0xdd, 0x53, 0x3b, 0xd3, 0x9e, 0x99, 0xee, 0x4e, 0x57, - 0xcd, 0xd8, 0x23, 0x11, 0x14, 0x84, 0x40, 0x3c, 0x25, 0x10, 0x42, 0x5c, 0x39, 0x70, 0x42, 0x48, - 0x48, 0x88, 0x13, 0x12, 0x07, 0x38, 0x20, 0x1f, 0x73, 0x00, 0x11, 0x05, 0xb4, 0xc2, 0x9b, 0x4b, - 0x24, 0x0e, 0x9c, 0xb8, 0xe4, 0x84, 0xea, 0xd1, 0x5d, 0xd5, 0x3d, 0xbb, 0xec, 0xae, 0x67, 0x6c, - 0xe0, 0xd6, 0xfd, 0x7d, 0x5f, 0x7f, 0xbf, 0xaf, 0xbf, 0xfa, 0xea, 0x7b, 0x54, 0xc1, 0x66, 0xc7, - 0x63, 0xdd, 0xe1, 0xed, 0x9a, 0x1b, 0x0c, 0xea, 0x4e, 0xd4, 0x09, 0xc2, 0x28, 0xb8, 0x23, 0x1e, - 0x9e, 0x73, 0xdb, 0xf5, 0xb0, 0xd7, 0xa9, 0x3b, 0xa1, 0x47, 0xeb, 0x4e, 0x18, 0xf6, 0x3d, 0xd7, - 0x61, 0x5e, 0xe0, 0xd7, 0x47, 0x17, 0x9c, 0x7e, 0xd8, 0x75, 0x2e, 0xd4, 0x3b, 0xc4, 0x27, 0x91, - 0xc3, 0x48, 0xbb, 0x16, 0x46, 0x01, 0x0b, 0xd0, 0xa7, 0xb5, 0xaa, 0x5a, 0xac, 0x4a, 0x3c, 0x7c, - 0xc9, 0x6d, 0xd7, 0xc2, 0x5e, 0xa7, 0xc6, 0x55, 0xd5, 0x0c, 0x55, 0xb5, 0x58, 0xd5, 0xd9, 0xe7, - 0x0c, 0x2b, 0x3a, 0x41, 0x27, 0xa8, 0x0b, 0x8d, 0xb7, 0x87, 0xbb, 0xe2, 0x4d, 0xbc, 0x88, 0x27, - 0x89, 0x74, 0xf6, 0x13, 0xbd, 0x8b, 0xb4, 0xe6, 0x05, 0xdc, 0xb6, 0x81, 0xe3, 0x76, 0x3d, 0x9f, - 0x44, 0x63, 0x6d, 0xec, 0x80, 0x30, 0xa7, 0x3e, 0x9a, 0xb0, 0xef, 0x6c, 0xfd, 0xb0, 0xaf, 0xa2, - 0xa1, 0xcf, 0xbc, 0x01, 0x99, 0xf8, 0xe0, 0x93, 0x47, 0x7d, 0x40, 0xdd, 0x2e, 0x19, 0x38, 0x13, - 0xdf, 0x7d, 0xfc, 0xb0, 0xef, 0x86, 0xcc, 0xeb, 0xd7, 0x3d, 0x9f, 0x51, 0x16, 0x65, 0x3f, 0xb2, - 0xff, 0x62, 0x01, 0x5c, 0x0a, 0xc3, 0xed, 0x28, 0xb8, 0x43, 0x5c, 0x86, 0xbe, 0x0c, 0x65, 0xfe, - 0x1f, 0x6d, 0x87, 0x39, 0xcb, 0xd6, 0x9a, 0x75, 0xbe, 0xba, 0xfe, 0xb1, 0x9a, 0x54, 0x5b, 0x33, - 0xd5, 0x6a, 0xbf, 0x72, 0xe9, 0xda, 0xe8, 0x42, 0xed, 0xd6, 0x6d, 0xfe, 0xfd, 0x0d, 0xc2, 0x9c, - 0x06, 0xba, 0xbf, 0xb7, 0x7a, 0x6a, 0x7f, 0x6f, 0x15, 0x34, 0x0d, 0x27, 0x5a, 0x51, 0x0f, 0x0a, - 0x34, 0x24, 0xee, 0x72, 0x4e, 0x68, 0xdf, 0xac, 0x3d, 0xf4, 0xea, 0xd5, 0xb4, 0xd9, 0xad, 0x90, - 0xb8, 0x8d, 0x79, 0x05, 0x5b, 0xe0, 0x6f, 0x58, 0x80, 0xd8, 0xef, 0x58, 0xb0, 0xa8, 0xc5, 0xae, - 0x7b, 0x94, 0xa1, 0x57, 0x27, 0xfe, 0xb0, 0x76, 0xbc, 0x3f, 0xe4, 0x5f, 0x8b, 0xff, 0x3b, 0xad, - 0x80, 0xca, 0x31, 0xc5, 0xf8, 0xbb, 0x3b, 0x50, 0xf4, 0x18, 0x19, 0xd0, 0xe5, 0xdc, 0x5a, 0xfe, - 0x7c, 0x75, 0xfd, 0xf2, 0x4c, 0x7e, 0xaf, 0xb1, 0xa0, 0x10, 0x8b, 0x9b, 0x5c, 0x37, 0x96, 0x10, - 0xf6, 0x3f, 0x73, 0xe6, 0xcf, 0xf1, 0xbf, 0x46, 0x17, 0xa0, 0x4a, 0x83, 0x61, 0xe4, 0x12, 0x4c, - 0xc2, 0x80, 0x2e, 0x5b, 0x6b, 0xf9, 0xf3, 0x95, 0xc6, 0xd2, 0xfe, 0xde, 0x6a, 0xb5, 0xa5, 0xc9, - 0xd8, 0x94, 0x41, 0xdf, 0xb5, 0x60, 0xbe, 0x4d, 0x28, 0xf3, 0x7c, 0x81, 0x1f, 0x5b, 0xfe, 0x85, - 0xe9, 0x2c, 0x8f, 0x89, 0x1b, 0x5a, 0x73, 0xe3, 0x49, 0xf5, 0x17, 0xf3, 0x06, 0x91, 0xe2, 0x14, - 0x38, 0x7a, 0x1e, 0xaa, 0x6d, 0x42, 0xdd, 0xc8, 0x0b, 0xf9, 0xfb, 0x72, 0x7e, 0xcd, 0x3a, 0x5f, - 0x69, 0x3c, 0xa1, 0x3e, 0xac, 0x6e, 0x68, 0x16, 0x36, 0xe5, 0x50, 0x0f, 0x8a, 0x51, 0xd0, 0x27, - 0x74, 0xb9, 0x20, 0x8c, 0xbf, 0x32, 0x85, 0xf1, 0xca, 0x9d, 0x38, 0xe8, 0x13, 0xed, 0x77, 0xfe, - 0x46, 0xb1, 0xc4, 0xb0, 0xff, 0x90, 0x87, 0xaa, 0xf1, 0x8b, 0x8f, 0x61, 0xcf, 0xf4, 0x53, 0x7b, - 0xe6, 0xda, 0x6c, 0x96, 0xe6, 0xb0, 0x4d, 0x83, 0x18, 0x94, 0x28, 0x73, 0xd8, 0x90, 0x0a, 0xf7, - 0x57, 0xd7, 0xaf, 0xcf, 0x08, 0x4f, 0xe8, 0x6c, 0x2c, 0x2a, 0xc4, 0x92, 0x7c, 0xc7, 0x0a, 0x0b, - 0xbd, 0x0e, 0x95, 0x20, 0xe4, 0xa9, 0x89, 0xaf, 0x7b, 0x41, 0x00, 0x6f, 0x4c, 0x01, 0x7c, 0x2b, - 0xd6, 0xd5, 0x58, 0xd8, 0xdf, 0x5b, 0xad, 0x24, 0xaf, 0x58, 0xa3, 0xd8, 0x2e, 0x3c, 0x69, 0xd8, - 0xd7, 0x0c, 0xfc, 0xb6, 0x27, 0x16, 0x74, 0x0d, 0x0a, 0x6c, 0x1c, 0x12, 0xb1, 0x98, 0x15, 0xed, - 0xa2, 0x9d, 0x71, 0x48, 0xb0, 0xe0, 0xa0, 0x8f, 0xc0, 0xdc, 0x80, 0x50, 0xea, 0x74, 0x88, 0x58, - 0x93, 0x4a, 0x63, 0x49, 0x09, 0xcd, 0xdd, 0x90, 0x64, 0x1c, 0xf3, 0xed, 0xd7, 0xe1, 0xe9, 0x83, - 0xf7, 0x03, 0xfa, 0x10, 0x94, 0x28, 0x89, 0x46, 0x24, 0x52, 0x40, 0xda, 0x33, 0x82, 0x8a, 0x15, - 0x17, 0xd5, 0xa1, 0xe2, 0x3b, 0x03, 0x42, 0x43, 0xc7, 0x8d, 0xe1, 0xce, 0x28, 0xd1, 0xca, 0xcd, - 0x98, 0x81, 0xb5, 0x8c, 0xfd, 0x57, 0x0b, 0x96, 0x0c, 0xcc, 0xc7, 0x90, 0xf6, 0x7a, 0xe9, 0xb4, - 0x77, 0x65, 0x36, 0x11, 0x73, 0x48, 0xde, 0xfb, 0x5d, 0x1e, 0xce, 0x98, 0x71, 0x25, 0x92, 0x19, - 0x5f, 0x92, 0x88, 0x84, 0xc1, 0x8b, 0xf8, 0xba, 0x72, 0x67, 0xb2, 0x24, 0x58, 0x92, 0x71, 0xcc, - 0xe7, 0xeb, 0x1b, 0x3a, 0xac, 0xab, 0x7c, 0x99, 0xac, 0xef, 0xb6, 0xc3, 0xba, 0x58, 0x70, 0x78, - 0x1a, 0x22, 0xfe, 0xc8, 0x8b, 0x02, 0x7f, 0x40, 0x7c, 0x96, 0x4d, 0x43, 0x97, 0x35, 0x0b, 0x9b, - 0x72, 0xe8, 0xf3, 0xb0, 0xc8, 0x9c, 0xa8, 0x43, 0x18, 0x26, 0x23, 0x8f, 0xc6, 0x81, 0x5c, 0x69, - 0x3c, 0xad, 0xbe, 0x5c, 0xdc, 0x49, 0x71, 0x71, 0x46, 0x1a, 0xfd, 0xda, 0x82, 0x67, 0xdc, 0x60, - 0x10, 0x06, 0x3e, 0xf1, 0xd9, 0xb6, 0x13, 0x39, 0x03, 0xc2, 0x48, 0x74, 0x6b, 0x44, 0xa2, 0xc8, - 0x6b, 0x13, 0xba, 0x5c, 0x14, 0xde, 0xbd, 0x31, 0x85, 0x77, 0x9b, 0x13, 0xda, 0x1b, 0xe7, 0x94, - 0x71, 0xcf, 0x34, 0x0f, 0x47, 0xc6, 0xff, 0xce, 0x2c, 0x5e, 0x75, 0x46, 0x4e, 0x7f, 0x48, 0xe8, - 0x15, 0x8f, 0xe7, 0xe0, 0x92, 0xae, 0x3a, 0x2f, 0x69, 0x32, 0x36, 0x65, 0xec, 0xdf, 0xe6, 0x52, - 0x21, 0xda, 0x8a, 0xf3, 0x8e, 0x58, 0x4b, 0x15, 0xa0, 0xb3, 0xca, 0x3b, 0x42, 0xa7, 0xb1, 0xbb, - 0x64, 0xf1, 0x53, 0x58, 0xe8, 0x5b, 0x96, 0x28, 0x39, 0xf1, 0xae, 0x54, 0x39, 0xf6, 0x11, 0x94, - 0x3f, 0xb3, 0x8a, 0xc5, 0x44, 0x6c, 0x42, 0xf3, 0x10, 0x0e, 0x65, 0xf5, 0x51, 0x11, 0x97, 0x84, - 0x70, 0x5c, 0x94, 0x62, 0xbe, 0xfd, 0xd3, 0x52, 0x7a, 0x0f, 0xc8, 0x1c, 0xfa, 0x43, 0x0b, 0x4e, - 0xf3, 0x85, 0x72, 0x22, 0x8f, 0x06, 0x3e, 0x26, 0x74, 0xd8, 0x67, 0xca, 0x99, 0x5b, 0x53, 0x06, - 0x8d, 0xa9, 0xb2, 0xb1, 0xac, 0xec, 0x3a, 0x9d, 0xe5, 0xe0, 0x09, 0x78, 0xc4, 0x60, 0xae, 0xeb, - 0x51, 0x16, 0x44, 0x63, 0x95, 0x1c, 0xa6, 0x69, 0xf9, 0x36, 0x48, 0xd8, 0x0f, 0xc6, 0x7c, 0xaf, - 0x6d, 0xfa, 0xbb, 0x81, 0xf6, 0xcf, 0x55, 0x89, 0x80, 0x63, 0x28, 0xf4, 0x35, 0x0b, 0x20, 0x8c, - 0x23, 0x95, 0x17, 0xb2, 0x47, 0xb0, 0x71, 0x92, 0x9a, 0x9d, 0x90, 0x28, 0x36, 0x40, 0x51, 0x00, - 0xa5, 0x2e, 0x71, 0xfa, 0xac, 0xab, 0xca, 0xd9, 0x0b, 0x53, 0xc0, 0x5f, 0x15, 0x8a, 0xb2, 0x25, - 0x54, 0x52, 0xb1, 0x82, 0x41, 0xdf, 0xb0, 0x60, 0x31, 0xa9, 0x6e, 0x5c, 0x96, 0x2c, 0x17, 0xa7, - 0xee, 0xb2, 0x6f, 0xa5, 0x14, 0x36, 0x10, 0x4f, 0x63, 0x69, 0x1a, 0xce, 0x80, 0xa2, 0xaf, 0x5b, - 0x00, 0x6e, 0x5c, 0x4d, 0x65, 0x3e, 0xa8, 0xae, 0xdf, 0x9a, 0xcd, 0x8e, 0x4a, 0xaa, 0xb4, 0x76, - 0x7f, 0x42, 0xa2, 0xd8, 0x80, 0xb5, 0xdf, 0xb5, 0xe0, 0x29, 0xe3, 0xc3, 0x97, 0x1d, 0xe6, 0x76, - 0x2f, 0x8f, 0x78, 0x9a, 0xde, 0x4a, 0xd5, 0xf7, 0x4f, 0x99, 0xf5, 0xfd, 0xfd, 0xbd, 0xd5, 0x0f, - 0x1f, 0x36, 0x46, 0xdd, 0xe5, 0x1a, 0x6a, 0x42, 0x85, 0xd1, 0x0a, 0xbc, 0x01, 0x55, 0xc3, 0x66, - 0x95, 0x3e, 0x66, 0x55, 0x00, 0x93, 0x9c, 0x61, 0x10, 0xb1, 0x89, 0x67, 0xff, 0x29, 0x07, 0x73, - 0xcd, 0xfe, 0x90, 0x32, 0x12, 0x1d, 0xbb, 0xa1, 0x58, 0x83, 0x02, 0x6f, 0x16, 0xb2, 0xf5, 0x8f, - 0xf7, 0x12, 0x58, 0x70, 0x50, 0x08, 0x25, 0x37, 0xf0, 0x77, 0xbd, 0x8e, 0x6a, 0x01, 0xaf, 0x4e, - 0xb3, 0x73, 0xa4, 0x75, 0x4d, 0xa1, 0x4f, 0xdb, 0x24, 0xdf, 0xb1, 0xc2, 0x41, 0xdf, 0xb7, 0x60, - 0xc9, 0x0d, 0x7c, 0x9f, 0xb8, 0x3a, 0x78, 0x0b, 0x53, 0xb7, 0xbb, 0xcd, 0xb4, 0xc6, 0xc6, 0xff, - 0x29, 0xf4, 0xa5, 0x0c, 0x03, 0x67, 0xb1, 0xed, 0x5f, 0xe5, 0x60, 0x21, 0x65, 0x39, 0x7a, 0x16, - 0xca, 0x43, 0x4a, 0x22, 0xe1, 0x39, 0xe9, 0xdf, 0xa4, 0x23, 0x7a, 0x51, 0xd1, 0x71, 0x22, 0xc1, - 0xa5, 0x43, 0x87, 0xd2, 0xbb, 0x41, 0xd4, 0x56, 0x7e, 0x4e, 0xa4, 0xb7, 0x15, 0x1d, 0x27, 0x12, - 0xbc, 0xdf, 0xb8, 0x4d, 0x9c, 0x88, 0x44, 0x3b, 0x41, 0x8f, 0x4c, 0x8c, 0x3d, 0x0d, 0xcd, 0xc2, - 0xa6, 0x9c, 0x70, 0x1a, 0xeb, 0xd3, 0x66, 0xdf, 0x23, 0x3e, 0x93, 0x66, 0xce, 0xc0, 0x69, 0x3b, - 0xd7, 0x5b, 0xa6, 0x46, 0xed, 0xb4, 0x0c, 0x03, 0x67, 0xb1, 0xed, 0x3f, 0x5a, 0x50, 0x55, 0x4e, - 0x7b, 0x0c, 0x4d, 0x67, 0x27, 0xdd, 0x74, 0x36, 0xa6, 0x8f, 0xd1, 0x43, 0x1a, 0xce, 0x5f, 0xe4, - 0x61, 0xa2, 0xd2, 0xa1, 0xd7, 0x78, 0x8e, 0xe3, 0x34, 0xd2, 0xbe, 0x14, 0x17, 0xd9, 0x8f, 0x1e, - 0xef, 0xef, 0x76, 0xbc, 0x01, 0x31, 0xd3, 0x57, 0xac, 0x05, 0x1b, 0x1a, 0xd1, 0x9b, 0x96, 0x06, - 0xd8, 0x09, 0x54, 0x5e, 0x99, 0x6d, 0x4b, 0x34, 0x61, 0xc2, 0x4e, 0x80, 0x0d, 0x4c, 0xf4, 0x99, - 0x64, 0x10, 0x2c, 0x8a, 0x80, 0xb4, 0xd3, 0xa3, 0xdb, 0xfb, 0xa9, 0x06, 0x20, 0x33, 0xce, 0x8d, - 0xa1, 0x12, 0x11, 0xd9, 0x62, 0xc5, 0x15, 0x60, 0x9a, 0x24, 0x82, 0x95, 0x2e, 0xb9, 0x8d, 0x93, - 0xf1, 0x27, 0x26, 0x53, 0xac, 0xd1, 0xec, 0xef, 0x59, 0x80, 0x26, 0xcb, 0x35, 0x1f, 0xa3, 0x92, - 0x26, 0x56, 0x6d, 0xe0, 0x44, 0x4f, 0x22, 0x8e, 0xb5, 0xcc, 0x31, 0xd2, 0xe4, 0x39, 0x28, 0x8a, - 0xa6, 0x56, 0x6d, 0xd8, 0x24, 0x7a, 0x44, 0xdb, 0x8b, 0x25, 0xcf, 0xfe, 0xbd, 0x05, 0xd9, 0x74, - 0x23, 0x32, 0xb5, 0xf4, 0x6c, 0x36, 0x53, 0xa7, 0xbd, 0x78, 0xfc, 0x39, 0x13, 0xbd, 0x0a, 0x55, - 0x87, 0x31, 0x32, 0x08, 0x99, 0x08, 0xc8, 0xfc, 0x89, 0x03, 0x72, 0x91, 0x47, 0xc2, 0x8d, 0xa0, - 0xed, 0xed, 0x7a, 0x22, 0x18, 0x4d, 0x75, 0xf6, 0x7b, 0x79, 0x58, 0x4c, 0x37, 0x5f, 0x68, 0x08, - 0x25, 0xd1, 0xec, 0xc8, 0x63, 0xa6, 0x99, 0x77, 0x57, 0x89, 0x4b, 0x04, 0x89, 0x62, 0x05, 0xc6, - 0x13, 0x6b, 0x14, 0x4f, 0x57, 0x99, 0xc4, 0x9a, 0xcc, 0x55, 0x89, 0xc4, 0x91, 0x13, 0x55, 0xfe, - 0xbf, 0x73, 0xa2, 0x7a, 0x0d, 0xa0, 0x2d, 0xbc, 0x2d, 0xd6, 0xb2, 0xf0, 0xf0, 0xc9, 0x65, 0x23, - 0xd1, 0x82, 0x0d, 0x8d, 0xe8, 0x2c, 0xe4, 0xbc, 0xb6, 0xd8, 0xd5, 0xf9, 0x06, 0x28, 0xd9, 0xdc, - 0xe6, 0x06, 0xce, 0x79, 0x6d, 0x9b, 0xc2, 0xbc, 0xd9, 0x6d, 0x1e, 0x3b, 0x56, 0x3f, 0x0b, 0x0b, - 0xf2, 0x69, 0x83, 0x30, 0xc7, 0xeb, 0x53, 0xb5, 0x3a, 0x4f, 0x29, 0xf1, 0x85, 0x96, 0xc9, 0xc4, - 0x69, 0x59, 0xfb, 0x27, 0x39, 0x80, 0xab, 0x41, 0xd0, 0x53, 0x98, 0xf1, 0xd6, 0xb3, 0x0e, 0xdd, - 0x7a, 0x6b, 0x50, 0xe8, 0x79, 0x7e, 0x3b, 0xbb, 0x39, 0xb7, 0x3c, 0xbf, 0x8d, 0x05, 0x07, 0xad, - 0x03, 0x38, 0xa1, 0xf7, 0x12, 0x89, 0xa8, 0x3e, 0x49, 0x4c, 0xfc, 0x72, 0x69, 0x7b, 0x53, 0x71, - 0xb0, 0x21, 0x85, 0x9e, 0x55, 0x9d, 0xa1, 0x1c, 0xdb, 0x97, 0x33, 0x9d, 0x61, 0x99, 0x5b, 0x68, - 0xb4, 0x7e, 0x17, 0x33, 0xf9, 0x71, 0x6d, 0x22, 0x3f, 0xea, 0x4e, 0x79, 0xbb, 0xeb, 0x50, 0x72, - 0xd0, 0xbe, 0x2e, 0x1d, 0x71, 0x7e, 0xd4, 0x82, 0xf2, 0xb5, 0x97, 0x77, 0x64, 0xbd, 0xb7, 0x21, - 0xef, 0x39, 0x32, 0x79, 0xe5, 0x75, 0xd8, 0x6f, 0x52, 0x3a, 0x14, 0x2b, 0xcc, 0x99, 0xe8, 0x1c, - 0xe4, 0xc9, 0xbd, 0x50, 0xf8, 0x25, 0xaf, 0x13, 0xdc, 0xe5, 0x7b, 0xa1, 0x17, 0x11, 0xca, 0x85, - 0xc8, 0xbd, 0xd0, 0xfe, 0xbb, 0x05, 0xfa, 0x48, 0x0c, 0xed, 0x42, 0x81, 0x8e, 0x7d, 0x57, 0x15, - 0xb1, 0x69, 0xd2, 0x74, 0x6b, 0xec, 0xbb, 0xfa, 0xe4, 0xad, 0x2c, 0x0e, 0x16, 0xc7, 0xbe, 0x8b, - 0x85, 0x7e, 0x34, 0x82, 0x72, 0x14, 0xf4, 0xfb, 0xb7, 0x1d, 0xb7, 0x37, 0x83, 0x7a, 0x86, 0x95, - 0x2a, 0x8d, 0x37, 0x2f, 0x92, 0x80, 0x22, 0xe3, 0x04, 0xcb, 0xfe, 0x65, 0x11, 0x32, 0x23, 0x0b, - 0x1a, 0x9a, 0xa7, 0x8d, 0xd6, 0x0c, 0x4f, 0x1b, 0x13, 0x8f, 0x1f, 0x74, 0xe2, 0x88, 0x9e, 0x87, - 0x62, 0xc8, 0x03, 0x41, 0x85, 0xed, 0x6a, 0x5c, 0x30, 0x44, 0x74, 0x1c, 0x10, 0x2f, 0x52, 0xda, - 0x0c, 0x97, 0xfc, 0x11, 0x65, 0xe0, 0xab, 0x00, 0xdc, 0xd7, 0x6a, 0xf6, 0x97, 0x99, 0xe3, 0xe6, - 0xac, 0x56, 0x54, 0x8d, 0xff, 0xa2, 0x52, 0xb4, 0x12, 0x14, 0x6c, 0x20, 0xa2, 0xef, 0x58, 0xb0, - 0x18, 0x3b, 0x5e, 0x19, 0x51, 0x7c, 0x24, 0x46, 0x88, 0x41, 0x14, 0xa7, 0x90, 0x70, 0x06, 0x19, - 0x7d, 0x11, 0x2a, 0x94, 0x39, 0x91, 0xac, 0x88, 0xa5, 0x13, 0x67, 0xd1, 0x64, 0x2d, 0x5b, 0xb1, - 0x12, 0xac, 0xf5, 0xa1, 0x57, 0x00, 0x76, 0x3d, 0xdf, 0xa3, 0x5d, 0xa1, 0x7d, 0xee, 0xe1, 0xea, - 0xed, 0x95, 0x44, 0x03, 0x36, 0xb4, 0xd9, 0xdf, 0xcc, 0x41, 0xd5, 0xb8, 0x88, 0x38, 0x46, 0x3e, - 0xcc, 0x5c, 0x9c, 0xe4, 0x8e, 0x79, 0x71, 0x72, 0x1e, 0xca, 0x61, 0xd0, 0xf7, 0x5c, 0x4f, 0xd5, - 0xc2, 0x8a, 0xdc, 0x44, 0xdb, 0x8a, 0x86, 0x13, 0x2e, 0x62, 0x50, 0xb9, 0x73, 0x97, 0x89, 0x3c, - 0x14, 0x5f, 0xb3, 0x34, 0xa7, 0x58, 0xd2, 0x38, 0xa7, 0x69, 0x27, 0xc7, 0x14, 0x8a, 0x35, 0x90, - 0xfd, 0xe7, 0x1c, 0x80, 0xb8, 0xa7, 0xf2, 0xc4, 0xb1, 0xce, 0x1a, 0x14, 0x22, 0x12, 0x06, 0x59, - 0x3f, 0x70, 0x09, 0x2c, 0x38, 0xa9, 0x29, 0x2d, 0x77, 0xa2, 0x29, 0x2d, 0x7f, 0xe4, 0x94, 0xc6, - 0x2b, 0x1c, 0xed, 0x6e, 0x47, 0xde, 0xc8, 0x61, 0x64, 0x8b, 0x8c, 0x55, 0x99, 0xd0, 0x15, 0xae, - 0x75, 0x55, 0x33, 0x71, 0x5a, 0xf6, 0xc0, 0x01, 0xb7, 0xf8, 0x1f, 0x1c, 0x70, 0xdf, 0xb1, 0x60, - 0x51, 0x7b, 0xf6, 0x7f, 0xeb, 0x6a, 0x54, 0xdb, 0x7d, 0xc8, 0xc4, 0xf6, 0x0f, 0x0b, 0x96, 0xe2, - 0xd9, 0x40, 0xb5, 0x18, 0x33, 0xe9, 0x29, 0x52, 0x57, 0x31, 0xf9, 0xa3, 0xaf, 0x62, 0xcc, 0xcc, - 0x5d, 0x38, 0x22, 0x73, 0x7f, 0x2e, 0xd3, 0x4d, 0x7c, 0x60, 0xa2, 0x9b, 0x40, 0xc9, 0x14, 0x34, - 0xf6, 0xdd, 0x74, 0xf7, 0x65, 0xff, 0xdc, 0x82, 0xf9, 0x98, 0x7d, 0x33, 0x68, 0x8b, 0xd9, 0x84, - 0x8a, 0x20, 0xb3, 0xd2, 0xb3, 0x89, 0x0c, 0x07, 0xc9, 0x43, 0x43, 0x28, 0xbb, 0x5d, 0xaf, 0xdf, - 0x8e, 0x88, 0xaf, 0x96, 0xe5, 0x85, 0x19, 0x0c, 0x69, 0x1c, 0x5f, 0x87, 0x42, 0x53, 0x01, 0xe0, - 0x04, 0xca, 0xfe, 0x4d, 0x1e, 0x16, 0x52, 0x13, 0x1d, 0x4f, 0x5f, 0xf2, 0x2e, 0xa4, 0x65, 0xd8, - 0x9c, 0xa4, 0xaf, 0x1d, 0xcd, 0xc2, 0xa6, 0x1c, 0x5f, 0x8f, 0xbe, 0x37, 0x92, 0x3a, 0xb2, 0x57, - 0x63, 0xd7, 0x63, 0x06, 0xd6, 0x32, 0xc6, 0x48, 0x9b, 0x3f, 0xf1, 0x48, 0xfb, 0x23, 0x0b, 0x90, - 0xf8, 0x05, 0xae, 0x39, 0x99, 0x3c, 0x55, 0x2e, 0x9c, 0x99, 0xdf, 0xce, 0x2a, 0x8b, 0x50, 0x73, - 0x02, 0x0a, 0x1f, 0x00, 0x6f, 0x9c, 0x32, 0x17, 0x1f, 0xcb, 0x29, 0xb3, 0xfd, 0x15, 0x38, 0x33, - 0xd1, 0x7a, 0xa9, 0x81, 0xc2, 0x3a, 0x68, 0xa0, 0xe0, 0x91, 0x18, 0x46, 0x43, 0x5f, 0x2e, 0x50, - 0x59, 0x47, 0xe2, 0x36, 0x27, 0x62, 0xc9, 0xe3, 0x53, 0x46, 0x3b, 0x1a, 0xe3, 0xa1, 0xec, 0xd4, - 0xcb, 0x1a, 0x7d, 0x43, 0x50, 0xb1, 0xe2, 0xda, 0xdf, 0xce, 0xc1, 0x42, 0xaa, 0x1d, 0x48, 0x0d, - 0x84, 0xd6, 0x91, 0x03, 0xe1, 0x2c, 0x8d, 0x41, 0x6f, 0xc0, 0x3c, 0x15, 0x5b, 0x31, 0x72, 0x18, - 0xe9, 0x8c, 0x67, 0x70, 0xce, 0xdf, 0x32, 0xd4, 0x35, 0x4e, 0xef, 0xef, 0xad, 0xce, 0x9b, 0x14, - 0x9c, 0x82, 0xb3, 0x7f, 0x96, 0x83, 0x27, 0x0e, 0x68, 0x8d, 0xd0, 0x5d, 0xf3, 0xec, 0x45, 0x0e, - 0xe7, 0xd7, 0x66, 0x10, 0x9e, 0x2a, 0x91, 0xca, 0x0b, 0xf5, 0x83, 0x4e, 0x5e, 0x4e, 0x38, 0x9b, - 0xef, 0x42, 0xb1, 0x1b, 0x04, 0xbd, 0x78, 0x08, 0x9f, 0xa6, 0x20, 0xe8, 0xd1, 0xb1, 0x51, 0xe1, - 0xab, 0xc9, 0xdf, 0x29, 0x96, 0xea, 0xed, 0xf7, 0x2c, 0x48, 0x79, 0x11, 0x0d, 0xa0, 0xc8, 0xb5, - 0x8c, 0x67, 0x70, 0xcf, 0x68, 0xea, 0xbd, 0xc4, 0x75, 0x4a, 0x7c, 0xf1, 0x88, 0x25, 0x0a, 0xf2, - 0xa0, 0xc0, 0x0d, 0x51, 0x23, 0xcf, 0xd6, 0x8c, 0xd0, 0xf8, 0x2f, 0xca, 0x09, 0x8b, 0x3f, 0x61, - 0x01, 0x61, 0x5f, 0x84, 0x33, 0x13, 0x16, 0xf1, 0x90, 0xdf, 0x0d, 0xe2, 0x6b, 0x55, 0x23, 0xe4, - 0xaf, 0x70, 0x22, 0x96, 0x3c, 0x5e, 0x3f, 0x4e, 0x67, 0xd5, 0xa3, 0x1f, 0x5b, 0x70, 0x86, 0x66, - 0xf5, 0x3d, 0x12, 0xaf, 0xfd, 0xbf, 0x32, 0x6a, 0xd2, 0x7c, 0x3c, 0x69, 0x01, 0x5f, 0xd1, 0xec, - 0x61, 0x34, 0x8f, 0x3d, 0xcf, 0xa7, 0xc4, 0x1d, 0x46, 0xf1, 0x8f, 0xea, 0x01, 0x59, 0xd1, 0x71, - 0x22, 0x81, 0xd6, 0x01, 0xe4, 0x65, 0xc8, 0x4d, 0xdd, 0x28, 0x26, 0x87, 0x03, 0xad, 0x84, 0x83, - 0x0d, 0x29, 0xde, 0x2b, 0xbb, 0x24, 0x62, 0x1b, 0xbc, 0x3d, 0xe2, 0x79, 0x61, 0x5e, 0xf6, 0xca, - 0x4d, 0x45, 0xc3, 0x09, 0x17, 0x7d, 0x10, 0xe6, 0x7a, 0x64, 0x2c, 0x04, 0x0b, 0x42, 0xb0, 0xca, - 0x2b, 0xfe, 0x96, 0x24, 0xe1, 0x98, 0x87, 0x6c, 0x28, 0xb9, 0x8e, 0x90, 0x2a, 0x0a, 0x29, 0x10, - 0xf7, 0x22, 0x97, 0x84, 0x90, 0xe2, 0x34, 0x6a, 0xf7, 0x1f, 0xac, 0x9c, 0x7a, 0xeb, 0xc1, 0xca, - 0xa9, 0xb7, 0x1f, 0xac, 0x9c, 0x7a, 0x73, 0x7f, 0xc5, 0xba, 0xbf, 0xbf, 0x62, 0xbd, 0xb5, 0xbf, - 0x62, 0xbd, 0xbd, 0xbf, 0x62, 0xfd, 0x6d, 0x7f, 0xc5, 0xfa, 0xc1, 0xbb, 0x2b, 0xa7, 0x5e, 0x29, - 0xc7, 0xae, 0xfd, 0x57, 0x00, 0x00, 0x00, 0xff, 0xff, 0x38, 0x84, 0xaf, 0x0d, 0x59, 0x29, 0x00, - 0x00, + // 2651 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x59, 0x4d, 0x6c, 0x24, 0x47, + 0xf5, 0xdf, 0x9e, 0x0f, 0x7b, 0xe6, 0x8d, 0x3f, 0x76, 0x2b, 0x1f, 0x7f, 0xff, 0x37, 0x92, 0x6d, + 0xf5, 0xf2, 0xb1, 0xa0, 0x64, 0xcc, 0x1a, 0x02, 0x4b, 0x40, 0x48, 0x1e, 0x7b, 0x37, 0xf6, 0x7a, + 0x3f, 0x4c, 0x8d, 0x93, 0x48, 0x21, 0x0a, 0xf4, 0xf6, 0x94, 0x67, 0x7a, 0x67, 0xa6, 0xbb, 0xd3, + 0x55, 0x33, 0xbb, 0x23, 0x08, 0x0a, 0x42, 0x20, 0xc2, 0x87, 0x04, 0x42, 0x88, 0x2b, 0x07, 0x4e, + 0x5c, 0x90, 0x50, 0x4e, 0xdc, 0xe0, 0x80, 0xf6, 0x98, 0x03, 0x88, 0x68, 0x41, 0x16, 0xeb, 0x5c, + 0x22, 0x71, 0xe0, 0xc4, 0x25, 0x27, 0x54, 0x1f, 0xdd, 0x55, 0xdd, 0x63, 0x63, 0xef, 0x4e, 0xef, + 0x02, 0xb7, 0xee, 0xf7, 0x5e, 0xbf, 0xdf, 0xeb, 0x57, 0xaf, 0xde, 0x47, 0x15, 0x6c, 0xb5, 0x3d, + 0xd6, 0x19, 0xdc, 0xac, 0xbb, 0x41, 0x7f, 0xc5, 0x89, 0xda, 0x41, 0x18, 0x05, 0xb7, 0xc4, 0xc3, + 0x73, 0x6e, 0x6b, 0x25, 0xec, 0xb6, 0x57, 0x9c, 0xd0, 0xa3, 0x2b, 0x4e, 0x18, 0xf6, 0x3c, 0xd7, + 0x61, 0x5e, 0xe0, 0xaf, 0x0c, 0x2f, 0x38, 0xbd, 0xb0, 0xe3, 0x5c, 0x58, 0x69, 0x13, 0x9f, 0x44, + 0x0e, 0x23, 0xad, 0x7a, 0x18, 0x05, 0x2c, 0x40, 0x9f, 0xd7, 0xaa, 0xea, 0xb1, 0x2a, 0xf1, 0xf0, + 0x55, 0xb7, 0x55, 0x0f, 0xbb, 0xed, 0x3a, 0x57, 0x55, 0x37, 0x54, 0xd5, 0x63, 0x55, 0x67, 0x9f, + 0x33, 0xac, 0x68, 0x07, 0xed, 0x60, 0x45, 0x68, 0xbc, 0x39, 0xd8, 0x13, 0x6f, 0xe2, 0x45, 0x3c, + 0x49, 0xa4, 0xb3, 0x9f, 0xe9, 0x5e, 0xa4, 0x75, 0x2f, 0xe0, 0xb6, 0xf5, 0x1d, 0xb7, 0xe3, 0xf9, + 0x24, 0x1a, 0x69, 0x63, 0xfb, 0x84, 0x39, 0x2b, 0xc3, 0x31, 0xfb, 0xce, 0xae, 0x1c, 0xf5, 0x55, + 0x34, 0xf0, 0x99, 0xd7, 0x27, 0x63, 0x1f, 0x7c, 0xf6, 0xb8, 0x0f, 0xa8, 0xdb, 0x21, 0x7d, 0x67, + 0xec, 0xbb, 0x4f, 0x1f, 0xf5, 0xdd, 0x80, 0x79, 0xbd, 0x15, 0xcf, 0x67, 0x94, 0x45, 0xd9, 0x8f, + 0xec, 0xbf, 0x58, 0x00, 0x6b, 0x61, 0xb8, 0x13, 0x05, 0xb7, 0x88, 0xcb, 0xd0, 0xd7, 0xa0, 0xc2, + 0xff, 0xa3, 0xe5, 0x30, 0x67, 0xc1, 0x5a, 0xb6, 0xce, 0xd7, 0x56, 0x3f, 0x55, 0x97, 0x6a, 0xeb, + 0xa6, 0x5a, 0xed, 0x57, 0x2e, 0x5d, 0x1f, 0x5e, 0xa8, 0xdf, 0xb8, 0xc9, 0xbf, 0xbf, 0x46, 0x98, + 0xd3, 0x40, 0x77, 0xf7, 0x97, 0x4e, 0x1d, 0xec, 0x2f, 0x81, 0xa6, 0xe1, 0x44, 0x2b, 0xea, 0x42, + 0x89, 0x86, 0xc4, 0x5d, 0x28, 0x08, 0xed, 0x5b, 0xf5, 0x87, 0x5e, 0xbd, 0xba, 0x36, 0xbb, 0x19, + 0x12, 0xb7, 0x31, 0xa3, 0x60, 0x4b, 0xfc, 0x0d, 0x0b, 0x10, 0xfb, 0x9e, 0x05, 0x73, 0x5a, 0xec, + 0xaa, 0x47, 0x19, 0x7a, 0x6d, 0xec, 0x0f, 0xeb, 0x27, 0xfb, 0x43, 0xfe, 0xb5, 0xf8, 0xbf, 0xd3, + 0x0a, 0xa8, 0x12, 0x53, 0x8c, 0xbf, 0xbb, 0x05, 0x65, 0x8f, 0x91, 0x3e, 0x5d, 0x28, 0x2c, 0x17, + 0xcf, 0xd7, 0x56, 0x2f, 0xe5, 0xf2, 0x7b, 0x8d, 0x59, 0x85, 0x58, 0xde, 0xe2, 0xba, 0xb1, 0x84, + 0xb0, 0xff, 0x59, 0x30, 0x7f, 0x8e, 0xff, 0x35, 0xba, 0x00, 0x35, 0x1a, 0x0c, 0x22, 0x97, 0x60, + 0x12, 0x06, 0x74, 0xc1, 0x5a, 0x2e, 0x9e, 0xaf, 0x36, 0xe6, 0x0f, 0xf6, 0x97, 0x6a, 0x4d, 0x4d, + 0xc6, 0xa6, 0x0c, 0xfa, 0x81, 0x05, 0x33, 0x2d, 0x42, 0x99, 0xe7, 0x0b, 0xfc, 0xd8, 0xf2, 0x2f, + 0x4f, 0x66, 0x79, 0x4c, 0xdc, 0xd0, 0x9a, 0x1b, 0x4f, 0xaa, 0xbf, 0x98, 0x31, 0x88, 0x14, 0xa7, + 0xc0, 0xd1, 0xf3, 0x50, 0x6b, 0x11, 0xea, 0x46, 0x5e, 0xc8, 0xdf, 0x17, 0x8a, 0xcb, 0xd6, 0xf9, + 0x6a, 0xe3, 0x09, 0xf5, 0x61, 0x6d, 0x43, 0xb3, 0xb0, 0x29, 0x87, 0xba, 0x50, 0x8e, 0x82, 0x1e, + 0xa1, 0x0b, 0x25, 0x61, 0xfc, 0xe5, 0x09, 0x8c, 0x57, 0xee, 0xc4, 0x41, 0x8f, 0x68, 0xbf, 0xf3, + 0x37, 0x8a, 0x25, 0x86, 0xfd, 0x87, 0x22, 0xd4, 0x8c, 0x5f, 0x7c, 0x0c, 0x7b, 0xa6, 0x97, 0xda, + 0x33, 0x57, 0xf2, 0x59, 0x9a, 0xa3, 0x36, 0x0d, 0x62, 0x30, 0x45, 0x99, 0xc3, 0x06, 0x54, 0xb8, + 0xbf, 0xb6, 0x7a, 0x35, 0x27, 0x3c, 0xa1, 0xb3, 0x31, 0xa7, 0x10, 0xa7, 0xe4, 0x3b, 0x56, 0x58, + 0xe8, 0x0d, 0xa8, 0x06, 0x21, 0x4f, 0x4d, 0x7c, 0xdd, 0x4b, 0x02, 0x78, 0x63, 0x02, 0xe0, 0x1b, + 0xb1, 0xae, 0xc6, 0xec, 0xc1, 0xfe, 0x52, 0x35, 0x79, 0xc5, 0x1a, 0xc5, 0x76, 0xe1, 0x49, 0xc3, + 0xbe, 0xf5, 0xc0, 0x6f, 0x79, 0x62, 0x41, 0x97, 0xa1, 0xc4, 0x46, 0x21, 0x11, 0x8b, 0x59, 0xd5, + 0x2e, 0xda, 0x1d, 0x85, 0x04, 0x0b, 0x0e, 0xfa, 0x04, 0x4c, 0xf7, 0x09, 0xa5, 0x4e, 0x9b, 0x88, + 0x35, 0xa9, 0x36, 0xe6, 0x95, 0xd0, 0xf4, 0x35, 0x49, 0xc6, 0x31, 0xdf, 0x7e, 0x03, 0x9e, 0x3e, + 0x7c, 0x3f, 0xa0, 0x8f, 0xc1, 0x14, 0x25, 0xd1, 0x90, 0x44, 0x0a, 0x48, 0x7b, 0x46, 0x50, 0xb1, + 0xe2, 0xa2, 0x15, 0xa8, 0xfa, 0x4e, 0x9f, 0xd0, 0xd0, 0x71, 0x63, 0xb8, 0x33, 0x4a, 0xb4, 0x7a, + 0x3d, 0x66, 0x60, 0x2d, 0x63, 0xff, 0xd5, 0x82, 0x79, 0x03, 0xf3, 0x31, 0xa4, 0xbd, 0x6e, 0x3a, + 0xed, 0x5d, 0xce, 0x27, 0x62, 0x8e, 0xc8, 0x7b, 0xbf, 0x2b, 0xc2, 0x19, 0x33, 0xae, 0x44, 0x32, + 0xe3, 0x4b, 0x12, 0x91, 0x30, 0x78, 0x09, 0x5f, 0x55, 0xee, 0x4c, 0x96, 0x04, 0x4b, 0x32, 0x8e, + 0xf9, 0x7c, 0x7d, 0x43, 0x87, 0x75, 0x94, 0x2f, 0x93, 0xf5, 0xdd, 0x71, 0x58, 0x07, 0x0b, 0x0e, + 0x4f, 0x43, 0xc4, 0x1f, 0x7a, 0x51, 0xe0, 0xf7, 0x89, 0xcf, 0xb2, 0x69, 0xe8, 0x92, 0x66, 0x61, + 0x53, 0x0e, 0x7d, 0x09, 0xe6, 0x98, 0x13, 0xb5, 0x09, 0xc3, 0x64, 0xe8, 0xd1, 0x38, 0x90, 0xab, + 0x8d, 0xa7, 0xd5, 0x97, 0x73, 0xbb, 0x29, 0x2e, 0xce, 0x48, 0xa3, 0x77, 0x2c, 0x78, 0xc6, 0x0d, + 0xfa, 0x61, 0xe0, 0x13, 0x9f, 0xed, 0x38, 0x91, 0xd3, 0x27, 0x8c, 0x44, 0x37, 0x86, 0x24, 0x8a, + 0xbc, 0x16, 0xa1, 0x0b, 0x65, 0xe1, 0xdd, 0x6b, 0x13, 0x78, 0x77, 0x7d, 0x4c, 0x7b, 0xe3, 0x9c, + 0x32, 0xee, 0x99, 0xf5, 0xa3, 0x91, 0xf1, 0xbf, 0x33, 0x8b, 0x57, 0x9d, 0xa1, 0xd3, 0x1b, 0x10, + 0x7a, 0xd9, 0xe3, 0x39, 0x78, 0x4a, 0x57, 0x9d, 0x97, 0x35, 0x19, 0x9b, 0x32, 0xf6, 0x3b, 0xc5, + 0x54, 0x88, 0x36, 0xe3, 0xbc, 0x23, 0xd6, 0x52, 0x05, 0x68, 0x5e, 0x79, 0x47, 0xe8, 0x34, 0x76, + 0x97, 0x2c, 0x7e, 0x0a, 0x0b, 0x7d, 0xcf, 0x12, 0x25, 0x27, 0xde, 0x95, 0x2a, 0xc7, 0x3e, 0x82, + 0xf2, 0x67, 0x56, 0xb1, 0x98, 0x88, 0x4d, 0x68, 0x1e, 0xc2, 0xa1, 0xac, 0x3e, 0x2a, 0xe2, 0x92, + 0x10, 0x8e, 0x8b, 0x52, 0xcc, 0x47, 0x03, 0x00, 0x3a, 0xf2, 0xdd, 0x9d, 0xa0, 0xe7, 0xb9, 0x23, + 0x95, 0x2e, 0x27, 0x69, 0x36, 0x9a, 0x89, 0xb2, 0xc6, 0x1c, 0x2f, 0x43, 0xfa, 0x1d, 0x1b, 0x40, + 0xf6, 0x2f, 0xa6, 0xd2, 0x5b, 0x4f, 0xa6, 0xee, 0x9f, 0x58, 0x70, 0x9a, 0xc7, 0x87, 0x13, 0x79, + 0x34, 0xf0, 0x31, 0xa1, 0x83, 0x1e, 0x53, 0x6b, 0xb8, 0x3d, 0x61, 0xac, 0x9a, 0x2a, 0x1b, 0x0b, + 0xca, 0x1d, 0xa7, 0xb3, 0x1c, 0x3c, 0x06, 0x8f, 0x18, 0x4c, 0x77, 0x3c, 0xca, 0x82, 0x68, 0xa4, + 0x72, 0xd2, 0x24, 0x9d, 0xe6, 0x06, 0x09, 0x7b, 0xc1, 0x88, 0x6f, 0xf1, 0x2d, 0x7f, 0x2f, 0xd0, + 0xcb, 0xb2, 0x29, 0x11, 0x70, 0x0c, 0x85, 0xbe, 0x65, 0x01, 0x84, 0xf1, 0x06, 0xe1, 0xf5, 0xf3, + 0x11, 0xec, 0xd7, 0xa4, 0x55, 0x48, 0x48, 0x14, 0x1b, 0xa0, 0x28, 0x80, 0xa9, 0x0e, 0x71, 0x7a, + 0xac, 0xa3, 0xc2, 0xe2, 0xc5, 0x09, 0xe0, 0x37, 0x85, 0xa2, 0x6c, 0xe5, 0x96, 0x54, 0xac, 0x60, + 0xd0, 0x77, 0x2c, 0x98, 0x4b, 0x8a, 0x2a, 0x97, 0x25, 0x0b, 0xe5, 0x89, 0x9b, 0xfb, 0x1b, 0x29, + 0x85, 0x0d, 0xc4, 0xb3, 0x67, 0x9a, 0x86, 0x33, 0xa0, 0xe8, 0xdb, 0x16, 0x80, 0x1b, 0x17, 0x71, + 0x99, 0x86, 0x6a, 0xab, 0x37, 0xf2, 0xd9, 0xc8, 0x49, 0x73, 0xa0, 0xdd, 0x9f, 0x90, 0x28, 0x36, + 0x60, 0xed, 0xf7, 0x2d, 0x78, 0xca, 0xf8, 0xf0, 0x15, 0x87, 0xb9, 0x9d, 0x4b, 0x43, 0x5e, 0x1d, + 0xb6, 0x53, 0x6d, 0xc5, 0xe7, 0xcc, 0xb6, 0xe2, 0xc3, 0xfd, 0xa5, 0x8f, 0x1f, 0x35, 0xbd, 0xdd, + 0xe6, 0x1a, 0xea, 0x42, 0x85, 0xd1, 0x81, 0xbc, 0x09, 0x35, 0xc3, 0x66, 0x95, 0xb5, 0xf2, 0xaa, + 0xbb, 0x49, 0xaa, 0x32, 0x88, 0xd8, 0xc4, 0xb3, 0xff, 0x54, 0x80, 0xe9, 0xf5, 0xde, 0x80, 0x32, + 0x12, 0x9d, 0xb8, 0x8f, 0x59, 0x86, 0x12, 0xef, 0x51, 0xb2, 0x65, 0x97, 0xb7, 0x30, 0x58, 0x70, + 0x50, 0x08, 0x53, 0x6e, 0xe0, 0xef, 0x79, 0x6d, 0xd5, 0x79, 0x6e, 0x4e, 0xb2, 0x73, 0xa4, 0x75, + 0xeb, 0x42, 0x9f, 0xb6, 0x49, 0xbe, 0x63, 0x85, 0x83, 0x7e, 0x64, 0xc1, 0xbc, 0x1b, 0xf8, 0x3e, + 0x71, 0x75, 0xf0, 0x96, 0x26, 0xee, 0xb2, 0xd7, 0xd3, 0x1a, 0x1b, 0xff, 0xa7, 0xd0, 0xe7, 0x33, + 0x0c, 0x9c, 0xc5, 0xb6, 0x7f, 0x53, 0x80, 0xd9, 0x94, 0xe5, 0xe8, 0x59, 0xa8, 0x0c, 0x28, 0x89, + 0x84, 0xe7, 0xa4, 0x7f, 0x93, 0x46, 0xec, 0x25, 0x45, 0xc7, 0x89, 0x04, 0x97, 0x0e, 0x1d, 0x4a, + 0x6f, 0x07, 0x51, 0x4b, 0xf9, 0x39, 0x91, 0xde, 0x51, 0x74, 0x9c, 0x48, 0xf0, 0x36, 0xe7, 0x26, + 0x71, 0x22, 0x12, 0xed, 0x06, 0x5d, 0x32, 0x36, 0x6d, 0x35, 0x34, 0x0b, 0x9b, 0x72, 0xc2, 0x69, + 0xac, 0x47, 0xd7, 0x7b, 0x1e, 0xf1, 0x99, 0x34, 0x33, 0x07, 0xa7, 0xed, 0x5e, 0x6d, 0x9a, 0x1a, + 0xb5, 0xd3, 0x32, 0x0c, 0x9c, 0xc5, 0xb6, 0xff, 0x68, 0x41, 0x4d, 0x39, 0xed, 0x31, 0xf4, 0xba, + 0xed, 0x74, 0xaf, 0xdb, 0x98, 0x3c, 0x46, 0x8f, 0xe8, 0x73, 0xef, 0x15, 0x61, 0xac, 0xd2, 0xa1, + 0xd7, 0x79, 0x8e, 0xe3, 0x34, 0xd2, 0x5a, 0x8b, 0x8b, 0xec, 0x27, 0x4f, 0xf6, 0x77, 0xbb, 0x5e, + 0x9f, 0x98, 0xe9, 0x2b, 0xd6, 0x82, 0x0d, 0x8d, 0xe8, 0x2d, 0x4b, 0x03, 0xec, 0x06, 0x2a, 0xaf, + 0xe4, 0xdb, 0x89, 0x8d, 0x99, 0xb0, 0x1b, 0x60, 0x03, 0x13, 0xbd, 0x90, 0xcc, 0x9f, 0x65, 0x11, + 0x90, 0x76, 0x7a, 0x62, 0xfc, 0x30, 0xd5, 0x00, 0x64, 0xa6, 0xc8, 0x11, 0x54, 0x23, 0x22, 0x3b, + 0xbb, 0xb8, 0x02, 0x4c, 0x92, 0x44, 0xb0, 0xd2, 0x25, 0xb7, 0x71, 0x32, 0x75, 0xc5, 0x64, 0x8a, + 0x35, 0x1a, 0xdf, 0x7a, 0x51, 0xdc, 0xf6, 0x4f, 0xa7, 0xb7, 0x5e, 0xd2, 0xf0, 0x27, 0x12, 0xf6, + 0x0f, 0x2d, 0x40, 0xe3, 0xc5, 0x9d, 0xcf, 0x7a, 0x49, 0xa7, 0xad, 0xb6, 0x7b, 0x82, 0x9a, 0x88, + 0x63, 0x2d, 0x73, 0x82, 0xa4, 0x7a, 0x0e, 0xca, 0xa2, 0xf3, 0x56, 0xdb, 0x3b, 0x89, 0x35, 0xd1, + 0x9b, 0x63, 0xc9, 0xb3, 0x7f, 0x6f, 0x41, 0x36, 0x39, 0x89, 0xbc, 0x2e, 0xd7, 0x21, 0x9b, 0xd7, + 0xd3, 0x3e, 0x3f, 0xf9, 0x30, 0x8c, 0x5e, 0x83, 0x9a, 0xc3, 0x18, 0xe9, 0x87, 0x4c, 0x84, 0x6f, + 0xf1, 0x81, 0xc3, 0x57, 0x34, 0xa7, 0xd7, 0x82, 0x96, 0xb7, 0xe7, 0x89, 0xd0, 0x35, 0xd5, 0xd9, + 0x1f, 0x14, 0x61, 0x2e, 0xdd, 0xaa, 0xa1, 0x01, 0x4c, 0x89, 0xd6, 0x48, 0x9e, 0x85, 0xe5, 0xde, + 0x8b, 0x25, 0x2e, 0x11, 0x24, 0x8a, 0x15, 0x58, 0x2a, 0x16, 0x0a, 0xc7, 0xc5, 0xc2, 0xb1, 0x63, + 0x5f, 0xf1, 0xbf, 0x73, 0xec, 0x7b, 0x1d, 0xa0, 0x25, 0xbc, 0x2d, 0xd6, 0xb2, 0xf4, 0xf0, 0xa9, + 0x68, 0x23, 0xd1, 0x82, 0x0d, 0x8d, 0xe8, 0x2c, 0x14, 0xbc, 0x96, 0xc8, 0x01, 0xc5, 0x06, 0x28, + 0xd9, 0xc2, 0xd6, 0x06, 0x2e, 0x78, 0x2d, 0x9b, 0xc2, 0x8c, 0xd9, 0x9b, 0x9e, 0x38, 0x56, 0xbf, + 0x00, 0xb3, 0xf2, 0x69, 0x83, 0x30, 0xc7, 0xeb, 0x51, 0xb5, 0x3a, 0x4f, 0x29, 0xf1, 0xd9, 0xa6, + 0xc9, 0xc4, 0x69, 0x59, 0xfb, 0xe7, 0x05, 0x80, 0xcd, 0x20, 0xe8, 0x2a, 0xcc, 0x78, 0xeb, 0x59, + 0x47, 0x6e, 0xbd, 0x65, 0x28, 0x75, 0x3d, 0xbf, 0x95, 0xdd, 0x9c, 0xdb, 0x9e, 0xdf, 0xc2, 0x82, + 0x83, 0x56, 0x01, 0x9c, 0xd0, 0x7b, 0x99, 0x44, 0x54, 0x1f, 0x77, 0x26, 0x7e, 0x59, 0xdb, 0xd9, + 0x52, 0x1c, 0x6c, 0x48, 0xa1, 0x67, 0x55, 0x1f, 0x29, 0xcf, 0x16, 0x16, 0x32, 0x7d, 0x64, 0x85, + 0x5b, 0x68, 0x34, 0x8a, 0x17, 0x33, 0xd9, 0x74, 0x79, 0x2c, 0x9b, 0xea, 0xbe, 0x7a, 0xa7, 0xe3, + 0x50, 0x72, 0xd8, 0xbe, 0x9e, 0x3a, 0xe6, 0x90, 0xab, 0x09, 0x95, 0x2b, 0xaf, 0xec, 0xca, 0xee, + 0xc0, 0x86, 0xa2, 0xe7, 0xc8, 0xe4, 0x55, 0xd4, 0x61, 0xbf, 0x45, 0xe9, 0x40, 0xac, 0x30, 0x67, + 0xa2, 0x73, 0x50, 0x24, 0x77, 0x42, 0xe1, 0x97, 0xa2, 0x4e, 0x70, 0x97, 0xee, 0x84, 0x5e, 0x44, + 0x28, 0x17, 0x22, 0x77, 0x42, 0xfb, 0xef, 0x16, 0xe8, 0x73, 0x3b, 0xb4, 0x07, 0x25, 0x3e, 0x88, + 0xaa, 0x92, 0xb7, 0x39, 0xe1, 0xac, 0xab, 0x8f, 0x07, 0x2b, 0xe2, 0xf4, 0x73, 0xe4, 0xbb, 0x58, + 0xe8, 0x47, 0x43, 0xa8, 0x44, 0x41, 0xaf, 0x77, 0xd3, 0x71, 0xbb, 0x39, 0x54, 0x3f, 0xac, 0x54, + 0x69, 0xbc, 0x19, 0x91, 0x04, 0x14, 0x19, 0x27, 0x58, 0xf6, 0xaf, 0xcb, 0x90, 0x19, 0x70, 0xd0, + 0xc0, 0x3c, 0x12, 0xb5, 0x72, 0x3c, 0x12, 0x4d, 0x3c, 0x7e, 0xd8, 0xb1, 0x28, 0x7a, 0x1e, 0xca, + 0x21, 0x0f, 0x04, 0x15, 0xb6, 0x4b, 0x71, 0xc1, 0x10, 0xd1, 0x71, 0x48, 0xbc, 0x48, 0x69, 0x33, + 0x5c, 0x8a, 0xc7, 0x94, 0x81, 0x6f, 0xca, 0xd3, 0x0b, 0x75, 0x52, 0x20, 0x33, 0xc7, 0xf5, 0xbc, + 0x56, 0x54, 0x1d, 0x16, 0x24, 0xc7, 0x18, 0xea, 0x88, 0xc0, 0x40, 0x44, 0xdf, 0xb7, 0x60, 0x2e, + 0x76, 0xbc, 0x32, 0xa2, 0xfc, 0x48, 0x8c, 0x10, 0x63, 0x2b, 0x4e, 0x21, 0xe1, 0x0c, 0x32, 0xfa, + 0x0a, 0x54, 0x29, 0x73, 0x22, 0x59, 0x11, 0xa7, 0x1e, 0x38, 0x8b, 0x26, 0x6b, 0xd9, 0x8c, 0x95, + 0x60, 0xad, 0x0f, 0xbd, 0x0a, 0xb0, 0xe7, 0xf9, 0x1e, 0xed, 0x08, 0xed, 0xd3, 0x0f, 0x57, 0x6f, + 0x2f, 0x27, 0x1a, 0xb0, 0xa1, 0xcd, 0xfe, 0x6e, 0x01, 0x6a, 0xc6, 0x6d, 0xc9, 0x09, 0xf2, 0x61, + 0xe6, 0x76, 0xa7, 0x70, 0xc2, 0xdb, 0x9d, 0xf3, 0x50, 0x09, 0x83, 0x9e, 0xe7, 0x7a, 0xaa, 0x16, + 0x56, 0xe5, 0x26, 0xda, 0x51, 0x34, 0x9c, 0x70, 0x11, 0x83, 0xea, 0xad, 0xdb, 0x4c, 0xe4, 0xa1, + 0xf8, 0x2e, 0x68, 0x7d, 0x82, 0x25, 0x8d, 0x73, 0x9a, 0x76, 0x72, 0x4c, 0xa1, 0x58, 0x03, 0xd9, + 0x7f, 0x2e, 0x00, 0x88, 0xcb, 0x34, 0x4f, 0x1c, 0x02, 0x2d, 0x43, 0x29, 0x22, 0x61, 0x90, 0xf5, + 0x03, 0x97, 0xc0, 0x82, 0x93, 0x9a, 0xe9, 0x0a, 0x0f, 0x34, 0xd3, 0x15, 0x8f, 0x9d, 0xe9, 0x78, + 0x85, 0xa3, 0x9d, 0x9d, 0xc8, 0x1b, 0x3a, 0x8c, 0x6c, 0x93, 0x91, 0x2a, 0x13, 0xba, 0xc2, 0x35, + 0x37, 0x35, 0x13, 0xa7, 0x65, 0x0f, 0x1d, 0x87, 0xcb, 0xff, 0xc1, 0x71, 0xf8, 0x9e, 0x05, 0x73, + 0xda, 0xb3, 0xff, 0x5b, 0xf7, 0xb7, 0xda, 0xee, 0x23, 0xe6, 0xbb, 0x7f, 0x58, 0x30, 0x1f, 0x4f, + 0x12, 0xaa, 0xc5, 0xc8, 0xa5, 0xa7, 0x48, 0xdd, 0x17, 0x15, 0x8f, 0xbf, 0x2f, 0x32, 0x33, 0x77, + 0xe9, 0x98, 0xcc, 0xfd, 0xc5, 0x4c, 0x37, 0xf1, 0x91, 0xb1, 0x6e, 0x02, 0x25, 0x33, 0xd3, 0xc8, + 0x77, 0xd3, 0xdd, 0x97, 0xfd, 0x2b, 0x0b, 0x66, 0x62, 0xf6, 0xf5, 0xa0, 0x25, 0x66, 0x13, 0x2a, + 0x82, 0xcc, 0x4a, 0xcf, 0x26, 0x32, 0x1c, 0x24, 0x0f, 0x0d, 0xa0, 0xe2, 0x76, 0xbc, 0x5e, 0x2b, + 0x22, 0xbe, 0x5a, 0x96, 0x17, 0x73, 0x18, 0xe9, 0x38, 0xbe, 0x0e, 0x85, 0x75, 0x05, 0x80, 0x13, + 0x28, 0xfb, 0xb7, 0x45, 0x98, 0x4d, 0xcd, 0x7f, 0x3c, 0x7d, 0xc9, 0x0b, 0x9b, 0xa6, 0x61, 0x73, + 0x92, 0xbe, 0x76, 0x35, 0x0b, 0x9b, 0x72, 0x7c, 0x3d, 0x7a, 0xde, 0x50, 0xea, 0xc8, 0xde, 0xdf, + 0x5d, 0x8d, 0x19, 0x58, 0xcb, 0x18, 0x03, 0x70, 0xf1, 0x81, 0x07, 0xe0, 0x9f, 0x5a, 0x80, 0xc4, + 0x2f, 0x70, 0xcd, 0xc9, 0x9c, 0xaa, 0x72, 0x61, 0x6e, 0x7e, 0x3b, 0xab, 0x2c, 0x42, 0xeb, 0x63, + 0x50, 0xf8, 0x10, 0x78, 0xe3, 0x4c, 0xba, 0xfc, 0x58, 0xce, 0xa4, 0xed, 0x6f, 0xc0, 0x99, 0xb1, + 0xd6, 0x4b, 0x0d, 0x14, 0xd6, 0x61, 0x03, 0x05, 0x8f, 0xc4, 0x30, 0x1a, 0xf8, 0x72, 0x81, 0x2a, + 0x3a, 0x12, 0x77, 0x38, 0x11, 0x4b, 0x1e, 0x9f, 0x32, 0x5a, 0xd1, 0x08, 0x0f, 0x64, 0xa7, 0x5e, + 0xd1, 0xe8, 0x1b, 0x82, 0x8a, 0x15, 0xd7, 0x7e, 0xbb, 0x00, 0xb3, 0xa9, 0x76, 0x20, 0x35, 0x10, + 0x5a, 0xc7, 0x0e, 0x84, 0x79, 0x1a, 0x83, 0xde, 0x84, 0x19, 0x2a, 0xb6, 0x62, 0xe4, 0x30, 0xd2, + 0x1e, 0xe5, 0x70, 0x2b, 0xd0, 0x34, 0xd4, 0x35, 0x4e, 0x1f, 0xec, 0x2f, 0xcd, 0x98, 0x14, 0x9c, + 0x82, 0xb3, 0x7f, 0x59, 0x80, 0x27, 0x0e, 0x69, 0x8d, 0xd0, 0x6d, 0xf3, 0xa4, 0x46, 0x0e, 0xe7, + 0x57, 0x72, 0x08, 0x4f, 0x95, 0x48, 0xe5, 0xad, 0xff, 0xb1, 0xe7, 0x34, 0xc7, 0xcf, 0xe6, 0x7b, + 0x50, 0xee, 0x04, 0x41, 0x37, 0x1e, 0xc2, 0x27, 0x29, 0x08, 0x7a, 0x74, 0x6c, 0x54, 0xf9, 0x6a, + 0xf2, 0x77, 0x8a, 0xa5, 0x7a, 0xfb, 0x6d, 0x0b, 0x8c, 0x4b, 0x37, 0xf4, 0x75, 0xa8, 0x3a, 0x03, + 0x16, 0xf4, 0x1d, 0x46, 0x5a, 0xaa, 0xcc, 0x5d, 0xcf, 0xe5, 0x7a, 0x6f, 0x2d, 0xd6, 0x2a, 0x3d, + 0x94, 0xbc, 0x62, 0x8d, 0x67, 0xbf, 0x20, 0x57, 0x2c, 0xf3, 0x81, 0x8e, 0x4a, 0xeb, 0xe8, 0xa8, + 0xb4, 0x3f, 0xb0, 0x20, 0x15, 0x0d, 0xa8, 0x0f, 0x65, 0x6e, 0xd2, 0x28, 0x87, 0x4b, 0x5d, 0x53, + 0xef, 0x1a, 0xd7, 0x29, 0xfd, 0x28, 0x1e, 0xb1, 0x44, 0x41, 0x1e, 0x94, 0xb8, 0x43, 0xd5, 0xe8, + 0xb6, 0x9d, 0x13, 0x1a, 0x5f, 0x2a, 0x39, 0x29, 0xf2, 0x27, 0x2c, 0x20, 0xec, 0x8b, 0x70, 0x66, + 0xcc, 0x22, 0xee, 0xa4, 0xbd, 0x20, 0xbe, 0xc3, 0x36, 0x9c, 0x74, 0x99, 0x13, 0xb1, 0xe4, 0xf1, + 0x3a, 0x78, 0x3a, 0xab, 0x1e, 0xfd, 0xcc, 0x82, 0x33, 0x34, 0xab, 0xef, 0x91, 0x78, 0xed, 0xff, + 0x95, 0x51, 0xe3, 0xe6, 0xe3, 0x71, 0x0b, 0xf8, 0x8a, 0x66, 0x8f, 0xe0, 0xf9, 0x1e, 0xf2, 0x7c, + 0x4a, 0xdc, 0x41, 0x14, 0xff, 0xa8, 0x1e, 0xf4, 0x15, 0x1d, 0x27, 0x12, 0x68, 0x15, 0x40, 0x5e, + 0x01, 0x5d, 0xd7, 0x0d, 0x6f, 0x72, 0xc8, 0xd1, 0x4c, 0x38, 0xd8, 0x90, 0xe2, 0x3d, 0xbf, 0x4b, + 0x22, 0xb6, 0xc1, 0xdb, 0x3c, 0x9e, 0xdf, 0x66, 0x64, 0xcf, 0xbf, 0xae, 0x68, 0x38, 0xe1, 0xa2, + 0x8f, 0xc2, 0x74, 0x97, 0x8c, 0x84, 0x60, 0x49, 0x08, 0xd6, 0x78, 0xe7, 0xb2, 0x2d, 0x49, 0x38, + 0xe6, 0x21, 0x1b, 0xa6, 0x5c, 0x47, 0x48, 0x95, 0x85, 0x14, 0x88, 0xdb, 0xa0, 0x35, 0x21, 0xa4, + 0x38, 0x8d, 0xfa, 0xdd, 0xfb, 0x8b, 0xa7, 0xde, 0xbd, 0xbf, 0x78, 0xea, 0xbd, 0xfb, 0x8b, 0xa7, + 0xde, 0x3a, 0x58, 0xb4, 0xee, 0x1e, 0x2c, 0x5a, 0xef, 0x1e, 0x2c, 0x5a, 0xef, 0x1d, 0x2c, 0x5a, + 0x7f, 0x3b, 0x58, 0xb4, 0x7e, 0xfc, 0xfe, 0xe2, 0xa9, 0x57, 0x2b, 0xb1, 0x6b, 0xff, 0x15, 0x00, + 0x00, 0xff, 0xff, 0x25, 0xc2, 0xb5, 0xcc, 0xc6, 0x2a, 0x00, 0x00, } diff --git a/pkg/apis/application/v1alpha1/generated.proto b/pkg/apis/application/v1alpha1/generated.proto index 16b3057f00..4f831012b1 100644 --- a/pkg/apis/application/v1alpha1/generated.proto +++ b/pkg/apis/application/v1alpha1/generated.proto @@ -117,6 +117,9 @@ message ApplicationSpec { // Project is a application project name. Empty name means that application belongs to 'default' project. optional string project = 3; + + // SyncPolicy controls when a sync will be performed + optional SyncPolicy syncPolicy = 4; } // ApplicationStatus contains information about application status in target environment. @@ -194,6 +197,8 @@ message ComparisonResult { optional string status = 5; repeated ResourceState resources = 6; + + optional string revision = 7; } // ComponentParameter contains information about component parameter value @@ -366,7 +371,8 @@ message RollbackOperation { // SyncOperation contains sync operation details. message SyncOperation { - // Revision is the git revision in which to sync the application to + // Revision is the git revision in which to sync the application to. + // If omitted, will use the revision specified in app spec. optional string revision = 1; // Prune deletes resources that are no longer tracked in git @@ -391,12 +397,24 @@ message SyncOperationResult { repeated HookStatus hooks = 3; } -// SyncStrategy indicates the +// SyncPolicy controls when a sync will be performed in response to updates in git +message SyncPolicy { + // Automated will keep an application synced to the target revision + optional SyncPolicyAutomated automated = 1; +} + +// SyncPolicyAutomated controls the behavior of an automated sync +message SyncPolicyAutomated { + // Prune will prune resources automatically as part of automated sync (default: false) + optional bool prune = 1; +} + +// SyncStrategy controls the manner in which a sync is performed message SyncStrategy { - // Apply wil perform a `kubectl apply` to perform the sync. This is the default strategy + // Apply wil perform a `kubectl apply` to perform the sync. optional SyncStrategyApply apply = 1; - // Hook will submit any referenced resources to perform the sync + // Hook will submit any referenced resources to perform the sync. This is the default strategy optional SyncStrategyHook hook = 2; } diff --git a/pkg/apis/application/v1alpha1/types.go b/pkg/apis/application/v1alpha1/types.go index 1bd5a96527..44af6ec3ca 100644 --- a/pkg/apis/application/v1alpha1/types.go +++ b/pkg/apis/application/v1alpha1/types.go @@ -16,7 +16,8 @@ import ( // SyncOperation contains sync operation details. type SyncOperation struct { - // Revision is the git revision in which to sync the application to + // Revision is the git revision in which to sync the application to. + // If omitted, will use the revision specified in app spec. Revision string `json:"revision,omitempty" protobuf:"bytes,1,opt,name=revision"` // Prune deletes resources that are no longer tracked in git Prune bool `json:"prune,omitempty" protobuf:"bytes,2,opt,name=prune"` @@ -78,11 +79,23 @@ type OperationState struct { FinishedAt *metav1.Time `json:"finishedAt" protobuf:"bytes,7,opt,name=finishedAt"` } -// SyncStrategy indicates the +// SyncPolicy controls when a sync will be performed in response to updates in git +type SyncPolicy struct { + // Automated will keep an application synced to the target revision + Automated *SyncPolicyAutomated `json:"automated,omitempty" protobuf:"bytes,1,opt,name=automated"` +} + +// SyncPolicyAutomated controls the behavior of an automated sync +type SyncPolicyAutomated struct { + // Prune will prune resources automatically as part of automated sync (default: false) + Prune bool `json:"prune,omitempty" protobuf:"bytes,1,opt,name=prune"` +} + +// SyncStrategy controls the manner in which a sync is performed type SyncStrategy struct { - // Apply wil perform a `kubectl apply` to perform the sync. This is the default strategy + // Apply wil perform a `kubectl apply` to perform the sync. Apply *SyncStrategyApply `json:"apply,omitempty" protobuf:"bytes,1,opt,name=apply"` - // Hook will submit any referenced resources to perform the sync + // Hook will submit any referenced resources to perform the sync. This is the default strategy Hook *SyncStrategyHook `json:"hook,omitempty" protobuf:"bytes,2,opt,name=hook"` } @@ -218,6 +231,8 @@ type ApplicationSpec struct { Destination ApplicationDestination `json:"destination" protobuf:"bytes,2,name=destination"` // Project is a application project name. Empty name means that application belongs to 'default' project. Project string `json:"project" protobuf:"bytes,3,name=project"` + // SyncPolicy controls when a sync will be performed + SyncPolicy *SyncPolicy `json:"syncPolicy" protobuf:"bytes,4,name=syncPolicy"` } // ComponentParameter contains information about component parameter value @@ -283,8 +298,10 @@ const ( ApplicationConditionDeletionError = "DeletionError" // ApplicationConditionInvalidSpecError indicates that application source is invalid ApplicationConditionInvalidSpecError = "InvalidSpecError" - // ApplicationComparisonError indicates controller failed to compare application state + // ApplicationConditionComparisonError indicates controller failed to compare application state ApplicationConditionComparisonError = "ComparisonError" + // ApplicationConditionSyncError indicates controller failed to automatically sync the application + ApplicationConditionSyncError = "SyncError" // ApplicationConditionUnknownError indicates an unknown controller error ApplicationConditionUnknownError = "UnknownError" // ApplicationConditionSharedResourceWarning indicates that controller detected resources which belongs to more than one application @@ -305,6 +322,7 @@ type ComparisonResult struct { ComparedTo ApplicationSource `json:"comparedTo" protobuf:"bytes,2,opt,name=comparedTo"` Status ComparisonStatus `json:"status" protobuf:"bytes,5,opt,name=status,casttype=ComparisonStatus"` Resources []ResourceState `json:"resources" protobuf:"bytes,6,opt,name=resources"` + Revision string `json:"revision" protobuf:"bytes,7,opt,name=revision"` } type HealthStatus struct { diff --git a/pkg/apis/application/v1alpha1/zz_generated.deepcopy.go b/pkg/apis/application/v1alpha1/zz_generated.deepcopy.go index b3f99492c0..dc6c0eb845 100644 --- a/pkg/apis/application/v1alpha1/zz_generated.deepcopy.go +++ b/pkg/apis/application/v1alpha1/zz_generated.deepcopy.go @@ -235,6 +235,15 @@ func (in *ApplicationSpec) DeepCopyInto(out *ApplicationSpec) { *out = *in in.Source.DeepCopyInto(&out.Source) out.Destination = in.Destination + if in.SyncPolicy != nil { + in, out := &in.SyncPolicy, &out.SyncPolicy + if *in == nil { + *out = nil + } else { + *out = new(SyncPolicy) + (*in).DeepCopyInto(*out) + } + } return } @@ -799,6 +808,47 @@ func (in *SyncOperationResult) DeepCopy() *SyncOperationResult { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *SyncPolicy) DeepCopyInto(out *SyncPolicy) { + *out = *in + if in.Automated != nil { + in, out := &in.Automated, &out.Automated + if *in == nil { + *out = nil + } else { + *out = new(SyncPolicyAutomated) + **out = **in + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SyncPolicy. +func (in *SyncPolicy) DeepCopy() *SyncPolicy { + if in == nil { + return nil + } + out := new(SyncPolicy) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *SyncPolicyAutomated) DeepCopyInto(out *SyncPolicyAutomated) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SyncPolicyAutomated. +func (in *SyncPolicyAutomated) DeepCopy() *SyncPolicyAutomated { + if in == nil { + return nil + } + out := new(SyncPolicyAutomated) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *SyncStrategy) DeepCopyInto(out *SyncStrategy) { *out = *in diff --git a/server/application/application.go b/server/application/application.go index e4896f1147..047cdc118a 100644 --- a/server/application/application.go +++ b/server/application/application.go @@ -705,70 +705,51 @@ func (s *Server) getRepo(ctx context.Context, repoURL string) *appv1.Repository // Sync syncs an application to its target state func (s *Server) Sync(ctx context.Context, syncReq *ApplicationSyncRequest) (*appv1.Application, error) { - a, err := s.appclientset.ArgoprojV1alpha1().Applications(s.ns).Get(*syncReq.Name, metav1.GetOptions{}) + appIf := s.appclientset.ArgoprojV1alpha1().Applications(s.ns) + a, err := appIf.Get(*syncReq.Name, metav1.GetOptions{}) if err != nil { return nil, err } if !s.enf.EnforceClaims(ctx.Value("claims"), "applications", "sync", appRBACName(*a)) { return nil, grpc.ErrPermissionDenied } - return s.setAppOperation(ctx, *syncReq.Name, "sync", func(app *appv1.Application) (*appv1.Operation, error) { - syncOp := appv1.SyncOperation{ + if a.Spec.SyncPolicy != nil && a.Spec.SyncPolicy.Automated != nil { + if syncReq.Revision != "" && syncReq.Revision != a.Spec.Source.TargetRevision { + return nil, status.Errorf(codes.FailedPrecondition, "Cannot sync to %s: auto-sync currently set to %s", syncReq.Revision, a.Spec.Source.TargetRevision) + } + } + + op := appv1.Operation{ + Sync: &appv1.SyncOperation{ Revision: syncReq.Revision, Prune: syncReq.Prune, DryRun: syncReq.DryRun, SyncStrategy: syncReq.Strategy, - } - return &appv1.Operation{ - Sync: &syncOp, - }, nil - }) + }, + } + return argo.SetAppOperation(ctx, appIf, s.auditLogger, *syncReq.Name, &op) } func (s *Server) Rollback(ctx context.Context, rollbackReq *ApplicationRollbackRequest) (*appv1.Application, error) { - a, err := s.appclientset.ArgoprojV1alpha1().Applications(s.ns).Get(*rollbackReq.Name, metav1.GetOptions{}) + appIf := s.appclientset.ArgoprojV1alpha1().Applications(s.ns) + a, err := appIf.Get(*rollbackReq.Name, metav1.GetOptions{}) if err != nil { return nil, err } if !s.enf.EnforceClaims(ctx.Value("claims"), "applications", "rollback", appRBACName(*a)) { return nil, grpc.ErrPermissionDenied } - return s.setAppOperation(ctx, *rollbackReq.Name, "rollback", func(app *appv1.Application) (*appv1.Operation, error) { - return &appv1.Operation{ - Rollback: &appv1.RollbackOperation{ - ID: rollbackReq.ID, - Prune: rollbackReq.Prune, - DryRun: rollbackReq.DryRun, - }, - }, nil - }) -} - -func (s *Server) setAppOperation(ctx context.Context, appName string, operationName string, operationCreator func(app *appv1.Application) (*appv1.Operation, error)) (*appv1.Application, error) { - for { - a, err := s.Get(ctx, &ApplicationQuery{Name: &appName}) - if err != nil { - return nil, err - } - if a.Operation != nil { - return nil, status.Errorf(codes.InvalidArgument, "another operation is already in progress") - } - op, err := operationCreator(a) - if err != nil { - return nil, err - } - a.Operation = op - a.Status.OperationState = nil - _, err = s.appclientset.ArgoprojV1alpha1().Applications(s.ns).Update(a) - if err != nil && apierr.IsConflict(err) { - log.Warnf("Failed to set operation for app '%s' due to update conflict. Retrying again...", appName) - } else { - if err == nil { - s.logEvent(a, ctx, argo.EventReasonResourceUpdated, operationName) - } - return a, err - } + if a.Spec.SyncPolicy != nil && a.Spec.SyncPolicy.Automated != nil { + return nil, status.Errorf(codes.FailedPrecondition, "Rollback cannot be initiated when auto-sync is enabled") } + op := appv1.Operation{ + Rollback: &appv1.RollbackOperation{ + ID: rollbackReq.ID, + Prune: rollbackReq.Prune, + DryRun: rollbackReq.DryRun, + }, + } + return argo.SetAppOperation(ctx, appIf, s.auditLogger, *rollbackReq.Name, &op) } func (s *Server) TerminateOperation(ctx context.Context, termOpReq *OperationTerminateRequest) (*OperationTerminateResponse, error) { diff --git a/server/swagger.json b/server/swagger.json index 54081f3468..f8374e710c 100644 --- a/server/swagger.json +++ b/server/swagger.json @@ -2104,6 +2104,9 @@ }, "source": { "$ref": "#/definitions/v1alpha1ApplicationSource" + }, + "syncPolicy": { + "$ref": "#/definitions/v1alpha1SyncPolicy" } } }, @@ -2223,6 +2226,9 @@ "$ref": "#/definitions/v1alpha1ResourceState" } }, + "revision": { + "type": "string" + }, "status": { "type": "string" } @@ -2534,8 +2540,8 @@ "title": "Prune deletes resources that are no longer tracked in git" }, "revision": { - "type": "string", - "title": "Revision is the git revision in which to sync the application to" + "description": "Revision is the git revision in which to sync the application to.\nIf omitted, will use the revision specified in app spec.", + "type": "string" }, "syncStrategy": { "$ref": "#/definitions/v1alpha1SyncStrategy" @@ -2566,9 +2572,29 @@ } } }, + "v1alpha1SyncPolicy": { + "type": "object", + "title": "SyncPolicy controls when a sync will be performed in response to updates in git", + "properties": { + "automated": { + "$ref": "#/definitions/v1alpha1SyncPolicyAutomated" + } + } + }, + "v1alpha1SyncPolicyAutomated": { + "type": "object", + "title": "SyncPolicyAutomated controls the behavior of an automated sync", + "properties": { + "prune": { + "type": "boolean", + "format": "boolean", + "title": "Prune will prune resources automatically as part of automated sync (default: false)" + } + } + }, "v1alpha1SyncStrategy": { "type": "object", - "title": "SyncStrategy indicates the", + "title": "SyncStrategy controls the manner in which a sync is performed", "properties": { "apply": { "$ref": "#/definitions/v1alpha1SyncStrategyApply" diff --git a/test/e2e/fixture.go b/test/e2e/fixture.go index 2c88cdad34..483eda4998 100644 --- a/test/e2e/fixture.go +++ b/test/e2e/fixture.go @@ -8,6 +8,8 @@ import ( "net" "os" "os/exec" + "path" + "path/filepath" "strings" "testing" "time" @@ -21,9 +23,6 @@ import ( "k8s.io/client-go/rest" "k8s.io/client-go/tools/clientcmd" - "path" - "path/filepath" - "github.com/argoproj/argo-cd/cmd/argocd/commands" "github.com/argoproj/argo-cd/common" "github.com/argoproj/argo-cd/controller" @@ -41,7 +40,6 @@ import ( "github.com/argoproj/argo-cd/util/cache" "github.com/argoproj/argo-cd/util/db" "github.com/argoproj/argo-cd/util/git" - "github.com/argoproj/argo-cd/util/kube" "github.com/argoproj/argo-cd/util/rbac" "github.com/argoproj/argo-cd/util/settings" ) @@ -58,7 +56,6 @@ type Fixture struct { AppClient appclientset.Interface DB db.ArgoDB Namespace string - InstanceID string RepoServerAddress string ApiServerAddress string Enforcer *rbac.Enforcer @@ -278,7 +275,6 @@ func NewFixture() (*Fixture, error) { DB: db, KubeClient: kubeClient, Namespace: namespace, - InstanceID: namespace, Enforcer: enforcer, } err = fixture.setup() @@ -288,7 +284,7 @@ func NewFixture() (*Fixture, error) { return fixture, nil } -// CreateApp creates application with appropriate controller instance id. +// CreateApp creates application func (f *Fixture) CreateApp(t *testing.T, application *v1alpha1.Application) *v1alpha1.Application { application = application.DeepCopy() application.Name = fmt.Sprintf("e2e-test-%v", time.Now().Unix()) @@ -297,7 +293,6 @@ func (f *Fixture) CreateApp(t *testing.T, application *v1alpha1.Application) *v1 labels = make(map[string]string) application.ObjectMeta.Labels = labels } - labels[common.LabelKeyApplicationControllerInstanceID] = f.InstanceID application.Spec.Source.ComponentParameterOverrides = append( application.Spec.Source.ComponentParameterOverrides, @@ -312,19 +307,12 @@ func (f *Fixture) CreateApp(t *testing.T, application *v1alpha1.Application) *v1 // createController creates new controller instance func (f *Fixture) createController() *controller.ApplicationController { - appStateManager := controller.NewAppStateManager( - f.DB, f.AppClient, reposerver.NewRepositoryServerClientset(f.RepoServerAddress), f.Namespace, kube.KubectlCmd{}) - return controller.NewApplicationController( f.Namespace, f.KubeClient, f.AppClient, reposerver.NewRepositoryServerClientset(f.RepoServerAddress), - f.DB, - kube.KubectlCmd{}, - appStateManager, - 10*time.Second, - &controller.ApplicationControllerConfig{Namespace: f.Namespace, InstanceID: f.InstanceID}) + 10*time.Second) } func (f *Fixture) NewApiClientset() (argocdclient.Client, error) { @@ -380,10 +368,10 @@ func WaitUntil(t *testing.T, condition wait.ConditionFunc) { type FakeGitClientFactory struct{} -func (f *FakeGitClientFactory) NewClient(repoURL, path, username, password, sshPrivateKey string) git.Client { +func (f *FakeGitClientFactory) NewClient(repoURL, path, username, password, sshPrivateKey string) (git.Client, error) { return &FakeGitClient{ root: path, - } + }, nil } // FakeGitClient is a test git client implementation which always clone local test repo. diff --git a/util/argo/argo.go b/util/argo/argo.go index 382a1f361a..b419398764 100644 --- a/util/argo/argo.go +++ b/util/argo/argo.go @@ -14,6 +14,7 @@ import ( log "github.com/sirupsen/logrus" "google.golang.org/grpc/codes" "google.golang.org/grpc/status" + "k8s.io/api/core/v1" apierr "k8s.io/apimachinery/pkg/api/errors" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/fields" @@ -29,6 +30,7 @@ import ( "github.com/argoproj/argo-cd/util" "github.com/argoproj/argo-cd/util/db" "github.com/argoproj/argo-cd/util/git" + "github.com/argoproj/argo-cd/util/session" ) const ( @@ -444,3 +446,35 @@ func verifyGenerateManifests(ctx context.Context, repoRes *argoappv1.Repository, } return conditions } + +// SetAppOperation updates an application with the specified operation, retrying conflict errors +func SetAppOperation(ctx context.Context, appIf v1alpha1.ApplicationInterface, audit *AuditLogger, appName string, op *argoappv1.Operation) (*argoappv1.Application, error) { + for { + a, err := appIf.Get(appName, metav1.GetOptions{}) + if err != nil { + return nil, err + } + if a.Operation != nil { + return nil, status.Errorf(codes.FailedPrecondition, "another operation is already in progress") + } + a.Operation = op + a.Status.OperationState = nil + a, err = appIf.Update(a) + var action string + if op.Sync != nil { + action = "sync" + } else if op.Rollback != nil { + action = "rollback" + } else { + return nil, status.Errorf(codes.InvalidArgument, "Operation unspecified") + } + if err == nil { + audit.LogAppEvent(a, EventInfo{Reason: EventReasonResourceUpdated, Action: action, Username: session.Username(ctx)}, v1.EventTypeNormal) + return a, nil + } + if !apierr.IsConflict(err) { + return nil, err + } + log.Warnf("Failed to set operation for app '%s' due to update conflict. Retrying again...", appName) + } +} diff --git a/util/argo/audit_logger.go b/util/argo/audit_logger.go index c3c1b013e8..6e56fddd69 100644 --- a/util/argo/audit_logger.go +++ b/util/argo/audit_logger.go @@ -39,8 +39,22 @@ func (l *AuditLogger) logEvent(objMeta metav1.ObjectMeta, gvk schema.GroupVersio } else { message = fmt.Sprintf("Unknown user executed action %s", info.Action) } + logCtx := log.WithFields(log.Fields{ + "type": eventType, + "action": info.Action, + "reason": info.Reason, + "username": info.Username, + }) + switch gvk.Kind { + case "Application": + logCtx = logCtx.WithField("application", objMeta.Name) + case "AppProject": + logCtx = logCtx.WithField("project", objMeta.Name) + default: + logCtx = logCtx.WithField("name", objMeta.Name) + } t := metav1.Time{Time: time.Now()} - _, err := l.kIf.CoreV1().Events(l.ns).Create(&v1.Event{ + event := v1.Event{ ObjectMeta: metav1.ObjectMeta{ Name: fmt.Sprintf("%v.%x", objMeta.Name, t.UnixNano()), }, @@ -62,9 +76,12 @@ func (l *AuditLogger) logEvent(objMeta metav1.ObjectMeta, gvk schema.GroupVersio Type: eventType, Action: info.Action, Reason: info.Reason, - }) + } + logCtx.Info(message) + _, err := l.kIf.CoreV1().Events(l.ns).Create(&event) if err != nil { - log.Errorf("Unable to create audit event: %v", err) + logCtx.Errorf("Unable to create audit event: %v", err) + return } }