Documentation

Overview

    Package inject defines interfaces and functions for propagating dependencies from a ControllerManager to the components registered with it. Dependencies are propagated to Reconciler, Source, EventHandler and Predicate objects which implement the Injectable interfaces.

    Index

    Constants

    This section is empty.

    Variables

    This section is empty.

    Functions

    func APIReaderInto

    func APIReaderInto(reader client.Reader, i interface{}) (bool, error)

      APIReaderInto will set APIReader on i and return the result if it implements APIReaderInto. Returns false if i does not implement APIReader

      func CacheInto

      func CacheInto(c cache.Cache, i interface{}) (bool, error)

        CacheInto will set informers on i and return the result if it implements Cache. Returns false if i does not implement Cache.

        func ClientInto

        func ClientInto(client client.Client, i interface{}) (bool, error)

          ClientInto will set client on i and return the result if it implements Client. Returns false if i does not implement Client.

          func ConfigInto

          func ConfigInto(config *rest.Config, i interface{}) (bool, error)

            ConfigInto will set config on i and return the result if it implements Config. Returns false if i does not implement Config.

            func InjectorInto

            func InjectorInto(f Func, i interface{}) (bool, error)

              InjectorInto will set f and return the result on i if it implements Injector. Returns false if i does not implement Injector.

              func LoggerInto

              func LoggerInto(l logr.Logger, i interface{}) (bool, error)

                LoggerInto will set the logger on the given object if it implements inject.Logger, returning true if a InjectLogger was called, and false otherwise.

                func MapperInto

                func MapperInto(mapper meta.RESTMapper, i interface{}) (bool, error)

                  MapperInto will set the rest mapper on i and return the result if it implements Mapper. Returns false if i does not implement Mapper.

                  func SchemeInto

                  func SchemeInto(scheme *runtime.Scheme, i interface{}) (bool, error)

                    SchemeInto will set scheme and return the result on i if it implements Scheme. Returns false if i does not implement Scheme.

                    func StopChannelInto

                    func StopChannelInto(stop <-chan struct{}, i interface{}) (bool, error)

                      StopChannelInto will set stop channel on i and return the result if it implements Stoppable. Returns false if i does not implement Stoppable.

                      Types

                      type APIReader

                      type APIReader interface {
                      	InjectAPIReader(client.Reader) error
                      }

                        APIReader is used by the Manager to inject the APIReader into necessary types.

                        type Cache

                        type Cache interface {
                        	InjectCache(cache cache.Cache) error
                        }

                          Cache is used by the ControllerManager to inject Cache into Sources, EventHandlers, Predicates, and Reconciles

                          type Client

                          type Client interface {
                          	InjectClient(client.Client) error
                          }

                            Client is used by the ControllerManager to inject client into Sources, EventHandlers, Predicates, and Reconciles

                            type Config

                            type Config interface {
                            	InjectConfig(*rest.Config) error
                            }

                              Config is used by the ControllerManager to inject Config into Sources, EventHandlers, Predicates, and Reconciles

                              type Func

                              type Func func(i interface{}) error

                                Func injects dependencies into i.

                                type Injector

                                type Injector interface {
                                	InjectFunc(f Func) error
                                }

                                  Injector is used by the ControllerManager to inject Func into Controllers

                                  type Logger

                                  type Logger interface {
                                  	InjectLogger(l logr.Logger) error
                                  }

                                    Logger is used to inject Loggers into components that need them and don't otherwise have opinions.

                                    type Mapper

                                    type Mapper interface {
                                    	InjectMapper(meta.RESTMapper) error
                                    }

                                      Mapper is used to inject the rest mapper to components that may need it

                                      type Scheme

                                      type Scheme interface {
                                      	InjectScheme(scheme *runtime.Scheme) error
                                      }

                                        Scheme is used by the ControllerManager to inject Scheme into Sources, EventHandlers, Predicates, and Reconciles

                                        type Stoppable

                                        type Stoppable interface {
                                        	InjectStopChannel(<-chan struct{}) error
                                        }

                                          Stoppable is used by the ControllerManager to inject stop channel into Sources, EventHandlers, Predicates, and Reconciles.

                                          Source Files