parse

type EventHandler struct {
	Context           context.Context
	Reconciler        Reconciler
	NSControllerState *namespacecontroller.State
}

type FileSource struct {
	// SourceDir is the path to the symbolic link of the source repository.
	SourceDir cmpath.Absolute
	// HydratedRoot is the path to the root of the hydrated directory.
	HydratedRoot string
	// RepoRoot is the absolute path to the parent directory of SourceRoot and HydratedRoot.
	RepoRoot cmpath.Absolute
	// HydratedLink is the relative path to the symbolic link of the hydrated configs.
	HydratedLink string
	// SyncDir is the path to the directory of policies within the source repository.
	SyncDir cmpath.Relative
	// SourceType is the type of the source repository, must be git or oci.
	SourceType configsync.SourceType
	// SourceRepo is the source repo to sync.
	SourceRepo string
	// SourceBranch is the branch of the source repo to sync.
	SourceBranch string
	// SourceRev is the revision of the source repo to sync.
	SourceRev            string
	ReconcilerSignalsDir cmpath.Absolute
}

type Files struct {
	// TODO: unwrap composition
	FileSource
}

type GitSourceSpec struct {
	Repo     string
	Revision string
	Branch   string
	Dir      string
}

type HelmSourceSpec struct {
	Repo    string
	Version string
	Chart   string
}

type OCISourceSpec struct {
	Image string
	Dir   string
}

type Options struct {
	// Files lists Files in the source of truth.
	// TODO: compose Files without extending.
	Files

	// Clock is used for time tracking, namely to simplify testing by allowing
	// a fake clock, instead of a RealClock.
	Clock clock.Clock

	// ConfigParser defines the minimum interface required for Reconciler to use a
	// ConfigParser to read configs from a filesystem.
	ConfigParser filesystem.ConfigParser

	// ClusterName is the name of the cluster we're syncing configuration to.
	ClusterName string

	// Client knows how to read objects from a Kubernetes cluster and update
	// status.
	Client client.Client

	// ReconcilerName is the name of the reconciler resources, such as service
	// account, service, deployment and etc.
	ReconcilerName string

	// SyncName is the name of the RootSync or RepoSync object.
	SyncName string

	// Scope defines the scope of the reconciler, either root or namespaced.
	Scope declared.Scope

	// DiscoveryClient is how the Parser learns what types are currently
	// available on the cluster.
	DiscoveryClient discovery.ServerResourcer

	// Converter uses the DiscoveryClient to encode the declared fields of
	// objects in Git.
	Converter *declared.ValueConverter

	// WebhookEnabled indicates whether the Webhook is currently enabled
	WebhookEnabled bool

	// DeclaredResources is the set of valid source objects, managed by the
	// Updater and shared with the Parser & Remediator.
	// This is used by the Parser to validate that CRDs can only be removed from
	// the source when all of its CRs are removed as well.
	DeclaredResources *declared.Resources
}

type Parser interface {
	// ParseSource parses the source manifest files and returns the objects.
	ParseSource(ctx context.Context, state *sourceState) ([]ast.FileObject, status.MultiError)
}

type ReconcileResult struct {
	SourceChanged bool
	Success       bool
}

type Reconciler interface {
	// Options returns the ReconcilerOptions used by this reconciler.
	Options() *ReconcilerOptions

	// ReconcilerState returns the current state of the parser/reconciler.
	ReconcilerState() *ReconcilerState

	// Reconcile the cluster with the source config.
	//
	// Reconcile has multiple phases:
	// - Fetch - Checks the shared filesystem for new source commits fetched by
	//     one of the *-sync sidecars.
	// - Render - Checks the shared filesystem for source rendered by the
	//     hydration-controller sidecar using helm or kustomize, if required.
	// - Read - Reads the fetch and render status from the shared filesystem and
	//     lists the source config files.
	// - Parse - Parses resource objects from the source config files, validates
	//    them, and adds custom metadata.
	// - Update (aka Sync) - Updates the cluster and remediator to reflect the
	//     latest resource object manifests in the source.
	Reconcile(ctx context.Context, trigger string) ReconcileResult

	// UpdateSyncStatus updates the RSync status to reflect asynchronous status
	// changes made by the remediator between Reconcile calls.
	// Returns an error if the status update failed or was cancelled.
	UpdateSyncStatus(context.Context) error
}

type ReconcilerOptions struct {
	// Extend parser options to ensure they're using the same dependencies.
	*Options

	// Updater syncs the source from the parsed cache to the cluster.
	*Updater

	// FullSyncPeriod is the max time between full reconciliations.
	// When elapsed, the next reconcile attempt will reset the source cache,
	// triggering full reconciliation.
	FullSyncPeriod time.Duration

	// StatusUpdatePeriod is how long the Parser waits between updates of the
	// sync status, to account for management conflict errors from the Remediator.
	StatusUpdatePeriod time.Duration

	// RenderingEnabled indicates whether the hydration-controller is currently
	// running for this reconciler.
	RenderingEnabled bool
}

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

type ReconcilerStatus struct {
	// SourceStatus tracks info from the `Status.Source` field of a RepoSync/RootSync.
	SourceStatus *SourceStatus

	// RenderingStatus tracks info from the `Status.Rendering` field of a RepoSync/RootSync.
	RenderingStatus *RenderingStatus

	// SyncStatus tracks info from the `Status.Sync` field of a RepoSync/RootSync.
	SyncStatus *SyncStatus
}

type RenderingStatus struct {
	// Spec represents the source specification that this status corresponds to.
	// The spec is stored in the status so we can distinguish if the status
	// reflects the latest spec or not.
	Spec       SourceSpec
	Commit     string
	Message    string
	Errs       status.MultiError
	LastUpdate metav1.Time
	// RequiresRendering indicates whether the sync source has dry configs
	// only used internally (not surfaced on RSync status)
	RequiresRendering bool
}

type RootOptions struct {
	// Extend parse.Options
	*Options

	// SourceFormat defines the structure of the Root repository. Only the Root
	// repository may be SourceFormatHierarchy; all others are implicitly
	// SourceFormatUnstructured.
	SourceFormat configsync.SourceFormat

	// NamespaceStrategy indicates the NamespaceStrategy to be used by this
	// reconciler.
	NamespaceStrategy configsync.NamespaceStrategy

	// DynamicNSSelectorEnabled represents whether the NamespaceSelector's dynamic
	// mode is enabled. If it is enabled, NamespaceSelector will also select
	// resources matching the on-cluster Namespaces.
	// Only Root reconciler may have dynamic NamespaceSelector enabled because
	// RepoSync can't manage NamespaceSelectors.
	DynamicNSSelectorEnabled bool

	// NSControllerState stores whether the Namespace Controller schedules a sync
	// event for the reconciler thread, along with the cached NamespaceSelector
	// and selected namespaces.
	// Only Root reconciler may have Namespace Controller state because
	// RepoSync can't manage NamespaceSelectors.
	NSControllerState *namespacecontroller.State
}

type SourceSpec interface {
	// Equals returns true if the specified SourceSpec equals this
	// SourceSpec, including type and all field values.
	Equals(SourceSpec) bool
}

type SourceStatus struct {
	// Spec represents the source specification that this status corresponds to.
	// The spec is stored in the status so we can distinguish if the status
	// reflects the latest spec or not.
	Spec       SourceSpec
	Commit     string
	Errs       status.MultiError
	LastUpdate metav1.Time
}

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

type SyncStatus struct {
	// Spec represents the source specification that this status corresponds to.
	// The spec is stored in the status so we can distinguish if the status
	// reflects the latest spec or not.
	Spec       SourceSpec
	Syncing    bool
	Commit     string
	Errs       status.MultiError
	LastUpdate metav1.Time
}

type SyncStatusClient interface {
	// GetReconcilerStatus reads the status of the reconciler from the RSync status.
	GetReconcilerStatus(ctx context.Context) (*ReconcilerStatus, status.Error)
	// SetSourceStatus sets the source status and syncing condition on the RSync.
	SetSourceStatus(ctx context.Context, newStatus *SourceStatus) status.Error
	// SetRenderingStatus sets the rendering status and syncing condition on the RSync.
	SetRenderingStatus(ctx context.Context, oldStatus, newStatus *RenderingStatus) status.Error
	// SetSyncStatus sets the sync status and syncing condition on the RSync.
	SetSyncStatus(ctx context.Context, newStatus *SyncStatus) status.Error
	// SetRequiresRenderingAnnotation sets the requires-rendering annotation on the RSync.
	SetRequiresRenderingAnnotation(ctx context.Context, renderingRequired bool) status.Error
	// SetImageToSyncAnnotation sets the source annotations on the RSync.
	SetImageToSyncAnnotation(ctx context.Context, commit string) status.Error
}

type Updater struct {
	// Scope defines the scope of the reconciler, either root or namespaced.
	Scope declared.Scope
	// Resources is a set of resources declared in the source of truth.
	Resources *declared.Resources
	// Remediator is the interface Remediator implements that accepts a new set of
	// declared configuration.
	Remediator remediator.Interface
	// Applier is a bulk client for applying a set of desired resource objects and
	// tracking them in a ResourceGroup inventory.
	Applier applier.Applier
	// SyncErrorCache caches the sync errors from the various reconciler
	// sub-components running in parallel. This allows batching updates and
	// pushing them asynchronously.
	SyncErrorCache *SyncErrorCache
	// contains filtered or unexported fields
}