modagent

type Api interface {
	modshared.Api
	MakeGitLabRequest(ctx context.Context, path string, opts ...GitLabRequestOption) (*GitLabResponse, error)
	GetAgentId(ctx context.Context) (int64, error)
	TryGetAgentId() (int64, bool)
}

type Config struct {
	// Log can be used for logging from the module.
	// It should not be used for logging from gRPC API methods. Use grpctool.LoggerFromContext(ctx) instead.
	Log       *zap.Logger
	AgentMeta *modshared.AgentMeta
	Api       Api
	// K8sUtilFactory provides means to interact with the Kubernetes cluster agentk is running in.
	K8sUtilFactory util.Factory
	// KasConn is the gRPC connection to gitlab-kas.
	KasConn grpc.ClientConnInterface
	// Server is a gRPC server that can be used to expose API endpoints to gitlab-kas and/or GitLab.
	// This can be used to add endpoints in Factory.New.
	// Request handlers can obtain the per-request logger using grpctool.LoggerFromContext(requestContext).
	Server *grpc.Server
	// AgentName is a string "gitlab-agent". Can be used as a user agent, server name, service name, etc.
	AgentName string
	// ServiceAccountName is a string defined by default as "gitlab-agent".
	ServiceAccountName string
}

type Factory interface {
	modshared.Factory
	// New creates a new instance of a Module.
	New(*Config) (Module, error)
}

type GitLabRequestConfig struct {
	Method string
	Header http.Header
	Query  url.Values
	Body   io.ReadCloser
}

type GitLabRequestOption func(*GitLabRequestConfig) error

type GitLabResponse struct {
	Status     string // e.g. "200 OK"
	StatusCode int32  // e.g. 200
	Header     http.Header
	Body       io.ReadCloser
}

type LeaderModule interface {
	Module
	IsRunnableConfiguration(cfg *agentcfg.AgentConfiguration) bool
	// Run runs the module. It is invoked when both conditions are satisfied:
	// - agentk acquires the leader lock.
	// - IsRunnableConfiguration() returns true for a configuration.
	// The passed context signals done when the module should fully shut down, including when the lock is lost,
	// or when IsRunnableConfiguration() returns false.
	// cfg keeps supplying configuration while IsRunnableConfiguration() is returning true for new values.
	// Same module instance is used for multiple RunLeader() calls.
	// Otherwise, this API works exactly as Module.Run.
	Run(ctx context.Context, cfg <-chan *agentcfg.AgentConfiguration) error
}

type Module interface {
	// Run runs the module.
	// Run can block until the context signals done or return if there is nothing to do or if there was an error.
	// cfg is a channel that gets configuration updates sent to it. It's closed when the module should shut down.
	// cfg sends configuration objects that are shared and must not be mutated.
	// Module should make a copy if it needs to mutate the object.
	// Applying configuration may take time, the provided context may signal done if module should shut down.
	// cfg only provides the latest available configuration, intermediate configuration states are discarded.
	Run(ctx context.Context, cfg <-chan *agentcfg.AgentConfiguration) error
	// DefaultAndValidateConfiguration applies defaults and validates the passed configuration.
	// It is called each time on configuration update before sending it via the channel passed to Run().
	// cfg is a shared instance, module can mutate only the part of it that it owns and only inside of this method.
	DefaultAndValidateConfiguration(cfg *agentcfg.AgentConfiguration) error
	// Name returns module's name.
	Name() string
}

type RpcApi interface {
	modshared.RpcApi
}

type RpcApiFactory func(ctx context.Context, method string) RpcApi

type WorkSource[C proto.Message] interface {
	ID() string
	Configuration() C
}

type Worker interface {
	Run(context.Context)
}

type WorkerFactory[C proto.Message] interface {
	New(agentId int64, source WorkSource[C]) Worker
	SourcesFromConfiguration(*agentcfg.AgentConfiguration) []WorkSource[C]
}

type WorkerManager[C proto.Message] struct {
	// contains filtered or unexported fields
}