node

type AuthenticatorsFactory = Factory[authn.Authenticator]

type AuthenticatorsFactoryFunc = FactoryFunc[authn.Authenticator]

type Compute struct {
	// Visible for testing
	ID             string
	LocalEndpoint  compute.Endpoint
	Capacity       capacity.Tracker
	ExecutionStore store.ExecutionStore
	Executors      executor.ExecProvider
	Storages       storage.StorageProvider
	Publishers     publisher.PublisherProvider
	Bidder         compute.Bidder
	Watchers       watcher.Manager
	// contains filtered or unexported fields
}

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

type ExecutorsFactory = Factory[executor.Executor]

type ExecutorsFactoryFunc = FactoryFunc[executor.Executor]

type Factory[P provider.Providable] interface {
	Get(ctx context.Context, nodeConfig NodeConfig) (provider.Provider[P], error)
}

type FactoryFunc[P provider.Providable] func(ctx context.Context, nodeConfig NodeConfig) (provider.Provider[P], error)

type FeatureConfig struct {
	Engines    []string
	Publishers []string
	Storages   []string
}

type MetadataStore interface {
	ReadLastUpdateCheck() (time.Time, error)
	WriteLastUpdateCheck(time.Time) error
	InstanceID() string
}

type Node struct {
	// Visible for testing
	ID             string
	APIServer      *publicapi.Server
	ComputeNode    *Compute
	RequesterNode  *Requester
	CleanupManager *system.CleanupManager
}

type NodeConfig struct {
	NodeID                 string
	CleanupManager         *system.CleanupManager
	BacalhauConfig         types.Bacalhau
	SystemConfig           SystemConfig
	DependencyInjector     NodeDependencyInjector
	FailureInjectionConfig models.FailureInjectionConfig
}

type NodeDependencyInjector struct {
	StorageProvidersFactory StorageProvidersFactory
	ExecutorsFactory        ExecutorsFactory
	PublishersFactory       PublishersFactory
	AuthenticatorsFactory   AuthenticatorsFactory
}

type PublishersFactory = Factory[publisher.Publisher]

type PublishersFactoryFunc = FactoryFunc[publisher.Publisher]

type Requester struct {
	// Visible for testing
	Endpoint *orchestrator.BaseEndpoint
	JobStore jobstore.Store
	// We need a reference to the node info store until libp2p is removed
	NodeInfoStore nodes.Lookup
	// contains filtered or unexported fields
}

type RuntimeLabelsProvider struct{}

type StorageProvidersFactory = Factory[storage.Storage]

type StorageProvidersFactoryFunc = FactoryFunc[storage.Storage]

type SystemConfig struct {

	// RetryStrategy overrides the orchestrator's retry strategy for testing purposes
	RetryStrategy orchestrator.RetryStrategy

	// OverSubscriptionFactor overrides the orchestrator's over subscription factor for testing purposes
	OverSubscriptionFactor float64

	// NodeRankRandomnessRange overrides the node's rank randomness range for testing purposes
	NodeRankRandomnessRange int

	// MaxExecutionsPerEval limits the number of new executions that can be created in a single evaluation
	MaxExecutionsPerEval int
	// ExecutionLimitBackoff is the duration to wait before creating a new evaluation when hitting execution limits
	ExecutionLimitBackoff time.Duration

	// BidSemanticStrategy overrides the node's bid semantic strategy for testing purposes
	BidSemanticStrategy bidstrategy.BidStrategy
	// BidResourceStrategy overrides the node's bid resource strategy for testing purposes
	BidResourceStrategy bidstrategy.BidStrategy

	// TODO: remove compute level resource defaults. This should be handled at the orchestrator,
	//  but we still need to validate the behaviour is a job without resource limits land on a compute node
	DefaultComputeJobResourceLimits models.Resources
}