config

type CLI ¶ added in v0.25.0

type CLI struct {
	RemoteConfig string `toml:"remote_config"`
	TTL          string `toml:"ttl"`
	LastChecked  string `toml:"last_checked"`
	Version      string `toml:"version"`
}

CLI represents CLI specific configuration.

type Data ¶

type Data struct {
	File   File
	Path   string
	Env    Environment
	Output io.Writer
	Flag   Flag
	ErrLog fsterr.LogInterface

	APIClient  api.Interface
	HTTPClient api.HTTPClient
	RTSClient  api.RealtimeStatsInterface
}

Data holds global-ish configuration data from all sources: environment variables, config files, and flags. It has methods to give each parameter to the components that need it, including the place the parameter came from, which is a requirement.

If the same parameter is defined in multiple places, it is resolved according to the following priority order: the config file (lowest priority), env vars, and then explicit flags (highest priority).

This package and its types are only meant for parameters that are applicable to most/all subcommands (e.g. API token) and are consistent for a given user (e.g. an email address). Otherwise, parameters should be defined in specific command structs, and parsed as flags.

func (d *Data) Endpoint() (string, Source)

func (d *Data) Token() (string, Source)

func (d *Data) Verbose() bool

type Environment ¶

type Environment struct {
	Token    string
	Endpoint string
}

Environment represents all of the configuration parameters that can come from environment variables.

func (e *Environment) Read(state map[string]string)

type Fastly ¶ added in v0.25.0

type Fastly struct {
	APIEndpoint string `toml:"api_endpoint"`
}

Fastly represents fastly specific configuration.

type File ¶

type File struct {
	CLI           CLI                 `toml:"cli"`
	ConfigVersion int                 `toml:"config_version"`
	Fastly        Fastly              `toml:"fastly"`
	Language      Language            `toml:"language"`
	StarterKits   StarterKitLanguages `toml:"starter-kits"`
	User          User                `toml:"user"`
	Viceroy       Viceroy             `toml:"viceroy"`

	// We store off a possible legacy configuration so that we can later extract
	// the relevant email and token values that may pre-exist.
	Legacy LegacyFile `toml:"legacy"`
	// contains filtered or unexported fields
}

File represents our dynamic application toml configuration.

func (f *File) Load(endpoint, path string, c api.HTTPClient) error

func (f *File) Read(path string, in io.Reader, out io.Writer) error

func (f *File) SetStatic(static []byte)

func (f *File) Static() []byte

func (f *File) UseStatic(cfg []byte, path string) error

func (f *File) ValidConfig(verbose bool, out io.Writer) bool

func (f *File) Write(path string) error

type Flag ¶

type Flag struct {
	Token    string
	Verbose  bool
	Endpoint string
}

Flag represents all of the configuration parameters that can be set with explicit flags. Consumers should bind their flag values to these fields directly.

type Language ¶ added in v0.25.0

type Language struct {
	Rust Rust `toml:"rust"`
}

Language represents C@E language specific configuration.

type LegacyFile ¶ added in v0.25.0

type LegacyFile struct {
	Token string `toml:"token"`
	Email string `toml:"email"`
}

LegacyFile represents the old toml configuration format.

NOTE: this exists to catch situations where an existing CLI user upgrades their version of the CLI and ends up trying to use the latest iteration of the toml configuration. We don't want them to have to re-enter their email or token, so we'll decode the existing config file into the LegacyFile type and then extract those details later when constructing the proper File type.

I had tried to make this an unexported type but it seemed the toml decoder would fail to unmarshal the configuration unless it was an exported type.

type Rust ¶ added in v0.25.0

type Rust struct {
	// ToolchainVersion is the `rustup` toolchain string for the compiler that we
	// support
	//
	// DEPRECATED in favour of ToolchainConstraint
	ToolchainVersion string `toml:"toolchain_version"`

	// ToolchainConstrain is the `rustup` toolchain constraint for the compiler
	// that we support (a range is expected, e.g. >= 1.49.0 < 2.0.0).
	ToolchainConstraint string `toml:"toolchain_constraint"`

	// WasmWasiTarget is the Rust compilation target for Wasi capable Wasm.
	WasmWasiTarget string `toml:"wasm_wasi_target"`

	// FastlySysConstraint is a free-form semver constraint for the internal Rust
	// ABI version that should be supported.
	FastlySysConstraint string `toml:"fastly_sys_constraint"`

	// RustupConstraint is a free-form semver constraint for the rustup version
	// that should be installed.
	RustupConstraint string `toml:"rustup_constraint"`
}

Rust represents Rust C@E language specific configuration.

type Source ¶

type Source uint8

Source enumerates where a config parameter is taken from.

type StarterKit ¶ added in v0.25.0

type StarterKit struct {
	Name        string `toml:"name"`
	Description string `toml:"description"`
	Path        string `toml:"path"`
	Tag         string `toml:"tag"`
	Branch      string `toml:"branch"`
}

StarterKit represents starter kit specific configuration.

type StarterKitLanguages ¶ added in v0.25.0

type StarterKitLanguages struct {
	AssemblyScript []StarterKit `toml:"assemblyscript"`
	JavaScript     []StarterKit `toml:"javascript"`
	Rust           []StarterKit `toml:"rust"`
}

StarterKitLanguages represents language specific starter kits.

type User ¶ added in v0.25.0

type User struct {
	Token string `toml:"token"`
	Email string `toml:"email"`
}

User represents user specific configuration.

type Viceroy ¶ added in v1.4.0

type Viceroy struct {
	LastChecked   string `toml:"last_checked"`
	LatestVersion string `toml:"latest_version"`
	TTL           string `toml:"ttl"`
}

Viceroy represents viceroy specific configuration.