managed

type ConnectionDetails map[string][]byte

type ExternalClient interface {
	// Observe the external resource the supplied Managed resource represents,
	// if any. Observe implementations must not modify the external resource,
	// but may update the supplied Managed resource to reflect the state of the
	// external resource.
	Observe(ctx context.Context, mg resource.Managed) (ExternalObservation, error)

	// Create an external resource per the specifications of the supplied
	// Managed resource. Called when Observe reports that the associated
	// external resource does not exist.
	Create(ctx context.Context, mg resource.Managed) (ExternalCreation, error)

	// Update the external resource represented by the supplied Managed
	// resource, if necessary. Called unless Observe reports that the
	// associated external resource is up to date.
	Update(ctx context.Context, mg resource.Managed) (ExternalUpdate, error)

	// Delete the external resource upon deletion of its associated Managed
	// resource. Called when the managed resource has been deleted.
	Delete(ctx context.Context, mg resource.Managed) error

	// GetTarget returns the targets the resource is assigned assigned to
	GetTarget() []string

	// GetConfig returns the full configuration of the network node
	GetConfig(ctx context.Context) ([]byte, error)

	// GetResourceName returns the resource that matches the path
	GetResourceName(ctx context.Context, path *config.Path) (string, error)
}

type ExternalClientFns struct {
	ObserveFn         func(ctx context.Context, mg resource.Managed) (ExternalObservation, error)
	CreateFn          func(ctx context.Context, mg resource.Managed) (ExternalCreation, error)
	UpdateFn          func(ctx context.Context, mg resource.Managed) (ExternalUpdate, error)
	DeleteFn          func(ctx context.Context, mg resource.Managed) error
	GetTargetFn       func() []string
	GetConfigFn       func(ctx context.Context) ([]byte, error)
	GetResourceNameFn func(ctx context.Context, path *config.Path) (string, error)
}

type ExternalConnecter interface {
	// Connect to the provider specified by the supplied managed resource and
	// produce an ExternalClient.
	Connect(ctx context.Context, mg resource.Managed) (ExternalClient, error)
}

type ExternalConnectorFn func(ctx context.Context, mg resource.Managed) (ExternalClient, error)

type ExternalCreation struct {
	// ExternalNameAssigned is true if the Create operation resulted in a change
	// in the external name annotation. If that's the case, we need to issue a
	// spec update and make sure it goes through so that we don't lose the identifier
	// of the resource we just created.
	ExternalNameAssigned bool

	// ConnectionDetails required to connect to this resource. These details
	// are a set that is collated throughout the managed resource's lifecycle -
	// i.e. returning new connection details will have no affect on old details
	// unless an existing key is overwritten. Crossplane may publish these
	// credentials to a store (e.g. a Secret).
	ConnectionDetails ConnectionDetails
}

type ExternalObservation struct {
	// ResourceExists must be true if a corresponding external resource exists
	// for the managed resource. Typically this is proven by the presence of an
	// external resource of the expected kind whose unique identifier matches
	// the managed resource's external name. Crossplane uses this information to
	// determine whether it needs to create or delete the external resource.
	ResourceExists bool

	// ResourceUpToDate should be true if the corresponding external resource
	// appears to be up-to-date - i.e. updating the external resource to match
	// the desired state of the managed resource would be a no-op. Keep in mind
	// that often only a subset of external resource fields can be updated.
	// Crossplane uses this information to determine whether it needs to update
	// the external resource.
	ResourceUpToDate bool

	// ResourceLateInitialized should be true if the managed resource's spec was
	// updated during its observation. A Crossplane provider may update a
	// managed resource's spec fields after it is created or updated, as long as
	// the updates are limited to setting previously unset fields, and adding
	// keys to maps. Crossplane uses this information to determine whether
	// changes to the spec were made during observation that must be persisted.
	// Note that changes to the spec will be persisted before changes to the
	// status, and that pending changes to the status may be lost when the spec
	// is persisted. Status changes will be persisted by the first subsequent
	// observation that _does not_ late initialize the managed resource, so it
	// is important that Observe implementations do not late initialize the
	// resource every time they are called.
	ResourceLateInitialized bool
}

type ExternalUpdate struct {
}

type NopClient struct{}

type NopConnecter struct{}

type NopResolver struct{}

type NopValidator struct{}

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

type ReconcilerOption func(*Reconciler)

type Resolver interface {
	GetManagedResource(ctx context.Context, resourceName string) (resource.Managed, error)
}

type ResolverFn struct {
	// A GetManagedResourceFn is a function that satisfies the GetManagedResource interface.
	GetManagedResourceFn func(ctx context.Context, resourceName string) (resource.Managed, error)
}

type ValidateExternalleafRefObservation struct {
	Success bool

	ResolvedLeafRefs []*leafref.ResolvedLeafRef

	Details string
}

type ValidateLocalleafRefObservation struct {
	Success bool

	ResolvedLeafRefs []*leafref.ResolvedLeafRef

	Details string
}

type ValidationParentDependencyObservation struct {
	Success bool

	ResolvedLeafRefs []*leafref.ResolvedLeafRef

	Details string
}

type Validator interface {
	ValidateLocalleafRef(ctx context.Context, mg resource.Managed) (ValidateLocalleafRefObservation, error)

	ValidateExternalleafRef(ctx context.Context, mg resource.Managed, cfg []byte) (ValidateExternalleafRefObservation, error)

	ValidateParentDependency(ctx context.Context, mg resource.Managed, cfg []byte) (ValidationParentDependencyObservation, error)
}

type ValidatorFn struct {
	ValidateLocalleafRefFn     func(ctx context.Context, mg resource.Managed) (ValidateLocalleafRefObservation, error)
	ValidateExternalleafRefFn  func(ctx context.Context, mg resource.Managed, cfg []byte) (ValidateExternalleafRefObservation, error)
	ValidateParentDependencyFn func(ctx context.Context, mg resource.Managed, cfg []byte) (ValidationParentDependencyObservation, error)
}