func registerRoutes(c *cli.Context) {
issues := checkFlags(c)
issues = append(issues, checkArguments(c, "register")...)
if len(issues) > 0 {
printHelpForCommand(c, issues, "register")
}
client := routing_api.NewClient(c.String("api"))
config := buildOauthConfig(c)
fetcher := token_fetcher.NewTokenFetcher(&config)
desiredRoutes := c.Args().First()
var routes []db.Route
err := json.Unmarshal([]byte(desiredRoutes), &routes)
if err != nil {
fmt.Println("Invalid json format.")
os.Exit(3)
}
err = commands.Register(client, fetcher, routes)
if err != nil {
fmt.Println("route registration failed:", err)
os.Exit(3)
}
fmt.Printf("Successfully registered routes: %s\n", desiredRoutes)
}
func streamEvents(c *cli.Context) {
issues := checkFlags(c)
issues = append(issues, checkArguments(c, "events")...)
if len(issues) > 0 {
printHelpForCommand(c, issues, "events")
}
client := routing_api.NewClient(c.String("api"))
config := buildOauthConfig(c)
fetcher := token_fetcher.NewTokenFetcher(&config)
eventSource, err := commands.Events(client, fetcher)
if err != nil {
fmt.Println("streaming events failed:", err)
os.Exit(3)
}
for {
e, err := eventSource.Next()
if err != nil {
fmt.Fprintf(os.Stderr, "Connection closed: %s", err.Error())
break
}
event, _ := json.Marshal(e)
fmt.Printf("%v\n", string(event))
}
}
func newTokenFetcher(c *config.Config, logger *steno.Logger) token_fetcher.TokenFetcher {
if c.RoutingApi.AuthDisabled {
logger.Info("using noop token fetcher")
return token_fetcher.NewNoOpTokenFetcher()
}
tokenFetcher := token_fetcher.NewTokenFetcher(&c.OAuth)
logger.Info("using uaa token fetcher")
return tokenFetcher
}
func setupRouteFetcher(c *config.Config, registry rregistry.RegistryInterface) {
if c.RoutingApiEnabled() {
tokenFetcher := token_fetcher.NewTokenFetcher(&c.OAuth)
routingApiUri := fmt.Sprintf("%s:%d", c.RoutingApi.Uri, c.RoutingApi.Port)
routingApiClient := routing_api.NewClient(routingApiUri)
routeFetcher := route_fetcher.NewRouteFetcher(steno.NewLogger("router.route_fetcher"), tokenFetcher, registry, c, routingApiClient, 1)
routeFetcher.StartFetchCycle()
routeFetcher.StartEventCycle()
}
}
func newTokenFetcher(logger lager.Logger, clock clock.Clock, c *config.Config) token_fetcher.TokenFetcher {
if c.RoutingApi.AuthDisabled {
logger.Info("using-noop-token-fetcher")
return token_fetcher.NewNoOpTokenFetcher()
}
tokenFetcherConfig := token_fetcher.TokenFetcherConfig{
MaxNumberOfRetries: c.TokenFetcherMaxRetries,
RetryInterval: c.TokenFetcherRetryInterval,
ExpirationBufferTime: c.TokenFetcherExpirationBufferTimeInSeconds,
}
logger.Info("fetching-token-from-uaa")
tokenFetcher, err := token_fetcher.NewTokenFetcher(logger, &c.OAuth, tokenFetcherConfig, clock)
if err != nil {
logger.Fatal("initialize-token-fetcher-error", err)
}
return tokenFetcher
}
func newTokenFetcher(logger *steno.Logger, clock clock.Clock, c *config.Config) token_fetcher.TokenFetcher {
if c.RoutingApi.AuthDisabled {
logger.Info("using noop token fetcher")
return token_fetcher.NewNoOpTokenFetcher()
}
tokenFetcherConfig := token_fetcher.TokenFetcherConfig{
MaxNumberOfRetries: c.TokenFetcherMaxRetries,
RetryInterval: c.TokenFetcherRetryInterval,
ExpirationBufferTime: c.TokenFetcherExpirationBufferTimeInSeconds,
}
cfLogger, _ := cf_lager.New("token_fetcher")
tokenFetcher, err := token_fetcher.NewTokenFetcher(cfLogger, &c.OAuth, tokenFetcherConfig, clock)
if err != nil {
logger.Errorf("Error creating token fetcher: %s\n", err)
os.Exit(1)
}
logger.Info("using uaa token fetcher")
return tokenFetcher
}
func listRoutes(c *cli.Context) {
issues := checkFlags(c)
issues = append(issues, checkArguments(c, "list")...)
if len(issues) > 0 {
printHelpForCommand(c, issues, "list")
}
client := routing_api.NewClient(c.String("api"))
config := buildOauthConfig(c)
fetcher := token_fetcher.NewTokenFetcher(&config)
routes, err := commands.List(client, fetcher)
if err != nil {
fmt.Println("listing routes failed:", err)
os.Exit(3)
}
prettyRoutes, _ := json.Marshal(routes)
fmt.Printf("%v\n", string(prettyRoutes))
}
func main() {
c := config.DefaultConfig()
logCounter := vcap.NewLogCounter()
if configFile != "" {
c = config.InitConfigFromFile(configFile)
}
InitLoggerFromConfig(c, logCounter)
logger := steno.NewLogger("router.main")
err := dropsonde.Initialize(c.Logging.MetronAddress, c.Logging.JobName)
if err != nil {
logger.Errorf("Dropsonde failed to initialize: %s", err.Error())
os.Exit(1)
}
// setup number of procs
if c.GoMaxProcs != 0 {
runtime.GOMAXPROCS(c.GoMaxProcs)
}
if c.DebugAddr != "" {
cf_debug_server.Run(c.DebugAddr)
}
natsServers := c.NatsServers()
var natsClient yagnats.NATSConn
attempts := 3
for attempts > 0 {
natsClient, err = yagnats.Connect(natsServers)
if err == nil {
break
} else {
attempts--
time.Sleep(100 * time.Millisecond)
}
}
if err != nil {
logger.Errorf("Error connecting to NATS: %s\n", err)
os.Exit(1)
}
natsClient.AddClosedCB(func(conn *nats.Conn) {
logger.Errorf("Close on NATS client. nats.Conn: %+v", *conn)
os.Exit(1)
})
registry := rregistry.NewRouteRegistry(c, natsClient)
if c.RoutingApiEnabled() {
logger.Info("Setting up routing_api route fetcher")
tokenFetcher := token_fetcher.NewTokenFetcher(&c.OAuth)
routingApiUri := fmt.Sprintf("%s:%d", c.RoutingApi.Uri, c.RoutingApi.Port)
routingApiClient := routing_api.NewClient(routingApiUri)
routeFetcher := route_fetcher.NewRouteFetcher(steno.NewLogger("router.route_fetcher"), tokenFetcher, registry, c, routingApiClient, 1)
routeFetcher.StartFetchCycle()
routeFetcher.StartEventCycle()
}
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,
SecureCookies: c.SecureCookies,
}
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)
}