state

type Access struct {
	ResourceNamespace resource.Namespace
	ResourceType      resource.Type
	ResourceID        resource.ID

	Verb Verb
}

type CoreState interface {
	// Get a resource by type and ID.
	//
	// If a resource is not found, error is returned.
	Get(context.Context, resource.Pointer, ...GetOption) (resource.Resource, error)

	// List resources by type.
	List(context.Context, resource.Kind, ...ListOption) (resource.List, error)

	// Create a resource.
	//
	// If a resource already exists, Create returns an error.
	Create(context.Context, resource.Resource, ...CreateOption) error

	// Update a resource.
	//
	// If a resource doesn't exist, error is returned.
	// On update current version of resource `new` in the state should match
	// the version on the backend, otherwise conflict error is returned.
	Update(ctx context.Context, newResource resource.Resource, opts ...UpdateOption) error

	// Destroy a resource.
	//
	// If a resource doesn't exist, error is returned.
	// If a resource has pending finalizers, error is returned.
	Destroy(context.Context, resource.Pointer, ...DestroyOption) error

	// Watch state of a resource by type.
	//
	// It's fine to watch for a resource which doesn't exist yet.
	// Watch is canceled when context gets canceled.
	// Watch sends initial resource state as the very first event on the channel,
	// and then sends any updates to the resource as events.
	Watch(context.Context, resource.Pointer, chan<- Event, ...WatchOption) error

	// WatchKind watches resources of specific kind (namespace and type).
	WatchKind(context.Context, resource.Kind, chan<- Event, ...WatchKindOption) error

	// WatchKindAggregated watches resources of specific kind (namespace and type), updates are sent aggregated.
	WatchKindAggregated(context.Context, resource.Kind, chan<- []Event, ...WatchKindOption) error
}

type CreateOption func(*CreateOptions)

type CreateOptions struct {
	Owner string
}

type DestroyOption func(*DestroyOptions)

type DestroyOptions struct {
	Owner string
}

type ErrConflict interface {
	ConflictError()
}

type ErrNotFound interface {
	NotFoundError()
}

type ErrOwnerConflict interface {
	OwnerConflictError()
}

type ErrPhaseConflict interface {
	PhaseConflictError()
}

type ErrUnsupported interface {
	UnsupportedError()
}

type Event struct {
	Resource resource.Resource
	Old      resource.Resource
	Error    error
	Type     EventType
}

type EventType int

type FilteringRule func(ctx context.Context, access Access) error

type GetOption func(*GetOptions)

type GetOptions struct {
	UnmarshalOptions UnmarshalOptions
}

type ListOption func(*ListOptions)

type ListOptions struct {
	IDQuery          resource.IDQuery
	LabelQueries     resource.LabelQueries
	UnmarshalOptions UnmarshalOptions
}

type ResourceConditionFunc func(resource.Resource) (bool, error)

type State interface {
	CoreState

	// UpdateWithConflicts automatically handles conflicts on update.
	UpdateWithConflicts(context.Context, resource.Pointer, UpdaterFunc, ...UpdateOption) (resource.Resource, error)

	// WatchFor watches for resource to reach all of the specified conditions.
	WatchFor(context.Context, resource.Pointer, ...WatchForConditionFunc) (resource.Resource, error)

	// Teardown a resource (mark as being destroyed).
	//
	// If a resource doesn't exist, error is returned.
	// It's not an error to tear down a resource which is already being torn down.
	// Teardown returns a flag telling whether it's fine to destroy a resource.
	Teardown(context.Context, resource.Pointer, ...TeardownOption) (bool, error)

	// AddFinalizer adds finalizer to resource metadata handling conflicts.
	AddFinalizer(context.Context, resource.Pointer, ...resource.Finalizer) error

	// RemoveFinalizer removes finalizer from resource metadata handling conflicts.
	RemoveFinalizer(context.Context, resource.Pointer, ...resource.Finalizer) error

	// ContextWithTeardown returns a new context which will be canceled when the resource is torn down or destroyed.
	//
	// The passed in context should be canceled, otherwise the goroutine might leak from this call.
	// If the resource doesn't exist, the context is canceled immediately.
	ContextWithTeardown(context.Context, resource.Pointer) (context.Context, error)
}

type TeardownOption func(*TeardownOptions)

type TeardownOptions struct {
	Owner string
}

type UnmarshalOption func(*UnmarshalOptions)

type UnmarshalOptions struct {
	SkipProtobufUnmarshal bool
}

type UpdateOption func(*UpdateOptions)

type UpdateOptions struct {
	ExpectedPhase *resource.Phase
	Owner         string
}

type UpdaterFunc func(resource.Resource) error

type Verb int

type WatchForCondition struct {
	// If set, match only if func returns true.
	Condition ResourceConditionFunc
	// If set, wait for resource phase to be one of the specified.
	Phases []resource.Phase
	// If set, watch only for specified event types.
	EventTypes []EventType
	// If true, wait for the finalizers to empty
	FinalizersEmpty bool
}

type WatchForConditionFunc func(*WatchForCondition) error

type WatchKindOption func(*WatchKindOptions)

type WatchKindOptions struct {
	IDQuery           resource.IDQuery
	LabelQueries      resource.LabelQueries
	UnmarshalOptions  UnmarshalOptions
	BootstrapContents bool
	TailEvents        int
}

type WatchOption func(*WatchOptions)

type WatchOptions struct {
	TailEvents       int
	UnmarshalOptions UnmarshalOptions
}