config

Documentation

Index

• Constants
• Variables
• type Config
  • func LoadFromData(data []byte) (*Config, error)
  • func LoadFromFile(path string) (*Config, error)
• type DatabaseConfig
  • func NewDefaultDatabaseConfig() *DatabaseConfig
  • func (c *DatabaseConfig) Validate() error
• type DatabaseEngine
• type NotifierConfig
  • func (c *NotifierConfig) Validate() error
• type NotifierType
• type ProviderConfig
  • func (c *ProviderConfig) Validate() error
  • func (c *ProviderConfig) ValidateHetzner() error
• type ProviderType
  • func (t ProviderType) String() string
• type ServerConfig
  • func (c *ServerConfig) Validate() error
• type TailnetConfig
  • func (c *TailnetConfig) Validate() error
• type TailnetType
  • func (t TailnetType) String() string
• type WorkflowConfig
  • func NewDefaultWorkflowConfig() *WorkflowConfig
  • func (c *WorkflowConfig) Validate() error
• type WorkflowType

Constants

const (
	DdbAccessKeyEnvVar = "DDB_AWS_ACCESS_KEY_ID"
	DdbSecretKeyEnvVar = "DDB_AWS_SECRET_ACCESS_KEY"
	DdbRegionEnvVar    = "DDB_AWS_REGION"
)

const (
	SnsAccessKeyEnvVar = "SNS_AWS_ACCESS_KEY_ID"
	SnsSecretKeyEnvVar = "SNS_AWS_SECRET_ACCESS_KEY"
	SnsRegionEnvVar    = "SNS_AWS_REGION"
)

const (
	AwsAccessKeyIdSuffix     = "AWS_ACCESS_KEY_ID"
	AwsSecretAccessKeySuffix = "AWS_SECRET_ACCESS_KEY"
	ApiKeySuffix             = "API_KEY"
)

const (
	ServerApiKeyEnv = "SERVER_API_KEY"
	DefaultTsState  = "/var/lib/texit/tsstate"
)

const (
	ProvisionWorkflowArnEnvVar   = "PROVISION_NODE_WORKFLOW_ARN"
	DeprovisionWorkflowArnEnvVar = "DEPROVISION_NODE_WORKFLOW_ARN"
	WorkflowAwsAccessKeyEnvVar   = "SFN_AWS_ACCESS_KEY_ID"
	WorkflowAwsSecretKeyEnvVar   = "SFN_AWS_SECRET_ACCESS_KEY"
	WorkflowAwsRegionEnvVar      = "SFN_AWS_REGION"
)

const (
	TailnetApiKeySuffix = "TAILNET_API_KEY"
)

Variables

var (
	ErrMissingDatabaseHost = errors.New("missing database host")
	ErrMissingDatabasePort = errors.New("missing database port")
	ErrMissingDatabaseUser = errors.New("missing database user")
	ErrMissingDatabasePass = errors.New("missing database pass")
	ErrMissingDatabaseName = errors.New("missing database name")
)

var (
	ErrMissingNotifierBroker   = errors.New("missing notifier broker")
	ErrMissingNotifierTopic    = errors.New("missing notifier topic")
	ErrMissiningNotifierRegion = errors.New("missing notifier region")
)

var (
	ErrMissingProviderAwsAccessKey = fmt.Errorf("missing provider access key")
	ErrMissingProviderAwsSecretKey = fmt.Errorf("missing provider secret key")
	ErrMissingApiKey               = fmt.Errorf("missing api key")
	ErrMissingProviderName         = fmt.Errorf("missing provider name")
)

var (
	ErrMissingTailnetType            = errors.New("missing tailnet type")
	ErrMissingTailnet                = errors.New("missing tailnet")
	ErrMissingTailnetApiKey          = errors.New("missing tailnet api key")
	ErrMissingUser                   = errors.New("missing headscale user")
	ErrMissingHeadscaleControlServer = errors.New("missing headscale control server")
)

Types

type Config

type Config struct {
	LogLevel  string            `yaml:"logLevel"`
	Server    *ServerConfig     `yaml:"server"`
	Tailnets  []*TailnetConfig  `yaml:"tailnets"`
	Database  *DatabaseConfig   `yaml:"database"`
	Providers []*ProviderConfig `yaml:"providers"`
	Notifiers []*NotifierConfig `yaml:"notifiers"`
	Workflow  *WorkflowConfig   `yaml:"workflow"`
}

func LoadFromData

func LoadFromData(data []byte) (*Config, error)

func LoadFromFile

func LoadFromFile(path string) (*Config, error)

Loads the application config from a file at the specified path.

type DatabaseConfig

type DatabaseConfig struct {
	// The database engine to use
	Engine DatabaseEngine `yaml:"engine"`
	// The host of the database
	Host string `yaml:"host"`
	// The port of the database
	Port int `yaml:"port"`
	// The username to connect to the database
	Username string `yaml:"username"`
	// The password to connect to the database
	Password string `yaml:"password"`
	// The name of the database
	Database string `yaml:"database"`
	// Location of the database file. For sqlite only
	Location string `yaml:"location"`
	// Whether to use SSL for the connection
	Ssl bool `yaml:"ssl"`
	// The region to use for a ddb table
	Region string `yaml:"region"`
	// The access key to use for a ddb table
	AccessKey string `yaml:"accessKey"`
	// The secret key to use for a ddb table
	SecretKey string `yaml:"secretKey"`
}

Configuration for the database

func NewDefaultDatabaseConfig

func NewDefaultDatabaseConfig() *DatabaseConfig

func (*DatabaseConfig) Validate

func (c *DatabaseConfig) Validate() error

type DatabaseEngine

type DatabaseEngine string

const (
	DatabaseEngineSqlite   DatabaseEngine = "sqlite"
	DatabaseEnginePostgres DatabaseEngine = "postgres"
	DatabaseEngineDynamoDb DatabaseEngine = "dynamodb"
)

type NotifierConfig

type NotifierConfig struct {
	// the notifier type
	Type NotifierType `yaml:"type"`
	// the notifier name
	Name string `yaml:"name"`
	// the topic to publish to
	Topic string `yaml:"topic"`
	// username for the notifier
	Username string `yaml:"username"`
	// password for the notifier
	Password string `yaml:"password"`
	// Access key for the notifier
	AccessKey string `yaml:"accessKey"`
	// Secret key for the notifier
	SecretKey string `yaml:"secretKey"`
	// the aws region for the notifier
	Region string `yaml:"region"`
	// The broker for the notifier
	Broker string `yaml:"broker"`
}

Configuration for the notifier

func (*NotifierConfig) Validate

func (c *NotifierConfig) Validate() error

type NotifierType

type NotifierType string

const (
	NotifierTypeMqtt NotifierType = "mqtt"
	NotifierTypeSns  NotifierType = "sns"
)

type ProviderConfig

type ProviderConfig struct {
	// The type of provider, curretly only aws-ecs
	Type ProviderType `yaml:"type"`
	// The access key for the provider. This is only for AWS types.
	AccessKey string `yaml:"accessKey"`
	// The secret key for the provider. This is only for AWS types.
	SecretKey string `yaml:"secretKey"`
	// An api key for the provider.
	ApiKey string `yaml:"apiKey"`
	// The name of the provider.
	Name string `yaml:"name"`
}

Configuration for a provider. Currently only AWS ECS.

func (*ProviderConfig) Validate

func (c *ProviderConfig) Validate() error

func (*ProviderConfig) ValidateHetzner

func (c *ProviderConfig) ValidateHetzner() error

type ProviderType

type ProviderType string

const (
	ProviderTypeAwsEcs  ProviderType = "aws-ecs"
	ProviderTypeAwsEc2  ProviderType = "aws-ec2"
	ProviderTypeLinode  ProviderType = "linode"
	ProviderTypeHetzner ProviderType = "hetzner"
)

func (ProviderType) String

func (t ProviderType) String() string

type ServerConfig

type ServerConfig struct {
	// The address to listen on
	Address string `yaml:"address"`
	// If specified, the server will join the tailnet with the config provided
	Tailnet *tsn.Config `yaml:"tailnet"`
	// A static key to use for the API. If not specified, one will be generated.
	APIKey string `yaml:"apiKey"` //TODO: make this better one day
}

Configuration for the server

func (*ServerConfig) Validate

func (c *ServerConfig) Validate() error

type TailnetConfig

type TailnetConfig struct {
	// The type of tailnet, tailscale or headscale
	Type TailnetType `yaml:"type"`
	// The network of the tailnet. On tailscale this is the network id
	Tailnet string `yaml:"tailnet"`
	// The api token to communicate with the tailnet
	ApiKey string `yaml:"apiKey"`
	// The user to register exist nodes for.
	User string `yaml:"user"`
	// the control server to use. This is require for headscale
	ControlServer string `yaml:"controlServer"`
}

Configuration for the tailnet exit nodes will join

func (*TailnetConfig) Validate

func (c *TailnetConfig) Validate() error

type TailnetType

type TailnetType string // tailscale or headscale

const (
	TailnetTypeTailscale TailnetType = "tailscale"
	TailnetTypeHeadscale TailnetType = "headscale"
)

func (TailnetType) String

func (t TailnetType) String() string

type WorkflowConfig

type WorkflowConfig struct {
	// the workflow type
	Type WorkflowType `yaml:"type"`

	// sfn provision workflow arn
	ProvisionWorkflowArn string `yaml:"provisionWorkflowArn"`
	// sfn deprovision workflow arn
	DeprovisionWorkflowArn string `yaml:"deprovisionWorkflowArn"`
	// Access key to use when calling sfn
	AccessKey string `yaml:"accessKey"`
	// Secret key to use when calling sfn
	SecretKey string `yaml:"secretKey"`
	// The region to use when calling sfn
	Region string `yaml:"region"`
}

Configuration for the notifier

func NewDefaultWorkflowConfig

func NewDefaultWorkflowConfig() *WorkflowConfig

func (*WorkflowConfig) Validate

func (c *WorkflowConfig) Validate() error

type WorkflowType

type WorkflowType string

const (
	WorkflowTypeLocal WorkflowType = "local"
	WorkflowTypeSfn   WorkflowType = "sfn"
)