"time"
"github.com/cloudfoundry-incubator/routing-api/config"
"github.com/cloudfoundry-incubator/routing-api/models"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("Config", func() {
Describe("NewConfigFromFile", func() {
Context("when auth is enabled", func() {
Context("when the file exists", func() {
It("returns a valid Config struct", func() {
cfg_file := "../example_config/example.yml"
cfg, err := config.NewConfigFromFile(cfg_file, false)
Expect(err).NotTo(HaveOccurred())
Expect(cfg.LogGuid).To(Equal("my_logs"))
Expect(cfg.MetronConfig.Address).To(Equal("1.2.3.4"))
Expect(cfg.MetronConfig.Port).To(Equal("4567"))
Expect(cfg.DebugAddress).To(Equal("1.2.3.4:1234"))
Expect(cfg.StatsdClientFlushInterval).To(Equal(10 * time.Millisecond))
Expect(cfg.OAuth.TokenEndpoint).To(Equal("localhost"))
Expect(cfg.OAuth.Port).To(Equal(3000))
})
Context("when there is no token endpoint specified", func() {
It("returns an error", func() {
cfg_file := "../example_config/missing_uaa_url.yml"
_, err := config.NewConfigFromFile(cfg_file, false)
import (
"time"
"github.com/cloudfoundry-incubator/routing-api/config"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("Config", func() {
Describe("NewConfigFromFile", func() {
Context("when the file exists", func() {
It("returns a valid Config struct", func() {
cfg_file := "../example_config/example.yml"
cfg, err := config.NewConfigFromFile(cfg_file)
Expect(err).NotTo(HaveOccurred())
Expect(cfg.LogGuid).To(Equal("my_logs"))
Expect(cfg.MetronConfig.Address).To(Equal("1.2.3.4"))
Expect(cfg.MetronConfig.Port).To(Equal("4567"))
Expect(cfg.DebugAddress).To(Equal("1.2.3.4:1234"))
Expect(cfg.MaxConcurrentETCDRequests).To(Equal((uint)(10)))
Expect(cfg.UAAPublicKey).To(ContainSubstring("-----BEGIN PUBLIC KEY-----"))
Expect(cfg.StatsdClientFlushInterval).To(Equal(10 * time.Millisecond))
})
})
Context("when the file does not exists", func() {
It("returns an error", func() {
cfg_file := "notexist"
func main() {
flag.Parse()
cf_lager.AddFlags(flag.CommandLine)
logger, reconfigurableSink := cf_lager.New("routing-api")
err := checkFlags()
if err != nil {
logger.Error("failed to start", err)
os.Exit(1)
}
cfg, err := config.NewConfigFromFile(*configPath)
if err != nil {
logger.Error("failed to start", err)
os.Exit(1)
}
err = dropsonde.Initialize(cfg.MetronConfig.Address+":"+cfg.MetronConfig.Port, cfg.LogGuid)
if err != nil {
logger.Error("failed to initialize Dropsonde", err)
os.Exit(1)
}
if cfg.DebugAddress != "" {
cf_debug_server.Run(cfg.DebugAddress, reconfigurableSink)
}
database, err := initializeDatabase(cfg, logger)
if err != nil {
logger.Error("failed to initialize database", err)
os.Exit(1)
}
err = database.Connect()
if err != nil {
logger.Error("failed to connect to database", err)
os.Exit(1)
}
defer database.Disconnect()
prefix := "routing_api"
statsdClient, err := statsd.NewBufferedClient(cfg.StatsdEndpoint, prefix, cfg.StatsdClientFlushInterval, 512)
if err != nil {
logger.Error("failed to create a statsd client", err)
os.Exit(1)
}
defer statsdClient.Close()
stopChan := make(chan struct{})
apiServer := constructApiServer(cfg, database, statsdClient, stopChan, logger)
stopper := constructStopper(stopChan)
routerRegister := constructRouteRegister(cfg.LogGuid, database, logger)
metricsTicker := time.NewTicker(cfg.MetricsReportingInterval)
metricsReporter := metrics.NewMetricsReporter(database, statsdClient, metricsTicker)
members := grouper.Members{
{"metrics", metricsReporter},
{"api-server", apiServer},
{"conn-stopper", stopper},
{"route-register", routerRegister},
}
group := grouper.NewOrdered(os.Interrupt, members)
process := ifrit.Invoke(sigmon.New(group))
// This is used by testrunner to signal ready for tests.
logger.Info("started", lager.Data{"port": *port})
errChan := process.Wait()
err = <-errChan
if err != nil {
logger.Error("shutdown-error", err)
os.Exit(1)
}
logger.Info("exited")
}
func main() {
logger := cf_lager.New("routing-api")
flag.Parse()
if *configPath == "" {
logger.Error("failed to start", errors.New("No configuration file provided"))
os.Exit(1)
}
cfg, err := config.NewConfigFromFile(*configPath)
if err != nil {
logger.Error("failed to start", err)
os.Exit(1)
}
err = dropsonde.Initialize(cfg.MetronConfig.Address+":"+cfg.MetronConfig.Port, cfg.LogGuid)
if err != nil {
logger.Error("failed to initialize Dropsonde", err)
os.Exit(1)
}
logger.Info("database", lager.Data{"etcd-addresses": flag.Args()})
database := db.NewETCD(flag.Args())
err = database.Connect()
if err != nil {
logger.Error("failed to connect to etcd", err)
os.Exit(1)
}
defer database.Disconnect()
var token authentication.Token
if *devMode {
token = authentication.NullToken{}
} else {
token = authentication.NewAccessToken(cfg.UAAPublicKey)
err = token.CheckPublicToken()
if err != nil {
logger.Error("failed to check public token", err)
os.Exit(1)
}
}
validator := handlers.NewValidator()
routesHandler := handlers.NewRoutesHandler(token, *maxTTL, validator, database, logger)
eventStreamHandler := handlers.NewEventStreamHandler(token, database, logger)
actions := rata.Handlers{
"Upsert": route(routesHandler.Upsert),
"Delete": route(routesHandler.Delete),
"List": route(routesHandler.List),
"EventStream": route(eventStreamHandler.EventStream),
}
handler, err := rata.NewRouter(routing_api.Routes, actions)
if err != nil {
logger.Error("failed to create router", err)
os.Exit(1)
}
handler = handlers.LogWrap(handler, logger)
logger.Info("starting", lager.Data{"port": *port})
err = http.ListenAndServe(":"+strconv.Itoa(*port), handler)
if err != nil {
panic(err)
}
}