runner

type Arg struct {
	// Flag: is a CLI flag, eg. `--from-file`
	Flag string `yaml:"flag"`
	// Value: is the value for this flag, eg. `path/to/my/files`
	Value string `yaml:"value"`
}

type Chart struct {
	// Type: chart type, can be either `ytt` or `helm`
	Type string `yaml:"type"`
	// Path: relative path to the chart itself
	Path string `yaml:"path"`
	// Name: overwrite helm application name
	Name string `yaml:"name"`
	// Namespace: will be pass to helm as parameter (helm only)
	Namespace string `yaml:"namespace"`
	// Disabled: disable this chart
	// This can be useful when inheriting the chart
	// must be castable to bool (0,1,true,false)
	Disabled string `yaml:"disabled"`
	// KubeVersion: kubernetes version to use for helm template (helm only)
	KubeVersion string `yaml:"kubeversion"`
}

type CmdChart struct {
	Type      string
	Path      string
	Name      string
	Namespace string
	// Must be castable into bool (0,1,true,false).
	Disabled        string
	ValuesFileNames []string
	KubeVersion     string
}

type CmdCharts map[string]CmdChart

type CmdConfig struct {
	Spec           CmdSpec
	RootDir        string
	Layers         []string
	Namespace      string
	Logger         zerolog.Logger
	DryRun         bool
	WithoutHydrate bool
	Output         string
	FetchHelmDeps  bool
	Tools          Tools
	// contains filtered or unexported fields
}

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

type CmdConfigOptions struct {
	Logger         zerolog.Logger
	RootDir        string
	ConfigDir      string
	DryRun         bool
	WithoutHydrate bool
	Output         string
	Namespace      string
	FetchHelmDeps  bool
}

type CmdCreate struct {
	Dir  string
	Args []Arg
}

type CmdCreateKey struct {
	Type string
	Name string
}

type CmdSha struct {
	Key      string
	Resource string
	Sha      string
}

type CmdSpec struct {
	Variables Variables
	Shas      []*CmdSha
	Charts    CmdCharts
	Ytt       Ytt
	Creates   map[CmdCreateKey]CmdCreate
}

type Config struct {
	// Inherit: relative path to another beaver project
	// a beaver project is a folder with a beaver.yaml file
	Inherit string `yaml:"inherit"`
	// BeaverVersion: the beaver version this config is supposed to work with.
	BeaverVersion string `yaml:"beaverversion"`
	// NameSpace: a kubernetes Namespace, shouldn't be mandatory
	NameSpace string `yaml:"namespace"`
	// Inherits: list of relative path to other beaver projects
	Inherits []string `yaml:"inherits,flow"`
	// PatchInherits: retarget inherited layers. Each entry redirects every
	// inherited edge whose resolved path equals its Source to its Dest.
	PatchInherits []PatchInherit `yaml:"patch_inherits,flow"`
	// Delete: remove variables and/or ytt-data files that an ANCESTOR layer
	// provided. Merge only ever adds or overrides, so a layer (e.g. a version
	// overlay) uses this to drop what it inherits. Collected from every layer and
	// applied after the merge (variables) / during ytt collection (ytt-data).
	Delete Delete `yaml:"delete"`
	// Variables: list of beaver variables
	Variables Variables `yaml:"variables,flow"`
	// Sha: list of Sha
	Sha []Sha `yaml:"sha,flow"`
	// Charts: map of charts definitions, where the key is the chart name for beaver values.
	// eg. beaver will use `foo.yaml` for a chart with key `foo`
	Charts map[string]Chart `yaml:"charts,flow"`
	// Creates: list of kubectl create commands
	Creates []Create `yaml:"create,flow"`
	// Tools: custom paths for external tools (helm, ytt, kubectl)
	Tools Tools `yaml:"tools"`
	// Dir: internal use
	Dir string `yaml:"-"` // the directory in which we found the config file
}

type Create struct {
	// Type: of resource you want to create with kubectl, eg. configmap
	Type string `yaml:"type"`
	// Name: resource name
	Name string `yaml:"name"`
	// Args: list of Arg pass to kubectl create command
	Args []Arg `yaml:"args,flow"`
}

type DefaultBoolParser struct{}

type DefaultChartArgsBuilder struct{}

type DefaultCommandExecutor struct {
	Logger zerolog.Logger
	DryRun bool
}

type DefaultCreateArgsBuilder struct{}

type DefaultDirCleaner struct{}

type DefaultFileCopier struct{}

type DefaultFileHydrator struct{}

type DefaultNameHydrator struct{}

type DefaultShaComputer struct{}

type DefaultStringHydrator struct{}

type DefaultYamlSplitter struct{}

type Delete struct {
	// Variables: dotted beaver-variable paths to remove after all layers are merged
	// (same path syntax as a variable reference, e.g. `backend.port`, `a."b.c".d`).
	Variables []string `yaml:"variables,flow"`
	// YttData: ytt-data file paths (relative to a layer's ytt-data/ dir, e.g.
	// `config/legacy.ini`) to exclude from the ytt data files, so data.read()/
	// data.list() no longer see them in any layer.
	YttData []string `yaml:"ytt_data,flow"`
	// Ytt: ytt overlay file paths (relative to a layer's ytt/ dir, e.g.
	// `patch.foo.yaml`) to exclude from every OTHER layer's ytt/ dir — never from
	// the declaring layer's own. ytt applies overlay files sequentially by
	// relative path (unlike ytt-data's first-wins data.read()), so a same-path
	// file does not automatically shadow an ancestor's: a layer that wants to
	// replace an inherited overlay must provide its own file AND declare it here,
	// or both apply in sequence.
	Ytt []string `yaml:"ytt,flow"`
}

type HelmChart struct {
	Dependencies []HelmDependency `yaml:"dependencies"`
}

type HelmDependency struct {
	Name       string `yaml:"name"`
	Repository string `yaml:"repository"`
}

type PatchInherit struct {
	// Source: relative path to the inherited project to replace
	Source string `yaml:"source"`
	// Dest: relative path to the inherited project to use instead
	Dest string `yaml:"dest"`
}

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

type Sha struct {
	// Key is used to generate beaver variable
	// beaver variable will be `sha.<Key>`
	Key string `yaml:"key"`
	// Resource file from which we should compute the sha256
	// Same format as beaver output:
	// <kind>.<apiVersion>.<name>.yaml
	Resource string `yaml:"resource"`
}

type Tools struct {
	// Helm: path to helm executable
	Helm string `yaml:"helm"`
	// Ytt: path to ytt executable
	Ytt string `yaml:"ytt"`
	// Kubectl: path to kubectl executable
	Kubectl string `yaml:"kubectl"`
}

type Variable struct {
	Name  string      `yaml:"name"`
	Value interface{} `yaml:"value"`
}

type Variables []Variable

type Ytt []string