196 lines
3.3 KiB
Go
196 lines
3.3 KiB
Go
package config
|
|
|
|
import (
|
|
"os"
|
|
"strings"
|
|
|
|
lib "git.sr.ht/~cco/go-scopes"
|
|
)
|
|
|
|
// default config
|
|
|
|
type DefaultCfg = defcfg
|
|
|
|
type defcfg struct {
|
|
name string
|
|
actions []lib.ActionConfig
|
|
children []lib.Config
|
|
}
|
|
|
|
func (cfg *defcfg) Name() string {
|
|
return cfg.name
|
|
}
|
|
|
|
func (cfg *defcfg) SetName(n string) {
|
|
cfg.name = n
|
|
}
|
|
|
|
func (cfg *defcfg) Actions() []lib.ActionConfig {
|
|
return cfg.actions
|
|
}
|
|
|
|
func (cfg *defcfg) AddAction(pattern string, specs ...lib.ActionSpec) {
|
|
act := actionConfig(pattern, specs)
|
|
cfg.actions = append(cfg.actions, act)
|
|
}
|
|
|
|
func (cfg *defcfg) Children() []lib.Config {
|
|
return cfg.children
|
|
}
|
|
|
|
func (cfg *defcfg) Add(c ...lib.Config) {
|
|
cfg.children = append(cfg.children, c...)
|
|
}
|
|
|
|
func (cfg *defcfg) Starter() lib.Proc {
|
|
return DefaultStart
|
|
}
|
|
|
|
func (cfg *defcfg) Listener() lib.Proc {
|
|
return DefaultListen
|
|
}
|
|
|
|
func (cfg *defcfg) Step() lib.Step {
|
|
return DefaultStep
|
|
}
|
|
|
|
func (cfg *defcfg) MessageHandler() lib.MessageHandler {
|
|
return DefaultMsgHandler
|
|
}
|
|
|
|
func (cfg *defcfg) DoneHandler() lib.Step {
|
|
return DefaultDoneHandler
|
|
}
|
|
|
|
func Default(name string) lib.Config {
|
|
return &defcfg{
|
|
name: name,
|
|
}
|
|
}
|
|
|
|
// base config
|
|
|
|
type BaseCfg = base
|
|
|
|
type base struct {
|
|
*defcfg
|
|
starter lib.Proc
|
|
listener lib.Proc
|
|
step lib.Step
|
|
msgHandler lib.MessageHandler
|
|
doneHandler lib.Step
|
|
}
|
|
|
|
func (cfg *base) Starter() lib.Proc {
|
|
return cfg.starter
|
|
}
|
|
|
|
func (cfg *base) Listener() lib.Proc {
|
|
return cfg.listener
|
|
}
|
|
|
|
func (cfg *base) Step() lib.Step {
|
|
return cfg.step
|
|
}
|
|
|
|
func (cfg *base) MessageHandler() lib.MessageHandler {
|
|
return cfg.msgHandler
|
|
}
|
|
|
|
func (cfg *base) DoneHandler() lib.Step {
|
|
return cfg.doneHandler
|
|
}
|
|
|
|
// implementation-specific methods and functions
|
|
|
|
func (cfg *base) WithListener(listener lib.Proc) *base {
|
|
cfg.listener = listener
|
|
return cfg
|
|
}
|
|
|
|
func (cfg *base) WithStep(step lib.Step) *base {
|
|
cfg.step = step
|
|
return cfg
|
|
}
|
|
|
|
func (cfg *base) WithMessageHandler(hdlr lib.MessageHandler) *base {
|
|
cfg.msgHandler = hdlr
|
|
return cfg
|
|
}
|
|
|
|
func (cfg *base) WithDoneHandler(hdlr lib.Step) *base {
|
|
cfg.doneHandler = hdlr
|
|
return cfg
|
|
}
|
|
|
|
func Base(name string, starter lib.Proc) *base {
|
|
return &base{
|
|
defcfg: &defcfg{
|
|
name: name,
|
|
},
|
|
starter: starter,
|
|
listener: DefaultListen,
|
|
step: DefaultStep,
|
|
msgHandler: DefaultMsgHandler,
|
|
doneHandler: DefaultDoneHandler,
|
|
}
|
|
}
|
|
|
|
// will be set by core.init()
|
|
var (
|
|
DefaultStart lib.Proc
|
|
DefaultListen lib.Proc
|
|
DefaultStep lib.Step
|
|
DefaultMsgHandler lib.MessageHandler
|
|
DefaultDoneHandler lib.Step
|
|
)
|
|
|
|
// action configuration
|
|
|
|
type action struct {
|
|
pattern lib.Pattern
|
|
specs []lib.ActionSpec
|
|
}
|
|
|
|
func (act *action) Pattern() lib.Pattern {
|
|
return act.pattern
|
|
}
|
|
|
|
func (act *action) Specs() []lib.ActionSpec {
|
|
return act.specs
|
|
}
|
|
|
|
func actionConfig(pat string, specs []lib.ActionSpec) *action {
|
|
return &action{
|
|
pattern: pattern(strings.Split(pat, "|")),
|
|
specs: specs,
|
|
}
|
|
}
|
|
|
|
type pattern []string
|
|
|
|
func (p pattern) String() string {
|
|
return strings.Join(p, "|")
|
|
}
|
|
|
|
func (p pattern) Slice() []string {
|
|
return []string(p)
|
|
}
|
|
|
|
func Pattern(p ...string) lib.Pattern {
|
|
return pattern(p)
|
|
}
|
|
|
|
// overridable settings
|
|
|
|
type Settings map[string]string
|
|
|
|
func (s Settings) Use(value, key string) string {
|
|
if v, ok := os.LookupEnv("SCOPES_" + strings.ToUpper(key)); ok {
|
|
return v
|
|
}
|
|
if v, ok := s[key]; ok {
|
|
return v
|
|
}
|
|
return value
|
|
}
|