resources

type AutoEdge interface {
	Next() []ResUID   // call to get list of edges to add
	Test([]bool) bool // call until false
}

type Base interface {
	GetName() string // can't be named "Name()" because of struct field
	SetName(string)
	SetKind(string)
	Kind() string
	Meta() *MetaParams
	Events() chan event.Event
	AssociateData(converger.Converger)
	IsWatching() bool
	SetWatching(bool)
	GetState() ResState
	SetState(ResState)
	DoSend(chan event.Event, string) (bool, error)
	SendEvent(event.EventName, bool, bool) bool
	ReadEvent(*event.Event) (bool, bool) // TODO: optional here?
	GroupCmp(Res) bool                   // TODO: is there a better name for this?
	GroupRes(Res) error                  // group resource (arg) into self
	IsGrouped() bool                     // am I grouped?
	SetGrouped(bool)                     // set grouped bool
	GetGroup() []Res                     // return everyone grouped inside me
	SetGroup([]Res)
}

type BaseRes struct {
	Name       string     `yaml:"name"`
	MetaParams MetaParams `yaml:"meta"` // struct of all the metaparams
	// contains filtered or unexported fields
}

type BaseUID struct {
	// contains filtered or unexported fields
}

type ExecRes struct {
	BaseRes    `yaml:",inline"`
	State      string `yaml:"state"`      // state: exists/present?, absent, (undefined?)
	Cmd        string `yaml:"cmd"`        // the command to run
	Shell      string `yaml:"shell"`      // the (optional) shell to use to run the cmd
	Timeout    int    `yaml:"timeout"`    // the cmd timeout in seconds
	WatchCmd   string `yaml:"watchcmd"`   // the watch command to run
	WatchShell string `yaml:"watchshell"` // the (optional) shell to use to run the watch cmd
	IfCmd      string `yaml:"ifcmd"`      // the if command to run
	IfShell    string `yaml:"ifshell"`    // the (optional) shell to use to run the if cmd
	PollInt    int    `yaml:"pollint"`    // the poll interval for the ifcmd
}

type ExecUID struct {
	BaseUID
	Cmd   string
	IfCmd string
}

type FileInfo struct {
	os.FileInfo        // embed
	AbsPath     string // smart variant
	RelPath     string // smart variant
}

type FileRes struct {
	BaseRes  `yaml:",inline"`
	Path     string `yaml:"path"` // path variable (should default to name)
	Dirname  string `yaml:"dirname"`
	Basename string `yaml:"basename"`
	Content  string `yaml:"content"` // FIXME: how do you describe: "leave content alone" - state = "create" ?
	Source   string `yaml:"source"`  // file path for source content
	State    string `yaml:"state"`   // state: exists/present?, absent, (undefined?)
	Recurse  bool   `yaml:"recurse"`
	Force    bool   `yaml:"force"`
	// contains filtered or unexported fields
}

type FileResAutoEdges struct {
	// contains filtered or unexported fields
}

type FileUID struct {
	BaseUID
	// contains filtered or unexported fields
}

type MetaParams struct {
	AutoEdge  bool `yaml:"autoedge"`  // metaparam, should we generate auto edges? // XXX: should default to true
	AutoGroup bool `yaml:"autogroup"` // metaparam, should we auto group? // XXX: should default to true
	Noop      bool `yaml:"noop"`
	// NOTE: there are separate Watch and CheckApply retry and delay values,
	// but I've decided to use the same ones for both until there's a proper
	// reason to want to do something differently for the Watch errors.
	Retry int16  `yaml:"retry"` // metaparam, number of times to retry on error. -1 for infinite
	Delay uint64 `yaml:"delay"` // metaparam, number of milliseconds to wait between retries
}

type MsgRes struct {
	BaseRes  `yaml:",inline"`
	Body     string            `yaml:"body"`
	Priority string            `yaml:"priority"`
	Fields   map[string]string `yaml:"fields"`
	Journal  bool              `yaml:"journal"` // enable systemd journal output
	Syslog   bool              `yaml:"syslog"`  // enable syslog output
	// contains filtered or unexported fields
}

type MsgUID struct {
	BaseUID
	// contains filtered or unexported fields
}

type NoopRes struct {
	BaseRes `yaml:",inline"`
	Comment string `yaml:"comment"` // extra field for example purposes
}

type NoopUID struct {
	BaseUID
	// contains filtered or unexported fields
}

type PkgRes struct {
	BaseRes          `yaml:",inline"`
	State            string `yaml:"state"`            // state: installed, uninstalled, newest, <version>
	AllowUntrusted   bool   `yaml:"allowuntrusted"`   // allow untrusted packages to be installed?
	AllowNonFree     bool   `yaml:"allownonfree"`     // allow nonfree packages to be found?
	AllowUnsupported bool   `yaml:"allowunsupported"` // allow unsupported packages to be found?
	// contains filtered or unexported fields
}

type PkgResAutoEdges struct {
	// contains filtered or unexported fields
}

type PkgUID struct {
	BaseUID
	// contains filtered or unexported fields
}

type Res interface {
	Base // include everything from the Base interface
	Init() error
	//Validate() error    // TODO: this might one day be added
	GetUIDs() []ResUID            // most resources only return one
	Watch(chan event.Event) error // send on channel to signal process() events
	CheckApply(apply bool) (checkOK bool, err error)
	AutoEdges() AutoEdge
	Compare(Res) bool
	CollectPattern(string) // XXX: temporary until Res collection is more advanced
}

type ResState int

type ResUID interface {
	GetName() string
	Kind() string
	IFF(ResUID) bool

	Reversed() bool // true means this resource happens before the generator
}

type SvcRes struct {
	BaseRes `yaml:",inline"`
	State   string `yaml:"state"`   // state: running, stopped, undefined
	Startup string `yaml:"startup"` // enabled, disabled, undefined
}

type SvcResAutoEdges struct {
	// contains filtered or unexported fields
}

type SvcUID struct {
	// NOTE: there is also a name variable in the BaseUID struct, this is
	// information about where this UID came from, and is unrelated to the
	// information about the resource we're matching. That data which is
	// used in the IFF function, is what you see in the struct fields here.
	BaseUID
	// contains filtered or unexported fields
}

type TimerRes struct {
	BaseRes  `yaml:",inline"`
	Interval int `yaml:"interval"` // Interval : Interval between runs
}

type TimerUID struct {
	BaseUID
	// contains filtered or unexported fields
}

type VirtRes struct {
	BaseRes    `yaml:",inline"`
	URI        string             `yaml:"uri"`       // connection uri, eg: qemu:///session
	State      string             `yaml:"state"`     // running, paused, shutoff
	Transient  bool               `yaml:"transient"` // defined (false) or undefined (true)
	CPUs       uint               `yaml:"cpus"`
	Memory     uint64             `yaml:"memory"` // in KBytes
	Boot       []string           `yaml:"boot"`   // boot order. values: fd, hd, cdrom, network
	Disk       []diskDevice       `yaml:"disk"`
	CDRom      []cdRomDevice      `yaml:"cdrom"`
	Network    []networkDevice    `yaml:"network"`
	Filesystem []filesystemDevice `yaml:"filesystem"`
	// contains filtered or unexported fields
}

type VirtUID struct {
	BaseUID
}