Example #1
0
func (f *forwarder) Apply(w http.ResponseWriter, req *http.Request, next filters.Next) error {
	op := ops.Begin("proxy_http")
	defer op.End()

	// Create a copy of the request suitable for our needs
	reqClone, err := f.cloneRequest(req, req.URL)
	if err != nil {
		return op.FailIf(filters.Fail("Error forwarding from %v to %v: %v", req.RemoteAddr, req.Host, err))
	}
	f.Rewriter.Rewrite(reqClone)

	if log.IsTraceEnabled() {
		reqStr, _ := httputil.DumpRequest(req, false)
		log.Tracef("Forwarder Middleware received request:\n%s", reqStr)

		reqStr2, _ := httputil.DumpRequest(reqClone, false)
		log.Tracef("Forwarder Middleware forwarding rewritten request:\n%s", reqStr2)
	}

	// Forward the request and get a response
	start := time.Now().UTC()
	response, err := f.RoundTripper.RoundTrip(reqClone)
	if err != nil {
		return op.FailIf(filters.Fail("Error forwarding from %v to %v: %v", req.RemoteAddr, req.Host, err))
	}
	log.Debugf("Round trip: %v, code: %v, duration: %v",
		reqClone.URL, response.StatusCode, time.Now().UTC().Sub(start))

	if log.IsTraceEnabled() {
		respStr, _ := httputil.DumpResponse(response, true)
		log.Tracef("Forward Middleware received response:\n%s", respStr)
	}

	// Forward the response to the origin
	copyHeadersForForwarding(w.Header(), response.Header)
	w.WriteHeader(response.StatusCode)

	// It became nil in a Co-Advisor test though the doc says it will never be nil
	if response.Body != nil {
		buf := buffers.Get()
		defer buffers.Put(buf)
		_, err = io.CopyBuffer(w, response.Body, buf)
		if err != nil {
			log.Debug(err)
		}

		response.Body.Close()
	}

	return filters.Stop()
}
Example #2
0
func (f *forwarder) Apply(w http.ResponseWriter, req *http.Request, next filters.Next) error {
	if !f.Force {
		persistentAllowed, _ := strconv.ParseBool(req.Header.Get(XLanternPersistent))
		if !persistentAllowed {
			return next()
		}
	}

	op := ops.Begin("proxy_http")
	defer op.End()
	err := f.intercept(w, req)
	if err != nil {
		log.Error(op.FailIf(err))
	}
	return filters.Stop()
}
Example #3
0
func (f *httpConnectHandler) Apply(w http.ResponseWriter, req *http.Request, next filters.Next) error {
	if req.Method != "CONNECT" {
		return next()
	}

	if log.IsTraceEnabled() {
		reqStr, _ := httputil.DumpRequest(req, true)
		log.Tracef("httpConnectHandler Middleware received request:\n%s", reqStr)
	}

	op := ops.Begin("proxy_https")
	defer op.End()
	if f.portAllowed(op, w, req) {
		err := f.intercept(w, req)
		if err != nil {
			log.Error(op.FailIf(err))
		}
	}

	return filters.Stop()
}
Example #4
0
func fail(resp http.ResponseWriter, err error) error {
	resp.WriteHeader(http.StatusForbidden)
	fmt.Fprint(resp, err)
	return filters.Stop()
}