agent

type Agent struct {
	// Unique system-wide ID
	ID string `jsonapi:"primary,agents"`
	// Optional name
	Name string `jsonapi:"attribute" json:"name"`
	// Version of agent
	Version string `jsonapi:"attribute" json:"version"`
	// Current status of agent
	Status AgentStatus `jsonapi:"attribute" json:"status"`
	// Max number of jobs agent can execute
	MaxJobs int `jsonapi:"attribute" json:"max_jobs"`
	// Current number of jobs allocated to agent.
	CurrentJobs int `jsonapi:"attribute" json:"current_jobs"`
	// Last time a ping was received from the agent
	LastPingAt time.Time `jsonapi:"attribute" json:"last-ping-at"`
	// Last time the status was updated
	LastStatusAt time.Time `jsonapi:"attribute" json:"last-status-at"`
	// IP address of agent
	IPAddress net.IP `jsonapi:"attribute" json:"ip-address"`
	// ID of agent' pool. If nil then the agent is assumed to be a server agent
	// (otfd).
	AgentPoolID *string `jsonapi:"attribute" json:"agent-pool-id"`
}

type AgentStatus string

type Config struct {
	Name            string // descriptive name for agent
	Concurrency     int    // number of jobs the agent can execute at any one time
	Sandbox         bool   // isolate privileged ops within sandbox
	Debug           bool   // toggle debug mode
	PluginCache     bool   // toggle use of terraform's shared plugin cache
	TerraformBinDir string // destination directory for terraform binaries
}

type CreateAgentPoolOptions struct {
	Name string `schema:"name,required"`
	// name of org
	Organization string `schema:"organization_name,required"`
	// defaults to true
	OrganizationScoped *bool
	// IDs of workspaces allowed to access the pool.
	AllowedWorkspaces []string
}

type CreateAgentTokenOptions struct {
	Description string `json:"description" schema:"description,required"`
}

type DaemonOptions struct {
	Logger *slog.Logger
	Config Config
	// contains filtered or unexported fields
}

type Job struct {
	// Spec uniquely identifies the job, identifying the corresponding run
	// phase.
	Spec JobSpec `jsonapi:"primary,jobs"`
	// Current status of job.
	Status JobStatus `jsonapi:"attribute" json:"status"`
	// ID of agent pool the job's workspace is assigned to use. If non-nil then
	// the job is allocated to a pool agent belonging to the pool. If nil then
	// the job is allocated to a server agent.
	AgentPoolID *string `jsonapi:"attribute" json:"agent_pool_id"`
	// Name of job's organization
	Organization string `jsonapi:"attribute" json:"organization"`
	// ID of job's workspace
	WorkspaceID string `jsonapi:"attribute" json:"workspace_id"`
	// ID of agent that this job is allocated to. Only set once job enters
	// JobAllocated state.
	AgentID *string `jsonapi:"attribute" json:"agent_id"`
	// Signaled is non-nil when a cancelation signal has been sent to the job
	// and it is true when it has been forceably canceled.
	Signaled *bool `jsonapi:"attribute" json:"signaled"`
}

type JobSpec struct {
	// ID of the run that this job is for.
	RunID string `json:"run_id"`
	// Phase of run that this job is for.
	Phase internal.PhaseType `json:"phase"`
}

type JobStatus string

type Pool struct {
	// Unique system-wide ID
	ID        string
	Name      string
	CreatedAt time.Time
	// Pool belongs to an organization with this name.
	Organization string
	// Whether pool of agents is accessible to all workspaces in organization
	// (true) or only those specified in AllowedWorkspaces (false).
	OrganizationScoped bool
	// IDs of workspaces allowed to access pool. Ignored if OrganizationScoped
	// is true.
	AllowedWorkspaces []string
	// IDs of workspaces assigned to the pool. Note: this is a subset of
	// AllowedWorkspaces.
	AssignedWorkspaces []string
}

type ServerDaemonOptions struct {
	Logger                      *slog.Logger
	Config                      Config
	RunService                  *run.Service
	WorkspaceService            *workspace.Service
	VariableService             *variable.Service
	ConfigurationVersionService *configversion.Service
	StateService                *state.Service
	LogsService                 *logs.Service
	AgentService                Service
	HostnameService             *internal.HostnameService
}

type Service interface {
	AddHandlers(r *mux.Router)
	NewAllocator(logger *slog.Logger) *allocator
	NewManager() *manager
	CreateAgentPool(ctx context.Context, opts CreateAgentPoolOptions) (*Pool, error)
	GetAgentPool(ctx context.Context, poolID string) (*Pool, error)
	WatchAgentPools(ctx context.Context) (<-chan pubsub.Event[*Pool], func())
	WatchAgents(ctx context.Context) (<-chan pubsub.Event[*Agent], func())
	WatchJobs(ctx context.Context) (<-chan pubsub.Event[*Job], func())
	CreateAgentToken(ctx context.Context, poolID string, opts CreateAgentTokenOptions) (*agentToken, []byte, error)
	GetAgentToken(ctx context.Context, tokenID string) (*agentToken, error)
	ListAgentTokens(ctx context.Context, poolID string) ([]*agentToken, error)
	DeleteAgentToken(ctx context.Context, tokenID string) (*agentToken, error)
	// contains filtered or unexported methods
}

type ServiceOptions struct {
	Logger *slog.Logger
	*sql.Pool
	*sql.Listener
	html.Renderer
	*tfeapi.Responder

	RunService       *tofutfrun.Service
	WorkspaceService *workspace.Service
	TokensService    *tokens.Service
}

type ServiceWithTracing struct {
	Service
	// contains filtered or unexported fields
}