func (p *proxy) ServeHTTP(responseWriter http.ResponseWriter, request *http.Request) {
startedAt := time.Now()
accessLog := access_log.AccessLogRecord{
Request: request,
StartedAt: startedAt,
ExtraHeadersToLog: p.ExtraHeadersToLog,
}
requestBodyCounter := &countingReadCloser{delegate: request.Body}
request.Body = requestBodyCounter
proxyWriter := NewProxyResponseWriter(responseWriter)
handler := NewRequestHandler(request, proxyWriter, p.reporter, &accessLog)
defer func() {
accessLog.RequestBytesReceived = requestBodyCounter.count
p.accessLogger.Log(accessLog)
}()
if !isProtocolSupported(request) {
handler.HandleUnsupportedProtocol()
return
}
if isLoadBalancerHeartbeat(request) {
handler.HandleHeartbeat()
return
}
routePool := p.lookup(request)
if routePool == nil {
p.reporter.CaptureBadRequest(request)
handler.HandleMissingRoute()
return
}
stickyEndpointId := p.getStickySession(request)
iter := &wrappedIterator{
nested: routePool.Endpoints(stickyEndpointId),
afterNext: func(endpoint *route.Endpoint) {
if endpoint != nil {
handler.Logger().Set("RouteEndpoint", endpoint.ToLogData())
accessLog.RouteEndpoint = endpoint
p.reporter.CaptureRoutingRequest(endpoint, request)
}
},
}
if isTcpUpgrade(request) {
handler.HandleTcpRequest(iter)
return
}
if isWebSocketUpgrade(request) {
handler.HandleWebSocketRequest(iter)
return
}
backend := true
routeServiceUrl := routePool.RouteServiceUrl()
// Attempted to use a route service when it is not supported
if routeServiceUrl != "" && !p.routeServiceConfig.RouteServiceEnabled() {
handler.HandleUnsupportedRouteService()
return
}
var routeServiceArgs route_service.RouteServiceArgs
if routeServiceUrl != "" {
rsSignature := request.Header.Get(route_service.RouteServiceSignature)
if hasBeenToRouteService(routeServiceUrl, rsSignature) {
// A request from a route service destined for a backend instances
routeServiceArgs.UrlString = routeServiceUrl
err := p.routeServiceConfig.ValidateSignature(&request.Header)
if err != nil {
handler.HandleBadSignature(err)
return
}
} else {
var err error
// should not hardcode http, will be addressed by #100982038
forwardedUrlRaw := "http" + "://" + request.Host + request.RequestURI
routeServiceArgs, err = buildRouteServiceArgs(p.routeServiceConfig, routeServiceUrl, forwardedUrlRaw)
backend = false
if err != nil {
handler.HandleRouteServiceFailure(err)
return
}
}
}
after := func(rsp *http.Response, endpoint *route.Endpoint, err error) {
accessLog.FirstByteAt = time.Now()
if rsp != nil {
accessLog.StatusCode = rsp.StatusCode
}
if p.traceKey != "" && request.Header.Get(router_http.VcapTraceHeader) == p.traceKey {
setTraceHeaders(responseWriter, p.ip, endpoint.CanonicalAddr())
}
latency := time.Since(startedAt)
p.reporter.CaptureRoutingResponse(endpoint, rsp, startedAt, latency)
if err != nil {
p.reporter.CaptureBadGateway(request)
handler.HandleBadGateway(err)
return
}
if endpoint.PrivateInstanceId != "" {
setupStickySession(responseWriter, rsp, endpoint, stickyEndpointId, p.secureCookies, routePool.ContextPath())
}
}
roundTripper := NewProxyRoundTripper(backend,
dropsonde.InstrumentedRoundTripper(p.transport), iter, handler, after)
newReverseProxy(roundTripper, request, routeServiceArgs, p.routeServiceConfig).ServeHTTP(proxyWriter, request)
accessLog.FinishedAt = time.Now()
accessLog.BodyBytesSent = proxyWriter.Size()
}
func (proxy *Proxy) ServeHTTP(responseWriter http.ResponseWriter, request *http.Request) {
startedAt := time.Now()
originalURL := request.URL
request.URL = &url.URL{Host: originalURL.Host, Opaque: request.RequestURI}
handler := NewRequestHandler(request, responseWriter)
accessLog := access_log.AccessLogRecord{
Request: request,
StartedAt: startedAt,
}
defer func() {
proxy.AccessLogger.Log(accessLog)
}()
if !isProtocolSupported(request) {
handler.HandleUnsupportedProtocol()
return
}
if isLoadBalancerHeartbeat(request) {
handler.HandleHeartbeat()
return
}
routeEndpoint, found := proxy.Lookup(request)
if !found {
proxy.Varz.CaptureBadRequest(request)
handler.HandleMissingRoute()
return
}
handler.logger.Set("RouteEndpoint", routeEndpoint.ToLogData())
accessLog.RouteEndpoint = routeEndpoint
proxy.Varz.CaptureRoutingRequest(routeEndpoint, handler.request)
if isTcpUpgrade(request) {
handler.HandleTcpRequest(routeEndpoint)
return
}
if isWebSocketUpgrade(request) {
handler.HandleWebSocketRequest(routeEndpoint)
return
}
endpointResponse, err := handler.HandleHttpRequest(proxy.Transport, routeEndpoint)
latency := time.Since(startedAt)
proxy.Registry.CaptureRoutingRequest(routeEndpoint, startedAt)
proxy.Varz.CaptureRoutingResponse(routeEndpoint, endpointResponse, latency)
if err != nil {
proxy.Varz.CaptureBadGateway(request)
handler.HandleBadGateway(err)
return
}
accessLog.FirstByteAt = time.Now()
accessLog.Response = endpointResponse
if proxy.Config.TraceKey != "" && request.Header.Get(VcapTraceHeader) == proxy.Config.TraceKey {
handler.SetTraceHeaders(proxy.Config.Ip, routeEndpoint.CanonicalAddr())
}
bytesSent := handler.WriteResponse(endpointResponse)
accessLog.FinishedAt = time.Now()
accessLog.BodyBytesSent = bytesSent
}
func (p *proxy) ServeHTTP(responseWriter http.ResponseWriter, request *http.Request) {
startedAt := time.Now()
accessLog := access_log.AccessLogRecord{
Request: request,
StartedAt: startedAt,
}
requestBodyCounter := &countingReadCloser{delegate: request.Body}
request.Body = requestBodyCounter
handler := NewRequestHandler(request, responseWriter, p.reporter, &accessLog)
defer func() {
accessLog.RequestBytesReceived = requestBodyCounter.count
p.accessLogger.Log(accessLog)
}()
if !isProtocolSupported(request) {
handler.HandleUnsupportedProtocol()
return
}
if isLoadBalancerHeartbeat(request) {
handler.HandleHeartbeat()
return
}
routePool := p.lookup(request)
if routePool == nil {
p.reporter.CaptureBadRequest(request)
handler.HandleMissingRoute()
return
}
stickyEndpointId := p.getStickySession(request)
iter := &wrappedIterator{
nested: routePool.Endpoints(stickyEndpointId),
afterNext: func(endpoint *route.Endpoint) {
if endpoint != nil {
handler.logger.Set("RouteEndpoint", endpoint.ToLogData())
accessLog.RouteEndpoint = endpoint
p.reporter.CaptureRoutingRequest(endpoint, request)
}
},
}
if isTcpUpgrade(request) {
handler.HandleTcpRequest(iter)
return
}
if isWebSocketUpgrade(request) {
handler.HandleWebSocketRequest(iter)
return
}
proxyWriter := newProxyResponseWriter(responseWriter)
roundTripper := &proxyRoundTripper{
transport: dropsonde.InstrumentedRoundTripper(p.transport),
iter: iter,
handler: &handler,
routeServiceTimeout: p.routeServiceTimeout,
after: func(rsp *http.Response, endpoint *route.Endpoint, err error) {
accessLog.FirstByteAt = time.Now()
if rsp != nil {
accessLog.StatusCode = rsp.StatusCode
}
if p.traceKey != "" && request.Header.Get(router_http.VcapTraceHeader) == p.traceKey {
setTraceHeaders(responseWriter, p.ip, endpoint.CanonicalAddr())
}
latency := time.Since(startedAt)
p.reporter.CaptureRoutingResponse(endpoint, rsp, startedAt, latency)
if err != nil {
p.reporter.CaptureBadGateway(request)
handler.HandleBadGateway(err)
proxyWriter.Done()
return
}
if endpoint.PrivateInstanceId != "" {
setupStickySession(responseWriter, rsp, endpoint, stickyEndpointId, p.secureCookies, routePool.ContextPath())
}
},
}
p.newReverseProxy(roundTripper, request).ServeHTTP(proxyWriter, request)
accessLog.FinishedAt = time.Now()
accessLog.BodyBytesSent = proxyWriter.Size()
}
func (p *proxy) ServeHTTP(responseWriter http.ResponseWriter, request *http.Request) {
startedAt := time.Now()
accessLog := access_log.AccessLogRecord{
Request: request,
StartedAt: startedAt,
}
handler := NewRequestHandler(request, responseWriter, p.reporter, &accessLog)
p.waitgroup.Add(1)
defer func() {
p.accessLogger.Log(accessLog)
p.waitgroup.Done()
}()
if !isProtocolSupported(request) {
handler.HandleUnsupportedProtocol()
return
}
if isLoadBalancerHeartbeat(request) {
handler.HandleHeartbeat()
return
}
routePool := p.lookup(request)
if routePool == nil {
p.reporter.CaptureBadRequest(request)
handler.HandleMissingRoute()
return
}
stickyEndpointId := p.getStickySession(request)
iter := &wrappedIterator{
nested: routePool.Endpoints(stickyEndpointId),
afterNext: func(endpoint *route.Endpoint) {
if endpoint != nil {
handler.logger.Set("RouteEndpoint", endpoint.ToLogData())
accessLog.RouteEndpoint = endpoint
p.reporter.CaptureRoutingRequest(endpoint, request)
}
},
}
if isTcpUpgrade(request) {
handler.HandleTcpRequest(iter)
return
}
if isWebSocketUpgrade(request) {
handler.HandleWebSocketRequest(iter)
return
}
proxyWriter := newProxyResponseWriter(responseWriter)
roundTripper := &proxyRoundTripper{
transport: p.transport,
iter: iter,
handler: &handler,
after: func(rsp *http.Response, endpoint *route.Endpoint, err error) {
accessLog.FirstByteAt = time.Now()
if rsp != nil {
accessLog.StatusCode = rsp.StatusCode
}
// disable keep-alives -- not needed with Go 1.3
responseWriter.Header().Set("Connection", "close")
if p.traceKey != "" && request.Header.Get(router_http.VcapTraceHeader) == p.traceKey {
setTraceHeaders(responseWriter, p.ip, endpoint.CanonicalAddr())
}
latency := time.Since(startedAt)
p.reporter.CaptureRoutingResponse(endpoint, rsp, startedAt, latency)
if err != nil {
p.reporter.CaptureBadGateway(request)
handler.HandleBadGateway(err)
proxyWriter.Done()
return
}
if endpoint.PrivateInstanceId != "" {
setupStickySession(responseWriter, rsp, endpoint)
}
},
}
proxyTransport := autowire.InstrumentedRoundTripper(roundTripper)
p.newReverseProxy(proxyTransport, request).ServeHTTP(proxyWriter, request)
accessLog.FinishedAt = time.Now()
accessLog.BodyBytesSent = int64(proxyWriter.Size())
}