worker

type CmdExec struct {
	Name string
	Args []string
	// Env is added to the process's own environment.
	Env []string
}

type ConnectorPayload struct {
	Kind   string         `json:"kind"`
	Fields map[string]any `json:"fields"`
}

type Connectors struct {
	Handlers map[string]Exec
	Names    []string
	// Unconfigured are kinds this worker was asked to serve and holds no
	// configuration for, so it does not subscribe to them. It is reported at startup
	// rather than swallowed: "mail is not being served here" is the answer to why a
	// mail task is waiting, and the worker's log is in the Workers console.
	Unconfigured []string
}

type Exec interface {
	Run(ctx context.Context, j Job) (map[string]any, error)
}

type ExecFunc func(ctx context.Context, j Job) (map[string]any, error)

type Job struct {
	JobKey             uint64         `json:"jobKey"`
	Type               string         `json:"type"`
	ProcessInstanceKey uint64         `json:"processInstanceKey"`
	ElementInstanceKey uint64         `json:"elementInstanceKey"`
	ProcessDefKey      uint64         `json:"processDefKey"`
	ElementID          string         `json:"elementId"`
	Retries            int32          `json:"retries"`
	LeaseToken         uint64         `json:"leaseToken"`
	Variables          map[string]any `json:"variables"`
	// Connector is a connector task the engine resolved into plain values, present
	// only for a kind the server no longer serves itself (ADR-0168). Nil for a plain
	// job-worker task, whose work is the customer's own command.
	Connector *ConnectorPayload `json:"connector,omitempty"`
}

type Options struct {
	// Server is the base URL of the Atlas to work for, e.g. http://localhost:8080.
	Server string
	// ID names this worker. It rides on every lease and every report, and it is what
	// the Workers view shows — so give each deployment its own.
	ID string
	// Token, when set, is sent as a bearer credential on every request.
	Token string
	// Handlers is what this worker serves, keyed by job type. A worker with none is a
	// misconfiguration rather than a process that polls forever over nothing.
	Handlers map[string]Exec
	// Lease is how long the engine holds a job for this worker. It must comfortably
	// exceed how long the work takes: an elapsed lease puts the job back on offer, and
	// the report that finally arrives is fenced out.
	Lease time.Duration
	// Wait is how long a poll may block waiting for work before coming back empty.
	Wait time.Duration
	// Retry is how long to wait after a failed poll before trying again. A worker
	// must not exit because the server was restarting, or because the process using
	// its job type is not deployed yet — both are ordinary and both resolve.
	Retry time.Duration
	// MaxJobs is how many jobs one poll may lease. Keep it to what this worker can
	// actually run: leased work nobody is running is work nobody else can take either.
	MaxJobs int
	// Connectors are the connector names this worker holds credentials for, reported
	// to the engine on every poll. Only the worker knows them — once a kind is
	// offloaded the engine holds no credential for it — and the Workers view
	// subtracts them from what deployed models reference to show which names are
	// configured nowhere (ADR-0168). Empty for a worker that serves only plain job
	// types, which need no credential of their own.
	Connectors []string
	// HTTP is the client to use; nil means a default one bounded by Lease + Wait.
	HTTP *http.Client
}

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