Golang ServeMux.ServeHTTP方法代码示例

func TestHandleFunc(t *testing.T) {
	wfe := setupWFE(t)
	var mux *http.ServeMux
	var rw *httptest.ResponseRecorder
	var stubCalled bool
	runWrappedHandler := func(req *http.Request, allowed ...string) {
		mux = http.NewServeMux()
		rw = httptest.NewRecorder()
		stubCalled = false
		wfe.HandleFunc(mux, "/test", func(http.ResponseWriter, *http.Request) {
			stubCalled = true
		}, allowed...)
		req.URL = mustParseURL("/test")
		mux.ServeHTTP(rw, req)
	}

	// Plain requests (no CORS)
	type testCase struct {
		allowed       []string
		reqMethod     string
		shouldSucceed bool
	}
	var lastNonce string
	for _, c := range []testCase{
		{[]string{"GET", "POST"}, "GET", true},
		{[]string{"GET", "POST"}, "POST", true},
		{[]string{"GET"}, "", false},
		{[]string{"GET"}, "POST", false},
		{[]string{"GET"}, "OPTIONS", false},     // TODO, #469
		{[]string{"GET"}, "MAKE-COFFEE", false}, // 405, or 418?
	} {
		runWrappedHandler(&http.Request{Method: c.reqMethod}, c.allowed...)
		test.AssertEquals(t, stubCalled, c.shouldSucceed)
		if c.shouldSucceed {
			test.AssertEquals(t, rw.Code, http.StatusOK)
		} else {
			test.AssertEquals(t, rw.Code, http.StatusMethodNotAllowed)
			test.AssertEquals(t, sortHeader(rw.Header().Get("Allow")), strings.Join(c.allowed, ", "))
			test.AssertEquals(t,
				rw.Body.String(),
				`{"type":"urn:acme:error:malformed","detail":"Method not allowed"}`)
		}
		nonce := rw.Header().Get("Replay-Nonce")
		test.AssertNotEquals(t, nonce, lastNonce)
		lastNonce = nonce
	}

	// Disallowed method returns error JSON in body
	runWrappedHandler(&http.Request{Method: "PUT"}, "GET", "POST")
	test.AssertEquals(t, rw.Header().Get("Content-Type"), "application/problem+json")
	test.AssertEquals(t, rw.Body.String(), `{"type":"urn:acme:error:malformed","detail":"Method not allowed"}`)
	test.AssertEquals(t, sortHeader(rw.Header().Get("Allow")), "GET, POST")

	// Disallowed method special case: response to HEAD has got no body
	runWrappedHandler(&http.Request{Method: "HEAD"}, "GET", "POST")
	test.AssertEquals(t, stubCalled, false)
	test.AssertEquals(t, rw.Body.String(), "")
	test.AssertEquals(t, sortHeader(rw.Header().Get("Allow")), "GET, POST")
}

func Use(h *http.ServeMux) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		for _, handler := range handlers {
			if !handler(w, r) {
				// Abort if function responded with false
				return
			}
		}

		h.ServeHTTP(w, r)
	}
}

func WithProxyMux(handler http.Handler, mux *http.ServeMux) http.Handler {
	if mux == nil {
		return handler
	}

	// register the handler at this stage against everything under slash.  More specific paths that get registered will take precedence
	// this effectively delegates by default unless something specific gets registered.
	mux.Handle("/", handler)

	return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
		mux.ServeHTTP(w, req)
	})
}

func HandlerMux(s *http.ServeMux, rules *rules) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		m := NewMobileDetect(r, rules)
		if m.IsTablet() {
			context.Set(r, "Device", "Tablet")
		} else if m.IsMobile() {
			context.Set(r, "Device", "Mobile")
		} else {
			context.Set(r, "Device", "Desktop")
		}
		s.ServeHTTP(w, r)
	})
}

func setupTChan(t *testing.T, mux *http.ServeMux) (string, func()) {
	ch := testutils.NewServer(t, testutils.NewOpts().SetServiceName("test"))
	handler := func(ctx context.Context, call *tchannel.InboundCall) {
		req, err := ReadRequest(call)
		if !assert.NoError(t, err, "ReadRequest failed") {
			return
		}

		// Make the HTTP call using the default mux.
		writer, finish := ResponseWriter(call.Response())
		mux.ServeHTTP(writer, req)
		finish()
	}
	ch.Register(tchannel.HandlerFunc(handler), "http")
	return ch.PeerInfo().HostPort, func() { ch.Close() }
}

func NewDigestAuthFilter(myMux *http.ServeMux, tm *JwtManager,
	digestRealm string, tlsConfig *tls.Config) http.Handler {

	authenticator := auth.NewDigestAuthenticator(digestRealm, func(user, realm string) string {
		return getUserString(tlsConfig, user, "digest")
	})

	newMux := http.NewServeMux()
	// Override the builtin wrap function to include our capabilities.
	newMux.HandleFunc("/",
		authenticator.Wrap(func(w http.ResponseWriter, ar *auth.AuthenticatedRequest) {
			t := tm.New(ar.Username)
			err := tm.AddTokenInfo(t, w, &ar.Request)
			if err != nil {
				log.Printf("Add token had issues: %v\n", err)
			}

			myMux.ServeHTTP(w, &ar.Request)
		}))

	return newMux
}

	revel.TemplateFuncs["javascript_include_tag"] = train.JavascriptTag
	revel.TemplateFuncs["stylesheet_link_tag"] = train.StylesheetTag
}

var AssetsFilter = func(c *revel.Controller, fc []revel.Filter) {
	if strings.HasPrefix(c.Request.URL.Path, "/assets") {
		train.ServeRequest(c.Response.Out, c.Request.Request)
	} else {
		fc[0](c, fc[1:])
	}
}

var AdminFilter = func(c *revel.Controller, fc []revel.Filter) {
	if strings.HasPrefix(c.Request.URL.Path, "/admin") {
		mux.ServeHTTP(c.Response.Out, c.Request.Request)
	} else {
		fc[0](c, fc[1:])
	}
}

func initAdmin() {
	Admin = admin.New(&qor.Config{DB: models.DB})
	Publish = publish.New(models.DB)
	sorting.RegisterCallbacks(models.DB)
	validations.RegisterCallbacks(models.DB)

	nodeSelectMeta := &admin.Meta{Name: "NodeId", Type: "select_one", Collection: nodeCollection}
	bodyMeta := &admin.Meta{Name: "Body", Type: "text"}

	Admin.AddResource(&admin.AssetManager{}, &admin.Config{Invisible: true})

func RootHandler(Layout *template.Template, Exits *Exits, domain *gettext.Domain, Phttp *http.ServeMux, Locales map[string]string) http.HandlerFunc {

	return func(w http.ResponseWriter, r *http.Request) {

		// serve public files
		if len(r.URL.Path) > 1 {
			Phttp.ServeHTTP(w, r)
			return
		}

		var (
			err         error
			isTor       bool
			host        string
			onOff       string
			fingerprint string
		)

		if host, err = GetHost(r); err == nil {
			fingerprint, isTor = Exits.IsTor(host)
		}

		// short circuit for torbutton
		if IsParamSet(r, "TorButton") {
			WriteHTMLBuf(w, r, Layout, domain, "torbutton.html", Page{IsTor: isTor})
			return
		}

		// try to determine if it's TBB
		notTBB := !LikelyTBB(r.UserAgent())

		// users shouldn't be relying on check
		// to determine the TBB is up-to-date
		// always return false to this param
		notUpToDate := IsParamSet(r, "uptodate")

		// string used for classes and such
		// in the template
		if isTor {
			if notTBB || notUpToDate {
				onOff = "not"
			} else {
				onOff = "on"
			}
		} else {
			onOff = "off"
		}

		// instance of your page model
		p := Page{
			isTor,
			notUpToDate,
			IsParamSet(r, "small"),
			notTBB,
			fingerprint,
			onOff,
			Lang(r),
			host,
			Locales,
		}

		// render the template
		WriteHTMLBuf(w, r, Layout, domain, "index.html", p)
	}

}

func RootHandler(Layout *template.Template, Exits *Exits, Phttp *http.ServeMux) func(http.ResponseWriter, *http.Request) {

	return func(w http.ResponseWriter, r *http.Request) {

		// serve public files
		if len(r.URL.Path) > 1 {
			Phttp.ServeHTTP(w, r)
			return
		}

		// get remote ip
		host := r.Header.Get("X-Forwarded-For")
		var err error
		if len(host) == 0 {
			host, _, err = net.SplitHostPort(r.RemoteAddr)
		}

		// determine if we're in Tor
		var isTor bool
		if err != nil {
			isTor = false
		} else {
			isTor = Exits.IsTor(host)
		}

		// short circuit for torbutton
		if len(r.URL.Query().Get("TorButton")) > 0 {
			if err := Layout.ExecuteTemplate(w, "torbutton.html", isTor); err != nil {
				http.Error(w, err.Error(), http.StatusInternalServerError)
			}
			return
		}

		// string used for classes and such
		// in the template
		var onOff string
		if isTor {
			onOff = "on"
		} else {
			onOff = "off"
		}

		small := Small(r)
		upToDate := UpToDate(r)

		// querystring params
		extra := ""
		if small {
			extra += "&small=1"
		}
		if !upToDate {
			extra += "&uptodate=0"
		}

		// instance of your page model
		p := Page{
			isTor,
			isTor && !upToDate,
			!small,
			onOff,
			Lang(r),
			host,
			extra,
			Locales,
		}

		// render the template
		if err := Layout.ExecuteTemplate(w, "index.html", p); err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
		}

	}

}