func generateConfig(statusPort, proxyPort uint16, natsPorts ...uint16) *config.Config {
c := config.DefaultConfig()
c.Port = proxyPort
c.Index = 2
c.TraceKey = "my_trace_key"
// Hardcode the IP to localhost to avoid leaving the machine while running tests
c.Ip = "127.0.0.1"
c.StartResponseDelayInterval = 1 * time.Second
c.PublishStartMessageInterval = 10 * time.Second
c.PruneStaleDropletsInterval = 0
c.DropletStaleThreshold = 10 * time.Second
c.PublishActiveAppsInterval = 0
c.Zone = "z1"
c.EndpointTimeout = 500 * time.Millisecond
c.Status = config.StatusConfig{
Port: statusPort,
User: "******",
Pass: "******",
}
c.Nats = []config.NatsConfig{}
for _, natsPort := range natsPorts {
c.Nats = append(c.Nats, config.NatsConfig{
Host: "localhost",
Port: natsPort,
User: "******",
Pass: "******",
})
}
c.Logging = config.LoggingConfig{
Level: "debug",
MetronAddress: "localhost:3457",
JobName: "router_test_z1_0",
}
c.OAuth = config.OAuthConfig{
TokenEndpoint: "uaa.cf.service.internal",
Port: 8443,
SkipSSLValidation: true,
}
c.RouteServiceSecret = "kCvXxNMB0JO2vinxoru9Hg=="
c.Tracing = config.Tracing{
EnableZipkin: true,
}
return c
}
"code.cloudfoundry.org/gorouter/varz"
"code.cloudfoundry.org/lager/lagertest"
"code.cloudfoundry.org/routing-api/models"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"strconv"
"code.cloudfoundry.org/gorouter/metrics/reporter/fakes"
)
var _ = Describe("AccessLogRecord", func() {
Measure("Register", func(b Benchmarker) {
logger := lagertest.NewTestLogger("test")
c := config.DefaultConfig()
r := registry.NewRouteRegistry(logger, c, new(fakes.FakeRouteRegistryReporter))
accesslog, err := access_log.CreateRunningAccessLogger(logger, c)
Expect(err).ToNot(HaveOccurred())
proxy.NewProxy(proxy.ProxyArgs{
EndpointTimeout: c.EndpointTimeout,
Ip: c.Ip,
TraceKey: c.TraceKey,
Registry: r,
Reporter: varz.NewVarz(r),
AccessLogger: accesslog,
})
b.Time("RegisterTime", func() {
client *fake_routing_api.FakeClient
eventSource *fake_routing_api.FakeEventSource
token *schema.Token
response []models.Route
process ifrit.Process
eventChannel chan routing_api.Event
errorChannel chan error
clock *fakeclock.FakeClock
)
BeforeEach(func() {
logger = lagertest.NewTestLogger("test")
cfg = config.DefaultConfig()
cfg.PruneStaleDropletsInterval = 2 * time.Millisecond
retryInterval := 0
uaaClient = &testUaaClient.FakeClient{}
registry = &testRegistry.FakeRegistryInterface{}
token = &schema.Token{
AccessToken: "access_token",
ExpiresIn: 5,
}
client = &fake_routing_api.FakeClient{}
eventChannel = make(chan routing_api.Event)
errorChannel = make(chan error)
eventSource = &fake_routing_api.FakeEventSource{}
. "github.com/onsi/gomega"
"encoding/json"
"fmt"
"net/http"
"time"
)
var _ = Describe("Varz", func() {
var Varz Varz
var Registry *registry.RouteRegistry
var logger lager.Logger
BeforeEach(func() {
logger = lagertest.NewTestLogger("test")
Registry = registry.NewRouteRegistry(logger, config.DefaultConfig(), new(fakes.FakeRouteRegistryReporter))
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",
func main() {
flag.StringVar(&configFile, "c", "", "Configuration File")
flag.Parse()
c := config.DefaultConfig()
logCounter := schema.NewLogCounter()
if configFile != "" {
c = config.InitConfigFromFile(configFile)
}
prefix := "gorouter.stdout"
if c.Logging.Syslog != "" {
prefix = c.Logging.Syslog
}
logger, reconfigurableSink := lagerflags.NewFromConfig(prefix,
lagerflags.LagerConfig{LogLevel: c.Logging.Level})
logger.Info("starting")
err := dropsonde.Initialize(c.Logging.MetronAddress, c.Logging.JobName)
if err != nil {
logger.Fatal("dropsonde-initialize-error", err)
}
// setup number of procs
if c.GoMaxProcs != 0 {
runtime.GOMAXPROCS(c.GoMaxProcs)
}
if c.DebugAddr != "" {
debugserver.Run(c.DebugAddr, reconfigurableSink)
}
logger.Info("setting-up-nats-connection")
startMsgChan := make(chan struct{})
natsClient := connectToNatsServer(logger.Session("nats"), c, startMsgChan)
metricsReporter := metrics.NewMetricsReporter()
registry := rregistry.NewRouteRegistry(logger.Session("registry"), c, metricsReporter)
if c.SuspendPruningIfNatsUnavailable {
registry.SuspendPruning(func() bool { return !(natsClient.Status() == nats.CONNECTED) })
}
subscriber := createSubscriber(logger, c, natsClient, registry, startMsgChan)
varz := rvarz.NewVarz(registry)
compositeReporter := metrics.NewCompositeReporter(varz, metricsReporter)
accessLogger, err := access_log.CreateRunningAccessLogger(logger.Session("access-log"), c)
if err != nil {
logger.Fatal("error-creating-access-logger", err)
}
var crypto secure.Crypto
var cryptoPrev secure.Crypto
if c.RouteServiceEnabled {
crypto = createCrypto(logger, c.RouteServiceSecret)
if c.RouteServiceSecretPrev != "" {
cryptoPrev = createCrypto(logger, c.RouteServiceSecretPrev)
}
}
proxy := buildProxy(logger.Session("proxy"), c, registry, accessLogger, compositeReporter, crypto, cryptoPrev)
healthCheck = 0
router, err := router.NewRouter(logger.Session("router"), c, proxy, natsClient, registry, varz, &healthCheck, logCounter, nil)
if err != nil {
logger.Fatal("initialize-router-error", err)
}
members := grouper.Members{
grouper.Member{Name: "subscriber", Runner: subscriber},
grouper.Member{Name: "router", Runner: router},
}
if c.RoutingApiEnabled() {
logger.Info("setting-up-routing-api")
routeFetcher := setupRouteFetcher(logger.Session("route-fetcher"), c, registry)
// check connectivity to routing api
err = routeFetcher.FetchRoutes()
if err != nil {
logger.Fatal("routing-api-connection-failed", err)
}
members = append(members, grouper.Member{Name: "router-fetcher", Runner: routeFetcher})
}
group := grouper.NewOrdered(os.Interrupt, members)
monitor := ifrit.Invoke(sigmon.New(group, syscall.SIGTERM, syscall.SIGINT, syscall.SIGUSR1))
err = <-monitor.Wait()
if err != nil {
logger.Error("gorouter.exited-with-failure", err)
os.Exit(1)
}
os.Exit(0)
}
"time"
)
var _ = Describe("RouteRegistry", func() {
var r *RouteRegistry
var reporter *fakes.FakeRouteRegistryReporter
var fooEndpoint, barEndpoint, bar2Endpoint *route.Endpoint
var configObj *config.Config
var logger lager.Logger
var modTag models.ModificationTag
BeforeEach(func() {
logger = lagertest.NewTestLogger("test")
configObj = config.DefaultConfig()
configObj.PruneStaleDropletsInterval = 50 * time.Millisecond
configObj.DropletStaleThreshold = 24 * time.Millisecond
reporter = new(fakes.FakeRouteRegistryReporter)
r = NewRouteRegistry(logger, configObj, reporter)
modTag = models.ModificationTag{}
fooEndpoint = route.NewEndpoint("12345", "192.168.1.1", 1234,
"id1", "0",
map[string]string{
"runtime": "ruby18",
"framework": "sinatra",
}, -1, "", modTag)
barEndpoint = route.NewEndpoint("54321", "192.168.1.2", 4321,