func New(cfg config.Config) *Server {
m := machine.New(cfg.BootId, cfg.PublicIP, cfg.Metadata())
m.RefreshState()
regClient := etcd.NewClient(cfg.EtcdServers)
regClient.SetConsistency(etcd.STRONG_CONSISTENCY)
r := registry.New(regClient)
eb := event.NewEventBus()
eb.Listen()
eventClient := etcd.NewClient(cfg.EtcdServers)
eventClient.SetConsistency(etcd.STRONG_CONSISTENCY)
es := registry.NewEventStream(eventClient)
a, err := agent.New(r, eb, m, cfg.AgentTTL, cfg.UnitPrefix)
if err != nil {
//TODO: return this as an error object rather than panicking
panic(err)
}
e := engine.New(r, eb, m)
return &Server{a, e, m, r, eb, es}
}
func newTestMachine(region string) *machine.Machine {
metadata := map[string]string{
"region": region,
}
state := machine.MachineState{Metadata: metadata}
return machine.New(state)
}
func New(cfg config.Config) *Server {
m := machine.New(cfg.BootId, cfg.PublicIP, cfg.Metadata())
m.RefreshState()
regClient := etcd.NewClient(cfg.EtcdServers)
regClient.SetConsistency(etcd.STRONG_CONSISTENCY)
r := registry.New(regClient)
eb := event.NewEventBus()
eb.Listen()
eventClient := etcd.NewClient(cfg.EtcdServers)
eventClient.SetConsistency(etcd.STRONG_CONSISTENCY)
es := registry.NewEventStream(eventClient, r)
var verifier *sign.SignatureVerifier
if cfg.VerifyUnits {
var err error
verifier, err = sign.NewSignatureVerifierFromAuthorizedKeysFile(cfg.AuthorizedKeysFile)
if err != nil {
log.Errorln("Failed to get any key from authorized key file in verify_units mode:", err)
verifier = sign.NewSignatureVerifier()
}
}
a, err := agent.New(r, eb, m, cfg.AgentTTL, cfg.UnitPrefix, verifier)
if err != nil {
//TODO: return this as an error object rather than panicking
panic(err)
}
e := engine.New(r, eb, m)
return &Server{a, e, m, r, eb, es}
}
func TestEventBusNoDispatch(t *testing.T) {
evchan := make(chan Event)
bus := NewEventBus()
bus.AddListener("test", machine.New("X", "", make(map[string]string, 0)), &TestListener{evchan})
bus.Listen()
defer bus.Stop()
go func() {
ev := Event{"EventTypeTwo", "payload", machine.New("Y", "", make(map[string]string, 0))}
bus.Channel <- &ev
ev = Event{"EventTypeOne", "payload", machine.New("Y", "", make(map[string]string, 0))}
bus.Channel <- &ev
}()
recv := <-evchan
if recv.Type != "EventTypeOne" {
t.Fatalf("handler received unexpected event")
}
}
func TestAbleToRunConditionMachineIDMismatch(t *testing.T) {
u := unit.NewUnit(`[X-Fleet]
X-ConditionMachineID=XYZ
`)
job := job.NewJob("example.service", *u)
mach := machine.New(machine.MachineState{ID: "123"})
agent := Agent{machine: mach, state: NewState()}
if agent.AbleToRun(job) {
t.Fatalf("Agent should not be able to run job")
}
}
func TestAbleToRunConditionMachineBootIDMismatch(t *testing.T) {
uf := unit.NewSystemdUnitFile(`[X-Fleet]
X-ConditionMachineBootID=XYZ
`)
payload := job.NewJobPayload("example.service", *uf)
job := job.NewJob("example.service", make(map[string][]string, 0), payload, nil)
mach := machine.New("123", "", make(map[string]string, 0))
agent := Agent{machine: mach, state: NewState()}
if agent.AbleToRun(job) {
t.Fatalf("Agent should not be able to run job")
}
}
func TestEventBus(t *testing.T) {
evchan := make(chan Event)
bus := NewEventBus()
bus.AddListener("test", machine.New("X", "", make(map[string]string, 0)), &TestListener{evchan})
bus.Listen()
defer bus.Stop()
ev := Event{"EventTypeOne", "payload", machine.New("Y", "", make(map[string]string, 0))}
bus.Channel <- &ev
select {
case <-time.After(time.Second):
t.Fatalf("Failed to dispatch event within a second")
case recv := <-evchan:
if recv.Payload.(string) != "payload" {
t.Error("event payload is incorrect")
}
if recv.Context.(*machine.Machine).State().BootID != "Y" {
t.Error("event context is incorrect")
}
}
}
func newMachineFromConfig(cfg config.Config) (*machine.Machine, error) {
state := machine.MachineState{
PublicIP: cfg.PublicIP,
Metadata: cfg.Metadata(),
Version: version.Version,
}
mach := machine.New(state)
mach.RefreshState()
if mach.State().ID == "" {
return nil, errors.New("unable to determine local machine ID")
}
return mach, nil
}