tasks

package
v0.0.0-...-db92b10 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 11, 2026 License: MIT Imports: 42 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	// TypeString covers Go strings and named string types such as State.
	TypeString = "string"

	// TypeBool covers bool and *bool.
	TypeBool = "bool"

	// TypeInt covers every sized integer kind.
	TypeInt = "int"

	// TypeFloat covers float32 and float64. No task field uses one today.
	TypeFloat = "float"

	// TypeList is a slice or array field.
	TypeList = "list"

	// TypeDict is a map field.
	TypeDict = "dict"

	// TypeObject is a struct element inside a list, such as a PortMapping. It
	// never appears as a field's own type - a task has no bare struct field.
	TypeObject = "object"

	// TypeAny is an element with no declared type, as in map[string]any.
	TypeAny = "any"

	// TypeUnknown is the fallback for a Go kind none of the above covers.
	// TestCatalogFieldTypesAreKnown fails on it, so adding an exotic field type
	// to a task is a build failure rather than a leaked Go type name in the
	// published JSON.
	TypeUnknown = "unknown"
)

Field and item type names. These are the doc-facing type vocabulary, shared with the Parameters table the generator renders, and they are what the published JSON Schema enumerates.

View Source 
const (
	// IdentityRoleKey marks a field that decides which resource the task
	// manages. Declaration order is key order.
	IdentityRoleKey = "key"

	// IdentityRoleCollection marks a collection the task manages wholesale.
	IdentityRoleCollection = "collection"
)

Identity roles a field can carry, from its `identity:` struct tag.

View Source 
const (
	// PropertyScopeApp means the property has a per-app form, set by naming an
	// app.
	PropertyScopeApp = "app"

	// PropertyScopeGlobal means the property has a global form, set with
	// `global: true`.
	PropertyScopeGlobal = "global"
)

Scopes a property can be set in.

View Source 
const (
	// WarnReasonUnknownProperty marks a probe warning raised when a property's
	// key is absent from the plugin's JSON report (a stale key map or a dokku
	// version that does not emit it).
	WarnReasonUnknownProperty = "unknown_property"
	// WarnReasonProbeRejected marks a probe warning raised when an older plugin
	// rejects `:report --format json` outright.
	WarnReasonProbeRejected = "probe_rejected"
	// WarnReasonProbeIndeterminate marks a probe warning raised when a probe
	// ran, was understood, and still could not answer: the server holds the
	// state but will not reveal enough of it to compare. dokku's
	// registry:auth-status reports exactly that when a docker credential
	// helper or an identity token holds the secret, or when the config it
	// would read does not parse. The task drifts and applies rather than
	// assuming a match, so the warning is what tells the operator why a run
	// against that server never settles.
	WarnReasonProbeIndeterminate = "probe_indeterminate"
	// WarnReasonServiceImageDrift marks a warning raised when a datastore
	// service is running an image other than the one the recipe pins, and the
	// task is leaving it alone. Unlike the three above it is not a probe failure:
	// the state was read successfully and the task is declining to reconcile
	// it, because dokku's only remedy recreates the container. It also covers
	// the case where the running image could not be read at all, so a recipe
	// that asked for drift to be caught is never silently told everything is
	// fine.
	WarnReasonServiceImageDrift = "service_image_drift"
)
View Source 
const CatalogVersion = 1

CatalogVersion is the wire-format version every emitted catalog carries in its `version` field.

It is deliberately independent of the --json event stream's version (commands.jsonSchemaVersion): the two are different formats with different consumers, and a breaking change to one must not force the other's consumers to re-branch. Bumps are reserved for breaking changes; adding a key within a major version does not bump.

View Source 
const FormatNameHCL = "hcl"

FormatNameHCL is the canonical name of the HCL codec.

View Source 
const FormatNameJSON5 = "json5"

FormatNameJSON5 is the canonical name of the JSON5 codec. It is spelled with "Name" because FormatJSON5 is already the JSON5 formatter.

View Source 
const FormatYAML = "yaml"

FormatYAML is the canonical name of the YAML codec.

View Source 
const PropertyFieldName = "property"

PropertyFieldName is the recipe key every property table constrains.

Variables

View Source 
var (
	InputBoolTrueSpellings  = []string{"true", "yes", "on", "y", "t", "1"}
	InputBoolFalseSpellings = []string{"false", "no", "off", "n", "f", "0"}
)

InputBoolTrueSpellings and InputBoolFalseSpellings are the spellings a bool input value may be written in, in the order diagnostics list them. They are the union of docket's own vocabulary and pflag's, so the set is a superset of what `strconv.ParseBool` takes: every spelling that works on the command line also works as a `default:` or a --vars-file value (#495).

View Source 
var InputTypeNames = []string{"bool", "float", "int", "string"}

InputTypeNames lists the `type:` values an input may declare, in the canonical order diagnostics spell them. An input that declares no `type:` is a string.

View Source 
var ReservedInputNames = map[string]bool{
	"tasks":                true,
	"tasks-format":         true,
	"host":                 true,
	"verbose":              true,
	"json":                 true,
	"no-color":             true,
	"tags":                 true,
	"skip-tags":            true,
	"sudo":                 true,
	"play":                 true,
	"vars-file":            true,
	"fail-fast":            true,
	"list-tasks":           true,
	"start-at-task":        true,
	"accept-new-host-keys": true,
	"detailed-exitcode":    true,
	"strict":               true,
	"output":               true,
	"force":                true,
	"plan":                 true,
}

ReservedInputNames is the set of recipe input names that collide with a built-in CLI flag on apply, plan, or validate. Declaring an input with one of these names used to make pflag panic with "flag redefined" before flag parsing even began; the loader and validator now reject it as reserved_input_name instead, and registerInputFlags skips it so no command panics. The set is the union of the built-in flags across the input-accepting commands, so validate flags the same names apply and plan would collide with. help / v / version are intentionally absent - they are handled by the CLI framework, not registered on the flag set, so they work as input names. A commands-package test keeps this set in sync with the real flag sets.

Functions

func As 

func As[T Task](e ExportedTask) (T, bool)

As returns e's body as the task type T, and false when the body is any other type, so a caller reads fields without hand-writing an assertion on Body: 

if cfg, ok := tasks.As[tasks.ConfigTask](task); ok { ... }

Pass the value type. Bodies are never pointers, so As[*ConfigTask] is always false. If an exporter ever needs to return a pointer, this and exportedBodyType are the places to absorb it.

func BuildPerPlayContext 

func BuildPerPlayContext(base map[string]interface{}, playInputs []Input, userSet map[string]bool) map[string]interface{}

BuildPerPlayContext layers the play's `inputs:` defaults above the file-level base context, but only for keys the user has not explicitly overridden via --vars-file or CLI flags. The userSet map carries the names of user-overridden inputs; nil disables the layering, which is the GetTasks back-compat behaviour. Per-play defaults with an empty Default string are skipped so they cannot accidentally shadow a real file-level value with "".

A default is layered in resolved to its declared type, matching the value the base context already holds for the same input from flag registration. Injecting the raw text instead made a play-local `type: bool, default: on` render as `on` where the file-level half rendered `true`, and made `when: 'debug == true'` compare a string to a bool (#495).

Exported because the apply / plan executors need to build the same per-play context the loader used so per-task `when:` predicates see the same values as the rendered task bodies.

func CanonicalInputType 

func CanonicalInputType(t string) (string, bool)

CanonicalInputType maps a declared `type:` onto its canonical spelling, resolving the empty type to "string". ok is false for a type docket does not implement, which the validator reports as invalid_input_type.

func CodecExtensions 

func CodecExtensions() []string

CodecExtensions returns every recognised recipe file extension, without leading dots, in codec order and then in each codec's own order. It backs file-completion and the positional-recipe-path check.

func CodecNames 

func CodecNames() []string

CodecNames returns the canonical format names in priority order. It backs shell completion for --tasks-format / --format and the list an invalid value is rejected against, so those two can never disagree.

func CollectEnvelopeNames 

func CollectEnvelopeNames(envs []*TaskEnvelope) []string

CollectEnvelopeNames returns every leaf and group envelope name reachable from envs, walking block / rescue / always recursively. Names appear in source order and are de-duplicated. Used by the --start-at-task validators (apply.go and internal/tasks/validate.go) to build the "available names" hint shown when no task matched.

func CollectPlaySensitiveValues 

func CollectPlaySensitiveValues(plays []*Play) []string

CollectPlaySensitiveValues is the multi-play sibling of CollectSensitiveValues. It walks every task across every play and returns the union of sensitive values, in play-then-task order.

func CollectSensitiveValues 

func CollectSensitiveValues(tasks OrderedStringEnvelopeMap) []string

CollectSensitiveValues walks every task in tasks and returns the union of values that must be masked in user-facing output. A value is included when either:

  • it lives in a struct field carrying the `sensitive:"true"` struct tag, or
  • the task implements SensitiveOverride and the method returns it.

String, []string, and map[string]string fields are supported. Nested structs and pointers are walked recursively. block/rescue/always group envelopes carry no task of their own, so their child envelopes are walked recursively to any depth. Empty values are dropped by the subprocess masker, not here.

func CompilePredicate 

func CompilePredicate(src string) (*vm.Program, error)

CompilePredicate compiles src as an expr-lang/expr program suitable for envelope predicates (when:, changed_when:, failed_when:, scalar-form loop:). Returns the cached compiled program when src has already been compiled. Empty src returns (nil, nil); callers should treat nil as "no predicate".

The compiler is configured with AllowUndefinedVariables so a predicate referencing a context key that the apply / plan path has not populated yet (e.g. .registered.foo before #210 lands) does not error at compile time - it evaluates to nil at runtime.

func Convert 

func Convert(data []byte, from, to Codec) ([]byte, error)

Convert renders a recipe written in the from codec as the same recipe in the to codec, canonically formatted.

Comments survive, which is the whole point: `docket fmt` preserves them within a format, so a conversion that dropped them would be no better than the trip through an external tool that #418 exists to replace.

func DoubleQuoteEscape 

func DoubleQuoteEscape(v interface{}) (string, error)

DoubleQuoteEscape escapes v for interpolation inside a double-quoted YAML (or JSON5) scalar, returning the escaped body WITHOUT the surrounding quotes so the caller keeps its own. JSON string escaping is a subset of YAML's double-quoted escaping, so json.Marshal produces a body that both parsers accept; HTML escaping is disabled so `<`, `>`, and `&` stay readable.

func EnvelopeContainsName 

func EnvelopeContainsName(env *TaskEnvelope, target string) bool

EnvelopeContainsName reports whether env or any of its block / rescue / always descendants has Name == target. Used by --start-at-task gating so the executor enters a group whose child matches the target rather than skipping the entire group.

func EnvelopePassesTags 

func EnvelopePassesTags(env *TaskEnvelope, includes, skips []string) bool

EnvelopePassesTags reports whether env survives the include (--tags) and skip (--skip-tags) filters, using the same rules FilterByTags applies per key:

  • No flags supplied: always kept.
  • --tags supplied: kept iff env's tag set intersects includes; untagged envelopes are excluded.
  • --skip-tags supplied: dropped iff env's tag set intersects skips; untagged envelopes are kept.
  • Both: --tags narrows first, then --skip-tags drops.

func EvalBool 

func EvalBool(prog *vm.Program, env map[string]interface{}) (bool, error)

EvalBool runs prog against env and reports the truthiness of the result. Non-bool results are coerced by truthy, which follows the standard expr truth rules (nil, 0, "", and empty collections are false; everything else is true). Returns an error when the program errors at run time.

func EvalList 

func EvalList(prog *vm.Program, env map[string]interface{}) ([]interface{}, error)

EvalList runs prog against env and asserts that the result is a list. Returns an error when the program errors or returns a non-list value.

func FileLevelInputNames 

func FileLevelInputNames(plays []*Play) map[string]bool

FileLevelInputNames returns the set of input names declared on "inputs-only" plays (plays with no tasks). Inputs on plays with tasks are play-local: their defaults are visible to that play's tasks but not to any play's `when:` and not to other plays' tasks.

Used by the apply / plan executors to build the file-level context the spec requires for per-play `when:` evaluation: file-level input defaults plus user overrides only, without play-local defaults leaking in.

func FilterByTags 

func FilterByTags(m OrderedStringEnvelopeMap, includes, skips []string) []string

FilterByTags returns the subset of m's keys that satisfy the include (--tags) and skip (--skip-tags) filters. Rules:

  • No flags supplied: every key.
  • --tags only: keep iff tag set intersects includes; untagged tasks are excluded.
  • --skip-tags only: drop iff tag set intersects skips; untagged tasks are kept.
  • Both: --tags narrows first, then --skip-tags drops from the result.

The order of the returned keys mirrors m.Keys() (insertion order).

func Format 

func Format(data []byte) ([]byte, error)

Format returns the canonical form of data. err is non-nil only on a yaml.v3 parse error or when the round-trip equivalence guard fails.

The formatter:

  • Uses yaml.v3's Node API so head/line/foot comments survive.
  • Indents with 2 spaces.
  • Reorders task envelope keys per canonicalEnvelopeKeys (task-type key last) and play keys per canonicalPlayKeys.
  • Inserts a blank line between top-level plays and between top-level task entries inside a play's tasks: list.
  • Strips trailing whitespace and forces LF line endings.
  • Re-parses the canonical output and aborts unless the original and canonical AST trees are structurally equivalent (defends against yaml.v3 emitter edge cases with anchors / complex flow scalars).

func FormatHCL 

func FormatHCL(data []byte) ([]byte, error)

FormatHCL returns the canonical form of an HCL recipe.

It is Format's shape for the third syntax: decode to the interchange tree, write it back out, then re-read the result and refuse to return it unless the two trees agree - so an emitter bug can never corrupt a recipe. An empty or comment-only file comes back untouched, as it does in YAML.

func FormatJSON5 

func FormatJSON5(data []byte) ([]byte, error)

FormatJSON5 returns the canonical JSON5 form of data. err is non-nil only on a parse error or when the round-trip equivalence guard fails.

The formatter mirrors the YAML Format() contract, adapted to JSON5:

  • 2-space indentation.
  • Reorders play and task envelope keys per canonicalPlayKeys / canonicalEnvelopeKeys (task-type key last). Members not in the canonical list keep their relative order, appended afterwards.
  • Inserts a blank line between top-level plays and between top- level task entries inside a play's tasks list, matching the YAML formatter so a JSON5 recipe and its YAML twin look the same.
  • Always emits trailing commas on multiline objects and arrays to match JSON5 community convention.
  • Quotes string values with double quotes; quotes object keys only when they are not valid JSON5 identifiers.
  • Preserves line and block comments in their original anchor position (before a member, beside it on the same line, or after the last member of a container).
  • Re-parses the canonical output and aborts unless the original and canonical AST trees are structurally equivalent. Catches emitter edge cases before the caller writes anything to disk.

func HCLDoubleQuoteEscape 

func HCLDoubleQuoteEscape(v interface{}) (string, error)

HCLDoubleQuoteEscape is `dq` for an HCL recipe.

HCL's quoted string is a template of its own: `${` opens an interpolation and `%{` a control sequence, neither of which YAML or JSON5 attaches any meaning to. A substituted value carrying either would be read as HCL syntax rather than as text, so both are doubled on the way in - the escape HCL itself defines. Everything else is DoubleQuoteEscape's JSON escaping, which HCL's quoted string accepts unchanged.

The doubling runs after the JSON escaping and is safe to apply blindly: a value that already contains `$${` lands as `$$${`, which HCL scans as a literal `$` followed by the escape, giving `$${` back.

func HCLScalar 

func HCLScalar(v interface{}) (string, error)

HCLScalar renders v as a complete HCL string literal, quotes included, for the `docket init` scaffold. It is the HCL sibling of YAMLScalar and JSONScalar and, like them, is not a recipe-render filter: its output carries its own quoting and so cannot sit inside an existing quoted scalar.

func IdentityAddress 

func IdentityAddress(typeKey string, t Task) string

IdentityAddress renders the resource t addresses as `dokku_config[app=api]`. Keys appear in declaration order; keys holding their zero value are omitted, so a task with no key value at all renders as the bare type key.

The result is a parseable surface, not just a label: it is the auto-generated task name in the `--json` event stream, the argument `--start-at-task` accepts, and the argument `export --resource` accepts. Values are therefore never truncated - a lossy address could not be resolved back.

func IdentityKeyNames 

func IdentityKeyNames(t Task) []string

IdentityKeyNames returns the yaml names of t's declared keys, in declaration order. Used by the docs generator, which reads a registry prototype and so has no values to render.

func IdentityMatches 

func IdentityMatches(t Task, want map[string]string) bool

IdentityMatches reports whether every key in want matches t's value for that key. A key naming a field t does not declare never matches. Used by `export --resource` to narrow the bodies an exporter returned.

func JSONScalar 

func JSONScalar(v interface{}) (string, error)

JSONScalar renders s as a JSON string literal (also valid JSON5), used by the JSON5 init scaffold so an embedded quote or backslash is escaped.

func ParseIdentityAddress 

func ParseIdentityAddress(address string) (string, map[string]string, error)

ParseIdentityAddress parses `dokku_config[app=api]` into its type key and key map. A bare type key parses to an empty map, which `export --resource` reads as "every resource of this type".

The parse is strict: it rejects an auto-generated task name carrying a collision ordinal (`dokku_config[app=api] #2`), because that names a task, not a resource, and two tasks can address one resource.

func ParseInputBool 

func ParseInputBool(s string) (bool, bool)

ParseInputBool parses the string spelling of a bool input value - a recipe `default:` or a --vars-file scalar - into a bool. Matching is case-insensitive, so `True` and `TRUE` read the same as `true`. ok is false for any other spelling, the empty string included: a caller that treats an omitted default as the type's zero value checks for that before asking.

The table is a superset of the one pflag parses a `--name=value` flag with, which is what keeps the two from disagreeing about the same recipe. It is not a subset: `yes` and `on` are docket's alone, so they remain unusable on the command line. See docs/inputs.md.

func ParseInputFloat 

func ParseInputFloat(s string) (float64, bool)

ParseInputFloat parses the string spelling of a float input value. ok is false when the spelling is not a number, the empty string included.

func ParseInputInt 

func ParseInputInt(s string) (int, bool)

ParseInputInt parses the string spelling of an int input value. ok is false when the spelling is not a whole number, the empty string included.

func PredicateIdentifiers 

func PredicateIdentifiers(src string) (map[string]bool, error)

PredicateIdentifiers returns the set of root identifiers src references. Only the root of a lookup chain counts: `registered.first` yields `registered`, because expr parses the `.first` half as a string property rather than an identifier. A quoted "registered" is a string literal and is likewise absent.

Callers use this to tell whether a predicate depends on a value that only exists while a recipe runs, which a substring match over the raw source cannot do without also matching an input named `registered_at` or a field access `x.failed_task`.

Returns an error when src does not parse. A predicate reaching a caller has already been through CompilePredicate, so in practice this only fires for sources that never came from a loaded recipe.

func RegisterTask 

func RegisterTask(t Task)

RegisterTask registers a task under `dokku_` plus its type name in snake_case with the `_task` suffix dropped, so &AppTask{} becomes dokku_app.

func RenderTemplate 

func RenderTemplate(input []byte, vars map[string]interface{}, name string) (bytes.Buffer, error)

RenderTemplate renders input with vars as the default surface syntax.

It is the spelling for a caller with no format to hand: a loop body, which is re-rendered from the YAML bytes the codec has already normalised whatever the recipe was written in, and the tests. A caller holding the recipe's own format uses RenderTemplateWithFormat.

func RenderTemplateWithFormat 

func RenderTemplateWithFormat(input []byte, vars map[string]interface{}, name, format string) (bytes.Buffer, error)

RenderTemplateWithFormat renders input with vars as the given surface syntax, under the render lock. Every render in docket goes through it.

func TaskDeprecation 

func TaskDeprecation(t Task) string

TaskDeprecation returns the deprecation notice for t, or "" when t does not implement DeprecationDocer. Centralised so docs generation, the list-tasks renderer, and the apply/plan executors share one read site.

func TaskSynopsis 

func TaskSynopsis(t Task) string

TaskSynopsis returns the docblock for t, or "" when t does not implement Documented. Centralised so the catalog and the coverage test share one read site, mirroring TaskDeprecation.

func TaskTypes 

func TaskTypes() []string

TaskTypes returns every registered task type, sorted. The result is a fresh slice, so a caller may sort, filter or truncate it without disturbing the registry.

func YAMLScalar 

func YAMLScalar(v interface{}) (string, error)

YAMLScalar renders s as a complete YAML scalar, quoting and escaping only when necessary so ordinary values stay unquoted. Used by internal/commands/init.go to emit an input's `default:` in the scaffold; it is not a recipe-render filter because its output carries its own quoting and so cannot sit inside an existing quoted scalar.

Types

type AclAppTask 

type AclAppTask struct {
	// App is the name of the app
	App string `required:"true" identity:"key" yaml:"app" description:"Name of the app"`

	// Users is the list of users to add, remove, or set on the ACL
	Users []string `` /* 147-byte string literal not displayed */

	// State is the desired state of the ACL entries
	State State `` /* 139-byte string literal not displayed */
}

AclAppTask manages the dokku-acl access list for a dokku application

func (AclAppTask) Doc 

func (t AclAppTask) Doc() string

Doc returns the docblock for the acl app task

func (AclAppTask) Execute 

func (t AclAppTask) Execute(ctx context.Context) TaskOutputState

Execute manages the app ACL

func (AclAppTask) ExportApp 

func (t AclAppTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs the app's ACL user list, or nil when it is empty. state:set replaces the whole list for an exact match.

func (AclAppTask) ExportSupport 

func (t AclAppTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (AclAppTask) Plan 

func (t AclAppTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the AclAppTask would produce.

func (AclAppTask) ProbeSupport 

func (t AclAppTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (AclAppTask) Requirements 

func (t AclAppTask) Requirements() []string

Requirements lists the non-core dokku plugins this task depends on.

func (AclAppTask) Validate 

func (t AclAppTask) Validate() error

Validate checks the AclAppTask's inputs without contacting the server, so `docket validate` and Plan() surface the same errors.

type AclAppTaskExample 

type AclAppTaskExample struct {
	// Name is the task name holding the AclAppTask description
	Name string `yaml:"-"`

	// AclAppTask is the AclAppTask configuration
	AclAppTask AclAppTask `yaml:"dokku_acl_app"`
}

AclAppTaskExample contains an example of an AclAppTask

func (AclAppTaskExample) GetName 

func (e AclAppTaskExample) GetName() string

GetName returns the name of the example

type AclServiceTask 

type AclServiceTask struct {
	// Service is the name of the service instance
	Service string `required:"true" identity:"key" yaml:"service" description:"Name of the service instance"`

	// Type is the type of service (e.g. redis, postgres)
	Type string `required:"true" identity:"key" yaml:"type" description:"Type of service (e.g. redis, postgres)"`

	// Users is the list of users to add, remove, or set on the ACL
	Users []string `` /* 147-byte string literal not displayed */

	// State is the desired state of the ACL entries
	State State `` /* 139-byte string literal not displayed */
}

AclServiceTask manages the dokku-acl access list for a dokku service

func (AclServiceTask) Doc 

func (t AclServiceTask) Doc() string

Doc returns the docblock for the acl service task

func (AclServiceTask) Execute 

func (t AclServiceTask) Execute(ctx context.Context) TaskOutputState

Execute manages the service ACL

func (AclServiceTask) ExportGlobal 

func (t AclServiceTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reconstructs the dokku-acl access list of every datastore service on the server. Discovery is via listServices; the members are read from `acl:list-service <type> <name>` (reusing getAclServiceUsers). Note the field inversion versus the other service tasks: Service holds the instance name and Type the datastore type. Services with no ACL entries - and every service when the dokku-acl plugin is absent - are skipped. state:set replaces the whole list for an exact match.

func (AclServiceTask) ExportSupport 

func (t AclServiceTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (AclServiceTask) Plan 

func (t AclServiceTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the AclServiceTask would produce.

func (AclServiceTask) ProbeSupport 

func (t AclServiceTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (AclServiceTask) Requirements 

func (t AclServiceTask) Requirements() []string

Requirements lists the non-core dokku plugins this task depends on.

func (AclServiceTask) Validate 

func (t AclServiceTask) Validate() error

Validate checks the AclServiceTask's inputs without contacting the server.

type AclServiceTaskExample 

type AclServiceTaskExample struct {
	// Name is the task name holding the AclServiceTask description
	Name string `yaml:"-"`

	// AclServiceTask is the AclServiceTask configuration
	AclServiceTask AclServiceTask `yaml:"dokku_acl_service"`
}

AclServiceTaskExample contains an example of an AclServiceTask

func (AclServiceTaskExample) GetName 

func (e AclServiceTaskExample) GetName() string

GetName returns the name of the example

type AppCloneTask 

type AppCloneTask struct {
	// App is the name of the new (target) app
	App string `required:"true" identity:"key" yaml:"app" description:"Name of the new (target) app"`

	// SourceApp is the name of the existing app to clone from
	SourceApp string `required:"true" yaml:"source_app" description:"Name of the existing app to clone from"`

	// SkipDeploy skips deployment of the cloned app
	SkipDeploy bool `required:"false" yaml:"skip_deploy,omitempty" description:"Skip deployment of the cloned app"`

	// State is the desired state of the cloned app
	State State `required:"false" yaml:"state,omitempty" default:"present" options:"present" description:"Desired state of the cloned app"`
}

AppCloneTask clones an existing dokku app to a new app

func (AppCloneTask) Doc 

func (t AppCloneTask) Doc() string

Doc returns the docblock for the app clone task

func (AppCloneTask) Execute 

func (t AppCloneTask) Execute(ctx context.Context) TaskOutputState

Execute clones an existing dokku app to a new app

func (AppCloneTask) ExportSupport 

func (t AppCloneTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (AppCloneTask) Plan 

func (t AppCloneTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the AppCloneTask would produce.

func (AppCloneTask) ProbeSupport 

func (t AppCloneTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (AppCloneTask) Validate 

func (t AppCloneTask) Validate() error

Validate checks the AppCloneTask's inputs without contacting the server.

type AppCloneTaskExample 

type AppCloneTaskExample struct {
	// Name is the task name holding the AppCloneTask description
	Name string `yaml:"-"`

	// AppCloneTask is the AppCloneTask configuration
	AppCloneTask AppCloneTask `yaml:"dokku_app_clone"`
}

AppCloneTaskExample contains an example of an AppCloneTask

func (AppCloneTaskExample) GetName 

func (e AppCloneTaskExample) GetName() string

GetName returns the name of the example

type AppDeploySource 

type AppDeploySource struct {
	Source         string `json:"app-deploy-source"`
	SourceMetadata string `json:"app-deploy-source-metadata"`
}

AppDeploySource contains deploy source information from apps:report

type AppExporter 

type AppExporter interface {
	ExportApp(ctx context.Context, app string) ([]interface{}, error)
}

AppExporter is implemented by a task type that can reconstruct its recipe representation for a single app from live server state. ExportApp returns zero or more task bodies (each the task's own struct, populated with real values); the engine wraps each under the task's type-key and applies vars-extraction/redaction uniformly afterwards.

For an app that does not exist, ExportApp must return an error or no bodies. A --resource run that pins its apps does not list the server's apps first, so it relies on this to tell a missing app from one that has nothing to export. dokku_app is the one exception - it reads nothing and always returns its body - and the engine confirms that app exists itself (see exportPinnedAppPlay).

type AppJsonPropertyTask 

type AppJsonPropertyTask PropertyFields

AppJsonPropertyTask manages the app.json configuration for a given dokku application

func (AppJsonPropertyTask) Doc 

func (t AppJsonPropertyTask) Doc() string

Doc returns the docblock for the app.json property task

func (AppJsonPropertyTask) Execute 

func (t AppJsonPropertyTask) Execute(ctx context.Context) TaskOutputState

Execute sets or unsets the app.json property

func (AppJsonPropertyTask) ExportApp 

func (t AppJsonPropertyTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs the app's explicitly-set properties.

func (AppJsonPropertyTask) ExportGlobal 

func (t AppJsonPropertyTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reconstructs the globally-set properties.

func (AppJsonPropertyTask) ExportSupport 

func (t AppJsonPropertyTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (AppJsonPropertyTask) Plan 

func (t AppJsonPropertyTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the AppJsonPropertyTask would produce.

func (AppJsonPropertyTask) ProbeSupport 

func (t AppJsonPropertyTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (AppJsonPropertyTask) Validate 

func (t AppJsonPropertyTask) Validate() error

Validate checks the AppJsonPropertyTask's inputs without contacting the server.

type AppJsonPropertyTaskExample 

type AppJsonPropertyTaskExample struct {
	// Name is the task name holding the AppJsonPropertyTask description
	Name string `yaml:"-"`

	// AppJsonPropertyTask is the AppJsonPropertyTask configuration
	AppJsonPropertyTask AppJsonPropertyTask `yaml:"dokku_app_json_property"`
}

AppJsonPropertyTaskExample contains an example of an AppJsonPropertyTask

func (AppJsonPropertyTaskExample) GetName 

func (e AppJsonPropertyTaskExample) GetName() string

GetName returns the name of the example

type AppLockTask 

type AppLockTask struct {
	// App is the name of the app
	App string `required:"true" identity:"key" yaml:"app" description:"Name of the app"`

	// State is the desired lock state
	State State `required:"false" yaml:"state,omitempty" default:"present" options:"present,absent" description:"Desired lock state"`
}

AppLockTask locks or unlocks a dokku application from deployment

func (AppLockTask) Doc 

func (t AppLockTask) Doc() string

Doc returns the docblock for the app lock task

func (AppLockTask) Execute 

func (t AppLockTask) Execute(ctx context.Context) TaskOutputState

Execute locks or unlocks the app

func (AppLockTask) ExportApp 

func (t AppLockTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp emits a dokku_app_lock task only when the app is locked (apps are unlocked by default).

func (AppLockTask) ExportSupport 

func (t AppLockTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (AppLockTask) Plan 

func (t AppLockTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the AppLockTask would produce.

func (AppLockTask) ProbeSupport 

func (t AppLockTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

type AppLockTaskExample 

type AppLockTaskExample struct {
	// Name is the task name holding the AppLockTask description
	Name string `yaml:"-"`

	// AppLockTask is the AppLockTask configuration
	AppLockTask AppLockTask `yaml:"dokku_app_lock"`
}

AppLockTaskExample contains an example of an AppLockTask

func (AppLockTaskExample) GetName 

func (e AppLockTaskExample) GetName() string

GetName returns the name of the example

type AppTask 

type AppTask struct {
	// App is the name of the app
	App string `required:"true" identity:"key" yaml:"app" description:"Name of the app"`

	// State is the state of the app
	State State `required:"false" yaml:"state,omitempty" default:"present" options:"present,absent" description:"State of the app"`
}

AppTask creates or destroys an app

func (AppTask) Doc 

func (t AppTask) Doc() string

Doc returns the docblock for the app task

func (AppTask) Execute 

func (t AppTask) Execute(ctx context.Context) TaskOutputState

Execute creates or destroys an app

func (AppTask) ExportApp 

func (t AppTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs the app itself. Enumeration already confirmed the app exists, so this simply declares it present (its default state).

func (AppTask) ExportSupport 

func (t AppTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (AppTask) Plan 

func (t AppTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the AppTask would produce.

func (AppTask) ProbeSupport 

func (t AppTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

type AppTaskExample 

type AppTaskExample struct {
	// Name is the task name holding the AppTask description
	Name string `yaml:"-"`

	// DokkuApp is the AppTask configuration
	DokkuApp AppTask `yaml:"dokku_app"`
}

AppTaskExample contains an example of an AppTask

func (AppTaskExample) GetName 

func (e AppTaskExample) GetName() string

GetName returns the name of the example

type AppsPropertyTask 

type AppsPropertyTask PropertyFields

AppsPropertyTask manages the apps plugin configuration for a given dokku application or globally

func (AppsPropertyTask) Doc 

func (t AppsPropertyTask) Doc() string

Doc returns the docblock for the apps property task

func (AppsPropertyTask) Execute 

func (t AppsPropertyTask) Execute(ctx context.Context) TaskOutputState

Execute sets or unsets the apps property

func (AppsPropertyTask) ExportApp 

func (t AppsPropertyTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs the app's explicitly-set properties.

func (AppsPropertyTask) ExportGlobal 

func (t AppsPropertyTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reconstructs the globally-set properties.

func (AppsPropertyTask) ExportSupport 

func (t AppsPropertyTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (AppsPropertyTask) Plan 

func (t AppsPropertyTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the AppsPropertyTask would produce.

func (AppsPropertyTask) ProbeSupport 

func (t AppsPropertyTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (AppsPropertyTask) Validate 

func (t AppsPropertyTask) Validate() error

Validate checks the AppsPropertyTask's inputs without contacting the server.

type AppsPropertyTaskExample 

type AppsPropertyTaskExample struct {
	// Name is the task name holding the AppsPropertyTask description
	Name string `yaml:"-"`

	// AppsPropertyTask is the AppsPropertyTask configuration
	AppsPropertyTask AppsPropertyTask `yaml:"dokku_apps_property"`
}

AppsPropertyTaskExample contains an example of an AppsPropertyTask

func (AppsPropertyTaskExample) GetName 

func (e AppsPropertyTaskExample) GetName() string

GetName returns the name of the example

type BuilderDockerfilePropertyTask 

type BuilderDockerfilePropertyTask PropertyFields

BuilderDockerfilePropertyTask manages the builder-dockerfile configuration for a given dokku application

func (BuilderDockerfilePropertyTask) Doc 

func (t BuilderDockerfilePropertyTask) Doc() string

Doc returns the docblock for the builder-dockerfile property task

func (BuilderDockerfilePropertyTask) Execute 

func (t BuilderDockerfilePropertyTask) Execute(ctx context.Context) TaskOutputState

Execute sets or unsets the builder-dockerfile property

func (BuilderDockerfilePropertyTask) ExportApp 

func (t BuilderDockerfilePropertyTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs the app's explicitly-set properties.

func (BuilderDockerfilePropertyTask) ExportGlobal 

func (t BuilderDockerfilePropertyTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reconstructs the globally-set properties.

func (BuilderDockerfilePropertyTask) ExportSupport 

func (t BuilderDockerfilePropertyTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (BuilderDockerfilePropertyTask) Plan 

func (t BuilderDockerfilePropertyTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the BuilderDockerfilePropertyTask would produce.

func (BuilderDockerfilePropertyTask) ProbeSupport 

func (t BuilderDockerfilePropertyTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (BuilderDockerfilePropertyTask) Validate 

func (t BuilderDockerfilePropertyTask) Validate() error

Validate checks the BuilderDockerfilePropertyTask's inputs without contacting the server.

type BuilderDockerfilePropertyTaskExample 

type BuilderDockerfilePropertyTaskExample struct {
	// Name is the task name holding the BuilderDockerfilePropertyTask description
	Name string `yaml:"-"`

	// BuilderDockerfilePropertyTask is the BuilderDockerfilePropertyTask configuration
	BuilderDockerfilePropertyTask BuilderDockerfilePropertyTask `yaml:"dokku_builder_dockerfile_property"`
}

BuilderDockerfilePropertyTaskExample contains an example of a BuilderDockerfilePropertyTask

func (BuilderDockerfilePropertyTaskExample) GetName 

func (e BuilderDockerfilePropertyTaskExample) GetName() string

GetName returns the name of the example

type BuilderHerokuishPropertyTask 

type BuilderHerokuishPropertyTask PropertyFields

BuilderHerokuishPropertyTask manages the builder-herokuish configuration for a given dokku application

func (BuilderHerokuishPropertyTask) Doc 

func (t BuilderHerokuishPropertyTask) Doc() string

Doc returns the docblock for the builder-herokuish property task

func (BuilderHerokuishPropertyTask) Execute 

func (t BuilderHerokuishPropertyTask) Execute(ctx context.Context) TaskOutputState

Execute sets or unsets the builder-herokuish property

func (BuilderHerokuishPropertyTask) ExportApp 

func (t BuilderHerokuishPropertyTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs the app's explicitly-set properties.

func (BuilderHerokuishPropertyTask) ExportGlobal 

func (t BuilderHerokuishPropertyTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reconstructs the globally-set properties.

func (BuilderHerokuishPropertyTask) ExportSupport 

func (t BuilderHerokuishPropertyTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (BuilderHerokuishPropertyTask) Plan 

func (t BuilderHerokuishPropertyTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the BuilderHerokuishPropertyTask would produce.

func (BuilderHerokuishPropertyTask) ProbeSupport 

func (t BuilderHerokuishPropertyTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (BuilderHerokuishPropertyTask) Validate 

func (t BuilderHerokuishPropertyTask) Validate() error

Validate checks the BuilderHerokuishPropertyTask's inputs without contacting the server.

type BuilderHerokuishPropertyTaskExample 

type BuilderHerokuishPropertyTaskExample struct {
	// Name is the task name holding the BuilderHerokuishPropertyTask description
	Name string `yaml:"-"`

	// BuilderHerokuishPropertyTask is the BuilderHerokuishPropertyTask configuration
	BuilderHerokuishPropertyTask BuilderHerokuishPropertyTask `yaml:"dokku_builder_herokuish_property"`
}

BuilderHerokuishPropertyTaskExample contains an example of a BuilderHerokuishPropertyTask

func (BuilderHerokuishPropertyTaskExample) GetName 

func (e BuilderHerokuishPropertyTaskExample) GetName() string

GetName returns the name of the example

type BuilderLambdaPropertyTask 

type BuilderLambdaPropertyTask PropertyFields

BuilderLambdaPropertyTask manages the builder-lambda configuration for a given dokku application

func (BuilderLambdaPropertyTask) Doc 

func (t BuilderLambdaPropertyTask) Doc() string

Doc returns the docblock for the builder-lambda property task

func (BuilderLambdaPropertyTask) Execute 

func (t BuilderLambdaPropertyTask) Execute(ctx context.Context) TaskOutputState

Execute sets or unsets the builder-lambda property

func (BuilderLambdaPropertyTask) ExportApp 

func (t BuilderLambdaPropertyTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs the app's explicitly-set properties.

func (BuilderLambdaPropertyTask) ExportGlobal 

func (t BuilderLambdaPropertyTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reconstructs the globally-set properties.

func (BuilderLambdaPropertyTask) ExportSupport 

func (t BuilderLambdaPropertyTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (BuilderLambdaPropertyTask) Plan 

func (t BuilderLambdaPropertyTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the BuilderLambdaPropertyTask would produce.

func (BuilderLambdaPropertyTask) ProbeSupport 

func (t BuilderLambdaPropertyTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (BuilderLambdaPropertyTask) Validate 

func (t BuilderLambdaPropertyTask) Validate() error

Validate checks the BuilderLambdaPropertyTask's inputs without contacting the server.

type BuilderLambdaPropertyTaskExample 

type BuilderLambdaPropertyTaskExample struct {
	// Name is the task name holding the BuilderLambdaPropertyTask description
	Name string `yaml:"-"`

	// BuilderLambdaPropertyTask is the BuilderLambdaPropertyTask configuration
	BuilderLambdaPropertyTask BuilderLambdaPropertyTask `yaml:"dokku_builder_lambda_property"`
}

BuilderLambdaPropertyTaskExample contains an example of a BuilderLambdaPropertyTask

func (BuilderLambdaPropertyTaskExample) GetName 

func (e BuilderLambdaPropertyTaskExample) GetName() string

GetName returns the name of the example

type BuilderNixpacksPropertyTask 

type BuilderNixpacksPropertyTask PropertyFields

BuilderNixpacksPropertyTask manages the builder-nixpacks configuration for a given dokku application

func (BuilderNixpacksPropertyTask) Doc 

func (t BuilderNixpacksPropertyTask) Doc() string

Doc returns the docblock for the builder-nixpacks property task

func (BuilderNixpacksPropertyTask) Execute 

func (t BuilderNixpacksPropertyTask) Execute(ctx context.Context) TaskOutputState

Execute sets or unsets the builder-nixpacks property

func (BuilderNixpacksPropertyTask) ExportApp 

func (t BuilderNixpacksPropertyTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs the app's explicitly-set properties.

func (BuilderNixpacksPropertyTask) ExportGlobal 

func (t BuilderNixpacksPropertyTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reconstructs the globally-set properties.

func (BuilderNixpacksPropertyTask) ExportSupport 

func (t BuilderNixpacksPropertyTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (BuilderNixpacksPropertyTask) Plan 

func (t BuilderNixpacksPropertyTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the BuilderNixpacksPropertyTask would produce.

func (BuilderNixpacksPropertyTask) ProbeSupport 

func (t BuilderNixpacksPropertyTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (BuilderNixpacksPropertyTask) Validate 

func (t BuilderNixpacksPropertyTask) Validate() error

Validate checks the BuilderNixpacksPropertyTask's inputs without contacting the server.

type BuilderNixpacksPropertyTaskExample 

type BuilderNixpacksPropertyTaskExample struct {
	// Name is the task name holding the BuilderNixpacksPropertyTask description
	Name string `yaml:"-"`

	// BuilderNixpacksPropertyTask is the BuilderNixpacksPropertyTask configuration
	BuilderNixpacksPropertyTask BuilderNixpacksPropertyTask `yaml:"dokku_builder_nixpacks_property"`
}

BuilderNixpacksPropertyTaskExample contains an example of a BuilderNixpacksPropertyTask

func (BuilderNixpacksPropertyTaskExample) GetName 

func (e BuilderNixpacksPropertyTaskExample) GetName() string

GetName returns the name of the example

type BuilderPackPropertyTask 

type BuilderPackPropertyTask PropertyFields

BuilderPackPropertyTask manages the builder-pack configuration for a given dokku application

func (BuilderPackPropertyTask) Doc 

func (t BuilderPackPropertyTask) Doc() string

Doc returns the docblock for the builder-pack property task

func (BuilderPackPropertyTask) Execute 

func (t BuilderPackPropertyTask) Execute(ctx context.Context) TaskOutputState

Execute sets or unsets the builder-pack property

func (BuilderPackPropertyTask) ExportApp 

func (t BuilderPackPropertyTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs the app's explicitly-set properties.

func (BuilderPackPropertyTask) ExportGlobal 

func (t BuilderPackPropertyTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reconstructs the globally-set properties.

func (BuilderPackPropertyTask) ExportSupport 

func (t BuilderPackPropertyTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (BuilderPackPropertyTask) Plan 

func (t BuilderPackPropertyTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the BuilderPackPropertyTask would produce.

func (BuilderPackPropertyTask) ProbeSupport 

func (t BuilderPackPropertyTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (BuilderPackPropertyTask) Validate 

func (t BuilderPackPropertyTask) Validate() error

Validate checks the BuilderPackPropertyTask's inputs without contacting the server.

type BuilderPackPropertyTaskExample 

type BuilderPackPropertyTaskExample struct {
	// Name is the task name holding the BuilderPackPropertyTask description
	Name string `yaml:"-"`

	// BuilderPackPropertyTask is the BuilderPackPropertyTask configuration
	BuilderPackPropertyTask BuilderPackPropertyTask `yaml:"dokku_builder_pack_property"`
}

BuilderPackPropertyTaskExample contains an example of a BuilderPackPropertyTask

func (BuilderPackPropertyTaskExample) GetName 

func (e BuilderPackPropertyTaskExample) GetName() string

GetName returns the name of the example

type BuilderPropertyTask 

type BuilderPropertyTask PropertyFields

BuilderTask manages the builder configuration for a given dokku application

func (BuilderPropertyTask) Doc 

func (t BuilderPropertyTask) Doc() string

Doc returns the docblock for the builder property task

func (BuilderPropertyTask) Execute 

func (t BuilderPropertyTask) Execute(ctx context.Context) TaskOutputState

Execute executes the builder configuration task

func (BuilderPropertyTask) ExportApp 

func (t BuilderPropertyTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs the app's explicitly-set properties.

func (BuilderPropertyTask) ExportGlobal 

func (t BuilderPropertyTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reconstructs the globally-set properties.

func (BuilderPropertyTask) ExportSupport 

func (t BuilderPropertyTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (BuilderPropertyTask) Plan 

func (t BuilderPropertyTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the BuilderPropertyTask would produce.

func (BuilderPropertyTask) ProbeSupport 

func (t BuilderPropertyTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (BuilderPropertyTask) Validate 

func (t BuilderPropertyTask) Validate() error

Validate checks the BuilderPropertyTask's inputs without contacting the server.

type BuilderPropertyTaskExample 

type BuilderPropertyTaskExample struct {
	// Name is the task name holding the BuilderPropertyTask description
	Name string `yaml:"-"`

	// BuilderPropertyTask is the BuilderPropertyTask configuration
	BuilderPropertyTask BuilderPropertyTask `yaml:"dokku_builder_property"`
}

BuilderPropertyTaskExample contains an example of a BuilderPropertyTask

func (BuilderPropertyTaskExample) GetName 

func (e BuilderPropertyTaskExample) GetName() string

GetName returns the name of the example

type BuilderRailpackPropertyTask 

type BuilderRailpackPropertyTask PropertyFields

BuilderRailpackPropertyTask manages the builder-railpack configuration for a given dokku application

func (BuilderRailpackPropertyTask) Doc 

func (t BuilderRailpackPropertyTask) Doc() string

Doc returns the docblock for the builder-railpack property task

func (BuilderRailpackPropertyTask) Execute 

func (t BuilderRailpackPropertyTask) Execute(ctx context.Context) TaskOutputState

Execute sets or unsets the builder-railpack property

func (BuilderRailpackPropertyTask) ExportApp 

func (t BuilderRailpackPropertyTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs the app's explicitly-set properties.

func (BuilderRailpackPropertyTask) ExportGlobal 

func (t BuilderRailpackPropertyTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reconstructs the globally-set properties.

func (BuilderRailpackPropertyTask) ExportSupport 

func (t BuilderRailpackPropertyTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (BuilderRailpackPropertyTask) Plan 

func (t BuilderRailpackPropertyTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the BuilderRailpackPropertyTask would produce.

func (BuilderRailpackPropertyTask) ProbeSupport 

func (t BuilderRailpackPropertyTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (BuilderRailpackPropertyTask) Validate 

func (t BuilderRailpackPropertyTask) Validate() error

Validate checks the BuilderRailpackPropertyTask's inputs without contacting the server.

type BuilderRailpackPropertyTaskExample 

type BuilderRailpackPropertyTaskExample struct {
	// Name is the task name holding the BuilderRailpackPropertyTask description
	Name string `yaml:"-"`

	// BuilderRailpackPropertyTask is the BuilderRailpackPropertyTask configuration
	BuilderRailpackPropertyTask BuilderRailpackPropertyTask `yaml:"dokku_builder_railpack_property"`
}

BuilderRailpackPropertyTaskExample contains an example of a BuilderRailpackPropertyTask

func (BuilderRailpackPropertyTaskExample) GetName 

func (e BuilderRailpackPropertyTaskExample) GetName() string

GetName returns the name of the example

type BuildpacksPropertyTask 

type BuildpacksPropertyTask PropertyFields

BuildpacksPropertyTask manages the buildpacks configuration for a given dokku application

func (BuildpacksPropertyTask) Doc 

func (t BuildpacksPropertyTask) Doc() string

Doc returns the docblock for the buildpacks property task

func (BuildpacksPropertyTask) Execute 

func (t BuildpacksPropertyTask) Execute(ctx context.Context) TaskOutputState

Execute sets or unsets the buildpacks property

func (BuildpacksPropertyTask) ExportApp 

func (t BuildpacksPropertyTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs the app's explicitly-set properties.

func (BuildpacksPropertyTask) ExportGlobal 

func (t BuildpacksPropertyTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reconstructs the globally-set properties.

func (BuildpacksPropertyTask) ExportSupport 

func (t BuildpacksPropertyTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (BuildpacksPropertyTask) Plan 

func (t BuildpacksPropertyTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the BuildpacksPropertyTask would produce.

func (BuildpacksPropertyTask) ProbeSupport 

func (t BuildpacksPropertyTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (BuildpacksPropertyTask) Validate 

func (t BuildpacksPropertyTask) Validate() error

Validate checks the BuildpacksPropertyTask's inputs without contacting the server.

type BuildpacksPropertyTaskExample 

type BuildpacksPropertyTaskExample struct {
	// Name is the task name holding the BuildpacksPropertyTask description
	Name string `yaml:"-"`

	// BuildpacksPropertyTask is the BuildpacksPropertyTask configuration
	BuildpacksPropertyTask BuildpacksPropertyTask `yaml:"dokku_buildpacks_property"`
}

BuildpacksPropertyTaskExample contains an example of a BuildpacksPropertyTask

func (BuildpacksPropertyTaskExample) GetName 

func (e BuildpacksPropertyTaskExample) GetName() string

GetName returns the name of the example

type BuildpacksTask 

type BuildpacksTask struct {
	// App is the name of the app
	App string `required:"true" identity:"key" yaml:"app" description:"Name of the app"`

	// Buildpacks is the list of buildpack URLs
	Buildpacks []string `required:"false" identity:"collection" yaml:"buildpacks" description:"List of buildpack URLs"`

	// State is the desired state of the buildpacks
	State State `required:"false" yaml:"state" default:"present" options:"present,absent" description:"Desired state of the buildpacks"`
}

BuildpacksTask manages the buildpacks for a given dokku application

func (BuildpacksTask) Doc 

func (t BuildpacksTask) Doc() string

Doc returns the docblock for the buildpacks task

func (BuildpacksTask) Execute 

func (t BuildpacksTask) Execute(ctx context.Context) TaskOutputState

Execute manages the buildpacks for a given app

func (BuildpacksTask) ExportApp 

func (t BuildpacksTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reads the app's buildpacks and returns a dokku_buildpacks task, or nil when none are set.

func (BuildpacksTask) ExportSupport 

func (t BuildpacksTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (BuildpacksTask) Plan 

func (t BuildpacksTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the BuildpacksTask would produce.

func (BuildpacksTask) ProbeSupport 

func (t BuildpacksTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (BuildpacksTask) Validate 

func (t BuildpacksTask) Validate() error

Validate checks the BuildpacksTask's inputs without contacting the server.

type BuildpacksTaskExample 

type BuildpacksTaskExample struct {
	// Name is the task name holding the BuildpacksTask description
	Name string `yaml:"-"`

	// BuildpacksTask is the BuildpacksTask configuration
	BuildpacksTask BuildpacksTask `yaml:"dokku_buildpacks"`
}

BuildpacksTaskExample contains an example of a BuildpacksTask

func (BuildpacksTaskExample) GetName 

func (e BuildpacksTaskExample) GetName() string

GetName returns the name of the example

type BuildsPropertyTask 

type BuildsPropertyTask PropertyFields

BuildsPropertyTask manages the builds configuration for a given dokku application

func (BuildsPropertyTask) Doc 

func (t BuildsPropertyTask) Doc() string

Doc returns the docblock for the builds property task

func (BuildsPropertyTask) Execute 

func (t BuildsPropertyTask) Execute(ctx context.Context) TaskOutputState

Execute sets or unsets the builds property

func (BuildsPropertyTask) ExportApp 

func (t BuildsPropertyTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs the app's explicitly-set properties.

func (BuildsPropertyTask) ExportGlobal 

func (t BuildsPropertyTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reconstructs the globally-set properties.

func (BuildsPropertyTask) ExportSupport 

func (t BuildsPropertyTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (BuildsPropertyTask) Plan 

func (t BuildsPropertyTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the BuildsPropertyTask would produce.

func (BuildsPropertyTask) ProbeSupport 

func (t BuildsPropertyTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (BuildsPropertyTask) Validate 

func (t BuildsPropertyTask) Validate() error

Validate checks the BuildsPropertyTask's inputs without contacting the server.

type BuildsPropertyTaskExample 

type BuildsPropertyTaskExample struct {
	// Name is the task name holding the BuildsPropertyTask description
	Name string `yaml:"-"`

	// BuildsPropertyTask is the BuildsPropertyTask configuration
	BuildsPropertyTask BuildsPropertyTask `yaml:"dokku_builds_property"`
}

BuildsPropertyTaskExample contains an example of a BuildsPropertyTask

func (BuildsPropertyTaskExample) GetName 

func (e BuildsPropertyTaskExample) GetName() string

GetName returns the name of the example

type CaddyPropertyTask 

type CaddyPropertyTask PropertyFields

CaddyPropertyTask manages the caddy configuration for a given dokku application

func (CaddyPropertyTask) Doc 

func (t CaddyPropertyTask) Doc() string

Doc returns the docblock for the caddy property task

func (CaddyPropertyTask) Execute 

func (t CaddyPropertyTask) Execute(ctx context.Context) TaskOutputState

Execute sets or unsets the caddy property

func (CaddyPropertyTask) ExportApp 

func (t CaddyPropertyTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs the app's explicitly-set properties.

func (CaddyPropertyTask) ExportGlobal 

func (t CaddyPropertyTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reconstructs the globally-set properties.

func (CaddyPropertyTask) ExportSupport 

func (t CaddyPropertyTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (CaddyPropertyTask) Plan 

func (t CaddyPropertyTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the CaddyPropertyTask would produce.

func (CaddyPropertyTask) ProbeSupport 

func (t CaddyPropertyTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (CaddyPropertyTask) Validate 

func (t CaddyPropertyTask) Validate() error

Validate checks the CaddyPropertyTask's inputs without contacting the server.

type CaddyPropertyTaskExample 

type CaddyPropertyTaskExample struct {
	// Name is the task name holding the CaddyPropertyTask description
	Name string `yaml:"-"`

	// CaddyPropertyTask is the CaddyPropertyTask configuration
	CaddyPropertyTask CaddyPropertyTask `yaml:"dokku_caddy_property"`
}

CaddyPropertyTaskExample contains an example of a CaddyPropertyTask

func (CaddyPropertyTaskExample) GetName 

func (e CaddyPropertyTaskExample) GetName() string

GetName returns the name of the example

type CertsTask 

type CertsTask struct {
	// App is the name of the app. Required if Global is false.
	App string `required:"false" identity:"key" yaml:"app" description:"Name of the app. Required if Global is false."`

	// Global is a flag indicating if the certificate should be applied globally
	// via the dokku-global-cert plugin
	Global bool `` /* 164-byte string literal not displayed */

	// Cert is the path on the dokku server to the SSL certificate file
	Cert string `` /* 161-byte string literal not displayed */

	// Key is the path on the dokku server to the SSL certificate key file
	Key string `` /* 163-byte string literal not displayed */

	// CertContent is the PEM-encoded certificate contents. Mutually
	// exclusive with Cert.
	CertContent string `` /* 141-byte string literal not displayed */

	// KeyContent is the PEM-encoded private key contents. Mutually
	// exclusive with Key.
	KeyContent string `` /* 139-byte string literal not displayed */

	// State is the desired state of the SSL configuration
	State State `` /* 135-byte string literal not displayed */
}

CertsTask manages SSL certificates for a dokku app or globally

func (CertsTask) Doc 

func (t CertsTask) Doc() string

Doc returns the docblock for the certs task

func (CertsTask) Execute 

func (t CertsTask) Execute(ctx context.Context) TaskOutputState

Execute manages the SSL certificate

func (CertsTask) ExportApp 

func (t CertsTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs an app's SSL certificate via certs:show. The cert and key PEM are sensitive and lifted into the vars-file by the engine.

func (CertsTask) ExportGlobal 

func (t CertsTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reconstructs the global SSL certificate via global-cert:show. The cert and key PEM are sensitive and lifted into the vars-file by the engine.

func (CertsTask) ExportSupport 

func (t CertsTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (CertsTask) Plan 

func (t CertsTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the CertsTask would produce.

func (CertsTask) ProbeSupport 

func (t CertsTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (CertsTask) Requirements 

func (t CertsTask) Requirements() []string

Requirements lists the non-core dokku plugins this task depends on.

func (CertsTask) Validate 

func (t CertsTask) Validate() error

Validate checks the CertsTask's inputs without contacting the server.

type CertsTaskExample 

type CertsTaskExample struct {
	// Name is the task name holding the CertsTask description
	Name string `yaml:"-"`

	// CertsTask is the CertsTask configuration
	CertsTask CertsTask `yaml:"dokku_certs"`
}

CertsTaskExample contains an example of a CertsTask

func (CertsTaskExample) GetName 

func (e CertsTaskExample) GetName() string

GetName returns the name of the example

type ChecksPropertyTask 

type ChecksPropertyTask PropertyFields

ChecksPropertyTask manages the checks configuration for a given dokku application

func (ChecksPropertyTask) Doc 

func (t ChecksPropertyTask) Doc() string

Doc returns the docblock for the checks property task

func (ChecksPropertyTask) Execute 

func (t ChecksPropertyTask) Execute(ctx context.Context) TaskOutputState

Execute sets or unsets the checks property

func (ChecksPropertyTask) ExportApp 

func (t ChecksPropertyTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs the app's explicitly-set properties.

func (ChecksPropertyTask) ExportGlobal 

func (t ChecksPropertyTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reconstructs the globally-set properties.

func (ChecksPropertyTask) ExportSupport 

func (t ChecksPropertyTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (ChecksPropertyTask) Plan 

func (t ChecksPropertyTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the ChecksPropertyTask would produce.

func (ChecksPropertyTask) ProbeSupport 

func (t ChecksPropertyTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (ChecksPropertyTask) Validate 

func (t ChecksPropertyTask) Validate() error

Validate checks the ChecksPropertyTask's inputs without contacting the server.

type ChecksPropertyTaskExample 

type ChecksPropertyTaskExample struct {
	// Name is the task name holding the ChecksPropertyTask description
	Name string `yaml:"-"`

	// ChecksPropertyTask is the ChecksPropertyTask configuration
	ChecksPropertyTask ChecksPropertyTask `yaml:"dokku_checks_property"`
}

ChecksPropertyTaskExample contains an example of a ChecksPropertyTask

func (ChecksPropertyTaskExample) GetName 

func (e ChecksPropertyTaskExample) GetName() string

GetName returns the name of the example

type ChecksToggleTask 

type ChecksToggleTask ToggleFields

ChecksToggleTask enables or disables the checks plugin for a given dokku application

func (ChecksToggleTask) Doc 

func (t ChecksToggleTask) Doc() string

Doc returns the docblock for the checks toggle task

func (ChecksToggleTask) Execute 

func (t ChecksToggleTask) Execute(ctx context.Context) TaskOutputState

Execute enables or disables the checks plugin

func (ChecksToggleTask) ExportApp 

func (t ChecksToggleTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp emits a dokku_checks_toggle task only when checks are disabled (they are enabled by default).

func (ChecksToggleTask) ExportSupport 

func (t ChecksToggleTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (ChecksToggleTask) Plan 

func (t ChecksToggleTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the ChecksToggleTask would produce.

func (ChecksToggleTask) ProbeSupport 

func (t ChecksToggleTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

type ChecksToggleTaskExample 

type ChecksToggleTaskExample struct {
	// Name is the task name holding the ChecksToggleTask description
	Name string `yaml:"-"`

	// ChecksToggleTask is the ChecksToggleTask configuration
	ChecksToggleTask ChecksToggleTask `yaml:"dokku_checks_toggle"`
}

ChecksToggleTaskExample contains an example of a ChecksToggleTask

func (ChecksToggleTaskExample) GetName 

func (e ChecksToggleTaskExample) GetName() string

GetName returns the name of the example

type Codec 

type Codec interface {
	// Name is the canonical identifier for the format: what
	// --tasks-format / --format resolve to, and what every format string
	// downstream holds.
	Name() string

	// Aliases are the other spellings the flags accept - "yml" for YAML,
	// "json" for JSON5. They resolve to Name but are deliberately left
	// out of shell completion so it suggests one spelling per format.
	Aliases() []string

	// Extensions are the file extensions, without the leading dot, that
	// select this codec. Order matters: it is the order shell completion
	// offers files in, so the canonical spelling comes first.
	Extensions() []string

	// Sniff reports whether data is written in this format. It is the
	// last resort for a source with no name to key off, which in practice
	// means stdin. The default codec is never asked - it is what
	// SniffCodec falls back to when no other codec claims the bytes.
	Sniff(data []byte) bool

	// ToYAML converts data from this surface syntax to the YAML bytes
	// every downstream stage reads, so the loader, the validator and
	// flag registration all agree on how a scalar lands in a Go field.
	//
	// A failure comes back as this format's parse diagnostic rather than
	// a bare error because the validator reports it to the user by Code
	// (docs/json-output.md documents those codes as a stable machine
	// key). Note the "yaml_parse" code is not one of these: it belongs to
	// the yaml.v3 parse that runs after normalisation, for every format.
	ToYAML(data []byte) ([]byte, *Problem)

	// Lint reports findings only this format can raise, reading the
	// ORIGINAL bytes rather than ToYAML's output - a duplicated JSON5 key
	// has already been deduped by the time the conversion is done.
	//
	// Kept separate from ToYAML on purpose: normalizeRecipeBytes runs
	// both, UnmarshalRecipe runs only the conversion. Folding Lint into
	// ToYAML would make parseInputDocument and countTasks start rejecting
	// duplicate-keyed JSON5 that they accept today.
	Lint(data []byte) []Problem

	// Format returns the canonical rendering of data - what `docket fmt`
	// writes back.
	Format(data []byte) ([]byte, error)

	// DecodeDocument parses data into a comment-carrying yaml.Node
	// document. That tree is the neutral interchange every cross-format
	// conversion passes through, which is what keeps conversion O(codecs)
	// rather than O(codec pairs): a new format implements this pair and
	// gets conversion to and from every other format for free.
	//
	// yaml.Node is the interchange rather than a tree of docket's own
	// because it is the richest model in play - anchors, tags, styles and
	// head/line/foot comments - so information is only ever lost on the
	// way OUT of it, in EncodeDocument, where the codec that cannot
	// represent something is the one deciding what to do about it. It also
	// makes the YAML codec's own pair free.
	//
	// A nil node with a nil error means data holds no document at all, for
	// a format that has an empty form: YAML's empty and comment-only
	// files, which Format already returns untouched. A format with no
	// empty representation returns an error instead, exactly as its Format
	// does today - parseJSON5 rejects empty input, so `docket fmt
	// empty.json` fails now and keeps failing.
	DecodeDocument(data []byte) (*yaml.Node, error)

	// EncodeDocument renders that document as a canonically formatted
	// recipe in this surface syntax - the same bytes Format would produce
	// for it. A nil document is an error; Convert screens for one first.
	//
	// This is where a format states what it cannot carry. JSON5 has no
	// anchors, so Convert flattens them before calling; it has no date
	// type, so a !!timestamp widens to a string; it has no complex keys,
	// so a non-scalar mapping key is refused outright rather than
	// stringified into something that means less.
	EncodeDocument(doc *yaml.Node) ([]byte, error)

	// Marshal renders v as a canonically formatted recipe document, the
	// same bytes Format would produce for it.
	Marshal(v interface{}) ([]byte, error)

	// MarshalVars renders v as a companion vars-file: a flat mapping of
	// input name to value, not a recipe, so it gets no canonical-form
	// pass.
	MarshalVars(v interface{}) ([]byte, error)

	// UnmarshalVars reads a vars-file back, the other half of MarshalVars.
	UnmarshalVars(data []byte) (map[string]interface{}, error)

	// EscapeDoubleQuoted is this format's `dq` filter: it escapes a
	// substituted value for interpolation inside a double-quoted scalar,
	// returning the body WITHOUT the surrounding quotes so the recipe keeps
	// its own.
	//
	// A recipe is rendered as text and only then parsed, so the escaping has
	// to suit the syntax the rendered bytes will be read as. YAML and JSON5
	// share one answer, which is why `dq` was a single function until HCL
	// arrived: HCL's quoted string is a template of its own and reads `${`
	// and `%{` as syntax.
	EscapeDoubleQuoted(v interface{}) (string, error)

	// DoubleQuotesOnly reports whether the double-quoted string is the only
	// string spelling this format's canonical form has.
	//
	// It is what Convert asks before refusing to rewrite an interpolation
	// whose quoting carries meaning. A format that can spell every YAML
	// style has nothing to refuse and answers false; one that folds every
	// string into `"..."` answers true, because `| dq` is the only escaping
	// that survives the fold.
	DoubleQuotesOnly() bool
}

Codec is everything docket needs to know about one recipe surface syntax. A recipe's format is a string on the wire - the --tasks-format / --format flags, recipeSource.Format, ValidateOptions.Format - and every place that used to branch on that string now resolves it to a Codec and calls a method.

Adding a format means writing one implementation and adding it to the codecs slice below. Nothing else in the tree should compare a format string against a literal; TestCodecConformance enforces what a new implementation has to satisfy.

func CodecFor 

func CodecFor(format string) Codec

CodecFor resolves a format string to its codec, falling back to DefaultCodec for the empty string and for anything unrecognised. It is the lenient lookup every dispatch site uses; the CLI has already rejected a bad spelling via LookupCodec by the time a format reaches here, and an embedder passing no format keeps getting YAML.

func CodecForExtension 

func CodecForExtension(ext string) (Codec, bool)

CodecForExtension resolves a file extension - without the leading dot, case-insensitive - to its codec. The second return is false when no codec claims it, which the caller turns into DefaultCodec so an explicit path like `--tasks recipe.txt` still reads as YAML.

func Codecs 

func Codecs() []Codec

Codecs returns every registered codec in priority order.

func DefaultCodec 

func DefaultCodec() Codec

DefaultCodec is the codec a recipe is read with when nothing says otherwise: an empty format string, an unrecognised one, an unknown file extension, or bytes no other codec claims.

This is the explicit default that replaced IsJSON5Format(""), which decided the same question by returning false.

func LookupCodec 

func LookupCodec(spelling string) (Codec, bool)

LookupCodec resolves a user-typed format spelling - a canonical name or an alias, case-insensitive and space-tolerant - to its codec. The second return is false for anything unrecognised, including the empty string; callers that treat "" as "not set" must check for it first.

func SniffCodec 

func SniffCodec(data []byte) Codec

SniffCodec picks a codec from the recipe bytes themselves, for a source with no name to key off. The default codec is skipped rather than asked: it is the answer when nobody else claims the bytes, so letting it match first would stop any other codec from ever being reached.

type ConfigTask 

type ConfigTask struct {
	// App is the name of the app
	App string `required:"true" identity:"key" yaml:"app" description:"Name of the app"`

	// Restart is a flag indicating if the app should be restarted. It is a
	// *bool so an explicit `restart: false` is distinguishable from an omitted
	// key: nil defaults to true via boolValue(t.Restart, true). The default:"true"
	// tag only drives the generated docs table; go-defaults leaves pointer fields
	// untouched, which is what fixes the silent override of an explicit false.
	Restart *bool `yaml:"restart,omitempty" default:"true" description:"Flag indicating if the app should be restarted"`

	// Config is a map of configuration key-value pairs
	Config map[string]string `identity:"collection" yaml:"config,omitempty" description:"Map of configuration key-value pairs; omit for state 'clear'"`

	// Preserve lists keys that state 'set' and 'clear' leave in place
	Preserve []string `` /* 234-byte string literal not displayed */

	// State is the desired state of the configuration
	State State `` /* 456-byte string literal not displayed */
}

ConfigTask manages the configuration for a given dokku application

func (ConfigTask) Doc 

func (t ConfigTask) Doc() string

Doc returns the docblock for the config task

func (ConfigTask) Execute 

func (t ConfigTask) Execute(ctx context.Context) TaskOutputState

Execute sets or unsets the configuration for a given dokku application

func (ConfigTask) ExportApp 

func (t ConfigTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reads the app's config and returns a dokku_config task carrying the current values as state 'set', or nil when there are none. Restart mirrors the task default so the emitted recipe matches apply's behaviour; the engine lifts the values into the companion vars-file.

The keys configKeptKeys keeps are dropped, so the exported map is exactly what state 'set' owns and a round trip agrees with itself. Config vars a datastore service link injected are among them: dokku_service_link recreates them on apply with the new server's credentials, so re-exporting the stale value would clobber the fresh one. NO_VHOST comes back through dokku_domains_toggle's own export, and the git rev key through the next build. The exclusion happens here, before the engine lifts values, so those values never reach the vars-file.

func (ConfigTask) ExportSupport 

func (t ConfigTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (ConfigTask) Plan 

func (t ConfigTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the ConfigTask would produce.

func (ConfigTask) ProbeSupport 

func (t ConfigTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (ConfigTask) SensitiveValues 

func (t ConfigTask) SensitiveValues() []string

SensitiveValues returns every non-empty value in the Config map together with its base64 encoding. The base64 form is included because the apply path passes config values to `dokku config:set --encoded` as `KEY=<base64(value)>`, so the literal value never appears on argv but the encoded form does. Masking both means the verbose command echo and the DOKKU_TRACE log scrub the secret in either representation.

func (ConfigTask) Validate 

func (t ConfigTask) Validate() error

Validate checks the config map and preserve list against the state before any subprocess call.

type ConfigTaskExample 

type ConfigTaskExample struct {
	// Name is the task name holding the ConfigTask description
	Name string `yaml:"-"`

	// ConfigTask is the ConfigTask configuration
	ConfigTask ConfigTask `yaml:"dokku_config"`
}

ConfigTaskExample contains an example of a ConfigTask

func (ConfigTaskExample) GetName 

func (e ConfigTaskExample) GetName() string

GetName returns the name of the example

type CronPropertyTask 

type CronPropertyTask PropertyFields

CronPropertyTask manages the cron configuration for a given dokku application

func (CronPropertyTask) Doc 

func (t CronPropertyTask) Doc() string

Doc returns the docblock for the cron property task

func (CronPropertyTask) Execute 

func (t CronPropertyTask) Execute(ctx context.Context) TaskOutputState

Execute sets or unsets the cron property

func (CronPropertyTask) ExportApp 

func (t CronPropertyTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs the app's explicitly-set properties.

func (CronPropertyTask) ExportGlobal 

func (t CronPropertyTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reconstructs the globally-set properties.

func (CronPropertyTask) ExportSupport 

func (t CronPropertyTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (CronPropertyTask) Plan 

func (t CronPropertyTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the CronPropertyTask would produce.

func (CronPropertyTask) ProbeSupport 

func (t CronPropertyTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (CronPropertyTask) Validate 

func (t CronPropertyTask) Validate() error

Validate checks the CronPropertyTask's inputs without contacting the server.

type CronPropertyTaskExample 

type CronPropertyTaskExample struct {
	// Name is the task name holding the CronPropertyTask description
	Name string `yaml:"-"`

	// CronPropertyTask is the CronPropertyTask configuration
	CronPropertyTask CronPropertyTask `yaml:"dokku_cron_property"`
}

CronPropertyTaskExample contains an example of a CronPropertyTask

func (CronPropertyTaskExample) GetName 

func (e CronPropertyTaskExample) GetName() string

GetName returns the name of the example

type DeprecationDocer 

type DeprecationDocer interface {
	Deprecation() string
}

DeprecationDocer is an optional interface a task implements when the task type is deprecated. Deprecation returns a human-readable notice naming the recommended replacement and (optionally) the reason. The docs generator renders the message in a Deprecated section on the task's page; --list-tasks marks the task; apply and plan emit a one-time warning when the task runs.

type Doc 

type Doc struct {
	Name      string
	Codeblock string
}

func MarshalExamples 

func MarshalExamples[T TaskExample](examples []T) ([]Doc, error)

MarshalExamples converts a slice of task examples into Doc slices.

func TaskExamples 

func TaskExamples(t Task) ([]Doc, error)

TaskExamples returns the examples for t, or none when t does not implement Documented. The error is the one examples() returns when an example fails to marshal.

type DockerOptionsTask 

type DockerOptionsTask struct {
	// App is the name of the app
	App string `required:"true" identity:"key" yaml:"app" description:"Name of the app"`

	// Phase is the deployment phase the option applies to
	Phase string `required:"true" identity:"key" yaml:"phase" options:"build,deploy,run" description:"Deployment phase the option applies to"`

	// ProcessType scopes the option to a specific Procfile process type.
	// Only valid for the deploy phase; empty applies to the default scope
	// (every container in the app).
	ProcessType string `` /* 187-byte string literal not displayed */

	// Option is the docker option string (e.g. "-v /var/run/docker.sock:/var/run/docker.sock")
	Option string `` /* 133-byte string literal not displayed */

	// State is the desired state of the docker option
	State State `` /* 131-byte string literal not displayed */
}

DockerOptionsTask manages docker-options for a given dokku application

func (DockerOptionsTask) Doc 

func (t DockerOptionsTask) Doc() string

Doc returns the docblock for the docker options task

func (DockerOptionsTask) Execute 

func (t DockerOptionsTask) Execute(ctx context.Context) TaskOutputState

Execute manages the docker option

func (DockerOptionsTask) ExportApp 

func (t DockerOptionsTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs the app's docker options as one task per individual option, per (phase, process type). Options are read from the structured `<phase>-list` report keys (dokku/dokku#8799), so each stored option - including values that contain spaces - is emitted as a discrete task without whitespace splitting.

func (DockerOptionsTask) ExportSupport 

func (t DockerOptionsTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (DockerOptionsTask) Plan 

func (t DockerOptionsTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the DockerOptionsTask would produce.

func (DockerOptionsTask) ProbeSupport 

func (t DockerOptionsTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (DockerOptionsTask) Validate 

func (t DockerOptionsTask) Validate() error

Validate checks the DockerOptionsTask's inputs without contacting the server.

type DockerOptionsTaskExample 

type DockerOptionsTaskExample struct {
	// Name is the task name holding the DockerOptionsTask description
	Name string `yaml:"-"`

	// DockerOptionsTask is the DockerOptionsTask configuration
	DockerOptionsTask DockerOptionsTask `yaml:"dokku_docker_options"`
}

DockerOptionsTaskExample contains an example of a DockerOptionsTask

func (DockerOptionsTaskExample) GetName 

func (e DockerOptionsTaskExample) GetName() string

GetName returns the name of the example

type Documented 

type Documented interface {
	// Doc returns the docblock for the task
	Doc() string
	// contains filtered or unexported methods
}

Documented is the interface a task implements to describe itself: a synopsis and a set of runnable examples. Neither has anything to do with running a task, so it is kept out of Task and modelled as an optional interface to match ExportDocer, ProbeDocer, DeprecationDocer and RequirementsDocer. Every registered task is expected to implement it - a coverage test enforces that so no task ships without a synopsis or examples - and the task catalog is what reads it, which in turn feeds the generated task pages and `docket schema`.

type DomainsTask 

type DomainsTask struct {
	// App is the name of the app
	App string `required:"false" identity:"key" yaml:"app" description:"Name of the app"`

	// Global is a flag indicating if the domains should be applied globally
	Global bool `` /* 127-byte string literal not displayed */

	// Domains is the list of domain names
	Domains []string `required:"false" identity:"collection" yaml:"domains,omitempty" description:"List of domain names; omit for state 'clear'"`

	// State is the desired state of the domains
	State State `required:"false" yaml:"state" default:"present" options:"present,absent,set,clear" description:"Desired state of the domains"`
}

DomainsTask manages the domains for a given dokku application or globally

func (DomainsTask) Doc 

func (t DomainsTask) Doc() string

Doc returns the docblock for the domains task

func (DomainsTask) Execute 

func (t DomainsTask) Execute(ctx context.Context) TaskOutputState

Execute manages the domains

func (DomainsTask) ExportApp 

func (t DomainsTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reads the app's vhosts and returns a dokku_domains task that sets exactly that set, or nil when the app has no custom domains.

func (DomainsTask) ExportSupport 

func (t DomainsTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (DomainsTask) Plan 

func (t DomainsTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the DomainsTask would produce.

func (DomainsTask) ProbeSupport 

func (t DomainsTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (DomainsTask) Validate 

func (t DomainsTask) Validate() error

Validate checks the DomainsTask's inputs without contacting the server.

type DomainsTaskExample 

type DomainsTaskExample struct {
	// Name is the task name holding the DomainsTask description
	Name string `yaml:"-"`

	// DomainsTask is the DomainsTask configuration
	DomainsTask DomainsTask `yaml:"dokku_domains"`
}

DomainsTaskExample contains an example of a DomainsTask

func (DomainsTaskExample) GetName 

func (e DomainsTaskExample) GetName() string

GetName returns the name of the example

type DomainsToggleTask 

type DomainsToggleTask ToggleFields

DomainsToggleTask enables or disables the domains plugin for a given dokku application

func (DomainsToggleTask) Doc 

func (t DomainsToggleTask) Doc() string

Doc returns the docblock for the domains toggle task

func (DomainsToggleTask) Execute 

func (t DomainsToggleTask) Execute(ctx context.Context) TaskOutputState

Execute enables or disables the domains plugin

func (DomainsToggleTask) ExportApp 

func (t DomainsToggleTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp emits a dokku_domains_toggle task only when the domains plugin is disabled for the app (it is enabled by default).

func (DomainsToggleTask) ExportSupport 

func (t DomainsToggleTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (DomainsToggleTask) Plan 

func (t DomainsToggleTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the DomainsToggleTask would produce.

func (DomainsToggleTask) ProbeSupport 

func (t DomainsToggleTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

type DomainsToggleTaskExample 

type DomainsToggleTaskExample struct {
	// Name is the task name holding the DomainsToggleTask description
	Name string `yaml:"-"`

	// DomainsToggleTask is the DomainsToggleTask configuration
	DomainsToggleTask DomainsToggleTask `yaml:"dokku_domains_toggle"`
}

DomainsToggleTaskExample contains an example of a DomainsToggleTask

func (DomainsToggleTaskExample) GetName 

func (e DomainsToggleTaskExample) GetName() string

GetName returns the name of the example

type DynamicPropertySchema 

type DynamicPropertySchema struct {
	// Prefix is what a member's name starts with.
	Prefix string `json:"prefix"`

	// Probeable is true when the plugin's report surfaces a row per set
	// member, so docket can read the value back. False means a recipe using
	// the family reports drift on every run and never converges.
	Probeable bool `json:"probeable"`

	// Sensitive is true when docket treats members as secrets.
	Sensitive bool `json:"sensitive,omitempty"`

	// Scopes is a non-empty subset of ["app", "global"], in that order, read
	// the same way as PropertyEntrySchema.Scopes: a family listed only under
	// "global" is rejected for an app at validate time, matching dokku's own
	// rejection. traefik's `dns-provider-*` credentials are global-only that
	// way, while letsencrypt's identically named family takes both.
	Scopes []string `json:"scopes"`
}

DynamicPropertySchema is a family of property names matched by prefix.

func DynamicPropertyFamilies 

func DynamicPropertyFamilies(plugin string) []DynamicPropertySchema

DynamicPropertyFamilies returns the dynamic name families a plugin declares, sorted by prefix, in the form the task catalog publishes. Exported so a consumer validating a recipe offline knows which unenumerable names to accept.

type ExampleSchema 

type ExampleSchema struct {
	Name string `json:"name"`
	YAML string `json:"yaml"`
}

ExampleSchema is one documented example: the heading its reference page gives it, and the YAML snippet itself.

type ExportDocer 

type ExportDocer interface {
	ExportSupport() ExportSupport
}

ExportDocer is the interface a task implements to declare its export support. Every registered task is expected to implement it - a coverage test enforces that so no task ships without an export decision - but it is modelled as an optional interface to match Documented, DeprecationDocer and RequirementsDocer. The docs generator renders the result in an Export support section on the task's page.

The export engine itself never reads this: emission is driven purely by membership in appExportOrder/globalExportOrder plus the AppExporter/ GlobalExporter type assertion. What keeps the declaration honest is TestExportSupportMatchesExportWiring, which fails when a task claims to be exportable without being wired into an order list (or vice versa).

type ExportOptions 

type ExportOptions struct {
	// Apps restricts the export to these app names; empty means every app.
	Apps []string

	// Resources restricts the export to specific resource addresses. Empty
	// means every resource. Mutually exclusive with Apps: an address already
	// says which app it belongs to.
	Resources []ResourceSelector

	// Redact replaces sensitive values with placeholders instead of the real
	// values (in the vars-file for file mode, in place for stdout mode). A
	// value whose task would not validate when blank is lifted into a required
	// input instead of being blanked, so the emitted recipe still parses and
	// validates - see processHttpAuthUser and processMaintenanceCustomPage.
	Redact bool

	// Inline keeps sensitive values in the task bodies instead of lifting them
	// into a vars map. Used for stdout output, which has no companion file.
	Inline bool
}

ExportOptions controls an export run.

type ExportReport 

type ExportReport struct {
	Warnings []string

	// MissingApps lists app names passed via --app that do not exist on the
	// server. The export still proceeds for the apps that do exist; the command
	// surfaces these and exits non-zero so a typo is not silently dropped (#346).
	MissingApps []string

	// MissingResources lists --resource addresses that matched nothing on the
	// server, in the order they were given. Same contract as MissingApps: the
	// export emits what it did find and the command exits non-zero, so an
	// address that names a resource the server does not have is not mistaken
	// for one that exports to nothing.
	MissingResources []string
}

ExportReport carries non-fatal diagnostics from an export run.

type ExportResult 

type ExportResult struct {
	Vars   map[string]string
	Report ExportReport
	// contains filtered or unexported fields
}

ExportResult is the outcome of ExportRecipe: the assembled recipe (as a list of plays), the companion vars map (empty in inline mode), and any warnings.

func ExportRecipe 

func ExportRecipe(ctx context.Context, opts ExportOptions) (*ExportResult, error)

ExportRecipe reads the live Dokku server (via the current subprocess host) and assembles a recipe describing it. It enumerates apps, runs every registered AppExporter for each, lifts sensitive values into a vars map (unless opts.Inline), and returns the result for the caller to marshal. A --resource run whose addresses all pin an app or are global does not enumerate: it reads only the pinned apps (#567).

The result is never nil, including on error: the global play is exported before any app is read, so a failure there - listing the apps, or probing whether a pinned one exists - still hands back what was already collected, and with it the sensitive values the caller has to register before it prints the failure (#488).

func (*ExportResult) AppCount 

func (res *ExportResult) AppCount() int

AppCount returns the number of app plays, excluding the leading "global" play (global resources are not an app), so the export summary reports the app count accurately.

func (*ExportResult) HasVars 

func (res *ExportResult) HasVars() bool

HasVars reports whether the export lifted any values into the vars map.

func (*ExportResult) MarshalRecipe 

func (res *ExportResult) MarshalRecipe(format string) ([]byte, error)

MarshalRecipe renders the assembled recipe in the codec keyed by format, canonicalised by the same formatter as `docket fmt`.

func (*ExportResult) MarshalVars 

func (res *ExportResult) MarshalVars(format string) ([]byte, error)

MarshalVars renders the companion vars-file (a flat mapping of input name to value) in the codec keyed by format, which the caller takes from --format or from the vars-output extension.

func (*ExportResult) PlayCount 

func (res *ExportResult) PlayCount() int

PlayCount returns the total number of plays in the result, including the leading global play when one was emitted. Used to detect an empty export.

func (*ExportResult) Plays 

func (res *ExportResult) Plays() []ExportedPlay

Plays returns the exported recipe as structured values: the same plays MarshalRecipe renders, with each task body still its own Go type.

It exists because the only ways out of an export used to be MarshalRecipe and MarshalVars, so a caller wanting data had to marshal to YAML and parse it straight back - or call ExportApp on a task directly and reimplement the ordering, warning collection and sensitive-value handling the engine already does (#425).

The slice is the result's own and must not be modified.

func (*ExportResult) SensitiveValues 

func (res *ExportResult) SensitiveValues() []string

SensitiveValues returns the literal values this export read off the server that must be masked in user-facing output. The caller registers them; the slice is the result's own and must not be modified.

type ExportStatus 

type ExportStatus string

ExportStatus classifies how a task participates in `docket export`, which reads a live Dokku server and emits a recipe (the inverse of apply). 

const (
	// ExportSupported means the task's full state can be read back from the
	// server and reconstructed faithfully.
	ExportSupported ExportStatus = "supported"

	// ExportPartial means the task can be exported but with caveats, for
	// example a secret value that is written to the companion vars-file, or a
	// field that cannot be read back and becomes a required input.
	ExportPartial ExportStatus = "partial"

	// ExportUnsupported means the task cannot be reconstructed from live
	// state: write-only secrets that never read back, imperative operations
	// that are not state, or resources whose export is not implemented yet.
	ExportUnsupported ExportStatus = "unsupported"
)

type ExportSupport 

type ExportSupport struct {
	Status ExportStatus `json:"status"`
	Caveat string       `json:"caveat,omitempty"`
}

ExportSupport describes a task's export behaviour. Status is required; Caveat is a human-readable note explaining a partial or unsupported status (and may be empty for a plainly supported task).

The json tags are for the task catalog, which publishes this verbatim.

func TaskExportSupport 

func TaskExportSupport(t Task) (ExportSupport, bool)

TaskExportSupport returns the export support for t, and whether t declared it. Centralised so docs generation, the export engine, and the coverage test share one read site, mirroring TaskDeprecation.

type ExportedPlay 

type ExportedPlay struct {
	Name   string                   `yaml:"name"`
	Inputs []map[string]interface{} `yaml:"inputs,omitempty"`
	Tasks  []ExportedTask           `yaml:"tasks"`
}

ExportedPlay is one play of an exported recipe. Name is the app it describes, or "global" for the leading play of not-app-scoped resources.

type ExportedTask 

type ExportedTask struct {
	Type string      `yaml:"-"`
	Body interface{} `yaml:"-"`
}

ExportedTask is one task in an exported play: the registry type-key it is emitted under, and the task's own struct populated from the server.

Body is the task value, not a marshalled form of it - `dokku_config` comes back as a ConfigTask - so a Go caller can read fields rather than parsing YAML the export just produced. It is always the value form of the task type registered under Type: the engine drops any body an exporter returns as a pointer or as another task's type (see exportedBodyType). Read it with As.

func (ExportedTask) MarshalYAML 

func (t ExportedTask) MarshalYAML() (interface{}, error)

MarshalYAML emits the task the way a recipe spells it: a single-key mapping from type-key to body. The exported fields are what a Go caller reads; this is what the recipe file gets, and having one type produce both is what keeps Plays() and MarshalRecipe from drifting apart.

type FieldSchema 

type FieldSchema struct {
	// Name is the recipe key, from the yaml tag. A field tagged `yaml:"-"` is
	// absent from the catalog entirely.
	Name string `json:"name"`

	// Type is the doc-facing type name.
	Type string `json:"type"`

	// Required mirrors what the loader enforces: `required:"true"` with no
	// default. A field carrying a default is never actually required, because
	// defaults.SetDefaults fills it in before the loader's zero-check runs.
	Required bool `json:"required"`

	// Default is the literal `default:` tag text, to be read according to
	// Type. It is not pre-parsed, so it cannot diverge from what go-defaults
	// does with it. Note that go-defaults leaves pointer fields untouched: on
	// a *bool the tag documents what the task coerces nil to, not a value the
	// loader writes into the struct.
	Default string `json:"default,omitempty"`

	// Choices are the `options:` tag values, in tag order. Absent when the
	// field is not an enum.
	Choices []string `json:"choices,omitempty"`

	// Description is the raw `description:` tag. Prose the reference page
	// appends - "(sensitive)", "Each item has: ..." - is derived from
	// Sensitive and Item rather than baked in here.
	Description string `json:"description,omitempty"`

	// Sensitive marks a field whose value is a secret. A consumer that echoes
	// a recipe must mask it.
	Sensitive bool `json:"sensitive,omitempty"`

	// RunnerFile marks a field naming a file docket reads on the machine it
	// runs on rather than on the dokku server, so the file must exist there
	// even when docket drives the server over --host. A path a task hands to
	// dokku as an argument resolves on the server and is not marked.
	RunnerFile bool `json:"runner_file,omitempty"`

	// Identity is "key" or "collection" when the field carries an identity
	// tag, and absent otherwise.
	Identity string `json:"identity,omitempty"`

	// Item describes the element shape of a list or dict field. Absent on a
	// scalar.
	Item *ItemSchema `json:"item,omitempty"`
}

FieldSchema is one recipe key a task accepts.

type GitAuthTask 

type GitAuthTask struct {
	// Host is the git server hostname (e.g. github.com)
	Host string `required:"true" identity:"key" yaml:"host" description:"Git server hostname (e.g. github.com)"`

	// Username is the netrc username. Required when state is present.
	Username string `required:"false" yaml:"username,omitempty" description:"Netrc username. Required when state is present."`

	// Password is the netrc password. Required when state is present.
	Password string `` /* 149-byte string literal not displayed */

	// State is the desired state of the netrc entry
	State State `` /* 129-byte string literal not displayed */
}

GitAuthTask manages netrc credentials for a git host via dokku git:auth.

The netrc file itself is unreadable (mode 0600 under $DOKKU_ROOT) and there is no report that dumps it, but idempotency does not need one: dokku's git:auth-status compares the stored entry against credentials it is handed and answers with its exit code, which is the only question Plan() asks. See gitAuthStatus for the two shapes that answers.

The password never reaches argv on either path. Both git:auth and git:auth-status read it from stdin when the username is supplied and the password argument is omitted, so it stays out of the plan output, the trace log, and the process table on the dokku host.

func (GitAuthTask) Doc 

func (t GitAuthTask) Doc() string

Doc returns the docblock for the git auth task

func (GitAuthTask) Execute 

func (t GitAuthTask) Execute(ctx context.Context) TaskOutputState

Execute manages the netrc entry for a host

func (GitAuthTask) ExportSupport 

func (t GitAuthTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

Probing and exporting ask different questions of the same command: git:auth-status confirms credentials the recipe already holds, but it cannot enumerate the hosts with an entry and never reveals a stored username, so there is still nothing for an exporter to reconstruct.

func (GitAuthTask) Plan 

func (t GitAuthTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the GitAuthTask would produce.

func (GitAuthTask) ProbeSupport 

func (t GitAuthTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (GitAuthTask) Validate 

func (t GitAuthTask) Validate() error

Validate checks the GitAuthTask's inputs without contacting the server.

type GitAuthTaskExample 

type GitAuthTaskExample struct {
	// Name is the task name holding the GitAuthTask description
	Name string `yaml:"-"`

	// GitAuthTask is the GitAuthTask configuration
	GitAuthTask GitAuthTask `yaml:"dokku_git_auth"`
}

GitAuthTaskExample contains an example of a GitAuthTask

func (GitAuthTaskExample) GetName 

func (e GitAuthTaskExample) GetName() string

GetName returns the name of the example

type GitFromArchiveTask 

type GitFromArchiveTask struct {
	// App is the name of the app
	App string `required:"true" identity:"key" yaml:"app" description:"Name of the app"`

	// ArchiveURL is the URL of the archive to deploy. Tagged sensitive
	// because URLs can embed credentials (e.g. https://user:token@host/path).
	ArchiveURL string `required:"true" sensitive:"true" yaml:"archive_url" description:"URL of the archive to deploy"`

	// ArchiveType is the format of the archive
	ArchiveType string `required:"false" yaml:"archive_type,omitempty" default:"tar" options:"tar,tar.gz,zip" description:"Format of the archive"`

	// GitUsername is the git author username for the synthetic commit
	GitUsername string `required:"false" yaml:"git_username,omitempty" description:"Git author username for the synthetic commit"`

	// GitEmail is the git author email for the synthetic commit
	GitEmail string `required:"false" yaml:"git_email,omitempty" description:"Git author email for the synthetic commit"`

	// State is the desired state of the deployment
	State State `required:"false" yaml:"state,omitempty" default:"deployed" options:"deployed" description:"Desired state of the deployment"`
}

GitFromArchiveTask deploys a git repository from an archive URL

func (GitFromArchiveTask) Doc 

func (t GitFromArchiveTask) Doc() string

Doc returns the docblock for the git from archive task

func (GitFromArchiveTask) Execute 

func (t GitFromArchiveTask) Execute(ctx context.Context) TaskOutputState

Execute deploys a git repository from an archive URL

func (GitFromArchiveTask) ExportApp 

func (t GitFromArchiveTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs a git-from-archive deploy source from apps:report. dokku records the archive type (tar/tar.gz/zip) as the source and the URL as the metadata; the URL is sensitive, so the engine lifts it into the vars-file.

func (GitFromArchiveTask) ExportSupport 

func (t GitFromArchiveTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (GitFromArchiveTask) Plan 

func (t GitFromArchiveTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the GitFromArchiveTask would produce.

func (GitFromArchiveTask) ProbeSupport 

func (t GitFromArchiveTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (GitFromArchiveTask) Validate 

func (t GitFromArchiveTask) Validate() error

Validate checks the GitFromArchiveTask's inputs without contacting the server.

type GitFromArchiveTaskExample 

type GitFromArchiveTaskExample struct {
	// Name is the task name holding the GitFromArchiveTask description
	Name string `yaml:"-"`

	// GitFromArchiveTask is the GitFromArchiveTask configuration
	GitFromArchiveTask GitFromArchiveTask `yaml:"dokku_git_from_archive"`
}

GitFromArchiveTaskExample contains an example of a GitFromArchiveTask

func (GitFromArchiveTaskExample) GetName 

func (e GitFromArchiveTaskExample) GetName() string

GetName returns the name of the example

type GitFromImageTask 

type GitFromImageTask struct {
	// App is the name of the app
	App string `required:"true" identity:"key" yaml:"app" description:"Name of the app"`

	// Image is the docker image to deploy. Tagged sensitive because image
	// references can embed registry credentials (e.g. user:token@host/repo).
	Image string `required:"true" sensitive:"true" yaml:"image" description:"Docker image to deploy"`

	// BuildDir is the directory to build the git repository
	BuildDir string `required:"false" yaml:"build_dir,omitempty" description:"Directory to build the git repository"`

	// GitUsername is the username to use for the git repository
	GitUsername string `required:"false" yaml:"git_username,omitempty" description:"Username to use for the git repository (requires git_email)"`

	// GitEmail is the email to use for the git repository
	GitEmail string `required:"false" yaml:"git_email,omitempty" description:"Email to use for the git repository (requires git_username)"`

	// State is the desired state of the git repository
	State State `` /* 127-byte string literal not displayed */
}

GitFromImageTask deploys a git repository from a docker image

func (GitFromImageTask) Doc 

func (t GitFromImageTask) Doc() string

Doc returns the docblock for the git from image task

func (GitFromImageTask) Execute 

func (t GitFromImageTask) Execute(ctx context.Context) TaskOutputState

Execute deploys a git repository from a docker image

func (GitFromImageTask) ExportApp 

func (t GitFromImageTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs a docker-image deploy source from apps:report. The image reference is sensitive, so the engine lifts it into the vars-file.

func (GitFromImageTask) ExportSupport 

func (t GitFromImageTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (GitFromImageTask) Plan 

func (t GitFromImageTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the GitFromImageTask would produce.

func (GitFromImageTask) ProbeSupport 

func (t GitFromImageTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (GitFromImageTask) Validate 

func (t GitFromImageTask) Validate() error

Validate checks the GitFromImageTask's inputs without contacting the server.

type GitFromImageTaskExample 

type GitFromImageTaskExample struct {
	// Name is the task name holding the GitFromImageTask description
	Name string `yaml:"-"`

	// GitFromImageTask is the GitFromImageTask configuration
	GitFromImageTask GitFromImageTask `yaml:"dokku_git_from_image"`
}

GitFromImageTaskExample contains an example of a GitFromImageTask

func (GitFromImageTaskExample) GetName 

func (e GitFromImageTaskExample) GetName() string

GetName returns the name of the example

type GitPropertyTask 

type GitPropertyTask PropertyFields

GitPropertyTask manages the git configuration for a given dokku application

func (GitPropertyTask) Doc 

func (t GitPropertyTask) Doc() string

Doc returns the docblock for the git property task

func (GitPropertyTask) Execute 

func (t GitPropertyTask) Execute(ctx context.Context) TaskOutputState

Execute sets or unsets the git property

func (GitPropertyTask) ExportApp 

func (t GitPropertyTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs the app's explicitly-set properties.

func (GitPropertyTask) ExportGlobal 

func (t GitPropertyTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reconstructs the globally-set properties.

func (GitPropertyTask) ExportSupport 

func (t GitPropertyTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (GitPropertyTask) Plan 

func (t GitPropertyTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the GitPropertyTask would produce.

func (GitPropertyTask) ProbeSupport 

func (t GitPropertyTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (GitPropertyTask) Validate 

func (t GitPropertyTask) Validate() error

Validate checks the GitPropertyTask's inputs without contacting the server.

type GitPropertyTaskExample 

type GitPropertyTaskExample struct {
	// Name is the task name holding the GitPropertyTask description
	Name string `yaml:"-"`

	// GitPropertyTask is the GitPropertyTask configuration
	GitPropertyTask GitPropertyTask `yaml:"dokku_git_property"`
}

GitPropertyTaskExample contains an example of a GitPropertyTask

func (GitPropertyTaskExample) GetName 

func (e GitPropertyTaskExample) GetName() string

GetName returns the name of the example

type GitSyncTask 

type GitSyncTask struct {
	// App is the name of the app
	App string `required:"true" identity:"key" yaml:"app" description:"Name of the app"`

	// Remote is the git remote url to sync
	Remote string `required:"true" yaml:"remote" description:"Git remote url to sync"`

	// GitRef is the git reference to sync
	GitRef string `required:"false" yaml:"git_ref" description:"Git reference to sync"`

	// Build triggers an application build after syncing
	Build bool `required:"false" yaml:"build" description:"Trigger an application build after syncing"`

	// BuildIfChanges triggers a build only if changes are detected
	BuildIfChanges bool `required:"false" yaml:"build_if_changes" description:"Trigger a build only if changes are detected"`

	// SkipDeployBranch skips automatically setting the deploy-branch property
	SkipDeployBranch bool `required:"false" yaml:"skip_deploy_branch" description:"Skip automatically setting the deploy-branch property"`

	// State is the desired state of the git sync
	State State `required:"false" yaml:"state" default:"present" options:"present" description:"Desired state of the git sync"`
}

GitSyncTask syncs a git repository to a dokku application

func (GitSyncTask) Doc 

func (t GitSyncTask) Doc() string

Doc returns the docblock for the git sync task

func (GitSyncTask) Execute 

func (t GitSyncTask) Execute(ctx context.Context) TaskOutputState

Execute syncs a git repository to a dokku application

func (GitSyncTask) ExportApp 

func (t GitSyncTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs a git-sync deploy source from apps:report. The metadata records "<remote>#<resolved SHA>", so the remote is taken from the portion before the last "#" and the ref from the deploy-branch git:sync persisted - not the SHA, which the probe cannot match against a branch or tag. It only emits when the app was last deployed via git:sync.

func (GitSyncTask) ExportSupport 

func (t GitSyncTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (GitSyncTask) Plan 

func (t GitSyncTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the GitSyncTask would produce.

func (GitSyncTask) ProbeSupport 

func (t GitSyncTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

type GitSyncTaskExample 

type GitSyncTaskExample struct {
	// Name is the task name holding the GitSyncTask description
	Name string `yaml:"-"`

	// GitSyncTask is the GitSyncTask configuration
	GitSyncTask GitSyncTask `yaml:"dokku_git_sync"`
}

GitSyncTaskExample contains an example of a GitSyncTask

func (GitSyncTaskExample) GetName 

func (e GitSyncTaskExample) GetName() string

GetName returns the name of the example

type GlobalExporter 

type GlobalExporter interface {
	ExportGlobal(ctx context.Context) ([]interface{}, error)
}

GlobalExporter is the not-app-scoped counterpart of AppExporter (global certs, networks, ssh keys, ...). It is defined here so global resources can be added the same way; the engine runs these into a leading global play.

type HaproxyPropertyTask 

type HaproxyPropertyTask PropertyFields

HaproxyPropertyTask manages the haproxy configuration for a given dokku application

func (HaproxyPropertyTask) Doc 

func (t HaproxyPropertyTask) Doc() string

Doc returns the docblock for the haproxy property task

func (HaproxyPropertyTask) Execute 

func (t HaproxyPropertyTask) Execute(ctx context.Context) TaskOutputState

Execute sets or unsets the haproxy property

func (HaproxyPropertyTask) ExportApp 

func (t HaproxyPropertyTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs the app's explicitly-set properties.

func (HaproxyPropertyTask) ExportGlobal 

func (t HaproxyPropertyTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reconstructs the globally-set properties.

func (HaproxyPropertyTask) ExportSupport 

func (t HaproxyPropertyTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (HaproxyPropertyTask) Plan 

func (t HaproxyPropertyTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the HaproxyPropertyTask would produce.

func (HaproxyPropertyTask) ProbeSupport 

func (t HaproxyPropertyTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (HaproxyPropertyTask) Validate 

func (t HaproxyPropertyTask) Validate() error

Validate checks the HaproxyPropertyTask's inputs without contacting the server.

type HaproxyPropertyTaskExample 

type HaproxyPropertyTaskExample struct {
	// Name is the task name holding the HaproxyPropertyTask description
	Name string `yaml:"-"`

	// HaproxyPropertyTask is the HaproxyPropertyTask configuration
	HaproxyPropertyTask HaproxyPropertyTask `yaml:"dokku_haproxy_property"`
}

HaproxyPropertyTaskExample contains an example of a HaproxyPropertyTask

func (HaproxyPropertyTaskExample) GetName 

func (e HaproxyPropertyTaskExample) GetName() string

GetName returns the name of the example

type HttpAuthAllowedIpTask 

type HttpAuthAllowedIpTask struct {
	// App is the name of the app
	App string `required:"true" identity:"key" yaml:"app" description:"Name of the app"`

	// AllowedIps is the list of IP addresses to allow or remove
	AllowedIps []string `` /* 145-byte string literal not displayed */

	// State is the desired state of the allowed IP entries
	State State `` /* 146-byte string literal not displayed */
}

HttpAuthAllowedIpTask manages the set of IP addresses allowed to bypass HTTP auth for a dokku application

func (HttpAuthAllowedIpTask) Doc 

func (t HttpAuthAllowedIpTask) Doc() string

Doc returns the docblock for the HTTP auth allowed ip task

func (HttpAuthAllowedIpTask) Execute 

func (t HttpAuthAllowedIpTask) Execute(ctx context.Context) TaskOutputState

Execute manages the app's HTTP auth allowed IPs

func (HttpAuthAllowedIpTask) ExportApp 

func (t HttpAuthAllowedIpTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs the app's HTTP-auth allowed IPs, or nil when none are set. state:set replaces the whole allow-list for an exact match.

func (HttpAuthAllowedIpTask) ExportSupport 

func (t HttpAuthAllowedIpTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (HttpAuthAllowedIpTask) Plan 

func (t HttpAuthAllowedIpTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the HttpAuthAllowedIpTask would produce.

func (HttpAuthAllowedIpTask) ProbeSupport 

func (t HttpAuthAllowedIpTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (HttpAuthAllowedIpTask) Requirements 

func (t HttpAuthAllowedIpTask) Requirements() []string

Requirements lists the non-core dokku plugins this task depends on.

func (HttpAuthAllowedIpTask) Validate 

func (t HttpAuthAllowedIpTask) Validate() error

Validate checks the HttpAuthAllowedIpTask's inputs without contacting the server.

type HttpAuthAllowedIpTaskExample 

type HttpAuthAllowedIpTaskExample struct {
	// Name is the task name holding the HttpAuthAllowedIpTask description
	Name string `yaml:"-"`

	// DokkuHttpAuthAllowedIp is the HttpAuthAllowedIpTask configuration
	DokkuHttpAuthAllowedIp HttpAuthAllowedIpTask `yaml:"dokku_http_auth_allowed_ip"`
}

HttpAuthAllowedIpTaskExample contains an example of an HttpAuthAllowedIpTask

func (HttpAuthAllowedIpTaskExample) GetName 

func (e HttpAuthAllowedIpTaskExample) GetName() string

GetName returns the name of the example

type HttpAuthDomainTask 

type HttpAuthDomainTask struct {
	// App is the name of the app
	App string `required:"true" identity:"key" yaml:"app" description:"Name of the app"`

	// Domains is the list of domains to restrict HTTP auth to
	Domains []string `` /* 142-byte string literal not displayed */

	// State is the desired state of the HTTP auth domain entries
	State State `` /* 152-byte string literal not displayed */
}

HttpAuthDomainTask manages the set of domains HTTP auth is restricted to for a dokku application

func (HttpAuthDomainTask) Doc 

func (t HttpAuthDomainTask) Doc() string

Doc returns the docblock for the HTTP auth domain task

func (HttpAuthDomainTask) Execute 

func (t HttpAuthDomainTask) Execute(ctx context.Context) TaskOutputState

Execute manages the app's HTTP auth domains

func (HttpAuthDomainTask) ExportApp 

func (t HttpAuthDomainTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs the domains HTTP auth is restricted to, or nil when none are set. state:set replaces the whole domain set for an exact match.

func (HttpAuthDomainTask) ExportSupport 

func (t HttpAuthDomainTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (HttpAuthDomainTask) Plan 

func (t HttpAuthDomainTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the HttpAuthDomainTask would produce.

func (HttpAuthDomainTask) ProbeSupport 

func (t HttpAuthDomainTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (HttpAuthDomainTask) Requirements 

func (t HttpAuthDomainTask) Requirements() []string

Requirements lists the non-core dokku plugins this task depends on.

func (HttpAuthDomainTask) Validate 

func (t HttpAuthDomainTask) Validate() error

Validate checks the HttpAuthDomainTask's inputs without contacting the server.

type HttpAuthDomainTaskExample 

type HttpAuthDomainTaskExample struct {
	// Name is the task name holding the HttpAuthDomainTask description
	Name string `yaml:"-"`

	// DokkuHttpAuthDomain is the HttpAuthDomainTask configuration
	DokkuHttpAuthDomain HttpAuthDomainTask `yaml:"dokku_http_auth_domain"`
}

HttpAuthDomainTaskExample contains an example of an HttpAuthDomainTask

func (HttpAuthDomainTaskExample) GetName 

func (e HttpAuthDomainTaskExample) GetName() string

GetName returns the name of the example

type HttpAuthTask 

type HttpAuthTask struct {
	// App is the name of the app
	App string `required:"true" identity:"key" yaml:"app" description:"Name of the app"`

	// Username is the HTTP auth username seeded when auth is enabled
	Username string `` /* 130-byte string literal not displayed */

	// Password is the HTTP auth password seeded when auth is enabled
	Password string `` /* 149-byte string literal not displayed */

	// State is the state of the HTTP auth
	State State `required:"false" yaml:"state,omitempty" default:"present" options:"present,absent" description:"State of the HTTP auth"`
}

HttpAuthTask manages HTTP authentication for a dokku application

func (HttpAuthTask) Doc 

func (t HttpAuthTask) Doc() string

Doc returns the docblock for the HTTP auth task

func (HttpAuthTask) Execute 

func (t HttpAuthTask) Execute(ctx context.Context) TaskOutputState

Execute enables or disables HTTP authentication for an app

func (HttpAuthTask) ExportApp 

func (t HttpAuthTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs whether HTTP auth is serving for an app. It is emitted after the rest of the http-auth family (see appExportOrder), because http-auth:add-user, add-allowed-ip and add-domain all write enabled=true as a side effect: this task runs last so the recipe's stated auth state is the one that sticks.

An enabled app emits `state: present`, with no credentials - the users come back as dokku_http_auth_user tasks, so seeding one here would only duplicate an input. A disabled app that still carries users, allowed IPs or auth domains emits `state: absent`, undoing the enable those tasks force; a disabled app with nothing configured emits no task at all.

func (HttpAuthTask) ExportSupport 

func (t HttpAuthTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (HttpAuthTask) Plan 

func (t HttpAuthTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the HttpAuthTask would produce.

func (HttpAuthTask) ProbeSupport 

func (t HttpAuthTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (HttpAuthTask) Requirements 

func (t HttpAuthTask) Requirements() []string

Requirements lists the non-core dokku plugins this task depends on.

func (HttpAuthTask) Validate 

func (t HttpAuthTask) Validate() error

Validate checks the HttpAuthTask's inputs without contacting the server.

`http-auth:enable` takes the username and password as optional positional arguments (`<app> [<user>] [<password>]`) and skips user initialization when they are absent, so a credential-free `state: present` is valid and simply turns auth on. What is not valid is half a credential, so the pair is required together.

type HttpAuthTaskExample 

type HttpAuthTaskExample struct {
	// Name is the task name holding the HttpAuthTask description
	Name string `yaml:"-"`

	// DokkuHttpAuth is the HttpAuthTask configuration
	DokkuHttpAuth HttpAuthTask `yaml:"dokku_http_auth"`
}

HttpAuthTaskExample contains an example of an HttpAuthTask

func (HttpAuthTaskExample) GetName 

func (e HttpAuthTaskExample) GetName() string

GetName returns the name of the example

type HttpAuthUser 

type HttpAuthUser struct {
	// Username is the HTTP auth username
	Username string `required:"true" identity:"key" yaml:"username" description:"HTTP auth username"`

	// Password is the cleartext HTTP auth password, applied with
	// http-auth:add-user. Mutually exclusive with Hash.
	Password string `` /* 132-byte string literal not displayed */

	// Hash is the user's htpasswd entry, as emitted by
	// http-auth:export-users. Applied with http-auth:import-users over stdin,
	// so the value never reaches argv. Mutually exclusive with Password; this
	// is the form `docket export` emits, since the plugin can read hashes back
	// but never the passwords behind them.
	Hash string `` /* 241-byte string literal not displayed */
}

HttpAuthUser represents a single HTTP auth user. Exactly one of Password and Hash carries the credential.

The `sensitive:"true"` tags document intent, but because the fields live in a slice-of-structs the reflection walker in sensitive.go cannot reach them - the task's SensitiveValues method is what actually masks these values.

type HttpAuthUserTask 

type HttpAuthUserTask struct {
	// App is the name of the app
	App string `required:"true" identity:"key" yaml:"app" description:"Name of the app"`

	// Users is the list of HTTP auth users to add or remove. The docs generator
	// lists an item's field names but cannot express that password and hash are
	// alternatives, nor that both are secret, so this description carries it.
	Users []HttpAuthUser `` /* 295-byte string literal not displayed */

	// UpdatePassword re-issues http-auth:add-user for users that already exist
	// so their password converges. Cleartext passwords are not exposed in the
	// report, so a rotation cannot be drift-detected; enable this to force
	// convergence. It governs the password path only - a hash user converges on
	// its own, because http-auth:export-users reads the stored hash back. It is
	// a *bool so the value survives decoding unchanged; nil defaults to false.
	UpdatePassword *bool `` /* 223-byte string literal not displayed */

	// State is the desired state of the HTTP auth users. There is no `clear`
	// state, unlike the sibling dokku_http_auth_domain: `absent` with an empty
	// `users` already removes every user.
	State State `` /* 137-byte string literal not displayed */
}

HttpAuthUserTask manages the set of HTTP auth users for a dokku application

func (HttpAuthUserTask) Doc 

func (t HttpAuthUserTask) Doc() string

Doc returns the docblock for the HTTP auth user task

func (HttpAuthUserTask) Execute 

func (t HttpAuthUserTask) Execute(ctx context.Context) TaskOutputState

Execute manages the app's HTTP auth users

func (HttpAuthUserTask) ExportApp 

func (t HttpAuthUserTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs the app's HTTP-auth users, each carrying the stored htpasswd hash. That is the whole point of exporting by hash: the recipe reproduces the users without anyone knowing the passwords behind them.

http-auth:export-users reads the same htpasswd the report derives its `users` key from, so it is the only probe needed here. A transport-level failure (`*subprocess.SSHError`) is propagated; any other failure is treated as "no users", matching the other readers in this package - that is what keeps a server without the http-auth plugin from raising an export warning for every app it has.

State is set explicitly so the emitted body is directly plannable, rather than depending on the decode-time default. It is `present`, not `set`, even though every listed user is exported and the sibling exact-set exporters (dokku_http_auth_domain, dokku_domains, dokku_ports) emit `set`: an exported recipe should not silently delete a user that exists only on the destination.

func (HttpAuthUserTask) ExportSupport 

func (t HttpAuthUserTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

Supported without a caveat because http-auth:export-users reads every user's htpasswd entry back, so an exported recipe reproduces the users with no operator-supplied credentials. That command is guaranteed by the floor in Requirements(); the whole http-auth family already assumes it (export-users and a credential-free http-auth:enable are both 0.13.0 behaviours), so there is no fallback for older plugins here.

func (HttpAuthUserTask) Plan 

func (t HttpAuthUserTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the HttpAuthUserTask would produce.

func (HttpAuthUserTask) ProbeSupport 

func (t HttpAuthUserTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (HttpAuthUserTask) Requirements 

func (t HttpAuthUserTask) Requirements() []string

Requirements lists the non-core dokku plugins this task depends on.

func (HttpAuthUserTask) SensitiveValues 

func (t HttpAuthUserTask) SensitiveValues() []string

SensitiveValues returns the per-user credentials so they are masked in user-facing output. The tag-based walker in sensitive.go does not descend into slices of structs, so they are collected here. Hashes are credential material too - they are what an attacker needs to reproduce the htpasswd - so they are masked alongside the cleartext passwords.

func (HttpAuthUserTask) Validate 

func (t HttpAuthUserTask) Validate() error

Validate checks the HttpAuthUserTask's inputs without contacting the server.

type HttpAuthUserTaskExample 

type HttpAuthUserTaskExample struct {
	// Name is the task name holding the HttpAuthUserTask description
	Name string `yaml:"-"`

	// DokkuHttpAuthUser is the HttpAuthUserTask configuration
	DokkuHttpAuthUser HttpAuthUserTask `yaml:"dokku_http_auth_user"`
}

HttpAuthUserTaskExample contains an example of an HttpAuthUserTask

func (HttpAuthUserTaskExample) GetName 

func (e HttpAuthUserTaskExample) GetName() string

GetName returns the name of the example

type IdentityCollection 

type IdentityCollection struct {
	// Field is the Go struct field name.
	Field string

	// YAMLName is the recipe key, from the field's yaml tag.
	YAMLName string

	// Item says what identifies one entry in the collection.
	Item ItemIdentity

	// ItemKeys are the element struct's own identity key yaml names, in
	// declaration order. Populated only when Item is ItemIdentityFields.
	ItemKeys []string
}

IdentityCollection is one declared collection field.

func TaskIdentityCollections 

func TaskIdentityCollections(t Task) []IdentityCollection

TaskIdentityCollections returns t's declared collection fields in declaration order. Most tasks declare none and none declares more than one today, but the shape does not forbid it.

type IdentityCollectionSchema 

type IdentityCollectionSchema struct {
	// Name is the collection's recipe key.
	Name string `json:"name"`

	// Item says what identifies one entry: "value", "map_key", or "fields".
	Item ItemIdentity `json:"item"`

	// ItemKeys are the element struct's own identity key names, in declaration
	// order. Populated only when Item is "fields".
	ItemKeys []string `json:"item_keys,omitempty"`
}

IdentityCollectionSchema is one `identity:"collection"` field.

type IdentityKey 

type IdentityKey struct {
	// Field is the Go struct field name.
	Field string

	// YAMLName is the recipe key, from the field's yaml tag.
	YAMLName string

	// Value is the field's value rendered as a string.
	Value string

	// Present is false when the field holds its zero value. A key that is not
	// present is omitted from the address, which is what lets the mutually
	// exclusive app / global pair render honestly.
	Present bool
}

IdentityKey is one declared key field, with the value it carries on the task instance it was read from. Value is empty and Present is false when read from a registry prototype, which is what the docs generator wants.

func TaskIdentity 

func TaskIdentity(t Task) []IdentityKey

TaskIdentity returns t's declared key fields in declaration order, each carrying the value it holds on t. Centralised so the loader, the export filter, and the docs generator share one read site, mirroring TaskProbeSupport and TaskExportSupport.

type IdentitySchema 

type IdentitySchema struct {
	// Keys are the recipe keys of the identity key fields, in declaration
	// order - the order IdentityAddress renders them in. A key holding its
	// zero value is omitted from the rendered address, which is what lets the
	// mutually exclusive app / global pair produce two different addresses.
	//
	// Derivable from the fields carrying `"identity": "key"`, and duplicated
	// here because building a resource address is the main thing a consumer
	// does with this.
	Keys []string `json:"keys"`

	// Collections are the collection fields the task manages wholesale.
	Collections []IdentityCollectionSchema `json:"collections,omitempty"`
}

IdentitySchema is what a task addresses, projected from the `identity:"key"` and `identity:"collection"` field tags.

type Input 

type Input struct {
	// Name is the name of the input
	Name string `yaml:"name" json:"name"`

	// Default is the default value of the input
	Default string `yaml:"default" json:"default,omitempty"`

	// Description is the description of the input
	Description string `yaml:"description" json:"description,omitempty"`

	// Required is a flag indicating if the input is required
	Required bool `yaml:"required" json:"required,omitempty"`

	// Sensitive marks the input's resolved value as a secret. When true,
	// the value is masked as `***` anywhere it would otherwise appear in
	// user-facing output (apply --verbose echoes, plan output, error
	// messages, and the DOKKU_TRACE debug log).
	Sensitive bool `yaml:"sensitive" json:"sensitive,omitempty"`

	// Type is the type of the input
	Type string `yaml:"type" json:"type,omitempty"`
	// contains filtered or unexported fields
}

Input represents an input for a task

func (Input) GetValue 

func (i Input) GetValue() string

GetValue returns the value of the input

func (Input) HasValue 

func (i Input) HasValue() bool

HasValue returns true if the input has a value

func (*Input) SetValue 

func (i *Input) SetValue(value string) error

SetValue sets the value of the input

type InputValidator 

type InputValidator interface {
	Validate() error
}

InputValidator is an optional interface a task implements to expose input-only validation: checks that are a pure function of the task's fields and require no server probing (empty-list-when-present, per-item required fields, enum values, mutually-exclusive fields, and so on).

A task's Plan() calls Validate() before it probes, so plan and apply surface these errors. `docket validate` calls the same Validate() offline (see validateTaskBody) so the identical conditional/semantic errors are caught without contacting a server. Implementations must never call a mutating or probing dokku command; that is what keeps validate offline.

type ItemIdentity 

type ItemIdentity string

ItemIdentity classifies what identifies one item inside a collection field. 

const (
	// ItemIdentityValue means the element value is the item's identity, as in
	// a `[]string` of domain names.
	ItemIdentityValue ItemIdentity = "value"

	// ItemIdentityMapKey means the map key is the item's identity, as in a
	// `map[string]string` of config pairs.
	ItemIdentityMapKey ItemIdentity = "map_key"

	// ItemIdentityFields means the element is a struct whose own
	// `identity:"key"` fields identify the item, as in PortMapping.
	ItemIdentityFields ItemIdentity = "fields"
)

type ItemSchema 

type ItemSchema struct {
	// KeyType is the map key's type. Present only on a dict; always "string"
	// today.
	KeyType string `json:"key_type,omitempty"`

	// Type is the element's type: a scalar name, "object" when the element is
	// a struct, or "any" when it is untyped.
	Type string `json:"type"`

	// Identity is what identifies one entry, for a field tagged
	// `identity:"collection"`: "value", "map_key", or "fields". Absent on a
	// collection the task treats as an attribute rather than as the set of
	// items it manages.
	Identity ItemIdentity `json:"identity,omitempty"`

	// Keys are the element struct's own identity key names. Present only when
	// Identity is "fields".
	Keys []string `json:"keys,omitempty"`

	// Fields are the element struct's own fields, in declaration order.
	// Present only when Type is "object". An element struct declares the same
	// tags a task does, so this is where a consumer learns that a
	// HttpAuthUser's `password` is sensitive.
	Fields []FieldSchema `json:"fields,omitempty"`
}

ItemSchema is the element shape of a list or dict field. `list` alone cannot tell a []string from a []PortMapping, which is the gap this closes.

type LetsencryptPropertyTask 

type LetsencryptPropertyTask SensitivePropertyFields

LetsencryptPropertyTask manages the letsencrypt configuration for a given dokku application

func (LetsencryptPropertyTask) Doc 

func (t LetsencryptPropertyTask) Doc() string

Doc returns the docblock for the letsencrypt property task

func (LetsencryptPropertyTask) Execute 

func (t LetsencryptPropertyTask) Execute(ctx context.Context) TaskOutputState

Execute sets or unsets the letsencrypt property

func (LetsencryptPropertyTask) ExportApp 

func (t LetsencryptPropertyTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs the app's explicitly-set properties.

func (LetsencryptPropertyTask) ExportGlobal 

func (t LetsencryptPropertyTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reconstructs the globally-set properties.

func (LetsencryptPropertyTask) ExportSupport 

func (t LetsencryptPropertyTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (LetsencryptPropertyTask) Plan 

func (t LetsencryptPropertyTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the LetsencryptPropertyTask would produce.

func (LetsencryptPropertyTask) ProbeSupport 

func (t LetsencryptPropertyTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

Supported without a caveat because dokku-letsencrypt 0.25.0+ reports the dynamic `dns-provider-*` family alongside the mapped properties, so every property this task manages is readable and converges (#449).

func (LetsencryptPropertyTask) Requirements 

func (t LetsencryptPropertyTask) Requirements() []string

Requirements lists the non-core dokku plugins this task depends on. The version floor is the release that surfaced `dns-provider-*` properties in `letsencrypt:report`; below it those properties are absent from the report and a `state: absent` task would read an unset property as already gone.

func (LetsencryptPropertyTask) Validate 

func (t LetsencryptPropertyTask) Validate() error

Validate checks the LetsencryptPropertyTask's inputs without contacting the server.

type LetsencryptPropertyTaskExample 

type LetsencryptPropertyTaskExample struct {
	// Name is the task name holding the LetsencryptPropertyTask description
	Name string `yaml:"-"`

	// LetsencryptPropertyTask is the LetsencryptPropertyTask configuration
	LetsencryptPropertyTask LetsencryptPropertyTask `yaml:"dokku_letsencrypt_property"`
}

LetsencryptPropertyTaskExample contains an example of a LetsencryptPropertyTask

func (LetsencryptPropertyTaskExample) GetName 

func (e LetsencryptPropertyTaskExample) GetName() string

GetName returns the name of the example

type LetsencryptTask 

type LetsencryptTask struct {
	// App is the name of the app
	App string `required:"true" identity:"key" yaml:"app" description:"Name of the app"`

	// State is the desired state of the letsencrypt integration
	State State `` /* 141-byte string literal not displayed */
}

LetsencryptTask enables or disables the dokku-letsencrypt plugin for a dokku app

func (LetsencryptTask) Doc 

func (t LetsencryptTask) Doc() string

Doc returns the docblock for the letsencrypt task

func (LetsencryptTask) Execute 

func (t LetsencryptTask) Execute(ctx context.Context) TaskOutputState

Execute enables or disables letsencrypt

func (LetsencryptTask) ExportApp 

func (t LetsencryptTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp emits a dokku_letsencrypt task when letsencrypt is active for the app (it is inactive by default, so a normal app needs no task).

func (LetsencryptTask) ExportSupport 

func (t LetsencryptTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (LetsencryptTask) Plan 

func (t LetsencryptTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the LetsencryptTask would produce.

func (LetsencryptTask) ProbeSupport 

func (t LetsencryptTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (LetsencryptTask) Requirements 

func (t LetsencryptTask) Requirements() []string

Requirements lists the non-core dokku plugins this task depends on.

func (LetsencryptTask) Validate 

func (t LetsencryptTask) Validate() error

Validate checks the LetsencryptTask's inputs without contacting the server.

type LetsencryptTaskExample 

type LetsencryptTaskExample struct {
	// Name is the task name holding the LetsencryptTask description
	Name string `yaml:"-"`

	// LetsencryptTask is the LetsencryptTask configuration
	LetsencryptTask LetsencryptTask `yaml:"dokku_letsencrypt"`
}

LetsencryptTaskExample contains an example of a LetsencryptTask

func (LetsencryptTaskExample) GetName 

func (e LetsencryptTaskExample) GetName() string

GetName returns the name of the example

type LogsPropertyTask 

type LogsPropertyTask PropertyFields

LogsPropertyTask manages the logs configuration for a given dokku application

func (LogsPropertyTask) Doc 

func (t LogsPropertyTask) Doc() string

Doc returns the docblock for the logs property task

func (LogsPropertyTask) Execute 

func (t LogsPropertyTask) Execute(ctx context.Context) TaskOutputState

Execute sets or unsets the logs property

func (LogsPropertyTask) ExportApp 

func (t LogsPropertyTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs the app's explicitly-set properties.

func (LogsPropertyTask) ExportGlobal 

func (t LogsPropertyTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reconstructs the globally-set properties.

func (LogsPropertyTask) ExportSupport 

func (t LogsPropertyTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (LogsPropertyTask) Plan 

func (t LogsPropertyTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the LogsPropertyTask would produce.

func (LogsPropertyTask) ProbeSupport 

func (t LogsPropertyTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (LogsPropertyTask) Validate 

func (t LogsPropertyTask) Validate() error

Validate checks the LogsPropertyTask's inputs without contacting the server.

type LogsPropertyTaskExample 

type LogsPropertyTaskExample struct {
	// Name is the task name holding the LogsPropertyTask description
	Name string `yaml:"-"`

	// LogsPropertyTask is the LogsPropertyTask configuration
	LogsPropertyTask LogsPropertyTask `yaml:"dokku_logs_property"`
}

LogsPropertyTaskExample contains an example of a LogsPropertyTask

func (LogsPropertyTaskExample) GetName 

func (e LogsPropertyTaskExample) GetName() string

GetName returns the name of the example

type MaintenanceCustomPageTask 

type MaintenanceCustomPageTask struct {
	// App is the name of the app
	App string `required:"true" identity:"key" yaml:"app" description:"Name of the app"`

	// Content is inline HTML stored as maintenance.html. Mutually exclusive
	// with Tarball.
	Content string `` /* 178-byte string literal not displayed */

	// Tarball is the path on the machine running docket to a tar archive
	// containing at least maintenance.html. Mutually exclusive with Content.
	Tarball string `` /* 236-byte string literal not displayed */

	// State is the desired state of the custom maintenance page
	State State `` /* 141-byte string literal not displayed */
}

MaintenanceCustomPageTask installs (or removes) a custom maintenance page for a dokku app via the dokku-maintenance plugin. The page is delivered as a tar archive streamed to `dokku maintenance:custom-page <app>` on stdin, either built from inline HTML (Content) or read from a tarball on disk (Tarball).

func (MaintenanceCustomPageTask) Doc 

func (t MaintenanceCustomPageTask) Doc() string

Doc returns the docblock for the maintenance custom page task

func (MaintenanceCustomPageTask) Execute 

func (t MaintenanceCustomPageTask) Execute(ctx context.Context) TaskOutputState

Execute installs or removes the custom maintenance page

func (MaintenanceCustomPageTask) ExportApp 

func (t MaintenanceCustomPageTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp satisfies AppExporter by delegating to exportApp with a no-op warn callback. The export engine prefers ExportAppReport when present, so the dropped-assets diagnostic reaches ExportReport.Warnings rather than being discarded here.

func (MaintenanceCustomPageTask) ExportAppReport 

func (t MaintenanceCustomPageTask) ExportAppReport(ctx context.Context, app string, warn func(msg string)) ([]interface{}, error)

ExportAppReport is the diagnostics-aware form of ExportApp (the appExportReporter interface): it routes the "dropped extra assets" warning through the engine's warn callback (wired to ExportReport.Warnings) instead of a raw log line, so the warning is rendered and masked like every other export diagnostic.

func (MaintenanceCustomPageTask) ExportSupport 

func (t MaintenanceCustomPageTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (MaintenanceCustomPageTask) Plan 

func (t MaintenanceCustomPageTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the MaintenanceCustomPageTask would produce.

func (MaintenanceCustomPageTask) ProbeSupport 

func (t MaintenanceCustomPageTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (MaintenanceCustomPageTask) Requirements 

func (t MaintenanceCustomPageTask) Requirements() []string

Requirements lists the non-core dokku plugins this task depends on.

func (MaintenanceCustomPageTask) Validate 

func (t MaintenanceCustomPageTask) Validate() error

Validate checks the MaintenanceCustomPageTask's inputs without contacting the server.

type MaintenanceCustomPageTaskExample 

type MaintenanceCustomPageTaskExample struct {
	// Name is the task name holding the MaintenanceCustomPageTask description
	Name string `yaml:"-"`

	// MaintenanceCustomPageTask is the MaintenanceCustomPageTask configuration
	MaintenanceCustomPageTask MaintenanceCustomPageTask `yaml:"dokku_maintenance_custom_page"`
}

MaintenanceCustomPageTaskExample contains an example of a MaintenanceCustomPageTask

func (MaintenanceCustomPageTaskExample) GetName 

func (e MaintenanceCustomPageTaskExample) GetName() string

GetName returns the name of the example

type MaintenanceTask 

type MaintenanceTask ToggleFields

MaintenanceTask enables or disables maintenance mode for a given dokku application

func (MaintenanceTask) Doc 

func (t MaintenanceTask) Doc() string

Doc returns the docblock for the maintenance task

func (MaintenanceTask) Execute 

func (t MaintenanceTask) Execute(ctx context.Context) TaskOutputState

Execute enables or disables maintenance mode

func (MaintenanceTask) ExportApp 

func (t MaintenanceTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp emits a dokku_maintenance task only when maintenance mode is on (it is off by default, so a normal app needs no task).

func (MaintenanceTask) ExportSupport 

func (t MaintenanceTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (MaintenanceTask) Plan 

func (t MaintenanceTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the MaintenanceTask would produce.

func (MaintenanceTask) ProbeSupport 

func (t MaintenanceTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (MaintenanceTask) Requirements 

func (t MaintenanceTask) Requirements() []string

Requirements lists the non-core dokku plugins this task depends on.

type MaintenanceTaskExample 

type MaintenanceTaskExample struct {
	// Name is the task name holding the MaintenanceTask description
	Name string `yaml:"-"`

	// MaintenanceTask is the MaintenanceTask configuration
	MaintenanceTask MaintenanceTask `yaml:"dokku_maintenance"`
}

MaintenanceTaskExample contains an example of a MaintenanceTask

func (MaintenanceTaskExample) GetName 

func (e MaintenanceTaskExample) GetName() string

GetName returns the name of the example

type NetworkPropertyTask 

type NetworkPropertyTask PropertyFields

NetworkPropertyTask manages the network property for a given dokku application

func (NetworkPropertyTask) Doc 

func (t NetworkPropertyTask) Doc() string

Doc returns the docblock for the network property task

func (NetworkPropertyTask) Execute 

func (t NetworkPropertyTask) Execute(ctx context.Context) TaskOutputState

Execute sets or unsets the network property

func (NetworkPropertyTask) ExportApp 

func (t NetworkPropertyTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs the app's explicitly-set properties.

func (NetworkPropertyTask) ExportGlobal 

func (t NetworkPropertyTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reconstructs the globally-set properties.

func (NetworkPropertyTask) ExportSupport 

func (t NetworkPropertyTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (NetworkPropertyTask) Plan 

func (t NetworkPropertyTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the NetworkPropertyTask would produce.

func (NetworkPropertyTask) ProbeSupport 

func (t NetworkPropertyTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (NetworkPropertyTask) Validate 

func (t NetworkPropertyTask) Validate() error

Validate checks the NetworkPropertyTask's inputs without contacting the server.

type NetworkPropertyTaskExample 

type NetworkPropertyTaskExample struct {
	// Name is the task name holding the NetworkPropertyTask description
	Name string `yaml:"-"`

	// NetworkPropertyTask is the NetworkPropertyTask configuration
	NetworkPropertyTask NetworkPropertyTask `yaml:"dokku_network_property"`
}

NetworkPropertyTaskExample contains an example of a NetworkPropertyTask

func (NetworkPropertyTaskExample) GetName 

func (e NetworkPropertyTaskExample) GetName() string

GetName returns the name of the example

type NetworkTask 

type NetworkTask struct {
	// Name is the name of the network
	Name string `required:"true" identity:"key" yaml:"name" description:"Name of the network"`

	// State is the state of the network
	State State `required:"false" yaml:"state,omitempty" default:"present" options:"present,absent" description:"State of the network"`
}

NetworkTask creates or destroys a Docker network

func (NetworkTask) Doc 

func (t NetworkTask) Doc() string

Doc returns the docblock for the network task

func (NetworkTask) Execute 

func (t NetworkTask) Execute(ctx context.Context) TaskOutputState

Execute creates or destroys a Docker network

func (NetworkTask) ExportGlobal 

func (t NetworkTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reconstructs the server's dokku-created networks from `network:list --format json`, emitting a dokku_network task for each network reporting DokkuManaged. Networks docket did not create - Docker built-ins and networks from other tooling - report DokkuManaged false and are skipped. A dokku predating the DokkuManaged field reports it absent (decoding to false) for every network, so nothing is exported rather than every network being re-emitted.

func (NetworkTask) ExportSupport 

func (t NetworkTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (NetworkTask) Plan 

func (t NetworkTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the NetworkTask would produce.

func (NetworkTask) ProbeSupport 

func (t NetworkTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

type NetworkTaskExample 

type NetworkTaskExample struct {
	// Name is the task name holding the NetworkTask description
	Name string `yaml:"-"`

	// DokkuNetwork is the NetworkTask configuration
	DokkuNetwork NetworkTask `yaml:"dokku_network"`
}

NetworkTaskExample contains an example of a NetworkTask

func (NetworkTaskExample) GetName 

func (e NetworkTaskExample) GetName() string

GetName returns the name of the example

type NginxPropertyTask 

type NginxPropertyTask PropertyFields

NginxPropertyTask manages the nginx configuration for a given dokku application

func (NginxPropertyTask) Doc 

func (t NginxPropertyTask) Doc() string

Doc returns the docblock for the nginx property task

func (NginxPropertyTask) Execute 

func (t NginxPropertyTask) Execute(ctx context.Context) TaskOutputState

Execute sets or unsets the nginx property

func (NginxPropertyTask) ExportApp 

func (t NginxPropertyTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs the app's explicitly-set nginx properties.

func (NginxPropertyTask) ExportGlobal 

func (t NginxPropertyTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reconstructs the globally-set properties.

func (NginxPropertyTask) ExportSupport 

func (t NginxPropertyTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (NginxPropertyTask) Plan 

func (t NginxPropertyTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the NginxPropertyTask would produce.

func (NginxPropertyTask) ProbeSupport 

func (t NginxPropertyTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (NginxPropertyTask) Validate 

func (t NginxPropertyTask) Validate() error

Validate checks the NginxPropertyTask's inputs without contacting the server.

type NginxPropertyTaskExample 

type NginxPropertyTaskExample struct {
	// Name is the task name holding the NginxPropertyTask description
	Name string `yaml:"-"`

	// NginxPropertyTask is the NginxPropertyTask configuration
	NginxPropertyTask NginxPropertyTask `yaml:"dokku_nginx_property"`
}

NginxPropertyTaskExample contains an example of a NginxPropertyTask

func (NginxPropertyTaskExample) GetName 

func (e NginxPropertyTaskExample) GetName() string

GetName returns the name of the example

type OpenrestyPropertyTask 

type OpenrestyPropertyTask PropertyFields

OpenrestyPropertyTask manages the openresty configuration for a given dokku application

func (OpenrestyPropertyTask) Doc 

func (t OpenrestyPropertyTask) Doc() string

Doc returns the docblock for the openresty property task

func (OpenrestyPropertyTask) Execute 

func (t OpenrestyPropertyTask) Execute(ctx context.Context) TaskOutputState

Execute sets or unsets the openresty property

func (OpenrestyPropertyTask) ExportApp 

func (t OpenrestyPropertyTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs the app's explicitly-set properties.

func (OpenrestyPropertyTask) ExportGlobal 

func (t OpenrestyPropertyTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reconstructs the globally-set properties.

func (OpenrestyPropertyTask) ExportSupport 

func (t OpenrestyPropertyTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (OpenrestyPropertyTask) Plan 

func (t OpenrestyPropertyTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the OpenrestyPropertyTask would produce.

func (OpenrestyPropertyTask) ProbeSupport 

func (t OpenrestyPropertyTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (OpenrestyPropertyTask) Validate 

func (t OpenrestyPropertyTask) Validate() error

Validate checks the OpenrestyPropertyTask's inputs without contacting the server.

type OpenrestyPropertyTaskExample 

type OpenrestyPropertyTaskExample struct {
	// Name is the task name holding the OpenrestyPropertyTask description
	Name string `yaml:"-"`

	// OpenrestyPropertyTask is the OpenrestyPropertyTask configuration
	OpenrestyPropertyTask OpenrestyPropertyTask `yaml:"dokku_openresty_property"`
}

OpenrestyPropertyTaskExample contains an example of an OpenrestyPropertyTask

func (OpenrestyPropertyTaskExample) GetName 

func (e OpenrestyPropertyTaskExample) GetName() string

GetName returns the name of the example

type OrderedStringEnvelopeMap 

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

OrderedStringEnvelopeMap is an insertion-ordered map of TaskEnvelopes keyed by string. Keys() returns names in the order they were Set, which is the order GetTasks parsed them out of the recipe. Loop expansions each contribute their own key (`<name> (item=<value>)`) so the map's uniqueness invariant holds across expanded envelopes.

Get(name) returns the underlying Task so it stays ergonomic for tests that only care about the decoded task body. Envelope-aware callers (apply / plan, sensitive, validate) use GetEnvelope to access the cross-cutting fields (tags / when / loop / register).

func GetTasks 

func GetTasks(data []byte, context map[string]interface{}) (OrderedStringEnvelopeMap, error)

GetTasks is a back-compat shim that returns the first play's task envelopes. New code should call GetPlays. The wrapper is kept because a large number of unit tests (tasks/*_test.go) exercise GetTasks directly against single-play recipes; those tests inspect the flat ordered map without caring about the multi-play envelope.

func (*OrderedStringEnvelopeMap) Get 

func (o *OrderedStringEnvelopeMap) Get(k string) Task

Get returns the Task registered under k, or nil if absent. This is a convenience wrapper for callers that only need the task body.

func (*OrderedStringEnvelopeMap) GetEnvelope 

func (o *OrderedStringEnvelopeMap) GetEnvelope(k string) *TaskEnvelope

GetEnvelope returns the envelope registered under k, or nil if absent.

func (*OrderedStringEnvelopeMap) Keys 

func (o *OrderedStringEnvelopeMap) Keys() []string

Keys returns the registered keys in insertion order.

func (*OrderedStringEnvelopeMap) Set 

func (o *OrderedStringEnvelopeMap) Set(k string, env *TaskEnvelope)

Set registers env under k. Setting a key that already exists overwrites the value but does not record a duplicate key in the order list. The loader avoids overwrites by suffixing loop-expansion names.

type PlanResult 

type PlanResult struct {
	// InSync is true when the task would not change anything.
	InSync bool

	// Status is the short marker for the drift kind.
	Status PlanStatus

	// Reason is human-readable detail (e.g. "ref drift", "2 keys to set").
	Reason string

	// Mutations optionally itemizes per-mutation drift for tasks that
	// perform multiple operations (e.g. config setting and unsetting
	// individual keys). One entry per atomic change.
	Mutations []string

	// Commands is the resolved dokku command line(s) that ExecutePlan
	// would invoke if Plan reported drift, in invocation order. They are
	// rendered against the target the planning context carried, which is the
	// same one Execute applies under today; a plan carried across hosts would
	// have to re-render them. Tasks populate it via
	// subprocess.ResolveCommandString from the same
	// ExecCommandInput values the apply closure executes, so plan and
	// apply render byte-identical strings for the same operation.
	//
	// Contract: non-empty whenever Status is "+", "~", or "-" (drift);
	// empty when InSync is true or when Status is "!" (probe error).
	// Sensitive values are already masked because ResolveCommandString
	// runs MaskString on the rendered form.
	Commands []string

	// DesiredState mirrors TaskOutputState.DesiredState so plan output can
	// render the same context as apply output.
	DesiredState State

	// Error is non-nil when the read-state probe itself failed. A non-nil
	// Error implies Status == PlanStatusError.
	Error error

	// Stdout / Stderr / ExitCode capture the underlying subprocess
	// response that produced a probe error. Populated by probe call
	// sites that bubble a CallExecCommand failure into a PlanResult so
	// `failed_when` predicates referencing `result.Stderr` work in plan
	// mode the same way they do in apply mode. Empty / zero on the
	// in-sync, drift, and apply-only paths.
	Stdout   string
	Stderr   string
	ExitCode int

	// Warnings carries non-fatal probe diagnostics raised while planning (for
	// example a property probe that found no matching report key). The run
	// loop drains them through EventEmitter.TaskWarning; ExecutePlan copies
	// them onto TaskOutputState so the apply path surfaces them too. Stored
	// raw and masked at emit time, mirroring Reason. Empty when no diagnostic.
	Warnings []PlanWarning
	// contains filtered or unexported fields
}

PlanResult is the read-only drift report for a task.

Plan() never mutates server state. The unexported apply closure carries any state probed during planning so the apply path does not re-probe; ExecutePlan is the only consumer. When InSync is true, apply is nil.

func DispatchPlan 

func DispatchPlan(state State, funcMap map[State]func() PlanResult) PlanResult

DispatchPlan looks up the given state in the funcMap, calls the matching function, and returns an error PlanResult if the state is not found. Mirrors DispatchState but for the read-only Plan() path.

func PlanErrorFromExec 

func PlanErrorFromExec(desiredState State, err error, r subprocess.ExecCommandResponse) PlanResult

PlanErrorFromExec wraps a probe-side CallExecCommand failure into a PlanResult that also carries the response's Stdout/Stderr/ExitCode. Probe helpers use it from their `if err != nil` branch so a later failed_when predicate can match `result.Stderr` in plan mode the same way it can in apply mode. desiredState is the state value the caller would have stored in PlanResult.DesiredState; pass the State argument the probe is processing.

type PlanStatus 

type PlanStatus string

PlanStatus is the short marker that summarizes a planned change. 

const (
	// PlanStatusOK indicates the task is in sync; no change would be made.
	PlanStatusOK PlanStatus = "ok"
	// PlanStatusModify indicates the task would modify existing state.
	PlanStatusModify PlanStatus = "~"
	// PlanStatusCreate indicates the task would create new state.
	PlanStatusCreate PlanStatus = "+"
	// PlanStatusDestroy indicates the task would remove existing state.
	PlanStatusDestroy PlanStatus = "-"
	// PlanStatusError indicates the read-state probe itself failed.
	PlanStatusError PlanStatus = "!"
)

type PlanWarning 

type PlanWarning struct {
	Reason  string
	Message string
}

PlanWarning is a non-fatal probe diagnostic a task's Plan() surfaces for the run loop to route through EventEmitter.TaskWarning. Reason is a stable machine key (see the WarnReason* constants) so JSON consumers can branch on a typed category; Message is human-readable detail, stored raw and masked at emit time like PlanResult.Reason.

type Play 

type Play struct {
	// Name is the user-supplied label for the play. Auto-generated as
	// "play #N" when the entry omits a name (see GetPlays).
	Name string

	// Tags is the play's tag list. Folded into every task envelope's Tags
	// at parse time so the existing FilterByTags helper keeps working
	// without a per-play branch.
	Tags []string

	// When is the raw expr-lang/expr source for the play-level conditional.
	// An empty string means "always run". When non-empty, whenProgram caches
	// the compiled form so the executor can re-evaluate cheaply.
	When string

	// Inputs is the play's own inputs declaration. Defaults layer above
	// file-level defaults but below --vars-file / CLI overrides.
	Inputs []Input

	// Host is the server this play's tasks run against, as
	// [user@]host[:port]. Empty means the play inherits the run-wide target
	// from --host / DOKKU_HOST, which is what every recipe written before
	// multi-host plays existed does.
	Host string

	// Sudo and AcceptNewHostKeys override the run-wide --sudo and
	// --accept-new-host-keys for this play. They are pointers because unset
	// and false mean different things here: an omitted key inherits whatever
	// the run was given, while `sudo: false` actively declines it for this
	// play alone. See ResolveTarget.
	Sudo              *bool
	AcceptNewHostKeys *bool

	// Tasks is the per-play envelope map populated by GetPlays. Insertion
	// order mirrors the play's tasks: source order.
	Tasks OrderedStringEnvelopeMap
	// contains filtered or unexported fields
}

Play is one entry in a docket recipe's top-level YAML list. A recipe may declare any number of plays; the executor walks them in order and bounds per-task state to the play's own context.

The envelope keys (Name, Tags, When, Inputs) sit alongside the per-play Tasks. Per-play Inputs override file-level defaults within their play but not across plays; CLI --name=value and --vars-file always win. Per-play Tags are inherited by every task in the play (additive with per-task tags already on the envelope).

The play's own When predicate is evaluated against the file-level merged context only - the play's own Inputs are not visible to its own When (the spec calls this circular). Per-task When inside the play does see the play's Inputs.

func GetPlays 

func GetPlays(data []byte, context map[string]interface{}, userSet map[string]bool) ([]*Play, error)

GetPlays parses data as a docket recipe and returns one Play per top-level entry, each carrying its own envelope map. The executor (internal/commands/apply.go, internal/commands/plan.go) walks the result in order.

The render pipeline is:

  1. Render the whole file with `context` (file-level inputs + vars-file + CLI overrides) for the structure pass. This catches template syntax errors at the same point GetTasks did before #208 and gives us the play count plus per-play metadata (name/tags/when/inputs).
  2. For each play, build a per-play context by layering the play's own `inputs:` defaults above file-level defaults, but only for keys the user has not overridden via --vars-file or CLI. The userSet map identifies user-overridden keys; pass nil to disable the layering (the GetTasks shim does this since back-compat tests do not need multi-play context).
  3. Re-render the whole file with the per-play context so task body templates substitute the play-local values, then walk to that play's tasks and build envelopes through the existing buildEnvelopesForEntry helper.
  4. Append the play's tags to every envelope (additive with per-task tags) so FilterByTags treats them uniformly.

Per-play `when:` predicates are pre-compiled here; the executor decides the evaluation context (file-level only, per the spec - the play's own inputs are not visible to its own when).

func GetPlaysWithFormat 

func GetPlaysWithFormat(data []byte, format string, context map[string]interface{}, userSet map[string]bool) ([]*Play, error)

GetPlaysWithFormat is the format-aware variant of GetPlays. format is one of "yaml" / "json5"; the empty string is treated as YAML. Parsing goes through the shared structural parser (internal/tasks/parse.go) that also powers `docket validate`, so the loader and the validator agree on structural validity by construction; the first structural problem is converted into the loader's fail-fast error.

func (*Play) HasWhen 

func (p *Play) HasWhen() bool

HasWhen reports whether the play carries a non-empty `when:` predicate that must be evaluated before the play's tasks run.

func (*Play) IsFileLevel 

func (p *Play) IsFileLevel() bool

IsFileLevel reports whether this play is an inputs-only entry rather than a task play. The convention: a play with no tasks acts purely as a file-level inputs declaration (its `inputs:` are visible to every play's `when:` and to every task body); a play with tasks treats its inputs as play-local (visible to its tasks only).

func (*Play) ResolveTarget 

func (p *Play) ResolveTarget(base subprocess.Target) subprocess.Target

ResolveTarget returns the target this play's tasks run against: base, with each key the play declared overriding it.

The override is per key rather than wholesale, so a run given --sudo keeps sudo when a play sends its tasks to a different host. That is the reading that matches the rest of the recipe format - a play's `inputs:` layer over the file's rather than replacing them - and it means a two-server migration does not have to restate the run's flags on every play. A play that wants the opposite says so: `sudo: false` declines it.

func (*Play) WhenProgram 

func (p *Play) WhenProgram() *vm.Program

WhenProgram returns the pre-compiled expr program for the play's When, or nil when no `when:` predicate is present.

type PluginTask 

type PluginTask struct {
	// Name is the plugin name as it appears in plugin:list
	Name string `required:"true" identity:"key" yaml:"name" description:"Plugin name as it appears in plugin:list"`

	// URL is the git URL to install from. Required when state is present.
	URL string `required:"false" yaml:"url,omitempty" description:"Git URL to install the plugin from. Required when state is present."`

	// Committish is an optional git ref (branch, tag, or commit) to install
	Committish string `required:"false" yaml:"committish,omitempty" description:"Optional git ref (branch, tag, or commit) to install"`

	// State is the desired state of the plugin
	State State `required:"false" yaml:"state,omitempty" default:"present" options:"present,absent" description:"Desired state of the plugin"`
}

PluginTask installs or uninstalls a third-party dokku plugin.

plugin:install and plugin:uninstall are root-level operations: over the SSH transport dokku wraps privilege server-side, and run locally docket must already be root. Idempotency is by plugin name only - a changed url or committish on an already-installed plugin is not detected.

func (PluginTask) Doc 

func (t PluginTask) Doc() string

Doc returns the docblock for the plugin task

func (PluginTask) Execute 

func (t PluginTask) Execute(ctx context.Context) TaskOutputState

Execute installs or uninstalls the plugin

func (PluginTask) ExportGlobal 

func (t PluginTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reconstructs the server's third-party plugins from `plugin:list --format json`, which exposes each plugin's install source URL, followed branch, and checked-out commit. Core plugins ship with dokku (and plugin:uninstall rejects them), and plugins without a git source (a tarball or local path) cannot be reinstalled declaratively, so both are skipped.

func (PluginTask) ExportSupport 

func (t PluginTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (PluginTask) Plan 

func (t PluginTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the PluginTask would produce.

func (PluginTask) ProbeSupport 

func (t PluginTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (PluginTask) Validate 

func (t PluginTask) Validate() error

Validate checks the PluginTask's inputs without contacting the server.

type PluginTaskExample 

type PluginTaskExample struct {
	// Name is the task name holding the PluginTask description
	Name string `yaml:"-"`

	// PluginTask is the PluginTask configuration
	PluginTask PluginTask `yaml:"dokku_plugin"`
}

PluginTaskExample contains an example of a PluginTask

func (PluginTaskExample) GetName 

func (e PluginTaskExample) GetName() string

GetName returns the name of the example

type PortMapping 

type PortMapping struct {
	// Scheme is the scheme of the port mapping
	Scheme string `required:"true" identity:"key" yaml:"scheme" description:"Scheme of the port mapping"`

	// Host is the host of the port mapping
	Host int `required:"true" identity:"key" yaml:"host" description:"Host of the port mapping"`

	// Container is the container of the port mapping
	Container int `required:"true" yaml:"container" description:"Container of the port mapping"`
}

PortMapping represents a port mapping

func (PortMapping) String 

func (p PortMapping) String() string

String returns the string representation of the port mapping

type PortsTask 

type PortsTask struct {
	// App is the name of the app
	App string `required:"true" identity:"key" yaml:"app" description:"Name of the app"`

	// PortMappings are the port mappings to set
	PortMappings []PortMapping `` /* 201-byte string literal not displayed */

	// State is the desired state of the ports
	State State `` /* 133-byte string literal not displayed */
}

PortsTask manages the ports for a given dokku application

func (PortsTask) Doc 

func (t PortsTask) Doc() string

Doc returns the docblock for the ports task

func (PortsTask) Execute 

func (t PortsTask) Execute(ctx context.Context) TaskOutputState

Execute manages the app's port mappings

func (PortsTask) ExportApp 

func (t PortsTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reads the app's port mappings and returns a dokku_ports task, or nil when none are configured. Mappings are sorted for deterministic output. state:set replaces the whole mapping list for an exact match.

func (PortsTask) ExportSupport 

func (t PortsTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (PortsTask) Plan 

func (t PortsTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the PortsTask would produce.

func (PortsTask) ProbeSupport 

func (t PortsTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (PortsTask) Validate 

func (t PortsTask) Validate() error

Validate checks the PortsTask's inputs without contacting the server.

type PortsTaskExample 

type PortsTaskExample struct {
	// Name is the task name holding the PortsTask description
	Name string `yaml:"-"`

	// PortsTask is the PortsTask configuration
	PortsTask PortsTask `yaml:"dokku_ports"`
}

PortsTaskExample contains an example of a PortsTask

func (PortsTaskExample) GetName 

func (e PortsTaskExample) GetName() string

GetName returns the name of the example

type ProbeDocer 

type ProbeDocer interface {
	ProbeSupport() ProbeSupport
}

ProbeDocer is the interface a task implements to declare whether Plan() can read its current state. Every registered task is expected to implement it - a coverage test enforces that so no task ships without a probe decision - but it is modelled as an optional interface to match Documented, ExportDocer, DeprecationDocer and RequirementsDocer. The docs generator renders the result in a Probe support section on the task's page, and `--list-tasks` marks the tasks that will never converge.

This declares a *structural* inability to read state: dokku exposes no command that reports the resource, so the answer is the same on every server and every run. It is not the same thing as a probe that fails at runtime - a stale property key map, an older plugin that rejects `:report --format json`, an unreachable host. Those stay what they are today: a PlanWarning (see WarnReasonUnknownProperty / WarnReasonProbeRejected) or a PlanStatusError, raised per-run by the probe call site, and they never change a task's declared status.

Nor is it the same thing as a difference a task reads successfully and declines to act on, which is also a PlanWarning (see WarnReasonServiceImageDrift). A task can probe a field perfectly well and still refuse to converge it because the only available remedy is worse than the drift; that is a property of the remedy, not of the probe, and it does not make the task partial for that field either.

Nothing in the plan or apply path reads this: drift is decided entirely by each Plan() implementation. What keeps the declaration honest is TestProbeSupportMatchesPlanWiring, which fails when a task claims it can converge but one of its DispatchPlan branches has no reachable in-sync result (or when it claims it cannot and some branch does). Asking per branch rather than per Plan() is what stops a task that probes `present` and not `absent` from passing on the strength of its `present` branch alone.

type ProbeStatus 

type ProbeStatus string

ProbeStatus classifies how much of a task's current state Plan() can read back from the server before it decides whether to mutate. 

const (
	// ProbeSupported means Plan() reads the resource it manages, so a server
	// that already matches the recipe plans as in sync and a second apply is
	// a no-op.
	ProbeSupported ProbeStatus = "supported"

	// ProbePartial means Plan() reads some of the resource but not all of it:
	// a write-only field with no read command, or an idempotency key that is
	// coarser than the task's inputs. The task converges for the dimensions it
	// probes and plans as drift forever for the rest.
	ProbePartial ProbeStatus = "partial"

	// ProbeUnsupported means Plan() cannot read the resource at all. The task
	// plans as drift on every run and never converges, so a recipe containing
	// one never settles to `plan --detailed-exitcode` exit 0.
	ProbeUnsupported ProbeStatus = "unsupported"
)

type ProbeSupport 

type ProbeSupport struct {
	Status ProbeStatus `json:"status"`
	Caveat string      `json:"caveat,omitempty"`
}

ProbeSupport describes a task's read-state behaviour. Status is required; Caveat is a human-readable note naming what cannot be read (and may be empty for a task that probes everything it manages).

The json tags are for the task catalog, which publishes this verbatim.

func TaskProbeSupport 

func TaskProbeSupport(t Task) (ProbeSupport, bool)

TaskProbeSupport returns the probe support for t, and whether t declared it. Centralised so docs generation, --list-tasks, and the coverage test share one read site, mirroring TaskExportSupport.

type Problem 

type Problem struct {
	Code    string
	Play    string
	Task    string
	Line    int
	Column  int
	Message string
	Hint    string
}

Problem is a single validation finding emitted by Validate.

Code is a stable machine-readable identifier so JSON consumers (and the follow-on issues that activate the placeholder checks) can branch without matching on free-form Message text. Line/Column are 1-based and 0 when the position cannot be derived from yaml.v3 anchors or the underlying parser.

func Validate 

func Validate(data []byte, opts ValidateOptions) []Problem

Validate parses data as a docket recipe and returns every problem it finds. It is offline by contract: the implementation must never invoke subprocess.CallExecCommand.

The validator first parses the raw bytes to extract input definitions, then renders the recipe through sigil with a context built from those defaults (plus a placeholder for any required input without a default) so structural checks operate on the same form `apply` would see. yaml.v3 line/column anchors from the rendered tree are used for error reporting. Source line numbers align with rendered line numbers as long as templates render inline, which is the case for typical recipes.

type PropertyEntrySchema 

type PropertyEntrySchema struct {
	// Name is the value a recipe puts in `property:`.
	Name string `json:"name"`

	// Scopes is a non-empty subset of ["app", "global"], in that order. Using
	// the property in a scope it does not list is rejected at validate time,
	// matching dokku's own CLI rejection.
	Scopes []string `json:"scopes"`

	// AppReportKey and GlobalReportKey are the keys
	// `dokku <plugin>:report --format json` emits for the property in each
	// scope. Absent for a scope the property has no form in.
	AppReportKey    string `json:"app_report_key,omitempty"`
	GlobalReportKey string `json:"global_report_key,omitempty"`

	// Sensitive marks a property whose value is a secret.
	Sensitive bool `json:"sensitive,omitempty"`
}

PropertyEntrySchema is one property name and where it may be used.

type PropertyFields 

type PropertyFields struct {
	// App is the name of the app. Required if Global is false.
	App string `required:"false" identity:"key" yaml:"app" description:"Name of the app. Required if Global is false."`

	// Global is a flag indicating if the property should be applied globally
	Global bool `` /* 128-byte string literal not displayed */

	// Property is the name of the property to set
	Property string `required:"true" identity:"key" yaml:"property" description:"Name of the property to set"`

	// Value is the value to set for the property
	Value string `required:"false" yaml:"value,omitempty" description:"Value to set for the property"`

	// State is the desired state of the property
	State State `` /* 126-byte string literal not displayed */
}

PropertyFields is the recipe shape every app-or-global property task shares: the scope (`app` or `global`), the property being managed, its value, and whether it should be present or absent. A property task declares `type XPropertyTask PropertyFields` rather than restating the five fields, so a cross-cutting field change - the identity tags of #427, say - lands in one place instead of twenty-seven.

A defined type rather than an embedded struct because the field set stays flat to reflection: the catalog, the required-field walk behind missing_required_field, the identity walk that names an unnamed task, and the sensitive-value walks all read a task's fields at the top level, and an embedded field set would empty every one of them out.

The descriptions are deliberately plugin-agnostic. A task's page already names its plugin in the title, the synopsis and the Properties table, so repeating it in every parameter row bought nothing and cost twenty-seven copies of the field set. See TestPropertyTasksDeclareTheSharedFields for the tasks whose shape genuinely differs.

type PropertyKeys 

type PropertyKeys struct {
	PerApp    string
	Global    string
	Sensitive bool
}

PropertyKeys carries the JSON keys that dokku <plugin>:report --format json emits for one property on dokku 0.38.8+. An empty string means the property has no form in that scope (so probing it in that scope is rejected at plan time, matching dokku's own CLI rejection).

Values point at the canonical bare-key shape (no <plugin>- prefix). The legacy <plugin>-prefixed keys remain emitted during the 0.38.x deprecation window but are ignored by the lookup.

Sensitive marks a property whose value is a secret (e.g. a password or a cluster token). When set, planProperty registers both the desired value and the server-probed current value with the masker, so the `(was %q)` drift reason and the command echo are masked. It is a per-property flag because a plugin usually has a mix of secret and benign properties.

type PropertySchema 

type PropertySchema struct {
	// Plugin is the dokku plugin, for example "apps" or "scheduler-k3s".
	Plugin string `json:"plugin"`

	// Subcommand is the dokku subcommand a set or unset runs, for example
	// "apps:set" or "buildpacks:set-property".
	Subcommand string `json:"subcommand"`

	// Field is the recipe key the table constrains. Always "property".
	Field string `json:"field"`

	// Properties are the enumerable property names, sorted.
	Properties []PropertyEntrySchema `json:"properties"`

	// Dynamic are the name families the table cannot enumerate, because dokku
	// validates them through the set subcommand rather than through its report
	// schema. A name matching one of these prefixes is legal even though it is
	// absent from Properties.
	Dynamic []DynamicPropertySchema `json:"dynamic,omitempty"`

	// Rejected are the name families this task refuses because another task
	// manages them. A name matching one of these prefixes is absent from
	// Properties for a different reason than a typo is, and a consumer that
	// reports it as an unknown name sends the user looking through a list it
	// will never be in.
	Rejected []RejectedPropertySchema `json:"rejected,omitempty"`
}

PropertySchema is the enumerable property table a *_property task manages - the real schema behind its free-form-looking `property` field.

type PropertyTable 

type PropertyTable struct {
	// Subcommand is the dokku subcommand a set or unset runs, for example
	// "apps:set" or "buildpacks:set-property".
	Subcommand string

	// Keys maps each supported property name to the JSON keys
	// `dokku <plugin>:report --format json` emits for it per scope.
	Keys map[string]PropertyKeys

	// Rejected are the name families this task refuses outright because
	// another task manages them. Checked before Keys, so a member is
	// answered with the task that owns it rather than with the list of
	// names this one supports.
	Rejected []RejectedPropertyFamily
}

PropertyTable is the property schema one *_property task manages: the dokku subcommand a set/unset runs, and the report keys for every property name the task supports.

It is the single source of truth for that task. Plan(), Validate(), the two exporters and the machine-readable catalog all read the same value, because the shared helpers below take the task through PropertyTableDocer rather than taking a subcommand and a map as separate arguments. A task therefore cannot declare one table to the catalog and run against another.

func TaskPropertyTable 

func TaskPropertyTable(t Task) (PropertyTable, bool)

TaskPropertyTable returns t's property table and whether t declared one. Centralised so the catalog, the docs generator and the coverage test share one read site, mirroring TaskExportSupport and TaskProbeSupport.

func (PropertyTable) Plugin 

func (p PropertyTable) Plugin() string

Plugin returns the dokku plugin the table belongs to, derived from the subcommand: "apps:set" -> "apps".

type PropertyTableDocer 

type PropertyTableDocer interface {
	// contains filtered or unexported methods
}

PropertyTableDocer is implemented by every task that manages a dokku property table.

Unlike its siblings (ExportDocer, ProbeDocer) this one is not read only by the docs generator: planProperty, validatePropertyInput and the property exporters take it as their first argument, so a task cannot reach the shared property machinery without declaring the table the catalog publishes.

A task whose property names are validated by dokku rather than by docket - dokku_service_property, whose names come from whichever datastore plugin backs the service - deliberately does not implement it. See TestEveryPropertyTaskDeclaresPropertyTable.

type ProxyPropertyTask 

type ProxyPropertyTask PropertyFields

ProxyPropertyTask manages the proxy configuration for a given dokku application

func (ProxyPropertyTask) Doc 

func (t ProxyPropertyTask) Doc() string

Doc returns the docblock for the proxy property task

func (ProxyPropertyTask) Execute 

func (t ProxyPropertyTask) Execute(ctx context.Context) TaskOutputState

Execute sets or unsets the proxy property

func (ProxyPropertyTask) ExportApp 

func (t ProxyPropertyTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs the app's explicitly-set properties.

func (ProxyPropertyTask) ExportGlobal 

func (t ProxyPropertyTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reconstructs the globally-set properties.

func (ProxyPropertyTask) ExportSupport 

func (t ProxyPropertyTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (ProxyPropertyTask) Plan 

func (t ProxyPropertyTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the ProxyPropertyTask would produce.

func (ProxyPropertyTask) ProbeSupport 

func (t ProxyPropertyTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (ProxyPropertyTask) Validate 

func (t ProxyPropertyTask) Validate() error

Validate checks the ProxyPropertyTask's inputs without contacting the server.

type ProxyPropertyTaskExample 

type ProxyPropertyTaskExample struct {
	// Name is the task name holding the ProxyPropertyTask description
	Name string `yaml:"-"`

	// ProxyPropertyTask is the ProxyPropertyTask configuration
	ProxyPropertyTask ProxyPropertyTask `yaml:"dokku_proxy_property"`
}

ProxyPropertyTaskExample contains an example of a ProxyPropertyTask

func (ProxyPropertyTaskExample) GetName 

func (e ProxyPropertyTaskExample) GetName() string

GetName returns the name of the example

type ProxyToggleTask 

type ProxyToggleTask ToggleFields

ProxyToggleTask manages the proxy for a given dokku application

func (ProxyToggleTask) Doc 

func (t ProxyToggleTask) Doc() string

Doc returns the docblock for the proxy toggle task

func (ProxyToggleTask) Execute 

func (t ProxyToggleTask) Execute(ctx context.Context) TaskOutputState

Execute enables or disables the proxy

func (ProxyToggleTask) ExportApp 

func (t ProxyToggleTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp emits a dokku_proxy_toggle task only when the proxy is disabled (it is enabled by default).

func (ProxyToggleTask) ExportSupport 

func (t ProxyToggleTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (ProxyToggleTask) Plan 

func (t ProxyToggleTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the ProxyToggleTask would produce.

func (ProxyToggleTask) ProbeSupport 

func (t ProxyToggleTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

type ProxyToggleTaskExample 

type ProxyToggleTaskExample struct {
	// Name is the task name holding the ProxyToggleTask description
	Name string `yaml:"-"`

	// ProxyToggleTask is the ProxyToggleTask configuration
	ProxyToggleTask ProxyToggleTask `yaml:"dokku_proxy_toggle"`
}

ProxyToggleTaskExample contains an example of a ProxyToggleTask

func (ProxyToggleTaskExample) GetName 

func (e ProxyToggleTaskExample) GetName() string

GetName returns the name of the example

type PsPropertyTask 

type PsPropertyTask PropertyFields

PsPropertyTask manages the ps configuration for a given dokku application

func (PsPropertyTask) Doc 

func (t PsPropertyTask) Doc() string

Doc returns the docblock for the ps property task

func (PsPropertyTask) Execute 

func (t PsPropertyTask) Execute(ctx context.Context) TaskOutputState

Execute sets or unsets the ps property

func (PsPropertyTask) ExportApp 

func (t PsPropertyTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs the app's explicitly-set properties.

func (PsPropertyTask) ExportGlobal 

func (t PsPropertyTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reconstructs the globally-set properties.

func (PsPropertyTask) ExportSupport 

func (t PsPropertyTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (PsPropertyTask) Plan 

func (t PsPropertyTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the PsPropertyTask would produce.

func (PsPropertyTask) ProbeSupport 

func (t PsPropertyTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (PsPropertyTask) Validate 

func (t PsPropertyTask) Validate() error

Validate checks the PsPropertyTask's inputs without contacting the server.

type PsPropertyTaskExample 

type PsPropertyTaskExample struct {
	// Name is the task name holding the PsPropertyTask description
	Name string `yaml:"-"`

	// PsPropertyTask is the PsPropertyTask configuration
	PsPropertyTask PsPropertyTask `yaml:"dokku_ps_property"`
}

PsPropertyTaskExample contains an example of a PsPropertyTask

func (PsPropertyTaskExample) GetName 

func (e PsPropertyTaskExample) GetName() string

GetName returns the name of the example

type PsScaleTask 

type PsScaleTask struct {
	// App is the name of the app
	App string `required:"true" identity:"key" yaml:"app" description:"Name of the app"`

	// Scale is a map of process types to quantities
	Scale map[string]int `required:"true" identity:"collection" yaml:"scale" description:"Map of process types to quantities"`

	// SkipDeploy skips the corresponding deploy. It is a *bool so the value
	// survives decoding unchanged; nil defaults to false.
	SkipDeploy *bool `yaml:"skip_deploy,omitempty" default:"false" description:"Skip the corresponding deploy"`

	// State is the desired state of the process scale
	State State `` /* 164-byte string literal not displayed */
}

PsScaleTask manages the process scale for a given dokku application.

The two states differ in what happens to a process type the recipe does not name. `present` leaves it alone, merging the declared quantities into whatever formation the app already runs. `set` declares the whole formation and scales every undeclared process type to zero.

Two dokku behaviours bound what `set` can promise, and neither is detectable offline. An app whose app.json carries a `formations` key refuses manual scaling outright, and `skip_deploy` writes the formation without touching any containers, so an undeclared process type keeps running until the next deploy.

func (PsScaleTask) Doc 

func (t PsScaleTask) Doc() string

Doc returns the docblock for the ps scale task

func (PsScaleTask) Execute 

func (t PsScaleTask) Execute(ctx context.Context) TaskOutputState

Execute sets the process scale for a given dokku application

func (PsScaleTask) ExportApp 

func (t PsScaleTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reads the app's process scale and returns a dokku_ps_scale task declaring the whole formation, or nil when nothing is scaled above zero (an undeployed app has nothing to set).

Zero-quantity process types are dropped rather than emitted: under state 'set' an omitted process type already means zero, and the zeroes dokku reports are not stable. A process type scaled down under skip_deploy sits in the `scale.old` property until the next deploy deletes it, so emitting them would make two exports of the same server differ on deploy timing alone.

func (PsScaleTask) ExportSupport 

func (t PsScaleTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (PsScaleTask) Plan 

func (t PsScaleTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the PsScaleTask would produce.

func (PsScaleTask) ProbeSupport 

func (t PsScaleTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (PsScaleTask) Validate 

func (t PsScaleTask) Validate() error

Validate checks the PsScaleTask's inputs without contacting the server.

type PsScaleTaskExample 

type PsScaleTaskExample struct {
	// Name is the task name holding the PsScaleTask description
	Name string `yaml:"-"`

	// PsScaleTask is the PsScaleTask configuration
	PsScaleTask PsScaleTask `yaml:"dokku_ps_scale"`
}

PsScaleTaskExample contains an example of a PsScaleTask

func (PsScaleTaskExample) GetName 

func (e PsScaleTaskExample) GetName() string

GetName returns the name of the example

type Recipe 

type Recipe []RecipeEntry

Recipe represents a docket recipe: a YAML list of plays. Each entry is a play envelope carrying the play-level metadata (name, tags, when, inputs) and the per-play tasks list. Single-play files are simply a one-element list and require no special handling.

func UnmarshalRecipe 

func UnmarshalRecipe(data []byte, format string) (Recipe, error)

UnmarshalRecipe decodes data as a Recipe using the codec keyed by format. Exposed because the commands package's input-extraction path (parseInputDocument) needs the same dispatch and there is no benefit to duplicating it.

The codec's ToYAML runs but its Lint deliberately does not: this path feeds parseInputDocument and countTasks, which accept a duplicate-keyed JSON5 recipe today. normalizeRecipeBytes is the one that lints.

JSON5 is normalised to YAML bytes and decoded by yaml.v3 rather than fed to json5.Unmarshal directly, which is what the loader and the validator already do - so all three agree on how a scalar lands in a Go field. Decoding the JSON5 straight would not: encoding/json refuses to put a number or a bare boolean into a string field, so a JSON5 recipe writing the natural `default: 8080` failed to decode at all, and since the only caller that noticed was flag registration, the recipe silently lost every input flag it declared - the #493 symptom reached through a second door.

type RecipeEntry 

type RecipeEntry struct {
	// Name is the play's user-facing label. Auto-generated as
	// "play #N" by GetPlays when omitted.
	Name string `yaml:"name,omitempty" json:"name,omitempty"`

	// Tags accepts either a YAML list (`tags: [a, b]`) or a scalar
	// (`tags: a`). Decoded via decodeTags into the Play.Tags slice.
	Tags interface{} `yaml:"tags,omitempty" json:"tags,omitempty"`

	// When is the raw expr source for the play-level conditional. Empty
	// means "always run". Compiled into the Play.whenProgram by GetPlays.
	When string `yaml:"when,omitempty" json:"when,omitempty"`

	// Inputs are the play-local input defaults. Layer above file-level
	// defaults but below --vars-file / CLI overrides (per-play merge
	// happens in GetPlays).
	Inputs []Input `yaml:"inputs,omitempty" json:"inputs,omitempty"`

	// Host sends this play's tasks to a server other than the run-wide
	// --host / DOKKU_HOST target. `[user@]host[:port]`, same spelling as the
	// flag.
	Host string `yaml:"host,omitempty" json:"host,omitempty"`

	// Sudo and AcceptNewHostKeys override the run-wide flags of the same
	// name for this play. Pointers so an omitted key inherits the run's
	// setting and an explicit false declines it.
	Sudo              *bool `yaml:"sudo,omitempty" json:"sudo,omitempty"`
	AcceptNewHostKeys *bool `yaml:"accept_new_host_keys,omitempty" json:"accept_new_host_keys,omitempty"`

	// Tasks is the raw per-play task list, decoded into envelopes by
	// GetPlays via buildEnvelopesForEntry.
	Tasks []map[string]interface{} `yaml:"tasks,omitempty" json:"tasks,omitempty"`
}

RecipeEntry is the on-disk shape of one play. The yaml-unmarshalled form; the runtime-facing Play struct (in play.go) is built from this by GetPlays.

type RegisteredValue 

type RegisteredValue struct {
	TaskOutputState
	Results []TaskOutputState
}

RegisteredValue is the shape stored in the apply / plan run-wide registered map for a `register: <name>` task. Predicates reach it via `.registered.<name>`.

For non-loop tasks, the embedded TaskOutputState is the post-override result and Results is nil; predicates use `.registered.foo.Changed`, `.registered.foo.Error`, etc. directly.

For loop expansions, every iteration shares the same Register name. Results carries the per-iteration post-override states in source order. The embedded TaskOutputState is an Ansible-style aggregate across the iterations:

  • Changed: true when any iteration's Changed is true.
  • Error: the first non-nil error among iterations (nil when every iteration succeeded).
  • State / DesiredState / Stdout / Stderr / ExitCode / Commands: the last iteration's values.

Embedded-struct field access works through expr-lang/expr because it uses reflect.Value.FieldByName, which traverses embedded fields.

func AggregateRegistered 

func AggregateRegistered(iter []TaskOutputState) RegisteredValue

AggregateRegistered builds a RegisteredValue from one or more per-iteration TaskOutputStates. Callers use it to roll a loop's expansions into a single registered value. Every loop expansion - including one that resolves to a single iteration - yields a Results list with one entry per iteration, so `.Results[0]` is always available for a register+loop task (the documented contract in docs/task-envelope.md). The empty input is the only nil-Results case.

type RegistryAuthTask 

type RegistryAuthTask struct {
	// App is the name of the app. Required if Global is false.
	App string `required:"false" identity:"key" yaml:"app" description:"Name of the app. Required if Global is false."`

	// Global is a flag indicating if the registry credential should be applied globally
	Global bool `` /* 139-byte string literal not displayed */

	// Server is the docker registry hostname (e.g. docker.io, ghcr.io).
	// dokku normalises hub.docker.com and docker.com to docker.io, and docker
	// stores Docker Hub under its index server address, on both the login and
	// the status path - so the value is passed through exactly as written.
	Server string `required:"true" identity:"key" yaml:"server" description:"Docker registry hostname (e.g. docker.io, ghcr.io)"`

	// Username is the registry username (required when state is present)
	Username string `required:"false" yaml:"username,omitempty" description:"Registry username (required when state is present)"`

	// Password is the registry password (required when state is present)
	// The value is fed to dokku via --password-stdin and never appears on argv
	Password string `required:"false" sensitive:"true" yaml:"password,omitempty" description:"Registry password (required when state is present)"`

	// State is the desired state of the registry credential
	State State `` /* 137-byte string literal not displayed */
}

RegistryAuthTask manages docker registry authentication for a dokku application or globally.

The stored credential is not readable - it lives in a docker config.json under $DOKKU_ROOT, and registry:report exposes which servers have one but never who it belongs to - yet idempotency does not need it to be. dokku's registry:auth-status compares a credential it is handed against the stored one and answers with its exit code, which is the only question Plan() asks. See registryAuthStatus for the shapes that answers. It needs dokku 0.38.29 (dokku/dokku#8993); below that the subcommand does not exist and the task falls back to reporting drift on every run, as it did before.

The password never reaches argv on either path. Both registry:login and registry:auth-status read it from stdin under --password-stdin, so it stays out of the plan output, the trace log, and the process table on the dokku host.

Unlike dokku_git_auth this task needs no newline rule on the password. dokku reads stdin with io.ReadAll and trims it on both the login and the status path, so whatever survives that round trip compares equal to itself. What it does reject is a password that trims away to nothing, which dokku would answer with an invalid-arguments exit rather than a comparison.

func (RegistryAuthTask) Doc 

func (t RegistryAuthTask) Doc() string

Doc returns the docblock for the registry auth task

func (RegistryAuthTask) Execute 

func (t RegistryAuthTask) Execute(ctx context.Context) TaskOutputState

Execute manages the registry authentication

func (RegistryAuthTask) ExportApp 

func (t RegistryAuthTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs the app's own registry logins. registry:report names the servers the app holds a credential for and nothing about the credential itself, so each emitted task carries the server and leaves the username and password for processRegistryAuth to lift into inputs.

func (RegistryAuthTask) ExportGlobal 

func (t RegistryAuthTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reconstructs the global registry logins. An app with a credential of its own shadows the global config rather than merging with it, so the two scopes read different keys and never emit the same server twice.

func (RegistryAuthTask) ExportSupport 

func (t RegistryAuthTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

registry:report names the servers an app or the global config holds a credential for, which is enough to reconstruct which logins a server needs. The credential itself is not readable in either half: the password is write-only, and dokku exposes no username field either, so both become required inputs the operator supplies at apply time.

func (RegistryAuthTask) Plan 

func (t RegistryAuthTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the RegistryAuthTask would produce.

func (RegistryAuthTask) ProbeSupport 

func (t RegistryAuthTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (RegistryAuthTask) Validate 

func (t RegistryAuthTask) Validate() error

Validate checks the RegistryAuthTask's inputs without contacting the server.

type RegistryAuthTaskExample 

type RegistryAuthTaskExample struct {
	// Name is the task name holding the RegistryAuthTask description
	Name string `yaml:"-"`

	// RegistryAuthTask is the RegistryAuthTask configuration
	RegistryAuthTask RegistryAuthTask `yaml:"dokku_registry_auth"`
}

RegistryAuthTaskExample contains an example of a RegistryAuthTask

func (RegistryAuthTaskExample) GetName 

func (e RegistryAuthTaskExample) GetName() string

GetName returns the name of the example

type RegistryPropertyTask 

type RegistryPropertyTask PropertyFields

RegistryPropertyTask manages the registry configuration for a given dokku application

func (RegistryPropertyTask) Doc 

func (t RegistryPropertyTask) Doc() string

Doc returns the docblock for the registry property task

func (RegistryPropertyTask) Execute 

func (t RegistryPropertyTask) Execute(ctx context.Context) TaskOutputState

Execute sets or unsets the registry property

func (RegistryPropertyTask) ExportApp 

func (t RegistryPropertyTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs the app's explicitly-set properties.

func (RegistryPropertyTask) ExportGlobal 

func (t RegistryPropertyTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reconstructs the globally-set properties.

func (RegistryPropertyTask) ExportSupport 

func (t RegistryPropertyTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (RegistryPropertyTask) Plan 

func (t RegistryPropertyTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the RegistryPropertyTask would produce.

func (RegistryPropertyTask) ProbeSupport 

func (t RegistryPropertyTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (RegistryPropertyTask) Validate 

func (t RegistryPropertyTask) Validate() error

Validate checks the RegistryPropertyTask's inputs without contacting the server.

type RegistryPropertyTaskExample 

type RegistryPropertyTaskExample struct {
	// Name is the task name holding the RegistryPropertyTask description
	Name string `yaml:"-"`

	// RegistryPropertyTask is the RegistryPropertyTask configuration
	RegistryPropertyTask RegistryPropertyTask `yaml:"dokku_registry_property"`
}

RegistryPropertyTaskExample contains an example of a RegistryPropertyTask

func (RegistryPropertyTaskExample) GetName 

func (e RegistryPropertyTaskExample) GetName() string

GetName returns the name of the example

type RejectedPropertyFamily 

type RejectedPropertyFamily struct {
	// Prefix is what a member's name starts with, for example "chart.".
	Prefix string

	// Replacement is the task type that manages the family instead, for
	// example "dokku_scheduler_k3s_chart".
	Replacement string

	// Reason says why this task does not manage it, as a clause that reads
	// after a semicolon: "the scheduler-k3s:set path for chart values is
	// deprecated in dokku".
	Reason string
}

RejectedPropertyFamily is a family of property names, matched by prefix, that a task deliberately refuses because another task owns them.

It is not the same as a name simply being absent from Keys. An absent name is a typo, and the right answer is the list of names that are supported; a rejected family is a name the user meant, written against the wrong task, and the only useful answer is which task to write it against instead. Offering the supported list there sends the user looking for something that is not on it (#458).

Declaring it on the table rather than guarding inside Plan() is what keeps plan, apply and validate on the same message: validatePropertyInput is the one function both paths reach, and it is where the family is checked.

type RejectedPropertySchema 

type RejectedPropertySchema struct {
	// Prefix is what a member's name starts with.
	Prefix string `json:"prefix"`

	// Replacement is the task type to write the property against instead.
	Replacement string `json:"replacement"`

	// Reason says why this task does not manage the family.
	Reason string `json:"reason"`
}

RejectedPropertySchema is a family of property names the task refuses, matched by prefix, and the task that manages them instead.

func RejectedPropertyFamilies 

func RejectedPropertyFamilies(table PropertyTable) []RejectedPropertySchema

RejectedPropertyFamilies returns the name families a table refuses, sorted by prefix, in the form the task catalog publishes. Exported so a consumer validating a recipe offline can answer a rejected name the way docket does - with the task that manages it - instead of reporting it as unknown.

type RequirementsDocer 

type RequirementsDocer interface {
	Requirements() []string
}

RequirementsDocer is an optional interface a task implements when it depends on a dokku plugin that is not part of dokku core. The docs generator renders the returned entries in a Requirements section on the task's page. Each entry names a plugin and may carry a parenthetical qualifier when the dependency is conditional.

type ResourceContext 

type ResourceContext struct {
	// App is the name of the app
	App string

	// ProcessType is the process type to filter resources for
	ProcessType string

	// Resources is a map of resource type to quantity
	Resources map[string]string

	// ClearBefore clears all resources before applying new ones
	ClearBefore bool
}

ResourceContext represents the context for a resource operation

type ResourceLimitTask 

type ResourceLimitTask struct {
	// App is the name of the app
	App string `required:"true" identity:"key" yaml:"app" description:"Name of the app"`

	// ProcessType is the process type to set resource limits for
	ProcessType string `required:"false" identity:"key" yaml:"process_type,omitempty" description:"Process type to set resource limits for"`

	// Resources is a map of resource type to quantity
	Resources map[string]string `identity:"collection" yaml:"resources" description:"Map of resource type to quantity"`

	// ClearBefore clears all resource limits before applying new ones. It is a
	// *bool so the value survives decoding unchanged; nil defaults to false.
	ClearBefore *bool `yaml:"clear_before,omitempty" default:"false" description:"ClearBefore clears all resource limits before applying new ones"`

	// State is the desired state of the resource limits
	State State `` /* 133-byte string literal not displayed */
}

ResourceLimitTask manages the resource limits for a given dokku application

func (ResourceLimitTask) Doc 

func (t ResourceLimitTask) Doc() string

Doc returns the docblock for the resource limit task

func (ResourceLimitTask) Execute 

func (t ResourceLimitTask) Execute(ctx context.Context) TaskOutputState

Execute sets or clears the resource limits for a given dokku application

func (ResourceLimitTask) ExportApp 

func (t ResourceLimitTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs the app's resource limits, one task per process type.

func (ResourceLimitTask) ExportSupport 

func (t ResourceLimitTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (ResourceLimitTask) Plan 

func (t ResourceLimitTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the ResourceLimitTask would produce.

func (ResourceLimitTask) ProbeSupport 

func (t ResourceLimitTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (ResourceLimitTask) Validate 

func (t ResourceLimitTask) Validate() error

Validate checks the ResourceLimitTask's inputs without contacting the server.

type ResourceLimitTaskExample 

type ResourceLimitTaskExample struct {
	// Name is the task name holding the ResourceLimitTask description
	Name string `yaml:"-"`

	// ResourceLimitTask is the ResourceLimitTask configuration
	ResourceLimitTask ResourceLimitTask `yaml:"dokku_resource_limit"`
}

ResourceLimitTaskExample contains an example of a ResourceLimitTask

func (ResourceLimitTaskExample) GetName 

func (e ResourceLimitTaskExample) GetName() string

GetName returns the name of the example

type ResourceReserveTask 

type ResourceReserveTask struct {
	// App is the name of the app
	App string `required:"true" identity:"key" yaml:"app" description:"Name of the app"`

	// ProcessType is the process type to set resource reservations for
	ProcessType string `required:"false" identity:"key" yaml:"process_type,omitempty" description:"Process type to set resource reservations for"`

	// Resources is a map of resource type to quantity
	Resources map[string]string `identity:"collection" yaml:"resources" description:"Map of resource type to quantity"`

	// ClearBefore clears all resource reservations before applying new ones. It
	// is a *bool so the value survives decoding unchanged; nil defaults to false.
	ClearBefore *bool `` /* 129-byte string literal not displayed */

	// State is the desired state of the resource reservations
	State State `` /* 139-byte string literal not displayed */
}

ResourceReserveTask manages the resource reservations for a given dokku application

func (ResourceReserveTask) Doc 

func (t ResourceReserveTask) Doc() string

Doc returns the docblock for the resource reserve task

func (ResourceReserveTask) Execute 

func (t ResourceReserveTask) Execute(ctx context.Context) TaskOutputState

Execute sets or clears the resource reservations for a given dokku application

func (ResourceReserveTask) ExportApp 

func (t ResourceReserveTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs the app's resource reservations, one task per process type.

func (ResourceReserveTask) ExportSupport 

func (t ResourceReserveTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (ResourceReserveTask) Plan 

func (t ResourceReserveTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the ResourceReserveTask would produce.

func (ResourceReserveTask) ProbeSupport 

func (t ResourceReserveTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (ResourceReserveTask) Validate 

func (t ResourceReserveTask) Validate() error

Validate checks the ResourceReserveTask's inputs without contacting the server.

type ResourceReserveTaskExample 

type ResourceReserveTaskExample struct {
	// Name is the task name holding the ResourceReserveTask description
	Name string `yaml:"-"`

	// ResourceReserveTask is the ResourceReserveTask configuration
	ResourceReserveTask ResourceReserveTask `yaml:"dokku_resource_reserve"`
}

ResourceReserveTaskExample contains an example of a ResourceReserveTask

func (ResourceReserveTaskExample) GetName 

func (e ResourceReserveTaskExample) GetName() string

GetName returns the name of the example

type ResourceSelector 

type ResourceSelector struct {
	// Address is the address as the user wrote it, for diagnostics.
	Address string

	// TypeKey is the registered task name, e.g. "dokku_config".
	TypeKey string

	// Keys are the identity key values the address pinned, by yaml name.
	Keys map[string]string
}

ResourceSelector is one parsed `docket export --resource` address: which task type to export, and which of that type's identity keys the address pinned. An empty Keys map means "every resource of this type".

func ParseResourceSelectors 

func ParseResourceSelectors(addresses []string) ([]ResourceSelector, error)

ParseResourceSelectors parses and validates every --resource value.

Validation happens here, before the export contacts the server, so a typo in an address fails immediately rather than after an SSH round trip. Three things are checked: the type resolves to a registered task, that task is actually reachable from ExportRecipe, and every key the address names is one the task declares.

type SchedulerDockerLocalPropertyTask 

type SchedulerDockerLocalPropertyTask PropertyFields

SchedulerDockerLocalPropertyTask manages the scheduler-docker-local configuration for a given dokku application

func (SchedulerDockerLocalPropertyTask) Doc 

func (t SchedulerDockerLocalPropertyTask) Doc() string

Doc returns the docblock for the scheduler-docker-local property task

func (SchedulerDockerLocalPropertyTask) Execute 

func (t SchedulerDockerLocalPropertyTask) Execute(ctx context.Context) TaskOutputState

Execute sets or unsets the scheduler-docker-local property

func (SchedulerDockerLocalPropertyTask) ExportApp 

func (t SchedulerDockerLocalPropertyTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs the app's explicitly-set properties.

func (SchedulerDockerLocalPropertyTask) ExportGlobal 

func (t SchedulerDockerLocalPropertyTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reconstructs the globally-set properties.

func (SchedulerDockerLocalPropertyTask) ExportSupport 

func (t SchedulerDockerLocalPropertyTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (SchedulerDockerLocalPropertyTask) Plan 

func (t SchedulerDockerLocalPropertyTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the SchedulerDockerLocalPropertyTask would produce.

func (SchedulerDockerLocalPropertyTask) ProbeSupport 

func (t SchedulerDockerLocalPropertyTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (SchedulerDockerLocalPropertyTask) Validate 

func (t SchedulerDockerLocalPropertyTask) Validate() error

Validate checks the SchedulerDockerLocalPropertyTask's inputs without contacting the server.

type SchedulerDockerLocalPropertyTaskExample 

type SchedulerDockerLocalPropertyTaskExample struct {
	// Name is the task name holding the SchedulerDockerLocalPropertyTask description
	Name string `yaml:"-"`

	// SchedulerDockerLocalPropertyTask is the SchedulerDockerLocalPropertyTask configuration
	SchedulerDockerLocalPropertyTask SchedulerDockerLocalPropertyTask `yaml:"dokku_scheduler_docker_local_property"`
}

SchedulerDockerLocalPropertyTaskExample contains an example of a SchedulerDockerLocalPropertyTask

func (SchedulerDockerLocalPropertyTaskExample) GetName 

func (e SchedulerDockerLocalPropertyTaskExample) GetName() string

GetName returns the name of the example

type SchedulerK3sAnnotationsTask 

type SchedulerK3sAnnotationsTask struct {
	// App is the name of the app. Required if Global is false.
	App string `required:"false" identity:"key" yaml:"app" description:"Name of the app. Required if Global is false."`

	// Global is a flag indicating if the annotations should be applied globally
	Global bool `` /* 131-byte string literal not displayed */

	// ProcessType narrows the annotations to a specific process type. When
	// empty, dokku stores the annotations under its default global process
	// type.
	ProcessType string `` /* 165-byte string literal not displayed */

	// ResourceType narrows the annotations to a specific kubernetes resource
	// type (e.g. deployment, ingress, service). Required, mirroring dokku's
	// own scheduler-k3s:annotations:set rejection of empty resource types.
	ResourceType string `` /* 146-byte string literal not displayed */

	// Annotations is the desired set of annotation key/value pairs to apply at
	// the (process_type, resource_type) scope.
	Annotations map[string]string `` /* 264-byte string literal not displayed */

	// State is the desired state of the annotations. 'present' and 'absent'
	// are additive, naming keys to write or clear; 'set' declares the complete
	// map for the scope and 'clear' empties it.
	State State `` /* 345-byte string literal not displayed */
}

SchedulerK3sAnnotationsTask manages a group of scheduler-k3s annotations scoped to a (process_type, resource_type) pair on a dokku application or globally.

func (SchedulerK3sAnnotationsTask) Doc 

func (t SchedulerK3sAnnotationsTask) Doc() string

Doc returns the docblock for the scheduler-k3s annotations task

func (SchedulerK3sAnnotationsTask) Execute 

func (t SchedulerK3sAnnotationsTask) Execute(ctx context.Context) TaskOutputState

Execute sets or clears the scheduler-k3s annotations for the configured scope

func (SchedulerK3sAnnotationsTask) ExportApp 

func (t SchedulerK3sAnnotationsTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs the app's annotations, one task per (process_type, resource_type) scope, from scheduler-k3s:annotations:report. state:set replaces each scope's whole map, so a re-applied export reproduces the exact set rather than merging into whatever the target already carries.

func (SchedulerK3sAnnotationsTask) ExportGlobal 

func (t SchedulerK3sAnnotationsTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reconstructs the global-scope annotations, one task per (process_type, resource_type) scope, from scheduler-k3s:annotations:report.

func (SchedulerK3sAnnotationsTask) ExportSupport 

func (t SchedulerK3sAnnotationsTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (SchedulerK3sAnnotationsTask) Plan 

func (t SchedulerK3sAnnotationsTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the SchedulerK3sAnnotationsTask would produce.

func (SchedulerK3sAnnotationsTask) ProbeSupport 

func (t SchedulerK3sAnnotationsTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (SchedulerK3sAnnotationsTask) Validate 

func (t SchedulerK3sAnnotationsTask) Validate() error

Validate checks the SchedulerK3sAnnotationsTask's inputs without contacting the server.

type SchedulerK3sAnnotationsTaskExample 

type SchedulerK3sAnnotationsTaskExample struct {
	// Name is the task name holding the SchedulerK3sAnnotationsTask description
	Name string `yaml:"-"`

	// SchedulerK3sAnnotationsTask is the SchedulerK3sAnnotationsTask configuration
	SchedulerK3sAnnotationsTask SchedulerK3sAnnotationsTask `yaml:"dokku_scheduler_k3s_annotations"`
}

SchedulerK3sAnnotationsTaskExample contains an example of a SchedulerK3sAnnotationsTask

func (SchedulerK3sAnnotationsTaskExample) GetName 

func (e SchedulerK3sAnnotationsTaskExample) GetName() string

GetName returns the name of the example

type SchedulerK3sAutoscalingAuthTask 

type SchedulerK3sAutoscalingAuthTask struct {
	// App is the name of the app. Required if Global is false.
	App string `required:"false" identity:"key" yaml:"app" description:"Name of the app. Required if Global is false."`

	// Global is a flag indicating if the trigger authentication should be
	// applied globally instead of on a single app.
	Global bool `` /* 142-byte string literal not displayed */

	// Trigger is the name of the KEDA trigger authentication resource that
	// groups the metadata keys.
	Trigger string `required:"true" identity:"key" yaml:"trigger" description:"Name of the KEDA trigger authentication resource"`

	// Metadata is the set of metadata key/value pairs to apply to the
	// trigger. On present, these keys are written and merged with any other
	// keys dokku already stores under the trigger. On absent, only the listed
	// keys are cleared; their values are ignored.
	Metadata map[string]string `` /* 226-byte string literal not displayed */

	// State is the desired state of the trigger authentication metadata.
	// 'present' and 'absent' are additive, naming keys to write or clear;
	// 'set' declares the trigger's complete map and 'clear' empties it.
	State State `` /* 295-byte string literal not displayed */
}

SchedulerK3sAutoscalingAuthTask manages the KEDA TriggerAuthentication metadata stored under a single trigger for a dokku application or globally.

func (SchedulerK3sAutoscalingAuthTask) Doc 

func (t SchedulerK3sAutoscalingAuthTask) Doc() string

Doc returns the docblock for the scheduler-k3s autoscaling-auth task

func (SchedulerK3sAutoscalingAuthTask) Execute 

func (t SchedulerK3sAutoscalingAuthTask) Execute(ctx context.Context) TaskOutputState

Execute sets or clears the scheduler-k3s autoscaling trigger authentication metadata

func (SchedulerK3sAutoscalingAuthTask) ExportApp 

func (t SchedulerK3sAutoscalingAuthTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs the app's trigger authentication metadata, one task per trigger, from scheduler-k3s:autoscaling-auth:report. The metadata values are secrets; the export engine lifts them into the companion vars-file.

func (SchedulerK3sAutoscalingAuthTask) ExportGlobal 

func (t SchedulerK3sAutoscalingAuthTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reconstructs the global-scope trigger authentication metadata, one task per trigger, from scheduler-k3s:autoscaling-auth:report.

func (SchedulerK3sAutoscalingAuthTask) ExportSupport 

func (t SchedulerK3sAutoscalingAuthTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (SchedulerK3sAutoscalingAuthTask) Plan 

func (t SchedulerK3sAutoscalingAuthTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the SchedulerK3sAutoscalingAuthTask would produce.

func (SchedulerK3sAutoscalingAuthTask) ProbeSupport 

func (t SchedulerK3sAutoscalingAuthTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (SchedulerK3sAutoscalingAuthTask) SensitiveValues 

func (t SchedulerK3sAutoscalingAuthTask) SensitiveValues() []string

SensitiveValues returns the trigger-authentication metadata values so they are masked in user-facing output. Every metadata value is a secret regardless of its key (the same shape as dokku_config), and the tag-based walker cannot reach a map on this task, so the values are collected here. The absent state leaves the values empty; those are dropped by the masker. Server-probed values (a drifted or surviving value) are registered separately at plan time, since they are not known from the task struct.

func (SchedulerK3sAutoscalingAuthTask) Validate 

func (t SchedulerK3sAutoscalingAuthTask) Validate() error

Validate checks the SchedulerK3sAutoscalingAuthTask's inputs without contacting the server.

type SchedulerK3sAutoscalingAuthTaskExample 

type SchedulerK3sAutoscalingAuthTaskExample struct {
	// Name is the task name holding the SchedulerK3sAutoscalingAuthTask description
	Name string `yaml:"-"`

	// SchedulerK3sAutoscalingAuthTask is the SchedulerK3sAutoscalingAuthTask configuration
	SchedulerK3sAutoscalingAuthTask SchedulerK3sAutoscalingAuthTask `yaml:"dokku_scheduler_k3s_autoscaling_auth"`
}

SchedulerK3sAutoscalingAuthTaskExample contains an example of a SchedulerK3sAutoscalingAuthTask

func (SchedulerK3sAutoscalingAuthTaskExample) GetName 

func (e SchedulerK3sAutoscalingAuthTaskExample) GetName() string

GetName returns the name of the example

type SchedulerK3sChartTask 

type SchedulerK3sChartTask struct {
	// Chart is the helm chart whose values to manage. Dokku validates the
	// chart name against its known HelmCharts list at apply time.
	Chart string `` /* 158-byte string literal not displayed */

	// Values is the desired set of helm value overrides. It accepts either
	// a flat map of dotted Helm property paths (e.g. resources.limits.cpu)
	// or a nested tree (resources: { limits: { cpu: 200m } }). Both shapes
	// flatten to the same dotted form before being handed to dokku. See
	// flattenChartValues for the exact coalescing rules, including the
	// nested-segment escaping that lets dotted leaf keys survive Helm's
	// strvals parser.
	Values map[string]any `` /* 351-byte string literal not displayed */

	// State is the desired state of the chart values.
	State State `` /* 131-byte string literal not displayed */
}

SchedulerK3sChartTask manages helm chart value overrides for one of dokku's bundled scheduler-k3s charts via the dokku `scheduler-k3s:charts:set` / `:charts:report` subcommands. Chart values are global by design in dokku, so the task carries no app/global toggle.

func (SchedulerK3sChartTask) Doc 

func (t SchedulerK3sChartTask) Doc() string

Doc returns the docblock for the scheduler-k3s chart task

func (SchedulerK3sChartTask) Execute 

func (t SchedulerK3sChartTask) Execute(ctx context.Context) TaskOutputState

Execute sets or clears the configured chart values

func (SchedulerK3sChartTask) ExportGlobal 

func (t SchedulerK3sChartTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reconstructs helm chart value overrides from charts:report, which returns every override keyed "<chart>.<key>". Values are grouped into one task per chart, keyed by the dotted override path.

func (SchedulerK3sChartTask) ExportSupport 

func (t SchedulerK3sChartTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (SchedulerK3sChartTask) Plan 

func (t SchedulerK3sChartTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the SchedulerK3sChartTask would produce.

func (SchedulerK3sChartTask) ProbeSupport 

func (t SchedulerK3sChartTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (SchedulerK3sChartTask) Validate 

func (t SchedulerK3sChartTask) Validate() error

Validate checks the SchedulerK3sChartTask's inputs without contacting the server.

type SchedulerK3sChartTaskExample 

type SchedulerK3sChartTaskExample struct {
	// Name is the task name holding the SchedulerK3sChartTask description
	Name string `yaml:"-"`

	// SchedulerK3sChartTask is the SchedulerK3sChartTask configuration
	SchedulerK3sChartTask SchedulerK3sChartTask `yaml:"dokku_scheduler_k3s_chart"`
}

SchedulerK3sChartTaskExample contains an example of a SchedulerK3sChartTask

func (SchedulerK3sChartTaskExample) GetName 

func (e SchedulerK3sChartTaskExample) GetName() string

GetName returns the name of the example

type SchedulerK3sLabelsTask 

type SchedulerK3sLabelsTask struct {
	// App is the name of the app. Required if Global is false.
	App string `required:"false" identity:"key" yaml:"app" description:"Name of the app. Required if Global is false."`

	// Global is a flag indicating if the labels should be applied globally
	Global bool `` /* 126-byte string literal not displayed */

	// ProcessType narrows the labels to a specific process type. When empty,
	// dokku stores the labels under its default global process type.
	ProcessType string `` /* 160-byte string literal not displayed */

	// ResourceType narrows the labels to a specific kubernetes resource type
	// (e.g. deployment, ingress, service). Required, mirroring dokku's own
	// scheduler-k3s:labels:set rejection of empty resource types.
	ResourceType string `` /* 141-byte string literal not displayed */

	// Labels is the desired set of label key/value pairs to apply at the
	// (process_type, resource_type) scope.
	Labels map[string]string `` /* 254-byte string literal not displayed */

	// State is the desired state of the labels. 'present' and 'absent' are
	// additive, naming keys to write or clear; 'set' declares the complete map
	// for the scope and 'clear' empties it.
	State State `` /* 335-byte string literal not displayed */
}

SchedulerK3sLabelsTask manages a group of scheduler-k3s labels scoped to a (process_type, resource_type) pair on a dokku application or globally.

func (SchedulerK3sLabelsTask) Doc 

func (t SchedulerK3sLabelsTask) Doc() string

Doc returns the docblock for the scheduler-k3s labels task

func (SchedulerK3sLabelsTask) Execute 

func (t SchedulerK3sLabelsTask) Execute(ctx context.Context) TaskOutputState

Execute sets or clears the scheduler-k3s labels for the configured scope

func (SchedulerK3sLabelsTask) ExportApp 

func (t SchedulerK3sLabelsTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs the app's labels, one task per (process_type, resource_type) scope, from scheduler-k3s:labels:report. state:set replaces each scope's whole map, so a re-applied export reproduces the exact set rather than merging into whatever the target already carries.

func (SchedulerK3sLabelsTask) ExportGlobal 

func (t SchedulerK3sLabelsTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reconstructs the global-scope labels, one task per (process_type, resource_type) scope, from scheduler-k3s:labels:report.

func (SchedulerK3sLabelsTask) ExportSupport 

func (t SchedulerK3sLabelsTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (SchedulerK3sLabelsTask) Plan 

func (t SchedulerK3sLabelsTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the SchedulerK3sLabelsTask would produce.

func (SchedulerK3sLabelsTask) ProbeSupport 

func (t SchedulerK3sLabelsTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (SchedulerK3sLabelsTask) Validate 

func (t SchedulerK3sLabelsTask) Validate() error

Validate checks the SchedulerK3sLabelsTask's inputs without contacting the server.

type SchedulerK3sLabelsTaskExample 

type SchedulerK3sLabelsTaskExample struct {
	// Name is the task name holding the SchedulerK3sLabelsTask description
	Name string `yaml:"-"`

	// SchedulerK3sLabelsTask is the SchedulerK3sLabelsTask configuration
	SchedulerK3sLabelsTask SchedulerK3sLabelsTask `yaml:"dokku_scheduler_k3s_labels"`
}

SchedulerK3sLabelsTaskExample contains an example of a SchedulerK3sLabelsTask

func (SchedulerK3sLabelsTaskExample) GetName 

func (e SchedulerK3sLabelsTaskExample) GetName() string

GetName returns the name of the example

type SchedulerK3sNodeSysctlsTask 

type SchedulerK3sNodeSysctlsTask struct {
	// Global scopes the sysctls to every node without a node profile.
	Global bool `` /* 176-byte string literal not displayed */

	// Profile scopes the sysctls to the nodes of a single node profile.
	Profile string `` /* 410-byte string literal not displayed */

	// Sysctls is the desired set of sysctl name/value pairs for the scope.
	Sysctls map[string]string `` /* 411-byte string literal not displayed */

	// State is the desired state of the sysctls. 'present' and 'absent' are
	// additive, naming sysctls to write or clear; 'set' declares the complete
	// map for the scope and 'clear' empties it.
	State State `` /* 249-byte string literal not displayed */
}

SchedulerK3sNodeSysctlsTask manages the node-level kernel sysctls scheduler-k3s applies either to every node without a node profile or to the nodes of a single node profile.

The probe reads `scheduler-k3s:node-sysctls:report --stored`, which reports the map each scope stores on its own. The plain report renders a profile's entry as the resolved set, with the global sysctls merged underneath the profile's own, while `--replace` and `:clear` write only the profile's own map - so a profile-scoped task probing the plain report would read drift forever. `--stored` arrived in dokku 0.38.30 (dokku/dokku#9075).

func (SchedulerK3sNodeSysctlsTask) Doc 

func (t SchedulerK3sNodeSysctlsTask) Doc() string

Doc returns the docblock for the scheduler-k3s node sysctls task

func (SchedulerK3sNodeSysctlsTask) Execute 

func (t SchedulerK3sNodeSysctlsTask) Execute(ctx context.Context) TaskOutputState

Execute sets or clears the scheduler-k3s node sysctls for the task's scope

func (SchedulerK3sNodeSysctlsTask) ExportGlobal 

func (t SchedulerK3sNodeSysctlsTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal satisfies GlobalExporter by delegating to exportGlobal with a no-op warn callback. The export engine prefers ExportGlobalReport when present, so the left-out-profile diagnostic reaches ExportReport.Warnings rather than being discarded here.

func (SchedulerK3sNodeSysctlsTask) ExportGlobalReport 

func (t SchedulerK3sNodeSysctlsTask) ExportGlobalReport(ctx context.Context, warn func(msg string)) ([]interface{}, error)

ExportGlobalReport is the diagnostics-aware form of ExportGlobal (the globalExportReporter interface).

func (SchedulerK3sNodeSysctlsTask) ExportSupport 

func (t SchedulerK3sNodeSysctlsTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (SchedulerK3sNodeSysctlsTask) Plan 

func (t SchedulerK3sNodeSysctlsTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the SchedulerK3sNodeSysctlsTask would produce.

func (SchedulerK3sNodeSysctlsTask) ProbeSupport 

func (t SchedulerK3sNodeSysctlsTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (SchedulerK3sNodeSysctlsTask) Validate 

func (t SchedulerK3sNodeSysctlsTask) Validate() error

Validate checks the SchedulerK3sNodeSysctlsTask's inputs without contacting the server.

type SchedulerK3sNodeSysctlsTaskExample 

type SchedulerK3sNodeSysctlsTaskExample struct {
	// Name is the task name holding the SchedulerK3sNodeSysctlsTask description
	Name string `yaml:"-"`

	// SchedulerK3sNodeSysctlsTask is the SchedulerK3sNodeSysctlsTask configuration
	SchedulerK3sNodeSysctlsTask SchedulerK3sNodeSysctlsTask `yaml:"dokku_scheduler_k3s_node_sysctls"`
}

SchedulerK3sNodeSysctlsTaskExample contains an example of a SchedulerK3sNodeSysctlsTask

func (SchedulerK3sNodeSysctlsTaskExample) GetName 

func (e SchedulerK3sNodeSysctlsTaskExample) GetName() string

GetName returns the name of the example

type SchedulerK3sProfileTask 

type SchedulerK3sProfileTask struct {
	// Name is the profile name. It is the lookup key both for the on-disk
	// global property and for `scheduler-k3s:profiles:list --format json`.
	Name string `` /* 292-byte string literal not displayed */

	// Role is the k3s role nodes joined with this profile take. Required and
	// validated up front; dokku also rejects unknown values but failing in the
	// task gives a clearer message.
	Role string `required:"true" yaml:"role" options:"server,worker" description:"Role for nodes joined with this profile."`

	// KubeletArgs is the list of `key=value` strings forwarded to k3s via
	// `--kubelet-arg`. Drift detection compares this as a multiset; the
	// emitted command preserves the user-declared order so the on-disk JSON
	// tracks the YAML when an apply actually runs.
	KubeletArgs []string `required:"false" yaml:"kubelet_args,omitempty" description:"List of key=value kubelet arguments to forward to k3s."`

	// TaintScheduling toggles the `--taint-scheduling` flag on
	// `scheduler-k3s:profiles:add`. Absent or false is "explicitly cleared".
	TaintScheduling bool `` /* 148-byte string literal not displayed */

	// AllowUnknownHosts toggles `--insecure-allow-unknown-hosts`. Absent or
	// false is "explicitly cleared".
	AllowUnknownHosts bool `` /* 144-byte string literal not displayed */

	// State is the desired state of the profile.
	State State `` /* 126-byte string literal not displayed */
}

SchedulerK3sProfileTask manages a global scheduler-k3s node profile via the dokku `scheduler-k3s:profiles:add` / `:profiles:remove` subcommands. Each profile is stored on the dokku host as a single JSON blob (`node-profile-<name>.json`); the task represents the complete desired state of that blob because dokku's `profiles:add` is a full replace, not a patch.

func (SchedulerK3sProfileTask) Doc 

func (t SchedulerK3sProfileTask) Doc() string

Doc returns the docblock for the scheduler-k3s profile task

func (SchedulerK3sProfileTask) Execute 

func (t SchedulerK3sProfileTask) Execute(ctx context.Context) TaskOutputState

Execute drives the profile to the configured state.

func (SchedulerK3sProfileTask) ExportGlobal 

func (t SchedulerK3sProfileTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal satisfies GlobalExporter by delegating to exportGlobal with a no-op warn callback. The export engine prefers ExportGlobalReport when present, so the left-out-profile diagnostic reaches ExportReport.Warnings rather than being discarded here.

func (SchedulerK3sProfileTask) ExportGlobalReport 

func (t SchedulerK3sProfileTask) ExportGlobalReport(ctx context.Context, warn func(msg string)) ([]interface{}, error)

ExportGlobalReport is the diagnostics-aware form of ExportGlobal (the globalExportReporter interface): it routes the "profile left out" warning through the engine's warn callback (wired to ExportReport.Warnings) instead of dropping the profile silently.

func (SchedulerK3sProfileTask) ExportSupport 

func (t SchedulerK3sProfileTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (SchedulerK3sProfileTask) Plan 

func (t SchedulerK3sProfileTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the SchedulerK3sProfileTask would produce.

func (SchedulerK3sProfileTask) ProbeSupport 

func (t SchedulerK3sProfileTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (SchedulerK3sProfileTask) Validate 

func (t SchedulerK3sProfileTask) Validate() error

Validate checks the SchedulerK3sProfileTask's inputs without contacting the server.

type SchedulerK3sProfileTaskExample 

type SchedulerK3sProfileTaskExample struct {
	// Name is the task name holding the SchedulerK3sProfileTask description
	Name string `yaml:"-"`

	// SchedulerK3sProfileTask is the SchedulerK3sProfileTask configuration
	SchedulerK3sProfileTask SchedulerK3sProfileTask `yaml:"dokku_scheduler_k3s_profile"`
}

SchedulerK3sProfileTaskExample contains an example of a SchedulerK3sProfileTask

func (SchedulerK3sProfileTaskExample) GetName 

func (e SchedulerK3sProfileTaskExample) GetName() string

GetName returns the name of the example

type SchedulerK3sPropertyTask 

type SchedulerK3sPropertyTask PropertyFields

SchedulerK3sPropertyTask manages the scheduler-k3s configuration for a given dokku application

func (SchedulerK3sPropertyTask) Doc 

func (t SchedulerK3sPropertyTask) Doc() string

Doc returns the docblock for the scheduler-k3s property task

func (SchedulerK3sPropertyTask) Execute 

func (t SchedulerK3sPropertyTask) Execute(ctx context.Context) TaskOutputState

Execute sets or unsets the scheduler-k3s property

func (SchedulerK3sPropertyTask) ExportApp 

func (t SchedulerK3sPropertyTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs the app's explicitly-set properties.

func (SchedulerK3sPropertyTask) ExportGlobal 

func (t SchedulerK3sPropertyTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reconstructs the globally-set properties.

func (SchedulerK3sPropertyTask) ExportSupport 

func (t SchedulerK3sPropertyTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (SchedulerK3sPropertyTask) Plan 

func (t SchedulerK3sPropertyTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the SchedulerK3sPropertyTask would produce.

func (SchedulerK3sPropertyTask) ProbeSupport 

func (t SchedulerK3sPropertyTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (SchedulerK3sPropertyTask) Validate 

func (t SchedulerK3sPropertyTask) Validate() error

Validate checks the SchedulerK3sPropertyTask's inputs without contacting the server.

type SchedulerK3sPropertyTaskExample 

type SchedulerK3sPropertyTaskExample struct {
	// Name is the task name holding the SchedulerK3sPropertyTask description
	Name string `yaml:"-"`

	// SchedulerK3sPropertyTask is the SchedulerK3sPropertyTask configuration
	SchedulerK3sPropertyTask SchedulerK3sPropertyTask `yaml:"dokku_scheduler_k3s_property"`
}

SchedulerK3sPropertyTaskExample contains an example of a SchedulerK3sPropertyTask

func (SchedulerK3sPropertyTaskExample) GetName 

func (e SchedulerK3sPropertyTaskExample) GetName() string

GetName returns the name of the example

type SchedulerPropertyTask 

type SchedulerPropertyTask PropertyFields

SchedulerPropertyTask manages the scheduler configuration for a given dokku application

func (SchedulerPropertyTask) Doc 

func (t SchedulerPropertyTask) Doc() string

Doc returns the docblock for the scheduler property task

func (SchedulerPropertyTask) Execute 

func (t SchedulerPropertyTask) Execute(ctx context.Context) TaskOutputState

Execute sets or unsets the scheduler property

func (SchedulerPropertyTask) ExportApp 

func (t SchedulerPropertyTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs the app's explicitly-set properties.

func (SchedulerPropertyTask) ExportGlobal 

func (t SchedulerPropertyTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reconstructs the globally-set properties.

func (SchedulerPropertyTask) ExportSupport 

func (t SchedulerPropertyTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (SchedulerPropertyTask) Plan 

func (t SchedulerPropertyTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the SchedulerPropertyTask would produce.

func (SchedulerPropertyTask) ProbeSupport 

func (t SchedulerPropertyTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (SchedulerPropertyTask) Validate 

func (t SchedulerPropertyTask) Validate() error

Validate checks the SchedulerPropertyTask's inputs without contacting the server.

type SchedulerPropertyTaskExample 

type SchedulerPropertyTaskExample struct {
	// Name is the task name holding the SchedulerPropertyTask description
	Name string `yaml:"-"`

	// SchedulerPropertyTask is the SchedulerPropertyTask configuration
	SchedulerPropertyTask SchedulerPropertyTask `yaml:"dokku_scheduler_property"`
}

SchedulerPropertyTaskExample contains an example of a SchedulerPropertyTask

func (SchedulerPropertyTaskExample) GetName 

func (e SchedulerPropertyTaskExample) GetName() string

GetName returns the name of the example

type SensitiveOverride 

type SensitiveOverride interface {
	SensitiveValues() []string
}

SensitiveOverride is implemented by tasks whose sensitive values cannot be declared with a struct tag - typically because the secret lives in the values of an arbitrary map (e.g. dokku_config's `config:` field where every value is a secret regardless of key).

SensitiveValues returns the literal string values from this task instance that must be masked in any user-facing logging output. The tag-based walker runs in addition to this method; both contribute to the final masked set.

type SensitivePropertyFields 

type SensitivePropertyFields struct {
	// App is the name of the app. Required if Global is false.
	App string `required:"false" identity:"key" yaml:"app" description:"Name of the app. Required if Global is false."`

	// Global is a flag indicating if the property should be applied globally
	Global bool `` /* 128-byte string literal not displayed */

	// Property is the name of the property to set
	Property string `required:"true" identity:"key" yaml:"property" description:"Name of the property to set"`

	// Value is the value to set for the property
	Value string `required:"false" sensitive:"true" yaml:"value,omitempty" description:"Value to set for the property"`

	// State is the desired state of the property
	State State `` /* 126-byte string literal not displayed */
}

SensitivePropertyFields is PropertyFields with a masked Value, for a plugin whose property values can carry credentials. Every value is masked, benign ones included, which is preferable to leaking a secret because the per-property judgement was wrong.

The tag drives output masking only - export decides what to lift into a vars file from the property's PropertyKeys entry, so a benign value stays readable in the exported recipe (#451). It is a separate type rather than a tag override because a defined type carries the tags of exactly one struct; TestSensitivePropertyFieldsMatchesPropertyFields fails if the two drift apart in anything but that one tag.

type ServiceBackupTask 

type ServiceBackupTask struct {
	// Service is the type of service to back up (e.g. redis, postgres, mysql)
	Service string `required:"true" identity:"key" yaml:"service" description:"Type of service to back up (e.g. redis, postgres, mysql)"`

	// Name is the name of the service instance
	Name string `required:"true" identity:"key" yaml:"name" description:"Name of the service instance"`

	// Schedule is the cron schedule for backups. Requires bucket.
	Schedule string `required:"false" yaml:"schedule,omitempty" description:"Cron schedule for backups (requires bucket)"`

	// Bucket is the S3 bucket backups are written to. Requires schedule.
	Bucket string `required:"false" yaml:"bucket,omitempty" description:"S3 bucket backups are written to (requires schedule)"`

	// UseIam configures the schedule to use the instance IAM profile instead of static credentials.
	UseIam bool `required:"false" yaml:"use_iam,omitempty" description:"Use the instance IAM profile instead of static credentials"`

	// AwsAccessKeyID is the AWS access key id used for backup auth. Requires aws_secret_access_key.
	AwsAccessKeyID string `` /* 132-byte string literal not displayed */

	// AwsSecretAccessKey is the AWS secret access key used for backup auth. Requires aws_access_key_id.
	AwsSecretAccessKey string `` /* 153-byte string literal not displayed */

	// AwsDefaultRegion is the AWS region used for backup auth.
	AwsDefaultRegion string `required:"false" yaml:"aws_default_region,omitempty" description:"AWS region used for backup auth"`

	// AwsSignatureVersion is the AWS signature version used for backup auth.
	AwsSignatureVersion string `` /* 142-byte string literal not displayed */

	// EndpointURL is the S3-compatible endpoint url used for backup auth.
	EndpointURL string `` /* 141-byte string literal not displayed */

	// EncryptionPassphrase is the passphrase used to encrypt future backups.
	EncryptionPassphrase string `` /* 128-byte string literal not displayed */

	// State is the desired state of the backup configuration
	State State `` /* 138-byte string literal not displayed */
}

ServiceBackupTask manages the S3 backup configuration for a dokku datastore service: the backup schedule, the S3 authentication, and the backup encryption passphrase.

Only the schedule is idempotent: dokku can read it back via <service>:backup-schedule-cat. The auth and encryption pieces have no read command - not even a comparator of the kind registry:auth-status gives dokku_registry_auth - so when those fields are provided they are applied unconditionally and the task reports Changed=true.

func (ServiceBackupTask) Doc 

func (t ServiceBackupTask) Doc() string

Doc returns the docblock for the service backup task

func (ServiceBackupTask) Execute 

func (t ServiceBackupTask) Execute(ctx context.Context) TaskOutputState

Execute manages the backup configuration for a dokku service

func (ServiceBackupTask) ExportGlobal 

func (t ServiceBackupTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reconstructs the backup schedule of every datastore service on the server. Discovery is via listServices; the schedule, bucket, and use_iam flag are parsed from `<service>:backup-schedule-cat <name>`. The AWS credentials and encryption passphrase have no read command, so they are omitted (a partial export) and must be re-supplied before the recipe backs up. Services without a schedule are skipped.

func (ServiceBackupTask) ExportSupport 

func (t ServiceBackupTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (ServiceBackupTask) Plan 

func (t ServiceBackupTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the ServiceBackupTask would produce.

func (ServiceBackupTask) ProbeSupport 

func (t ServiceBackupTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (ServiceBackupTask) Requirements 

func (t ServiceBackupTask) Requirements() []string

Requirements lists the non-core dokku plugins this task depends on.

func (ServiceBackupTask) Validate 

func (t ServiceBackupTask) Validate() error

Validate checks the ServiceBackupTask's inputs without contacting the server.

type ServiceBackupTaskExample 

type ServiceBackupTaskExample struct {
	// Name is the task name holding the ServiceBackupTask description
	Name string `yaml:"-"`

	// ServiceBackupTask is the ServiceBackupTask configuration
	ServiceBackupTask ServiceBackupTask `yaml:"dokku_service_backup"`
}

ServiceBackupTaskExample contains an example of a ServiceBackupTask

func (ServiceBackupTaskExample) GetName 

func (e ServiceBackupTaskExample) GetName() string

GetName returns the name of the example

type ServiceCreateTask 

type ServiceCreateTask struct {
	// Service is the type of service to create (e.g. redis, postgres, mysql)
	Service string `required:"true" identity:"key" yaml:"service" description:"Type of service to create (e.g. redis, postgres, mysql)"`

	// Name is the name of the service instance
	Name string `required:"true" identity:"key" yaml:"name" description:"Name of the service instance"`

	// Image is the image the service container is started from.
	Image string `` /* 230-byte string literal not displayed */

	// ImageVersion is the tag of the image the service container is started from.
	ImageVersion string `` /* 220-byte string literal not displayed */

	// ConfigOptions are extra arguments passed to the container create command.
	ConfigOptions string `` /* 212-byte string literal not displayed */

	// CustomEnv is the environment the service container is started with.
	CustomEnv map[string]string `` /* 224-byte string literal not displayed */

	// Memory is the container memory limit in megabytes.
	Memory int `` /* 133-byte string literal not displayed */

	// ShmSize is the shared memory size of the service container.
	ShmSize string `` /* 195-byte string literal not displayed */

	// InitialNetwork is the network the service is attached to on creation.
	InitialNetwork string `` /* 200-byte string literal not displayed */

	// PostCreateNetwork are the networks attached after service creation.
	PostCreateNetwork []string `` /* 220-byte string literal not displayed */

	// PostStartNetwork are the networks attached after service start.
	PostStartNetwork []string `` /* 216-byte string literal not displayed */

	// Password overrides the user-level service password.
	Password string `` /* 157-byte string literal not displayed */

	// RootPassword overrides the root-level service password.
	RootPassword string `` /* 162-byte string literal not displayed */

	// ImageDrift is what the task does when the service already exists on an
	// image other than the one `image` / `image_version` pins. Read through
	// imageDriftMode, never directly: the `default:` tag is only applied to a
	// decoded recipe, so a task built in Go carries the empty string.
	ImageDrift string `` /* 462-byte string literal not displayed */

	// RestartApps forces the apps linked to the service to restart after an
	// image_drift upgrade has recreated its container.
	RestartApps bool `` /* 280-byte string literal not displayed */

	// State is the desired state of the service
	State State `required:"false" yaml:"state,omitempty" default:"present" options:"present,absent" description:"Desired state of the service"`
}

ServiceCreateTask creates or destroys a dokku service.

Every field below `Name` is a create-time option: the datastore plugins accept them as flags on `<service>:create` (the same set ansible-dokku's module reaches through Ansible's `environment:` keyword, e.g. POSTGRES_IMAGE). They are rendered onto the argv rather than passed as environment variables so they behave identically locally and over SSH - a variable put in front of the local process never reaches the remote shell, so the argv is the only carrier both transports share.

They apply when the service is created. Once it exists dokku's only remedy is `<service>:upgrade`, which removes and recreates the container, so the task does not reach for it on its own: `image_drift` decides what happens when the recipe's `image` / `image_version` pin no longer matches what the service is running, and it defaults to reporting the mismatch rather than acting on it. The remaining create-time options have no read command at all (see ProbeSupport), so they are neither compared nor reconciled.

func (ServiceCreateTask) Doc 

func (t ServiceCreateTask) Doc() string

Doc returns the docblock for the service create task

func (ServiceCreateTask) Execute 

func (t ServiceCreateTask) Execute(ctx context.Context) TaskOutputState

Execute creates or destroys a dokku service

func (ServiceCreateTask) ExportGlobal 

func (t ServiceCreateTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reconstructs every datastore service instance on the server as a dokku_service_create task. Discovery is via listServices (the `service-list` plugin trigger). Like dokku_storage_mount, the service's data is migrated separately - but the image it runs is exported, so a service recreated on another server comes up on the same version rather than whatever that server's plugin defaults to, which is what its `:import` counterpart needs.

func (ServiceCreateTask) ExportSupport 

func (t ServiceCreateTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (ServiceCreateTask) Plan 

func (t ServiceCreateTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the ServiceCreateTask would produce.

func (ServiceCreateTask) ProbeSupport 

func (t ServiceCreateTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (ServiceCreateTask) Requirements 

func (t ServiceCreateTask) Requirements() []string

Requirements lists the non-core dokku plugins this task depends on.

func (ServiceCreateTask) Validate 

func (t ServiceCreateTask) Validate() error

Validate checks the ServiceCreateTask's inputs without contacting the server.

type ServiceCreateTaskExample 

type ServiceCreateTaskExample struct {
	// Name is the task name holding the ServiceCreateTask description
	Name string `yaml:"-"`

	// ServiceCreateTask is the ServiceCreateTask configuration
	ServiceCreateTask ServiceCreateTask `yaml:"dokku_service_create"`
}

ServiceCreateTaskExample contains an example of a ServiceCreateTask

func (ServiceCreateTaskExample) GetName 

func (e ServiceCreateTaskExample) GetName() string

GetName returns the name of the example

type ServiceExposeTask 

type ServiceExposeTask struct {
	// Service is the type of service to expose (e.g. redis, postgres, mysql)
	Service string `required:"true" identity:"key" yaml:"service" description:"Type of service to expose (e.g. redis, postgres, mysql)"`

	// Name is the name of the service instance
	Name string `required:"true" identity:"key" yaml:"name" description:"Name of the service instance"`

	// Ports are the host ports to expose the service on. Required when state is present.
	Ports []string `` /* 144-byte string literal not displayed */

	// State is the desired state of the service exposure
	State State `` /* 134-byte string literal not displayed */
}

ServiceExposeTask exposes or unexposes a dokku service on host ports

func (ServiceExposeTask) Doc 

func (t ServiceExposeTask) Doc() string

Doc returns the docblock for the service expose task

func (ServiceExposeTask) Execute 

func (t ServiceExposeTask) Execute(ctx context.Context) TaskOutputState

Execute exposes or unexposes a dokku service

func (ServiceExposeTask) ExportGlobal 

func (t ServiceExposeTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reconstructs the exposed-ports state of every datastore service on the server. Discovery is via listServices; the exposed host ports are read from `<service>:info <name> --exposed-ports`. Services with no exposed ports are skipped.

func (ServiceExposeTask) ExportSupport 

func (t ServiceExposeTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (ServiceExposeTask) Plan 

func (t ServiceExposeTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the ServiceExposeTask would produce.

func (ServiceExposeTask) ProbeSupport 

func (t ServiceExposeTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (ServiceExposeTask) Requirements 

func (t ServiceExposeTask) Requirements() []string

Requirements lists the non-core dokku plugins this task depends on.

func (ServiceExposeTask) Validate 

func (t ServiceExposeTask) Validate() error

Validate checks the ServiceExposeTask's inputs without contacting the server.

type ServiceExposeTaskExample 

type ServiceExposeTaskExample struct {
	// Name is the task name holding the ServiceExposeTask description
	Name string `yaml:"-"`

	// ServiceExposeTask is the ServiceExposeTask configuration
	ServiceExposeTask ServiceExposeTask `yaml:"dokku_service_expose"`
}

ServiceExposeTaskExample contains an example of a ServiceExposeTask

func (ServiceExposeTaskExample) GetName 

func (e ServiceExposeTaskExample) GetName() string

GetName returns the name of the example

type ServiceLinkTask 

type ServiceLinkTask struct {
	// App is the name of the app to link the service to
	App string `required:"true" identity:"key" yaml:"app" description:"Name of the app to link the service to"`

	// Service is the type of service to link (e.g. redis, postgres, mysql)
	Service string `required:"true" identity:"key" yaml:"service" description:"Type of service to link (e.g. redis, postgres, mysql)"`

	// Name is the name of the service instance
	Name string `required:"true" identity:"key" yaml:"name" description:"Name of the service instance"`

	// State is the desired state of the service link
	State State `` /* 130-byte string literal not displayed */
}

ServiceLinkTask links or unlinks a dokku service to an app

func (ServiceLinkTask) Doc 

func (t ServiceLinkTask) Doc() string

Doc returns the docblock for the service link task

func (ServiceLinkTask) Execute 

func (t ServiceLinkTask) Execute(ctx context.Context) TaskOutputState

Execute links or unlinks a dokku service to an app

func (ServiceLinkTask) ExportApp 

func (t ServiceLinkTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs an app's datastore service links: it enumerates services (listServices) and emits a dokku_service_link for each service the app appears in (serviceLinkedApps). The link, not dokku_config, is the source of truth for the injected `<ALIAS>_URL`, so config export drops those values (see linkedServiceDSNs).

func (ServiceLinkTask) ExportSupport 

func (t ServiceLinkTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (ServiceLinkTask) Plan 

func (t ServiceLinkTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the ServiceLinkTask would produce.

func (ServiceLinkTask) ProbeSupport 

func (t ServiceLinkTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (ServiceLinkTask) Requirements 

func (t ServiceLinkTask) Requirements() []string

Requirements lists the non-core dokku plugins this task depends on.

type ServiceLinkTaskExample 

type ServiceLinkTaskExample struct {
	// Name is the task name holding the ServiceLinkTask description
	Name string `yaml:"-"`

	// ServiceLinkTask is the ServiceLinkTask configuration
	ServiceLinkTask ServiceLinkTask `yaml:"dokku_service_link"`
}

ServiceLinkTaskExample contains an example of a ServiceLinkTask

func (ServiceLinkTaskExample) GetName 

func (e ServiceLinkTaskExample) GetName() string

GetName returns the name of the example

type ServicePropertyTask 

type ServicePropertyTask struct {
	// Service is the type of service to configure (e.g. redis, postgres, mysql)
	Service string `required:"true" identity:"key" yaml:"service" description:"Type of service to configure (e.g. redis, postgres, mysql)"`

	// Name is the name of the service instance
	Name string `required:"true" identity:"key" yaml:"name" description:"Name of the service instance"`

	// Property is the name of the property to set
	Property string `required:"true" identity:"key" yaml:"property" description:"Name of the property to set"`

	// Value is the value to set the property to. Required when state is present.
	Value string `required:"false" yaml:"value,omitempty" description:"Value to set the property to. Required when state is present."`

	// State is the desired state of the property
	State State `` /* 126-byte string literal not displayed */
}

ServicePropertyTask manages a single dokku service property via <service>:set.

Idempotency is intentionally skipped here because dokku service plugins expose no uniform way to read back an arbitrary set key: there is no per-service report JSON, and the `<service>:info` flags do not correspond one-to-one to settable keys (e.g. restart-policy, shm-size, and image are settable but not readable via info). The plan therefore reports drift unconditionally, and docket export cannot reconstruct these properties. Once a machine-readable service property report exists (requested upstream in dokku/dokku-datastore#98), this task should switch to probing instead of always reporting Changed=true, and its export can move off unsupported.

func (ServicePropertyTask) Doc 

func (t ServicePropertyTask) Doc() string

Doc returns the docblock for the service property task

func (ServicePropertyTask) Execute 

func (t ServicePropertyTask) Execute(ctx context.Context) TaskOutputState

Execute sets or clears the dokku service property

func (ServicePropertyTask) ExportSupport 

func (t ServicePropertyTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (ServicePropertyTask) Plan 

func (t ServicePropertyTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the ServicePropertyTask would produce. dokku has no reliable way to read back a service set key, so the plan reports drift unconditionally once the service is confirmed to exist.

func (ServicePropertyTask) ProbeSupport 

func (t ServicePropertyTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (ServicePropertyTask) Requirements 

func (t ServicePropertyTask) Requirements() []string

Requirements lists the non-core dokku plugins this task depends on.

func (ServicePropertyTask) Validate 

func (t ServicePropertyTask) Validate() error

Validate checks the ServicePropertyTask's inputs without contacting the server.

type ServicePropertyTaskExample 

type ServicePropertyTaskExample struct {
	// Name is the task name holding the ServicePropertyTask description
	Name string `yaml:"-"`

	// ServicePropertyTask is the ServicePropertyTask configuration
	ServicePropertyTask ServicePropertyTask `yaml:"dokku_service_property"`
}

ServicePropertyTaskExample contains an example of a ServicePropertyTask

func (ServicePropertyTaskExample) GetName 

func (e ServicePropertyTaskExample) GetName() string

GetName returns the name of the example

type SshKeyTask 

type SshKeyTask struct {
	// Name identifies the key in dokku
	Name string `required:"true" identity:"key" yaml:"name" description:"Name that identifies the key in dokku"`

	// Key is the public key contents. Required when state is present.
	Key string `required:"false" yaml:"key,omitempty" description:"Public key contents. Required when state is present."`

	// State is the desired state of the SSH key
	State State `required:"false" yaml:"state,omitempty" default:"present" options:"present,absent" description:"Desired state of the SSH key"`
}

SshKeyTask manages an SSH public key for git push access via dokku's core ssh-keys plugin.

func (SshKeyTask) Doc 

func (t SshKeyTask) Doc() string

Doc returns the docblock for the ssh key task

func (SshKeyTask) Execute 

func (t SshKeyTask) Execute(ctx context.Context) TaskOutputState

Execute adds or removes the SSH key

func (SshKeyTask) ExportGlobal 

func (t SshKeyTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reconstructs the server's SSH keys from ssh-keys:list, which exposes both the name and the public-key body, so each key is reproduced faithfully.

func (SshKeyTask) ExportSupport 

func (t SshKeyTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (SshKeyTask) Plan 

func (t SshKeyTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the SshKeyTask would produce.

func (SshKeyTask) ProbeSupport 

func (t SshKeyTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (SshKeyTask) Validate 

func (t SshKeyTask) Validate() error

Validate checks the SshKeyTask's inputs without contacting the server.

type SshKeyTaskExample 

type SshKeyTaskExample struct {
	// Name is the task name holding the SshKeyTask description
	Name string `yaml:"-"`

	// SshKeyTask is the SshKeyTask configuration
	SshKeyTask SshKeyTask `yaml:"dokku_ssh_key"`
}

SshKeyTaskExample contains an example of a SshKeyTask

func (SshKeyTaskExample) GetName 

func (e SshKeyTaskExample) GetName() string

GetName returns the name of the example

type State 

type State string

State represents the desired state of a task 

const (
	// StatePresent represents the present state
	StatePresent State = "present"
	// StateAbsent represents the absent state
	StateAbsent State = "absent"
	// StateDeployed represents the deployed state
	StateDeployed State = "deployed"
	// StateSet represents the set state
	StateSet State = "set"
	// StateClear represents the clear state
	StateClear State = "clear"
	// StateSkipped is the sentinel value the apply / plan path emits when
	// a task's `when:` predicate is false. Both State and DesiredState are
	// set to this so the equality check in internal/commands/apply.go does not flag
	// a skipped task as a state mismatch.
	StateSkipped State = "skipped"
)

State constants

type StorageEnsureTask 

type StorageEnsureTask struct {
	// App is the name of the app
	App string `required:"true" identity:"key" yaml:"app" description:"Name of the app"`

	// Chown is the chown value to set
	Chown string `` /* 165-byte string literal not displayed */

	// State is the desired state of the storage
	State State `required:"false" yaml:"state,omitempty" default:"present" options:"present,absent" description:"Desired state of the storage"`
}

StorageEnsureTask manages the storage for a given dokku application

func (StorageEnsureTask) Deprecation 

func (t StorageEnsureTask) Deprecation() string

Deprecation marks dokku_storage_ensure as deprecated. dokku's underlying storage:ensure-directory subcommand has been deprecated in favor of storage:create, which docket exposes through dokku_storage_entry.

func (StorageEnsureTask) Doc 

func (t StorageEnsureTask) Doc() string

Doc returns the docblock for the storage ensure task

func (StorageEnsureTask) Execute 

func (t StorageEnsureTask) Execute(ctx context.Context) TaskOutputState

Execute ensures the storage for a given app

func (StorageEnsureTask) ExportSupport 

func (t StorageEnsureTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (StorageEnsureTask) Plan 

func (t StorageEnsureTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the StorageEnsureTask would produce. dokku does not expose a probe for storage:ensure-directory, so the plan reports drift unconditionally.

func (StorageEnsureTask) ProbeSupport 

func (t StorageEnsureTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (StorageEnsureTask) Validate 

func (t StorageEnsureTask) Validate() error

Validate checks the StorageEnsureTask's inputs without contacting the server. chown is optional: an omitted value lets dokku apply its default (herokuish) ownership. A non-empty value must be one dokku's storage:ensure-directory accepts - a named ownership preset or a numeric uid in 0-65535 (see validChown) - so a typo or out-of-range value is caught before dispatch.

type StorageEnsureTaskExample 

type StorageEnsureTaskExample struct {
	// Name is the task name holding the StorageEnsureTask description
	Name string `yaml:"-"`

	// StorageEnsureTask is the StorageEnsureTask configuration
	StorageEnsureTask StorageEnsureTask `yaml:"dokku_storage_ensure"`
}

StorageEnsureTaskExample contains an example of a StorageEnsureTask

func (StorageEnsureTaskExample) GetName 

func (e StorageEnsureTaskExample) GetName() string

GetName returns the name of the example

type StorageEntryTask 

type StorageEntryTask struct {
	// Name is the name of the storage entry
	Name string `required:"true" identity:"key" yaml:"name" description:"Name of the storage entry"`

	// Path is the host path for the entry. Optional; on docker-local it
	// defaults to the dokku storage root + name.
	Path string `` /* 314-byte string literal not displayed */

	// Scheduler is the scheduler that backs the entry
	Scheduler string `` /* 258-byte string literal not displayed */

	// Size is the volume size (k3s scheduler; required there, rejected on docker-local)
	Size string `` /* 160-byte string literal not displayed */

	// AccessMode is the volume access mode (k3s scheduler)
	AccessMode string `` /* 350-byte string literal not displayed */

	// StorageClass is the storage class name (k3s scheduler)
	StorageClass string `` /* 272-byte string literal not displayed */

	// Namespace is the namespace (scheduler-dependent)
	Namespace string `required:"false" yaml:"namespace,omitempty" description:"Namespace (scheduler-dependent). Converged on an entry that exists"`

	// Chown is the ownership applied to the entry's host directory, on
	// creation and again whenever the recipe changes it.
	Chown string `` /* 403-byte string literal not displayed */

	// Mode is the octal permission set applied to the entry's host
	// directory, on creation and again whenever the recipe changes it.
	Mode string `` /* 494-byte string literal not displayed */

	// ReclaimPolicy is the reclaim policy (k3s scheduler)
	ReclaimPolicy string `` /* 185-byte string literal not displayed */

	// Annotations are the volume annotations (k3s scheduler)
	Annotations map[string]string `` /* 217-byte string literal not displayed */

	// Labels are the volume labels (k3s scheduler)
	Labels map[string]string `` /* 207-byte string literal not displayed */

	// DestroyHostDir removes the host directory alongside the entry, and
	// is only meaningful under state 'absent'.
	DestroyHostDir bool `` /* 358-byte string literal not displayed */

	// State is the desired state of the storage entry
	State State `` /* 131-byte string literal not displayed */
}

StorageEntryTask manages a named storage registry entry — the thing `storage:create` produces and `storage:list-entries` reports. Entries exist independently of any single app, and an attachment created via dokku_storage_mount references them by name.

The entry name selects the entry; every other attribute is compared against what `storage:list-entries` records for it, so a recipe that changes one converges on the next apply rather than being applied once at create time. A field the recipe omits is unmanaged: it is neither compared nor cleared, which is what stops a recipe naming only `name` and `chown` from dropping a `size` it never mentions. Clearing an attribute is a manual `dokku storage:set <name> <property>` with no value.

`destroy_host_dir` is the one field that is not an attribute. It modifies the `storage:destroy` the `absent` state issues, so there is nothing on the entry to compare it against and nothing for an export to reconstruct.

Four fields cannot be converged, because dokku cannot change them on an entry that exists: `storage:set` refuses an access-mode or storage-class swap outright, and there is no command at all for the scheduler or the host path. A recipe that disagrees with the entry on one of them is reported as a plan error naming both values, so it fails before an apply starts rather than part way through one.

func (StorageEntryTask) Doc 

func (t StorageEntryTask) Doc() string

Doc returns the docblock for the storage entry task

func (StorageEntryTask) Execute 

func (t StorageEntryTask) Execute(ctx context.Context) TaskOutputState

Execute creates or destroys the storage entry

func (StorageEntryTask) ExportGlobal 

func (t StorageEntryTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reads the named storage registry entries and returns a dokku_storage_entry task per explicitly-created entry. Auto-generated "legacy-" entries (created implicitly by legacy bind-mounts) are skipped since they are reconstructed by dokku_storage_mount.

storage:list-entries marshals the whole entry, so every field the task can set comes back from the one call. Reconstructing all of them is what makes the export lossless: dropping chown or mode would lose the host directory's ownership and permissions, and dropping size would produce a k3s entry the task's own validation rejects. destroy_host_dir is not exported because it is not state - it modifies a destroy the exported recipe does not perform.

func (StorageEntryTask) ExportSupport 

func (t StorageEntryTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (StorageEntryTask) Plan 

func (t StorageEntryTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the StorageEntryTask would produce.

func (StorageEntryTask) ProbeSupport 

func (t StorageEntryTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (StorageEntryTask) Validate 

func (t StorageEntryTask) Validate() error

Validate checks the StorageEntryTask's inputs without contacting the server. It mirrors the rules dokku's own Entry.Validate enforces, so a combination the server would refuse fails at `docket validate` time instead of halfway through an apply. It deliberately goes no further: dokku ignores rather than rejects namespace, reclaim_policy, annotations, and labels on a docker-local entry, and a stricter docket would refuse recipes the server accepts.

type StorageEntryTaskExample 

type StorageEntryTaskExample struct {
	// Name is the task name holding the StorageEntryTask description
	Name string `yaml:"-"`

	// StorageEntryTask is the StorageEntryTask configuration
	StorageEntryTask StorageEntryTask `yaml:"dokku_storage_entry"`
}

StorageEntryTaskExample contains an example of a StorageEntryTask

func (StorageEntryTaskExample) GetName 

func (e StorageEntryTaskExample) GetName() string

GetName returns the name of the example

type StorageMount 

type StorageMount struct {
	// EntryName is the named storage registry entry to attach. Mutually
	// exclusive with host_dir.
	EntryName string `` /* 132-byte string literal not displayed */

	// HostDir is the host directory to mount (legacy bind-mount form).
	// Mutually exclusive with entry_name.
	HostDir string `` /* 171-byte string literal not displayed */

	// ContainerDir is the container directory to mount. It identifies the
	// mount within its scope: dokku holds at most one attachment per
	// container path per process type.
	ContainerDir string `` /* 142-byte string literal not displayed */

	// Phases is the deployment phases the attachment applies to.
	Phases []string `` /* 148-byte string literal not displayed */

	// Subpath is the subpath within the entry to mount
	Subpath string `required:"false" yaml:"subpath,omitempty" description:"Subpath within the entry to mount; must not contain ','"`

	// Readonly mounts the attachment as read-only when true
	Readonly bool `required:"false" yaml:"readonly,omitempty" description:"Mount the attachment as read-only"`

	// VolumeChown is the chown option applied to the volume at mount time
	VolumeChown string `` /* 131-byte string literal not displayed */

	// VolumeOptions is the comma-separated Docker mount options.
	VolumeOptions string `` /* 206-byte string literal not displayed */
}

StorageMount is one attachment in a StorageMountTask mounts list.

type StorageMountTask 

type StorageMountTask struct {
	// App is the name of the app
	App string `required:"true" identity:"key" yaml:"app" description:"Name of the app"`

	// EntryName is the named storage registry entry to attach. Mutually
	// exclusive with host_dir.
	EntryName string `` /* 143-byte string literal not displayed */

	// HostDir is the host directory to mount (legacy bind-mount form).
	// Mutually exclusive with entry_name.
	HostDir string `` /* 158-byte string literal not displayed */

	// ContainerDir is the container directory to mount
	ContainerDir string `` /* 137-byte string literal not displayed */

	// Phases is the deployment phases the attachment applies to (deploy, run).
	// Empty defers to the dokku default (both phases).
	Phases []string `` /* 148-byte string literal not displayed */

	// ProcessType limits the attachment to a specific process type. For the
	// mounts list it is the scope the list describes.
	ProcessType string `` /* 261-byte string literal not displayed */

	// Subpath is the subpath within the entry to mount
	Subpath string `required:"false" yaml:"subpath,omitempty" description:"Subpath within the entry to mount"`

	// Readonly mounts the attachment as read-only when true
	Readonly bool `required:"false" yaml:"readonly,omitempty" description:"Mount the attachment as read-only"`

	// VolumeChown is the chown option applied to the volume at mount time
	VolumeChown string `required:"false" yaml:"volume_chown,omitempty" description:"Chown option applied to the volume at mount time"`

	// VolumeOptions is the comma-separated mount options applied to the
	// attachment (e.g. "Z" for SELinux relabeling, "noexec,nosuid", NFS
	// opts). On the legacy form it is appended as the third colon segment;
	// on the named-entry form it is passed via --volume-options.
	VolumeOptions string `` /* 168-byte string literal not displayed */

	// Mounts is the list form: the attachments of one process-type scope.
	Mounts []StorageMount `` /* 352-byte string literal not displayed */

	// State is the desired state of the storage
	State State `` /* 184-byte string literal not displayed */
}

StorageMountTask manages storage attachments for a dokku application. It has two mutually exclusive forms:

  • Single mount: the top-level entry_name / host_dir / container_dir and mount-time fields describe one attachment, for state present or absent. A named entry maps to `storage:mount <app> <entry_name> --container-dir <container_dir>` plus the matching attachment flags; host_dir passes the legacy host:container[:opts] colon form. The attachment is found by (source, container_path, process_type), and drift in any of its mount-time attributes is remediated with an in-place upsert.
  • Mount list: `mounts` lists the attachments of one process-type scope, for any of the four states. Every state is a single whole-scope command - `storage:mount --replace` or `storage:unmount --all --process-type` - and every attribute is drift-detected.

Export reads `storage:report <app> --format json` and emits one mount list per process type with state set.

func (StorageMountTask) Doc 

func (t StorageMountTask) Doc() string

Doc returns the docblock for the storage mount task

func (StorageMountTask) Execute 

func (t StorageMountTask) Execute(ctx context.Context) TaskOutputState

Execute attaches or detaches storage for a given app

func (StorageMountTask) ExportApp 

func (t StorageMountTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reads the app's storage attachments via storage:report and returns one dokku_storage_mount per process type, with state set and a mounts list reconstructing every mount-time attribute (phases, subpath, readonly, volume_options, volume_chown). Legacy bind-mounts (dokku wraps these under an auto-generated "legacy-" entry name) use the host_dir form; named registry entries use the entry_name form. Phases and process_type that match dokku's defaults are omitted so the exported recipe stays minimal.

A process type holding an attachment the mounts list cannot express - a key=value or ro/rw volume option, or a comma in its subpath or chown - is exported as one single-mount task per attachment with state present instead, which reproduces the mounts without the list's authority over the scope.

func (StorageMountTask) ExportSupport 

func (t StorageMountTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (StorageMountTask) Plan 

func (t StorageMountTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the StorageMountTask would produce.

func (StorageMountTask) ProbeSupport 

func (t StorageMountTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

func (StorageMountTask) Validate 

func (t StorageMountTask) Validate() error

Validate checks the StorageMountTask's inputs without contacting the server.

type StorageMountTaskExample 

type StorageMountTaskExample struct {
	// Name is the task name holding the StorageMountTask description
	Name string `yaml:"-"`

	// StorageMountTask is the StorageMountTask configuration
	StorageMountTask StorageMountTask `yaml:"dokku_storage_mount"`
}

StorageMountTaskExample contains an example of a StorageMountTask

func (StorageMountTaskExample) GetName 

func (e StorageMountTaskExample) GetName() string

GetName returns the name of the example

type Task 

type Task interface {
	// Plan reports the drift the task would produce against the live server,
	// without mutating it. Plan must never call mutating dokku commands.
	//
	// ctx carries the per-invocation state a task needs: cancellation, and the
	// target the dokku commands run against. Pass it to every subprocess call
	// rather than reaching for context.Background().
	Plan(ctx context.Context) PlanResult

	// Execute executes the task. Conventionally implemented as
	// ExecutePlan(ctx, t.Plan(ctx)) so probing happens once and the per-state
	// mutation logic lives only in Plan().
	Execute(ctx context.Context) TaskOutputState
}

Task represents a task. It is only what running a task needs; the synopsis and examples a task documents itself with live on the optional Documented interface.

func DecodeTask 

func DecodeTask(typeKey string, body []byte) (Task, error)

DecodeTask builds a task of the given type-key from a YAML task body, with defaults applied - the loader's own path, exported so a caller holding a recipe fragment does not have to reimplement it (#425).

func Lookup 

func Lookup(typeKey string) (Task, bool)

Lookup reports whether typeKey is a registered task type and, when it is, returns a zero-value instance of it for reading the task's metadata - its synopsis, identity keys, export support and so on.

Every call allocates, so a caller may do anything with the result without affecting the registry or any other caller. The instance has no `default:` tags applied; use NewTask for a task to set fields on and run.

func NewTask 

func NewTask(typeKey string) (Task, error)

NewTask allocates a task of the given registry type-key with its `default:` tags applied, ready to have its fields set.

Building a task by struct literal is the documented way to drive the engine from Go, and it skips the defaults the loader applies - a literal with no State gets "" rather than "present", which falls into the `invalid state: ""` branch of DispatchPlan instead of behaving the way the field tag says it should. The only code that got this right was decodeTaskBytes, which is unexported and needs YAML to go through. This is the same allocation without the round trip (#425).

The returned Task is a pointer to the registered type, so a caller sets fields through a type assertion: 

task, err := tasks.NewTask("dokku_app")
app := task.(*tasks.AppTask)
app.App = "api"

type TaskCatalog 

type TaskCatalog struct {
	// Version is CatalogVersion. Consumers should branch on it so a future
	// schema change does not silently break them.
	Version int `json:"version"`

	// Tasks are the requested task types - every registered one unless the
	// caller narrowed the selection - sorted by Type.
	Tasks []TaskSchema `json:"tasks"`
}

TaskCatalog is the machine-readable description of a set of registered task types. It is what `docket schema` emits.

func Catalog 

func Catalog() (TaskCatalog, error)

Catalog returns the catalog for every registered task, sorted by type key.

func CatalogFor 

func CatalogFor(typeKeys []string) (TaskCatalog, error)

CatalogFor returns the catalog narrowed to typeKeys, sorted by type key. A nil or empty selection means every registered task, so the whole catalog and a narrowed one are the same code path rather than two that can drift.

Sorting is by type key whatever order the keys arrived in, which is what lets a narrowed catalog be diffed against a full one and makes two runs of the same selection byte-identical. Duplicates collapse: the document is a set keyed by type, so naming a type twice is not an error.

An unregistered key is an error rather than a silently smaller document - a caller asking for a type that does not exist wants to know. Keys are checked in the order given, so the message names the first one the caller wrote, and all of them are checked before any schema is built.

The other error comes from examples(), which yaml-marshals each example struct. Nothing else here can fail.

func (TaskCatalog) Encode 

func (c TaskCatalog) Encode(w io.Writer) error

Encode writes the catalog as an indented JSON document with a trailing newline. This is the byte format `docket schema` emits, so it lives with the catalog rather than with the command.

HTML escaping is off: json.Marshal would turn a description mentioning `dokku <plugin>:report` into `<plugin>`, which is unreadable for a document a human also skims.

type TaskEnvelope 

type TaskEnvelope struct {
	// Name is the user-supplied human label for the task. Auto-generated
	// when the entry omits a name (see GetTasks): a leaf task is named after
	// the resource it addresses (`dokku_config[app=api]`), a group after its
	// position (`group #3`).
	Name string

	// NameGenerated records that Name was derived rather than written in the
	// recipe. dedupeGeneratedNames renames only these, so a generated name
	// can never displace one a recipe author wrote.
	NameGenerated bool

	// Tags is the list of tag strings on the entry. The --tags / --skip-tags
	// CLI flags filter against this set.
	Tags []string

	// When is the raw expr-lang/expr source for the per-task conditional.
	// An empty string means "always run". When non-empty, whenProgram caches
	// the compiled form so loop iterations re-evaluate cheaply.
	When string

	// Loop is the per-task iteration source. Either a list literal
	// ([]interface{}) or an expr-lang/expr source string returning a list.
	// nil means no loop. The loader resolves this into N expanded envelopes
	// and replaces the original entry; downstream consumers see the
	// expansions, not Loop itself.
	Loop interface{}

	// Register, ChangedWhen, FailedWhen, IgnoreErrors are reserved for #210.
	// The loader recognises and decodes them so that issue does not have to
	// revisit the envelope-key allowlist.
	Register     string
	ChangedWhen  string
	FailedWhen   string
	IgnoreErrors bool

	// Block / Rescue / Always carry the nested child envelopes for a
	// try/catch/finally group entry (#211). When Block is non-empty the
	// envelope is a group: Task is nil, TypeName is empty, and the
	// executor walks the three child slices instead of dispatching to a
	// task body. The wrapping envelope's `name`, `tags`, `when`, `loop`,
	// `register`, `changed_when`, `failed_when`, and `ignore_errors`
	// apply to the whole group.
	Block  []*TaskEnvelope
	Rescue []*TaskEnvelope
	Always []*TaskEnvelope

	// Task is the decoded task body. Non-nil for leaf envelopes the
	// loader produces; nil for group envelopes (#211) where Block /
	// Rescue / Always carry the nested children instead.
	Task Task

	// TypeName is the registered task name (e.g. "dokku_app") that
	// dispatched this envelope's body decode. Used for diagnostics.
	TypeName string

	// LoopItem and LoopIndex are populated on envelopes produced by loop
	// expansion. LoopItem is the iterator value (expr context `.item`);
	// LoopIndex is the zero-based position. Non-loop envelopes leave both
	// at their zero value.
	LoopItem  interface{}
	LoopIndex int

	// IsLoopExpansion distinguishes a single-iteration envelope (e.g. when
	// LoopIndex == 0 and LoopItem == nil) from one that came from loop
	// expansion. Useful for predicate context construction.
	IsLoopExpansion bool
	// contains filtered or unexported fields
}

TaskEnvelope wraps a single Task with the cross-cutting fields that the task entry envelope admits. The envelope-key allowlist is the union of:

  • the keys carrying values on this struct (name, tags, when, loop, register, changed_when, failed_when, ignore_errors), and
  • the registered task-type key (e.g. dokku_app) which is decoded into Task and identified by TypeName.

register / changed_when / failed_when / ignore_errors are reserved by #205 but their semantics are activated in #210; the loader recognises the keys today so #210 does not need to revisit the cap.

func (*TaskEnvelope) ChangedWhenProgram 

func (e *TaskEnvelope) ChangedWhenProgram() *vm.Program

ChangedWhenProgram returns the pre-compiled expr program for ChangedWhen, or nil when no `changed_when:` predicate is present.

func (*TaskEnvelope) FailedWhenProgram 

func (e *TaskEnvelope) FailedWhenProgram() *vm.Program

FailedWhenProgram returns the pre-compiled expr program for FailedWhen, or nil when no `failed_when:` predicate is present.

func (*TaskEnvelope) HasChangedWhen 

func (e *TaskEnvelope) HasChangedWhen() bool

HasChangedWhen reports whether the envelope carries a non-empty `changed_when:` predicate.

func (*TaskEnvelope) HasFailedWhen 

func (e *TaskEnvelope) HasFailedWhen() bool

HasFailedWhen reports whether the envelope carries a non-empty `failed_when:` predicate.

func (*TaskEnvelope) HasTag 

func (e *TaskEnvelope) HasTag(tag string) bool

HasTag reports whether the envelope's tag set contains tag.

func (*TaskEnvelope) HasWhen 

func (e *TaskEnvelope) HasWhen() bool

HasWhen reports whether the envelope carries a non-empty `when:` predicate that must be evaluated before execution.

func (*TaskEnvelope) IntersectsTags 

func (e *TaskEnvelope) IntersectsTags(tags []string) bool

IntersectsTags reports whether the envelope's tag set intersects with any of the given tags. Returns false for an envelope with no tags.

func (*TaskEnvelope) IsGroup 

func (e *TaskEnvelope) IsGroup() bool

IsGroup reports whether the envelope is a try/catch/finally group entry (#211). Group envelopes carry their children in Block / Rescue / Always; their Task is nil. The executor uses this flag as the dispatch boundary between the leaf-task code path and the group walker.

func (*TaskEnvelope) WhenProgram 

func (e *TaskEnvelope) WhenProgram() *vm.Program

WhenProgram returns the pre-compiled expr program for When, or nil if no `when:` predicate is present.

type TaskExample 

type TaskExample interface {
	GetName() string
}

TaskExample is a constraint for example structs that have a Name field.

type TaskOutputState 

type TaskOutputState struct {
	// Changed is a flag indicating if the task was changed
	Changed bool

	// Commands records every resolved Dokku subprocess command line the
	// task's apply path executed, in invocation order. Used by
	// `docket apply --verbose` to echo one `→` continuation line per
	// command. Empty for tasks that did not invoke any subprocess.
	Commands []string

	// DesiredState is the desired state of the task
	DesiredState State

	// Error is the error of the task
	Error error

	// ExitCode is the exit code of the last subprocess command the task
	// executed. Zero when the call succeeded or no subprocess ran.
	ExitCode int

	// Message is the message of the task
	Message string

	// Meta is the meta of the task
	Meta struct{}

	// State is the state of the task
	State State

	// Stderr is the captured stderr of the last subprocess command the
	// task executed. Empty when no subprocess ran. Tasks that issue
	// multiple subprocess calls record only the final call's stderr;
	// per-call output, when needed, lives on Commands.
	Stderr string

	// Stdout is the captured stdout of the last subprocess command the
	// task executed. Empty when no subprocess ran. Same last-call-wins
	// rule as Stderr.
	Stdout string

	// Warnings carries non-fatal probe diagnostics discovered while planning
	// (a property task's Plan() surfaces them, and ExecutePlan copies them off
	// the PlanResult so the apply path can drain them). The run loop routes
	// each entry through EventEmitter.TaskWarning; the message is masked at
	// emit time. Empty for tasks that produced no diagnostic.
	Warnings []PlanWarning
}

TaskOutputState represents the output of a task

func DispatchState 

func DispatchState(state State, funcMap map[State]func() TaskOutputState) TaskOutputState

DispatchState looks up the given state in the funcMap, calls the matching function, and returns an error TaskOutputState if the state is not found.

func ExecutePlan 

func ExecutePlan(ctx context.Context, p PlanResult) (out TaskOutputState)

ExecutePlan applies a PlanResult to the server. It is the canonical implementation of Task.Execute(): each task's Execute body is `return ExecutePlan(ctx, t.Plan(ctx))`. ExecutePlan ensures the existing `state.State == state.DesiredState` contract that internal/commands/apply.go relies on.

Three branches:

  1. p.Error != nil - probe failed; return TaskOutputState carrying the error and the desired state. The apply closure is not invoked.
  2. p.InSync - no change needed; return State == DesiredState with Changed=false. The apply closure is not invoked.
  3. otherwise - invoke p.apply (must be non-nil) and return its TaskOutputState verbatim. apply is responsible for setting Changed and a final State that matches DesiredState on success.

ctx is handed to the apply closure rather than the closure capturing the context Plan ran under, so applying a plan always uses the caller's current cancellation and target.

func TaskOutputErrorFromExec 

func TaskOutputErrorFromExec(state TaskOutputState, err error, result subprocess.ExecCommandResponse) TaskOutputState

TaskOutputErrorFromExec sets Error and Message on the given state from an exec result, copies the captured Stdout/Stderr/ExitCode onto the state via withExecResult, and ensures the failing invocation is recorded in state.Commands so it surfaces under `--verbose`. Idempotent against the per-task pre-error-check append pattern: when the failing command is already the most recent entry it is not appended again. Returns the modified state for convenient use with early returns.

type TaskSchema 

type TaskSchema struct {
	// Type is the registry key - the name a recipe uses to invoke the task,
	// such as "dokku_apps_property".
	Type string `json:"type"`

	// Synopsis is the task's Doc(), trimmed. Empty for a task that does not
	// implement Documented.
	Synopsis string `json:"synopsis"`

	// Deprecation is the notice a deprecated task declares. Absent when the
	// task is current.
	Deprecation string `json:"deprecation,omitempty"`

	// Requirements are the non-core dokku plugins the task needs, in declared
	// order. Absent when the task needs nothing beyond dokku core.
	Requirements []string `json:"requirements,omitempty"`

	// Export says whether `docket export` can reconstruct the task from a live
	// server.
	Export ExportSupport `json:"export"`

	// Probe says how much of its own state the task's Plan() can read back. An
	// "unsupported" task plans as drift on every run and never converges.
	Probe ProbeSupport `json:"probe"`

	// Identity is what the task addresses on the server.
	Identity IdentitySchema `json:"identity"`

	// Fields are the recipe keys the task accepts, in declaration order -
	// which is the order the reference page lists them in.
	Fields []FieldSchema `json:"fields"`

	// PropertySchema is present only for a task that manages an enumerable
	// dokku property table. Its absence on a task that has a `property` field
	// means the legal names are not enumerable from docket, not that there are
	// none - see dokku_service_property.
	PropertySchema *PropertySchema `json:"property_schema,omitempty"`

	// Examples are the task's documented examples, the same ones its reference
	// page publishes.
	Examples []ExampleSchema `json:"examples,omitempty"`
}

TaskSchema describes one registered task type. The Go field order here is the key order of the emitted JSON.

func TaskSchemaOf 

func TaskSchemaOf(typeKey string, task Task) (TaskSchema, error)

TaskSchemaOf describes one task. Exported so a caller holding a single prototype does not have to build all of them.

type ToggleContext 

type ToggleContext struct {
	// App is the name of the app
	App string
}

ToggleContext represents the context for a toggle operation

type ToggleFields 

type ToggleFields struct {
	// App is the name of the app
	App string `required:"true" identity:"key" yaml:"app" description:"Name of the app"`

	// State is the desired state of the plugin for the app
	State State `` /* 136-byte string literal not displayed */
}

ToggleFields is the recipe shape every toggle task shares: the app whose plugin is being turned on or off, and whether it should be enabled (present) or disabled (absent). A toggle task declares `type XToggleTask ToggleFields` rather than restating the two fields, so a cross-cutting field change - the identity tags of #427, say - lands in one place instead of in every copy.

A defined type rather than an embedded struct because the field set stays flat to reflection: the catalog, the required-field walk behind missing_required_field, the identity walk that names an unnamed task, and the sensitive-value walks all read a task's fields at the top level, and an embedded field set would empty every one of them out.

The descriptions are deliberately plugin-agnostic. A task's page already names its plugin in the title and the synopsis, so repeating it in every parameter row bought nothing and cost a copy of the field set per plugin.

There is no `global` field: planToggle always targets an app, the global machinery having been removed in #322. A toggle that later needs one declares its own fields and goes on the toggleTasksWithOwnFields allowlist with the reason. See TestToggleTasksDeclareTheSharedFields.

type ToggleProbe 

type ToggleProbe func(ctx context.Context, tc ToggleContext) (enabled bool, err error)

ToggleProbe returns whether the toggle is currently in the "enabled" (state: present) position. nil from a probe (or a non-nil error) is treated as "drift, must mutate" so we still run the underlying command, except an SSH transport failure, which is surfaced as a plan error.

The Go context comes first, as everywhere else; tc is the toggle's own addressing context.

type TraefikPropertyTask 

type TraefikPropertyTask PropertyFields

TraefikPropertyTask manages the traefik configuration for a given dokku application

func (TraefikPropertyTask) Doc 

func (t TraefikPropertyTask) Doc() string

Doc returns the docblock for the traefik property task

func (TraefikPropertyTask) Execute 

func (t TraefikPropertyTask) Execute(ctx context.Context) TaskOutputState

Execute sets or unsets the traefik property

func (TraefikPropertyTask) ExportApp 

func (t TraefikPropertyTask) ExportApp(ctx context.Context, app string) ([]interface{}, error)

ExportApp reconstructs the app's explicitly-set properties.

func (TraefikPropertyTask) ExportGlobal 

func (t TraefikPropertyTask) ExportGlobal(ctx context.Context) ([]interface{}, error)

ExportGlobal reconstructs the globally-set properties.

func (TraefikPropertyTask) ExportSupport 

func (t TraefikPropertyTask) ExportSupport() ExportSupport

ExportSupport reports how docket export handles this task.

func (TraefikPropertyTask) Plan 

func (t TraefikPropertyTask) Plan(ctx context.Context) PlanResult

Plan reports the drift the TraefikPropertyTask would produce.

func (TraefikPropertyTask) ProbeSupport 

func (t TraefikPropertyTask) ProbeSupport() ProbeSupport

ProbeSupport reports whether Plan() can read this task's current state.

Supported without a caveat because dokku 0.38.27+ reports the dynamic `dns-provider-*` family alongside the mapped properties, so every property this task manages is readable and converges (#450).

func (TraefikPropertyTask) Validate 

func (t TraefikPropertyTask) Validate() error

Validate checks the TraefikPropertyTask's inputs without contacting the server.

type TraefikPropertyTaskExample 

type TraefikPropertyTaskExample struct {
	// Name is the task name holding the TraefikPropertyTask description
	Name string `yaml:"-"`

	// TraefikPropertyTask is the TraefikPropertyTask configuration
	TraefikPropertyTask TraefikPropertyTask `yaml:"dokku_traefik_property"`
}

TraefikPropertyTaskExample contains an example of a TraefikPropertyTask

func (TraefikPropertyTaskExample) GetName 

func (e TraefikPropertyTaskExample) GetName() string

GetName returns the name of the example

type ValidateOptions 

type ValidateOptions struct {
	Strict         bool
	InputOverrides map[string]bool
	PlayName       string
	StartAtTask    string
	Format         string
}

ValidateOptions controls optional checks. Strict turns on the input-resolution audit; InputOverrides is the set of input names whose values were supplied on the CLI (the same map registerInputFlags fills in for apply/plan).

PlayName and StartAtTask carry the values of `validate --play` and `validate --start-at-task` respectively. They power the cross-reference audit that runs under `--strict`: each non-empty value must resolve to a real play / task name in the recipe.

Format selects the on-disk surface syntax: "yaml" (default) or "json5". JSON5 input is normalised to YAML bytes once at the top of Validate so the rest of the pipeline (sigil render, yaml.Node walk, line/column reporting) keeps a single implementation. Line / column numbers in problems for a JSON5 file therefore index into the normalised form, not the original JSON5 source.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.