agent

type AgentAPI struct {
	ModuleName        string
	AgentKey          *syncz.ValueHolder[api.AgentKey]
	GitLabExternalURL *syncz.ValueHolder[url.URL]
	Client            gitlab_access_rpc.GitlabAccessClient
}

type AgentSharedAPI struct {
}

type CancelRunWhenLeaderFunc func()

type ConfigurationWatcher[CD any] interface {
	Watch(context.Context, func(context.Context, CD))
}

type FactoriesLayer[CF, CM any] struct {
	Log       *slog.Logger
	Config    func(name string) CF
	LR        LeaderRunnerInterface[CM]
	MR        ModuleRunnerInterface[CM]
	Factories []modagent.Factory[CF, CM]
}

type InMemAPIServer struct {
	Server        *grpc.Server
	InMemConn     *grpc.ClientConn
	InMemListener net.Listener
}

type LeaderElector interface {
	Run(ctx context.Context, onStartedLeading, onStoppedLeading func())
}

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

type LeaderRunner[CM any] struct {
	// contains filtered or unexported fields
}

type LeaderRunnerInterface[CM any] interface {
	WrapModule(modagent.Module[CM]) modagent.Module[CM]
}

type ListenAPIServer struct {
	Log                          *slog.Logger
	ListenNetwork, ListenAddress string
	CertFile, KeyFile            string

	AuxCancel context.CancelFunc
	Server    *grpc.Server
}

type ModuleRunner[CD, CM any] struct {
	Log         *slog.Logger
	Watcher     ConfigurationWatcher[CD]
	Data2Config func(CD) (CM, []any) // second return value is extra attributes for the logger
	// contains filtered or unexported fields
}

type ModuleRunnerInterface[CM any] interface {
	RegisterModules(...modagent.Module[CM]) []stager.StageFunc
}

type ModuleStartFunc func()

type ModuleStopFunc func() ModuleStopWaitFunc

type ModuleStopWaitFunc func(context.Context) error

type ObsTools struct {
	Reg              *prometheus.Registry
	TP               trace.TracerProvider
	MP               otelmetric.MeterProvider
	P                propagation.TextMapPropagator
	StreamProm       grpc.StreamServerInterceptor
	UnaryProm        grpc.UnaryServerInterceptor
	StreamClientProm grpc.StreamClientInterceptor
	UnaryClientProm  grpc.UnaryClientInterceptor
}

type Options struct {
	Log               *slog.Logger
	LogLevel          *slog.LevelVar
	GRPCHandler       slog.Handler
	GRPCLogLevel      *slog.LevelVar
	Validator         protovalidate.Validator
	AgentKey          *syncz.ValueHolder[api.AgentKey]
	GitLabExternalURL *syncz.ValueHolder[url.URL]

	KASAddress       string
	KASCACertFile    string
	KASHeaders       []string
	KASSkipTLSVerify bool
	KASTLSServerName string

	ObservabilityListenNetwork string
	ObservabilityListenAddress string
	ObservabilityCertFile      string
	ObservabilityKeyFile       string

	TokenFile  string
	AgentToken api.AgentToken
}

type PrivateAPIServer struct {
	Log            *slog.Logger
	ListenNetwork  string
	ListenAddress  string
	OwnURL         grpctool.URLTarget
	OwnURLScheme   string
	OwnURLPort     string
	Server         grpctool.GRPCServer
	ListenServer   *grpc.Server
	InMemServer    *grpc.Server
	InMemListener  net.Listener
	AgentPool      grpctool.PoolInterface[grpctool.URLTarget]
	AgentPoolClose func()
	AuxCancel      context.CancelFunc
}

type Runner interface {
	// RunWhenLeader registers the given start and stop functions for this module with the leader runner.
	// When the leader runner is elected as the leader it will execute the start function and
	// when the leader runner lost the leadership it will execute the stop function.
	// The start function must be able to be triggered multiple times (with intermediate stop executions)
	// without having to rely on a new agent configuration.
	// The function that is returned must be used to unregister the module
	// from the leader runner in case a shutdown is initiated or a previously registered start function
	// became invalid, for example because a new agent configuration turned out to be invalid.
	RunWhenLeader(ctx context.Context, startFn ModuleStartFunc, stopFunc ModuleStopFunc) (CancelRunWhenLeaderFunc, error)
}