pipeline

type Application interface {

	// Application resource
	HasResource

	// optional dot-separated path inside the application resource locating field where intermediate binding secret ref should be injected
	// the returns value follows foo.bar.bla convention, but it can be empty
	SecretPath() string

	// Returns a container-like interface.
	BindablePods() (*MetaPodSpec, error)

	// A flag indicating if changes have been propogated
	IsUpdated() bool

	// GroupVersionResource of the application
	GroupVersionResource() schema.GroupVersionResource

	// Use a different mapping
	SetMapping(WorkloadMapping)
}

type Bindable interface {
	IsBindable() (bool, error)
}

type BindingItem struct {
	Name   string
	Value  interface{}
	Source Service
}

type BindingItems []*BindingItem

type Bindings interface {
	// available bindgins
	Items() (BindingItems, error)

	// reference to resource holding the bindings, nil if not persisted in a resource
	Source() *v1.ObjectReference
}

type CRD interface {

	// CRD resource
	HasResource

	Bindable
}

type CRDDescription olmv1alpha1.CRDDescription

type Context interface {
	BindingName() string

	// Services referred by binding
	// if reading fails, return error
	Services() ([]Service, error)

	// Applications referred by binding
	// if no application found, return an error
	Applications() ([]Application, error)

	// Returns true if the binding needs to be removed
	UnbindRequested() bool

	// Returns true if the binding is being removed
	IsRemoved() bool

	// Cleans temporary annotations on the underlying resources
	CleanAnnotations() bool

	BindingSecretName() string

	// Return true if bindings should be projected as files inside application containers
	BindAsFiles() bool

	// Template that should be applied on collected binding names, prior projection
	NamingTemplate() string

	// Additional bindings that will be projected into application containers
	// entry key is the future binding name
	// entry value contains template that generates binding value
	Mappings() map[string]string

	// Add binding item to the context
	AddBindingItem(item *BindingItem)

	// Add bindings to the context
	AddBindings(bindings Bindings)

	// List binding items that should be projected into application containers
	BindingItems() BindingItems

	// EnvBindings returns list of (env variable name, binding name) pairs
	// describing what binding should be injected as env var as well
	EnvBindings() []*EnvBinding

	// Indicates that the binding should be retried at some later time
	// The current processing stops and context gets closed
	RetryProcessing(reason error)

	// Indicates that the binding should be retried with a delay.  The context will determine the
	// appropriate delay to add.  This will close the context, and is similar to RetryProcessing
	DelayReprocessing(reason error)

	// Indicates that en error has occurred while processing the binding
	Error(err error)

	// Stops processing
	StopProcessing()

	// Closes the context, persisting changed resources
	// Returns error if occurrs
	Close() error

	// Persists the secret containing binding data into the cluster.
	PersistSecret() error

	// Sets context condition
	SetCondition(condition *metav1.Condition)

	kubernetes.ConfigMapReader
	kubernetes.SecretReader

	FlowStatus() FlowStatus

	WorkloadResourceTemplate(gvr *schema.GroupVersionResource, containerPath string) (*WorkloadMapping, error)

	// Is this service binding getting its workloads from a label selector?
	HasLabelSelector() bool
}

type ContextProvider interface {
	Get(binding interface{}) (Context, error)
}

type EnvBinding struct {
	Var  string
	Name string
}

type FlowStatus struct {
	Retry bool
	Stop  bool
	Err   error
	Delay time.Duration
}

type Handler interface {
	Handle(ctx Context)
}

type HandlerFunc func(ctx Context)

type HasResource interface {
	Resource() *unstructured.Unstructured
}

type MetaContainer struct {
	Name        string
	Env         []string
	EnvFrom     []string
	VolumeMount []string
	Data        map[string]interface{}
}

type MetaPodSpec struct {
	Containers []MetaContainer
	Volume     []string
	Data       map[string]interface{}
}

type Pipeline interface {

	// Reconcile given service binding
	// Returns true if processing should be repeated
	// and optional error if occurred
	// important: even if error occurred it might not be needed to retry processing
	Process(binding interface{}) (bool, time.Duration, error)
}

type SecretBackedBindings struct {
	// service associated to the bindings
	Service Service

	// secret containing the bindings
	// each binding correspond to a (key, value) pair
	Secret *unstructured.Unstructured
	// contains filtered or unexported fields
}

type Service interface {

	// Service resource
	HasResource

	// Return CRD for this service, otherwise nil if not backed by CRD
	// Error might be returned if occurred during the operation
	CustomResourceDefinition() (CRD, error)

	// Resources owned by the service, if any
	// Error might be returned if occurred during the operation
	OwnedResources() ([]*unstructured.Unstructured, error)

	// Attach binding definition to service
	AddBindingDef(def binding.Definition)

	// All binding definitions attached to the service
	BindingDefs() []binding.Definition

	// Optional service id
	Id() *string

	Bindable
}

type WorkloadContainer struct {
	Path         *jsonpath.JSONPath
	Name         []string
	Env          []string
	EnvFrom      []string
	VolumeMounts []string
}

type WorkloadMapping struct {
	Containers []WorkloadContainer
	Volume     []string
}