// Router adds panel routes to an existing mux.Router. func UIRouter(theBaseHref string, rt *mux.Router) *mux.Router { baseHref = theBaseHref rt.Path("/calls").Methods("GET").HandlerFunc(uiCalls).Name(appmonUICalls) rt.Path("/").Methods("GET").HandlerFunc(uiMain).Name(appmonUIMain) return rt }
func InitAnswerRoutes(r *mux.Router) *mux.Router { //PUT r.Path("/{category:[a-z]+}/{questionID:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/answer}").Methods("PUT").Name(CreatePendingAnswer) r.Path("/{category:[a-z]+}/answer/{answerID:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/vote/{vote:-1|1}}").Methods("PUT").Name(UpdateAnswerVote) return r }
// PopulateRouter adds all Coordinate URL paths to a router. func (api *restAPI) PopulateRouter(r *mux.Router) { api.PopulateNamespace(r) r.Path("/").Name("root").Handler(&resourceHandler{ Representation: restdata.RootData{}, Context: api.Context, Get: api.RootDocument, }) }
func setupApiApps(apirouter *mux.Router, domainmgr DomainManager, usermgr UserManager) { prefix, _ := apirouter.Path("/").URL() apirouter.PathPrefix("/v1").Handler( context.ClearHandler(HandlerList{ SilentHandler(SessionHandler(options.SessionStore, int(options.SessionTTL/time.Second))), SilentHandler(BasicAuth(usermgr)), SilentHandler(ValidateUID(usermgr)), http.StripPrefix(prefix.Path+"v1", NewAPIv1(domainmgr, usermgr)), })) }
/* DocHandle registeres a path/method/api version route in the provided router, handled by the provided f, wrapping it in appstats.NewHandler, registering the f-function and its route with jsoncontext.Document and then using jsoncontext.Handle to do something that acts like JSONHandlerFunc. */ func DocHandle(router *mux.Router, f interface{}, path string, method string, minAPIVersion, maxAPIVersion int, scopes ...string) { doc, fu := jsoncontext.Document(f, path, method, minAPIVersion, maxAPIVersion, scopes...) jsoncontext.Remember(doc) router.Path(path).Methods(method).Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { gaeCont := appengine.NewContext(r) c := NewJSONContext(gaeCont, jsoncontext.NewJSONContext(httpcontext.NewHTTPContext(w, r))) jsoncontext.Handle(c, func() (resp jsoncontext.Resp, err error) { return fu(c) }, minAPIVersion, maxAPIVersion, scopes...) })) }
func (a *AgentCommand) dashboardRoutes(r *mux.Router) { r.Path("/" + dashboardPathPrefix).HandlerFunc(a.dashboardIndexHandler) subui := r.PathPrefix("/" + dashboardPathPrefix).Subrouter() subui.HandleFunc("/jobs", a.dashboardJobsHandler) subui.HandleFunc("/jobs/{job}/executions", a.dashboardExecutionsHandler) // Path of static files must be last! r.PathPrefix("/dashboard").Handler( http.StripPrefix("/dashboard", http.FileServer( http.Dir(filepath.Join(a.config.UIDir, "static"))))) }
func ServStatic(router *mux.Router) { statikFS, se := fs.New() if se != nil { log.Fatalf(se.Error()) } // statikFS := http.Dir(filepath.Join(Settings.Root, "htdocs")) ss := http.FileServer(statikFS) router.PathPrefix("/static/").Handler(ss).Methods("GET", "HEAD") router.Path("/favicon.ico").Handler(ss).Methods("GET", "HEAD") router.Path("/robots.txt").Handler(ss).Methods("GET", "HEAD") }
func Routes(r *mux.Router) { ps := r.Path("/paintings").Subrouter() ps.Methods("GET").Handler(listPaintings) ps.Methods("POST").Handler(createPainting) r.Methods("GET").Path("/paintings/categories").Handler(listCategories) r.Methods("GET").Path("/paintings/media").Handler(listMedia) p := r.Path("/paintings/{ID:[0-9]+}").Subrouter() p.Methods("GET").Handler(showPainting) p.Methods("PUT").Handler(editPainting) r.Methods("POST").Path("/paintings/{ID:[0-9]+}/rotate").Handler(rotatePainting) }
func (m *overchanMiddleware) SetupRoutes(mux *mux.Router) { // setup front page handler mux.Path("/").HandlerFunc(m.ServeIndex) // setup thread handler mux.Path("/thread/{id}/").HandlerFunc(m.ServeThread) // setup board page handler mux.Path("/board/{name}/").HandlerFunc(m.ServeBoardPage) // setup posting endpoint mux.Path("/post") // create captcha captchaPrefix := "/captcha/" m.captcha = NewCaptchaServer(200, 400, captchaPrefix, m.store) // setup captcha endpoint m.captcha.SetupRoutes(mux.PathPrefix(captchaPrefix).Subrouter()) }
func createRoute(router *mux.Router, route Route) { r := router. Path(route.Path). Name(route.Name) if route.Headers != nil { r.Headers(route.Headers...) } if route.Queries != nil { r.Queries(route.Queries...) } if route.Schemes != nil { r.Schemes(route.Schemes...) } if route.Methods != nil { r.Methods(route.Methods...) } if route.Host != "" { r.Host(route.Host) } r.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { handler := route.Handler for _, middleware := range route.Middleware { handler = middleware(handler) } handler.ServeHTTP(w, r) }) }
func (a *AgentCommand) apiRoutes(r *mux.Router) { r.Path("/v1").HandlerFunc(a.indexHandler) subver := r.PathPrefix("/v1").Subrouter() subver.HandleFunc("/members", a.membersHandler) subver.HandleFunc("/leader", a.leaderHandler) subver.Path("/jobs").HandlerFunc(a.jobCreateOrUpdateHandler).Methods("POST", "PATCH") subver.Path("/jobs").HandlerFunc(a.jobsHandler).Methods("GET") sub := subver.PathPrefix("/jobs").Subrouter() sub.HandleFunc("/{job}", a.jobGetHandler).Methods("GET") sub.HandleFunc("/{job}", a.jobDeleteHandler).Methods("DELETE") sub.HandleFunc("/{job}", a.jobRunHandler).Methods("POST") subex := subver.PathPrefix("/executions").Subrouter() subex.HandleFunc("/{job}", a.executionsHandler).Methods("GET") }
func setupAuthApps(authrouter *mux.Router, usermgr UserManager) { for _, authkey := range options.AuthKeys { authconfig, ok := (*options.AuthConfigs)[authkey.Name] if !ok { log.Printf("Unknown authenticator \"%s\", skipping", authkey.Name) continue } authconfig.AuthKey = authkey var auth Authenticator var ex Extractor prefix, _ := authrouter.Path("/" + authkey.Name).URL() switch authconfig.Extractor.Type { case "json": ex = NewJSONExtractor(authconfig.Extractor.URL, authconfig.Extractor.Field) default: log.Printf("Unknown extractor \"%s\", skipping", authconfig.Extractor.Type) continue } switch authconfig.Type { case "oauth": log.Printf("Enabling %s OAuth on %s with ClientID %s", authkey.Name, prefix.String(), authconfig.AuthKey.ClientID) auth = NewOAuthAuthenticator(authkey.Name, &oauth.Config{ ClientId: authconfig.AuthKey.ClientID, ClientSecret: authconfig.AuthKey.Secret, AuthURL: authconfig.AuthURL, TokenURL: authconfig.TokenURL, Scope: authconfig.Scope, RedirectURL: prefix.String() + "/callback", }, ex, usermgr) default: log.Printf("Unknown authenticator \"%s\", skipping", authconfig.Type) continue } authrouter.PathPrefix("/" + authkey.Name).Handler( context.ClearHandler(HandlerList{ SilentHandler(SessionHandler(options.SessionStore, int(options.SessionTTL/time.Second))), http.StripPrefix(prefix.Path, auth), })) } authrouter.Handle("/", authListHandler(options.AuthConfigs)) authrouter.Path("/logout").Handler( context.ClearHandler(HandlerList{ SilentHandler(SessionHandler(options.SessionStore, int(options.SessionTTL/time.Second))), http.HandlerFunc(LogoutHandler), })) }
// PopulateNamespace adds namespace-specific routes to a router. // r should be rooted at the root of the Coordinate URL tree, e.g. "/". func (api *restAPI) PopulateNamespace(r *mux.Router) { r.Path("/namespace").Name("namespaces").Handler(&resourceHandler{ Representation: restdata.NamespaceShort{}, Context: api.Context, Get: api.NamespaceList, Post: api.NamespacePost, }) r.Path("/namespace/{namespace}").Name("namespace").Handler(&resourceHandler{ Representation: restdata.Namespace{}, Context: api.Context, Get: api.NamespaceGet, Delete: api.NamespaceDelete, }) sr := r.PathPrefix("/namespace/{namespace}").Subrouter() api.PopulateWorkSpec(sr) api.PopulateWorker(sr) }
func setupPaymentsRoutes(r *mux.Router) { client := redis.NewTCPClient(&redis.Options{ Addr: "localhost:6379", Password: "", // no password set DB: 0, // use default DB }) store := &RedisStorage{ Client: client, } ph := NewPaymentsHandler(store) r. Path("/api/payments/{id}"). Methods("GET"). HandlerFunc(func(w http.ResponseWriter, r *http.Request) { vars := mux.Vars(r) id := vars["id"] p, err := ph.Get(id) if err != nil { http.Error(w, "Not found", http.StatusNotFound) return } renderAsJson(w, p) }) r. Path("/api/payments"). Methods("POST"). HandlerFunc(func(w http.ResponseWriter, r *http.Request) { decoder := json.NewDecoder(r.Body) var p Payments err := decoder.Decode(&p) if err != nil { http.Error(w, "Bad data", http.StatusBadRequest) return } p, err = ph.Create(p) if err != nil { http.Error(w, "Err", http.StatusInternalServerError) return } renderAsJson(w, p) }) }
// SetupRoutes populates the routes for the REST interface func SetupRoutes(r *mux.Router) { // API v1 r.Path("/api/v1/mailbox/{name}").Handler(httpd.Handler(MailboxListV1)).Name("MailboxListV1").Methods("GET") r.Path("/api/v1/mailbox/{name}").Handler(httpd.Handler(MailboxPurgeV1)).Name("MailboxPurgeV1").Methods("DELETE") r.Path("/api/v1/mailbox/{name}/{id}").Handler(httpd.Handler(MailboxShowV1)).Name("MailboxShowV1").Methods("GET") r.Path("/api/v1/mailbox/{name}/{id}").Handler(httpd.Handler(MailboxDeleteV1)).Name("MailboxDeleteV1").Methods("DELETE") r.Path("/api/v1/mailbox/{name}/{id}/source").Handler(httpd.Handler(MailboxSourceV1)).Name("MailboxSourceV1").Methods("GET") }
func InitQuestionRoutes(r *mux.Router) *mux.Router { //GET r.Path("/post/{questionId:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}}").Methods("GET").Name(ReadPost) r.Path("/questions/{filter:posted-by|answered-by|category}/{val:[A-Za-z0-9]+}").Methods("GET").Name(ReadQuestionsByFilter) r.Path("/{postComponent:questions|answers}/{sortedBy:upvotes|edits|date}/{order:desc|asc}/{offset:[0-9]+}").Methods("GET").Name(ReadSortedQuestions) //POST r.Path("/question/{category:[a-z]+}").Methods("POST").Name(CreateQuestion) return r }
// Setup sub routes for more efficient routing of requests inside of gorilla mux. func (f *Fogo) SubRoute(prefix, path string, methods []string, hf FogoHandler) { var subRouter *mux.Router var ok bool subRouter, ok = f.subRoutes[prefix] if !ok { subRouter = f.router.PathPrefix(prefix).Subrouter() f.subRoutes[prefix] = subRouter } fn := func(w http.ResponseWriter, r *http.Request) { f.runRoute(w, r, hf, prefix+path) } if methods != nil { subRouter.Path(path).Methods(methods...).HandlerFunc(fn) } else { subRouter.Path(path).HandlerFunc(fn) } }
func InitUserRoutes(r *mux.Router) *mux.Router { //GET r.Path("/{filter:id|username}/{searchVal:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}|[a-z0-9]}").Methods("GET").Name(ReadUser) //POST r.Path("/register").Methods("POST").Name(CreateUser) r.Path("/login").Methods("POST").Name(Login) r.Path("/logout").Methods("POST").Name(Logout) return r }
func AddRoutes(router *mux.Router) *mux.Router { router.Path("/") for acceptHeader, vApi := range acceptVersionMap { // Create a subrouter for the header/api version. subrouter := router.MatcherFunc( acceptOrQueryMatcherFactory(acceptHeader)).Subrouter() // Define the path/handler relationships. pathHandlerMap := map[string]func(http.ResponseWriter, *http.Request){ "/json.json": vApi.JsonHandler, "/json2.json": vApi.JsonHandler2, "/json3.json": vApi.JsonHandler3, } // Create a route in the subrouter for each path/handler. for path, handler := range pathHandlerMap { route := subrouter.HandleFunc(path, handler) route.Name(fmt.Sprintf("%s - %s", path, handler)) } } return router }
// Router adds panel routes to an existing mux.Router. func UIRouter(theBaseHref string, rt *mux.Router) *mux.Router { baseHref = theBaseHref rt.Path("/calls").Methods("GET").HandlerFunc(uiCalls).Name(trackUICalls) rt.Path("/views").Methods("GET").HandlerFunc(uiViews).Name(trackUIViews) rt.Path("/users").Methods("GET").HandlerFunc(uiUsers).Name(trackUIUsers) rt.Path("/").Methods("GET").HandlerFunc(uiMain).Name(trackUIMain) return rt }
func CreateObjectServer(router *mux.Router, repository ObjectRepository) *ObjectServer { server := &ObjectServer{ repository: repository, } server.route = router.Path("/{id}").HandlerFunc(func(w http.ResponseWriter, req *http.Request) { vars := mux.Vars(req) id := vars["id"] if id == "" { log.Println("bad request: no ID specified") http.Error(w, "no ID specified", http.StatusBadRequest) return } object, found := repository.FindObject(id) if !found { err := fmt.Errorf("id not found: %s", id) log.Printf(err.Error()) http.NotFound(w, req) return } data, err := object.Open() if err != nil { err := fmt.Sprintf("error opening object %s: %s", id, err) log.Printf(err) http.Error(w, err, http.StatusInternalServerError) return } defer data.Close() log.Printf("loaded object id: %s (%d bytes)", id, object.Size()) http.ServeContent(w, req, id, object.LastModified(), data) }) return server }
func setupPrimaryRouter(r *mux.Router, context *context, enableCors bool) { for method, mappings := range routes { for route, fct := range mappings { log.WithFields(log.Fields{"method": method, "route": route}).Debug("Registering HTTP route") localRoute := route localFct := fct wrap := func(w http.ResponseWriter, r *http.Request) { log.WithFields(log.Fields{"method": r.Method, "uri": r.RequestURI}).Debug("HTTP request received") if enableCors { writeCorsHeaders(w, r) } context.apiVersion = mux.Vars(r)["version"] localFct(context, w, r) } localMethod := method r.Path("/v{version:[0-9]+.[0-9]+}" + localRoute).Methods(localMethod).HandlerFunc(wrap) r.Path(localRoute).Methods(localMethod).HandlerFunc(wrap) if enableCors { optionsMethod := "OPTIONS" optionsFct := optionsHandler wrap := func(w http.ResponseWriter, r *http.Request) { log.WithFields(log.Fields{"method": optionsMethod, "uri": r.RequestURI}). Debug("HTTP request received") if enableCors { writeCorsHeaders(w, r) } context.apiVersion = mux.Vars(r)["version"] optionsFct(context, w, r) } r.Path("/v{version:[0-9]+.[0-9]+}" + localRoute). Methods(optionsMethod).HandlerFunc(wrap) r.Path(localRoute).Methods(optionsMethod). HandlerFunc(wrap) } } } }
func SetRoutes(r *mux.Router) { simulate := r.Path("/simulate").Subrouter() simulate.Methods("GET").HandlerFunc(SimulateGet) people := r.Path("/people").Subrouter() people.Methods("GET").HandlerFunc(PeopleGet) people.Methods("POST").HandlerFunc(PeoplePost) r.Path("/people/new").Methods("GET").HandlerFunc(PeopleGetNew) person := r.PathPrefix("/people/{id:[0-9]+}").Subrouter() person.Methods("GET").HandlerFunc(PeopleGetOne) person.Methods("POST").HandlerFunc(PeoplePostOne) person.Methods("DELETE").HandlerFunc(PeoplePostRemove) person.Path("/allocations").Methods("GET").HandlerFunc(PeopleAllocateGet) r.PathPrefix("/s/").Handler(http.StripPrefix("/s/", http.FileServer(http.Dir("./public")))) r.HandleFunc("/", HomeIndex) http.Handle("/", r) }
// PopulateWorkUnit adds routes to a namespace router to manipulate // work unit. r should generally be rooted in a subpath like // /namespace/{}/work_spec/{}. func (api *restAPI) PopulateWorkUnit(r *mux.Router) { r.Path("/work_unit").Name("workUnits").Handler(&resourceHandler{ Representation: restdata.WorkUnit{}, Context: api.Context, Get: api.WorkUnitsGet, Delete: api.WorkUnitsDelete, Post: api.WorkUnitsPost, }) r.Path("/work_unit/{unit}").Name("workUnit").Handler(&resourceHandler{ Representation: restdata.WorkUnit{}, Context: api.Context, Get: api.WorkUnitGet, Put: api.WorkUnitPut, }) r.Path("/work_unit/{unit}/attempts").Name("workUnitAttempts").Handler(&resourceHandler{ Representation: restdata.AttemptList{}, Context: api.Context, Get: api.WorkUnitAttempts, }) sr := r.PathPrefix("/work_unit/{unit}").Subrouter() api.PopulateAttempt(sr) }
func (a *AgentCommand) dashboardRoutes(r *mux.Router) { r.Path("/dashboard").HandlerFunc(a.dashboardIndexHandler).Methods("GET") subui := r.PathPrefix("/dashboard").Subrouter() subui.HandleFunc("/jobs", a.dashboardJobsHandler).Methods("GET") subui.HandleFunc("/jobs/{job}/executions", a.dashboardExecutionsHandler).Methods("GET") }
// SetupProtobufV2Paths tells the router which paths the given handler (which should handle v2 protobufs) // should see func SetupProtobufV2Paths(r *mux.Router, handler http.Handler) { r.Path("/v2/datapoint").Methods("POST").Headers("Content-Type", "application/x-protobuf").Handler(handler) }
// SetupJSONV2Paths tells the router which paths the given handler (which should handle v2 JSON) // should see func SetupJSONV2Paths(r *mux.Router, handler http.Handler) { r.Path("/v2/datapoint").Methods("POST").Headers("Content-Type", "application/json").Handler(handler) r.Path("/v2/datapoint").Methods("POST").Headers("Content-Type", "").HandlerFunc(invalidContentType) r.Path("/v2/datapoint").Methods("POST").Handler(handler) }
func (api *restAPI) PopulateAttempt(r *mux.Router) { r.Path("/attempt").Name("attempts").Handler(&resourceHandler{ Representation: restdata.AttemptShort{}, Context: api.Context, }) r.Path("/attempt/{worker}/{start}").Name("attempt").Handler(&resourceHandler{ Representation: restdata.AttemptShort{}, Context: api.Context, Get: api.AttemptGet, }) r.Path("/attempt/{worker}/{start}/renew").Name("attemptRenew").Handler(&resourceHandler{ Representation: restdata.AttemptCompletion{}, Context: api.Context, Post: api.AttemptRenew, }) r.Path("/attempt/{worker}/{start}/expire").Name("attemptExpire").Handler(&resourceHandler{ Representation: restdata.AttemptCompletion{}, Context: api.Context, Post: api.AttemptExpire, }) r.Path("/attempt/{worker}/{start}/finish").Name("attemptFinish").Handler(&resourceHandler{ Representation: restdata.AttemptCompletion{}, Context: api.Context, Post: api.AttemptFinish, }) r.Path("/attempt/{worker}/{start}/fail").Name("attemptFail").Handler(&resourceHandler{ Representation: restdata.AttemptCompletion{}, Context: api.Context, Post: api.AttemptFail, }) r.Path("/attempt/{worker}/{start}/retry").Name("attemptRetry").Handler(&resourceHandler{ Representation: restdata.AttemptCompletion{}, Context: api.Context, Post: api.AttemptRetry, }) }
// New initalizes a new auth router. func New(r *mux.Router) { r.Path("/auth").Methods("POST").HandlerFunc(register) r.Path("/auth/login").Methods("POST").HandlerFunc(login) r.Path("/auth/user").Methods("GET").HandlerFunc(CheckAuth(getUser)) r.Path("/auth/user").Methods("POST").HandlerFunc(CheckAuth(updateUser)) }
// SetupCollectdPaths tells the router which paths the given handler (which should handle collectd json) // should see func SetupCollectdPaths(r *mux.Router, handler http.Handler) { r.Path("/v1/collectd").Methods("POST").Headers("Content-Type", "application/json").Handler(handler) r.Path("/v1/collectd").Methods("POST").Headers("Content-Type", "").HandlerFunc(invalidContentType) }