job

type Ctx ¶

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

Ctx is the per-run handle wick passes to a job through context. It carries the owning job's Key and a view onto the configs service so Run() can read its own runtime-editable config without re-plumbing the service down from main.

Construction is internal to wick — jobs receive a ready-made Ctx via job.FromContext(ctx) inside Run.

func FromContext(ctx context.Context) *Ctx

func NewCtx(owner string, cfg cfgReader) *Ctx

func (c *Ctx) Cfg(key string) string

func (c *Ctx) CfgBool(key string) bool

func (c *Ctx) CfgInt(key string) int

func (c *Ctx) CfgOf(owner, key string) string

func (c *Ctx) Owner() string

type Meta ¶

type Meta struct {
	Key         string
	Name        string
	Description string
	Icon        string
	DefaultCron string
	// DefaultTags works the same as tool.Tool.DefaultTags — seeded on
	// startup, linked to the job's path, and used for tag-based access
	// control in the admin UI.
	DefaultTags []tool.DefaultTag
	// AutoEnable forces Job.Enabled = true on every Bootstrap. Intended
	// for built-in maintenance jobs that ship pre-enabled and have no
	// user-facing toggle (typically combined with DefaultTags carrying
	// the System tag so the row is hidden from non-admin manager UI).
	// Admin-managed jobs leave this false — admins enable from the
	// /manager/jobs UI.
	AutoEnable bool
}

Meta holds the static metadata for a job instance. Downstream code passes one Meta per app.RegisterJob call — duplicating a module with a different Key + Meta registers a second scheduled instance backed by the same RunFunc.

type Module ¶

type Module struct {
	Meta    Meta
	Configs []entity.Config
	Run     RunFunc
}

Module is the internal, fully-resolved registration record wick keeps for every job. It is produced by app.RegisterJob — the Meta, any configs reflected from the paired typed struct, and the RunFunc itself. Downstream code does not construct Module directly.

type RunFunc ¶

type RunFunc func(ctx context.Context) (string, error)

RunFunc is the job-side run signature. It executes the job and returns a markdown-formatted result string. An empty string means "no output to display". Errors should be returned via the error value, not embedded in the result.

ctx carries a *Ctx (via FromContext) so Run can read this instance's runtime config, e.g. job.FromContext(ctx).Cfg("endpoint"). When the job needs process-wide state (a DB handle, an HTTP client, a cache), wrap RunFunc in a factory: func NewRun(db *sql.DB) job.RunFunc { ... }.