func (a *ASuite) TestAdvertiserAdvertisesUpdatedID(c *C) { mbus := mock_cfmessagebus.NewMockMessageBus() config := basil.Config{ AdvertiseInterval: 100 * time.Millisecond, } advertisements := make(chan []byte) mbus.Subscribe("ssh.advertise", func(msg []byte) { advertisements <- msg }) advertiser := NewAdvertiser(config) advertiser.Update(&State{ID: "some-unique-id"}) advertiser.AdvertisePeriodically(mbus) msg1 := waitReceive(advertisements, 1*time.Second) c.Assert(string(msg1), Equals, `{"id":"some-unique-id"}`) advertiser.Update(&State{ID: "some-other-unique-id"}) msg2 := waitReceive(advertisements, 1*time.Second) c.Assert(string(msg2), Equals, `{"id":"some-other-unique-id"}`) }
func (s *RSuite) TestRouterClientGreeting(c *C) { mbus := mock_cfmessagebus.NewMockMessageBus() routerClient := NewRouterClient("1.2.3.4", mbus) times := make(chan time.Time) routerClient.Periodically(func() { times <- time.Now() }) mbus.RespondToChannel("router.greet", func([]byte) []byte { return []byte(`{"minimumRegisterIntervalInSeconds":1}`) }) err := routerClient.Greet() c.Assert(err, IsNil) time1 := timedReceive(times, 2*time.Second) c.Assert(time1, NotNil) time2 := timedReceive(times, 2*time.Second) c.Assert(time2, NotNil) c.Assert((*time2).Sub(*time1) >= 1*time.Second, Equals, true) }
func (s *SRSuite) TestPeriodicRegistration(c *C) { mbus := mock_cfmessagebus.NewMockMessageBus() routerClient := basil.NewRouterClient("1.2.3.4", mbus) registrar := NewRegistrar(routerClient) registrar.Update(&State{ ID: "foo", Sessions: map[string]Session{ "abc": Session{ Port: 123, }, }, }) registered := make(chan time.Time) mbus.Subscribe("router.register", func(msg []byte) { registered <- time.Now() }) mbus.RespondToChannel("router.greet", func([]byte) []byte { return []byte(`{"minimumRegisterIntervalInSeconds":1}`) }) err := registrar.RegisterPeriodically() c.Assert(err, IsNil) time1 := timedReceive(registered, 2*time.Second) c.Assert(time1, NotNil) time2 := timedReceive(registered, 2*time.Second) c.Assert(time2, NotNil) c.Assert((*time2).Sub(*time1) >= 1*time.Second, Equals, true) }
func (a *ASuite) TestAdvertiserAdvertisesPeriodically(c *C) { mbus := mock_cfmessagebus.NewMockMessageBus() config := basil.Config{ AdvertiseInterval: 100 * time.Millisecond, } advertisements := make(chan []byte) mbus.Subscribe("ssh.advertise", func(msg []byte) { advertisements <- msg }) advertiser := NewAdvertiser(config) advertiser.Update(&State{ID: "some-unique-id"}) advertiser.AdvertisePeriodically(mbus) msg1 := waitReceive(advertisements, 1*time.Second) c.Assert(msg1, NotNil) time1 := time.Now() msg2 := waitReceive(advertisements, 1*time.Second) c.Assert(msg2, NotNil) time2 := time.Now() c.Assert(time2.Sub(time1) >= 100*time.Millisecond, Equals, true) }
func (s *SRSuite) TestRegistrarUpdateUnregisters(c *C) { mbus := mock_cfmessagebus.NewMockMessageBus() routerClient := basil.NewRouterClient("1.2.3.4", mbus) unregistered := make(chan []byte) mbus.Subscribe("router.unregister", func(msg []byte) { unregistered <- msg }) registrar := NewRegistrar(routerClient) registrar.Update(&State{ ID: "foo", Sessions: map[string]Session{ "abc": Session{ Port: 123, }, }, }) registrar.Update(&State{ ID: "foo", Sessions: map[string]Session{}, }) select { case msg := <-unregistered: c.Assert(string(msg), Equals, `{"uris":["abc"],"host":"1.2.3.4","port":123}`) case <-time.After(500 * time.Millisecond): c.Error("did not receive a router.register!") } }
func (s *WSuite) TestReactingToRouterStart(c *C) { watcher := basil.NewStateWatcher(s.stateFile.Name()) mbus := mock_cfmessagebus.NewMockMessageBus() err := ioutil.WriteFile( s.stateFile.Name(), []byte(`{"id":"abc","sessions":{"abc":{"port":123,"container":"foo"}}}`), 0644, ) c.Assert(err, IsNil) err = ReactTo(watcher, mbus, basil.DefaultConfig) c.Assert(err, IsNil) registered := make(chan time.Time) mbus.Subscribe("router.register", func(msg []byte) { registered <- time.Now() }) mbus.Publish("router.start", []byte(`{"minimumRegisterIntervalInSeconds":1}`)) time1 := timedReceive(registered, 2*time.Second) c.Assert(time1, NotNil) time2 := timedReceive(registered, 2*time.Second) c.Assert(time2, NotNil) c.Assert((*time2).Sub(*time1) >= 1*time.Second, Equals, true) }
func (s *WSuite) TestHandlingInitialState(c *C) { watcher := basil.NewStateWatcher(s.stateFile.Name()) mbus := mock_cfmessagebus.NewMockMessageBus() err := ioutil.WriteFile( s.stateFile.Name(), []byte(`{"id":"abc","sessions":{"abc":{"port":123,"container":"foo"}}}`), 0644, ) c.Assert(err, IsNil) registered := make(chan []byte) mbus.Subscribe("router.register", func(msg []byte) { registered <- msg }) err = ReactTo(watcher, mbus, basil.DefaultConfig) c.Assert(err, IsNil) select { case msg := <-registered: c.Assert(string(msg), Equals, `{"uris":["abc"],"host":"127.0.0.1","port":123}`) case <-time.After(500 * time.Millisecond): c.Error("did not receive a router.register!") } }
func (s *WSuite) TestReactorSendsAdvertisements(c *C) { watcher := basil.NewStateWatcher(s.stateFile.Name()) mbus := mock_cfmessagebus.NewMockMessageBus() err := ioutil.WriteFile( s.stateFile.Name(), []byte(`{"id":"abc","sessions":{}}`), 0644, ) c.Assert(err, IsNil) config := basil.DefaultConfig config.AdvertiseInterval = 100 * time.Millisecond err = ReactTo(watcher, mbus, config) c.Assert(err, IsNil) advertised := make(chan time.Time) mbus.Subscribe("ssh.advertise", func(msg []byte) { advertised <- time.Now() }) time1 := timedReceive(advertised, 1*time.Second) c.Assert(time1, NotNil) time2 := timedReceive(advertised, 1*time.Second) c.Assert(time2, NotNil) c.Assert((*time2).Sub(*time1) >= 100*time.Millisecond, Equals, true) }
func (a *ASuite) TestAdvertiserDoesNotAdvertiseWithoutState(c *C) { mbus := mock_cfmessagebus.NewMockMessageBus() config := basil.Config{ AdvertiseInterval: 100 * time.Millisecond, } advertisements := make(chan []byte) mbus.Subscribe("ssh.advertise", func(msg []byte) { advertisements <- msg }) advertiser := NewAdvertiser(config) advertiser.AdvertisePeriodically(mbus) msg1 := waitReceive(advertisements, 1*time.Second) c.Assert(msg1, IsNil) }
func (s *RSuite) TestRouterClientUnregistering(c *C) { mbus := mock_cfmessagebus.NewMockMessageBus() routerClient := NewRouterClient("1.2.3.4", mbus) registered := make(chan []byte) mbus.Subscribe("router.unregister", func(msg []byte) { registered <- msg }) routerClient.Unregister(123, []string{"abc"}) select { case msg := <-registered: c.Assert(string(msg), Equals, `{"uris":["abc"],"host":"1.2.3.4","port":123}`) case <-time.After(500 * time.Millisecond): c.Error("did not receive a router.unregister!") } }
func (s *WSuite) TestReactorSendsAdvertisementsWithUpdatedID(c *C) { watcher := basil.NewStateWatcher(s.stateFile.Name()) mbus := mock_cfmessagebus.NewMockMessageBus() err := ioutil.WriteFile( s.stateFile.Name(), []byte(`{"id":"abc","sessions":{}}`), 0644, ) c.Assert(err, IsNil) config := basil.DefaultConfig config.AdvertiseInterval = 100 * time.Millisecond err = ReactTo(watcher, mbus, config) c.Assert(err, IsNil) advertised := make(chan []byte) mbus.Subscribe("ssh.advertise", func(msg []byte) { advertised <- msg }) msg1 := waitReceive(advertised, 2*time.Second) c.Assert(string(msg1), Equals, `{"id":"abc"}`) err = ioutil.WriteFile( s.stateFile.Name(), []byte(`{"id":"def","sessions":{}}`), 0644, ) c.Assert(err, IsNil) msg2 := waitReceive(advertised, 2*time.Second) c.Assert(string(msg2), Equals, `{"id":"def"}`) }
"version":"123", "indices":[1,2], "running":{"123":2}, "flapping":false }` jsonStopMessage := `{ "droplet":"abc", "last_updated":1377816348, "version":"123", "instances":{"xyz":"123", "uvw":"123"}, "running":{"123":2} }` BeforeEach(func() { fakeMessageBus = mock_cfmessagebus.NewMockMessageBus() listener = NewStartStopListener(fakeMessageBus) }) Describe("when a start message arrives", func() { It("adds a start message to its list", func() { expectedStart := StartMessage{ AppGuid: "abc", LastUpdated: 1377816348, AppVersion: "123", IndicesToStart: []int{1, 2}, RunningInstancesByVersion: map[string]int{"123": 2}, Flapping: false, } fakeMessageBus.PublishSync("health.start", []byte(jsonStartMessage))