func (maker ComponentMaker) NATSClient() diegonats.NATSClient {
client := diegonats.NewClient()
_, err := client.Connect([]string{"nats://" + maker.Addresses.NATS})
Expect(err).NotTo(HaveOccurred())
return client
}
func StartGnatsd(natsPort int) (ifrit.Process, diegonats.NATSClient) {
ginkgomonRunner := NewGnatsdTestRunner(natsPort)
gnatsdProcess := ifrit.Envoke(ginkgomonRunner)
natsClient := diegonats.NewClient()
_, err := natsClient.Connect([]string{fmt.Sprintf("nats://127.0.0.1:%d", natsPort)})
Expect(err).ShouldNot(HaveOccurred())
return gnatsdProcess, natsClient
}
func main() {
cf_debug_server.AddFlags(flag.CommandLine)
cf_lager.AddFlags(flag.CommandLine)
flag.Parse()
cf_http.Initialize(*communicationTimeout)
logger, reconfigurableSink := cf_lager.New(*sessionName)
natsClient := diegonats.NewClient()
clock := clock.NewClock()
syncer := syncer.NewSyncer(clock, *syncInterval, natsClient, logger)
initializeDropsonde(logger)
natsClientRunner := diegonats.NewClientRunner(*natsAddresses, *natsUsername, *natsPassword, logger, natsClient)
table := initializeRoutingTable()
emitter := initializeNatsEmitter(natsClient, logger)
watcher := ifrit.RunFunc(func(signals <-chan os.Signal, ready chan<- struct{}) error {
return watcher.NewWatcher(initializeBBSClient(logger), clock, table, emitter, syncer.Events(), logger).Run(signals, ready)
})
syncRunner := ifrit.RunFunc(func(signals <-chan os.Signal, ready chan<- struct{}) error {
return syncer.Run(signals, ready)
})
lockMaintainer := initializeLockMaintainer(logger, *consulCluster, *sessionName, *lockTTL, *lockRetryInterval, clock)
members := grouper.Members{
{"lock-maintainer", lockMaintainer},
{"nats-client", natsClientRunner},
{"watcher", watcher},
{"syncer", syncRunner},
}
if dbgAddr := cf_debug_server.DebugAddress(flag.CommandLine); dbgAddr != "" {
members = append(grouper.Members{
{"debug-server", cf_debug_server.Runner(dbgAddr, reconfigurableSink)},
}, members...)
}
group := grouper.NewOrdered(os.Interrupt, members)
monitor := ifrit.Invoke(sigmon.New(group))
logger.Info("started")
err := <-monitor.Wait()
if err != nil {
logger.Error("exited-with-failure", err)
os.Exit(1)
}
logger.Info("exited")
}
func main() {
cf_debug_server.AddFlags(flag.CommandLine)
cf_lager.AddFlags(flag.CommandLine)
etcdFlags := etcdstoreadapter.AddFlags(flag.CommandLine)
flag.Parse()
cf_http.Initialize(*communicationTimeout)
logger, reconfigurableSink := cf_lager.New("receptor")
logger.Info("starting")
initializeDropsonde(logger)
etcdOptions, err := etcdFlags.Validate()
if err != nil {
logger.Fatal("etcd-validation-failed", err)
}
if err := validateNatsArguments(); err != nil {
logger.Error("invalid-nats-flags", err)
os.Exit(1)
}
bbs := initializeReceptorBBS(etcdOptions, logger)
hub := event.NewHub()
handler := handlers.New(bbs, hub, logger, *username, *password, *corsEnabled)
worker, enqueue := task_handler.NewTaskWorkerPool(bbs, logger)
taskHandler := task_handler.New(enqueue, logger)
lrpChangeWatcher := watcher.NewWatcher(
bbs,
hub,
clock.NewClock(),
bbsWatchRetryWaitDuration,
logger,
)
members := grouper.Members{
{"lrp-change-watcher", lrpChangeWatcher},
{"server", http_server.New(*serverAddress, handler)},
{"worker", worker},
{"task-complete-handler", http_server.New(*taskHandlerAddress, taskHandler)},
{"hub-closer", closeHub(logger.Session("hub-closer"), hub)},
}
if *registerWithRouter {
registration := initializeServerRegistration(logger)
natsClient := diegonats.NewClient()
members = append(members, grouper.Member{
Name: "background-heartbeat",
Runner: natbeat.NewBackgroundHeartbeat(natsClient, *natsAddresses, *natsUsername, *natsPassword, logger, registration),
})
}
if dbgAddr := cf_debug_server.DebugAddress(flag.CommandLine); dbgAddr != "" {
members = append(grouper.Members{
{"debug-server", cf_debug_server.Runner(dbgAddr, reconfigurableSink)},
}, members...)
}
group := grouper.NewOrdered(os.Interrupt, members)
monitor := ifrit.Invoke(sigmon.New(group))
logger.Info("started")
err = <-monitor.Wait()
if err != nil {
logger.Error("exited-with-failure", err)
os.Exit(1)
}
logger.Info("exited")
}
logger = lagertest.NewTestLogger("test")
etcdRunner.Reset()
consulRunner.Reset()
consulSession = consulRunner.NewSession("a-session")
receptorAddress = fmt.Sprintf("127.0.0.1:%d", 6700+GinkgoParallelNode())
receptorTaskHandlerAddress = fmt.Sprintf("127.0.0.1:%d", 1169+GinkgoParallelNode())
etcdAdapter = etcdRunner.Adapter(nil)
legacyBBS = Bbs.NewBBS(etcdAdapter, consulSession, "http://"+receptorTaskHandlerAddress, clock.NewClock(), logger)
natsPort = 4051 + GinkgoParallelNode()
natsAddress = fmt.Sprintf("127.0.0.1:%d", natsPort)
natsClient = diegonats.NewClient()
natsGroupProcess = ginkgomon.Invoke(newNatsGroup())
receptorURL := &url.URL{
Scheme: "http",
Host: receptorAddress,
User: url.UserPassword(username, password),
}
client = receptor.NewClient(receptorURL.String())
receptorArgs = testrunner.Args{
RegisterWithRouter: true,
DomainNames: "example.com",
Address: receptorAddress,
TaskHandlerAddress: receptorTaskHandlerAddress,