framework

type ConfigStore ¶ added in v1.17.0

type ConfigStore struct {
	*resolverconfig.Store
	// contains filtered or unexported fields
}

ConfigStore wraps a knative untyped store and provides helper methods for working with a resolver's configuration data.

func NewConfigStore(resolverConfigName string, logger configmap.Logger) *ConfigStore

func (store *ConfigStore) GetResolverConfig() map[string]string

func (store *ConfigStore) ToContext(ctx context.Context) context.Context

func (store *ConfigStore) WatchConfigs(w configmap.Watcher)

type ConfigWatcher ¶ added in v1.17.0

type ConfigWatcher interface {
	// GetConfigName should return a string name for its
	// configuration to be referenced by. This will map to the name
	// of a ConfigMap in the same namespace as the resolver.
	GetConfigName(ctx context.Context) string
}

ConfigWatcher is the interface to implement if your resolver accepts additional configuration from an admin. Examples of how this might be used: - your resolver might require an allow-list of repositories or registries - your resolver might allow request timeout settings to be configured - your resolver might need an API endpoint or base url to be set

When your resolver implements this interface it will be able to access configuration from the context it receives in calls to ValidateParams and Resolve.

type FakeResolvedResource ¶ added in v1.17.0

type FakeResolvedResource struct {
	Content       string
	AnnotationMap map[string]string
	ContentSource *pipelinev1.RefSource
	ErrorWith     string
	WaitFor       time.Duration
}

FakeResolvedResource is a framework.ResolvedResource implementation for use with the fake resolver. If it's the value in the FakeResolver's ForParam map for the key given as the fake param value, the FakeResolver will first check if it's got a value for ErrorWith. If so, that string will be returned as an error. Then, if WaitFor is greater than zero, the FakeResolver will wait that long before returning. And finally, the FakeResolvedResource will be returned.

func (f *FakeResolvedResource) Annotations() map[string]string

func (f *FakeResolvedResource) Data() []byte

func (f *FakeResolvedResource) RefSource() *pipelinev1.RefSource

type FakeResolver ¶

type FakeResolver struct {
	ForParam map[string]*FakeResolvedResource
	Timeout  time.Duration
}

FakeResolver implements a framework.Resolver that can fetch pre-configured strings based on a parameter value, or return resolution attempts with a configured error.

func (r *FakeResolver) GetName(_ context.Context) string

func (r *FakeResolver) GetResolutionTimeout(ctx context.Context, defaultTimeout time.Duration, params map[string]string) (time.Duration, error)

func (r *FakeResolver) GetSelector(_ context.Context) map[string]string

func (r *FakeResolver) Initialize(ctx context.Context) error

func (r *FakeResolver) Resolve(_ context.Context, req *v1beta1.ResolutionRequestSpec) (ResolvedResource, error)

func (r *FakeResolver) Validate(_ context.Context, req *v1beta1.ResolutionRequestSpec) error

type Reconciler ¶

type Reconciler struct {
	// Implements reconciler.LeaderAware
	reconciler.LeaderAwareFuncs

	// Clock is used by the reconciler to track the passage of time
	// and can be overridden for tests.
	Clock clock.PassiveClock
	// contains filtered or unexported fields
}

Reconciler handles ResolutionRequest objects, performs functionality common to all resolvers and delegates resolver-specific actions to its embedded type-specific Resolver object.

func (r *Reconciler) MarkFailed(ctx context.Context, rr *v1beta1.ResolutionRequest, resolutionErr error) error

func (r *Reconciler) OnError(ctx context.Context, rr *v1beta1.ResolutionRequest, err error) error

func (r *Reconciler) Reconcile(ctx context.Context, key string) error

type ReconcilerModifier ¶

type ReconcilerModifier = func(reconciler *Reconciler)

ReconcilerModifier is a func that can access and modify a reconciler in the moments before a resolver is started. It allows for things like injecting a test clock.

type ResolvedResource ¶ added in v1.17.0

type ResolvedResource interface {
	Data() []byte
	Annotations() map[string]string
	RefSource() *pipelinev1.RefSource
}

ResolvedResource returns the data and annotations of a successful resource fetch.

This is a distinct named interface from the old resolution/resolver/framework.ResolvedResource. Resolver implementations returning the old type won’t satisfy the new framework.Resolver, even though the method sets are identical.

func Resolve(params []pipelinev1.Param, forParam map[string]*FakeResolvedResource) (ResolvedResource, error)

type Resolver ¶

type Resolver interface {
	// Initialize is called at the moment the resolver controller is
	// instantiated and is a good place to setup things like
	// resource listers.
	Initialize(ctx context.Context) error

	// GetName should give back the name of the resolver. E.g. "Git"
	GetName(ctx context.Context) string

	// GetSelector returns the labels that are used to direct resolution
	// requests to this resolver.
	GetSelector(ctx context.Context) map[string]string

	// Validate is given the ressolution request spec
	// should return an error if the resolver cannot resolve it.
	Validate(ctx context.Context, req *v1beta1.ResolutionRequestSpec) error

	// ResolveRequest receives the resolution request spec
	// and returns the resolved data along with any annotations
	// to include in the response. If resolution fails then an error
	// should be returned instead. If a resolution.Error
	// is returned then its Reason and Message are used as part of the
	// response to the request. If an error is returned which is transient,
	// such as a kubernetes timeout or too many requests error, the
	// ResolutionRequest will not be updated with a failed status.
	// See github.com/tektoncd/pipeline/pkg/resolution/common/errors.go for
	// the definition of a transient error.
	//
	// Note that the ResolvedResource returned by this function definition
	// corresponds to remoteresolution/resolver/framework.ResolvedResource and
	// not resolution/resolver/framework.ResolvedResource.
	// Resolver implementations returning the old type won’t satisfy the new
	// remoteresolution/resolver/framework.Resolver
	Resolve(ctx context.Context, req *v1beta1.ResolutionRequestSpec) (ResolvedResource, error)
}

Resolver is the interface to implement for type-specific resource resolution. It fetches resources from a given type of remote location and returns their content along with any associated annotations.

type TimedResolution ¶ added in v1.17.0

type TimedResolution interface {
	// GetResolutionTimeout receives the current request's context
	// object, which includes any request-scoped data like
	// resolver config and the request's originating namespace,
	// along with a default.
	GetResolutionTimeout(ctx context.Context, timeout time.Duration, params map[string]string) (time.Duration, error)
}

TimedResolution is an optional interface that a resolver can implement to override the default resolution request timeout.

There are two timeouts that a resolution request adheres to: First there is a global timeout that the core ResolutionRequest reconciler enforces on _all_ requests. This prevents zombie requests (such as those with a misconfigured `type`) sticking around in perpetuity. Second there are resolver-specific timeouts that default to 1 minute.

A resolver implementing the TimedResolution interface sets the maximum duration of any single request to this resolver.

The core ResolutionRequest reconciler's global timeout overrides any resolver-specific timeout.