Add combined remote resolvers binary

Part of #4710

Signed-off-by: Andrew Bayer <andrew.bayer@gmail.com>

cmd/resolvers/kodata/HEAD

@@ -0,0 +1 @@
+../../../.git/HEAD

cmd/resolvers/kodata/LICENSE

@@ -0,0 +1 @@
+../../../LICENSE

cmd/resolvers/kodata/refs

@@ -0,0 +1 @@
+../../../.git/refs

cmd/resolvers/kodata/third_party

@@ -0,0 +1 @@
+../../../third_party

cmd/resolvers/main.go

@@ -0,0 +1,37 @@
+/*
+Copyright 2022 The Tekton Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package main
+
+import (
+ "github.com/tektoncd/pipeline/pkg/apis/resolution/v1alpha1"
+ "github.com/tektoncd/pipeline/pkg/resolution/resolver/bundle"
+ "github.com/tektoncd/pipeline/pkg/resolution/resolver/framework"
+ "github.com/tektoncd/pipeline/pkg/resolution/resolver/git"
+ "github.com/tektoncd/pipeline/pkg/resolution/resolver/hub"
+ filteredinformerfactory "knative.dev/pkg/client/injection/kube/informers/factory/filtered"
+ "knative.dev/pkg/injection/sharedmain"
+ "knative.dev/pkg/signals"
+)
+
+func main() {
+ ctx := filteredinformerfactory.WithSelectors(signals.NewContext(), v1alpha1.ManagedByLabelKey)
+
+ sharedmain.MainWithContext(ctx, "controller",
+ framework.NewController(ctx, &git.Resolver{}),
+ framework.NewController(ctx, &hub.Resolver{}),
+ framework.NewController(ctx, &bundle.Resolver{}))
+}

pkg/apis/config/feature_flags.go

@@ -60,6 +60,10 @@ const (
  DefaultSendCloudEventsForRuns = false
  // DefaultEmbeddedStatus is the default value for "embedded-status".
  DefaultEmbeddedStatus = FullEmbeddedStatus
+ // DefaultEnableGitResolver is the default value for "enable-git-resolver".
+ DefaultEnableGitResolver = false
+ // DefaultEnableHubResolver is the default value for "enable-hub-resolver".
+ DefaultEnableHubResolver = false
 
  disableAffinityAssistantKey = "disable-affinity-assistant"
  disableCredsInitKey = "disable-creds-init"
@@ -71,6 +75,11 @@ const (
  enableAPIFields = "enable-api-fields"
  sendCloudEventsForRuns = "send-cloudevents-for-runs"
  embeddedStatus = "embedded-status"
+
+ // EnableGitResolver is the flag used to enable the git remote resolver
+ EnableGitResolver = "enable-git-resolver"
+ // EnableHubResolver is the flag used to enable the hub remote resolver
+ EnableHubResolver = "enable-hub-resolver"
 )
 
 // FeatureFlags holds the features configurations
@@ -87,6 +96,8 @@ type FeatureFlags struct {
  SendCloudEventsForRuns bool
  AwaitSidecarReadiness bool
  EmbeddedStatus string
+ EnableGitResolver bool
+ EnableHubResolver bool
 }
 
 // GetFeatureFlagsConfigName returns the name of the configmap containing all
@@ -138,6 +149,12 @@ func NewFeatureFlagsFromMap(cfgMap map[string]string) (*FeatureFlags, error) {
  if err := setEmbeddedStatus(cfgMap, DefaultEmbeddedStatus, &tc.EmbeddedStatus); err != nil {
  return nil, err
  }
+ if err := setFeature(EnableGitResolver, DefaultEnableGitResolver, &tc.EnableGitResolver); err != nil {
+ return nil, err
+ }
+ if err := setFeature(EnableHubResolver, DefaultEnableHubResolver, &tc.EnableHubResolver); err != nil {
+ return nil, err
+ }
 
  // Given that they are alpha features, Tekton Bundles and Custom Tasks should be switched on if
  // enable-api-fields is "alpha". If enable-api-fields is not "alpha" then fall back to the value of

pkg/resolution/resolver/bundle/resolver.go

@@ -18,15 +18,19 @@ package bundle
 
 import (
  "context"
+ "errors"
  "time"
 
  "github.com/google/go-containerregistry/pkg/authn/k8schain"
+ "github.com/tektoncd/pipeline/pkg/apis/config"
  "github.com/tektoncd/pipeline/pkg/resolution/common"
  "github.com/tektoncd/pipeline/pkg/resolution/resolver/framework"
  "k8s.io/client-go/kubernetes"
  "knative.dev/pkg/client/injection/kube/client"
 )
 
+const disabledError = "cannot handle resolution request, enable-tekton-oci-bundles feature flag not true"
+
 // LabelValueBundleResolverType is the value to use for the
 // resolution.tekton.dev/type label on resource requests
 const LabelValueBundleResolverType string = "bundles"
@@ -65,6 +69,9 @@ func (r *Resolver) GetSelector(context.Context) map[string]string {
 
 // ValidateParams ensures parameters from a request are as expected.
 func (r *Resolver) ValidateParams(ctx context.Context, params map[string]string) error {
+ if r.isDisabled(ctx) {
+ return errors.New(disabledError)
+ }
  if _, err := OptionsFromParams(ctx, params); err != nil {
  return err
  }
@@ -73,6 +80,9 @@ func (r *Resolver) ValidateParams(ctx context.Context, params map[string]string)
 
 // Resolve uses the given params to resolve the requested file or resource.
 func (r *Resolver) Resolve(ctx context.Context, params map[string]string) (framework.ResolvedResource, error) {
+ if r.isDisabled(ctx) {
+ return nil, errors.New(disabledError)
+ }
  opts, err := OptionsFromParams(ctx, params)
  if err != nil {
  return nil, err
@@ -86,3 +96,12 @@ func (r *Resolver) Resolve(ctx context.Context, params map[string]string) (frame
  defer cancelFn()
  return GetEntry(ctx, kc, opts)
 }
+
+func (r *Resolver) isDisabled(ctx context.Context) bool {
+ cfg := config.FromContextOrDefaults(ctx)
+ if cfg.FeatureFlags.EnableTektonOCIBundles {
+ return false
+ }
+
+ return true
+}

pkg/resolution/resolver/bundle/resolver_test.go

@@ -20,7 +20,10 @@ import (
  "context"
  "testing"
 
+ "github.com/google/go-cmp/cmp"
  resolutioncommon "github.com/tektoncd/pipeline/pkg/resolution/common"
+ frtesting "github.com/tektoncd/pipeline/pkg/resolution/resolver/framework/testing"
+ "github.com/tektoncd/pipeline/test/diff"
 )
 
 func TestGetSelector(t *testing.T) {
@@ -42,7 +45,7 @@ func TestValidateParams(t *testing.T) {
  ParamBundle: "bar",
  ParamServiceAccount: "baz",
  }
- if err := resolver.ValidateParams(context.Background(), paramsWithTask); err != nil {
+ if err := resolver.ValidateParams(resolverContext(), paramsWithTask); err != nil {
  t.Fatalf("unexpected error validating params: %v", err)
  }
 
@@ -52,11 +55,32 @@ func TestValidateParams(t *testing.T) {
  ParamBundle: "bar",
  ParamServiceAccount: "baz",
  }
- if err := resolver.ValidateParams(context.Background(), paramsWithPipeline); err != nil {
+ if err := resolver.ValidateParams(resolverContext(), paramsWithPipeline); err != nil {
  t.Fatalf("unexpected error validating params: %v", err)
  }
 }
 
+func TestValidateParamsDisabled(t *testing.T) {
+ resolver := Resolver{}
+
+ var err error
+
+ params := map[string]string{
+ ParamKind: "task",
+ ParamName: "foo",
+ ParamBundle: "bar",
+ ParamServiceAccount: "baz",
+ }
+ err = resolver.ValidateParams(context.Background(), params)
+ if err == nil {
+ t.Fatalf("expected disabled err")
+ }
+
+ if d := cmp.Diff(disabledError, err.Error()); d != "" {
+ t.Errorf("unexpected error: %s", diff.PrintWantGot(d))
+ }
+}
+
 func TestValidateParamsMissing(t *testing.T) {
  resolver := Resolver{}
 
@@ -67,7 +91,7 @@ func TestValidateParamsMissing(t *testing.T) {
  ParamName: "foo",
  ParamServiceAccount: "baz",
  }
- err = resolver.ValidateParams(context.Background(), paramsMissingBundle)
+ err = resolver.ValidateParams(resolverContext(), paramsMissingBundle)
  if err == nil {
  t.Fatalf("expected missing kind err")
  }
@@ -77,9 +101,34 @@ func TestValidateParamsMissing(t *testing.T) {
  ParamBundle: "bar",
  ParamServiceAccount: "baz",
  }
- err = resolver.ValidateParams(context.Background(), paramsMissingName)
+ err = resolver.ValidateParams(resolverContext(), paramsMissingName)
  if err == nil {
  t.Fatalf("expected missing name err")
  }
 
 }
+
+func TestResolveDisabled(t *testing.T) {
+ resolver := Resolver{}
+
+ var err error
+
+ params := map[string]string{
+ ParamKind: "task",
+ ParamName: "foo",
+ ParamBundle: "bar",
+ ParamServiceAccount: "baz",
+ }
+ _, err = resolver.Resolve(context.Background(), params)
+ if err == nil {
+ t.Fatalf("expected disabled err")
+ }
+
+ if d := cmp.Diff(disabledError, err.Error()); d != "" {
+ t.Errorf("unexpected error: %s", diff.PrintWantGot(d))
+ }
+}
+
+func resolverContext() context.Context {
+ return frtesting.ContextWithBundleResolverEnabled(context.Background())
+}

pkg/resolution/resolver/framework/configstore.go

@@ -19,6 +19,7 @@ package framework
 import (
  "context"
 
+ "github.com/tektoncd/pipeline/pkg/apis/config"
  corev1 "k8s.io/api/core/v1"
  "knative.dev/pkg/configmap"
 )
@@ -44,10 +45,34 @@ func DataFromConfigMap(config *corev1.ConfigMap) (map[string]string, error) {
 // ConfigStore wraps a knative untyped store and provides helper methods
 // for working with a resolver's configuration data.
 type ConfigStore struct {
+ *config.Store
  resolverConfigName string
  untyped *configmap.UntypedStore
 }
 
+// NewConfigStore creates a new untyped store for the resolver's configuration and a config.Store for general Pipeline configuration.
+func NewConfigStore(resolverConfigName string, logger configmap.Logger) *ConfigStore {
+ return &ConfigStore{
+ Store: config.NewStore(logger),
+ resolverConfigName: resolverConfigName,
+ untyped: configmap.NewUntypedStore(
+ "resolver-config",
+ logger,
+ configmap.Constructors{
+ resolverConfigName: DataFromConfigMap,
+ },
+ ),
+ }
+}
+
+// WatchConfigs uses the provided configmap.Watcher
+// to setup watches for the config names provided in the
+// Constructors map
+func (store *ConfigStore) WatchConfigs(w configmap.Watcher) {
+ store.untyped.WatchConfigs(w)
+ store.Store.WatchConfigs(w)
+}
+
 // GetResolverConfig returns a copy of the resolver's current
 // configuration or an empty map if the stored config is nil or invalid.
 func (store *ConfigStore) GetResolverConfig() map[string]string {
@@ -65,7 +90,7 @@ func (store *ConfigStore) GetResolverConfig() map[string]string {
 // data stored in it.
 func (store *ConfigStore) ToContext(ctx context.Context) context.Context {
  conf := store.GetResolverConfig()
- return InjectResolverConfigToContext(ctx, conf)
+ return InjectResolverConfigToContext(store.Store.ToContext(ctx), conf)
 }
 
 // InjectResolverConfigToContext returns a new context with a

pkg/resolution/resolver/framework/controller.go

@@ -167,17 +167,8 @@ func watchConfigChanges(ctx context.Context, reconciler *Reconciler, cmw configm
  if resolverConfigName == "" {
  panic("resolver returned empty config name")
  }
- reconciler.configStore = &ConfigStore{
- resolverConfigName: resolverConfigName,
- untyped: configmap.NewUntypedStore(
- "resolver-config",
- logger,
- configmap.Constructors{
- resolverConfigName: DataFromConfigMap,
- },
- ),
- }
- reconciler.configStore.untyped.WatchConfigs(cmw)
+ reconciler.configStore = NewConfigStore(resolverConfigName, logger)
+ reconciler.configStore.WatchConfigs(cmw)
  }
 }
 

pkg/resolution/resolver/framework/testing/fakecontroller.go

@@ -24,11 +24,13 @@ import (
 
  "github.com/google/go-cmp/cmp"
  "github.com/google/go-cmp/cmp/cmpopts"
+ "github.com/tektoncd/pipeline/pkg/apis/config"
  "github.com/tektoncd/pipeline/pkg/apis/resolution/v1alpha1"
  "github.com/tektoncd/pipeline/pkg/resolution/resolver/framework"
  "github.com/tektoncd/pipeline/test"
  "github.com/tektoncd/pipeline/test/diff"
  "github.com/tektoncd/pipeline/test/names"
+ corev1 "k8s.io/api/core/v1"
  metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
  "k8s.io/apimachinery/pkg/types"
  "k8s.io/apimachinery/pkg/util/clock"
@@ -95,6 +97,7 @@ func GetResolverFrameworkController(ctx context.Context, t *testing.T, d test.Da
 func initializeResolverFrameworkControllerAssets(ctx context.Context, t *testing.T, d test.Data, resolver framework.Resolver, modifiers ...framework.ReconcilerModifier) (test.Assets, func()) {
  t.Helper()
  ctx, cancel := context.WithCancel(ctx)
+ ensureConfigurationConfigMapsExist(&d)
  c, informers := test.SeedTestData(t, ctx, d)
  configMapWatcher := cminformer.NewInformedWatcher(c.Kube, system.Namespace())
  ctl := framework.NewController(ctx, resolver, modifiers...)(ctx, configMapWatcher)
@@ -125,3 +128,54 @@ func setClockOnReconciler(r *framework.Reconciler) {
  r.Clock = testClock
  }
 }
+
+func ensureConfigurationConfigMapsExist(d *test.Data) {
+ var defaultsExists, featureFlagsExists, artifactBucketExists, artifactPVCExists, metricsExists bool
+ for _, cm := range d.ConfigMaps {
+ if cm.Name == config.GetDefaultsConfigName() {
+ defaultsExists = true
+ }
+ if cm.Name == config.GetFeatureFlagsConfigName() {
+ featureFlagsExists = true
+ }
+ if cm.Name == config.GetArtifactBucketConfigName() {
+ artifactBucketExists = true
+ }
+ if cm.Name == config.GetArtifactPVCConfigName() {
+ artifactPVCExists = true
+ }
+ if cm.Name == config.GetMetricsConfigName() {
+ metricsExists = true
+ }
+ }
+ if !defaultsExists {
+ d.ConfigMaps = append(d.ConfigMaps, &corev1.ConfigMap{
+ ObjectMeta: metav1.ObjectMeta{Name: config.GetDefaultsConfigName(), Namespace: system.Namespace()},
+ Data: map[string]string{},
+ })
+ }
+ if !featureFlagsExists {
+ d.ConfigMaps = append(d.ConfigMaps, &corev1.ConfigMap{
+ ObjectMeta: metav1.ObjectMeta{Name: config.GetFeatureFlagsConfigName(), Namespace: system.Namespace()},
+ Data: map[string]string{},
+ })
+ }
+ if !artifactBucketExists {
+ d.ConfigMaps = append(d.ConfigMaps, &corev1.ConfigMap{
+ ObjectMeta: metav1.ObjectMeta{Name: config.GetArtifactBucketConfigName(), Namespace: system.Namespace()},
+ Data: map[string]string{},
+ })
+ }
+ if !artifactPVCExists {
+ d.ConfigMaps = append(d.ConfigMaps, &corev1.ConfigMap{
+ ObjectMeta: metav1.ObjectMeta{Name: config.GetArtifactPVCConfigName(), Namespace: system.Namespace()},
+ Data: map[string]string{},
+ })
+ }
+ if !metricsExists {
+ d.ConfigMaps = append(d.ConfigMaps, &corev1.ConfigMap{
+ ObjectMeta: metav1.ObjectMeta{Name: config.GetMetricsConfigName(), Namespace: system.Namespace()},
+ Data: map[string]string{},
+ })
+ }
+}