func (runner *NATSRunner) Start() {
if runner.natsSession != nil {
panic("starting an already started NATS runner!!!")
}
_, err := exec.LookPath("gnatsd")
if err != nil {
fmt.Println("You need gnatsd installed!")
os.Exit(1)
}
cmd := exec.Command("gnatsd", "-p", strconv.Itoa(runner.port))
sess, err := gexec.Start(
cmd,
gexec.NewPrefixedWriter("\x1b[32m[o]\x1b[34m[gnatsd]\x1b[0m ", ginkgo.GinkgoWriter),
gexec.NewPrefixedWriter("\x1b[91m[e]\x1b[34m[gnatsd]\x1b[0m ", ginkgo.GinkgoWriter),
)
Ω(err).ShouldNot(HaveOccurred(), "Make sure to have gnatsd on your path")
runner.natsSession = sess
messageBus := yagnats.NewApceraClientWrapper([]string{fmt.Sprintf("nats://127.0.0.1:%d", runner.port)})
Eventually(func() error {
return messageBus.Connect()
}, 5, 0.1).ShouldNot(HaveOccurred())
runner.MessageBus = messageBus
}
func newMessageBus(c *config.Config) (yagnats.ApceraWrapperNATSClient, error) {
natsMembers := make([]string, len(c.Nats))
for _, info := range c.Nats {
uri := url.URL{
Scheme: "nats",
User: url.UserPassword(info.User, info.Pass),
Host: fmt.Sprintf("%s:%d", info.Host, info.Port),
}
natsMembers = append(natsMembers, uri.String())
}
natsClient := yagnats.NewApceraClientWrapper(natsMembers)
err := natsClient.Connect()
return natsClient, err
}
func main() {
c := config.DefaultConfig()
logCounter := vcap.NewLogCounter()
InitLoggerFromConfig(c, logCounter)
if configFile != "" {
c = config.InitConfigFromFile(configFile)
}
// setup number of procs
if c.GoMaxProcs != 0 {
runtime.GOMAXPROCS(c.GoMaxProcs)
}
InitLoggerFromConfig(c, logCounter)
logger := steno.NewLogger("router.main")
natsMembers := make([]string, len(c.Nats))
for _, info := range c.Nats {
uri := url.URL{
Scheme: "nats",
User: url.UserPassword(info.User, info.Pass),
Host: fmt.Sprintf("%s:%d", info.Host, info.Port),
}
natsMembers = append(natsMembers, uri.String())
}
natsClient := yagnats.NewApceraClientWrapper(natsMembers)
err := natsClient.Connect()
if err != nil {
logger.Fatalf("Error connecting to NATS: %s\n", err)
}
registry := rregistry.NewRouteRegistry(c, natsClient)
varz := rvarz.NewVarz(registry)
accessLogger, err := access_log.CreateRunningAccessLogger(c)
if err != nil {
logger.Fatalf("Error creating access logger: %s\n", err)
}
args := proxy.ProxyArgs{
EndpointTimeout: c.EndpointTimeout,
Ip: c.Ip,
TraceKey: c.TraceKey,
Registry: registry,
Reporter: varz,
AccessLogger: accessLogger,
}
p := proxy.NewProxy(args)
router, err := router.NewRouter(c, p, natsClient, registry, varz, logCounter)
if err != nil {
logger.Errorf("An error occurred: %s", err.Error())
os.Exit(1)
}
signals := make(chan os.Signal, 1)
signal.Notify(signals, syscall.SIGTERM, syscall.SIGINT, syscall.SIGUSR1)
errChan := router.Run()
logger.Info("gorouter.started")
select {
case err := <-errChan:
if err != nil {
logger.Errorf("Error occurred: %s", err.Error())
os.Exit(1)
}
case sig := <-signals:
go func() {
for sig := range signals {
logger.Infod(
map[string]interface{}{
"signal": sig.String(),
},
"gorouter.signal.ignored",
)
}
}()
if sig == syscall.SIGUSR1 {
logger.Infod(
map[string]interface{}{
"timeout": (c.DrainTimeout).String(),
},
"gorouter.draining",
)
router.Drain(c.DrainTimeout)
}
stoppingAt := time.Now()
logger.Info("gorouter.stopping")
router.Stop()
logger.Infod(
map[string]interface{}{
"took": time.Since(stoppingAt).String(),
},
"gorouter.stopped",
)
}
os.Exit(0)
}