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.

    Package inject is used by a Manager to inject types into Sources, EventHandlers, Predicates, and Reconciles. Deprecated: Use manager.Options fields directly. This package will be removed in v0.10.

    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