synccontext

type AddQueueFunc func(nameMapping NameMapping, queue workqueue.TypedRateLimitingInterface[ctrl.Request])

type BidirectionalObjectCache struct {
	// contains filtered or unexported fields
}

type ControllerContext struct {
	context.Context

	LocalManager          ctrl.Manager
	VirtualManager        ctrl.Manager
	VirtualRawConfig      *clientcmdapi.Config
	VirtualClusterVersion *version.Info

	WorkloadNamespaceClient client.Client

	Config   *config.VirtualClusterConfig
	StopChan <-chan struct{}

	// PreServerHooks are extra filters to inject into the server before everything else
	PreServerHooks []Filter

	// PostServerHooks are extra filters to inject into the server after everything else
	PostServerHooks []Filter

	// AcquiredLeaderHooks are hooks to start after vCluster acquired leader
	AcquiredLeaderHooks []Hook

	// Mappings hold the objects mappings store
	Mappings MappingsRegistry
}

type Filter func(http.Handler, *ControllerContext) http.Handler

type Hook func(ctx *ControllerContext) error

type Mapper interface {
	// Migrate is called right before the controllers are started and should be used for
	// validating the mappings are initialized in the store correctly. Mapper is passed here
	// as an argument because we want underling structs to retrieve the name from the topmost
	// struct that implements the mapping as overriding methods within embedded structs is not possible in golang.
	Migrate(ctx *RegisterContext, mapper Mapper) error

	// GroupVersionKind retrieves the group version kind
	GroupVersionKind() schema.GroupVersionKind

	// VirtualToHost translates a virtual name to a physical name
	VirtualToHost(ctx *SyncContext, req types.NamespacedName, vObj client.Object) types.NamespacedName

	// HostToVirtual translates a physical name to a virtual name
	HostToVirtual(ctx *SyncContext, req types.NamespacedName, pObj client.Object) types.NamespacedName

	// IsManaged determines if a physical object is managed by the vCluster
	IsManaged(ctx *SyncContext, pObj client.Object) (bool, error)
}

type MappingsRegistry interface {
	// ByGVK retrieves a mapper by GroupVersionKind.
	ByGVK(gvk schema.GroupVersionKind) (Mapper, error)

	// List retrieves all mappers as a map
	List() map[schema.GroupVersionKind]Mapper

	// Has checks if the store contains a mapper with the given GroupVersionKind.
	Has(gvk schema.GroupVersionKind) bool

	// AddMapper adds the given mapper to the store.
	AddMapper(mapper Mapper) error

	// Store returns the mapping store of the registry
	Store() MappingsStore
}

type MappingsStore interface {
	// Watch builds a source that can be used in a controller to watch on changes within the store for a given
	// GroupVersionKind.
	Watch(gvk schema.GroupVersionKind, addQueueFn AddQueueFunc) source.Source

	// StartGarbageCollection starts the mapping store garbage collection
	StartGarbageCollection(ctx context.Context)

	// HasHostObject checks if the store has a mapping for the host object
	HasHostObject(ctx context.Context, pObj Object) bool

	// HasVirtualObject checks if the store has a mapping for the virtual object
	HasVirtualObject(ctx context.Context, pObj Object) bool

	// AddReferenceAndSave adds a reference mapping and directly saves the mapping
	AddReferenceAndSave(ctx context.Context, nameMapping, belongsTo NameMapping) error

	// DeleteReferenceAndSave deletes a reference mapping and directly saves the mapping
	DeleteReferenceAndSave(ctx context.Context, nameMapping, belongsTo NameMapping) error

	// AddReference adds a reference mapping
	AddReference(ctx context.Context, nameMapping, belongsTo NameMapping) error

	// DeleteReference deletes a reference mapping
	DeleteReference(ctx context.Context, nameMapping, belongsTo NameMapping) error

	// SaveMapping saves the mapping in the backing store
	SaveMapping(ctx context.Context, mapping NameMapping) error

	// DeleteMapping deletes the mapping in the backing store
	DeleteMapping(ctx context.Context, mapping NameMapping) error

	// ReferencesTo retrieves all known references to this object
	ReferencesTo(ctx context.Context, vObj Object) []NameMapping

	// HostToVirtualName maps the given host object to the virtual name if found within the store
	HostToVirtualName(ctx context.Context, pObj Object) (types.NamespacedName, bool)

	// VirtualToHostName maps the given virtual object to the host name if found within the store
	VirtualToHostName(ctx context.Context, vObj Object) (types.NamespacedName, bool)
}

type NameMapping struct {
	schema.GroupVersionKind

	VirtualName types.NamespacedName
	HostName    types.NamespacedName
}

type Object struct {
	schema.GroupVersionKind
	types.NamespacedName
}

type ObjectCache struct {
	// contains filtered or unexported fields
}

type RegisterContext struct {
	context.Context

	Config *config.VirtualClusterConfig

	CurrentNamespace       string
	CurrentNamespaceClient client.Client

	Mappings MappingsRegistry

	VirtualManager  ctrl.Manager
	PhysicalManager ctrl.Manager
}

type SyncContext struct {
	context.Context

	Log loghelper.Logger

	Config *config.VirtualClusterConfig

	PhysicalClient client.Client
	VirtualClient  client.Client

	ObjectCache *BidirectionalObjectCache

	Mappings MappingsRegistry

	CurrentNamespace       string
	CurrentNamespaceClient client.Client
}

type SyncDirection string

type SyncEvent[T client.Object] struct {
	HostOld T
	Host    T

	VirtualOld T
	Virtual    T
}

type SyncToHostEvent[T client.Object] struct {
	HostOld T

	Virtual T
}

type SyncToVirtualEvent[T client.Object] struct {
	VirtualOld T

	Host T
}