config

Documentation

Index

• type APIServer
  • func (a *APIServer) BindAddress() string
  • func (a *APIServer) Validate() error
• type Config
  • func NewConfig(cfgFile string) (*Config, error)
  • func (c *Config) Validate() error
• type DBBackendType
• type Database
  • func (d *Database) GormParams() (dbType DBBackendType, uri string, err error)
  • func (d *Database) Validate() error
• type Default
  • func (d *Default) Validate() error
• type External
  • func (e *External) ExecutablePath() (string, error)
  • func (e *External) GetEnvironmentVariables() []string
  • func (e *External) Validate() error
• type Github
  • func (g *Github) APIEndpoint() string
  • func (g *Github) BaseEndpoint() string
  • func (g *Github) CACertBundle() ([]byte, error)
  • func (g *Github) UploadEndpoint() string
  • func (g *Github) Validate() error
• type JWTAuth
  • func (j *JWTAuth) Validate() error
• type Metrics
• type MySQL
  • func (m *MySQL) ConnectionString() (string, error)
  • func (m *MySQL) Validate() error
• type Provider
  • func (p *Provider) Validate() error
• type SQLite
  • func (s *SQLite) ConnectionString() (string, error)
  • func (s *SQLite) Validate() error
• type TLSConfig
  • func (t *TLSConfig) Validate() error

Types

type APIServer

type APIServer struct {
	Bind        string    `toml:"bind" json:"bind"`
	Port        int       `toml:"port" json:"port"`
	UseTLS      bool      `toml:"use_tls" json:"use-tls"`
	TLSConfig   TLSConfig `toml:"tls" json:"tls"`
	CORSOrigins []string  `toml:"cors_origins" json:"cors-origins"`
}

APIServer holds configuration for the API server worker

func (*APIServer) BindAddress

func (a *APIServer) BindAddress() string

BindAddress returns a host:port string.

func (*APIServer) Validate

func (a *APIServer) Validate() error

Validate validates the API server config

type Config

type Config struct {
	Default   Default    `toml:"default" json:"default"`
	APIServer APIServer  `toml:"apiserver,omitempty" json:"apiserver,omitempty"`
	Metrics   Metrics    `toml:"metrics,omitempty" json:"metrics,omitempty"`
	Database  Database   `toml:"database,omitempty" json:"database,omitempty"`
	Providers []Provider `toml:"provider,omitempty" json:"provider,omitempty"`
	Github    []Github   `toml:"github,omitempty"`
	JWTAuth   JWTAuth    `toml:"jwt_auth" json:"jwt-auth"`
}

func NewConfig

func NewConfig(cfgFile string) (*Config, error)

NewConfig returns a new Config

func (*Config) Validate

func (c *Config) Validate() error

Validate validates the config

type DBBackendType

type DBBackendType string

const (
	// MySQLBackend represents the MySQL DB backend
	MySQLBackend DBBackendType = "mysql"
	// SQLiteBackend represents the SQLite3 DB backend
	SQLiteBackend DBBackendType = "sqlite3"
	// EnvironmentVariablePrefix is the prefix for all environment variables
	// that can not be used to get overwritten via the external provider
	EnvironmentVariablePrefix = "GARM"
)

type Database

type Database struct {
	Debug     bool          `toml:"debug" json:"debug"`
	DbBackend DBBackendType `toml:"backend" json:"backend"`
	MySQL     MySQL         `toml:"mysql" json:"mysql"`
	SQLite    SQLite        `toml:"sqlite3" json:"sqlite3"`
	// Passphrase is used to encrypt any sensitive info before
	// inserting it into the database. This is just temporary until
	// we move to something like vault or barbican for secrets storage.
	// Don't lose or change this. It will invalidate all encrypted data
	// in the DB. This field must be set and must be exactly 32 characters.
	Passphrase string `toml:"passphrase"`
}

Database is the database config entry

func (*Database) GormParams

func (d *Database) GormParams() (dbType DBBackendType, uri string, err error)

GormParams returns the database type and connection URI

func (*Database) Validate

func (d *Database) Validate() error

Validate validates the database config entry

type Default

type Default struct {
	// CallbackURL is the URL where the instances can send back status reports.
	CallbackURL string `toml:"callback_url" json:"callback-url"`
	// MetadataURL is the URL where instances can fetch information they may need
	// to set themselves up.
	MetadataURL string `toml:"metadata_url" json:"metadata-url"`
	// WebhookURL is the URL that will be installed as a webhook target in github.
	WebhookURL string `toml:"webhook_url" json:"webhook-url"`
	// EnableWebhookManagement enables the webhook management API.
	EnableWebhookManagement bool `toml:"enable_webhook_management" json:"enable-webhook-management"`

	// LogFile is the location of the log file.
	LogFile           string `toml:"log_file,omitempty" json:"log-file"`
	EnableLogStreamer bool   `toml:"enable_log_streamer"`
	DebugServer       bool   `toml:"debug_server" json:"debug-server"`
}

func (*Default) Validate

func (d *Default) Validate() error

type External

type External struct {
	// ConfigFile is the path on disk to a file which will be passed to
	// the external binary as an environment variable: GARM_PROVIDER_CONFIG
	// You can use this file for any configuration you need to do for the
	// cloud your calling into, to create the compute resources.
	ConfigFile string `toml:"config_file" json:"config-file"`
	// ProviderDir is the path on disk to a folder containing an executable
	// called "garm-external-provider".
	ProviderDir string `toml:"provider_dir" json:"provider-dir"`
	// ProviderExecutable is the full path to the executable that implements
	// the provider. If specified, it will take precedence over the "garm-external-provider"
	// executable in the ProviderDir.
	ProviderExecutable string `toml:"provider_executable" json:"provider-executable"`
	// EnvironmentVariables is a list of environment variable names that will be
	// passed to the external binary together with their values.
	EnvironmentVariables []string `toml:"environment_variables" json:"environment-variables"`
}

External represents the config for an external provider. The external provider is a provider that delegates all operations to an external binary. This way, you can write your own logic in whatever programming language you wish, while still remaining compatible with garm.

func (*External) ExecutablePath

func (e *External) ExecutablePath() (string, error)

func (*External) GetEnvironmentVariables

func (e *External) GetEnvironmentVariables() []string

func (*External) Validate

func (e *External) Validate() error

type Github

type Github struct {
	Name          string `toml:"name" json:"name"`
	Description   string `toml:"description" json:"description"`
	OAuth2Token   string `toml:"oauth2_token" json:"oauth2-token"`
	APIBaseURL    string `toml:"api_base_url" json:"api-base-url"`
	UploadBaseURL string `toml:"upload_base_url" json:"upload-base-url"`
	BaseURL       string `toml:"base_url" json:"base-url"`
	// CACertBundlePath is the path on disk to a CA certificate bundle that
	// can validate the endpoints defined above. Leave empty if not using a
	// self signed certificate.
	CACertBundlePath string `toml:"ca_cert_bundle" json:"ca-cert-bundle"`
}

Github hold configuration options specific to interacting with github. Currently that is just a OAuth2 personal token.

func (*Github) APIEndpoint

func (g *Github) APIEndpoint() string

func (*Github) BaseEndpoint

func (g *Github) BaseEndpoint() string

func (*Github) CACertBundle

func (g *Github) CACertBundle() ([]byte, error)

func (*Github) UploadEndpoint

func (g *Github) UploadEndpoint() string

func (*Github) Validate

func (g *Github) Validate() error

type JWTAuth

type JWTAuth struct {
	Secret     string     `toml:"secret" json:"secret"`
	TimeToLive timeToLive `toml:"time_to_live" json:"time-to-live"`
}

JWTAuth holds settings used to generate JWT tokens

func (*JWTAuth) Validate

func (j *JWTAuth) Validate() error

Validate validates the JWTAuth config

type Metrics

type Metrics struct {
	DisableAuth bool `toml:"disable_auth" json:"disable-auth"`
	Enable      bool `toml:"enable" json:"enable"`
}

type MySQL

type MySQL struct {
	Username     string `toml:"username" json:"username"`
	Password     string `toml:"password" json:"password"`
	Hostname     string `toml:"hostname" json:"hostname"`
	DatabaseName string `toml:"database" json:"database"`
}

MySQL is the config entry for the mysql section

func (*MySQL) ConnectionString

func (m *MySQL) ConnectionString() (string, error)

ConnectionString returns a gorm compatible connection string

func (*MySQL) Validate

func (m *MySQL) Validate() error

Validate validates a Database config entry

type Provider

type Provider struct {
	Name         string              `toml:"name" json:"name"`
	ProviderType params.ProviderType `toml:"provider_type" json:"provider-type"`
	Description  string              `toml:"description" json:"description"`
	// DisableJITConfig explicitly disables JIT configuration and forces runner registration
	// tokens to be used. This may happen if a provider has not yet been updated to support
	// JIT configuration.
	DisableJITConfig bool     `toml:"disable_jit_config" json:"disable-jit-config"`
	External         External `toml:"external" json:"external"`
}

Provider holds access information for a particular provider. A provider offers compute resources on which we spin up self hosted runners.

func (*Provider) Validate

func (p *Provider) Validate() error

type SQLite

type SQLite struct {
	DBFile string `toml:"db_file" json:"db-file"`
}

SQLite is the config entry for the sqlite3 section

func (*SQLite) ConnectionString

func (s *SQLite) ConnectionString() (string, error)

func (*SQLite) Validate

func (s *SQLite) Validate() error

type TLSConfig

type TLSConfig struct {
	CRT string `toml:"certificate" json:"certificate"`
	Key string `toml:"key" json:"key"`
}

TLSConfig is the API server TLS config

func (*TLSConfig) Validate

func (t *TLSConfig) Validate() error

Validate validates the TLS config