Golang httputil.ReverseProxy类代码示例

func handler(proxy *httputil.ReverseProxy) func(http.ResponseWriter, *http.Request) {
	return func(writer http.ResponseWriter, request *http.Request) {
		vars := mux.Vars(request)
		log.Println(vars["branch"])
		proxy.ServeHTTP(writer, request)
	}
}

// This function isn't the default handler but returns the default handler, i.e. has
// a function closure. This allows me to set up my Mutex secured increment and decrement functions
// and assemble an access queue so that only five of the concurrent requests are being processed
// at any time, and put the function that reports the number of requests in a a global,
// so it may be called from main().
func makeDefaultHandler(p *httputil.ReverseProxy, overcapacityBehavior string) func(http.ResponseWriter, *http.Request) {
	capacityQueue := make(chan int, maxConcurrentRequests) // the Brass Rings, as it were.
	for i := 0; i < maxConcurrentRequests; i++ {           // grab one, and you're in. :)
		capacityQueue <- i
	}

	incrementConcurrentReqs, decrementConcurrentReqs, tellMeNumReqs := makeTotalConcurrentCounters()
	totalReqs = tellMeNumReqs

	return func(w http.ResponseWriter, r *http.Request) {
		incrementConcurrentReqs() // do this BEFORE pulling off queue; we want to count the reqs that wait
		log.Printf("New Request: now concurrent requests: %03d\n", tellMeNumReqs())
		if overcapacityBehavior == rejectOvercapacityReqs { // Reject more than five concurrent requests
			if tellMeNumReqs() > maxReqsAllowed {
				log.Printf("Surpassed capacity for %03d concurrent requests: sending back 503 error\n", maxReqsAllowed)
				http.Error(w, "Maximum Capacity Exceeded", http.StatusServiceUnavailable)
				return
			}
		} // overcapacityBehavior == rejectOvercapacityReqs
		queueSlot := <-capacityQueue
		log.Printf("queueSlot %d, Client requested %s, forwarding to localhost:8181 (totalReqs = %d)\n",
			queueSlot, r.URL, tellMeNumReqs())
		p.ServeHTTP(w, r)
		capacityQueue <- queueSlot
		decrementConcurrentReqs()
		log.Printf("Request completed: now concurrent requests: %03d\n", tellMeNumReqs())
	}
}

func main() {
	// get /blog => to server1
	// get /login => to server2
	var target1, target2 *url.URL
	var err error

	if target1, err = url.Parse(SERVER1); err != nil {
		log.Fatal("parse url: ", err)
	}

	if target2, err = url.Parse(SERVER2); err != nil {
		log.Fatal("parse url: ", err)
	}

	reverseProxy := new(httputil.ReverseProxy)

	reverseProxy.Director = func(req *http.Request) {
		req.URL.Scheme = "http"

		if strings.HasPrefix(req.URL.Path, "/blog") {
			req.URL.Host = target1.Host
		}

		if strings.HasPrefix(req.URL.Path, "/login") {
			req.URL.Host = target2.Host
		}
	}

	err = http.ListenAndServe(":80", reverseProxy)
	if err != nil {
		log.Fatal("ListenAndServe: ", err)
	}
}

func handler(p *httputil.ReverseProxy) func(http.ResponseWriter, *http.Request) {
	return func(w http.ResponseWriter, r *http.Request) {
		if isLogging {
			log.Printf("- %v, %v, %v", r.RemoteAddr, r.Method, r.RequestURI)
		}
		p.ServeHTTP(w, r)
	}
}

// ProxyHandle registers a new resource with its handler
func (r *AppRoute) ProxyHandle(method string, path string, proxy *httputil.ReverseProxy, filters ...ResponseFilter) {
	r.Handle(method, path, func(ctx *Context) {
		for _, filter := range filters {
			ctx.Response.Before(filter)
		}

		proxy.ServeHTTP(ctx.Response, ctx.Request)
	})
}

// Proxy will setup a direct proxy inbetween this service and the destination
// service.
func (c *Context) Proxy(targetURL string, rewrite func(req *http.Request)) error {
	target, err := url.Parse(targetURL)
	if err != nil {
		return err
	}

	// Define our custom request director to ensure that the correct headers are
	// forwarded as well as having the request path and query rewritten
	// properly.
	director := func(req *http.Request) {
		req.URL.Scheme = target.Scheme
		req.URL.Host = target.Host
		req.URL.Path = singleJoiningSlash(target.Path, req.URL.Path)

		if target.RawQuery == "" || req.URL.RawQuery == "" {
			req.URL.RawQuery = target.RawQuery + req.URL.RawQuery
		} else {
			req.URL.RawQuery = target.RawQuery + "&" + req.URL.RawQuery
		}

		// Set the headers on the incoming request by clearing them all out.
		req.Header = make(http.Header)

		// Rewrite the request for the director if a rewrite function was passed.
		if rewrite != nil {
			rewrite(req)
		}
	}

	// Make a copy of the current upstream headers on the request.
	upstreamHeaders := make(http.Header)
	copyHeader(upstreamHeaders, c.Header())

	// Create a new reverse proxy. We need to to this here because for the path
	// rewriting we may need access to variables stored in this specific
	// request's path parameters which can allow to be overridden via the
	// rewrite argument to this function.
	proxy := httputil.ReverseProxy{Director: director}

	// Create a new proxy response writer that will record the http status code
	// issued by the reverse proxy.
	prw := ProxyResponseWriter{
		UpstreamHeaders: upstreamHeaders,
		ResponseWriter:  c.ResponseWriter,
	}

	// Serve the request via the built in handler here.
	proxy.ServeHTTP(&prw, c.Request)

	// Set the status code so that we can log the response code later.
	c.Status = prw.Status

	return nil
}

func handler(p *httputil.ReverseProxy, redisClient *redis.Client) func(http.ResponseWriter, *http.Request) {
	return func(w http.ResponseWriter, r *http.Request) {

		hash := hashKey(r)

		serializableResponse := SerializableResponse{make(map[string][]string), nil}

		s, err := redisClient.Get(hash)
		if err != nil { // The request is not cached
			rec := httptest.NewRecorder()
			log.Println("Non cached: " + hash)

			// Perform the real request and cache it
			p.ServeHTTP(rec, r)

			for k, v := range rec.Header() {
				serializableResponse.Header[k] = v
			}
			serializableResponse.Body = rec.Body.Bytes()

			jsonResponse, err := json.Marshal(serializableResponse)
			if err != nil {
				panic(err)
			}
			redisClient.Set(hash, jsonResponse)
			w.Header().Set("X-Eidetic", "Live request")

		} else { // The request is cached
			log.Println("Cached!: " + hash)

			// Load the cached request
			err = json.Unmarshal([]byte(s), &serializableResponse)
			if err != nil {
				panic(err)
			}

			w.Header().Set("X-Eidetic", "Cached request")

		}

		//Copy the data to the actual ResponseWriter
		// log.Println("\n\n\nResponse Headers:")
		for k, v := range serializableResponse.Header {
			w.Header()[k] = v
			// log.Println(k + ": ")
			// for _, str := range v {
			// 	log.Println("  " + str)
			// }
		}
		w.Write([]byte(serializableResponse.Body))
		// log.Println("\nResponse body:\n" + string(serializableResponse.Body))

	}
}

func handler(p *httputil.ReverseProxy) func(http.ResponseWriter, *http.Request) {

	return func(w http.ResponseWriter, r *http.Request) {
		log.Println(r.URL.Path)

		return
		_, err := os.Stat(CACHE_PATH + r.URL.Path)
		if os.IsNotExist(err) {
			log.Println("Miss")
		} else {
			p.ServeHTTP(w, r)
		}

	}
}

func handler(p *httputil.ReverseProxy) func(http.ResponseWriter, *http.Request) {
	return func(w http.ResponseWriter, r *http.Request) {
		r.Header.Set("X-Forwarded-Proto", "https")

		session, _ := sessions.SessionStore.Get(r, "session-name")
		userLoginId := session.Values[sessions.USER_LOGIN_ID]
		if userLoginId != nil {
			r.Header.Set("REMOTE_USER", userLoginId.(string))
		}
		p.ServeHTTP(w, r)

		newLoc := w.Header().Get("Location")
		if newLoc != "" {
			log.Println("Redirecting.. " + newLoc)
		}
	}
}

func setProxyDirector(proxy *httputil.ReverseProxy) {
	director := proxy.Director
	proxy.Director = func(req *http.Request) {
		director(req)
		// use RequestURI so that we aren't unescaping encoded slashes in the request path
		req.URL.Opaque = req.RequestURI
		req.URL.RawQuery = ""
	}
}

func setProxyUpstreamHostHeader(proxy *httputil.ReverseProxy, target *url.URL) {
	director := proxy.Director
	proxy.Director = func(req *http.Request) {
		director(req)
		// use RequestURI so that we aren't unescaping encoded slashes in the request path
		req.Host = target.Host
		req.URL.Opaque = req.RequestURI
		req.URL.RawQuery = ""
	}
}

func handler(fw *httputil.ReverseProxy) func(http.ResponseWriter, *http.Request) {
	return func(wr http.ResponseWriter, req *http.Request) {
		wr.Header()["X-Powered-By"] = []string{"jenkins-authentication-proxy/" + version}
		if isOpenPrefix(req.RequestURI) {
			fw.ServeHTTP(wr, req)
			return
		}

		if authed, err := authenticateWithBackend(req); err != nil {
			wr.WriteHeader(http.StatusInternalServerError)
			fmt.Fprint(wr, "error", err)
			log.Print(err)
		} else if authed {
			fw.ServeHTTP(wr, req)
		} else {
			wr.Header()["Www-Authenticate"] = []string{"Basic realm=\"Jenkins\""}
			wr.WriteHeader(http.StatusUnauthorized)
		}
	}
}

func main() {
	var srv httputil.ReverseProxy

	log.SetFlags(0)
	flag.Parse()
	if *file == "" {
		log.Print("config file (-c) is required")
		flag.PrintDefaults()
		os.Exit(1)
	}
	if cfg, err := config.ParseFile(*file); err != nil {
		log.Fatalf("parse %s failed: %s", *file, err)
	} else {
		srv.Director = cfg.MapRequest
		if *addr == "" {
			*addr = cfg.Address
		}
	}
	http.Handle("/render", accesslog.Handler(&srv, nil))
	log.Fatal(http.ListenAndServe(*addr, nil))
}

func main() {
	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		if strings.HasSuffix(r.Host, "manveru.name") {
			proxy := httputil.ReverseProxy{Director: manveruDotName}
			proxy.ServeHTTP(w, r)
		} else if strings.HasSuffix(r.Host, "nsans.eu") {
			proxy := httputil.ReverseProxy{Director: nsansDotEu}
			proxy.ServeHTTP(w, r)
		} else {
			w.WriteHeader(404)
		}
	})

	err := http.ListenAndServe("0.0.0.0:80", nil)
	if err != nil {
		log.Fatalln("ListenAndServe:", err)
	}
}

func proxyHandler(p *httputil.ReverseProxy) func(http.ResponseWriter, *http.Request) {
	return func(w http.ResponseWriter, r *http.Request) {
		r.Header.Add("Proxy-RemoteIP", strings.Split(r.RemoteAddr, ":")[0])
		p.ServeHTTP(w, r)
	}
}