func buildProxy(logger lager.Logger, c *config.Config, registry rregistry.RegistryInterface, accessLogger access_log.AccessLogger, reporter reporter.ProxyReporter, crypto secure.Crypto, cryptoPrev secure.Crypto) proxy.Proxy {
args := proxy.ProxyArgs{
Logger: logger,
EndpointTimeout: c.EndpointTimeout,
Ip: c.Ip,
TraceKey: c.TraceKey,
Registry: registry,
Reporter: reporter,
AccessLogger: accessLogger,
SecureCookies: c.SecureCookies,
TLSConfig: &tls.Config{
CipherSuites: c.CipherSuites,
InsecureSkipVerify: c.SkipSSLValidation,
},
RouteServiceEnabled: c.RouteServiceEnabled,
RouteServiceTimeout: c.RouteServiceTimeout,
RouteServiceRecommendHttps: c.RouteServiceRecommendHttps,
Crypto: crypto,
CryptoPrev: cryptoPrev,
ExtraHeadersToLog: &c.ExtraHeadersToLog,
HealthCheckUserAgent: c.HealthCheckUserAgent,
HeartbeatOK: &healthCheck,
EnableZipkin: c.Tracing.EnableZipkin,
ForceForwardedProtoHttps: c.ForceForwardedProtoHttps,
DefaultLoadBalance: c.LoadBalance,
}
return proxy.NewProxy(args)
}
"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() {
for i := 0; i < 1000; i++ {
str := strconv.Itoa(i)
r.Register(
route.Uri("bench.vcap.me."+str),
route.NewEndpoint("", "localhost", uint16(i), "", "", nil, -1, "", models.ModificationTag{}),
)
}
})
}, 10)
InsecureSkipVerify: conf.SkipSSLValidation,
}
fakeAccessLogger = &fakelogger.FakeAccessLogger{}
logger = lagertest.NewTestLogger("test")
r = registry.NewRouteRegistry(logger, conf, new(fakes.FakeRouteRegistryReporter))
proxyObj = proxy.NewProxy(proxy.ProxyArgs{
EndpointTimeout: conf.EndpointTimeout,
Ip: conf.Ip,
TraceKey: conf.TraceKey,
Registry: r,
Reporter: test_helpers.NullVarz{},
Logger: logger,
AccessLogger: fakeAccessLogger,
SecureCookies: conf.SecureCookies,
TLSConfig: tlsConfig,
RouteServiceEnabled: conf.RouteServiceEnabled,
RouteServiceTimeout: conf.RouteServiceTimeout,
Crypto: crypto,
CryptoPrev: cryptoPrev,
HealthCheckUserAgent: "HTTP-Monitor/1.1",
})
r.Register(route.Uri("some-app"), &route.Endpoint{})
})
Context("when backend fails to respond", func() {
It("logs the error and associated endpoint", func() {
body := []byte("some body")
req := test_util.NewRequest("GET", "some-app", "/", bytes.NewReader(body))
config.SSLPort = sslPort
config.SSLCertificate = cert
config.CipherSuites = []uint16{tls.TLS_RSA_WITH_AES_256_CBC_SHA}
config.EndpointTimeout = 5 * time.Second
mbusClient = natsRunner.MessageBus
registry = rregistry.NewRouteRegistry(logger, config, new(fakes.FakeRouteRegistryReporter))
varz = vvarz.NewVarz(registry)
logcounter := schema.NewLogCounter()
atomic.StoreInt32(&healthCheck, 0)
p = proxy.NewProxy(proxy.ProxyArgs{
Logger: logger,
EndpointTimeout: config.EndpointTimeout,
Ip: config.Ip,
TraceKey: config.TraceKey,
Registry: registry,
Reporter: varz,
AccessLogger: &access_log.NullAccessLogger{},
HealthCheckUserAgent: "HTTP-Monitor/1.1",
HeartbeatOK: &healthCheck,
})
errChan := make(chan error, 2)
rtr, err = router.NewRouter(logger, config, p, mbusClient, registry, varz, &healthCheck, logcounter, errChan)
Expect(err).ToNot(HaveOccurred())
opts := &mbus.SubscriberOpts{
ID: "test",
MinimumRegisterIntervalInSeconds: int(config.StartResponseDelayInterval.Seconds()),
PruneThresholdInSeconds: int(config.DropletStaleThreshold.Seconds()),
}
CipherSuites: conf.CipherSuites,
InsecureSkipVerify: conf.SkipSSLValidation,
RootCAs: caCertPool,
}
heartbeatOK = 1
p = proxy.NewProxy(proxy.ProxyArgs{
EndpointTimeout: conf.EndpointTimeout,
Ip: conf.Ip,
TraceKey: conf.TraceKey,
Logger: logger,
Registry: r,
Reporter: fakeReporter,
AccessLogger: accessLog,
SecureCookies: conf.SecureCookies,
TLSConfig: tlsConfig,
RouteServiceEnabled: conf.RouteServiceEnabled,
RouteServiceTimeout: conf.RouteServiceTimeout,
Crypto: crypto,
CryptoPrev: cryptoPrev,
RouteServiceRecommendHttps: recommendHttps,
HealthCheckUserAgent: "HTTP-Monitor/1.1",
HeartbeatOK: &heartbeatOK,
EnableZipkin: conf.Tracing.EnableZipkin,
ExtraHeadersToLog: &conf.ExtraHeadersToLog,
ForceForwardedProtoHttps: conf.ForceForwardedProtoHttps,
})
proxyServer, err = net.Listen("tcp", "127.0.0.1:0")
Expect(err).NotTo(HaveOccurred())
server := http.Server{Handler: p}
