conversion

type Chain ¶

type Chain struct {
	// A cache of calculated paths. A key is an arbitrary path and value is a sequence of base paths.
	PathsCache map[Rule][]Rule
	// An index to search for base paths by given From and To.
	BaseFromToIndex map[string]map[string]struct{}
}

func (c Chain) HasTargetVersion(target string) bool

func (c Chain) NextRules(fromVer string) []Rule

func (c *Chain) Put(rule Rule)

func (c Chain) RulesWithSimilarFromVersion(rule Rule) []Rule

func (c Chain) SearchPathForRule(rule Rule) []Rule

type ChainStorage ¶

type ChainStorage struct {
	Chains map[string]*Chain
}

func NewChainStorage() *ChainStorage

func (cs ChainStorage) FindConversionChain(crdName string, rule Rule) []Rule

func (cs ChainStorage) Get(crdName string) *Chain

type CrdClientConfig ¶

type CrdClientConfig struct {
	KubeClient  *klient.Client
	CrdName     string
	Namespace   string
	ServiceName string
	Path        string
	CABundle    []byte
}

A clientConfig for a particular CRD.

func (c *CrdClientConfig) Update(ctx context.Context) error

type EventHandlerFn ¶

type EventHandlerFn func(ctx context.Context, cdrName string, request *v1.ConversionRequest) (*Response, error)

type Response ¶

type Response struct {
	FailedMessage    string                 `json:"failedMessage"`
	ConvertedObjects []runtime.RawExtension `json:"convertedObjects,omitempty"`
}

Response is a holder of the conversion hook response.

Unlike ConverionsResponse, only one filed (FailedMessage) is used to determine success or fail:

Response is Success if FailedMessage is empty:

"result": {
  "status": "Success"
},

Response is Failed:

"result": {
  "status": "Failed",
  "message": FailedMessage
}

ConvertedObjects: # Objects must match the order of request.objects, and have apiVersion set to <request.desiredAPIVersion>. # kind, metadata.uid, metadata.name, and metadata.namespace fields must not be changed by the webhook. # metadata.labels and metadata.annotations fields may be changed by the webhook. # All other changes to metadata fields by the webhook are ignored.

func ResponseFromBytes(data []byte) (*Response, error)

func ResponseFromFile(filePath string) (*Response, error)

func ResponseFromReader(r io.Reader) (*Response, error)

func (r *Response) Dump() string

type Rule ¶

type Rule struct {
	FromVersion string `json:"fromVersion"`
	ToVersion   string `json:"toVersion"`
}

func (r Rule) ShortFromVersion() string

func (r Rule) ShortToVersion() string

func (r Rule) String() string

type WebhookConfig ¶

type WebhookConfig struct {
	Rules    []Rule
	CrdName  string // This name is used as a suffix to create different URLs for clientConfig in CRD.
	Metadata struct {
		Name         string
		DebugName    string
		LogLabels    map[string]string
		MetricLabels map[string]string
	}
}

WebhookConfig

type WebhookHandler ¶

type WebhookHandler struct {
	Manager *WebhookManager
	Router  chi.Router
}

func NewWebhookHandler() *WebhookHandler

type WebhookManager ¶

type WebhookManager struct {
	KubeClient *klient.Client

	EventHandlerFn EventHandlerFn
	Settings       *WebhookSettings
	Namespace      string

	Server        *server.WebhookServer
	ClientConfigs map[string]*CrdClientConfig
	Handler       *WebhookHandler
}

WebhookManager is a public interface to be used from operator.go.

No dynamic configuration for now. The steps are: - Init():

• Create a router to distinguish conversion requests between CRDs
• Create a handler to handle ConversionReview
• Create a server that listens for Kubernetes requests
• Call AddWebhook() to register a CRD name in conversion bindings in hooks

- Start():

• Start server loop.
• Update clientConfig in each registered CRD.

func NewWebhookManager() *WebhookManager

func (m *WebhookManager) AddWebhook(webhook *WebhookConfig)

func (m *WebhookManager) Init() error

func (m *WebhookManager) Start() error

type WebhookSettings ¶

type WebhookSettings struct {
	server.Settings
	CAPath   string
	CABundle []byte
}