func (s *RCSuite) TestRouterClientGreeting(c *C) { mbus := fakeyagnats.New() routerClient := NewCFRouterClient("1.2.3.4", mbus) routerClient.Register(123, "abc") err := routerClient.Greet() c.Assert(err, IsNil) greetMsg := mbus.PublishedMessages("router.greet")[0] greetCallback := mbus.Subscriptions(greetMsg.ReplyTo)[0] greetCallback.Callback(&yagnats.Message{ Payload: []byte(`{"minimumRegisterIntervalInSeconds":1}`), }) c.Assert(len(mbus.PublishedMessages("router.register")), Equals, 1) time.Sleep(600 * time.Millisecond) c.Assert(len(mbus.PublishedMessages("router.register")), Equals, 1) time.Sleep(600 * time.Millisecond) c.Assert(len(mbus.PublishedMessages("router.register")), Equals, 2) time.Sleep(600 * time.Millisecond) c.Assert(len(mbus.PublishedMessages("router.register")), Equals, 2) time.Sleep(600 * time.Millisecond) c.Assert(len(mbus.PublishedMessages("router.register")), Equals, 3) }
func (s *RCSuite) TestRouterClientRouterStartHandling(c *C) { mbus := fakeyagnats.New() routerClient := NewCFRouterClient("1.2.3.4", mbus) err := routerClient.Greet() c.Assert(err, IsNil) startCallback := mbus.Subscriptions["router.start"][0] startCallback.Callback(&yagnats.Message{ Payload: []byte(`{"minimumRegisterIntervalInSeconds":1}`), }) routerClient.Register(123, "abc") c.Assert(len(mbus.PublishedMessages["router.register"]), Equals, 1) time.Sleep(600 * time.Millisecond) c.Assert(len(mbus.PublishedMessages["router.register"]), Equals, 1) time.Sleep(600 * time.Millisecond) c.Assert(len(mbus.PublishedMessages["router.register"]), Equals, 2) time.Sleep(600 * time.Millisecond) c.Assert(len(mbus.PublishedMessages["router.register"]), Equals, 2) time.Sleep(600 * time.Millisecond) c.Assert(len(mbus.PublishedMessages["router.register"]), Equals, 3) }
func (s *ProxySuite) SetUpTest(c *C) { s.conf = config.DefaultConfig() s.conf.TraceKey = "my_trace_key" s.conf.EndpointTimeout = 500 * time.Millisecond mbus := fakeyagnats.New() s.r = registry.NewCFRegistry(s.conf, mbus) fmt.Printf("Config: %#v", s.conf) s.accessLogFile = new(test_util.FakeFile) accessLog := access_log.NewFileAndLoggregatorAccessLogger(s.accessLogFile, "localhost:9843", "secret", 42) go accessLog.Run() s.p = NewProxy(ProxyArgs{ EndpointTimeout: s.conf.EndpointTimeout, Ip: s.conf.Ip, TraceKey: s.conf.TraceKey, Registry: s.r, Reporter: nullVarz{}, Logger: accessLog, }) ln, err := net.Listen("tcp", "127.0.0.1:0") if err != nil { panic(err) } server := server.Server{Handler: s.p} go server.Serve(ln) s.proxyServer = ln }
func BenchmarkRegister(b *testing.B) { c := config.DefaultConfig() mbus := fakeyagnats.New() r := registry.NewCFRegistry(c, mbus) proxy.NewProxy(proxy.ProxyArgs{ EndpointTimeout: c.EndpointTimeout, Ip: c.Ip, TraceKey: c.TraceKey, Registry: r, Reporter: varz.NewVarz(r), Logger: access_log.CreateRunningAccessLogger(c), }) for i := 0; i < b.N; i++ { str := strconv.Itoa(i) r.Register( route.Uri("bench.vcap.me."+str), &route.Endpoint{ Host: "localhost", Port: uint16(i), }, ) } }
func createNatsClientAndHandler() (client *fakeyagnats.FakeYagnats, handler natsHandler) { settings := boshsettings.Settings{ AgentId: "my-agent-id", Mbus: "nats://*****:*****@127.0.0.1:1234", } client = fakeyagnats.New() handler = newNatsHandler(client, settings) return }
func (s *RCSuite) TestRouterClientUnregistering(c *C) { mbus := fakeyagnats.New() routerClient := NewCFRouterClient("1.2.3.4", mbus) routerClient.Unregister(123, "abc") unregistrations := mbus.PublishedMessages["router.unregister"] c.Assert(len(unregistrations), Not(Equals), 0) c.Assert(string(unregistrations[0].Payload), Equals, `{"uris":["abc"],"host":"1.2.3.4","port":123}`) }
func (s *RCSuite) TestRouterClientRegistering(c *C) { mbus := fakeyagnats.New() routerClient := NewCFRouterClient("1.2.3.4", mbus) routerClient.Register(123, "abc") registrations := mbus.PublishedMessages("router.register") c.Assert(len(registrations), Not(Equals), 0) c.Assert(string(registrations[0].Payload), Equals, `{"uris":["abc"],"host":"1.2.3.4","port":123,"private_instance_id":"`+routerClient.PrivateInstanceId+`"}`) }
func BenchmarkRegister(b *testing.B) { c := config.DefaultConfig() mbus := fakeyagnats.New() r := registry.NewRegistry(c, mbus) p := proxy.NewProxy(c, r, varz.NewVarz(r)) for i := 0; i < b.N; i++ { str := strconv.Itoa(i) p.Register( route.Uri("bench.vcap.me."+str), &route.Endpoint{ Host: "localhost", Port: uint16(i), }, ) } }
func (s *ProxySuite) SetUpTest(c *C) { config := config.DefaultConfig() config.TraceKey = "my_trace_key" config.EndpointTimeout = 500 * time.Millisecond mbus := fakeyagnats.New() s.r = registry.NewRegistry(config, mbus) s.p = NewProxy(config, s.r, nullVarz{}) ln, err := net.Listen("tcp", "127.0.0.1:0") if err != nil { panic(err) } server := server.Server{Handler: s.p} go server.Serve(ln) s.proxyServer = ln }
func (s *RegistrySuite) SetUpTest(c *C) { var configObj *config.Config configObj = config.DefaultConfig() configObj.DropletStaleThreshold = 10 * time.Millisecond s.messageBus = fakeyagnats.New() s.Registry = NewRegistry(configObj, s.messageBus) fooEndpoint = &route.Endpoint{ Host: "192.168.1.1", Port: 1234, ApplicationId: "12345", Tags: map[string]string{ "runtime": "ruby18", "framework": "sinatra", }, } barEndpoint = &route.Endpoint{ Host: "192.168.1.2", Port: 4321, ApplicationId: "54321", Tags: map[string]string{ "runtime": "javascript", "framework": "node", }, } bar2Endpoint = &route.Endpoint{ Host: "192.168.1.3", Port: 1234, ApplicationId: "54321", Tags: map[string]string{ "runtime": "javascript", "framework": "node", }, } }
func buildNatsClientAndHandler(settings boshsettings.Service) (client *fakeyagnats.FakeYagnats, handler natsHandler) { logger := boshlog.NewLogger(boshlog.LEVEL_NONE) client = fakeyagnats.New() handler = newNatsHandler(settings, logger, client) return }
"time" ) var _ = Describe("RouteRegistry", func() { var r *RouteRegistry var messageBus *fakeyagnats.FakeYagnats var fooEndpoint, barEndpoint, bar2Endpoint *route.Endpoint var configObj *config.Config BeforeEach(func() { configObj = config.DefaultConfig() configObj.PruneStaleDropletsInterval = 50 * time.Millisecond configObj.DropletStaleThreshold = 10 * time.Millisecond messageBus = fakeyagnats.New() r = NewRouteRegistry(configObj, messageBus) fooEndpoint = route.NewEndpoint("12345", "192.168.1.1", 1234, "id1", map[string]string{ "runtime": "ruby18", "framework": "sinatra", }) barEndpoint = route.NewEndpoint("54321", "192.168.1.2", 4321, "id2", map[string]string{ "runtime": "javascript", "framework": "node", }) bar2Endpoint = route.NewEndpoint("54321", "192.168.1.3", 1234, "id3", map[string]string{
func main() { seed := time.Now().UnixNano() rand.Seed(seed) flag.Parse() if *version { fmt.Printf("version: %s\ngitSha: %s\nsourceUrl: https://github.com/cloudfoundry/loggregator/tree/%s\n\n", versionNumber, gitSha, gitSha) return } runtime.GOMAXPROCS(runtime.NumCPU()) if *cpuprofile != "" { f, err := os.Create(*cpuprofile) if err != nil { panic(err) } pprof.StartCPUProfile(f) defer func() { pprof.StopCPUProfile() f.Close() }() } if *memprofile != "" { f, err := os.Create(*memprofile) if err != nil { panic(err) } go func() { defer f.Close() ticker := time.NewTicker(time.Second * 1) defer ticker.Stop() for { <-ticker.C pprof.WriteHeapProfile(f) } }() } config, logger := parseConfig(logLevel, configFile, logFilePath) if len(config.NatsHosts) == 0 { logger.Warn("Startup: Did not receive a NATS host - not going to regsiter component") cfcomponent.DefaultYagnatsClientProvider = func(logger *gosteno.Logger, c *cfcomponent.Config) (yagnats.NATSClient, error) { return fakeyagnats.New(), nil } } err := config.Validate(logger) if err != nil { panic(err) } l := New("0.0.0.0", config, logger) cfc, err := cfcomponent.NewComponent( logger, "LoggregatorServer", config.Index, &LoggregatorServerHealthMonitor{}, config.VarzPort, []string{config.VarzUser, config.VarzPass}, l.Emitters(), ) if err != nil { panic(err) } cr := collectorregistrar.NewCollectorRegistrar(config.MbusClient, logger) err = cr.RegisterWithCollector(cfc) if err != nil { logger.Warnf("Unable to register with collector. Err: %v.", err) } go func() { err := cfc.StartMonitoringEndpoints() if err != nil { panic(err) } }() l.Start() logger.Info("Startup: loggregator server started.") killChan := make(chan os.Signal) signal.Notify(killChan, os.Kill, os.Interrupt) for { select { case <-cfcomponent.RegisterGoRoutineDumpSignalChannel(): cfcomponent.DumpGoRoutine() case <-killChan: logger.Info("Shutting down") l.Stop() return } } }
func init() { Describe("natsHandler", func() { var ( settingsService *fakesettings.FakeSettingsService client *fakeyagnats.FakeYagnats logger boshlog.Logger handler boshhandler.Handler ) BeforeEach(func() { settingsService = &fakesettings.FakeSettingsService{ Settings: boshsettings.Settings{ AgentID: "my-agent-id", Mbus: "nats://*****:*****@127.0.0.1:1234", }, } logger = boshlog.NewLogger(boshlog.LevelNone) client = fakeyagnats.New() handler = NewNatsHandler(settingsService, client, logger) }) Describe("Start", func() { It("starts", func() { var receivedRequest boshhandler.Request handler.Start(func(req boshhandler.Request) (resp boshhandler.Response) { receivedRequest = req return boshhandler.NewValueResponse("expected value") }) defer handler.Stop() Expect(client.ConnectedConnectionProvider()).ToNot(BeNil()) Expect(client.SubscriptionCount()).To(Equal(1)) subscriptions := client.Subscriptions("agent.my-agent-id") Expect(len(subscriptions)).To(Equal(1)) expectedPayload := []byte(`{"method":"ping","arguments":["foo","bar"], "reply_to": "reply to me!"}`) subscription := subscriptions[0] subscription.Callback(&yagnats.Message{ Subject: "agent.my-agent-id", Payload: expectedPayload, }) Expect(receivedRequest).To(Equal(boshhandler.Request{ ReplyTo: "reply to me!", Method: "ping", Payload: expectedPayload, })) Expect(client.PublishedMessageCount()).To(Equal(1)) messages := client.PublishedMessages("reply to me!") Expect(len(messages)).To(Equal(1)) Expect(messages[0].Payload).To(Equal([]byte(`{"value":"expected value"}`))) }) It("does not respond if the response is nil", func() { err := handler.Start(func(req boshhandler.Request) (resp boshhandler.Response) { return nil }) Expect(err).ToNot(HaveOccurred()) defer handler.Stop() subscription := client.Subscriptions("agent.my-agent-id")[0] subscription.Callback(&yagnats.Message{ Subject: "agent.my-agent-id", Payload: []byte(`{"method":"ping","arguments":["foo","bar"], "reply_to": "reply to me!"}`), }) Expect(client.PublishedMessageCount()).To(Equal(0)) }) It("responds with an error if the response is bigger than 1MB", func() { err := handler.Start(func(req boshhandler.Request) (resp boshhandler.Response) { // gets inflated by json.Marshal when enveloping size := 0 switch req.Method { case "small": size = 1024*1024 - 12 case "big": size = 1024 * 1024 default: panic("unknown request size") } chars := make([]byte, size) for i := range chars { chars[i] = 'A' } return boshhandler.NewValueResponse(string(chars)) }) Expect(err).ToNot(HaveOccurred()) defer handler.Stop() subscription := client.Subscriptions("agent.my-agent-id")[0] subscription.Callback(&yagnats.Message{ Subject: "agent.my-agent-id", Payload: []byte(`{"method":"small","arguments":[], "reply_to": "fake-reply-to"}`), }) subscription.Callback(&yagnats.Message{ Subject: "agent.my-agent-id", Payload: []byte(`{"method":"big","arguments":[], "reply_to": "fake-reply-to"}`), }) Expect(client.PublishedMessageCount()).To(Equal(1)) messages := client.PublishedMessages("fake-reply-to") Expect(len(messages)).To(Equal(2)) Expect(messages[0].Payload).To(MatchRegexp("value")) Expect(messages[1].Payload).To(Equal([]byte( `{"exception":{"message":"Response exceeded maximum allowed length"}}`))) }) It("can add additional handler funcs to receive requests", func() { var firstHandlerReq, secondHandlerRequest boshhandler.Request handler.Start(func(req boshhandler.Request) (resp boshhandler.Response) { firstHandlerReq = req return boshhandler.NewValueResponse("first-handler-resp") }) defer handler.Stop() handler.RegisterAdditionalFunc(func(req boshhandler.Request) (resp boshhandler.Response) { secondHandlerRequest = req return boshhandler.NewValueResponse("second-handler-resp") }) expectedPayload := []byte(`{"method":"ping","arguments":["foo","bar"], "reply_to": "fake-reply-to"}`) subscription := client.Subscriptions("agent.my-agent-id")[0] subscription.Callback(&yagnats.Message{ Subject: "agent.my-agent-id", Payload: expectedPayload, }) // Expected requests received by both handlers Expect(firstHandlerReq).To(Equal(boshhandler.Request{ ReplyTo: "fake-reply-to", Method: "ping", Payload: expectedPayload, })) Expect(secondHandlerRequest).To(Equal(boshhandler.Request{ ReplyTo: "fake-reply-to", Method: "ping", Payload: expectedPayload, })) // Bosh handler responses were sent Expect(client.PublishedMessageCount()).To(Equal(1)) messages := client.PublishedMessages("fake-reply-to") Expect(len(messages)).To(Equal(2)) Expect(messages[0].Payload).To(Equal([]byte(`{"value":"first-handler-resp"}`))) Expect(messages[1].Payload).To(Equal([]byte(`{"value":"second-handler-resp"}`))) }) It("has the correct connection info", func() { err := handler.Start(func(req boshhandler.Request) (res boshhandler.Response) { return }) Expect(err).ToNot(HaveOccurred()) defer handler.Stop() Expect(client.ConnectedConnectionProvider()).To(Equal(&yagnats.ConnectionInfo{ Addr: "127.0.0.1:1234", Username: "******", Password: "******", })) }) It("does not err when no username and password", func() { settingsService.Settings.Mbus = "nats://127.0.0.1:1234" handler = NewNatsHandler(settingsService, client, logger) err := handler.Start(func(req boshhandler.Request) (res boshhandler.Response) { return }) Expect(err).ToNot(HaveOccurred()) defer handler.Stop() }) It("errs when has username without password", func() { settingsService.Settings.Mbus = "nats://[email protected]:1234" handler = NewNatsHandler(settingsService, client, logger) err := handler.Start(func(req boshhandler.Request) (res boshhandler.Response) { return }) Expect(err).To(HaveOccurred()) defer handler.Stop() }) }) Describe("Send", func() { It("sends the message over nats to a subject that includes the target and topic", func() { errCh := make(chan error, 1) payload := map[string]string{"key1": "value1", "keyA": "valueA"} go func() { errCh <- handler.Send(boshhandler.HealthMonitor, boshhandler.Heartbeat, payload) }() var err error select { case err = <-errCh: } Expect(err).ToNot(HaveOccurred()) Expect(client.PublishedMessageCount()).To(Equal(1)) messages := client.PublishedMessages("hm.agent.heartbeat.my-agent-id") Expect(messages).To(HaveLen(1)) Expect(messages[0].Payload).To(Equal( []byte("{\"key1\":\"value1\",\"keyA\":\"valueA\"}"), )) }) }) }) }
func init() { Describe("natsHandler", func() { var ( client *fakeyagnats.FakeYagnats logger boshlog.Logger handler boshhandler.Handler ) BeforeEach(func() { settings := &fakesettings.FakeSettingsService{ AgentID: "my-agent-id", MbusURL: "nats://*****:*****@127.0.0.1:1234", } logger = boshlog.NewLogger(boshlog.LevelNone) client = fakeyagnats.New() handler = NewNatsHandler(settings, logger, client) }) Describe("Start", func() { It("starts", func() { var receivedRequest boshhandler.Request handler.Start(func(req boshhandler.Request) (resp boshhandler.Response) { receivedRequest = req return boshhandler.NewValueResponse("expected value") }) defer handler.Stop() Expect(client.ConnectedConnectionProvider).ToNot(BeNil()) Expect(len(client.Subscriptions)).To(Equal(1)) subscriptions := client.Subscriptions["agent.my-agent-id"] Expect(len(subscriptions)).To(Equal(1)) expectedPayload := []byte(`{"method":"ping","arguments":["foo","bar"], "reply_to": "reply to me!"}`) subscription := client.Subscriptions["agent.my-agent-id"][0] subscription.Callback(&yagnats.Message{ Subject: "agent.my-agent-id", Payload: expectedPayload, }) Expect(receivedRequest).To(Equal(boshhandler.Request{ ReplyTo: "reply to me!", Method: "ping", Payload: expectedPayload, })) Expect(len(client.PublishedMessages)).To(Equal(1)) messages := client.PublishedMessages["reply to me!"] Expect(len(messages)).To(Equal(1)) Expect(messages[0].Payload).To(Equal([]byte(`{"value":"expected value"}`))) }) It("does not respond if the response is nil", func() { err := handler.Start(func(req boshhandler.Request) (resp boshhandler.Response) { return nil }) Expect(err).ToNot(HaveOccurred()) defer handler.Stop() subscription := client.Subscriptions["agent.my-agent-id"][0] subscription.Callback(&yagnats.Message{ Subject: "agent.my-agent-id", Payload: []byte(`{"method":"ping","arguments":["foo","bar"], "reply_to": "reply to me!"}`), }) Expect(len(client.PublishedMessages)).To(Equal(0)) }) It("responds with an error if the response is bigger than 1MB", func() { err := handler.Start(func(req boshhandler.Request) (resp boshhandler.Response) { // gets inflated by json.Marshal when enveloping size := 0 switch req.Method { case "small": size = 1024*1024 - 12 case "big": size = 1024 * 1024 default: panic("unknown request size") } chars := make([]byte, size) for i := range chars { chars[i] = 'A' } return boshhandler.NewValueResponse(string(chars)) }) Expect(err).ToNot(HaveOccurred()) defer handler.Stop() subscription := client.Subscriptions["agent.my-agent-id"][0] subscription.Callback(&yagnats.Message{ Subject: "agent.my-agent-id", Payload: []byte(`{"method":"small","arguments":[], "reply_to": "fake-reply-to"}`), }) subscription.Callback(&yagnats.Message{ Subject: "agent.my-agent-id", Payload: []byte(`{"method":"big","arguments":[], "reply_to": "fake-reply-to"}`), }) Expect(len(client.PublishedMessages)).To(Equal(1)) messages := client.PublishedMessages["fake-reply-to"] Expect(len(messages)).To(Equal(2)) Expect(messages[0].Payload).To(MatchRegexp("value")) Expect(messages[1].Payload).To(Equal([]byte( `{"exception":{"message":"Response exceeded maximum size allowed to be sent over NATS"}}`))) }) It("can add additional handler funcs to receive requests", func() { var firstHandlerReq, secondHandlerRequest boshhandler.Request handler.Start(func(req boshhandler.Request) (resp boshhandler.Response) { firstHandlerReq = req return boshhandler.NewValueResponse("first-handler-resp") }) defer handler.Stop() handler.RegisterAdditionalHandlerFunc(func(req boshhandler.Request) (resp boshhandler.Response) { secondHandlerRequest = req return boshhandler.NewValueResponse("second-handler-resp") }) expectedPayload := []byte(`{"method":"ping","arguments":["foo","bar"], "reply_to": "fake-reply-to"}`) subscription := client.Subscriptions["agent.my-agent-id"][0] subscription.Callback(&yagnats.Message{ Subject: "agent.my-agent-id", Payload: expectedPayload, }) // Expected requests received by both handlers Expect(firstHandlerReq).To(Equal(boshhandler.Request{ ReplyTo: "fake-reply-to", Method: "ping", Payload: expectedPayload, })) Expect(secondHandlerRequest).To(Equal(boshhandler.Request{ ReplyTo: "fake-reply-to", Method: "ping", Payload: expectedPayload, })) // Bosh handler responses were sent Expect(len(client.PublishedMessages)).To(Equal(1)) messages := client.PublishedMessages["fake-reply-to"] Expect(len(messages)).To(Equal(2)) Expect(messages[0].Payload).To(Equal([]byte(`{"value":"first-handler-resp"}`))) Expect(messages[1].Payload).To(Equal([]byte(`{"value":"second-handler-resp"}`))) }) It("has the correct connection info", func() { err := handler.Start(func(req boshhandler.Request) (res boshhandler.Response) { return }) Expect(err).ToNot(HaveOccurred()) defer handler.Stop() Expect(client.ConnectedConnectionProvider).To(Equal(&yagnats.ConnectionInfo{ Addr: "127.0.0.1:1234", Username: "******", Password: "******", })) }) It("does not err when no username and password", func() { settings := &fakesettings.FakeSettingsService{MbusURL: "nats://127.0.0.1:1234"} handler = NewNatsHandler(settings, logger, client) err := handler.Start(func(req boshhandler.Request) (res boshhandler.Response) { return }) Expect(err).ToNot(HaveOccurred()) defer handler.Stop() }) It("errs when has username without password", func() { settings := &fakesettings.FakeSettingsService{MbusURL: "nats://[email protected]:1234"} handler = NewNatsHandler(settings, logger, client) err := handler.Start(func(req boshhandler.Request) (res boshhandler.Response) { return }) Expect(err).To(HaveOccurred()) defer handler.Stop() }) }) Describe("SendToHealthManager", func() { It("sends periodic heartbeats", func() { errCh := make(chan error, 1) jobName := "foo" jobIndex := 0 expectedHeartbeat := Heartbeat{Job: &jobName, Index: &jobIndex} go func() { errCh <- handler.SendToHealthManager("heartbeat", expectedHeartbeat) }() var err error select { case err = <-errCh: } Expect(err).ToNot(HaveOccurred()) Expect(len(client.PublishedMessages)).To(Equal(1)) messages := client.PublishedMessages["hm.agent.heartbeat.my-agent-id"] Expect(len(messages)).To(Equal(1)) message := messages[0] expectedJSON, _ := json.Marshal(expectedHeartbeat) Expect(string(expectedJSON)).To(Equal(string(message.Payload))) }) }) }) }
} var _ = Describe("Proxy", func() { var r *registry.RouteRegistry var p Proxy var conf *config.Config var proxyServer net.Listener var accessLog access_log.AccessLogger var accessLogFile *test_util.FakeFile BeforeEach(func() { conf = config.DefaultConfig() conf.TraceKey = "my_trace_key" conf.EndpointTimeout = 500 * time.Millisecond mbus := fakeyagnats.New() r = registry.NewRouteRegistry(conf, mbus) accessLogFile = new(test_util.FakeFile) accessLog = access_log.NewFileAndLoggregatorAccessLogger(accessLogFile, nil) go accessLog.Run() p = NewProxy(ProxyArgs{ EndpointTimeout: conf.EndpointTimeout, Ip: conf.Ip, TraceKey: conf.TraceKey, Registry: r, Reporter: nullVarz{}, AccessLogger: accessLog, })
func buildNatsClientAndHandler(settings boshsettings.Service) (client *fakeyagnats.FakeYagnats, handler boshhandler.Handler) { logger := boshlog.NewLogger(boshlog.LevelNone) client = fakeyagnats.New() handler = NewNatsHandler(settings, logger, client) return }
func (s *VarzSuite) SetUpTest(c *C) { r := registry.NewCFRegistry(config.DefaultConfig(), fakeyagnats.New()) s.Registry = r s.Varz = NewVarz(r) }
"github.com/cloudfoundry/yagnats/fakeyagnats" . "github.com/onsi/ginkgo" . "github.com/onsi/gomega" "encoding/json" "fmt" "net/http" "time" ) var _ = Describe("Varz", func() { var Varz Varz var Registry *registry.RouteRegistry BeforeEach(func() { Registry = registry.NewRouteRegistry(config.DefaultConfig(), fakeyagnats.New()) Varz = NewVarz(Registry) }) It("contains the following items", func() { v := Varz members := []string{ "responses_2xx", "responses_3xx", "responses_4xx", "responses_5xx", "responses_xxx", "latency", "rate", "tags",