// Handler uses a multiplexing router to route http requests func (ws *webServer) Handler() http.Handler { mux := mux.NewRouter() mux.PathPrefix("/t/cc/").HandlerFunc(ws.Cloudconfig).Methods("GET") mux.PathPrefix("/t/ig/").HandlerFunc(ws.Ignition).Methods("GET") mux.PathPrefix("/t/bp/").HandlerFunc(ws.Bootparams).Methods("GET") mux.HandleFunc("/api/version", ws.Version) mux.HandleFunc("/api/machines", ws.MachinesList) mux.HandleFunc("/api/machines/{mac}", ws.MachineDelete).Methods("DELETE") // mux.PathPrefix("/api/machine/").HandlerFunc(ws.NodeSetIPMI).Methods("PUT") // Machine variables; used in templates mux.PathPrefix("/api/machines/{mac}/variables").HandlerFunc(ws.MachineVariables).Methods("GET") mux.PathPrefix("/api/machines/{mac}/variables/{name}").HandlerFunc(ws.SetMachineVariable).Methods("PUT") mux.PathPrefix("/api/machines/{mac}/variables/{name}").HandlerFunc(ws.DelMachineVariable).Methods("DELETE") // Cluster variables; used in templates mux.PathPrefix("/api/variables/{name}").HandlerFunc(ws.GetClusterVariables).Methods("GET") mux.PathPrefix("/api/variables/{name}").HandlerFunc(ws.SetClusterVariables).Methods("PUT") mux.PathPrefix("/api/variables/{name}").HandlerFunc(ws.DelClusterVariables).Methods("DELETE") mux.PathPrefix("/api/variables").HandlerFunc(ws.ClusterVariablesList).Methods("GET") // TODO: returning other files functionalities mux.PathPrefix("/files/images/").Handler(http.StripPrefix("/files/images", http.FileServer(http.Dir(filepath.Join(ws.ds.WorkspacePath(), "images"))))) mux.PathPrefix("/files/").Handler(http.StripPrefix("/files/", http.FileServer(http.Dir(filepath.Join(ws.ds.WorkspacePath(), "files"))))) mux.Path("/ui").Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { http.Redirect(w, r, "/ui/", 302) })) mux.PathPrefix("/ui/").Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { index, _ := FSByte(false, "/static/index.html") w.Write(index) })) mux.PathPrefix("/static/").Handler(http.FileServer(FS(false))) mux.PathPrefix("/uploadworkspace/{hash}").HandlerFunc(ws.WorkspaceUploadHandler).Methods("POST") return mux }
func main() { // Load the environment variables we need err := godotenv.Load() if err != nil { log.Fatal("Error loading .env file") } // Read the port port := os.Getenv("PORT") tlsConfig, err := getTLSConfig(os.Getenv("SWARM_CREDS_DIR")) if err != nil { log.Fatal("Could not create TLS certificate.") } docker, _ := dockerclient.NewDockerClient(os.Getenv("DOCKER_HOST"), tlsConfig) mux := mux.NewRouter() // mux.HandleFunc("/events", get_events(dbmap)).Methods("GET") // mux.HandleFunc("/events/{year}", get_events_by_year(dbmap)).Methods("GET") mux.HandleFunc("/spawn", spawn(docker)).Methods("GET") mux.HandleFunc("/list-containers", list_containers(docker)).Methods("GET") n := negroni.Classic() n.UseHandler(mux) log.Printf("Listening on port %s\n", port) n.Run(":" + port) }
// Handler uses a multiplexing router to route http requests func (ws *webServer) Handler() http.Handler { mux := mux.NewRouter() mux.PathPrefix("/t/cc/").HandlerFunc(ws.Cloudconfig).Methods("GET") mux.PathPrefix("/t/ig/").HandlerFunc(ws.Ignition).Methods("GET") mux.PathPrefix("/t/bp/").HandlerFunc(ws.Bootparams).Methods("GET") mux.HandleFunc("/api/version", ws.Version) mux.HandleFunc("/api/nodes", ws.NodesList) mux.PathPrefix("/api/node/").HandlerFunc(ws.NodeFlags).Methods("GET") mux.PathPrefix("/api/flag/").HandlerFunc(ws.SetFlag).Methods("PUT") mux.PathPrefix("/api/flag/").HandlerFunc(ws.DelFlag).Methods("DELETE") mux.HandleFunc("/upload/", ws.Upload) mux.HandleFunc("/files", ws.Files).Methods("GET") mux.HandleFunc("/files", ws.DeleteFile).Methods("DELETE") mux.PathPrefix("/files/").Handler(http.StripPrefix("/files/", http.FileServer(http.Dir(filepath.Join(ws.ds.WorkspacePath(), "files"))))) mux.PathPrefix("/ui/").Handler(http.FileServer(FS(false))) return mux }
func RouteRequest() http.Handler { mux := mux.NewRouter() mux.HandleFunc("/test", HandleTest) mux.HandleFunc("/json", HandleJSON) mux.HandleFunc("/retry", HandleRetry) mux.HandleFunc("/limit", HandleLimit) return mux }
func Start(c *Configuration) { log.Printf("Starting Deamon on Port: %s", c.Port) mux := mux.NewRouter() mux.HandleFunc("/bounce/{type}/{name}/{version}", http.HandlerFunc(bounce)) mux.HandleFunc("/hook", http.HandlerFunc(hook)) http.Handle("/", mux) log.Println("Listening...") http.ListenAndServe(":"+c.Port, nil) }
// Create a new server. func NewServer(addr string, hooks ServerHooks, logger *log.Logger) *Server { srv := &Server{} srv.addr = addr srv.hooks = hooks srv.logger = logger mux := mux.NewRouter() mux.StrictSlash(true) mux.HandleFunc("/stop/", srv.handleStop).Methods("POST") mux.HandleFunc("/reload/", srv.handleReload).Methods("POST") srv.server = NewHTTPServer(addr, mux) return srv }
// // Benchmarks for rcrowley/go-tigertonic's tigertonic.TrieServeMux: // func tigertonicRouterFor(namespaces []string, resources []string) http.Handler { mux := tigertonic.NewTrieServeMux() for _, ns := range namespaces { for _, res := range resources { mux.HandleFunc("GET", "/"+ns+"/"+res, helloHandler) mux.HandleFunc("POST", "/"+ns+"/"+res, helloHandler) mux.HandleFunc("GET", "/"+ns+"/"+res+"/{id}", helloHandler) mux.HandleFunc("POST", "/"+ns+"/"+res+"/{id}", helloHandler) mux.HandleFunc("DELETE", "/"+ns+"/"+res+"/{id}", helloHandler) } } return mux }
func main() { mux := mux.NewRouter().StrictSlash(true) mux.HandleFunc("/orders", GetOrders).Methods("GET") mux.HandleFunc("/orders/{orderId}/", GetOrder).Methods("GET") mux.HandleFunc("/orders/", PostOrder).Methods("POST") mux.HandleFunc("/orders/{orderId}/", DeleteOrder).Methods("DELETE") mux.HandleFunc("/orders/{orderId}/", PutOrder).Methods("PUT") log.Println("Listening...") log.Fatal(http.ListenAndServe(":3000", mux)) }
func main() { mux := mux.NewRouter() mux.HandleFunc("/", homeHandler) mux.HandleFunc("/data/{food}", dataHandler) mux.HandleFunc("/static/{folder}/{file}", func(w http.ResponseWriter, r *http.Request) { http.ServeFile(w, r, r.URL.Path[1:]) }) port := ":3000" log.Println("Listening on " + port) http.ListenAndServe(port, mux) }
func (a *RestServer) Mux() *mux.Router { mux := mux.NewRouter() mux.HandleFunc("/api/nodes", a.nodesList) mux.HandleFunc("/api/etcd-endpoints", a.etcdEndpoints) mux.HandleFunc("/upload/", a.upload) mux.HandleFunc("/files", a.files).Methods("GET") mux.HandleFunc("/files", a.deleteFile).Methods("DELETE") mux.PathPrefix("/files/").Handler(http.StripPrefix("/files/", http.FileServer(http.Dir(filepath.Join(a.runtimeConfig.WorkspacePath, "files"))))) mux.PathPrefix("/ui/").Handler(http.FileServer(FS(false))) return mux }
func main() { app := cli.App("System-healthcheck", "A service that report on current VM status at __health") hostPath = app.String(cli.StringOpt{ Name: "hostPath", Value: "", Desc: "The dir path of the mounted host fs (in the container)", EnvVar: "SYS_HC_HOST_PATH", }) checks = append(checks, diskFreeChecker{20}.Checks()...) checks = append(checks, memoryChecker{15}.Checks()...) checks = append(checks, loadAverageChecker{}.Checks()...) checks = append(checks, ntpChecker{}.Checks()...) checks = append(checks, tcpChecker{}.Checks()...) mux := mux.NewRouter() mux.HandleFunc("/__health", fthealth.Handler("myserver", "a server", checks...)) log.Printf("Starting http server on 8080\n") err := http.ListenAndServe(":8080", mux) if err != nil { panic(err) } }
func runServer() *httptest.Server { handler := ShortenerHandler{Database: database} mux := mux.NewRouter().StrictSlash(true) mux.HandleFunc("/", handler.Add).Methods("POST") server := httptest.NewServer(mux) return server }
// vulcan func startVulcan() { mux := vulcan.NewMux() expr := fmt.Sprintf(`Method("%s") && Path("%s")`, "GET", "/hello") mux.HandleFunc(expr, helloHandler) http.ListenAndServe(":"+strconv.Itoa(port), mux) }
func ExampleServeMux_customized() { // Define our error format and how to expose it to the client. type customError struct { Error string `json:"error"` HTTPCode int `json:"http_code"` } errorHandler := func(w ehttp.ResponseWriter, req *http.Request, err error) { _ = json.NewEncoder(w).Encode(customError{ Error: err.Error(), HTTPCode: w.Code(), }) } // Define a cutom logger for unexpected events (double header send). logger := log.New(os.Stderr, "", log.LstdFlags) // Create the mux. mux := ehttp.NewServeMux(errorHandler, "application/text; charset=utf-8", false, logger) // Register the handler. mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) error { // Return an error. return ehttp.NewErrorf(http.StatusTeapot, "fail") }) // Start serve the mux. log.Fatal(http.ListenAndServe(":8080", mux)) }
func ExampleServeMux_panic() { mux := ehttp.NewServeMux(nil, "application/text; charset=utf-8", true, nil) mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) error { panic(ehttp.InternalServerError) }) log.Fatal(http.ListenAndServe(":8080", mux)) }
func startTestDriver() error { mux := http.NewServeMux() server := httptest.NewServer(mux) if server == nil { return fmt.Errorf("Failed to start a HTTP Server") } mux.HandleFunc("/Plugin.Activate", func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json") fmt.Fprintf(w, `{"Implements": ["%s"]}`, driverapi.NetworkPluginEndpointType) }) mux.HandleFunc(fmt.Sprintf("/%s.GetCapabilities", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json") fmt.Fprintf(w, `{"Scope":"global"}`) }) mux.HandleFunc(fmt.Sprintf("/%s.CreateNetwork", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json") fmt.Fprintf(w, "null") }) mux.HandleFunc(fmt.Sprintf("/%s.DeleteNetwork", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json") fmt.Fprintf(w, "null") }) mux.HandleFunc(fmt.Sprintf("/%s.CreateEndpoint", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json") fmt.Fprintf(w, "null") }) mux.HandleFunc(fmt.Sprintf("/%s.DeleteEndpoint", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json") fmt.Fprintf(w, "null") }) mux.HandleFunc(fmt.Sprintf("/%s.Join", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json") fmt.Fprintf(w, "null") }) mux.HandleFunc(fmt.Sprintf("/%s.Leave", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json") fmt.Fprintf(w, "null") }) if err := os.MkdirAll("/etc/docker/plugins", 0755); err != nil { return err } if err := ioutil.WriteFile("/etc/docker/plugins/test.spec", []byte(server.URL), 0644); err != nil { return err } return nil }
func loadTigerTonic(routes []route) http.Handler { re := regexp.MustCompile(":([^/]*)") mux := tigertonic.NewTrieServeMux() for _, route := range routes { mux.HandleFunc(route.method, re.ReplaceAllString(route.path, "{$1}"), httpHandlerFunc) } return mux }
func main() { handlers := BaseHandlers() mux := mux.NewRouter() mux.HandleFunc("/", handlers.landing) mux.HandleFunc("/signup", handlers.signup) accounts := mux.PathPrefix("/account").Subrouter() accounts.HandleFunc("/", handlers.accountIndex) n := negroni.Classic() n.UseHandler(mux) n.Run(*httpAddr) }
func main() { mux := mux.NewRouter() mux.HandleFunc("/", rootHandler) muxWithMiddlewares := http.TimeoutHandler(mux, time.Second*39, "Timeout!") http.ListenAndServe(":18080", muxWithMiddlewares) }
func main() { configtoml := flag.String("f", "nixy.toml", "Path to config. (default nixy.toml)") version := flag.Bool("v", false, "prints current nixy version") flag.Parse() if *version { fmt.Println(VERSION) os.Exit(0) } file, err := ioutil.ReadFile(*configtoml) if err != nil { log.Fatal(err) } err = toml.Unmarshal(file, &config) if err != nil { log.Fatal("Problem parsing config: ", err) } if config.Statsd != "" { statsd, _ = g2s.Dial("udp", config.Statsd) } nixystats := stats.New() //mux := http.NewServeMux() mux := mux.NewRouter() mux.HandleFunc("/", nixy_version) mux.HandleFunc("/v1/reload", nixy_reload) mux.HandleFunc("/v1/apps", nixy_apps) mux.HandleFunc("/v1/health", nixy_health) mux.HandleFunc("/v1/stats", func(w http.ResponseWriter, req *http.Request) { stats := nixystats.Data() b, _ := json.MarshalIndent(stats, "", " ") w.Write(b) return }) handler := nixystats.Handler(mux) s := &http.Server{ Addr: ":" + config.Port, Handler: handler, } eventStream() eventWorker() log.Println("Starting nixy on :" + config.Port) err = s.ListenAndServe() if err != nil { log.Fatal(err) } }
// to run // func run() { mux := mux.NewRouter() mux.HandleFunc("/metrics", serveContext(route.PostMetrics)).Methods("POST") mux.HandleFunc("/planets", serveContext(route.GetPlanets)).Methods("GET") mux.HandleFunc("/containers", serveContext(route.GetContainers)).Methods("GET") mux.HandleFunc("/metrics", serveContext(route.GetMetrics)).Methods("GET") http.Handle("/", serveMiddleware(mux)) http.ListenAndServe(":"+port, nil) }
func BenchmarkRcrowleyTigerTonic_Simple(b *testing.B) { mux := tigertonic.NewTrieServeMux() mux.HandleFunc("GET", "/action", helloHandler) rw, r := testRequest("GET", "/action") b.ResetTimer() for i := 0; i < b.N; i++ { mux.ServeHTTP(rw, r) } }
func init() { mux := mux.NewRouter() mux.HandleFunc("/", root) n := negroni.Classic() n.UseHandler(mux) http.Handle("/", n) }
func loadVulcanSingle(method, path string, handler http.HandlerFunc) http.Handler { re := regexp.MustCompile(":([^/]*)") mux := vulcan.NewMux() path = re.ReplaceAllString(path, "<$1>") expr := fmt.Sprintf(`Method("%s") && Path("%s")`, method, path) if err := mux.HandleFunc(expr, httpHandlerFunc); err != nil { panic(err) } return mux }
func ExampleServeMux_customLogger() { // When returning an error after sending the errors, we can't set the http Status. // As data as already been sent, we don't want to corrupt it so we log the error server side. logger := log.New(os.Stderr, "", log.LstdFlags) mux := ehttp.NewServeMux(nil, "application/text; charset=utf-8", true, logger) mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) error { panic(ehttp.InternalServerError) }) log.Fatal(http.ListenAndServe(":8080", mux)) }
func main() { configtoml := flag.String("f", "nixy.toml", "Path to config. (default nixy.toml)") version := flag.Bool("v", false, "prints current nixy version") flag.Parse() if *version { fmt.Println(VERSION) os.Exit(0) } file, err := ioutil.ReadFile(*configtoml) if err != nil { logger.WithFields(logrus.Fields{ "error": err.Error(), }).Fatal("problem opening toml config") } err = toml.Unmarshal(file, &config) if err != nil { logger.WithFields(logrus.Fields{ "error": err.Error(), }).Fatal("problem parsing config") } statsd, _ = setupStatsd() mux := mux.NewRouter() mux.HandleFunc("/", nixy_version) mux.HandleFunc("/v1/reload", nixy_reload) mux.HandleFunc("/v1/config", nixy_config) mux.HandleFunc("/v1/health", nixy_health) s := &http.Server{ Addr: ":" + config.Port, Handler: mux, } health = newHealth() endpointHealth() eventStream() eventWorker() logger.Info("starting nixy on :" + config.Port) err = s.ListenAndServe() if err != nil { log.Fatal(err) } }
func Example_customErrorHandler() { // Define how to send errors to the user. errorHandler := func(w ehttp.ResponseWriter, req *http.Request, err error) { fmt.Fprintf(w, "<<<<<<%s>>>>>>", err) } mux := ehttp.NewServeMux(errorHandler, "application/text; charset=utf-8", false, nil) mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) error { return ehttp.NewErrorf(http.StatusTeapot, "fail") }) log.Fatal(http.ListenAndServe(":8080", mux)) }
func main() { store, err = ratelimit.Init(&net.TCPAddr{Port: 6379}) if err != nil { panic(err) } defer store.Close() mux := mux.NewRouter() mux.HandleFunc("/", redis_ping) http.ListenAndServe(":8080", mux) }
func loadVulcan(routes []route) http.Handler { re := regexp.MustCompile(":([^/]*)") mux := vulcan.NewMux() for _, route := range routes { path := re.ReplaceAllString(route.path, "<$1>") expr := fmt.Sprintf(`Method("%s") && Path("%s")`, route.method, path) if err := mux.HandleFunc(expr, httpHandlerFunc); err != nil { panic(err) } } return mux }
func main() { addr := flag.String("listen", "0.0.0.0:9004", "Endpoint address") redisEndpoint := flag.String("redis", "127.0.0.1:6379", "Redis endpoint") paymentEndpoint := flag.String("payment", "localhost:9002", "Endpoint for payment service") catalogEndpoint := flag.String("catalog", "localhost:9003", "Endpoint for catalog service") services.ParseBalanceEndpointsFlags() flag.Parse() services.ParseLoadBalanceConfig() services.EnableResponseLogging() golib.ConfigureOpenFilesLimit() redisClient, err := services.ConnectRedis(*redisEndpoint) if err != nil { log.Fatalln(err) } if err := services.RegisterLockScripts(redisClient); err != nil { log.Fatalln("Failed to register redis scripts", err) } shop := &Shop{ redis: redisClient, redisLockValue: services.EndpointLockValue(*addr), catalogEndpoint: *catalogEndpoint, paymentEndpoint: *paymentEndpoint, } launchOrderProcessing(shop) mux := mux.NewRouter() mux.HandleFunc("/shop", shop.show_items).Methods("GET") mux.HandleFunc("/order", shop.order_item).Methods("POST").MatcherFunc(services.MatchFormKeys("user", "item", "qty")) mux.HandleFunc("/order/{order}", shop.get_order).Methods("GET") mux.HandleFunc("/orders/{user}", shop.show_orders).Methods("GET") services.L.Warnf("Running on " + *addr) if err := http.ListenAndServe(*addr, mux); err != nil { log.Fatal(err) } }