types

Documentation

Index

• Constants
• type DependsOnConfig
• type DeprecationParams
• type Environment
• type LogRotationConfig
• type LoggerConfig
• type MemoryState
• type ProcessConfig
  • func (p *ProcessConfig) CalculateReplicaName() string
  • func (p *ProcessConfig) GetDependencies() []string
  • func (p *ProcessConfig) IsDeferred() bool
• type ProcessDependency
• type ProcessFunc
• type ProcessPorts
• type ProcessState
  • func NewProcessState(proc *ProcessConfig) *ProcessState
• type Processes
• type ProcessesState
• type Project
  • func (p *Project) GetDependenciesOrderNames() ([]string, error)
  • func (p *Project) GetLexicographicProcessNames() ([]string, error)
  • func (p *Project) GetProcesses(names ...string) ([]ProcessConfig, error)
  • func (p *Project) WithProcesses(names []string, fn ProcessFunc) error
• type ProjectState
• type RestartPolicyConfig
• type ShutDownParams
• type Vars

Constants

const (
	RestartPolicyAlways        = "always"
	RestartPolicyOnFailure     = "on_failure"
	RestartPolicyExitOnFailure = "exit_on_failure"
	RestartPolicyNo            = "no"
)

const (
	ProcessStateDisabled    = "Disabled"
	ProcessStateForeground  = "Foreground"
	ProcessStatePending     = "Pending"
	ProcessStateRunning     = "Running"
	ProcessStateLaunching   = "Launching"
	ProcessStateLaunched    = "Launched"
	ProcessStateRestarting  = "Restarting"
	ProcessStateTerminating = "Terminating"
	ProcessStateCompleted   = "Completed"
	ProcessStateSkipped     = "Skipped"
	ProcessStateError       = "Error"
)

const (
	ProcessHealthReady    = "Ready"
	ProcessHealthNotReady = "Not Ready"
	ProcessHealthUnknown  = "N/A"
)

const (
	// ProcessConditionCompleted is the type for waiting until a process has completed (any exit code).
	ProcessConditionCompleted = "process_completed"

	// ProcessConditionCompletedSuccessfully is the type for waiting until a process has completed successfully (exit code 0).
	ProcessConditionCompletedSuccessfully = "process_completed_successfully"

	// ProcessConditionHealthy is the type for waiting until a process is healthy.
	ProcessConditionHealthy = "process_healthy"

	// ProcessConditionStarted is the type for waiting until a process has started (default).
	ProcessConditionStarted = "process_started"
)

const DefaultNamespace = "default"

Types

type DependsOnConfig

type DependsOnConfig map[string]ProcessDependency

type DeprecationParams

type DeprecationParams struct {
	StartTime time.Time
}

type Environment

type Environment []string

type LogRotationConfig

type LogRotationConfig struct {
	// Directory to log to when filelogging is enabled
	Directory string `yaml:"directory"`
	// Filename is the name of the logfile which will be placed inside the directory
	Filename string `yaml:"filename"`
	// MaxSize the max size in MB of the logfile before it's rolled
	MaxSize int `yaml:"max_size_mb"`
	// MaxBackups the max number of rolled files to keep
	MaxBackups int `yaml:"max_backups"`
	// MaxAge the max age in days to keep a logfile
	MaxAge int `yaml:"max_age_days"`
	// Compress determines if the rotated log files should be compressed
	// using gzip. The default is not to perform compression.
	Compress bool `json:"compress" yaml:"compress"`
}

LogRotationConfig is the configuration for logging

type LoggerConfig

type LoggerConfig struct {
	// Rotation is the configuration for logging rotation
	Rotation *LogRotationConfig `yaml:"rotation"`
	// FieldsOrder is the order in which fields are logged
	FieldsOrder []string `yaml:"fields_order"`
	// DisableJSON disables log JSON formatting
	DisableJSON bool `yaml:"disable_json"`
	// TimestampFormat is the format of the timestamp
	TimestampFormat string `yaml:"timestamp_format"`
	// NoColor disables coloring
	NoColor bool `yaml:"no_color"`
	// NoMetadata disables log metadata (process, replica)
	NoMetadata bool `yaml:"no_metadata"`
	// AddTimestamp adds timestamp to log
	AddTimestamp bool `yaml:"add_timestamp"`
	// FlushEachLine flushes the logger on each line
	FlushEachLine bool `yaml:"flush_each_line"`
}

type MemoryState

type MemoryState struct {
	Allocated      uint64 `json:"allocated"`
	TotalAllocated uint64 `json:"totalAllocated"`
	SystemMemory   uint64 `json:"systemMemory"`
	GcCycles       uint32 `json:"gcCycles"`
}

type ProcessConfig

type ProcessConfig struct {
	Name              string
	Disabled          bool                   `yaml:"disabled,omitempty"`
	IsDaemon          bool                   `yaml:"is_daemon,omitempty"`
	Command           string                 `yaml:"command"`
	Entrypoint        []string               `yaml:"entrypoint"`
	LogLocation       string                 `yaml:"log_location,omitempty"`
	LoggerConfig      *LoggerConfig          `yaml:"log_configuration,omitempty"`
	Environment       Environment            `yaml:"environment,omitempty"`
	RestartPolicy     RestartPolicyConfig    `yaml:"availability,omitempty"`
	DependsOn         DependsOnConfig        `yaml:"depends_on,omitempty"`
	LivenessProbe     *health.Probe          `yaml:"liveness_probe,omitempty"`
	ReadinessProbe    *health.Probe          `yaml:"readiness_probe,omitempty"`
	ShutDownParams    ShutDownParams         `yaml:"shutdown,omitempty"`
	DisableAnsiColors bool                   `yaml:"disable_ansi_colors,omitempty"`
	WorkingDir        string                 `yaml:"working_dir"`
	Namespace         string                 `yaml:"namespace"`
	Replicas          int                    `yaml:"replicas"`
	Extensions        map[string]interface{} `yaml:",inline"`
	Description       string                 `yaml:"description,omitempty"`
	Vars              Vars                   `yaml:"vars"`
	IsForeground      bool                   `yaml:"is_foreground"`
	ReplicaNum        int
	ReplicaName       string
	Executable        string
	Args              []string
}

func (*ProcessConfig) CalculateReplicaName

func (p *ProcessConfig) CalculateReplicaName() string

func (*ProcessConfig) GetDependencies

func (p *ProcessConfig) GetDependencies() []string

func (*ProcessConfig) IsDeferred

func (p *ProcessConfig) IsDeferred() bool

type ProcessDependency

type ProcessDependency struct {
	Condition  string                 `yaml:",omitempty"`
	Extensions map[string]interface{} `yaml:",inline"`
}

type ProcessFunc

type ProcessFunc func(process ProcessConfig) error

type ProcessPorts

type ProcessPorts struct {
	Name     string   `json:"name"`
	TcpPorts []uint16 `json:"tcp_ports"`
	UdpPorts []uint16 `json:"udp_ports"`
}

type ProcessState

type ProcessState struct {
	Name       string        `json:"name"`
	Namespace  string        `json:"namespace"`
	Status     string        `json:"status"`
	SystemTime string        `json:"system_time"`
	Age        time.Duration `json:"age"`
	Health     string        `json:"is_ready"`
	Restarts   int           `json:"restarts"`
	ExitCode   int           `json:"exit_code"`
	Pid        int           `json:"pid"`
	IsRunning  bool
}

func NewProcessState

func NewProcessState(proc *ProcessConfig) *ProcessState

type Processes

type Processes map[string]ProcessConfig

type ProcessesState

type ProcessesState struct {
	States []ProcessState `json:"data"`
}

type Project

type Project struct {
	Version      string               `yaml:"version"`
	LogLocation  string               `yaml:"log_location,omitempty"`
	LogLevel     string               `yaml:"log_level,omitempty"`
	LogLength    int                  `yaml:"log_length,omitempty"`
	LoggerConfig *LoggerConfig        `yaml:"log_configuration,omitempty"`
	LogFormat    string               `yaml:"log_format,omitempty"`
	Processes    Processes            `yaml:"processes"`
	Environment  Environment          `yaml:"environment,omitempty"`
	ShellConfig  *command.ShellConfig `yaml:"shell,omitempty"`
	IsStrict     bool                 `yaml:"is_strict"`
	Vars         Vars                 `yaml:"vars"`
	FileNames    []string
}

func (*Project) GetDependenciesOrderNames

func (p *Project) GetDependenciesOrderNames() ([]string, error)

func (*Project) GetLexicographicProcessNames

func (p *Project) GetLexicographicProcessNames() ([]string, error)

func (*Project) GetProcesses

func (p *Project) GetProcesses(names ...string) ([]ProcessConfig, error)

func (*Project) WithProcesses

func (p *Project) WithProcesses(names []string, fn ProcessFunc) error

WithProcesses run ProcessFunc on each Process and dependencies in dependency order

type ProjectState

type ProjectState struct {
	FileNames         []string      `json:"fileNames"`
	UpTime            time.Duration `json:"upTime"`
	StartTime         time.Time     `json:"startTime"`
	ProcessNum        int           `json:"processNum"`
	RunningProcessNum int           `json:"runningProcessNum"`
	UserName          string        `json:"userName"`
	HostName          string        `json:"hostName"`
	Version           string        `json:"version"`
	MemoryState       *MemoryState  `json:"memoryState,omitempty"`
}

type RestartPolicyConfig

type RestartPolicyConfig struct {
	Restart        string `yaml:",omitempty"`
	BackoffSeconds int    `yaml:"backoff_seconds,omitempty"`
	MaxRestarts    int    `yaml:"max_restarts,omitempty"`
	ExitOnEnd      bool   `yaml:"exit_on_end,omitempty"`
}

type ShutDownParams

type ShutDownParams struct {
	ShutDownCommand string `yaml:"command,omitempty"`
	ShutDownTimeout int    `yaml:"timeout_seconds,omitempty"`
	Signal          int    `yaml:"signal,omitempty"`
	ParentOnly      bool   `yaml:"parent_only,omitempty"`
}

type Vars

type Vars map[string]any