From a26fd084e0ed3d279a88eb5dd62d97d581e9a97c Mon Sep 17 00:00:00 2001 From: Oleksandr Saulyak Date: Tue, 3 Dec 2024 11:24:53 +0200 Subject: [PATCH] feat(event-reporter): multi-sourced apps - resource git details reporting (#352) * event-reporter: created dedicated func resolveApplicationVersions * event-reporter: added new types for variables grouping * event-reporter: removed redundant code comment * event-reporter(refactoring): params grouping, added new type ArgoTrackingMetadata to pass data between methods * event-reporter(refactoring): params grouping, added new type ReportedEntityParentApp to pass data between methods * event-reporter(refactoring): params grouping, added new type ReportedResource to pass data between methods, created new methods to group logic inside getResourceEventPayload * event-reporter(refactoring): fixed nil pointer issues after refactoring * event-reporter(refactoring): fixed lint issue * event-reporter(refactoring): fixed lint issue * event-reporter: added agroDb to ApplicationEventReporter * event-reporter: ObjectSource message proto extended to report operationSyncRevisions, destServer, destName, appMultiSourced * event-reporter / utils: added func GetOperationRevisions * event-reporter(non-grpc app client): added support of new query params SourcePositions, Revisions for GetManifests request * event-reporter(getDesiredManifests): updated logic to retrieve appVersion for multi-sourced applications based on sync result revisions * event-reporter(resource source payload): added new field OperationSyncRevisions * event-reporter(resource source payload): added new fields DestName, DestServer * event-reporter(resource source payload): added new field AppMultiSourced * event-reporter(resource source payload): added AppSourceIdx with source index to which this resource belongs. Also updated logic of retrieving correct git commit info based on AppSourceIdx * event-reporter: updated changelog * event-reporter: fixed lint issues * event-reporter: changes after pr review * fix lint issue * reporter: fix lint issue * reporter: fix lint issue * updated changelog record * event-reporter: refactored fields inside ObjectSource * event-reporter: added runtime version reporting with each event --- assets/swagger.json | 8 + .../CHANGELOG-2.12.3-2024.11.14-d7a4c4e7e.md | 3 +- changelog/CHANGELOG.md | 4 +- .../commands/event_reporter_server.go | 11 +- event_reporter/application/client.go | 10 + event_reporter/controller/controller.go | 6 +- event_reporter/reporter/app_revision_test.go | 3 + .../reporter/application_event_reporter.go | 116 +++- .../application_event_reporter_test.go | 36 +- event_reporter/reporter/event_payload.go | 116 ++-- event_reporter/reporter/types.go | 13 +- event_reporter/server.go | 2 +- event_reporter/utils/app.go | 65 +++ event_reporter/utils/app_revision.go | 64 ++- event_reporter/utils/app_revision_test.go | 221 ++++++++ pkg/apiclient/events/events.pb.go | 499 ++++++++++++++---- pkg/codefresh/client.go | 9 +- reposerver/apiclient/repository.pb.go | 451 ++++++++++------ reposerver/repository/repository.proto | 2 + server/application/application.go | 1 + server/application/events.proto | 13 +- 21 files changed, 1295 insertions(+), 358 deletions(-) create mode 100644 event_reporter/utils/app.go diff --git a/assets/swagger.json b/assets/swagger.json index ecdbf6062defd..9241eef9942f5 100644 --- a/assets/swagger.json +++ b/assets/swagger.json @@ -5294,6 +5294,14 @@ "sourceType": { "type": "string" }, + "sourcesManifestsStartingIdx": { + "type": "array", + "title": "for multisourced apps will be [0,12,20], so this means that 0-11 - from first app source, 12-19 from second one, 20-x - third one", + "items": { + "type": "integer", + "format": "int32" + } + }, "verifyResult": { "type": "string", "title": "Raw response of git verify-commit operation (always the empty string for Helm)" diff --git a/changelog/CHANGELOG-2.12.3-2024.11.14-d7a4c4e7e.md b/changelog/CHANGELOG-2.12.3-2024.11.14-d7a4c4e7e.md index b865f7475ea3d..c1666e82a2cba 100644 --- a/changelog/CHANGELOG-2.12.3-2024.11.14-d7a4c4e7e.md +++ b/changelog/CHANGELOG-2.12.3-2024.11.14-d7a4c4e7e.md @@ -1,2 +1,3 @@ ### Changes -- fix(event-reporter): fixed issue when if managed resource in degraded state and all of it child nodes in non-degraded state no error reported \ No newline at end of file +- fix(event-reporter): fixed issue when if managed resource in degraded state and all of it child nodes in non-degraded state no error reported +- fix(repo-server): fixed repeated resources generation for ApplicationSourceTypeDirectory \ No newline at end of file diff --git a/changelog/CHANGELOG.md b/changelog/CHANGELOG.md index b865f7475ea3d..f26d54ef9a0d6 100644 --- a/changelog/CHANGELOG.md +++ b/changelog/CHANGELOG.md @@ -1,2 +1,2 @@ -### Changes -- fix(event-reporter): fixed issue when if managed resource in degraded state and all of it child nodes in non-degraded state no error reported \ No newline at end of file +### Features +- feat(event-reporter): multisourced apps support improvements: reporting syncOperationRevisions, detecting correct resource sourceIdx, reporting correct git commit info \ No newline at end of file diff --git a/cmd/event-reporter-server/commands/event_reporter_server.go b/cmd/event-reporter-server/commands/event_reporter_server.go index 5d39d70171d45..43b41695f3d44 100644 --- a/cmd/event-reporter-server/commands/event_reporter_server.go +++ b/cmd/event-reporter-server/commands/event_reporter_server.go @@ -96,6 +96,7 @@ func NewCommand() *cobra.Command { codefreshUrl string codefreshToken string shardingAlgorithm string + runtimeVersion string rootpath string useGrpc bool @@ -179,10 +180,11 @@ func NewCommand() *cobra.Command { ApplicationNamespaces: applicationNamespaces, ApplicationServiceClient: getApplicationClient(useGrpc, applicationServerAddress, argocdToken, rootpath), CodefreshConfig: &codefresh.CodefreshConfig{ - BaseURL: codefreshUrl, - AuthToken: codefreshToken, - TlsInsecure: codefreshTlsInsecure, - CaCertPath: codefreshTlsCertPath, + BaseURL: codefreshUrl, + AuthToken: codefreshToken, + TlsInsecure: codefreshTlsInsecure, + CaCertPath: codefreshTlsCertPath, + RuntimeVersion: runtimeVersion, }, RateLimiterOpts: &reporter.RateLimiterOpts{ Enabled: rateLimiterEnabled, @@ -236,6 +238,7 @@ func NewCommand() *cobra.Command { command.Flags().StringVar(&codefreshUrl, "codefresh-url", env.StringFromEnv("CODEFRESH_URL", "https://g.codefresh.io"), "Codefresh API url") command.Flags().StringVar(&codefreshToken, "codefresh-token", env.StringFromEnv("CODEFRESH_TOKEN", ""), "Codefresh token") command.Flags().StringVar(&shardingAlgorithm, "sharding-method", env.StringFromEnv(common.EnvEventReporterShardingAlgorithm, common.DefaultEventReporterShardingAlgorithm), "Enables choice of sharding method. Supported sharding methods are : [legacy] ") + command.Flags().StringVar(&runtimeVersion, "codefresh-runtime-version", env.StringFromEnv("CODEFRESH_RUNTIME_VERSION", ""), "Codefresh runtime version to be reported with each event to platform") command.Flags().StringSliceVar(&applicationNamespaces, "application-namespaces", env.StringsFromEnv("ARGOCD_APPLICATION_NAMESPACES", []string{}, ","), "List of additional namespaces where application resources can be managed in") command.Flags().BoolVar(&useGrpc, "grpc", env.ParseBoolFromEnv("USE_GRPC", false), "Use grpc for interact with argocd server") command.Flags().BoolVar(&rateLimiterEnabled, "rate-limiter-enabled", env.ParseBoolFromEnv("RATE_LIMITER_ENABLED", false), "Use rate limiter for prevent queue to be overflowed") diff --git a/event_reporter/application/client.go b/event_reporter/application/client.go index 3c4fd356c092c..86b0b53cb952c 100644 --- a/event_reporter/application/client.go +++ b/event_reporter/application/client.go @@ -126,6 +126,16 @@ func (c *httpApplicationClient) GetManifests(ctx context.Context, in *appclient. if in.Revision != nil { params = fmt.Sprintf("%s&revision=%s", params, *in.Revision) } + if in.SourcePositions != nil && len(in.SourcePositions) > 0 { + for _, sourcePosition := range in.SourcePositions { + params = fmt.Sprintf("%s&sourcePositions=%d", params, sourcePosition) + } + } + if in.Revisions != nil && len(in.Revisions) > 0 { + for _, revision := range in.Revisions { + params = fmt.Sprintf("%s&revisions=%s", params, revision) + } + } url := fmt.Sprintf("%s/api/v1/applications/%s/manifests%s", c.baseUrl, *in.Name, params) manifest := &repoapiclient.ManifestResponse{} diff --git a/event_reporter/controller/controller.go b/event_reporter/controller/controller.go index 85aba07fb7b7f..262f55a7a7c34 100644 --- a/event_reporter/controller/controller.go +++ b/event_reporter/controller/controller.go @@ -6,6 +6,8 @@ import ( "strings" "time" + "github.com/argoproj/argo-cd/v2/util/db" + appclient "github.com/argoproj/argo-cd/v2/event_reporter/application" log "github.com/sirupsen/logrus" @@ -43,7 +45,7 @@ type eventReporterController struct { metricsServer *metrics.MetricsServer } -func NewEventReporterController(appInformer cache.SharedIndexInformer, cache *servercache.Cache, settingsMgr *settings.SettingsManager, applicationServiceClient appclient.ApplicationClient, appLister applisters.ApplicationLister, codefreshConfig *codefresh.CodefreshConfig, metricsServer *metrics.MetricsServer, featureManager *reporter.FeatureManager, rateLimiterOpts *reporter.RateLimiterOpts) EventReporterController { +func NewEventReporterController(appInformer cache.SharedIndexInformer, cache *servercache.Cache, settingsMgr *settings.SettingsManager, applicationServiceClient appclient.ApplicationClient, appLister applisters.ApplicationLister, codefreshConfig *codefresh.CodefreshConfig, metricsServer *metrics.MetricsServer, featureManager *reporter.FeatureManager, rateLimiterOpts *reporter.RateLimiterOpts, db db.ArgoDB) EventReporterController { appBroadcaster := reporter.NewBroadcaster(featureManager, metricsServer, rateLimiterOpts) _, err := appInformer.AddEventHandler(appBroadcaster) if err != nil { @@ -51,7 +53,7 @@ func NewEventReporterController(appInformer cache.SharedIndexInformer, cache *se } return &eventReporterController{ appBroadcaster: appBroadcaster, - applicationEventReporter: reporter.NewApplicationEventReporter(cache, applicationServiceClient, appLister, codefreshConfig, metricsServer), + applicationEventReporter: reporter.NewApplicationEventReporter(cache, applicationServiceClient, appLister, codefreshConfig, metricsServer, db), cache: cache, settingsMgr: settingsMgr, applicationServiceClient: applicationServiceClient, diff --git a/event_reporter/reporter/app_revision_test.go b/event_reporter/reporter/app_revision_test.go index 4b9611738432f..3dfc78127813b 100644 --- a/event_reporter/reporter/app_revision_test.go +++ b/event_reporter/reporter/app_revision_test.go @@ -54,6 +54,7 @@ func TestGetRevisionsDetails(t *testing.T) { newAppLister(), appServiceClient, &metrics.MetricsServer{}, + fakeArgoDb(), } result, _ := reporter.getRevisionsDetails(context.Background(), &app, []string{expectedRevision}) @@ -118,6 +119,7 @@ func TestGetRevisionsDetails(t *testing.T) { newAppLister(), appServiceClient, &metrics.MetricsServer{}, + fakeArgoDb(), } result, _ := reporter.getRevisionsDetails(context.Background(), &app, []string{expectedRevision1, expectedRevision2}) @@ -159,6 +161,7 @@ func TestGetRevisionsDetails(t *testing.T) { newAppLister(), appServiceClient, &metrics.MetricsServer{}, + fakeArgoDb(), } result, _ := reporter.getRevisionsDetails(context.Background(), &app, []string{expectedRevision}) diff --git a/event_reporter/reporter/application_event_reporter.go b/event_reporter/reporter/application_event_reporter.go index 242784a557111..359f694f7af5a 100644 --- a/event_reporter/reporter/application_event_reporter.go +++ b/event_reporter/reporter/application_event_reporter.go @@ -9,8 +9,12 @@ import ( "strings" "time" + "github.com/argoproj/argo-cd/v2/util/db" + "github.com/argoproj/argo-cd/v2/event_reporter/utils" + argoutils "github.com/argoproj/argo-cd/v2/util/argo" + "github.com/argoproj/argo-cd/v2/reposerver/apiclient" argocommon "github.com/argoproj/argo-cd/v2/common" @@ -40,6 +44,8 @@ type applicationEventReporter struct { appLister applisters.ApplicationLister applicationServiceClient appclient.ApplicationClient metricsServer *metrics.MetricsServer + db db.ArgoDB + runtimeVersion string } type ApplicationEventReporter interface { @@ -53,13 +59,15 @@ type ApplicationEventReporter interface { ShouldSendApplicationEvent(ae *appv1.ApplicationWatchEvent) (shouldSend bool, syncStatusChanged bool) } -func NewApplicationEventReporter(cache *servercache.Cache, applicationServiceClient appclient.ApplicationClient, appLister applisters.ApplicationLister, codefreshConfig *codefresh.CodefreshConfig, metricsServer *metrics.MetricsServer) ApplicationEventReporter { +func NewApplicationEventReporter(cache *servercache.Cache, applicationServiceClient appclient.ApplicationClient, appLister applisters.ApplicationLister, codefreshConfig *codefresh.CodefreshConfig, metricsServer *metrics.MetricsServer, db db.ArgoDB) ApplicationEventReporter { return &applicationEventReporter{ cache: cache, applicationServiceClient: applicationServiceClient, codefreshClient: codefresh.NewCodefreshClient(codefreshConfig), appLister: appLister, metricsServer: metricsServer, + db: db, + runtimeVersion: codefreshConfig.RuntimeVersion, } } @@ -87,15 +95,28 @@ func (s *applicationEventReporter) shouldSendResourceEvent(a *appv1.Application, return true } -func (r *applicationEventReporter) getDesiredManifests(ctx context.Context, a *appv1.Application, revision *string, logCtx *log.Entry) (*apiclient.ManifestResponse, bool) { +func (r *applicationEventReporter) getDesiredManifests( + ctx context.Context, + logCtx *log.Entry, + a *appv1.Application, + revision *string, + sourcePositions *[]int64, + revisions *[]string, +) (*apiclient.ManifestResponse, bool) { // get the desired state manifests of the application project := a.Spec.GetProject() - desiredManifests, err := r.applicationServiceClient.GetManifests(ctx, &application.ApplicationManifestQuery{ + query := application.ApplicationManifestQuery{ Name: &a.Name, AppNamespace: &a.Namespace, Revision: revision, Project: &project, - }) + } + if sourcePositions != nil && query.Revisions != nil { + query.SourcePositions = *sourcePositions + query.Revisions = *revisions + } + + desiredManifests, err := r.applicationServiceClient.GetManifests(ctx, &query) if err != nil { // if it's manifest generation error we need to still report the actual state // of the resources, but since we can't get the desired state, we will report @@ -137,7 +158,7 @@ func (s *applicationEventReporter) StreamApplicationEvents( logCtx.Info("getting desired manifests") - desiredManifests, manifestGenErr := s.getDesiredManifests(ctx, a, nil, logCtx) + desiredManifests, manifestGenErr := s.getDesiredManifests(ctx, logCtx, a, nil, nil, nil) applicationVersions := s.resolveApplicationVersions(ctx, a, logCtx) @@ -158,17 +179,21 @@ func (s *applicationEventReporter) StreamApplicationEvents( rs := utils.GetAppAsResource(a) utils.SetHealthStatusIfMissing(rs) - parentDesiredManifests, manifestGenErr := s.getDesiredManifests(ctx, parentApplicationEntity, nil, logCtx) + parentDesiredManifests, manifestGenErr := s.getDesiredManifests(ctx, logCtx, parentApplicationEntity, nil, nil, nil) parentAppSyncRevisionsMetadata, err := s.getApplicationRevisionsMetadata(ctx, logCtx, parentApplicationEntity) if err != nil { logCtx.WithError(err).Warn("failed to get parent application's revision metadata, resuming") } + validatedDestination := parentApplicationEntity.Spec.Destination.DeepCopy() + _ = argoutils.ValidateDestination(ctx, validatedDestination, s.db) // resolves server field if missing + err = s.processResource(ctx, *rs, logCtx, eventProcessingStartedAt, parentDesiredManifests, manifestGenErr, a, applicationVersions, &ReportedEntityParentApp{ - app: parentApplicationEntity, - appTree: appTree, - revisionsMetadata: parentAppSyncRevisionsMetadata, + app: parentApplicationEntity, + appTree: appTree, + revisionsMetadata: parentAppSyncRevisionsMetadata, + validatedDestination: validatedDestination, }, argoTrackingMetadata) if err != nil { s.metricsServer.IncErroredEventsCounter(metrics.MetricChildAppEventType, metrics.MetricEventUnknownErrorType, a.Name) @@ -178,7 +203,7 @@ func (s *applicationEventReporter) StreamApplicationEvents( } else { // will get here only for root applications (not managed as a resource by another application) logCtx.Info("processing as root application") - appEvent, err := s.getApplicationEventPayload(ctx, a, appTree, eventProcessingStartedAt, applicationVersions, argoTrackingMetadata) + appEvent, err := s.getApplicationEventPayload(ctx, a, appTree, eventProcessingStartedAt, applicationVersions, argoTrackingMetadata, s.runtimeVersion) if err != nil { s.metricsServer.IncErroredEventsCounter(metrics.MetricParentAppEventType, metrics.MetricEventGetPayloadErrorType, a.Name) return fmt.Errorf("failed to get application event: %w", err) @@ -197,6 +222,9 @@ func (s *applicationEventReporter) StreamApplicationEvents( s.metricsServer.ObserveEventProcessingDurationHistogramDuration(a.Name, metrics.MetricParentAppEventType, metricTimer.Duration()) } + validatedDestination := a.Spec.Destination.DeepCopy() + _ = argoutils.ValidateDestination(ctx, validatedDestination, s.db) // resolves server field if missing + revisionsMetadata, _ := s.getApplicationRevisionsMetadata(ctx, logCtx, a) // for each resource in the application get desired and actual state, // then stream the event @@ -210,9 +238,10 @@ func (s *applicationEventReporter) StreamApplicationEvents( continue } err := s.processResource(ctx, rs, logCtx, eventProcessingStartedAt, desiredManifests, manifestGenErr, nil, nil, &ReportedEntityParentApp{ - app: a, - appTree: appTree, - revisionsMetadata: revisionsMetadata, + app: a, + appTree: appTree, + revisionsMetadata: revisionsMetadata, + validatedDestination: validatedDestination, }, argoTrackingMetadata) if err != nil { s.metricsServer.IncErroredEventsCounter(metrics.MetricResourceEventType, metrics.MetricEventUnknownErrorType, a.Name) @@ -222,13 +251,30 @@ func (s *applicationEventReporter) StreamApplicationEvents( return nil } +// returns appVersion from first non-ref source for multisourced apps func (s *applicationEventReporter) resolveApplicationVersions(ctx context.Context, a *appv1.Application, logCtx *log.Entry) *apiclient.ApplicationVersions { - syncRevision := utils.GetOperationStateRevision(a) - if syncRevision == nil { + if a.Spec.HasMultipleSources() { + syncResultRevisions := utils.GetOperationSyncResultRevisions(a) + if syncResultRevisions == nil { + return nil + } + + var sourcePositions []int64 + for i := 0; i < len(*syncResultRevisions); i++ { + sourcePositions = append(sourcePositions, int64(i+1)) + } + + syncManifests, _ := s.getDesiredManifests(ctx, logCtx, a, nil, &sourcePositions, syncResultRevisions) + return syncManifests.GetApplicationVersions() + } + + syncResultRevision := utils.GetOperationSyncResultRevision(a) + + if syncResultRevision == nil { return nil } - syncManifests, _ := s.getDesiredManifests(ctx, a, syncRevision, logCtx) + syncManifests, _ := s.getDesiredManifests(ctx, logCtx, a, syncResultRevision, nil, nil) return syncManifests.GetApplicationVersions() } @@ -279,7 +325,7 @@ func (s *applicationEventReporter) processResource( }) // get resource desired state - desiredState := getResourceDesiredState(&rs, desiredManifests, logCtx) + desiredState, appSourceIdx := getResourceDesiredState(&rs, desiredManifests, logCtx) actualState, err := s.getResourceActualState(ctx, logCtx, metricsEventType, rs, reportedEntityParentApp.app, originalApplication) if err != nil { @@ -304,6 +350,7 @@ func (s *applicationEventReporter) processResource( actualState: actualState, desiredState: desiredState, manifestGenErr: manifestGenErr, + appSourceIdx: appSourceIdx, rsAsAppInfo: &ReportedResourceAsApp{ app: originalApplication, revisionsMetadata: originalAppRevisionMetadata, @@ -311,11 +358,14 @@ func (s *applicationEventReporter) processResource( }, }, &ReportedEntityParentApp{ - app: parentApplicationToReport, - appTree: reportedEntityParentApp.appTree, - revisionsMetadata: revisionMetadataToReport, + app: parentApplicationToReport, + appTree: reportedEntityParentApp.appTree, + revisionsMetadata: revisionMetadataToReport, + validatedDestination: reportedEntityParentApp.validatedDestination, + desiredManifests: reportedEntityParentApp.desiredManifests, }, argoTrackingMetadata, + s.runtimeVersion, ) if err != nil { s.metricsServer.IncErroredEventsCounter(metricsEventType, metrics.MetricEventGetPayloadErrorType, reportedEntityParentApp.app.Name) @@ -474,11 +524,11 @@ func applicationMetadataChanged(ae *appv1.ApplicationWatchEvent, cachedApp *appv return !reflect.DeepEqual(newEventAppMeta, cachedAppMeta) } -func getResourceDesiredState(rs *appv1.ResourceStatus, ds *apiclient.ManifestResponse, logger *log.Entry) *apiclient.Manifest { +func getResourceDesiredState(rs *appv1.ResourceStatus, ds *apiclient.ManifestResponse, logger *log.Entry) (manifest *apiclient.Manifest, sourceIdx int32) { if ds == nil { - return &apiclient.Manifest{} + return &apiclient.Manifest{}, 0 } - for _, m := range ds.Manifests { + for idx, m := range ds.Manifests { u, err := appv1.UnmarshalToUnstructured(m.CompiledManifest) if err != nil { logger.WithError(err).Warnf("failed to unmarshal compiled manifest") @@ -498,11 +548,27 @@ func getResourceDesiredState(rs *appv1.ResourceStatus, ds *apiclient.ManifestRes m.RawManifest = m.CompiledManifest } - return m + return m, getResourceSourceIdxFromManifestResponse(idx, ds) } } // no desired state for resource // it's probably deleted from git - return &apiclient.Manifest{} + return &apiclient.Manifest{}, 0 +} + +func getResourceSourceIdxFromManifestResponse(rsIdx int, ds *apiclient.ManifestResponse) int32 { + if ds.SourcesManifestsStartingIdx == nil { + return -1 + } + + sourceIdx := int32(-1) + + for currentSourceIdx, sourceStartingIdx := range ds.SourcesManifestsStartingIdx { + if int32(rsIdx) >= sourceStartingIdx { + sourceIdx = int32(currentSourceIdx) + } + } + + return sourceIdx } diff --git a/event_reporter/reporter/application_event_reporter_test.go b/event_reporter/reporter/application_event_reporter_test.go index 24f57525b9a5d..650b455094492 100644 --- a/event_reporter/reporter/application_event_reporter_test.go +++ b/event_reporter/reporter/application_event_reporter_test.go @@ -8,22 +8,28 @@ import ( "testing" "time" + "github.com/argoproj/argo-cd/v2/util/db" + "github.com/argoproj/argo-cd/v2/util/settings" + + "k8s.io/client-go/kubernetes/fake" + "github.com/aws/smithy-go/ptr" "github.com/sirupsen/logrus" "github.com/stretchr/testify/mock" "github.com/stretchr/testify/require" "k8s.io/apimachinery/pkg/watch" + "google.golang.org/grpc" + "k8s.io/apimachinery/pkg/runtime" + appclient "github.com/argoproj/argo-cd/v2/event_reporter/application" appMocks "github.com/argoproj/argo-cd/v2/event_reporter/application/mocks" "github.com/argoproj/argo-cd/v2/pkg/apiclient" apiclientapppkg "github.com/argoproj/argo-cd/v2/pkg/apiclient/application" appv1reg "github.com/argoproj/argo-cd/v2/pkg/apis/application" + repoapiclient "github.com/argoproj/argo-cd/v2/reposerver/apiclient" "github.com/argoproj/argo-cd/v2/util/io" - "google.golang.org/grpc" - "k8s.io/apimachinery/pkg/runtime" - "github.com/argoproj/argo-cd/v2/event_reporter/metrics" appsv1 "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1" @@ -93,6 +99,12 @@ func fakeAppServiceClient() apiclientapppkg.ApplicationServiceClient { return applicationServiceClient } +func fakeArgoDb() db.ArgoDB { + clientset := fake.NewSimpleClientset() + + return db.NewDB("", settings.NewSettingsManager(context.Background(), clientset, testNamespace), clientset) +} + func fakeReporter(customAppServiceClient appclient.ApplicationClient) *applicationEventReporter { guestbookApp := &appsv1.Application{ TypeMeta: metav1.TypeMeta{ @@ -159,6 +171,7 @@ func fakeReporter(customAppServiceClient appclient.ApplicationClient) *applicati appLister, customAppServiceClient, metricsServ, + fakeArgoDb(), } } @@ -459,3 +472,20 @@ func TestGetResourceActualState(t *testing.T) { assert.Equal(t, "", ptr.ToString(res.Manifest)) }) } + +func TestGetResourceSourceIdxFromManifestResponse(t *testing.T) { + t.Run("should return correct sourceIdx", func(t *testing.T) { + sourcesManifestsStartingIdx := []int32{0, 5, 15} + desiredManifests := &repoapiclient.ManifestResponse{ + SourcesManifestsStartingIdx: sourcesManifestsStartingIdx, + } + + assert.Equal(t, int32(0), getResourceSourceIdxFromManifestResponse(0, desiredManifests)) + assert.Equal(t, int32(0), getResourceSourceIdxFromManifestResponse(1, desiredManifests)) + assert.Equal(t, int32(1), getResourceSourceIdxFromManifestResponse(5, desiredManifests)) + assert.Equal(t, int32(1), getResourceSourceIdxFromManifestResponse(6, desiredManifests)) + assert.Equal(t, int32(2), getResourceSourceIdxFromManifestResponse(15, desiredManifests)) + assert.Equal(t, int32(2), getResourceSourceIdxFromManifestResponse(16, desiredManifests)) + assert.Equal(t, int32(-1), getResourceSourceIdxFromManifestResponse(2, &repoapiclient.ManifestResponse{})) + }) +} diff --git a/event_reporter/reporter/event_payload.go b/event_reporter/reporter/event_payload.go index e5963e2496fd4..24d7cbd465011 100644 --- a/event_reporter/reporter/event_payload.go +++ b/event_reporter/reporter/event_payload.go @@ -24,6 +24,7 @@ func getResourceEventPayload( rr *ReportedResource, reportedEntityParentApp *ReportedEntityParentApp, argoTrackingMetadata *ArgoTrackingMetadata, + runtimeVersion string, ) (*events.Event, error) { var ( err error @@ -100,33 +101,34 @@ func getResourceEventPayload( } source := events.ObjectSource{ - DesiredManifest: rr.desiredState.CompiledManifest, - ActualManifest: *rr.actualState.Manifest, - GitManifest: rr.desiredState.RawManifest, - RepoURL: reportedEntityParentApp.app.Status.Sync.ComparedTo.Source.RepoURL, - Path: rr.desiredState.Path, - Revision: utils.GetApplicationLatestRevision(reportedEntityParentApp.app), - OperationSyncRevision: utils.GetOperationRevision(reportedEntityParentApp.app), - HistoryId: utils.GetLatestAppHistoryId(reportedEntityParentApp.app), - AppName: reportedEntityParentApp.app.Name, - AppNamespace: reportedEntityParentApp.app.Namespace, - AppUID: string(reportedEntityParentApp.app.ObjectMeta.UID), - AppLabels: reportedEntityParentApp.app.Labels, - SyncStatus: string(rr.rs.Status), - SyncStartedAt: syncStarted, - SyncFinishedAt: syncFinished, - Cluster: reportedEntityParentApp.app.Spec.Destination.Server, - AppInstanceLabelKey: *argoTrackingMetadata.AppInstanceLabelKey, - TrackingMethod: string(*argoTrackingMetadata.TrackingMethod), + DesiredManifest: rr.desiredState.CompiledManifest, + ActualManifest: *rr.actualState.Manifest, + GitManifest: rr.desiredState.RawManifest, + Path: rr.desiredState.Path, + Revision: utils.GetApplicationLatestRevision(reportedEntityParentApp.app), + Revisions: utils.GetApplicationLatestRevisions(reportedEntityParentApp.app), + OperationSyncRevision: utils.GetOperationRevision(reportedEntityParentApp.app), + OperationSyncRevisions: utils.GetOperationRevisions(reportedEntityParentApp.app), + HistoryId: utils.GetLatestAppHistoryId(reportedEntityParentApp.app), + AppName: reportedEntityParentApp.app.Name, + AppNamespace: reportedEntityParentApp.app.Namespace, + AppUID: string(reportedEntityParentApp.app.ObjectMeta.UID), + AppLabels: reportedEntityParentApp.app.Labels, + SyncStatus: string(rr.rs.Status), + SyncStartedAt: syncStarted, + SyncFinishedAt: syncFinished, + Cluster: reportedEntityParentApp.app.Spec.Destination.Server, + AppInstanceLabelKey: *argoTrackingMetadata.AppInstanceLabelKey, + TrackingMethod: string(*argoTrackingMetadata.TrackingMethod), + AppMultiSourced: reportedEntityParentApp.app.Spec.HasMultipleSources(), + AppSourceIdx: rr.appSourceIdx, } - if reportedEntityParentApp.revisionsMetadata != nil && reportedEntityParentApp.revisionsMetadata.SyncRevisions != nil { - revisionMetadata := getApplicationLegacyRevisionDetails(reportedEntityParentApp.app, reportedEntityParentApp.revisionsMetadata) - if revisionMetadata != nil { - source.CommitMessage = revisionMetadata.Message - source.CommitAuthor = revisionMetadata.Author - source.CommitDate = &revisionMetadata.Date - } + source.RepoURL = getResourceSourceRepoUrl(rr, reportedEntityParentApp) + addResourceEventPayloadGitCommitDetails(&source, rr, reportedEntityParentApp) + + if reportedEntityParentApp.validatedDestination != nil { + source.ClusterName = &reportedEntityParentApp.validatedDestination.Name } if rr.rs.Health != nil { @@ -135,11 +137,12 @@ func getResourceEventPayload( } payload := events.EventPayload{ - Timestamp: appEventProcessingStartedAt, - Object: object, - Source: &source, - Errors: getResourceEventPayloadErrors(rr, reportedEntityParentApp), - AppVersions: applicationVersionsEvents, + Timestamp: appEventProcessingStartedAt, + Object: object, + Source: &source, + Errors: getResourceEventPayloadErrors(rr, reportedEntityParentApp), + AppVersions: applicationVersionsEvents, + RuntimeVersion: runtimeVersion, } if payload.AppVersions != nil { @@ -154,6 +157,47 @@ func getResourceEventPayload( return &events.Event{Payload: payloadBytes}, nil } +func getResourceSourceRepoUrl( + rr *ReportedResource, + reportedEntityParentApp *ReportedEntityParentApp, +) string { + specCopy := reportedEntityParentApp.app.Spec.DeepCopy() + + specCopy.Sources = reportedEntityParentApp.app.Status.Sync.ComparedTo.Sources + specCopy.Source = reportedEntityParentApp.app.Status.Sync.ComparedTo.Source.DeepCopy() + + if specCopy.HasMultipleSources() { + if !rr.appSourceIdxDetected() { + return "" + } + source := specCopy.GetSourcePtrByIndex(int(rr.appSourceIdx)) + if source == nil { + return "" + } + return source.RepoURL + } + + return specCopy.Source.RepoURL +} + +func addResourceEventPayloadGitCommitDetails( + source *events.ObjectSource, + rr *ReportedResource, + reportedEntityParentApp *ReportedEntityParentApp, +) { + if reportedEntityParentApp.revisionsMetadata == nil || reportedEntityParentApp.revisionsMetadata.SyncRevisions == nil || rr.appSourceIdx == -1 { + return + } + + syncRevisionWithMetadata := reportedEntityParentApp.revisionsMetadata.GetSyncRevisionAt(int(rr.appSourceIdx)) + + if syncRevisionWithMetadata != nil && syncRevisionWithMetadata.Metadata != nil { + source.CommitMessage = syncRevisionWithMetadata.Metadata.Message + source.CommitAuthor = syncRevisionWithMetadata.Metadata.Author + source.CommitDate = &syncRevisionWithMetadata.Metadata.Date + } +} + func getResourceEventPayloadErrors( rr *ReportedResource, reportedEntityParentApp *ReportedEntityParentApp, @@ -247,6 +291,7 @@ func (s *applicationEventReporter) getApplicationEventPayload( eventProcessingStartedAt string, applicationVersions *apiclient.ApplicationVersions, argoTrackingMetadata *ArgoTrackingMetadata, + runtimeVersion string, ) (*events.Event, error) { var ( syncStarted = metav1.Now() @@ -323,11 +368,12 @@ func (s *applicationEventReporter) getApplicationEventPayload( errors = append(errors, parseAggregativeHealthErrorsOfApplication(a, appTree)...) payload := events.EventPayload{ - Timestamp: eventProcessingStartedAt, - Object: object, - Source: source, - Errors: errors, - AppVersions: applicationVersionsEvents, + Timestamp: eventProcessingStartedAt, + Object: object, + Source: source, + Errors: errors, + AppVersions: applicationVersionsEvents, + RuntimeVersion: runtimeVersion, } logCtx.Infof("AppVersion before encoding: %v", utils.SafeString(payload.AppVersions.AppVersion)) diff --git a/event_reporter/reporter/types.go b/event_reporter/reporter/types.go index 910104394f0bc..810f26253ec1a 100644 --- a/event_reporter/reporter/types.go +++ b/event_reporter/reporter/types.go @@ -10,6 +10,7 @@ import ( type ReportedResource struct { rs *appv1.ResourceStatus rsAsAppInfo *ReportedResourceAsApp // passed if resource is application + appSourceIdx int32 actualState *application.ApplicationResourceResponse desiredState *apiclient.Manifest manifestGenErr bool @@ -22,9 +23,11 @@ type ReportedResourceAsApp struct { } type ReportedEntityParentApp struct { - app *appv1.Application - appTree *appv1.ApplicationTree - revisionsMetadata *utils.AppSyncRevisionsMetadata + app *appv1.Application + appTree *appv1.ApplicationTree + revisionsMetadata *utils.AppSyncRevisionsMetadata + validatedDestination *appv1.ApplicationDestination // with resolved Server url field if server Name used + desiredManifests *apiclient.ManifestResponse } type ArgoTrackingMetadata struct { @@ -40,3 +43,7 @@ func (rr *ReportedResource) GetApiVersion() string { return apiVersion } + +func (rr *ReportedResource) appSourceIdxDetected() bool { + return rr.appSourceIdx >= 0 +} diff --git a/event_reporter/server.go b/event_reporter/server.go index aaad53fde3ddf..6c23dcf099d44 100644 --- a/event_reporter/server.go +++ b/event_reporter/server.go @@ -153,7 +153,7 @@ func (a *EventReporterServer) Init(ctx context.Context) { } func (a *EventReporterServer) RunController(ctx context.Context) { - controller := event_reporter.NewEventReporterController(a.appInformer, a.Cache, a.settingsMgr, a.ApplicationServiceClient, a.appLister, a.CodefreshConfig, a.serviceSet.MetricsServer, a.featureManager, a.RateLimiterOpts) + controller := event_reporter.NewEventReporterController(a.appInformer, a.Cache, a.settingsMgr, a.ApplicationServiceClient, a.appLister, a.CodefreshConfig, a.serviceSet.MetricsServer, a.featureManager, a.RateLimiterOpts, a.db) go controller.Run(ctx) } diff --git a/event_reporter/utils/app.go b/event_reporter/utils/app.go new file mode 100644 index 0000000000000..cbb1756b20770 --- /dev/null +++ b/event_reporter/utils/app.go @@ -0,0 +1,65 @@ +package utils + +import appv1 "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1" + +type AppRevisionsFieldNames string + +var ( + AppRevisionFieldName AppRevisionsFieldNames = "Revision" + AppRevisionsFieldName AppRevisionsFieldNames = "Revisions" +) + +type AppUtils struct { + App *appv1.Application +} + +func (au *AppUtils) operationStateSyncExists(fieldToCheck *AppRevisionsFieldNames) bool { + result := au.App != nil && au.App.Status.OperationState != nil && au.App.Status.OperationState.Operation.Sync != nil + if !result { + return false + } + + return revisionsToCheck(RevisionsData{ + Revision: au.App.Status.OperationState.Operation.Sync.Revision, + Revisions: au.App.Status.OperationState.Operation.Sync.Revisions, + }, fieldToCheck) +} + +func (au *AppUtils) operationSyncExists(fieldToCheck *AppRevisionsFieldNames) bool { + result := au.App != nil && au.App.Operation != nil && au.App.Operation.Sync != nil + if !result { + return false + } + + return revisionsToCheck(RevisionsData{ + Revision: au.App.Operation.Sync.Revision, + Revisions: au.App.Operation.Sync.Revisions, + }, fieldToCheck) +} + +func (au *AppUtils) operationSyncResultExists(fieldToCheck *AppRevisionsFieldNames) bool { + result := au.App != nil && au.App.Status.OperationState != nil && au.App.Status.OperationState.SyncResult != nil + if !result { + return false + } + + return revisionsToCheck(RevisionsData{ + Revision: au.App.Status.OperationState.SyncResult.Revision, + Revisions: au.App.Status.OperationState.SyncResult.Revisions, + }, fieldToCheck) +} + +// expected to return true if fieldToCheck == nil +func revisionsToCheck(obj RevisionsData, fieldToCheck *AppRevisionsFieldNames) bool { + if fieldToCheck == nil { + return true + } + if *fieldToCheck == AppRevisionFieldName { + return obj.Revision != "" + } + + if *fieldToCheck == AppRevisionsFieldName { + return obj.Revisions != nil && len(obj.Revisions) > 0 + } + return true +} diff --git a/event_reporter/utils/app_revision.go b/event_reporter/utils/app_revision.go index f4bb1bcb232ae..2ed0840bde153 100644 --- a/event_reporter/utils/app_revision.go +++ b/event_reporter/utils/app_revision.go @@ -25,6 +25,13 @@ type RevisionsData struct { const annotationRevisionKey = "app.meta.revisions-metadata" +func (asrm *AppSyncRevisionsMetadata) GetSyncRevisionAt(idx int) *RevisionWithMetadata { + if asrm == nil || asrm.SyncRevisions == nil || idx < 0 || idx >= len(asrm.SyncRevisions) { + return nil + } + return asrm.SyncRevisions[idx] +} + func GetLatestAppHistoryId(a *appv1.Application) int64 { if lastHistory := getLatestAppHistoryItem(a); lastHistory != nil { return lastHistory.ID @@ -49,34 +56,70 @@ func GetApplicationLatestRevision(a *appv1.Application) string { return a.Status.Sync.Revision } +func GetApplicationLatestRevisions(a *appv1.Application) []string { + if lastHistory := getLatestAppHistoryItem(a); lastHistory != nil { + return lastHistory.Revisions + } + + return a.Status.Sync.Revisions +} + func GetOperationRevision(a *appv1.Application) string { if a == nil { return "" } - + au := &AppUtils{App: a} // this value will be used in case if application hasn't resources , like gitsource revision := a.Status.Sync.Revision - if a.Status.OperationState != nil && a.Status.OperationState.Operation.Sync != nil && a.Status.OperationState.Operation.Sync.Revision != "" { + if au.operationStateSyncExists(&AppRevisionFieldName) { revision = a.Status.OperationState.Operation.Sync.Revision - } else if a.Operation != nil && a.Operation.Sync != nil && a.Operation.Sync.Revision != "" { + } else if au.operationSyncExists(&AppRevisionFieldName) { revision = a.Operation.Sync.Revision } return revision } -func GetOperationStateRevision(a *appv1.Application) *string { - if a == nil || a.Status.OperationState == nil || a.Status.OperationState.SyncResult == nil { +func GetOperationRevisions(a *appv1.Application) []string { + if a == nil { return nil } + au := &AppUtils{App: a} - return &a.Status.OperationState.SyncResult.Revision + // this value will be used in case if application hasn't resources , like gitsource + revisions := a.Status.Sync.Revisions + if au.operationStateSyncExists(&AppRevisionsFieldName) { + revisions = a.Status.OperationState.Operation.Sync.Revisions + } else if au.operationSyncExists(&AppRevisionsFieldName) { + revisions = a.Operation.Sync.Revisions + } + + return revisions +} + +func GetOperationSyncResultRevision(a *appv1.Application) *string { + au := &AppUtils{App: a} + if au.operationSyncResultExists(nil) { + return &a.Status.OperationState.SyncResult.Revision + } + + return nil +} + +func GetOperationSyncResultRevisions(a *appv1.Application) *[]string { + au := &AppUtils{App: a} + if au.operationSyncResultExists(nil) { + return &a.Status.OperationState.SyncResult.Revisions + } + + return nil } func GetOperationSyncRevisions(a *appv1.Application) []string { if a == nil { return []string{} } + au := &AppUtils{App: a} // this value will be used in case if application hasn't resources, like empty gitsource revisions := getRevisions(RevisionsData{ @@ -84,12 +127,12 @@ func GetOperationSyncRevisions(a *appv1.Application) []string { Revisions: a.Status.Sync.Revisions, }) - if a.Status.OperationState != nil && a.Status.OperationState.Operation.Sync != nil { + if au.operationStateSyncExists(nil) { revisions = getRevisions(RevisionsData{ Revision: a.Status.OperationState.Operation.Sync.Revision, Revisions: a.Status.OperationState.Operation.Sync.Revisions, }) - } else if a.Operation != nil && a.Operation.Sync != nil { + } else if au.operationSyncExists(nil) { revisions = getRevisions(RevisionsData{ Revision: a.Operation.Sync.Revision, Revisions: a.Operation.Sync.Revisions, @@ -106,16 +149,17 @@ func GetOperationChangeRevisions(a *appv1.Application) []string { if a == nil { return revisions } + au := &AppUtils{App: a} // this value will be used in case if application hasn't resources, like empty gitsource - if a.Status.OperationState != nil && a.Status.OperationState.Operation.Sync != nil { + if au.operationStateSyncExists(nil) { if a.Status.OperationState.Operation.Sync.ChangeRevision != "" || a.Status.OperationState.Operation.Sync.ChangeRevisions != nil { revisions = getRevisions(RevisionsData{ Revision: a.Status.OperationState.Operation.Sync.ChangeRevision, Revisions: a.Status.OperationState.Operation.Sync.ChangeRevisions, }) } - } else if a.Operation != nil && a.Operation.Sync != nil { + } else if au.operationSyncExists(nil) { if a.Operation.Sync.ChangeRevision != "" || a.Operation.Sync.ChangeRevisions != nil { revisions = getRevisions(RevisionsData{ Revision: a.Operation.Sync.ChangeRevision, diff --git a/event_reporter/utils/app_revision_test.go b/event_reporter/utils/app_revision_test.go index 370edecdb2d5a..88cb9bccd8c82 100644 --- a/event_reporter/utils/app_revision_test.go +++ b/event_reporter/utils/app_revision_test.go @@ -441,3 +441,224 @@ func TestAddCommitDetailsToLabels(t *testing.T) { assert.Equal(t, "http://my-grafana.com/pre-generated-link", result.GetLabels()["link"]) }) } + +func TestGetSyncRevisionAt(t *testing.T) { + t.Run("should return nil once idx out of range", func(t *testing.T) { + revisionMetadata := AppSyncRevisionsMetadata{ + SyncRevisions: []*RevisionWithMetadata{{ + Metadata: &v1alpha1.RevisionMetadata{ + Author: "demo usert", + Date: metav1.Time{}, + Message: "some message", + }, + }}, + } + + assert.Nil(t, revisionMetadata.GetSyncRevisionAt(-1)) + assert.Nil(t, revisionMetadata.GetSyncRevisionAt(1)) + }) + t.Run("should return nil if data missing", func(t *testing.T) { + revisionMetadata := AppSyncRevisionsMetadata{} + + assert.Nil(t, revisionMetadata.GetSyncRevisionAt(1)) + }) + t.Run("should return correct idx", func(t *testing.T) { + revisionMetadata := AppSyncRevisionsMetadata{ + SyncRevisions: []*RevisionWithMetadata{ + { + Metadata: &v1alpha1.RevisionMetadata{ + Author: "demo usert", + Date: metav1.Time{}, + Message: "some message", + }, + }, + { + Metadata: &v1alpha1.RevisionMetadata{ + Author: "demo user2", + Date: metav1.Time{}, + Message: "some message 2", + }, + }, + }, + } + + syncRev := revisionMetadata.GetSyncRevisionAt(1) + assert.NotNil(t, syncRev) + assert.Equal(t, "demo user2", syncRev.Metadata.Author) + assert.Equal(t, "some message 2", syncRev.Metadata.Message) + }) +} + +func TestGetOperationRevision(t *testing.T) { + t.Run("should return empty strint once app in nil", func(t *testing.T) { + assert.Equal(t, "", GetOperationRevision(nil)) + }) + t.Run("should return Status.Sync.Revision as fallback", func(t *testing.T) { + assert.Equal(t, "Status.Sync.Revision", GetOperationRevision(&v1alpha1.Application{ + Status: v1alpha1.ApplicationStatus{ + Sync: v1alpha1.SyncStatus{ + Revision: "Status.Sync.Revision", + }, + }, + })) + }) + t.Run("should return Status.OperationState.Operation.Sync.Revision", func(t *testing.T) { + assert.Equal(t, "Status.OperationState.Operation.Sync.Revision", GetOperationRevision(&v1alpha1.Application{ + Status: v1alpha1.ApplicationStatus{ + Sync: v1alpha1.SyncStatus{ + Revision: "Status.Sync.Revision", + }, + OperationState: &v1alpha1.OperationState{ + Operation: v1alpha1.Operation{ + Sync: &v1alpha1.SyncOperation{ + Revision: "Status.OperationState.Operation.Sync.Revision", + }, + }, + }, + }, + Operation: &v1alpha1.Operation{ + Sync: &v1alpha1.SyncOperation{ + Revision: "Operation.Sync.Revision", + }, + }, + })) + }) + t.Run("should return Status-Sync-Revision", func(t *testing.T) { + assert.Equal(t, "Operation.Sync.Revision", GetOperationRevision(&v1alpha1.Application{ + Status: v1alpha1.ApplicationStatus{ + Sync: v1alpha1.SyncStatus{ + Revision: "Status-Sync-Revision", + }, + }, + Operation: &v1alpha1.Operation{ + Sync: &v1alpha1.SyncOperation{ + Revision: "Operation.Sync.Revision", + }, + }, + })) + }) +} + +func TestGetOperationRevisions(t *testing.T) { + t.Run("should return empty strint once app in nil", func(t *testing.T) { + assert.Nil(t, GetOperationRevisions(nil)) + }) + t.Run("should return Status.Sync.Revisions as fallback", func(t *testing.T) { + res := GetOperationRevisions(&v1alpha1.Application{ + Status: v1alpha1.ApplicationStatus{ + Sync: v1alpha1.SyncStatus{ + Revision: "Status.Sync.Revision", + Revisions: []string{"Status.Sync.Revisions"}, + }, + }, + }) + assert.Len(t, res, 1) + assert.Equal(t, "Status.Sync.Revisions", res[0]) + }) + t.Run("should return Status.OperationState.Operation.Sync.Revisions", func(t *testing.T) { + res := GetOperationRevisions(&v1alpha1.Application{ + Status: v1alpha1.ApplicationStatus{ + Sync: v1alpha1.SyncStatus{ + Revision: "Status.Sync.Revision", + Revisions: []string{"Status.Sync.Revisions"}, + }, + OperationState: &v1alpha1.OperationState{ + Operation: v1alpha1.Operation{ + Sync: &v1alpha1.SyncOperation{ + Revision: "Status.OperationState.Operation.Sync.Revision", + Revisions: []string{"Status.OperationState.Operation.Sync.Revisions"}, + }, + }, + }, + }, + Operation: &v1alpha1.Operation{ + Sync: &v1alpha1.SyncOperation{ + Revision: "Operation.Sync.Revision", + Revisions: []string{"Operation.Sync.Revisions"}, + }, + }, + }) + assert.Len(t, res, 1) + assert.Equal(t, "Status.OperationState.Operation.Sync.Revisions", res[0]) + }) + t.Run("should return Status-Sync-Revisions", func(t *testing.T) { + res := GetOperationRevisions(&v1alpha1.Application{ + Status: v1alpha1.ApplicationStatus{ + Sync: v1alpha1.SyncStatus{ + Revision: "Status-Sync-Revision", + }, + }, + Operation: &v1alpha1.Operation{ + Sync: &v1alpha1.SyncOperation{ + Revision: "Operation.Sync.Revision", + Revisions: []string{"Operation.Sync.Revisions"}, + }, + }, + }) + assert.Len(t, res, 1) + assert.Equal(t, "Operation.Sync.Revisions", res[0]) + }) +} + +func TestGetOperationSyncResultRevision(t *testing.T) { + t.Run("should return nil", func(t *testing.T) { + assert.Nil(t, GetOperationSyncResultRevision(nil)) + assert.Nil(t, GetOperationSyncResultRevision(&v1alpha1.Application{ + Status: v1alpha1.ApplicationStatus{ + OperationState: &v1alpha1.OperationState{ + Operation: v1alpha1.Operation{ + Sync: &v1alpha1.SyncOperation{ + Revision: "Status.OperationState.Operation.Sync.Revision", + Revisions: []string{"Status.OperationState.Operation.Sync.Revisions"}, + }, + }, + }, + }, + })) + }) + t.Run("should return revision", func(t *testing.T) { + res := GetOperationSyncResultRevision(&v1alpha1.Application{ + Status: v1alpha1.ApplicationStatus{ + OperationState: &v1alpha1.OperationState{ + SyncResult: &v1alpha1.SyncOperationResult{ + Revision: "Status.OperationState.SyncResult.Revision", + Revisions: []string{"Status.OperationState.SyncResult.Revisions"}, + }, + }, + }, + }) + assert.Equal(t, "Status.OperationState.SyncResult.Revision", *res) + }) +} + +func TestGetOperationSyncResultRevisions(t *testing.T) { + t.Run("should return nil", func(t *testing.T) { + assert.Nil(t, GetOperationSyncResultRevisions(nil)) + assert.Nil(t, GetOperationSyncResultRevisions(&v1alpha1.Application{ + Status: v1alpha1.ApplicationStatus{ + OperationState: &v1alpha1.OperationState{ + Operation: v1alpha1.Operation{ + Sync: &v1alpha1.SyncOperation{ + Revision: "Status.OperationState.Operation.Sync.Revision", + Revisions: []string{"Status.OperationState.Operation.Sync.Revisions"}, + }, + }, + }, + }, + })) + }) + t.Run("should return revisions", func(t *testing.T) { + res := GetOperationSyncResultRevisions(&v1alpha1.Application{ + Status: v1alpha1.ApplicationStatus{ + OperationState: &v1alpha1.OperationState{ + SyncResult: &v1alpha1.SyncOperationResult{ + Revision: "Status.OperationState.SyncResult.Revision", + Revisions: []string{"Status.OperationState.SyncResult.Revisions"}, + }, + }, + }, + }) + assert.NotNil(t, res) + assert.Len(t, *res, 1) + }) +} diff --git a/pkg/apiclient/events/events.pb.go b/pkg/apiclient/events/events.pb.go index d484348341781..9abdc40a779b8 100644 --- a/pkg/apiclient/events/events.pb.go +++ b/pkg/apiclient/events/events.pb.go @@ -161,10 +161,12 @@ type EventPayload struct { // The errors of this object Errors []*ObjectError `protobuf:"bytes,4,rep,name=errors" json:"errors,omitempty"` // A version of the application and its dependencies - AppVersions *ApplicationVersions `protobuf:"bytes,5,opt,name=appVersions" json:"appVersions,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + AppVersions *ApplicationVersions `protobuf:"bytes,5,opt,name=appVersions" json:"appVersions,omitempty"` + // A version of codefresh runtime + RuntimeVersion string `protobuf:"bytes,6,req,name=runtimeVersion" json:"runtimeVersion"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *EventPayload) Reset() { *m = EventPayload{} } @@ -235,35 +237,47 @@ func (m *EventPayload) GetAppVersions() *ApplicationVersions { return nil } +func (m *EventPayload) GetRuntimeVersion() string { + if m != nil { + return m.RuntimeVersion + } + return "" +} + // * // Holds information about the object source type ObjectSource struct { - DesiredManifest string `protobuf:"bytes,1,opt,name=desiredManifest" json:"desiredManifest"` - ActualManifest string `protobuf:"bytes,2,opt,name=actualManifest" json:"actualManifest"` - GitManifest string `protobuf:"bytes,3,opt,name=gitManifest" json:"gitManifest"` - RepoURL string `protobuf:"bytes,4,opt,name=repoURL" json:"repoURL"` - Path string `protobuf:"bytes,5,opt,name=path" json:"path"` - Revision string `protobuf:"bytes,6,opt,name=revision" json:"revision"` - CommitMessage string `protobuf:"bytes,7,opt,name=commitMessage" json:"commitMessage"` - CommitAuthor string `protobuf:"bytes,8,opt,name=commitAuthor" json:"commitAuthor"` - CommitDate *v1.Time `protobuf:"bytes,9,opt,name=commitDate" json:"commitDate,omitempty"` - AppName string `protobuf:"bytes,10,opt,name=appName" json:"appName"` - AppLabels map[string]string `protobuf:"bytes,11,rep,name=appLabels" json:"appLabels" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` - SyncStatus string `protobuf:"bytes,12,opt,name=syncStatus" json:"syncStatus"` - SyncStartedAt v1.Time `protobuf:"bytes,13,opt,name=syncStartedAt" json:"syncStartedAt"` - SyncFinishedAt *v1.Time `protobuf:"bytes,14,opt,name=syncFinishedAt" json:"syncFinishedAt,omitempty"` - HealthStatus *string `protobuf:"bytes,15,opt,name=healthStatus" json:"healthStatus,omitempty"` - HealthMessage *string `protobuf:"bytes,16,opt,name=healthMessage" json:"healthMessage,omitempty"` - Cluster string `protobuf:"bytes,17,opt,name=cluster" json:"cluster"` - HistoryId int64 `protobuf:"varint,18,opt,name=historyId" json:"historyId"` - OperationSyncRevision string `protobuf:"bytes,19,opt,name=operationSyncRevision" json:"operationSyncRevision"` - AppUID string `protobuf:"bytes,20,opt,name=appUID" json:"appUID"` - AppNamespace string `protobuf:"bytes,21,opt,name=appNamespace" json:"appNamespace"` - AppInstanceLabelKey string `protobuf:"bytes,22,opt,name=appInstanceLabelKey" json:"appInstanceLabelKey"` - TrackingMethod string `protobuf:"bytes,23,opt,name=trackingMethod" json:"trackingMethod"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + DesiredManifest string `protobuf:"bytes,1,opt,name=desiredManifest" json:"desiredManifest"` + ActualManifest string `protobuf:"bytes,2,opt,name=actualManifest" json:"actualManifest"` + GitManifest string `protobuf:"bytes,3,opt,name=gitManifest" json:"gitManifest"` + RepoURL string `protobuf:"bytes,4,opt,name=repoURL" json:"repoURL"` + Path string `protobuf:"bytes,5,opt,name=path" json:"path"` + Revision string `protobuf:"bytes,6,opt,name=revision" json:"revision"` + CommitMessage string `protobuf:"bytes,7,opt,name=commitMessage" json:"commitMessage"` + CommitAuthor string `protobuf:"bytes,8,opt,name=commitAuthor" json:"commitAuthor"` + CommitDate *v1.Time `protobuf:"bytes,9,opt,name=commitDate" json:"commitDate,omitempty"` + AppName string `protobuf:"bytes,10,opt,name=appName" json:"appName"` + AppLabels map[string]string `protobuf:"bytes,11,rep,name=appLabels" json:"appLabels" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + SyncStatus string `protobuf:"bytes,12,opt,name=syncStatus" json:"syncStatus"` + SyncStartedAt v1.Time `protobuf:"bytes,13,opt,name=syncStartedAt" json:"syncStartedAt"` + SyncFinishedAt *v1.Time `protobuf:"bytes,14,opt,name=syncFinishedAt" json:"syncFinishedAt,omitempty"` + HealthStatus *string `protobuf:"bytes,15,opt,name=healthStatus" json:"healthStatus,omitempty"` + HealthMessage *string `protobuf:"bytes,16,opt,name=healthMessage" json:"healthMessage,omitempty"` + Cluster string `protobuf:"bytes,17,opt,name=cluster" json:"cluster"` + HistoryId int64 `protobuf:"varint,18,opt,name=historyId" json:"historyId"` + OperationSyncRevision string `protobuf:"bytes,19,opt,name=operationSyncRevision" json:"operationSyncRevision"` + AppUID string `protobuf:"bytes,20,opt,name=appUID" json:"appUID"` + AppNamespace string `protobuf:"bytes,21,opt,name=appNamespace" json:"appNamespace"` + AppInstanceLabelKey string `protobuf:"bytes,22,opt,name=appInstanceLabelKey" json:"appInstanceLabelKey"` + TrackingMethod string `protobuf:"bytes,23,opt,name=trackingMethod" json:"trackingMethod"` + Revisions []string `protobuf:"bytes,24,rep,name=revisions" json:"revisions,omitempty"` + OperationSyncRevisions []string `protobuf:"bytes,25,rep,name=operationSyncRevisions" json:"operationSyncRevisions,omitempty"` + ClusterName *string `protobuf:"bytes,26,opt,name=clusterName" json:"clusterName,omitempty"` + AppMultiSourced bool `protobuf:"varint,27,req,name=appMultiSourced" json:"appMultiSourced"` + AppSourceIdx int32 `protobuf:"varint,28,req,name=appSourceIdx" json:"appSourceIdx"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *ObjectSource) Reset() { *m = ObjectSource{} } @@ -460,6 +474,41 @@ func (m *ObjectSource) GetTrackingMethod() string { return "" } +func (m *ObjectSource) GetRevisions() []string { + if m != nil { + return m.Revisions + } + return nil +} + +func (m *ObjectSource) GetOperationSyncRevisions() []string { + if m != nil { + return m.OperationSyncRevisions + } + return nil +} + +func (m *ObjectSource) GetClusterName() string { + if m != nil && m.ClusterName != nil { + return *m.ClusterName + } + return "" +} + +func (m *ObjectSource) GetAppMultiSourced() bool { + if m != nil { + return m.AppMultiSourced + } + return false +} + +func (m *ObjectSource) GetAppSourceIdx() int32 { + if m != nil { + return m.AppSourceIdx + } + return 0 +} + // * // Holds error information; present only when error sent with application but not resource itself type ObjectError struct { @@ -760,72 +809,78 @@ func init() { func init() { proto.RegisterFile("server/application/events.proto", fileDescriptor_3ad9267ec62b112f) } var fileDescriptor_3ad9267ec62b112f = []byte{ - // 1038 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x56, 0xcd, 0x6e, 0x1b, 0x37, - 0x10, 0xee, 0xca, 0xb2, 0x1d, 0x8d, 0x64, 0x27, 0xa5, 0xed, 0x94, 0x30, 0x5c, 0x47, 0x10, 0x8c, - 0x42, 0x08, 0x92, 0x15, 0xec, 0xfe, 0x20, 0x09, 0x8a, 0x02, 0x0e, 0xec, 0xb6, 0x6e, 0xed, 0xb6, - 0x58, 0x37, 0x39, 0xe4, 0x46, 0xef, 0x8e, 0x57, 0x8c, 0x56, 0x24, 0x4b, 0x52, 0x02, 0x74, 0xef, - 0xd3, 0xf4, 0x49, 0x72, 0xec, 0x13, 0x14, 0x85, 0x2f, 0x7d, 0x87, 0x9e, 0x0a, 0x72, 0x57, 0x32, - 0xd7, 0xd5, 0xa1, 0xe9, 0x8d, 0xfc, 0xe6, 0x9b, 0x21, 0xe7, 0x97, 0x84, 0x47, 0x06, 0xf5, 0x14, - 0xf5, 0x80, 0x29, 0x55, 0xf0, 0x94, 0x59, 0x2e, 0xc5, 0x00, 0xa7, 0x28, 0xac, 0x89, 0x95, 0x96, - 0x56, 0x92, 0xf5, 0x1c, 0x05, 0x6a, 0x9e, 0xee, 0x9e, 0xe7, 0xdc, 0x0e, 0x27, 0x57, 0x71, 0x2a, - 0xc7, 0x03, 0xa6, 0x73, 0xa9, 0xb4, 0x7c, 0xeb, 0x17, 0x4f, 0xd3, 0x6c, 0x30, 0x3d, 0x1a, 0xa8, - 0x51, 0x3e, 0x60, 0x8a, 0x9b, 0x9a, 0xa9, 0xe9, 0x21, 0x2b, 0xd4, 0x90, 0x1d, 0x0e, 0xbc, 0x15, - 0x66, 0x31, 0x2b, 0xcd, 0xee, 0x7e, 0x36, 0x7a, 0x66, 0x62, 0x2e, 0x9d, 0xc6, 0x98, 0xa5, 0x43, - 0x2e, 0x50, 0xcf, 0x6e, 0x4d, 0x8c, 0xd1, 0xb2, 0xc1, 0xf4, 0xdf, 0x5a, 0xdb, 0xb9, 0xf4, 0x07, - 0x5b, 0x39, 0x70, 0xab, 0x0a, 0xdd, 0xcb, 0xa5, 0xcc, 0x0b, 0x74, 0xaa, 0x03, 0x26, 0x84, 0xb4, - 0xfe, 0xec, 0xca, 0x81, 0xde, 0x73, 0x68, 0x9f, 0x3a, 0x87, 0x2e, 0xe5, 0x44, 0xa7, 0x48, 0x08, - 0x34, 0x05, 0x1b, 0x23, 0x8d, 0xba, 0x8d, 0x7e, 0x2b, 0xf1, 0x6b, 0xf2, 0x10, 0xd6, 0x52, 0x29, - 0xae, 0x79, 0x4e, 0x1b, 0xdd, 0xa8, 0xdf, 0x49, 0xaa, 0x5d, 0xef, 0x73, 0x58, 0xf5, 0xaa, 0x4b, - 0x95, 0x28, 0xac, 0x2b, 0x36, 0x2b, 0x24, 0xcb, 0x68, 0xa3, 0xdb, 0xe8, 0x77, 0x92, 0xf9, 0xb6, - 0xf7, 0x57, 0x04, 0x1d, 0xaf, 0xf7, 0x53, 0x09, 0x90, 0x1e, 0xb4, 0x2c, 0x1f, 0xa3, 0xb1, 0x6c, - 0xac, 0x4a, 0x1b, 0x2f, 0x9b, 0xef, 0xfe, 0x78, 0xf4, 0x41, 0x72, 0x0b, 0xbb, 0x3b, 0xc8, 0xab, - 0xb7, 0x98, 0xda, 0xca, 0x5a, 0xb5, 0x23, 0x4f, 0x61, 0xcd, 0xf8, 0x9b, 0xd3, 0x95, 0x6e, 0xa3, - 0xdf, 0x3e, 0xda, 0x89, 0xab, 0x84, 0xc4, 0x3f, 0x7a, 0x42, 0xe9, 0x56, 0x52, 0x91, 0xc8, 0x13, - 0x58, 0x43, 0xad, 0xa5, 0x36, 0xb4, 0xd9, 0x5d, 0xe9, 0xb7, 0x8f, 0xb6, 0xef, 0xd0, 0x4f, 0x9d, - 0x30, 0xa9, 0x38, 0xe4, 0x2b, 0x68, 0x33, 0xa5, 0x5e, 0xa3, 0x36, 0x2e, 0x60, 0x74, 0xb5, 0x1b, - 0xf5, 0xdb, 0x47, 0x7b, 0x0b, 0x95, 0xe3, 0xdb, 0x4c, 0xce, 0x39, 0x49, 0xa8, 0xd0, 0xfb, 0xb5, - 0x05, 0x9d, 0xf0, 0x1a, 0x24, 0x86, 0xfb, 0x19, 0x1a, 0xae, 0x31, 0xbb, 0x60, 0x82, 0x5f, 0xa3, - 0xb1, 0x34, 0xea, 0x46, 0x0b, 0x7f, 0xef, 0x0a, 0xc9, 0x13, 0xd8, 0x64, 0xa9, 0x9d, 0xb0, 0x62, - 0x41, 0x6f, 0x04, 0xf4, 0x3b, 0x32, 0xf2, 0x09, 0xb4, 0x73, 0x6e, 0x17, 0xd4, 0x95, 0x80, 0x1a, - 0x0a, 0xc8, 0x3e, 0xac, 0x6b, 0x54, 0xf2, 0x55, 0x72, 0x4e, 0x9b, 0x01, 0x67, 0x0e, 0x12, 0x0a, - 0x4d, 0xc5, 0xec, 0xd0, 0xfb, 0x3b, 0x17, 0x7a, 0x84, 0x74, 0xe1, 0x9e, 0xc6, 0x29, 0x77, 0xde, - 0xd1, 0xb5, 0x40, 0xba, 0x40, 0xc9, 0x63, 0xd8, 0x48, 0xe5, 0x78, 0xcc, 0xed, 0x05, 0x1a, 0xc3, - 0x72, 0xa4, 0xeb, 0x01, 0xad, 0x2e, 0x22, 0x7d, 0xe8, 0x94, 0xc0, 0xf1, 0xc4, 0x0e, 0xa5, 0xa6, - 0xf7, 0x02, 0x6a, 0x4d, 0x42, 0xbe, 0x03, 0x28, 0xf7, 0x27, 0xcc, 0x22, 0x6d, 0xf9, 0x3c, 0x3c, - 0x8e, 0xcb, 0x1e, 0x89, 0xc3, 0x1e, 0x89, 0xd5, 0x28, 0x77, 0x80, 0x89, 0x5d, 0x8f, 0xc4, 0xd3, - 0xc3, 0xf8, 0x67, 0x3e, 0xc6, 0x24, 0xd0, 0x76, 0xde, 0x33, 0xa5, 0x7e, 0x70, 0xf5, 0x0a, 0xa1, - 0xf7, 0x15, 0x48, 0xbe, 0x85, 0x16, 0x53, 0xea, 0x9c, 0x5d, 0x61, 0x61, 0x68, 0xdb, 0x57, 0xc9, - 0xc1, 0xd2, 0xa2, 0x72, 0xf9, 0x2f, 0x69, 0xa7, 0xc2, 0xea, 0xd9, 0xbc, 0x66, 0x17, 0xca, 0xe4, - 0x00, 0xc0, 0xcc, 0x44, 0x7a, 0x69, 0x99, 0x9d, 0x18, 0xda, 0x09, 0x0e, 0x0b, 0x70, 0xf2, 0x1a, - 0x36, 0xaa, 0x9d, 0xb6, 0x98, 0x1d, 0x5b, 0xba, 0xf1, 0xbe, 0xee, 0xcd, 0xa3, 0x5b, 0x33, 0x43, - 0x12, 0xd8, 0x74, 0xc0, 0xd7, 0x5c, 0x70, 0x33, 0xf4, 0x86, 0x37, 0xdf, 0x3b, 0x6e, 0x77, 0x2c, - 0x90, 0x1e, 0x74, 0x86, 0xc8, 0x0a, 0x3b, 0xac, 0x7c, 0xba, 0xef, 0x7c, 0x4a, 0x6a, 0x18, 0x39, - 0x80, 0x8d, 0x72, 0x3f, 0xaf, 0x80, 0x07, 0x9e, 0x54, 0x07, 0x5d, 0x16, 0xd2, 0x62, 0x62, 0x2c, - 0x6a, 0xfa, 0x61, 0x98, 0x85, 0x0a, 0x74, 0x33, 0x61, 0xc8, 0x8d, 0x95, 0x7a, 0x76, 0x96, 0x51, - 0xd2, 0x8d, 0xfa, 0x2b, 0xf3, 0xf8, 0x2e, 0x60, 0xf2, 0x02, 0x76, 0xa4, 0x72, 0x03, 0x90, 0x4b, - 0x71, 0x39, 0x13, 0x69, 0x32, 0x2f, 0xcd, 0xad, 0xc0, 0xe2, 0x72, 0x0a, 0xd9, 0x83, 0x35, 0xa6, - 0xd4, 0xab, 0xb3, 0x13, 0xba, 0x1d, 0x90, 0x2b, 0xcc, 0x55, 0x66, 0x55, 0x0e, 0x46, 0xb1, 0x14, - 0xe9, 0x4e, 0x58, 0x99, 0xa1, 0x84, 0x7c, 0x01, 0x5b, 0x4c, 0xa9, 0x33, 0x61, 0x2c, 0x13, 0x29, - 0xfa, 0xc4, 0x7f, 0x8f, 0x33, 0xfa, 0x30, 0x50, 0x58, 0x46, 0x70, 0x9d, 0x6d, 0x35, 0x4b, 0x47, - 0x5c, 0xe4, 0x17, 0x68, 0x87, 0x32, 0xa3, 0x1f, 0x85, 0x9d, 0x5d, 0x97, 0xed, 0x7e, 0x09, 0x9b, - 0xf5, 0x62, 0x23, 0x0f, 0x60, 0x65, 0x84, 0xb3, 0x72, 0x7a, 0x24, 0x6e, 0x49, 0xb6, 0x61, 0x75, - 0xca, 0x8a, 0x09, 0x96, 0x23, 0x22, 0x29, 0x37, 0x2f, 0x1a, 0xcf, 0xa2, 0xde, 0xdf, 0x11, 0xb4, - 0x83, 0xf1, 0xe6, 0xfa, 0xdb, 0xce, 0x14, 0xd6, 0x46, 0x8f, 0x47, 0xc8, 0x2e, 0xac, 0x16, 0x38, - 0xc5, 0xa2, 0x36, 0x66, 0x4a, 0xc8, 0x65, 0x6c, 0x5c, 0x65, 0x34, 0x9c, 0x2c, 0x73, 0x90, 0x9c, - 0xc3, 0xbd, 0x82, 0x19, 0x7b, 0x89, 0x28, 0xfc, 0x58, 0xf9, 0x3f, 0x25, 0xbc, 0xb0, 0x40, 0xbe, - 0x81, 0xfb, 0xe5, 0xc8, 0x4e, 0xf0, 0x1a, 0x35, 0x8a, 0x14, 0xab, 0xf1, 0xfb, 0xf1, 0xa2, 0x17, - 0xbd, 0x33, 0x97, 0x75, 0x52, 0x72, 0x57, 0xab, 0xf7, 0x5b, 0x04, 0xdb, 0xcb, 0x98, 0xce, 0xd7, - 0x5c, 0xcb, 0x89, 0xaa, 0x85, 0xa1, 0x84, 0x9c, 0xaf, 0xd3, 0x72, 0x88, 0xd7, 0x22, 0x31, 0x07, - 0x5d, 0x04, 0x47, 0x5c, 0x64, 0xfe, 0xcd, 0x59, 0x44, 0xd0, 0x21, 0x4e, 0xe2, 0x9f, 0xc2, 0x66, - 0x28, 0xf1, 0x0f, 0x62, 0x0f, 0x5a, 0x62, 0x51, 0x50, 0xe1, 0x68, 0xbd, 0x85, 0x7b, 0x6f, 0xa0, - 0x73, 0x82, 0x0a, 0x45, 0x86, 0x22, 0xe5, 0x68, 0xdc, 0xc3, 0x5a, 0xc8, 0x74, 0x54, 0xa5, 0xd9, - 0xaf, 0x1d, 0x96, 0xa1, 0x32, 0x55, 0x9a, 0xfd, 0xda, 0xf5, 0xa5, 0xc6, 0x5f, 0x26, 0x5c, 0xe3, - 0xd8, 0xfd, 0x4d, 0xca, 0x04, 0x25, 0x35, 0xac, 0xa7, 0x60, 0x6b, 0xc9, 0x83, 0x45, 0xf6, 0x01, - 0x6e, 0x9f, 0xac, 0xea, 0xa0, 0x00, 0x21, 0xcf, 0xa1, 0x93, 0x05, 0x57, 0xf2, 0xc7, 0x86, 0xcf, - 0x6c, 0x78, 0xdf, 0xa4, 0x46, 0x7d, 0x79, 0xfc, 0xee, 0x66, 0x3f, 0xfa, 0xfd, 0x66, 0x3f, 0xfa, - 0xf3, 0x66, 0x3f, 0x7a, 0xf3, 0xe9, 0x7f, 0xfb, 0x20, 0xa5, 0x05, 0x47, 0x61, 0xab, 0x4f, 0xd6, - 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xd4, 0x18, 0x11, 0xf8, 0x80, 0x09, 0x00, 0x00, + // 1125 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x56, 0xdd, 0x8e, 0x1b, 0xb5, + 0x17, 0xff, 0x27, 0xfb, 0x99, 0x93, 0xec, 0xb6, 0x7f, 0x77, 0x5b, 0xcc, 0xb2, 0x6c, 0xa3, 0xa8, + 0x42, 0x51, 0xd5, 0x26, 0xea, 0x02, 0x55, 0x5b, 0x21, 0xa4, 0xad, 0x5a, 0x60, 0x61, 0x17, 0xd0, + 0x2c, 0xed, 0x45, 0xef, 0xdc, 0x99, 0xd3, 0x89, 0x9b, 0x89, 0x6d, 0x6c, 0x27, 0x22, 0x0f, 0xc2, + 0x4b, 0xf0, 0x24, 0xbd, 0xe4, 0x8a, 0x4b, 0x84, 0xfa, 0x18, 0x5c, 0x21, 0x7b, 0x3c, 0x89, 0x27, + 0x04, 0x89, 0x72, 0x67, 0xff, 0xce, 0xef, 0x1c, 0xfb, 0x7c, 0xda, 0x70, 0xd3, 0xa0, 0x9e, 0xa1, + 0x1e, 0x32, 0xa5, 0x0a, 0x9e, 0x32, 0xcb, 0xa5, 0x18, 0xe2, 0x0c, 0x85, 0x35, 0x03, 0xa5, 0xa5, + 0x95, 0x64, 0x27, 0x47, 0x81, 0x9a, 0xa7, 0x87, 0xe7, 0x39, 0xb7, 0xa3, 0xe9, 0xcb, 0x41, 0x2a, + 0x27, 0x43, 0xa6, 0x73, 0xa9, 0xb4, 0x7c, 0xed, 0x17, 0x77, 0xd3, 0x6c, 0x38, 0x3b, 0x19, 0xaa, + 0x71, 0x3e, 0x64, 0x8a, 0x9b, 0x9a, 0xa9, 0xd9, 0x3d, 0x56, 0xa8, 0x11, 0xbb, 0x37, 0xf4, 0x56, + 0x98, 0xc5, 0xac, 0x34, 0x7b, 0xf8, 0xc9, 0xf8, 0x81, 0x19, 0x70, 0xe9, 0x34, 0x26, 0x2c, 0x1d, + 0x71, 0x81, 0x7a, 0xbe, 0x34, 0x31, 0x41, 0xcb, 0x86, 0xb3, 0xbf, 0x6b, 0x1d, 0xe4, 0xd2, 0x1f, + 0x6c, 0xe5, 0xd0, 0xad, 0x02, 0x7a, 0x94, 0x4b, 0x99, 0x17, 0xe8, 0x54, 0x87, 0x4c, 0x08, 0x69, + 0xfd, 0xd9, 0xc1, 0x81, 0xde, 0x43, 0x68, 0x3f, 0x75, 0x0e, 0x5d, 0xca, 0xa9, 0x4e, 0x91, 0x10, + 0xd8, 0x14, 0x6c, 0x82, 0xb4, 0xd1, 0x6d, 0xf6, 0x5b, 0x89, 0x5f, 0x93, 0x1b, 0xb0, 0x9d, 0x4a, + 0xf1, 0x8a, 0xe7, 0xb4, 0xd9, 0x6d, 0xf4, 0x3b, 0x49, 0xd8, 0xf5, 0x3e, 0x85, 0x2d, 0xaf, 0xba, + 0x56, 0x89, 0xc2, 0x8e, 0x62, 0xf3, 0x42, 0xb2, 0x8c, 0x36, 0xbb, 0xcd, 0x7e, 0x27, 0xa9, 0xb6, + 0xbd, 0x9f, 0x9b, 0xd0, 0xf1, 0x7a, 0xdf, 0x97, 0x00, 0xe9, 0x41, 0xcb, 0xf2, 0x09, 0x1a, 0xcb, + 0x26, 0xaa, 0xb4, 0xf1, 0x78, 0xf3, 0xcd, 0xef, 0x37, 0xff, 0x97, 0x2c, 0x61, 0x77, 0x07, 0xf9, + 0xf2, 0x35, 0xa6, 0x36, 0x58, 0x0b, 0x3b, 0x72, 0x17, 0xb6, 0x8d, 0xbf, 0x39, 0xdd, 0xe8, 0x36, + 0xfb, 0xed, 0x93, 0xeb, 0x83, 0x90, 0x90, 0xc1, 0x77, 0x9e, 0x50, 0xba, 0x95, 0x04, 0x12, 0xb9, + 0x03, 0xdb, 0xa8, 0xb5, 0xd4, 0x86, 0x6e, 0x76, 0x37, 0xfa, 0xed, 0x93, 0x83, 0x15, 0xfa, 0x53, + 0x27, 0x4c, 0x02, 0x87, 0x7c, 0x0e, 0x6d, 0xa6, 0xd4, 0x73, 0xd4, 0xc6, 0x05, 0x8c, 0x6e, 0x75, + 0x1b, 0xfd, 0xf6, 0xc9, 0xd1, 0x42, 0xe5, 0x74, 0x99, 0xc9, 0x8a, 0x93, 0xc4, 0x0a, 0xe4, 0x0e, + 0xec, 0xeb, 0xa9, 0x70, 0x4e, 0x04, 0x88, 0x6e, 0x47, 0xde, 0xad, 0xc8, 0x7a, 0xbf, 0x01, 0x74, + 0xe2, 0x4b, 0x93, 0x01, 0x5c, 0xc9, 0xd0, 0x70, 0x8d, 0xd9, 0x05, 0x13, 0xfc, 0x15, 0x1a, 0x4b, + 0x1b, 0xdd, 0xc6, 0x42, 0x7f, 0x55, 0xe8, 0x8e, 0x63, 0xa9, 0x9d, 0xb2, 0x62, 0x41, 0x6f, 0x46, + 0xf4, 0x15, 0x19, 0xf9, 0x08, 0xda, 0x39, 0xb7, 0x0b, 0xea, 0x46, 0x44, 0x8d, 0x05, 0xe4, 0x18, + 0x76, 0x34, 0x2a, 0xf9, 0x2c, 0x39, 0xa7, 0x9b, 0x11, 0xa7, 0x02, 0x09, 0x85, 0x4d, 0xc5, 0xec, + 0xc8, 0x47, 0xa7, 0x12, 0x7a, 0x84, 0x74, 0x61, 0x57, 0xe3, 0x8c, 0x07, 0xc7, 0x97, 0xd2, 0x05, + 0x4a, 0x6e, 0xc3, 0x5e, 0x2a, 0x27, 0x13, 0x6e, 0x2f, 0xd0, 0x18, 0x96, 0x23, 0xdd, 0x89, 0x68, + 0x75, 0x11, 0xe9, 0x43, 0xa7, 0x04, 0x4e, 0xa7, 0x76, 0x24, 0x35, 0xdd, 0x8d, 0xa8, 0x35, 0x09, + 0xf9, 0x1a, 0xa0, 0xdc, 0x3f, 0x61, 0x16, 0x69, 0xcb, 0x67, 0xed, 0xf6, 0xa0, 0xec, 0xa8, 0x41, + 0xdc, 0x51, 0x03, 0x35, 0xce, 0x1d, 0x60, 0x06, 0xae, 0xa3, 0x06, 0xb3, 0x7b, 0x83, 0x1f, 0xf8, + 0x04, 0x93, 0x48, 0xdb, 0x79, 0xcf, 0x94, 0xfa, 0xd6, 0x55, 0x37, 0xc4, 0xde, 0x07, 0x90, 0x7c, + 0x05, 0x2d, 0xa6, 0xd4, 0x39, 0x7b, 0x89, 0x85, 0xa1, 0x6d, 0x5f, 0x53, 0xb7, 0xd6, 0x96, 0xa0, + 0xab, 0x96, 0x92, 0xf6, 0x54, 0x58, 0x3d, 0xaf, 0x2a, 0x7c, 0xa1, 0x4c, 0x6e, 0x01, 0x98, 0xb9, + 0x48, 0x2f, 0x2d, 0xb3, 0x53, 0x43, 0x3b, 0xd1, 0x61, 0x11, 0x4e, 0x9e, 0xc3, 0x5e, 0xd8, 0x69, + 0x8b, 0xd9, 0xa9, 0xa5, 0x7b, 0xef, 0xea, 0x5e, 0x15, 0xdd, 0x9a, 0x19, 0x92, 0xc0, 0xbe, 0x03, + 0xbe, 0xe0, 0x82, 0x9b, 0x91, 0x37, 0xbc, 0xff, 0xce, 0x71, 0x5b, 0xb1, 0x40, 0x7a, 0xd0, 0x19, + 0x21, 0x2b, 0xec, 0x28, 0xf8, 0x74, 0xc5, 0xf9, 0x94, 0xd4, 0x30, 0x72, 0x0b, 0xf6, 0xca, 0x7d, + 0x55, 0x01, 0x57, 0x3d, 0xa9, 0x0e, 0xba, 0x2c, 0xa4, 0xc5, 0xd4, 0x58, 0xd4, 0xf4, 0xff, 0x71, + 0x16, 0x02, 0xe8, 0x26, 0xc8, 0x88, 0x1b, 0x2b, 0xf5, 0xfc, 0x2c, 0xa3, 0xa4, 0xdb, 0xe8, 0x6f, + 0x54, 0xf1, 0x5d, 0xc0, 0xe4, 0x11, 0x5c, 0x97, 0xca, 0x8d, 0x4b, 0x2e, 0xc5, 0xe5, 0x5c, 0xa4, + 0x49, 0x55, 0x9a, 0xd7, 0x22, 0x8b, 0xeb, 0x29, 0xe4, 0x08, 0xb6, 0x99, 0x52, 0xcf, 0xce, 0x9e, + 0xd0, 0x83, 0x88, 0x1c, 0x30, 0x57, 0x99, 0xa1, 0x1c, 0x8c, 0x62, 0x29, 0xd2, 0xeb, 0x71, 0x65, + 0xc6, 0x12, 0x72, 0x1f, 0xae, 0x31, 0xa5, 0xce, 0x84, 0xb1, 0x4c, 0xa4, 0xe8, 0x13, 0xff, 0x0d, + 0xce, 0xe9, 0x8d, 0x48, 0x61, 0x1d, 0xc1, 0x75, 0xb6, 0xd5, 0x2c, 0x1d, 0x73, 0x91, 0x5f, 0xa0, + 0x1d, 0xc9, 0x8c, 0xbe, 0x17, 0x77, 0x76, 0x5d, 0x46, 0x8e, 0xa0, 0x55, 0x75, 0x98, 0xa1, 0xb4, + 0xbb, 0xd1, 0x6f, 0x25, 0x4b, 0x80, 0xdc, 0x87, 0x1b, 0x6b, 0x9d, 0x34, 0xf4, 0x7d, 0x4f, 0xfd, + 0x07, 0x29, 0xe9, 0x42, 0x3b, 0x84, 0xdb, 0x77, 0xc3, 0xa1, 0xcf, 0x53, 0x0c, 0xb9, 0x79, 0xc5, + 0x94, 0xba, 0x98, 0x16, 0x96, 0x97, 0x35, 0x9f, 0xd1, 0x0f, 0xba, 0xcd, 0xfe, 0x6e, 0x35, 0xaf, + 0x56, 0x84, 0x21, 0x6e, 0xe5, 0xee, 0x2c, 0xfb, 0x89, 0x1e, 0x75, 0x9b, 0xfd, 0xad, 0x28, 0x6e, + 0x0b, 0xc9, 0xe1, 0x67, 0xb0, 0x5f, 0x6f, 0x1f, 0x72, 0x15, 0x36, 0xc6, 0x38, 0x2f, 0xe7, 0x61, + 0xe2, 0x96, 0xe4, 0x00, 0xb6, 0x66, 0xac, 0x98, 0x62, 0x39, 0xf4, 0x92, 0x72, 0xf3, 0xa8, 0xf9, + 0xa0, 0xd1, 0xfb, 0xb3, 0x01, 0xed, 0x68, 0xbc, 0xbb, 0x89, 0x65, 0xe7, 0x0a, 0x6b, 0xc3, 0xd4, + 0x23, 0xe4, 0x10, 0xb6, 0x0a, 0x9c, 0x61, 0x51, 0x1b, 0x9c, 0x25, 0xe4, 0x6a, 0x70, 0x12, 0x6a, + 0x34, 0x9e, 0x95, 0x15, 0x48, 0xce, 0x61, 0xb7, 0x60, 0xc6, 0x5e, 0x22, 0x0a, 0x3f, 0x28, 0xff, + 0x4b, 0x53, 0x2e, 0x2c, 0x90, 0x2f, 0xe1, 0x4a, 0xf9, 0x64, 0x25, 0xf8, 0x0a, 0x35, 0x8a, 0x14, + 0xc3, 0xf3, 0xf3, 0xe1, 0x62, 0xba, 0x78, 0x67, 0x2e, 0xeb, 0xa4, 0x64, 0x55, 0xab, 0xf7, 0x4b, + 0x03, 0x0e, 0xd6, 0x31, 0x9d, 0xaf, 0xb9, 0x96, 0x53, 0x55, 0x0b, 0x43, 0x09, 0x39, 0x5f, 0x67, + 0xe1, 0xc5, 0x8a, 0x23, 0x51, 0x81, 0x2e, 0x82, 0x63, 0x2e, 0x32, 0xff, 0xe6, 0x2e, 0x22, 0xe8, + 0x10, 0x27, 0xf1, 0x5f, 0x81, 0xcd, 0x58, 0xe2, 0x3f, 0x04, 0x3d, 0x68, 0x89, 0x45, 0x8b, 0xc4, + 0x8f, 0xc5, 0x12, 0xee, 0xbd, 0x80, 0xce, 0x13, 0x54, 0x28, 0x32, 0x14, 0x29, 0x47, 0xe3, 0x3e, + 0x16, 0x85, 0x4c, 0xc7, 0x21, 0xcd, 0x7e, 0xed, 0xb0, 0x0c, 0x95, 0x09, 0x69, 0xf6, 0x6b, 0x37, + 0x69, 0x34, 0xfe, 0x38, 0xe5, 0x1a, 0x27, 0xee, 0x6f, 0x56, 0x26, 0x28, 0xa9, 0x61, 0x3d, 0x05, + 0xd7, 0xd6, 0x3c, 0xd8, 0xe4, 0x18, 0x60, 0xf9, 0x64, 0x87, 0x83, 0x22, 0x84, 0x3c, 0x84, 0x4e, + 0x16, 0x5d, 0xc9, 0x1f, 0x1b, 0x7f, 0x33, 0xe2, 0xfb, 0x26, 0x35, 0xea, 0xe3, 0xd3, 0x37, 0x6f, + 0x8f, 0x1b, 0xbf, 0xbe, 0x3d, 0x6e, 0xfc, 0xf1, 0xf6, 0xb8, 0xf1, 0xe2, 0xe3, 0x7f, 0xf7, 0x41, + 0x4c, 0x0b, 0x8e, 0xc2, 0x86, 0x4f, 0xe6, 0x5f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xc5, 0xd7, 0x70, + 0xae, 0x80, 0x0a, 0x00, 0x00, } func (m *EventSource) Marshal() (dAtA []byte, err error) { @@ -940,6 +995,11 @@ func (m *EventPayload) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } + i -= len(m.RuntimeVersion) + copy(dAtA[i:], m.RuntimeVersion) + i = encodeVarintEvents(dAtA, i, uint64(len(m.RuntimeVersion))) + i-- + dAtA[i] = 0x32 if m.AppVersions != nil { { size, err := m.AppVersions.MarshalToSizedBuffer(dAtA[:i]) @@ -1021,6 +1081,52 @@ func (m *ObjectSource) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } + i = encodeVarintEvents(dAtA, i, uint64(m.AppSourceIdx)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xe0 + i-- + if m.AppMultiSourced { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xd8 + if m.ClusterName != nil { + i -= len(*m.ClusterName) + copy(dAtA[i:], *m.ClusterName) + i = encodeVarintEvents(dAtA, i, uint64(len(*m.ClusterName))) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xd2 + } + if len(m.OperationSyncRevisions) > 0 { + for iNdEx := len(m.OperationSyncRevisions) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.OperationSyncRevisions[iNdEx]) + copy(dAtA[i:], m.OperationSyncRevisions[iNdEx]) + i = encodeVarintEvents(dAtA, i, uint64(len(m.OperationSyncRevisions[iNdEx]))) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xca + } + } + if len(m.Revisions) > 0 { + for iNdEx := len(m.Revisions) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Revisions[iNdEx]) + copy(dAtA[i:], m.Revisions[iNdEx]) + i = encodeVarintEvents(dAtA, i, uint64(len(m.Revisions[iNdEx]))) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xc2 + } + } i -= len(m.TrackingMethod) copy(dAtA[i:], m.TrackingMethod) i = encodeVarintEvents(dAtA, i, uint64(len(m.TrackingMethod))) @@ -1477,6 +1583,8 @@ func (m *EventPayload) Size() (n int) { l = m.AppVersions.Size() n += 1 + l + sovEvents(uint64(l)) } + l = len(m.RuntimeVersion) + n += 1 + l + sovEvents(uint64(l)) if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } @@ -1548,6 +1656,24 @@ func (m *ObjectSource) Size() (n int) { n += 2 + l + sovEvents(uint64(l)) l = len(m.TrackingMethod) n += 2 + l + sovEvents(uint64(l)) + if len(m.Revisions) > 0 { + for _, s := range m.Revisions { + l = len(s) + n += 2 + l + sovEvents(uint64(l)) + } + } + if len(m.OperationSyncRevisions) > 0 { + for _, s := range m.OperationSyncRevisions { + l = len(s) + n += 2 + l + sovEvents(uint64(l)) + } + } + if m.ClusterName != nil { + l = len(*m.ClusterName) + n += 2 + l + sovEvents(uint64(l)) + } + n += 3 + n += 2 + sovEvents(uint64(m.AppSourceIdx)) if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } @@ -2105,6 +2231,39 @@ func (m *EventPayload) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RuntimeVersion", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + 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 ErrInvalidLengthEvents + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RuntimeVersion = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + hasFields[0] |= uint64(0x00000008) default: iNdEx = preIndex skippy, err := skipEvents(dAtA[iNdEx:]) @@ -2130,6 +2289,9 @@ func (m *EventPayload) Unmarshal(dAtA []byte) error { if hasFields[0]&uint64(0x00000004) == 0 { return github_com_gogo_protobuf_proto.NewRequiredNotSetError("source") } + if hasFields[0]&uint64(0x00000008) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("runtimeVersion") + } if iNdEx > l { return io.ErrUnexpectedEOF @@ -2137,6 +2299,7 @@ func (m *EventPayload) Unmarshal(dAtA []byte) error { return nil } func (m *ObjectSource) Unmarshal(dAtA []byte) error { + var hasFields [1]uint64 l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -2994,6 +3157,144 @@ func (m *ObjectSource) Unmarshal(dAtA []byte) error { } m.TrackingMethod = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex + case 24: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Revisions", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + 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 ErrInvalidLengthEvents + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Revisions = append(m.Revisions, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 25: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OperationSyncRevisions", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + 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 ErrInvalidLengthEvents + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.OperationSyncRevisions = append(m.OperationSyncRevisions, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 26: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClusterName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + 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 ErrInvalidLengthEvents + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(dAtA[iNdEx:postIndex]) + m.ClusterName = &s + iNdEx = postIndex + case 27: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AppMultiSourced", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.AppMultiSourced = bool(v != 0) + hasFields[0] |= uint64(0x00000001) + case 28: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AppSourceIdx", wireType) + } + m.AppSourceIdx = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.AppSourceIdx |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + hasFields[0] |= uint64(0x00000002) default: iNdEx = preIndex skippy, err := skipEvents(dAtA[iNdEx:]) @@ -3010,6 +3311,12 @@ func (m *ObjectSource) Unmarshal(dAtA []byte) error { iNdEx += skippy } } + if hasFields[0]&uint64(0x00000001) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("appMultiSourced") + } + if hasFields[0]&uint64(0x00000002) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("appSourceIdx") + } if iNdEx > l { return io.ErrUnexpectedEOF diff --git a/pkg/codefresh/client.go b/pkg/codefresh/client.go index d917fe9dd90e6..47158f6af6fd0 100644 --- a/pkg/codefresh/client.go +++ b/pkg/codefresh/client.go @@ -21,10 +21,11 @@ import ( ) type CodefreshConfig struct { - BaseURL string - AuthToken string - TlsInsecure bool - CaCertPath string + BaseURL string + AuthToken string + TlsInsecure bool + CaCertPath string + RuntimeVersion string } type CodefreshClient struct { diff --git a/reposerver/apiclient/repository.pb.go b/reposerver/apiclient/repository.pb.go index bd29211801e06..1b79360fa657b 100644 --- a/reposerver/apiclient/repository.pb.go +++ b/reposerver/apiclient/repository.pb.go @@ -903,10 +903,12 @@ type ManifestResponse struct { CommitAuthor string `protobuf:"bytes,9,opt,name=commitAuthor,proto3" json:"commitAuthor,omitempty"` CommitDate *v1.Time `protobuf:"bytes,10,opt,name=commitDate,proto3" json:"commitDate,omitempty"` // A version of the application and its dependencies - ApplicationVersions *ApplicationVersions `protobuf:"bytes,11,opt,name=applicationVersions,proto3" json:"applicationVersions,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + ApplicationVersions *ApplicationVersions `protobuf:"bytes,11,opt,name=applicationVersions,proto3" json:"applicationVersions,omitempty"` + // for multisourced apps will be [0,12,20], so this means that 0-11 - from first app source, 12-19 from second one, 20-x - third one + SourcesManifestsStartingIdx []int32 `protobuf:"varint,12,rep,packed,name=sourcesManifestsStartingIdx,proto3" json:"sourcesManifestsStartingIdx,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *ManifestResponse) Reset() { *m = ManifestResponse{} } @@ -1012,6 +1014,13 @@ func (m *ManifestResponse) GetApplicationVersions() *ApplicationVersions { return nil } +func (m *ManifestResponse) GetSourcesManifestsStartingIdx() []int32 { + if m != nil { + return m.SourcesManifestsStartingIdx + } + return nil +} + type ListRefsRequest struct { Repo *v1alpha1.Repository `protobuf:"bytes,1,opt,name=repo,proto3" json:"repo,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` @@ -2819,174 +2828,176 @@ func init() { } var fileDescriptor_dd8723cfcc820480 = []byte{ - // 2664 bytes of a gzipped FileDescriptorProto + // 2690 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x1a, 0x4d, 0x6f, 0x1c, 0x49, 0xd5, 0xf3, 0xe9, 0x99, 0x37, 0xfe, 0xac, 0xd8, 0x4e, 0x67, 0x76, 0x63, 0xbc, 0xcd, 0x6e, 0xe4, - 0xf5, 0xee, 0xce, 0x60, 0xef, 0x47, 0x96, 0x6c, 0x58, 0xe4, 0x75, 0x12, 0x3b, 0x1f, 0x4e, 0xbc, - 0x9d, 0xec, 0xa2, 0x2c, 0x01, 0x54, 0xd3, 0x53, 0x9e, 0xe9, 0x4c, 0x7f, 0x54, 0xba, 0x7b, 0x1c, - 0x1c, 0x09, 0x09, 0x09, 0xc4, 0x85, 0x3b, 0x12, 0xdc, 0x10, 0xbf, 0x01, 0x71, 0xe4, 0xb4, 0x82, - 0x13, 0x42, 0x5c, 0x90, 0xb8, 0x80, 0xf2, 0x4b, 0x50, 0x7d, 0x74, 0x77, 0x75, 0x4f, 0x7b, 0xec, - 0xc5, 0x89, 0x17, 0xb8, 0xd8, 0x55, 0xaf, 0xab, 0xde, 0x7b, 0xf5, 0xbe, 0xea, 0xbd, 0x57, 0x03, - 0x97, 0x7c, 0x42, 0xbd, 0x80, 0xf8, 0x07, 0xc4, 0x6f, 0xf3, 0xa1, 0x15, 0x7a, 0xfe, 0xa1, 0x32, - 0x6c, 0x51, 0xdf, 0x0b, 0x3d, 0x04, 0x09, 0xa4, 0xa9, 0x0f, 0x3e, 0x0c, 0x5a, 0x96, 0xd7, 0xc6, - 0xd4, 0x6a, 0x9b, 0x9e, 0x4f, 0xda, 0x07, 0xeb, 0xed, 0x1e, 0x71, 0x89, 0x8f, 0x43, 0xd2, 0x15, - 0xeb, 0x9b, 0xef, 0x25, 0x6b, 0x1c, 0x6c, 0xf6, 0x2d, 0x97, 0xf8, 0x87, 0x6d, 0x3a, 0xe8, 0x31, - 0x40, 0xd0, 0x76, 0x48, 0x88, 0xf3, 0x76, 0xdd, 0xe9, 0x59, 0x61, 0x7f, 0xd8, 0x69, 0x99, 0x9e, - 0xd3, 0xc6, 0x7e, 0xcf, 0xa3, 0xbe, 0xf7, 0x98, 0x0f, 0xde, 0x31, 0xbb, 0xed, 0x83, 0x8d, 0x04, - 0x01, 0xa6, 0xd4, 0xb6, 0x4c, 0x1c, 0x5a, 0x9e, 0xdb, 0x3e, 0x58, 0xc7, 0x36, 0xed, 0xe3, 0x51, - 0x6c, 0xaf, 0xf4, 0x3c, 0xaf, 0x67, 0x93, 0x36, 0x9f, 0x75, 0x86, 0xfb, 0x6d, 0xe2, 0xd0, 0x50, - 0x1e, 0x48, 0xff, 0xcb, 0x34, 0xcc, 0xee, 0x62, 0xd7, 0xda, 0x27, 0x41, 0x68, 0x90, 0x27, 0x43, - 0x12, 0x84, 0xe8, 0x11, 0x94, 0xd9, 0x31, 0xb5, 0xc2, 0x4a, 0x61, 0xb5, 0xb1, 0xb1, 0xd3, 0x4a, - 0xb8, 0x69, 0x45, 0xdc, 0xf0, 0xc1, 0x8f, 0xcc, 0x6e, 0xeb, 0x60, 0xa3, 0x45, 0x07, 0xbd, 0x16, - 0xe3, 0xa6, 0xa5, 0x70, 0xd3, 0x8a, 0xb8, 0x69, 0x19, 0xb1, 0xc0, 0x0c, 0x8e, 0x15, 0x35, 0xa1, - 0xe6, 0x93, 0x03, 0x2b, 0xb0, 0x3c, 0x57, 0x2b, 0xae, 0x14, 0x56, 0xeb, 0x46, 0x3c, 0x47, 0x1a, - 0x4c, 0xba, 0xde, 0x16, 0x36, 0xfb, 0x44, 0x2b, 0xad, 0x14, 0x56, 0x6b, 0x46, 0x34, 0x45, 0x2b, - 0xd0, 0xc0, 0x94, 0xde, 0xc1, 0x1d, 0x62, 0xdf, 0x26, 0x87, 0x5a, 0x99, 0x6f, 0x54, 0x41, 0x6c, - 0x2f, 0xa6, 0xf4, 0x2e, 0x76, 0x88, 0x56, 0xe1, 0x5f, 0xa3, 0x29, 0x7a, 0x15, 0xea, 0x2e, 0x76, - 0x48, 0x40, 0xb1, 0x49, 0xb4, 0x1a, 0xff, 0x96, 0x00, 0xd0, 0x4f, 0x60, 0x5e, 0x61, 0xfc, 0xbe, - 0x37, 0xf4, 0x4d, 0xa2, 0x01, 0x3f, 0xfa, 0xbd, 0xd3, 0x1d, 0x7d, 0x33, 0x8b, 0xd6, 0x18, 0xa5, - 0x84, 0x7e, 0x08, 0x15, 0x6e, 0x53, 0x5a, 0x63, 0xa5, 0xf4, 0x42, 0xa5, 0x2d, 0xd0, 0x22, 0x17, - 0x26, 0xa9, 0x3d, 0xec, 0x59, 0x6e, 0xa0, 0x4d, 0x71, 0x0a, 0x0f, 0x4e, 0x47, 0x61, 0xcb, 0x73, - 0xf7, 0xad, 0xde, 0x2e, 0x76, 0x71, 0x8f, 0x38, 0xc4, 0x0d, 0xf7, 0x38, 0x72, 0x23, 0x22, 0x82, - 0x9e, 0xc1, 0xdc, 0x60, 0x18, 0x84, 0x9e, 0x63, 0x3d, 0x23, 0xf7, 0x28, 0xdb, 0x1b, 0x68, 0xd3, - 0x5c, 0x9a, 0x77, 0x4f, 0x47, 0xf8, 0x76, 0x06, 0xab, 0x31, 0x42, 0x87, 0x19, 0xc9, 0x60, 0xd8, - 0x21, 0x9f, 0x13, 0x9f, 0x5b, 0xd7, 0x8c, 0x30, 0x12, 0x05, 0x24, 0xcc, 0xc8, 0x92, 0xb3, 0x40, - 0x9b, 0x5d, 0x29, 0x09, 0x33, 0x8a, 0x41, 0x68, 0x15, 0x66, 0x0f, 0x88, 0x6f, 0xed, 0x1f, 0xde, - 0xb7, 0x7a, 0x2e, 0x0e, 0x87, 0x3e, 0xd1, 0xe6, 0xb8, 0x29, 0x66, 0xc1, 0xc8, 0x81, 0xe9, 0x3e, - 0xb1, 0x1d, 0x26, 0xf2, 0x2d, 0x9f, 0x74, 0x03, 0x6d, 0x9e, 0xcb, 0x77, 0xfb, 0xf4, 0x1a, 0xe4, - 0xe8, 0x8c, 0x34, 0x76, 0xc6, 0x98, 0xeb, 0x19, 0xd2, 0x53, 0x84, 0x8f, 0x20, 0xc1, 0x58, 0x06, - 0x8c, 0x2e, 0xc1, 0x4c, 0xe8, 0x63, 0x73, 0x60, 0xb9, 0xbd, 0x5d, 0x12, 0xf6, 0xbd, 0xae, 0x76, - 0x8e, 0x4b, 0x22, 0x03, 0x45, 0x26, 0x20, 0xe2, 0xe2, 0x8e, 0x4d, 0xba, 0xc2, 0x16, 0x1f, 0x1c, - 0x52, 0x12, 0x68, 0x0b, 0xfc, 0x14, 0xef, 0xb6, 0x94, 0xd8, 0x97, 0x09, 0x10, 0xad, 0xeb, 0x23, - 0xbb, 0xae, 0xbb, 0xa1, 0x7f, 0x68, 0xe4, 0xa0, 0x43, 0x03, 0x68, 0xb0, 0x73, 0x44, 0xa6, 0xb0, - 0xc8, 0x4d, 0xe1, 0xe6, 0xe9, 0x64, 0xb4, 0x93, 0x20, 0x34, 0x54, 0xec, 0xa8, 0x05, 0xa8, 0x8f, - 0x83, 0xdd, 0xa1, 0x1d, 0x5a, 0xd4, 0x26, 0x82, 0x8d, 0x40, 0x5b, 0xe2, 0x62, 0xca, 0xf9, 0x82, - 0x6e, 0x03, 0xf8, 0x64, 0x3f, 0x5a, 0x77, 0x9e, 0x9f, 0xfc, 0xad, 0x71, 0x27, 0x37, 0xe2, 0xd5, - 0xe2, 0xc4, 0xca, 0x76, 0xd4, 0x81, 0x73, 0x0a, 0xb7, 0xbb, 0x24, 0xc4, 0x5d, 0x1c, 0x62, 0x4d, - 0xe3, 0x27, 0xfe, 0x56, 0x4b, 0xdc, 0x04, 0x2d, 0xf5, 0x26, 0x48, 0x8e, 0xc9, 0x6e, 0x82, 0xd6, - 0xc1, 0x7a, 0xeb, 0x5e, 0xe7, 0x31, 0x31, 0x43, 0xb6, 0xd7, 0xc8, 0x43, 0xc6, 0x0e, 0xc8, 0x44, - 0x45, 0xcc, 0x50, 0x46, 0x14, 0x1e, 0x3a, 0x2e, 0x70, 0x33, 0xce, 0xf9, 0xc2, 0xec, 0x5d, 0x42, - 0x79, 0x60, 0x6c, 0x0a, 0x8f, 0x50, 0x40, 0xcd, 0xeb, 0x70, 0xfe, 0x08, 0x75, 0xa2, 0x39, 0x28, - 0x0d, 0xc8, 0x21, 0xbf, 0x06, 0xea, 0x06, 0x1b, 0xa2, 0x05, 0xa8, 0x1c, 0x60, 0x7b, 0x48, 0x78, - 0xe0, 0xae, 0x19, 0x62, 0x72, 0xa5, 0xf8, 0x61, 0xa1, 0xf9, 0x8b, 0x02, 0xcc, 0x66, 0x84, 0x93, - 0xb3, 0xff, 0x07, 0xea, 0xfe, 0x17, 0xe0, 0x2a, 0xfb, 0x0f, 0xb0, 0xdf, 0x23, 0xa1, 0xc2, 0x88, - 0xfe, 0xb7, 0x02, 0x68, 0x19, 0xad, 0x7d, 0xcf, 0x0a, 0xfb, 0x37, 0x2c, 0x9b, 0x04, 0xe8, 0x32, - 0x4c, 0xfa, 0x02, 0x26, 0x2f, 0xb7, 0x57, 0xc6, 0x28, 0x7b, 0x67, 0xc2, 0x88, 0x56, 0xa3, 0x8f, - 0xa1, 0xe6, 0x44, 0x0a, 0x15, 0xbc, 0xaf, 0xe4, 0xed, 0x64, 0x54, 0x22, 0x5d, 0xed, 0x4c, 0x18, - 0xf1, 0x1e, 0xf4, 0x3e, 0x54, 0xcc, 0xfe, 0xd0, 0x1d, 0xf0, 0x6b, 0xad, 0xb1, 0x71, 0xf1, 0xa8, - 0xcd, 0x5b, 0x6c, 0xd1, 0xce, 0x84, 0x21, 0x56, 0x7f, 0x52, 0x85, 0x32, 0xc5, 0x7e, 0xa8, 0xdf, - 0x80, 0x85, 0x3c, 0x12, 0xec, 0x2e, 0x35, 0xfb, 0xc4, 0x1c, 0x04, 0x43, 0x47, 0x8a, 0x39, 0x9e, - 0x23, 0x04, 0xe5, 0xc0, 0x7a, 0x26, 0x44, 0x5d, 0x32, 0xf8, 0x58, 0x7f, 0x13, 0xe6, 0x47, 0xa8, - 0x31, 0xa5, 0x0a, 0xde, 0x18, 0x86, 0x29, 0x49, 0x5a, 0x1f, 0xc2, 0xe2, 0x03, 0x2e, 0x8b, 0xf8, - 0x42, 0x39, 0x8b, 0xec, 0x40, 0xdf, 0x81, 0xa5, 0x2c, 0xd9, 0x80, 0x7a, 0x6e, 0x40, 0x98, 0xe9, - 0xf3, 0x08, 0x6c, 0x91, 0x6e, 0xf2, 0x95, 0x73, 0x51, 0x33, 0x72, 0xbe, 0xe8, 0xbf, 0x2b, 0xc2, - 0x92, 0x41, 0x02, 0xcf, 0x3e, 0x20, 0x51, 0x78, 0x3c, 0x9b, 0x04, 0xe7, 0xfb, 0x50, 0xc2, 0x94, - 0x4a, 0x33, 0xb9, 0xf9, 0xc2, 0x52, 0x08, 0x83, 0x61, 0x45, 0x6f, 0xc3, 0x3c, 0x76, 0x3a, 0x56, - 0x6f, 0xe8, 0x0d, 0x83, 0xe8, 0x58, 0xdc, 0xa8, 0xea, 0xc6, 0xe8, 0x07, 0xe6, 0xfe, 0x01, 0xf7, - 0xc8, 0x9b, 0x6e, 0x97, 0xfc, 0x98, 0x67, 0x4d, 0x25, 0x43, 0x05, 0xe9, 0x26, 0x9c, 0x1f, 0x11, - 0x92, 0x14, 0xb8, 0x9a, 0xa8, 0x15, 0x32, 0x89, 0x5a, 0x2e, 0x1b, 0xc5, 0x23, 0xd8, 0xd0, 0x7f, - 0x5a, 0x80, 0x5a, 0x64, 0x77, 0x68, 0x0d, 0xe6, 0x4c, 0xcf, 0xa1, 0x96, 0x4d, 0xba, 0x11, 0x4c, - 0xa2, 0x1f, 0x81, 0x33, 0xfe, 0x7d, 0xfc, 0x34, 0x5e, 0x26, 0x08, 0xa8, 0x20, 0x66, 0xe5, 0x14, - 0x87, 0x7d, 0x29, 0x02, 0x3e, 0x66, 0x30, 0xdb, 0x72, 0x09, 0x3f, 0x6e, 0xc5, 0xe0, 0x63, 0xfd, - 0x0b, 0x98, 0xba, 0x46, 0x28, 0x71, 0xbb, 0xc4, 0x35, 0x2d, 0x12, 0xf0, 0x35, 0x9e, 0x39, 0x90, - 0x94, 0xf9, 0x98, 0xc1, 0xba, 0x84, 0x06, 0x92, 0x0c, 0x1f, 0x23, 0x1d, 0xa6, 0x58, 0x0c, 0xb0, - 0x7c, 0x9e, 0xec, 0x04, 0x92, 0x4e, 0x0a, 0xa6, 0x07, 0x70, 0x4e, 0xd1, 0x53, 0x9c, 0x49, 0x2c, - 0x03, 0x60, 0x4a, 0xa3, 0x64, 0x44, 0x10, 0x52, 0x20, 0xe8, 0x2a, 0x4c, 0x75, 0x15, 0x96, 0xa4, - 0xc1, 0x68, 0x6a, 0x68, 0x50, 0x59, 0x36, 0x52, 0xab, 0xf5, 0x2f, 0x4b, 0x30, 0x97, 0x04, 0x2c, - 0xa9, 0xb2, 0x0d, 0xa8, 0x3b, 0x12, 0x16, 0x68, 0x05, 0x7e, 0x9d, 0x2d, 0xe4, 0x46, 0xb8, 0x64, - 0x59, 0x3a, 0x3b, 0x2e, 0x66, 0xb3, 0xe3, 0x25, 0xa8, 0x8a, 0xb2, 0x48, 0x9e, 0x5c, 0xce, 0x52, + 0xf5, 0xee, 0xce, 0x60, 0xef, 0x27, 0xd9, 0xb0, 0xe0, 0x75, 0x12, 0x3b, 0x1f, 0x4e, 0xbc, 0x9d, + 0xec, 0xa2, 0x2c, 0x01, 0x54, 0xd3, 0x53, 0x9e, 0xe9, 0x4c, 0x7f, 0x54, 0xba, 0x7b, 0x9c, 0x75, + 0x24, 0x24, 0x24, 0x10, 0x1c, 0xb8, 0x23, 0xc1, 0x0d, 0xf1, 0x1b, 0x10, 0x47, 0x4e, 0x08, 0x4e, + 0x08, 0x71, 0x41, 0xe2, 0x02, 0xca, 0x2f, 0x41, 0xf5, 0xd1, 0xdd, 0xd5, 0x3d, 0xed, 0xb1, 0x17, + 0x27, 0x5e, 0xe0, 0x62, 0x57, 0xbd, 0x7e, 0xf5, 0xea, 0xd5, 0xfb, 0xaa, 0xf7, 0x5e, 0x0d, 0x5c, + 0xf2, 0x09, 0xf5, 0x02, 0xe2, 0x1f, 0x10, 0xbf, 0xcd, 0x87, 0x56, 0xe8, 0xf9, 0x87, 0xca, 0xb0, + 0x45, 0x7d, 0x2f, 0xf4, 0x10, 0x24, 0x90, 0xa6, 0x3e, 0xf8, 0x20, 0x68, 0x59, 0x5e, 0x1b, 0x53, + 0xab, 0x6d, 0x7a, 0x3e, 0x69, 0x1f, 0xac, 0xb7, 0x7b, 0xc4, 0x25, 0x3e, 0x0e, 0x49, 0x57, 0xe0, + 0x37, 0xdf, 0x49, 0x70, 0x1c, 0x6c, 0xf6, 0x2d, 0x97, 0xf8, 0x87, 0x6d, 0x3a, 0xe8, 0x31, 0x40, + 0xd0, 0x76, 0x48, 0x88, 0xf3, 0x56, 0xdd, 0xee, 0x59, 0x61, 0x7f, 0xd8, 0x69, 0x99, 0x9e, 0xd3, + 0xc6, 0x7e, 0xcf, 0xa3, 0xbe, 0xf7, 0x88, 0x0f, 0xde, 0x32, 0xbb, 0xed, 0x83, 0x8d, 0x84, 0x00, + 0xa6, 0xd4, 0xb6, 0x4c, 0x1c, 0x5a, 0x9e, 0xdb, 0x3e, 0x58, 0xc7, 0x36, 0xed, 0xe3, 0x51, 0x6a, + 0x2f, 0xf5, 0x3c, 0xaf, 0x67, 0x93, 0x36, 0x9f, 0x75, 0x86, 0xfb, 0x6d, 0xe2, 0xd0, 0x50, 0x1e, + 0x48, 0xff, 0xcb, 0x34, 0xcc, 0xee, 0x62, 0xd7, 0xda, 0x27, 0x41, 0x68, 0x90, 0xc7, 0x43, 0x12, + 0x84, 0xe8, 0x21, 0x94, 0xd9, 0x31, 0xb5, 0xc2, 0x4a, 0x61, 0xb5, 0xb1, 0xb1, 0xd3, 0x4a, 0xb8, + 0x69, 0x45, 0xdc, 0xf0, 0xc1, 0x0f, 0xcd, 0x6e, 0xeb, 0x60, 0xa3, 0x45, 0x07, 0xbd, 0x16, 0xe3, + 0xa6, 0xa5, 0x70, 0xd3, 0x8a, 0xb8, 0x69, 0x19, 0xb1, 0xc0, 0x0c, 0x4e, 0x15, 0x35, 0xa1, 0xe6, + 0x93, 0x03, 0x2b, 0xb0, 0x3c, 0x57, 0x2b, 0xae, 0x14, 0x56, 0xeb, 0x46, 0x3c, 0x47, 0x1a, 0x4c, + 0xba, 0xde, 0x16, 0x36, 0xfb, 0x44, 0x2b, 0xad, 0x14, 0x56, 0x6b, 0x46, 0x34, 0x45, 0x2b, 0xd0, + 0xc0, 0x94, 0xde, 0xc6, 0x1d, 0x62, 0xdf, 0x22, 0x87, 0x5a, 0x99, 0x2f, 0x54, 0x41, 0x6c, 0x2d, + 0xa6, 0xf4, 0x0e, 0x76, 0x88, 0x56, 0xe1, 0x5f, 0xa3, 0x29, 0x7a, 0x19, 0xea, 0x2e, 0x76, 0x48, + 0x40, 0xb1, 0x49, 0xb4, 0x1a, 0xff, 0x96, 0x00, 0xd0, 0x8f, 0x60, 0x5e, 0x61, 0xfc, 0x9e, 0x37, + 0xf4, 0x4d, 0xa2, 0x01, 0x3f, 0xfa, 0xdd, 0xd3, 0x1d, 0x7d, 0x33, 0x4b, 0xd6, 0x18, 0xdd, 0x09, + 0xfd, 0x00, 0x2a, 0xdc, 0xa6, 0xb4, 0xc6, 0x4a, 0xe9, 0xb9, 0x4a, 0x5b, 0x90, 0x45, 0x2e, 0x4c, + 0x52, 0x7b, 0xd8, 0xb3, 0xdc, 0x40, 0x9b, 0xe2, 0x3b, 0xdc, 0x3f, 0xdd, 0x0e, 0x5b, 0x9e, 0xbb, + 0x6f, 0xf5, 0x76, 0xb1, 0x8b, 0x7b, 0xc4, 0x21, 0x6e, 0xb8, 0xc7, 0x89, 0x1b, 0xd1, 0x26, 0xe8, + 0x29, 0xcc, 0x0d, 0x86, 0x41, 0xe8, 0x39, 0xd6, 0x53, 0x72, 0x97, 0xb2, 0xb5, 0x81, 0x36, 0xcd, + 0xa5, 0x79, 0xe7, 0x74, 0x1b, 0xdf, 0xca, 0x50, 0x35, 0x46, 0xf6, 0x61, 0x46, 0x32, 0x18, 0x76, + 0xc8, 0x67, 0xc4, 0xe7, 0xd6, 0x35, 0x23, 0x8c, 0x44, 0x01, 0x09, 0x33, 0xb2, 0xe4, 0x2c, 0xd0, + 0x66, 0x57, 0x4a, 0xc2, 0x8c, 0x62, 0x10, 0x5a, 0x85, 0xd9, 0x03, 0xe2, 0x5b, 0xfb, 0x87, 0xf7, + 0xac, 0x9e, 0x8b, 0xc3, 0xa1, 0x4f, 0xb4, 0x39, 0x6e, 0x8a, 0x59, 0x30, 0x72, 0x60, 0xba, 0x4f, + 0x6c, 0x87, 0x89, 0x7c, 0xcb, 0x27, 0xdd, 0x40, 0x9b, 0xe7, 0xf2, 0xdd, 0x3e, 0xbd, 0x06, 0x39, + 0x39, 0x23, 0x4d, 0x9d, 0x31, 0xe6, 0x7a, 0x86, 0xf4, 0x14, 0xe1, 0x23, 0x48, 0x30, 0x96, 0x01, + 0xa3, 0x4b, 0x30, 0x13, 0xfa, 0xd8, 0x1c, 0x58, 0x6e, 0x6f, 0x97, 0x84, 0x7d, 0xaf, 0xab, 0x9d, + 0xe3, 0x92, 0xc8, 0x40, 0x91, 0x09, 0x88, 0xb8, 0xb8, 0x63, 0x93, 0xae, 0xb0, 0xc5, 0xfb, 0x87, + 0x94, 0x04, 0xda, 0x02, 0x3f, 0xc5, 0xdb, 0x2d, 0x25, 0xf6, 0x65, 0x02, 0x44, 0xeb, 0xda, 0xc8, + 0xaa, 0x6b, 0x6e, 0xe8, 0x1f, 0x1a, 0x39, 0xe4, 0xd0, 0x00, 0x1a, 0xec, 0x1c, 0x91, 0x29, 0x2c, + 0x72, 0x53, 0xb8, 0x71, 0x3a, 0x19, 0xed, 0x24, 0x04, 0x0d, 0x95, 0x3a, 0x6a, 0x01, 0xea, 0xe3, + 0x60, 0x77, 0x68, 0x87, 0x16, 0xb5, 0x89, 0x60, 0x23, 0xd0, 0x96, 0xb8, 0x98, 0x72, 0xbe, 0xa0, + 0x5b, 0x00, 0x3e, 0xd9, 0x8f, 0xf0, 0xce, 0xf3, 0x93, 0xbf, 0x31, 0xee, 0xe4, 0x46, 0x8c, 0x2d, + 0x4e, 0xac, 0x2c, 0x47, 0x1d, 0x38, 0xa7, 0x70, 0xbb, 0x4b, 0x42, 0xdc, 0xc5, 0x21, 0xd6, 0x34, + 0x7e, 0xe2, 0x6f, 0xb4, 0xc4, 0x4d, 0xd0, 0x52, 0x6f, 0x82, 0xe4, 0x98, 0xec, 0x26, 0x68, 0x1d, + 0xac, 0xb7, 0xee, 0x76, 0x1e, 0x11, 0x33, 0x64, 0x6b, 0x8d, 0x3c, 0x62, 0xec, 0x80, 0x4c, 0x54, + 0xc4, 0x0c, 0x65, 0x44, 0xe1, 0xa1, 0xe3, 0x02, 0x37, 0xe3, 0x9c, 0x2f, 0xcc, 0xde, 0x25, 0x94, + 0x07, 0xc6, 0xa6, 0xf0, 0x08, 0x05, 0xd4, 0xbc, 0x06, 0xe7, 0x8f, 0x50, 0x27, 0x9a, 0x83, 0xd2, + 0x80, 0x1c, 0xf2, 0x6b, 0xa0, 0x6e, 0xb0, 0x21, 0x5a, 0x80, 0xca, 0x01, 0xb6, 0x87, 0x84, 0x07, + 0xee, 0x9a, 0x21, 0x26, 0x97, 0x8b, 0x1f, 0x14, 0x9a, 0x3f, 0x2b, 0xc0, 0x6c, 0x46, 0x38, 0x39, + 0xeb, 0xbf, 0xaf, 0xae, 0x7f, 0x0e, 0xae, 0xb2, 0x7f, 0x1f, 0xfb, 0x3d, 0x12, 0x2a, 0x8c, 0xe8, + 0x7f, 0x2b, 0x80, 0x96, 0xd1, 0xda, 0x77, 0xad, 0xb0, 0x7f, 0xdd, 0xb2, 0x49, 0x80, 0xde, 0x87, + 0x49, 0x5f, 0xc0, 0xe4, 0xe5, 0xf6, 0xd2, 0x18, 0x65, 0xef, 0x4c, 0x18, 0x11, 0x36, 0xfa, 0x08, + 0x6a, 0x4e, 0xa4, 0x50, 0xc1, 0xfb, 0x4a, 0xde, 0x4a, 0xb6, 0x4b, 0xa4, 0xab, 0x9d, 0x09, 0x23, + 0x5e, 0x83, 0xde, 0x85, 0x8a, 0xd9, 0x1f, 0xba, 0x03, 0x7e, 0xad, 0x35, 0x36, 0x2e, 0x1e, 0xb5, + 0x78, 0x8b, 0x21, 0xed, 0x4c, 0x18, 0x02, 0xfb, 0xe3, 0x2a, 0x94, 0x29, 0xf6, 0x43, 0xfd, 0x3a, + 0x2c, 0xe4, 0x6d, 0xc1, 0xee, 0x52, 0xb3, 0x4f, 0xcc, 0x41, 0x30, 0x74, 0xa4, 0x98, 0xe3, 0x39, + 0x42, 0x50, 0x0e, 0xac, 0xa7, 0x42, 0xd4, 0x25, 0x83, 0x8f, 0xf5, 0xd7, 0x61, 0x7e, 0x64, 0x37, + 0xa6, 0x54, 0xc1, 0x1b, 0xa3, 0x30, 0x25, 0xb7, 0xd6, 0x87, 0xb0, 0x78, 0x9f, 0xcb, 0x22, 0xbe, + 0x50, 0xce, 0x22, 0x3b, 0xd0, 0x77, 0x60, 0x29, 0xbb, 0x6d, 0x40, 0x3d, 0x37, 0x20, 0xcc, 0xf4, + 0x79, 0x04, 0xb6, 0x48, 0x37, 0xf9, 0xca, 0xb9, 0xa8, 0x19, 0x39, 0x5f, 0xf4, 0xdf, 0x16, 0x61, + 0xc9, 0x20, 0x81, 0x67, 0x1f, 0x90, 0x28, 0x3c, 0x9e, 0x4d, 0x82, 0xf3, 0x3d, 0x28, 0x61, 0x4a, + 0xa5, 0x99, 0xdc, 0x78, 0x6e, 0x29, 0x84, 0xc1, 0xa8, 0xa2, 0x37, 0x61, 0x1e, 0x3b, 0x1d, 0xab, + 0x37, 0xf4, 0x86, 0x41, 0x74, 0x2c, 0x6e, 0x54, 0x75, 0x63, 0xf4, 0x03, 0x73, 0xff, 0x80, 0x7b, + 0xe4, 0x0d, 0xb7, 0x4b, 0xbe, 0xe0, 0x59, 0x53, 0xc9, 0x50, 0x41, 0xba, 0x09, 0xe7, 0x47, 0x84, + 0x24, 0x05, 0xae, 0x26, 0x6a, 0x85, 0x4c, 0xa2, 0x96, 0xcb, 0x46, 0xf1, 0x08, 0x36, 0xf4, 0x1f, + 0x17, 0xa0, 0x16, 0xd9, 0x1d, 0x5a, 0x83, 0x39, 0xd3, 0x73, 0xa8, 0x65, 0x93, 0x6e, 0x04, 0x93, + 0xe4, 0x47, 0xe0, 0x8c, 0x7f, 0x1f, 0x3f, 0x89, 0xd1, 0xc4, 0x06, 0x2a, 0x88, 0x59, 0x39, 0xc5, + 0x61, 0x5f, 0x8a, 0x80, 0x8f, 0x19, 0xcc, 0xb6, 0x5c, 0xc2, 0x8f, 0x5b, 0x31, 0xf8, 0x58, 0xff, + 0x1c, 0xa6, 0xae, 0x12, 0x4a, 0xdc, 0x2e, 0x71, 0x4d, 0x8b, 0x04, 0x1c, 0xc7, 0x33, 0x07, 0x72, + 0x67, 0x3e, 0x66, 0xb0, 0x2e, 0xa1, 0x81, 0xdc, 0x86, 0x8f, 0x91, 0x0e, 0x53, 0x2c, 0x06, 0x58, + 0x3e, 0x4f, 0x76, 0x02, 0xb9, 0x4f, 0x0a, 0xa6, 0x07, 0x70, 0x4e, 0xd1, 0x53, 0x9c, 0x49, 0x2c, + 0x03, 0x60, 0x4a, 0xa3, 0x64, 0x44, 0x6c, 0xa4, 0x40, 0xd0, 0x15, 0x98, 0xea, 0x2a, 0x2c, 0x49, + 0x83, 0xd1, 0xd4, 0xd0, 0xa0, 0xb2, 0x6c, 0xa4, 0xb0, 0xf5, 0x9f, 0x97, 0x61, 0x2e, 0x09, 0x58, + 0x52, 0x65, 0x1b, 0x50, 0x77, 0x24, 0x2c, 0xd0, 0x0a, 0xfc, 0x3a, 0x5b, 0xc8, 0x8d, 0x70, 0x09, + 0x5a, 0x3a, 0x3b, 0x2e, 0x66, 0xb3, 0xe3, 0x25, 0xa8, 0x8a, 0xb2, 0x48, 0x9e, 0x5c, 0xce, 0x52, 0xc6, 0x51, 0xce, 0x18, 0xc7, 0x32, 0x40, 0x10, 0xdf, 0x25, 0x5a, 0x55, 0x1c, 0x3c, 0x81, 0x30, - 0x99, 0x8a, 0x5c, 0xca, 0x20, 0xc1, 0xd0, 0x0e, 0xb5, 0x49, 0x21, 0x53, 0x15, 0x86, 0x5e, 0x87, - 0x69, 0xd3, 0x73, 0x1c, 0x2b, 0xdc, 0x25, 0x41, 0x80, 0x7b, 0x51, 0xde, 0x9e, 0x06, 0x32, 0x4c, - 0x02, 0xb0, 0x39, 0x0c, 0xfb, 0x9e, 0xaf, 0xd5, 0x05, 0x26, 0x15, 0x86, 0x6e, 0x01, 0x88, 0xf9, - 0x35, 0x1c, 0x46, 0x89, 0xfd, 0xda, 0xc9, 0x6e, 0xe3, 0x07, 0x96, 0x43, 0x0c, 0x65, 0x37, 0xfa, - 0x34, 0x75, 0xc5, 0xc7, 0x69, 0x64, 0x83, 0x23, 0xfd, 0x86, 0x2a, 0xe9, 0x1c, 0x83, 0x30, 0xf2, - 0xf6, 0xea, 0x1e, 0xcc, 0xde, 0xb1, 0x98, 0x0a, 0xf7, 0x83, 0xb3, 0x89, 0xb0, 0x1f, 0x40, 0x99, - 0x11, 0x63, 0x1a, 0xec, 0xf8, 0xd8, 0x35, 0xfb, 0x44, 0x98, 0x4a, 0xdd, 0x88, 0xe7, 0xcc, 0x13, - 0x42, 0xdc, 0x63, 0x26, 0xc9, 0xe0, 0x7c, 0xac, 0xff, 0xa1, 0x28, 0x38, 0xdd, 0xa4, 0x34, 0xf8, - 0xfa, 0x2b, 0xc5, 0xfc, 0xdc, 0xb5, 0x34, 0x9a, 0xbb, 0x66, 0x58, 0xfe, 0x2a, 0xb9, 0xeb, 0x0b, - 0xca, 0x8d, 0xf4, 0x21, 0x4c, 0x6e, 0x52, 0xca, 0x18, 0x41, 0xeb, 0x50, 0xc6, 0x94, 0x46, 0xbe, - 0x79, 0x31, 0x63, 0x31, 0x6c, 0x09, 0xfb, 0x2f, 0x59, 0xe2, 0x4b, 0x9b, 0x97, 0xa1, 0x1e, 0x83, - 0x8e, 0x23, 0x5b, 0x57, 0xc9, 0xae, 0x00, 0x88, 0xe2, 0xec, 0xa6, 0xbb, 0xef, 0x31, 0x95, 0x32, - 0xaf, 0x8e, 0x02, 0x1e, 0x1b, 0xeb, 0x57, 0xa2, 0x15, 0x9c, 0xb7, 0xb7, 0xa1, 0x62, 0x85, 0xc4, - 0x89, 0x98, 0x5b, 0x52, 0x99, 0x4b, 0x10, 0x19, 0x62, 0x91, 0xfe, 0xa7, 0x1a, 0x5c, 0x60, 0x1a, - 0xbb, 0xcf, 0xe3, 0xc1, 0x26, 0xa5, 0xd7, 0x48, 0x88, 0x2d, 0x3b, 0xf8, 0x74, 0x48, 0xfc, 0xc3, - 0x97, 0x6c, 0x18, 0x3d, 0xa8, 0x8a, 0x70, 0x22, 0x63, 0xe6, 0x0b, 0xaf, 0xd3, 0x25, 0xfa, 0xa4, - 0x38, 0x2f, 0xbd, 0x9c, 0xe2, 0x3c, 0xaf, 0x58, 0x2e, 0x9f, 0x51, 0xb1, 0x7c, 0x74, 0xbf, 0x44, - 0xe9, 0xc2, 0x54, 0xd3, 0x5d, 0x98, 0x9c, 0x1a, 0x74, 0xf2, 0xa4, 0x35, 0x68, 0x2d, 0xb7, 0x06, - 0x75, 0x72, 0xfd, 0xb8, 0xce, 0xc5, 0xfd, 0x1d, 0xd5, 0x02, 0x8f, 0xb4, 0xb5, 0xd3, 0x54, 0xa3, - 0xf0, 0x52, 0xab, 0xd1, 0xcf, 0x52, 0xd5, 0xa5, 0xe8, 0xef, 0xbc, 0x7f, 0xb2, 0x33, 0x8d, 0xa9, - 0x33, 0xff, 0xef, 0x2a, 0xb6, 0x9f, 0xf3, 0x44, 0x9d, 0x7a, 0x89, 0x0c, 0xe2, 0x7c, 0x86, 0xdd, - 0x43, 0x2c, 0x87, 0x90, 0x41, 0x8b, 0x8d, 0xd1, 0x5b, 0x50, 0x66, 0x42, 0x96, 0x95, 0xd4, 0x79, - 0x55, 0x9e, 0x4c, 0x13, 0x9b, 0x94, 0xde, 0xa7, 0xc4, 0x34, 0xf8, 0x22, 0x74, 0x05, 0xea, 0xb1, - 0xe1, 0x4b, 0xcf, 0x7a, 0x55, 0xdd, 0x11, 0xfb, 0x49, 0xb4, 0x2d, 0x59, 0xce, 0xf6, 0x76, 0x2d, - 0x9f, 0x98, 0xbc, 0xce, 0xa8, 0x8c, 0xee, 0xbd, 0x16, 0x7d, 0x8c, 0xf7, 0xc6, 0xcb, 0xd1, 0x3a, - 0x54, 0x45, 0x43, 0x8c, 0x7b, 0x50, 0x63, 0xe3, 0xc2, 0x68, 0x30, 0x8d, 0x76, 0xc9, 0x85, 0xfa, - 0x97, 0x05, 0x78, 0x2d, 0x31, 0x88, 0xc8, 0x9b, 0xa2, 0x52, 0xef, 0xeb, 0xbf, 0x71, 0x2f, 0xc1, - 0x0c, 0xaf, 0x2d, 0x93, 0xbe, 0x98, 0x68, 0xd1, 0x66, 0xa0, 0xfa, 0xef, 0x0b, 0xf0, 0xc6, 0xe8, - 0x39, 0xb6, 0xfa, 0xd8, 0x0f, 0x63, 0xf5, 0x9e, 0xc5, 0x59, 0xa2, 0x0b, 0xaf, 0x98, 0x5c, 0x78, - 0xa9, 0xf3, 0x95, 0xd2, 0xe7, 0xd3, 0xff, 0x58, 0x84, 0x86, 0x62, 0x40, 0x79, 0x17, 0x26, 0xcb, - 0x6c, 0xb9, 0xdd, 0xf2, 0x6e, 0x02, 0xbf, 0x14, 0xea, 0x86, 0x02, 0x41, 0x03, 0x00, 0x8a, 0x7d, - 0xec, 0x90, 0x90, 0xf8, 0x2c, 0x92, 0x33, 0x8f, 0xbf, 0x7d, 0xfa, 0xe8, 0xb2, 0x17, 0xe1, 0x34, - 0x14, 0xf4, 0x2c, 0x35, 0xe7, 0xa4, 0x03, 0x19, 0xbf, 0xe5, 0x0c, 0x3d, 0x85, 0x99, 0x7d, 0xcb, - 0x26, 0x7b, 0x09, 0x23, 0x55, 0xce, 0xc8, 0xbd, 0xd3, 0x33, 0x72, 0x43, 0xc5, 0x6b, 0x64, 0xc8, - 0xe8, 0x6b, 0x30, 0x97, 0xf5, 0x27, 0xc6, 0xa4, 0xe5, 0xe0, 0x5e, 0x2c, 0x2d, 0x39, 0xd3, 0x11, - 0xcc, 0x65, 0xfd, 0x47, 0xff, 0x67, 0x11, 0x16, 0x63, 0x74, 0x9b, 0xae, 0xeb, 0x0d, 0x5d, 0x93, - 0x97, 0x58, 0xb9, 0xba, 0x58, 0x80, 0x4a, 0x68, 0x85, 0x76, 0x9c, 0xf8, 0xf0, 0x09, 0xbb, 0xbb, - 0x42, 0xcf, 0xb3, 0x43, 0x8b, 0x4a, 0x05, 0x47, 0x53, 0xa1, 0x7b, 0x5e, 0xb5, 0x75, 0x79, 0x24, - 0xa8, 0x19, 0xf1, 0x9c, 0x7d, 0x63, 0x59, 0x0d, 0xaf, 0x57, 0x84, 0x30, 0xe3, 0x39, 0xb7, 0x7b, - 0xcf, 0xb6, 0x89, 0xc9, 0xc4, 0xa1, 0x54, 0x34, 0x19, 0x28, 0xaf, 0x94, 0x42, 0xdf, 0x72, 0x7b, - 0xb2, 0x9e, 0x91, 0x33, 0xc6, 0x27, 0xf6, 0x7d, 0x7c, 0xa8, 0xd5, 0xb8, 0x00, 0xc4, 0x04, 0x5d, - 0x85, 0x92, 0x83, 0xa9, 0xbc, 0xe8, 0xd6, 0x52, 0xd1, 0x21, 0x4f, 0x02, 0xad, 0x5d, 0x4c, 0xc5, - 0x4d, 0xc0, 0xb6, 0x35, 0x3f, 0x60, 0xf5, 0x34, 0xfd, 0xea, 0x29, 0xe1, 0x63, 0x98, 0x4e, 0x05, - 0x1f, 0xf4, 0x10, 0x96, 0x12, 0x8b, 0x52, 0x09, 0xca, 0x24, 0xf0, 0xb5, 0x63, 0x39, 0x33, 0x8e, - 0x40, 0xa0, 0x3f, 0x81, 0x79, 0x66, 0x32, 0xdc, 0xf1, 0xcf, 0xa8, 0xb4, 0xf9, 0x08, 0xea, 0x31, - 0xc9, 0x5c, 0x9b, 0x69, 0x42, 0xed, 0x20, 0x2a, 0xda, 0x44, 0x6d, 0x13, 0xcf, 0xf5, 0x4d, 0x40, - 0x2a, 0xbf, 0xf2, 0x06, 0x7a, 0x2b, 0x9d, 0x14, 0x2f, 0x66, 0xaf, 0x1b, 0xbe, 0x3c, 0xca, 0x89, - 0xff, 0x5e, 0x84, 0xd9, 0x6d, 0x8b, 0xb7, 0xd6, 0xce, 0x28, 0xc8, 0xad, 0xc1, 0x5c, 0x30, 0xec, - 0x38, 0x5e, 0x77, 0x68, 0x13, 0x99, 0x14, 0xc8, 0x9b, 0x7e, 0x04, 0x3e, 0x2e, 0xf8, 0xc5, 0x6d, - 0x94, 0xb2, 0xd2, 0x46, 0xb9, 0x0a, 0x17, 0xee, 0x92, 0xa7, 0xf2, 0x3c, 0xdb, 0xb6, 0xd7, 0xe9, - 0x58, 0x6e, 0x2f, 0x22, 0x52, 0xe1, 0x44, 0x8e, 0x5e, 0x90, 0x97, 0x2a, 0x56, 0xf3, 0x53, 0xc5, - 0xb8, 0x1d, 0xb0, 0xc5, 0x0b, 0x6d, 0x99, 0x51, 0xa6, 0x60, 0xfa, 0xcf, 0x0a, 0x30, 0x97, 0x48, - 0x56, 0xea, 0xe6, 0xb2, 0xf0, 0x21, 0xa1, 0x99, 0x37, 0x54, 0xcd, 0x64, 0x97, 0xfe, 0xe7, 0xee, - 0x33, 0xa5, 0xba, 0xcf, 0x2f, 0x8b, 0xb0, 0xb8, 0x6d, 0x85, 0x51, 0xe0, 0xb2, 0xfe, 0xd7, 0xb4, - 0x9c, 0xa3, 0x93, 0xf2, 0xc9, 0x74, 0x52, 0xc9, 0xd1, 0x49, 0x0b, 0x96, 0xb2, 0xc2, 0x90, 0x8a, - 0x59, 0x80, 0x0a, 0xb3, 0xa0, 0xa8, 0xaf, 0x20, 0x26, 0xfa, 0x3f, 0xaa, 0x70, 0xf1, 0x33, 0xda, - 0xc5, 0x61, 0xdc, 0x6a, 0xbc, 0xe1, 0xf9, 0x7b, 0xec, 0xd3, 0xd9, 0x48, 0x31, 0xf3, 0x84, 0x5c, - 0x1c, 0xfb, 0x84, 0x5c, 0x1a, 0xf3, 0x84, 0x5c, 0x3e, 0xd1, 0x13, 0x72, 0xe5, 0xcc, 0x9e, 0x90, - 0x47, 0x6b, 0xad, 0x6a, 0x6e, 0xad, 0xf5, 0x30, 0x55, 0x8f, 0x4c, 0x72, 0xb7, 0xf9, 0xb6, 0xea, - 0x36, 0x63, 0xb5, 0x33, 0xf6, 0xed, 0x2b, 0xf3, 0xf2, 0x5a, 0x3b, 0xf6, 0xe5, 0xb5, 0x3e, 0xfa, - 0xf2, 0x9a, 0xff, 0x78, 0x07, 0x47, 0x3e, 0xde, 0x5d, 0x82, 0x99, 0xe0, 0xd0, 0x35, 0x49, 0x37, - 0x6e, 0x40, 0x37, 0xc4, 0xb1, 0xd3, 0xd0, 0x94, 0x47, 0x4c, 0x65, 0x3c, 0x22, 0xb6, 0xd4, 0x69, - 0xc5, 0x52, 0xf3, 0xfc, 0x64, 0x26, 0xd7, 0x4f, 0xfe, 0x7b, 0x8a, 0xa8, 0xcf, 0x61, 0xf9, 0x28, - 0xed, 0x49, 0xa7, 0xd4, 0x60, 0xd2, 0xec, 0x63, 0xb7, 0xc7, 0xdb, 0x7d, 0xbc, 0xaa, 0x97, 0xd3, - 0x71, 0x59, 0xbf, 0xfe, 0xeb, 0x22, 0x2c, 0x6e, 0xf1, 0x75, 0xd9, 0x47, 0x14, 0xc5, 0x59, 0x0a, - 0x63, 0x9c, 0x65, 0xa4, 0xa3, 0xbc, 0x0a, 0xb3, 0xe6, 0xd0, 0xf7, 0x59, 0xea, 0x90, 0x8e, 0x53, - 0x59, 0x30, 0x0b, 0x7b, 0x94, 0x31, 0xa2, 0xbe, 0x31, 0x08, 0xdf, 0x1b, 0x81, 0x27, 0x8a, 0xac, - 0xa8, 0x8a, 0x8c, 0x02, 0x4a, 0xf5, 0xa5, 0xa4, 0x1b, 0xef, 0xc1, 0x52, 0x56, 0x34, 0xc7, 0x3f, - 0x9d, 0x6c, 0xfc, 0xb6, 0x01, 0xf3, 0x49, 0x7d, 0xc4, 0xfe, 0x5a, 0x26, 0x41, 0xf7, 0x60, 0x6e, - 0x5b, 0xfe, 0x6e, 0x27, 0x7e, 0xdb, 0x18, 0xf7, 0x38, 0xd9, 0x7c, 0x35, 0xff, 0xa3, 0x60, 0x40, - 0x9f, 0x40, 0x26, 0x5c, 0xc8, 0x22, 0x4c, 0xde, 0x41, 0x5f, 0x1f, 0x83, 0x39, 0x5e, 0x75, 0x1c, - 0x89, 0xd5, 0x02, 0x7a, 0x08, 0x33, 0xe9, 0xd7, 0x3a, 0x94, 0x4a, 0x18, 0x73, 0x1f, 0x10, 0x9b, - 0xfa, 0xb8, 0x25, 0x31, 0xff, 0x8f, 0x98, 0x63, 0xa5, 0x1e, 0xa6, 0x90, 0x9e, 0xee, 0x9d, 0xe4, - 0x3d, 0xed, 0x35, 0xbf, 0x39, 0x76, 0x4d, 0x8c, 0xfd, 0x23, 0xa8, 0x45, 0x5d, 0xf7, 0xb4, 0x98, - 0x33, 0xbd, 0xf8, 0xe6, 0x5c, 0x1a, 0xdf, 0x7e, 0xa0, 0x4f, 0xa0, 0x8f, 0xc5, 0xe6, 0x4d, 0x4a, - 0x73, 0x36, 0x2b, 0xbd, 0xe6, 0xe6, 0xb9, 0x9c, 0xfe, 0xae, 0x3e, 0x81, 0xbe, 0x0b, 0x0d, 0x36, - 0xda, 0x93, 0xbf, 0x98, 0x59, 0x6a, 0x89, 0x1f, 0x68, 0xb5, 0xa2, 0x1f, 0x68, 0xb5, 0xae, 0x3b, - 0x34, 0x3c, 0x6c, 0xe6, 0x34, 0x60, 0x25, 0x82, 0x47, 0x30, 0xbd, 0x4d, 0xc2, 0xa4, 0x5f, 0x82, - 0xde, 0x38, 0x51, 0x57, 0xa9, 0xa9, 0x67, 0x97, 0x8d, 0xb6, 0x5c, 0xf4, 0x09, 0xf4, 0xab, 0x02, - 0x9c, 0xdb, 0x26, 0x61, 0xb6, 0x03, 0x81, 0xde, 0xc9, 0x27, 0x72, 0x44, 0xa7, 0xa2, 0x79, 0xf7, - 0xb4, 0xde, 0x96, 0x46, 0xab, 0x4f, 0xa0, 0xdf, 0x14, 0xe0, 0xbc, 0xc2, 0x98, 0xda, 0x52, 0x40, - 0xeb, 0xe3, 0x99, 0xcb, 0x69, 0x3f, 0x34, 0x6f, 0x9d, 0xf2, 0x87, 0x50, 0x0a, 0x4a, 0x7d, 0x02, - 0xed, 0x71, 0x9d, 0x24, 0x15, 0x04, 0xba, 0x98, 0x5b, 0x2a, 0xc4, 0xd4, 0x97, 0x8f, 0xfa, 0x1c, - 0xeb, 0xe1, 0x16, 0x34, 0xb6, 0x49, 0x18, 0xa5, 0xb2, 0x69, 0x4b, 0xcb, 0x54, 0x19, 0x69, 0x57, - 0xcd, 0x66, 0xbf, 0xdc, 0x62, 0xe6, 0x05, 0x2e, 0x25, 0x5d, 0x4b, 0xfb, 0x6a, 0x6e, 0x5e, 0x9b, - 0xb6, 0x98, 0xfc, 0x6c, 0x4f, 0x9f, 0x40, 0x4f, 0x60, 0x29, 0xff, 0xf2, 0x41, 0x6f, 0x9e, 0x38, - 0xbd, 0x68, 0xae, 0x9d, 0x64, 0x69, 0xe6, 0x40, 0xe9, 0xf0, 0x9b, 0x3e, 0x50, 0xee, 0xad, 0x95, - 0x3e, 0x50, 0x7e, 0xf4, 0xd6, 0x27, 0x3e, 0xd9, 0xfc, 0xf3, 0xf3, 0xe5, 0xc2, 0x5f, 0x9f, 0x2f, - 0x17, 0xfe, 0xf5, 0x7c, 0xb9, 0xf0, 0xc5, 0xbb, 0xc7, 0xfc, 0x1c, 0x53, 0xf9, 0xed, 0x28, 0xa6, - 0x96, 0x69, 0x5b, 0xc4, 0x0d, 0x3b, 0x55, 0xee, 0xcd, 0xef, 0xfe, 0x3b, 0x00, 0x00, 0xff, 0xff, - 0xb7, 0x12, 0x5d, 0x05, 0x5a, 0x2a, 0x00, 0x00, + 0x99, 0x8a, 0x5c, 0xca, 0x20, 0xc1, 0xd0, 0x0e, 0xb5, 0x49, 0x21, 0x53, 0x15, 0x86, 0x5e, 0x85, + 0x69, 0xd3, 0x73, 0x1c, 0x2b, 0xdc, 0x25, 0x41, 0x80, 0x7b, 0x51, 0xde, 0x9e, 0x06, 0x32, 0x4a, + 0x02, 0xb0, 0x39, 0x0c, 0xfb, 0x9e, 0xaf, 0xd5, 0x05, 0x25, 0x15, 0x86, 0x6e, 0x02, 0x88, 0xf9, + 0x55, 0x1c, 0x46, 0x89, 0xfd, 0xda, 0xc9, 0x6e, 0xe3, 0xfb, 0x96, 0x43, 0x0c, 0x65, 0x35, 0xfa, + 0x24, 0x75, 0xc5, 0xc7, 0x69, 0x64, 0x83, 0x13, 0xfd, 0x9a, 0x2a, 0xe9, 0x1c, 0x83, 0x30, 0xf2, + 0xd6, 0xa2, 0xef, 0xc0, 0x4b, 0x42, 0x34, 0x41, 0xa4, 0x9c, 0xe0, 0x5e, 0x88, 0xfd, 0xd0, 0x72, + 0x7b, 0x37, 0xba, 0x5f, 0xf0, 0x9c, 0xbd, 0x62, 0x8c, 0x43, 0xd1, 0x3d, 0x98, 0xbd, 0x6d, 0x31, + 0x23, 0xd8, 0x0f, 0xce, 0x26, 0x46, 0xbf, 0x07, 0x65, 0xb6, 0x19, 0xb3, 0x81, 0x8e, 0x8f, 0x5d, + 0xb3, 0x4f, 0x84, 0xb1, 0xd5, 0x8d, 0x78, 0xce, 0x7c, 0x29, 0xc4, 0x3d, 0x66, 0xd4, 0x0c, 0xce, + 0xc7, 0xfa, 0xef, 0x8b, 0x82, 0xd3, 0x4d, 0x4a, 0x83, 0xaf, 0xbe, 0xd6, 0xcc, 0xcf, 0x7e, 0x4b, + 0xa3, 0xd9, 0x6f, 0x86, 0xe5, 0x2f, 0x93, 0xfd, 0x3e, 0xa7, 0xec, 0x4a, 0x1f, 0xc2, 0xe4, 0x26, + 0xa5, 0x8c, 0x11, 0xb4, 0x0e, 0x65, 0x4c, 0x69, 0xe4, 0xdd, 0x17, 0x33, 0x36, 0xc7, 0x50, 0xd8, + 0x7f, 0xc9, 0x12, 0x47, 0x6d, 0xbe, 0x0f, 0xf5, 0x18, 0x74, 0xdc, 0xb6, 0x75, 0x75, 0xdb, 0x15, + 0x00, 0x51, 0xde, 0xdd, 0x70, 0xf7, 0x3d, 0xa6, 0x52, 0x16, 0x17, 0xa2, 0x90, 0xc9, 0xc6, 0xfa, + 0xe5, 0x08, 0x83, 0xf3, 0xf6, 0x26, 0x54, 0xac, 0x90, 0x38, 0x11, 0x73, 0x4b, 0x2a, 0x73, 0x09, + 0x21, 0x43, 0x20, 0xe9, 0x7f, 0xaa, 0xc1, 0x05, 0xa6, 0xb1, 0x7b, 0x3c, 0xa2, 0x6c, 0x52, 0x7a, + 0x95, 0x84, 0xd8, 0xb2, 0x83, 0x4f, 0x86, 0xc4, 0x3f, 0x7c, 0xc1, 0x86, 0xd1, 0x83, 0xaa, 0x70, + 0x29, 0x19, 0x75, 0x9f, 0x7b, 0xa5, 0x2f, 0xc9, 0x27, 0xe5, 0x7d, 0xe9, 0xc5, 0x94, 0xf7, 0x79, + 0xe5, 0x76, 0xf9, 0x8c, 0xca, 0xed, 0xa3, 0x3b, 0x2e, 0x4a, 0x1f, 0xa7, 0x9a, 0xee, 0xe3, 0xe4, + 0x54, 0xb1, 0x93, 0x27, 0xad, 0x62, 0x6b, 0xb9, 0x55, 0xac, 0x93, 0xeb, 0xc7, 0x75, 0x2e, 0xee, + 0x6f, 0xa9, 0x16, 0x78, 0xa4, 0xad, 0x9d, 0xa6, 0x9e, 0x85, 0x17, 0x5a, 0xcf, 0x7e, 0x9a, 0xaa, + 0x4f, 0x45, 0x87, 0xe8, 0xdd, 0x93, 0x9d, 0x69, 0x4c, 0xa5, 0xfa, 0x7f, 0x57, 0xf3, 0xfd, 0x94, + 0xa7, 0xfa, 0xd4, 0x4b, 0x64, 0x10, 0x67, 0x44, 0xec, 0x1e, 0x62, 0x59, 0x88, 0x0c, 0x5a, 0x6c, + 0x8c, 0xde, 0x80, 0x32, 0x13, 0xb2, 0xac, 0xc5, 0xce, 0xab, 0xf2, 0x64, 0x9a, 0xd8, 0xa4, 0xf4, + 0x1e, 0x25, 0xa6, 0xc1, 0x91, 0xd0, 0x65, 0xa8, 0xc7, 0x86, 0x2f, 0x3d, 0xeb, 0x65, 0x75, 0x45, + 0xec, 0x27, 0xd1, 0xb2, 0x04, 0x9d, 0xad, 0xed, 0x5a, 0x3e, 0x31, 0x79, 0xa5, 0x52, 0x19, 0x5d, + 0x7b, 0x35, 0xfa, 0x18, 0xaf, 0x8d, 0xd1, 0xd1, 0x3a, 0x54, 0x45, 0x4b, 0x8d, 0x7b, 0x50, 0x63, + 0xe3, 0xc2, 0x68, 0x30, 0x8d, 0x56, 0x49, 0x44, 0xfd, 0x8f, 0x05, 0x78, 0x25, 0x31, 0x88, 0xc8, + 0x9b, 0xa2, 0x62, 0xf1, 0xab, 0xbf, 0x71, 0x2f, 0xc1, 0x0c, 0xaf, 0x4e, 0x93, 0xce, 0x9a, 0x68, + 0xf2, 0x66, 0xa0, 0xfa, 0xef, 0x0a, 0xf0, 0xda, 0xe8, 0x39, 0xb6, 0xfa, 0xd8, 0x0f, 0x63, 0xf5, + 0x9e, 0xc5, 0x59, 0xa2, 0x0b, 0xaf, 0x98, 0x5c, 0x78, 0xa9, 0xf3, 0x95, 0xd2, 0xe7, 0xd3, 0xff, + 0x50, 0x84, 0x86, 0x62, 0x40, 0x79, 0x17, 0x26, 0xcb, 0x8d, 0xb9, 0xdd, 0xf2, 0x7e, 0x04, 0xbf, + 0x14, 0xea, 0x86, 0x02, 0x41, 0x03, 0x00, 0x8a, 0x7d, 0xec, 0x90, 0x90, 0xf8, 0x2c, 0x92, 0x33, + 0x8f, 0xbf, 0x75, 0xfa, 0xe8, 0xb2, 0x17, 0xd1, 0x34, 0x14, 0xf2, 0x2c, 0xb9, 0xe7, 0x5b, 0x07, + 0x32, 0x7e, 0xcb, 0x19, 0x7a, 0x02, 0x33, 0xfb, 0x96, 0x4d, 0xf6, 0x12, 0x46, 0xaa, 0x9c, 0x91, + 0xbb, 0xa7, 0x67, 0xe4, 0xba, 0x4a, 0xd7, 0xc8, 0x6c, 0xa3, 0xaf, 0xc1, 0x5c, 0xd6, 0x9f, 0x18, + 0x93, 0x96, 0x83, 0x7b, 0xb1, 0xb4, 0xe4, 0x4c, 0x47, 0x30, 0x97, 0xf5, 0x1f, 0xfd, 0x9f, 0x45, + 0x58, 0x8c, 0xc9, 0x6d, 0xba, 0xae, 0x37, 0x74, 0x4d, 0x5e, 0xa4, 0xe5, 0xea, 0x62, 0x01, 0x2a, + 0xa1, 0x15, 0xda, 0x71, 0xe2, 0xc3, 0x27, 0xec, 0xee, 0x0a, 0x3d, 0xcf, 0x0e, 0x2d, 0x2a, 0x15, + 0x1c, 0x4d, 0x85, 0xee, 0x79, 0xdd, 0xd7, 0xe5, 0x91, 0xa0, 0x66, 0xc4, 0x73, 0xf6, 0x8d, 0x65, + 0x35, 0xbc, 0xe2, 0x11, 0xc2, 0x8c, 0xe7, 0xdc, 0xee, 0x3d, 0xdb, 0x26, 0x26, 0x13, 0x87, 0x52, + 0x13, 0x65, 0xa0, 0xbc, 0xd6, 0x0a, 0x7d, 0xcb, 0xed, 0xc9, 0x8a, 0x48, 0xce, 0x18, 0x9f, 0xd8, + 0xf7, 0xf1, 0xa1, 0x56, 0xe3, 0x02, 0x10, 0x13, 0x74, 0x05, 0x4a, 0x0e, 0xa6, 0xf2, 0xa2, 0x5b, + 0x4b, 0x45, 0x87, 0x3c, 0x09, 0xb4, 0x76, 0x31, 0x15, 0x37, 0x01, 0x5b, 0xd6, 0x7c, 0x8f, 0x55, + 0xe4, 0xf4, 0xcb, 0xa7, 0x84, 0x8f, 0x60, 0x3a, 0x15, 0x7c, 0xd0, 0x03, 0x58, 0x4a, 0x2c, 0x4a, + 0xdd, 0x50, 0x26, 0x81, 0xaf, 0x1c, 0xcb, 0x99, 0x71, 0x04, 0x01, 0xfd, 0x31, 0xcc, 0x33, 0x93, + 0xe1, 0x8e, 0x7f, 0x46, 0xa5, 0xcd, 0x87, 0x50, 0x8f, 0xb7, 0xcc, 0xb5, 0x99, 0x26, 0xd4, 0x0e, + 0xa2, 0xb2, 0x4f, 0xd4, 0x36, 0xf1, 0x5c, 0xdf, 0x04, 0xa4, 0xf2, 0x2b, 0x6f, 0xa0, 0x37, 0xd2, + 0x49, 0xf1, 0x62, 0xf6, 0xba, 0xe1, 0xe8, 0x51, 0x4e, 0xfc, 0xf7, 0x22, 0xcc, 0x6e, 0x5b, 0xbc, + 0x39, 0x77, 0x46, 0x41, 0x6e, 0x0d, 0xe6, 0x82, 0x61, 0xc7, 0xf1, 0xba, 0x43, 0x9b, 0xc8, 0xa4, + 0x40, 0xde, 0xf4, 0x23, 0xf0, 0x71, 0xc1, 0x2f, 0x6e, 0xc4, 0x94, 0x95, 0x46, 0xcc, 0x15, 0xb8, + 0x70, 0x87, 0x3c, 0x91, 0xe7, 0xd9, 0xb6, 0xbd, 0x4e, 0xc7, 0x72, 0x7b, 0xd1, 0x26, 0x15, 0xbe, + 0xc9, 0xd1, 0x08, 0x79, 0xa9, 0x62, 0x35, 0x3f, 0x55, 0x8c, 0x1b, 0x0a, 0x5b, 0xbc, 0x54, 0x97, + 0x19, 0x65, 0x0a, 0xa6, 0xff, 0xa4, 0x00, 0x73, 0x89, 0x64, 0xa5, 0x6e, 0xde, 0x17, 0x3e, 0x24, + 0x34, 0xf3, 0x9a, 0xaa, 0x99, 0x2c, 0xea, 0x7f, 0xee, 0x3e, 0x53, 0xaa, 0xfb, 0xfc, 0xa2, 0x08, + 0x8b, 0xdb, 0x56, 0x18, 0x05, 0x2e, 0xeb, 0x7f, 0x4d, 0xcb, 0x39, 0x3a, 0x29, 0x9f, 0x4c, 0x27, + 0x95, 0x1c, 0x9d, 0xb4, 0x60, 0x29, 0x2b, 0x0c, 0xa9, 0x98, 0x05, 0xa8, 0x30, 0x0b, 0x8a, 0xfa, + 0x0a, 0x62, 0xa2, 0xff, 0xa3, 0x0a, 0x17, 0x3f, 0xa5, 0x5d, 0x1c, 0xc6, 0xcd, 0xca, 0xeb, 0x9e, + 0xbf, 0xc7, 0x3e, 0x9d, 0x8d, 0x14, 0x33, 0x8f, 0xd0, 0xc5, 0xb1, 0x8f, 0xd0, 0xa5, 0x31, 0x8f, + 0xd0, 0xe5, 0x13, 0x3d, 0x42, 0x57, 0xce, 0xec, 0x11, 0x7a, 0xb4, 0xd6, 0xaa, 0xe6, 0xd6, 0x5a, + 0x0f, 0x52, 0xf5, 0xc8, 0x24, 0x77, 0x9b, 0x6f, 0xaa, 0x6e, 0x33, 0x56, 0x3b, 0x63, 0x5f, 0xcf, + 0x32, 0x6f, 0xb7, 0xb5, 0x63, 0xdf, 0x6e, 0xeb, 0xa3, 0x6f, 0xb7, 0xf9, 0xcf, 0x7f, 0x70, 0xe4, + 0xf3, 0xdf, 0x25, 0x98, 0x09, 0x0e, 0x5d, 0x93, 0x74, 0xe3, 0x16, 0x76, 0x43, 0x1c, 0x3b, 0x0d, + 0x4d, 0x79, 0xc4, 0x54, 0xc6, 0x23, 0x62, 0x4b, 0x9d, 0x56, 0x2c, 0x35, 0xcf, 0x4f, 0x66, 0x72, + 0xfd, 0xe4, 0xbf, 0xa7, 0x88, 0xfa, 0x0c, 0x96, 0x8f, 0xd2, 0x9e, 0x74, 0x4a, 0x0d, 0x26, 0xcd, + 0x3e, 0x76, 0x7b, 0xbc, 0xdd, 0xc7, 0xab, 0x7a, 0x39, 0x1d, 0x97, 0xf5, 0xeb, 0xbf, 0x2a, 0xc2, + 0xe2, 0x16, 0xc7, 0xcb, 0x3e, 0xc3, 0x28, 0xce, 0x52, 0x18, 0xe3, 0x2c, 0x23, 0x3d, 0xe9, 0x55, + 0x98, 0x35, 0x87, 0xbe, 0xcf, 0x52, 0x87, 0x74, 0x9c, 0xca, 0x82, 0x59, 0xd8, 0xa3, 0x8c, 0x11, + 0xf5, 0x95, 0x42, 0xf8, 0xde, 0x08, 0x3c, 0x51, 0x64, 0x45, 0x55, 0x64, 0x14, 0x50, 0xaa, 0x2f, + 0x24, 0xdd, 0x78, 0x07, 0x96, 0xb2, 0xa2, 0x39, 0xfe, 0xf1, 0x65, 0xe3, 0x37, 0x0d, 0x98, 0x4f, + 0xea, 0x23, 0xf6, 0xd7, 0x32, 0x09, 0xba, 0x0b, 0x73, 0xdb, 0xf2, 0x97, 0x3f, 0xf1, 0xeb, 0xc8, + 0xb8, 0xe7, 0xcd, 0xe6, 0xcb, 0xf9, 0x1f, 0x05, 0x03, 0xfa, 0x04, 0x32, 0xe1, 0x42, 0x96, 0x60, + 0xf2, 0x92, 0xfa, 0xea, 0x18, 0xca, 0x31, 0xd6, 0x71, 0x5b, 0xac, 0x16, 0xd0, 0x03, 0x98, 0x49, + 0xbf, 0xf7, 0xa1, 0x54, 0xc2, 0x98, 0xfb, 0x04, 0xd9, 0xd4, 0xc7, 0xa1, 0xc4, 0xfc, 0x3f, 0x64, + 0x8e, 0x95, 0x7a, 0xda, 0x42, 0x7a, 0xba, 0x77, 0x92, 0xf7, 0x38, 0xd8, 0xfc, 0xfa, 0x58, 0x9c, + 0x98, 0xfa, 0x87, 0x50, 0x8b, 0xba, 0xee, 0x69, 0x31, 0x67, 0x7a, 0xf1, 0xcd, 0xb9, 0x34, 0xbd, + 0xfd, 0x40, 0x9f, 0x40, 0x1f, 0x89, 0xc5, 0x9b, 0x94, 0xe6, 0x2c, 0x56, 0x7a, 0xcd, 0xcd, 0x73, + 0x39, 0xfd, 0x5d, 0x7d, 0x02, 0x7d, 0x1b, 0x1a, 0x6c, 0xb4, 0x27, 0x7f, 0x73, 0xb3, 0xd4, 0x12, + 0x3f, 0xf1, 0x6a, 0x45, 0x3f, 0xf1, 0x6a, 0x5d, 0x73, 0x68, 0x78, 0xd8, 0xcc, 0x69, 0xc0, 0x4a, + 0x02, 0x0f, 0x61, 0x7a, 0x9b, 0x84, 0x49, 0xbf, 0x04, 0xbd, 0x76, 0xa2, 0xae, 0x52, 0x53, 0xcf, + 0xa2, 0x8d, 0xb6, 0x5c, 0xf4, 0x09, 0xf4, 0xcb, 0x02, 0x9c, 0xdb, 0x26, 0x61, 0xb6, 0x03, 0x81, + 0xde, 0xca, 0xdf, 0xe4, 0x88, 0x4e, 0x45, 0xf3, 0xce, 0x69, 0xbd, 0x2d, 0x4d, 0x56, 0x9f, 0x40, + 0xbf, 0x2e, 0xc0, 0x79, 0x85, 0x31, 0xb5, 0xa5, 0x80, 0xd6, 0xc7, 0x33, 0x97, 0xd3, 0x7e, 0x68, + 0xde, 0x3c, 0xe5, 0x4f, 0xa9, 0x14, 0x92, 0xfa, 0x04, 0xda, 0xe3, 0x3a, 0x49, 0x2a, 0x08, 0x74, + 0x31, 0xb7, 0x54, 0x88, 0x77, 0x5f, 0x3e, 0xea, 0x73, 0xac, 0x87, 0x9b, 0xd0, 0xd8, 0x26, 0x61, + 0x94, 0xca, 0xa6, 0x2d, 0x2d, 0x53, 0x65, 0xa4, 0x5d, 0x35, 0x9b, 0xfd, 0x72, 0x8b, 0x99, 0x17, + 0xb4, 0x94, 0x74, 0x2d, 0xed, 0xab, 0xb9, 0x79, 0x6d, 0xda, 0x62, 0xf2, 0xb3, 0x3d, 0x7d, 0x02, + 0x3d, 0x86, 0xa5, 0xfc, 0xcb, 0x07, 0xbd, 0x7e, 0xe2, 0xf4, 0xa2, 0xb9, 0x76, 0x12, 0xd4, 0xcc, + 0x81, 0xd2, 0xe1, 0x37, 0x7d, 0xa0, 0xdc, 0x5b, 0x2b, 0x7d, 0xa0, 0xfc, 0xe8, 0xad, 0x4f, 0x7c, + 0xbc, 0xf9, 0xe7, 0x67, 0xcb, 0x85, 0xbf, 0x3e, 0x5b, 0x2e, 0xfc, 0xeb, 0xd9, 0x72, 0xe1, 0xf3, + 0xb7, 0x8f, 0xf9, 0x41, 0xa7, 0xf2, 0xeb, 0x53, 0x4c, 0x2d, 0xd3, 0xb6, 0x88, 0x1b, 0x76, 0xaa, + 0xdc, 0x9b, 0xdf, 0xfe, 0x77, 0x00, 0x00, 0x00, 0xff, 0xff, 0x2a, 0xb4, 0x26, 0x19, 0x9c, 0x2a, + 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -4465,6 +4476,25 @@ func (m *ManifestResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } + if len(m.SourcesManifestsStartingIdx) > 0 { + dAtA15 := make([]byte, len(m.SourcesManifestsStartingIdx)*10) + var j14 int + for _, num1 := range m.SourcesManifestsStartingIdx { + num := uint64(num1) + for num >= 1<<7 { + dAtA15[j14] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j14++ + } + dAtA15[j14] = uint8(num) + j14++ + } + i -= j14 + copy(dAtA[i:], dAtA15[:j14]) + i = encodeVarintRepository(dAtA, i, uint64(j14)) + i-- + dAtA[i] = 0x62 + } if m.ApplicationVersions != nil { { size, err := m.ApplicationVersions.MarshalToSizedBuffer(dAtA[:i]) @@ -6590,6 +6620,13 @@ func (m *ManifestResponse) Size() (n int) { l = m.ApplicationVersions.Size() n += 1 + l + sovRepository(uint64(l)) } + if len(m.SourcesManifestsStartingIdx) > 0 { + l = 0 + for _, e := range m.SourcesManifestsStartingIdx { + l += sovRepository(uint64(e)) + } + n += 1 + sovRepository(uint64(l)) + l + } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } @@ -9852,6 +9889,82 @@ func (m *ManifestResponse) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 12: + if wireType == 0 { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRepository + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.SourcesManifestsStartingIdx = append(m.SourcesManifestsStartingIdx, v) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRepository + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthRepository + } + postIndex := iNdEx + packedLen + if postIndex < 0 { + return ErrInvalidLengthRepository + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var elementCount int + var count int + for _, integer := range dAtA[iNdEx:postIndex] { + if integer < 128 { + count++ + } + } + elementCount = count + if elementCount != 0 && len(m.SourcesManifestsStartingIdx) == 0 { + m.SourcesManifestsStartingIdx = make([]int32, 0, elementCount) + } + for iNdEx < postIndex { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRepository + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.SourcesManifestsStartingIdx = append(m.SourcesManifestsStartingIdx, v) + } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field SourcesManifestsStartingIdx", wireType) + } default: iNdEx = preIndex skippy, err := skipRepository(dAtA[iNdEx:]) diff --git a/reposerver/repository/repository.proto b/reposerver/repository/repository.proto index ad295e95712a1..90de0e1a7c4b7 100644 --- a/reposerver/repository/repository.proto +++ b/reposerver/repository/repository.proto @@ -128,6 +128,8 @@ message ManifestResponse { k8s.io.apimachinery.pkg.apis.meta.v1.Time commitDate = 10; // A version of the application and its dependencies ApplicationVersions applicationVersions = 11; + // for multisourced apps will be [0,12,20], so this means that 0-11 - from first app source, 12-19 from second one, 20-x - third one + repeated int32 sourcesManifestsStartingIdx = 12; } message ListRefsRequest { diff --git a/server/application/application.go b/server/application/application.go index edf5fbe754427..8e9d765cfb04f 100644 --- a/server/application/application.go +++ b/server/application/application.go @@ -574,6 +574,7 @@ func (s *Server) GetManifests(ctx context.Context, q *application.ApplicationMan manifestInfo.Manifests[i].CompiledManifest = string(data) } } + manifests.SourcesManifestsStartingIdx = append(manifests.SourcesManifestsStartingIdx, int32(len(manifests.Manifests))) manifests.Manifests = append(manifests.Manifests, manifestInfo.Manifests...) } if manifestInfosAppVersionsIdx >= 0 && manifestInfos[manifestInfosAppVersionsIdx] != nil { diff --git a/server/application/events.proto b/server/application/events.proto index f70d522e17a78..045aa5888de7b 100644 --- a/server/application/events.proto +++ b/server/application/events.proto @@ -44,6 +44,8 @@ message EventPayload { repeated ObjectError errors = 4; // A version of the application and its dependencies optional ApplicationVersions appVersions = 5; + // A version of codefresh runtime + required string runtimeVersion = 6 [(gogoproto.nullable) = false]; } /** @@ -55,7 +57,7 @@ message ObjectSource { optional string gitManifest = 3 [(gogoproto.nullable) = false]; optional string repoURL = 4 [(gogoproto.nullable) = false]; optional string path = 5 [(gogoproto.nullable) = false]; - optional string revision = 6 [(gogoproto.nullable) = false]; + optional string revision = 6 [(gogoproto.nullable) = false]; // sync.revision optional string commitMessage = 7 [(gogoproto.nullable) = false]; optional string commitAuthor = 8 [(gogoproto.nullable) = false]; optional k8s.io.apimachinery.pkg.apis.meta.v1.Time commitDate = 9; @@ -66,13 +68,18 @@ message ObjectSource { optional k8s.io.apimachinery.pkg.apis.meta.v1.Time syncFinishedAt = 14; optional string healthStatus = 15; optional string healthMessage = 16; - optional string cluster = 17 [(gogoproto.nullable) = false]; - optional int64 historyId = 18 [(gogoproto.nullable) = false]; + optional string cluster = 17 [(gogoproto.nullable) = false]; // destination.server + optional int64 historyId = 18 [(gogoproto.nullable) = false]; // legacy optional string operationSyncRevision = 19 [(gogoproto.nullable) = false]; optional string appUID = 20 [(gogoproto.nullable) = false]; optional string appNamespace = 21 [(gogoproto.nullable) = false]; optional string appInstanceLabelKey = 22 [(gogoproto.nullable) = false]; optional string trackingMethod = 23 [(gogoproto.nullable) = false]; + repeated string revisions = 24; // sync.revisions + repeated string operationSyncRevisions = 25; // syncResult.revisions + optional string clusterName = 26; // destination.name + required bool appMultiSourced = 27 [(gogoproto.nullable) = false]; + required int32 appSourceIdx = 28 [(gogoproto.nullable) = false]; } /**