quantum

type Acceptor interface {
	Accept(net.Listener) error
	IsShutdown() chan struct{}
	io.Closer
}

type Agent interface {
	Acceptor
	Registry
	Start() error
}

type AgentConn interface {
	mux.Server
	Logs() chan string
	Signals() chan os.Signal
	Lager() lager.Lager
}

type BasicCommunicator struct {
	sync.WaitGroup
	// contains filtered or unexported fields
}

type BasicExecutor struct {
	Steps []Step
}

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

type BasicRunner struct{}

type BasicUI struct {
	lager.Lager
	// contains filtered or unexported fields
}

type Client interface {
	Dial(address string) (ClientConn, error)
	DialTimeout(address string, time time.Duration) (ClientConn, error)
}

type ClientConn interface {
	mux.Client
	Run(request Request) error
	Logs() <-chan string
	Signals() chan<- os.Signal
}

type ClientResolver interface {
	Resolve(request ResolveRequest) (ClientConn, error)
}

type ClientResolverConfig struct {
	Config *Config
	Server string
}

type Communicator interface {
	Communicate(exitCh chan struct{})
	Add(num int)
	Done()
	Wait()
}

type Config struct {
	Lager lager.Lager
	Pool  mux.Pool
}

type ConnConfig struct {
	Timeout time.Duration
	*Config
}

type Executor interface {
	Execute(statebag StateBag) error
}

type Job interface {
	// Used to match requests to jobs
	Routable
	Configure([]byte) error
	Run(AgentConn) error
}

type MultiClientResolver struct {
	Resolvers []ClientResolver
}

type MultiRegistrator struct {
	Registrators []Registrator
}

type Registrator interface {
	Register(port int, reg Registry) error
	Deregister() error
}

type Registry interface {
	Add(job Job)
	Get(request Request) (Job, error)
	Types() (types []string)
}

type Request struct {
	Type string
	Data []byte
}

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

type ResolveRequest struct {
	Agent string
	Type  string
}

type Routable interface {
	Type() string
}

type Runner interface {
	Run(string, chan<- string, <-chan os.Signal) error
}

type StateBag struct {
	multistep.StateBag
}

type Step interface {
	Run(state StateBag) error
	Cleanup(state StateBag)
}

type StepsJob interface {
	Job
	Steps() []Step
}

type UI interface {
	lager.Lager
	Client(log string)
	Both(log string)
}