func router() *mux.Router { r := mux.NewRouter() r.Handle("/tasks", http.Handler(ContextAdapter{ctx: taskctx, handler: ContextHandlerFunc(tasklist)})).Methods("GET") r.Handle("/tasks", http.Handler(ContextAdapter{ctx: taskctx, handler: ContextHandlerFunc(taskadd)})).Methods("POST") r.Handle("/tasks/complete", http.Handler(ContextAdapter{ctx: taskctx, handler: ContextHandlerFunc(taskcomplete)})).Methods("POST") r.Handle("/tasks/search", http.Handler(ContextAdapter{ctx: taskctx, handler: ContextHandlerFunc(tasksearch)})).Methods("GET") return r }
func UploadHandler(fileBackend backend.FileBackend) http.Handler { result := func(w http.ResponseWriter, r *http.Request) { log.Println("Uploading file...") uploadedFile, header, err := r.FormFile("data") if err != nil { log.Printf("problem with file %v", err) w.WriteHeader(http.StatusBadRequest) return } defer uploadedFile.Close() parts := s.Split(header.Filename, ".") extension := parts[len(parts)-1] contentType := mime.TypeByExtension("." + extension) log.Printf("determined %s as content type", contentType) log.Printf("got file %s", header.Filename) id, err := fileBackend.Save(contentType, nil, uploadedFile) if err != nil { log.Printf("problem saving file %v", err) w.WriteHeader(http.StatusInternalServerError) } w.Header().Set("Location", id) w.WriteHeader(http.StatusCreated) } return http.Handler(http.HandlerFunc(result)) }
func (a *Api) Run() error { globalMux := http.NewServeMux() router := mux.NewRouter() router.HandleFunc("/", a.index).Methods("GET") router.HandleFunc("/create", a.create).Methods("POST") router.HandleFunc("/ip", a.getIP).Methods("GET") router.HandleFunc("/state", a.getState).Methods("GET") router.HandleFunc("/start", a.start).Methods("GET") router.HandleFunc("/kill", a.kill).Methods("GET") router.HandleFunc("/remove", a.remove).Methods("GET") router.HandleFunc("/restart", a.restart).Methods("GET") router.HandleFunc("/stop", a.stop).Methods("GET") // enable auth if token is present if a.config.AuthToken != "" { am := auth.NewAuthMiddleware(a.config.AuthToken) globalMux.Handle("/", negroni.New( negroni.HandlerFunc(am.Handler), negroni.Wrap(http.Handler(router)), )) } else { globalMux.Handle("/", router) } log.Infof("rivet version %s", version.FULL_VERSION) log.Infof("listening: addr=%s", a.config.ListenAddr) n := negroni.New() n.UseHandler(globalMux) return http.ListenAndServe(a.config.ListenAddr, n) }
func (app *App) Run() error { path := "/" if app.options.RandomUrl { randomPath := generateRandomString(8) path = "/" + randomPath + "/" } fs := http.StripPrefix(path, http.FileServer(&assetfs.AssetFS{Asset: Asset, AssetDir: AssetDir, Prefix: "bindata"})) http.Handle(path, fs) http.HandleFunc(path+"ws", app.handler) endpoint := app.options.Address + ":" + app.options.Port log.Printf("Server is running at %s, command: %s", endpoint+path, strings.Join(app.options.Command, " ")) handler := http.Handler(http.DefaultServeMux) handler = loggerHandler(handler) if app.options.Credential != "" { handler = basicAuthHandler(handler, app.options.Credential) } err := http.ListenAndServe(endpoint, handler) if err != nil { return err } return nil }
func startHTTP(wg *sync.WaitGroup) { log.Println("Starting HTTP Server...") mux := http.NewServeMux() mux.HandleFunc("/status", statusHandler) mux.HandleFunc("/ls", lsHandler) mux.HandleFunc("/shutdown", func(w http.ResponseWriter, _ *http.Request) { fmt.Fprintf(w, "OK") forceShutdown <- true }) mux.Handle("/files/", http.StripPrefix("/files/", http.FileServer(torrentFS))) handler := http.Handler(mux) if config.idleTimeout > 0 { connTrackChannel := make(chan int, 10) handler = NewConnectionCounterHandler(connTrackChannel, mux) go inactiveAutoShutdown(connTrackChannel) } log.Printf("Listening HTTP on %s...\n", config.bindAddress) s := &http.Server{ Addr: config.bindAddress, Handler: handler, } var e error if httpListener, e = net.Listen("tcp", config.bindAddress); e != nil { log.Fatal(e) } go s.Serve(httpListener) defer wg.Done() }
func (e *Etcd) serve() (err error) { var ctlscfg *tls.Config if !e.cfg.ClientTLSInfo.Empty() { plog.Infof("ClientTLS: %s", e.cfg.ClientTLSInfo) if ctlscfg, err = e.cfg.ClientTLSInfo.ServerConfig(); err != nil { return err } } if e.cfg.CorsInfo.String() != "" { plog.Infof("cors = %s", e.cfg.CorsInfo) } // Start the peer server in a goroutine ph := v2http.NewPeerHandler(e.Server) for _, l := range e.Peers { go func(l net.Listener) { e.errc <- servePeerHTTP(l, ph) }(l) } // Start a client server goroutine for each listen address ch := http.Handler(&cors.CORSHandler{ Handler: v2http.NewClientHandler(e.Server, e.Server.Cfg.ReqTimeout()), Info: e.cfg.CorsInfo, }) for _, sctx := range e.sctxs { // read timeout does not work with http close notify // TODO: https://github.com/golang/go/issues/9524 go func(s *serveCtx) { e.errc <- s.serve(e.Server, ctlscfg, ch, e.errc) }(sctx) } return nil }
func main() { var ( fsRoot = flag.String("fs.root", "/tmp", "FileSystem root directory") httpAddress = flag.String("http.addr", ":5555", "HTTP listen address") providerDir = flag.String("provider.dir", "/tmp", "Provider directory with bucket policies") ) flag.Parse() prometheus.Register("ent_requests_total", "Total number of requests made", prometheus.NilLabels, requestTotal) prometheus.Register("ent_requests_duration_nanoseconds_total", "Total amount of time ent has spent to answer requests in nanoseconds", prometheus.NilLabels, requestDuration) prometheus.Register("ent_requests_duration_nanoseconds", "Amounts of time ent has spent answering requests in nanoseconds", prometheus.NilLabels, requestDurations) prometheus.Register("ent_request_bytes_total", "Total volume of request payloads emitted in bytes", prometheus.NilLabels, requestBytes) prometheus.Register("ent_response_bytes_total", "Total volume of response payloads emitted in bytes", prometheus.NilLabels, responseBytes) p, err := NewDiskProvider(*providerDir) if err != nil { log.Fatal(err) } fs := NewDiskFS(*fsRoot) r := pat.New() r.Get(fileRoute, handleGet(p, fs)) r.Post(fileRoute, handleCreate(p, fs)) r.Handle("/metrics", prometheus.DefaultRegistry.Handler()) r.Get("/", handleBucketList(p)) log.Fatal(http.ListenAndServe(*httpAddress, http.Handler(r))) }
// New returns a new instance of GenericAPIServer from the given config. // Certain config fields will be set to a default value if unset, // including: // ServiceClusterIPRange // ServiceNodePortRange // MasterCount // ReadWritePort // PublicAddress // Public fields: // Handler -- The returned GenericAPIServer has a field TopHandler which is an // http.Handler which handles all the endpoints provided by the GenericAPIServer, // including the API, the UI, and miscellaneous debugging endpoints. All // these are subject to authorization and authentication. // InsecureHandler -- an http.Handler which handles all the same // endpoints as Handler, but no authorization and authentication is done. // Public methods: // HandleWithAuth -- Allows caller to add an http.Handler for an endpoint // that uses the same authentication and authorization (if any is configured) // as the GenericAPIServer's built-in endpoints. // If the caller wants to add additional endpoints not using the GenericAPIServer's // auth, then the caller should create a handler for those endpoints, which delegates the // any unhandled paths to "Handler". func (c completedConfig) New() (*GenericAPIServer, error) { if c.Serializer == nil { return nil, fmt.Errorf("Genericapiserver.New() called with config.Serializer == nil") } s := &GenericAPIServer{ ServiceClusterIPRange: c.ServiceClusterIPRange, ServiceNodePortRange: c.ServiceNodePortRange, LoopbackClientConfig: c.LoopbackClientConfig, legacyAPIPrefix: c.APIPrefix, apiPrefix: c.APIGroupPrefix, admissionControl: c.AdmissionControl, requestContextMapper: c.RequestContextMapper, Serializer: c.Serializer, minRequestTimeout: time.Duration(c.MinRequestTimeout) * time.Second, enableSwaggerSupport: c.EnableSwaggerSupport, MasterCount: c.MasterCount, SecureServingInfo: c.SecureServingInfo, InsecureServingInfo: c.InsecureServingInfo, ExternalAddress: c.ExternalHost, ClusterIP: c.PublicAddress, PublicReadWritePort: c.ReadWritePort, ServiceReadWriteIP: c.ServiceReadWriteIP, ServiceReadWritePort: c.ServiceReadWritePort, ExtraServicePorts: c.ExtraServicePorts, ExtraEndpointPorts: c.ExtraEndpointPorts, KubernetesServiceNodePort: c.KubernetesServiceNodePort, apiGroupsForDiscovery: map[string]unversioned.APIGroup{}, enableOpenAPISupport: c.EnableOpenAPISupport, openAPIInfo: c.OpenAPIInfo, openAPIDefaultResponse: c.OpenAPIDefaultResponse, openAPIDefinitions: c.OpenAPIDefinitions, } if c.RestfulContainer != nil { s.HandlerContainer = c.RestfulContainer } else { s.HandlerContainer = NewHandlerContainer(http.NewServeMux(), c.Serializer) } // Use CurlyRouter to be able to use regular expressions in paths. Regular expressions are required in paths for example for proxy (where the path is proxy/{kind}/{name}/{*}) s.HandlerContainer.Router(restful.CurlyRouter{}) s.Mux = apiserver.NewPathRecorderMux(s.HandlerContainer.ServeMux) apiserver.InstallServiceErrorHandler(s.Serializer, s.HandlerContainer) if c.ProxyDialer != nil || c.ProxyTLSClientConfig != nil { s.ProxyTransport = utilnet.SetTransportDefaults(&http.Transport{ Dial: c.ProxyDialer, TLSClientConfig: c.ProxyTLSClientConfig, }) } s.installAPI(c.Config) s.Handler, s.InsecureHandler = s.buildHandlerChains(c.Config, http.Handler(s.Mux.BaseMux().(*http.ServeMux))) return s, nil }
func upsertMultiplePermissionsHandler(mapper *pgmapper.Mapper, sidIdExtractor idextractor.Extractor) http.Handler { result := func(w http.ResponseWriter, r *http.Request) { sid, err := sidIdExtractor(r) if err != nil { w.WriteHeader(http.StatusInternalServerError) return } ids, ok := r.URL.Query()["oid"] if !ok { w.WriteHeader(http.StatusBadRequest) return } permissions := make(map[string]interface{}) err = json.NewDecoder(r.Body).Decode(&permissions) if err != nil { w.WriteHeader(http.StatusBadRequest) return } err = mapper.Execute("SELECT insert_bulk_sid_permissions(%v)", sid, permissions["create_permission"], permissions["read_permission"], permissions["update_permission"], permissions["delete_permission"], ids) if err != nil { w.WriteHeader(http.StatusInternalServerError) return } w.WriteHeader(http.StatusOK) return } return http.Handler(http.HandlerFunc(result)) }
func main() { if !flag.Parsed() { flag.Parse() } router := mux.NewRouter() router.StrictSlash(true) for _, route := range routes { handler := http.Handler(http.HandlerFunc(route.HandlerFunc)) switch route.Type { case "JSON": handler = handlers.ContentTypeHandler(handler, "application/json") case "": break default: log.Fatalf("invalid route type: %v", route.Type) } r := router.NewRoute() r.Name(route.Name). Path(route.Path). Methods(route.Methods). Handler(handler) } address := fmt.Sprintf(":%d", *port) handler := handlers.CombinedLoggingHandler(os.Stderr, router) log.Printf("Version: %s", version.DeploymentManagerVersion) log.Printf("Listening on port %d...", *port) log.Fatal(http.ListenAndServe(address, handler)) }
func main() { db := sqlx.MustConnect("sqlite3", ":memory:") if err := createFooTable(db); err != nil { log.Fatal("couldn't create table: ", err) } for i := 0; i < 10; i++ { id, err := insertFoo(db, "hello world "+strconv.Itoa(i)) if err != nil { log.Fatal("failed to insert value: ", err) } log.Print("inserted foo record ", id) } h := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { fooListEndpoint(w, r, &FooStore{db: db}) })) h = handlers.LoggingHandler(os.Stdout, h) h = handlers.ContentTypeHandler(h, "application/json") http.Handle("/foo/", h) flag.Parse() log.Print("starting http server on ", *addr) if err := http.ListenAndServe(*addr, nil); err != nil { log.Printf("http server failed: ", err) } }
// Use adds a Middleware function to the stack. func (b *Builder) Use(f Middleware) { b.handler = http.Handler(nil) b.middleware = append(b.middleware, f) for i := len(b.middleware) - 1; i >= 0; i-- { b.handler = b.middleware[i](b.handler) } }
func upsertPermissionsHandler(mapper *pgmapper.Mapper, objectIdExtractor idextractor.Extractor) http.Handler { result := func(w http.ResponseWriter, r *http.Request) { objectId, err := objectIdExtractor(r) if err != nil { w.WriteHeader(http.StatusInternalServerError) return } ids, ok := r.URL.Query()["sid"] entity := make(map[string]interface{}) err = json.NewDecoder(r.Body).Decode(&entity) if err != nil { w.WriteHeader(http.StatusInternalServerError) return } if ok { err = mapper.Execute("SELECT insert_bulk_permissions(%v)", objectId, entity["create_permission"], entity["read_permission"], entity["update_permission"], entity["delete_permission"], ids) } else { _, err = mapper.ExecuteRaw("insert into acl_entries(object_id,sid,create_permission,read_permission,update_permission,delete_permission) values($1,$2,$3,$4,$5,$6) ON CONFLICT (object_id,sid) DO UPDATE SET create_permission = $3, read_permission = $4, update_permission = $5, delete_permission = $6 where acl_entries.sid = $2 AND acl_entries.object_id = $1", objectId, entity["sid"], entity["create_permission"], entity["read_permission"], entity["update_permission"], entity["delete_permission"]) } if err != nil { w.WriteHeader(http.StatusInternalServerError) return } } return http.Handler(http.HandlerFunc(result)) }
// StartHTTP starts listening for RPC requests sent via HTTP. func StartHttp(cfg HttpConfig, codec codec.Codec, api shared.EthereumApi) error { httpServerMu.Lock() defer httpServerMu.Unlock() addr := fmt.Sprintf("%s:%d", cfg.ListenAddress, cfg.ListenPort) if httpServer != nil { if addr != httpServer.Addr { return fmt.Errorf("RPC service already running on %s ", httpServer.Addr) } return nil // RPC service already running on given host/port } // Set up the request handler, wrapping it with CORS headers if configured. handler := http.Handler(&handler{codec, api}) if len(cfg.CorsDomain) > 0 { opts := cors.Options{ AllowedMethods: []string{"POST"}, AllowedOrigins: strings.Split(cfg.CorsDomain, " "), } handler = cors.New(opts).Handler(handler) } // Start the server. s, err := listenHTTP(addr, handler) if err != nil { glog.V(logger.Error).Infof("Can't listen on %s:%d: %v", cfg.ListenAddress, cfg.ListenPort, err) return err } httpServer = s return nil }
func TestRWVFS(t *testing.T) { tmpdir, err := ioutil.TempDir("", "rwvfs-test-") if err != nil { t.Fatal("TempDir", err) } defer os.RemoveAll(tmpdir) h := http.Handler(rwvfs.HTTPHandler(rwvfs.Map(map[string]string{}), nil)) httpServer := httptest.NewServer(h) defer httpServer.Close() httpURL, err := url.Parse(httpServer.URL) if err != nil { t.Fatal(err) } tests := []struct { fs rwvfs.FileSystem path string }{ {rwvfs.OS(tmpdir), "/foo"}, {rwvfs.Map(map[string]string{}), "/foo"}, {rwvfs.Sub(rwvfs.Map(map[string]string{}), "/x"), "/foo"}, {rwvfs.HTTP(httpURL, nil), "/foo"}, } for _, test := range tests { testWrite(t, test.fs, test.path) testMkdir(t, test.fs) testMkdirAll(t, test.fs) testGlob(t, test.fs) } }
func prepareServer(serviceName string) *httptest.Server { // wir schreiben einen fake server. Dieser server stellt den eigentlichen service dar, // an den du deine Requests weiterleiten möchtest (beispielsweise der authentication-service). // Falls er angesprochen wird soll er den Statuscode 418 (im a teapot) zurückgesendet. serviceHandler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusTeapot) })) server := httptest.NewServer(serviceHandler) // der servicecache wird so konfiguriert, dass er immer die url des eben erstellten server zurückliefert. // Wir umgehen somit die periodischen Anfragen an den discovery-service. fakeRetriever := func(consulAddress string) (map[string]*api.AgentService, error) { services := make(map[string]*api.AgentService) serviceUrl, _ := url.Parse(server.URL) parts := strings.Split(serviceUrl.Host, ":") host := parts[0] port, _ := strconv.Atoi(parts[1]) services[serviceName] = createService(serviceName+"1", serviceName, port, host, "public", "interactive-lecture") return services, nil } // wir configurieren den cache und bauen anschließend unseren mock-retreiver ein. cache, _ := servicecache.Configure("discovery:8500", 1*time.Millisecond, serviceName) cache.SetServiceRetriever(fakeRetriever) return server }
func TestHTTP_BaseURL(t *testing.T) { m := map[string]string{"b/c": "c"} mapFS := rwvfs.Map(m) prefix := "/foo/bar/baz" h := http.Handler(http.StripPrefix(prefix, rwvfs.HTTPHandler(mapFS, nil))) httpServer := httptest.NewServer(h) defer httpServer.Close() httpURL, err := url.Parse(httpServer.URL + prefix) if err != nil { t.Fatal(err) } fs := rwvfs.HTTP(httpURL, nil) if err := rwvfs.MkdirAll(fs, "b"); err != nil { t.Errorf("MkdirAll %q: %s", "b", err) } fis, err := fs.ReadDir("b") if err != nil { t.Fatal(err) } if len(fis) != 1 { t.Errorf("got len(fis) == %d, want 1", len(fis)) } if wantName := "c"; fis[0].Name() != wantName { t.Errorf("got name == %q, want %q", fis[0].Name(), wantName) } }
func main() { log.SetFlags(log.LstdFlags | log.Lmicroseconds) var ( httpAddress = flag.String("http.addr", ":8080", "HTTP listen address") historicData = flag.String("historic.data", "", "path to data directory") printVersion = flag.Bool("version", false, "print version and exit") ) flag.Parse() if *printVersion { fmt.Printf("%s", Version) os.Exit(0) } cache, err := populateExchangeRateCache(*historicData) if err != nil { log.Fatalf("Unable to populate cache: %v", err) } go func() { for { time.Sleep(6 * time.Hour) updateExchangeRatesCache(cache) } }() log.Printf("listening on %v", *httpAddress) log.Fatal(http.ListenAndServe(*httpAddress, logHandler(http.Handler(rateHTTP.Handler(cache))))) }
// Handler returns an http.Handler for the embedded router and middleware. func (h *Hitch) Handler() http.Handler { handler := http.Handler(h.Router) for i := len(h.middleware) - 1; i >= 0; i-- { handler = h.middleware[i](handler) } return handler }
func listen(port string, environment string, dbUrl string) { log.Printf("Setting env to %v", environment) db, err = sql.Open("mysql", dbUrl) if err != nil { log.Fatalf("Error opening DB connection: %v", err) } http.HandleFunc("/validate/", validationHandler) http.Handle("/metrics", http.Handler(inmemMetrics)) //Only host the static template when the ENV is 'Live' or 'Test' if environment == "Live" || environment == "Test" { http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { http.ServeFile(w, r, "static/"+r.URL.Path[1:]) }) } err = http.ListenAndServe(":"+port, nil) if err != nil { log.Fatal("ListenAndServe: ", err) } }
// NewProxyServer creates and installs a new ProxyServer. // It automatically registers the created ProxyServer to http.DefaultServeMux. // 'filter', if non-nil, protects requests to the api only. func NewProxyServer(port int, filebase string, apiProxyPrefix string, staticPrefix string, filter *FilterServer, cfg *client.Config) (*ProxyServer, error) { host := cfg.Host if !strings.HasSuffix(host, "/") { host = host + "/" } target, err := url.Parse(host) if err != nil { return nil, err } proxy := newProxy(target) if proxy.Transport, err = client.TransportFor(cfg); err != nil { return nil, err } proxyServer := http.Handler(proxy) if filter != nil { proxyServer = filter.HandlerFor(proxyServer) } if !strings.HasPrefix(apiProxyPrefix, "/api") { proxyServer = stripLeaveSlash(apiProxyPrefix, proxyServer) } mux := http.NewServeMux() mux.Handle(apiProxyPrefix, proxyServer) if filebase != "" { // Require user to explicitly request this behavior rather than // serving their working directory by default. mux.Handle(staticPrefix, newFileHandler(staticPrefix, filebase)) } return &ProxyServer{handler: mux, port: port}, nil }
func main() { o := ParseOpts() if o.ShowVersion { fmt.Println("sms-api-server", Version) os.Exit(0) } tx := &smpp.Transceiver{ Addr: o.SMPPAddr, User: os.Getenv("SMPP_USER"), Passwd: os.Getenv("SMPP_PASSWD"), } exit := make(chan os.Signal, 1) signal.Notify(exit, os.Interrupt, os.Kill) go func() { <-exit tx.Close() os.Exit(0) }() if o.ClientTLS { host, _, _ := net.SplitHostPort(tx.Addr) tx.TLS = &tls.Config{ ServerName: host, } if o.ClientTLSInsecure { tx.TLS.InsecureSkipVerify = true } } api := &apiserver.Handler{Prefix: o.APIPrefix, Tx: tx} conn := api.Register(http.DefaultServeMux) go func() { for c := range conn { m := fmt.Sprintf("SMPP connection status to %s: %s", o.SMPPAddr, c.Status()) if err := c.Error(); err != nil { m = fmt.Sprintf("%s (%v)", m, err) } log.Println(m) } }() if o.PublicDir != "" { fs := http.FileServer(http.Dir(o.PublicDir)) http.Handle("/", http.StripPrefix(o.APIPrefix, fs)) } mux := http.Handler(http.DefaultServeMux) if o.Log { var l *log.Logger if o.LogTS { l = log.New(os.Stderr, "", log.LstdFlags) } else { l = log.New(os.Stderr, "", 0) } mux = httplog.ApacheCombinedFormat(l)(mux.ServeHTTP) } err := ListenAndServe(o, mux) if err != nil { log.Fatal(err) } }
func runReplicaAPI(context *cli.Context) { router := http.Handler(replica.NewRouter()) router = handlers.LoggingHandler(os.Stdout, router) router = handlers.ProxyHeaders(router) listen := "0.0.0.0:80" logrus.Infof("Listening on %s", listen) err := http.ListenAndServe(listen, router) logrus.Fatalf("API returned with error: %v", err) }
// TestHealthHandler ensures that our handler implementation correct protects // the web application when things aren't so healthy. func TestHealthHandler(t *testing.T) { // clear out existing checks. DefaultRegistry = NewRegistry() // protect an http server handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusNoContent) })) // wrap it in our health handler handler = Handler(handler) // use this swap check status updater := NewStatusUpdater() Register("test_check", updater) // now, create a test server server := httptest.NewServer(handler) checkUp := func(t *testing.T, message string) { resp, err := http.Get(server.URL) if err != nil { t.Fatalf("error getting success status: %v", err) } defer resp.Body.Close() if resp.StatusCode != http.StatusNoContent { t.Fatalf("unexpected response code from server when %s: %d != %d", message, resp.StatusCode, http.StatusNoContent) } // NOTE(stevvooe): we really don't care about the body -- the format is // not standardized or supported, yet. } checkDown := func(t *testing.T, message string) { resp, err := http.Get(server.URL) if err != nil { t.Fatalf("error getting down status: %v", err) } defer resp.Body.Close() if resp.StatusCode != http.StatusServiceUnavailable { t.Fatalf("unexpected response code from server when %s: %d != %d", message, resp.StatusCode, http.StatusServiceUnavailable) } } // server should be up checkUp(t, "initial health check") // now, we fail the health check updater.Update(fmt.Errorf("the server is now out of commission")) checkDown(t, "server should be down") // should be down // bring server back up updater.Update(nil) checkUp(t, "when server is back up") // now we should be back up. }
func (app *App) Run() error { if app.options.PermitWrite { log.Printf("Permitting clients to write input to the PTY.") } path := "" if app.options.RandomUrl { path += "/" + generateRandomString(8) } endpoint := net.JoinHostPort(app.options.Address, app.options.Port) wsHandler := http.HandlerFunc(app.handleWS) staticHandler := http.FileServer( &assetfs.AssetFS{Asset: Asset, AssetDir: AssetDir, Prefix: "static"}, ) var siteMux = http.NewServeMux() siteMux.Handle(path+"/", http.StripPrefix(path+"/", staticHandler)) siteMux.Handle(path+"/ws", wsHandler) siteHandler := http.Handler(siteMux) if app.options.Credential != "" { log.Printf("Using Basic Authentication") siteHandler = wrapBasicAuth(siteHandler, app.options.Credential) } siteHandler = wrapLogger(siteHandler) log.Printf( "Server is starting with command: %s", strings.Join(app.options.Command, " "), ) if app.options.Address != "" { log.Printf( "URL: %s", (&url.URL{Scheme: "http", Host: endpoint, Path: path + "/"}).String(), ) } else { for _, address := range listAddresses() { log.Printf( "URL: %s", (&url.URL{ Scheme: "http", Host: net.JoinHostPort(address, app.options.Port), Path: path + "/", }).String(), ) } } if err := http.ListenAndServe(endpoint, siteHandler); err != nil { return err } return nil }
func newUmsatzServer(db *sql.DB, currencyAddress string) http.Handler { r := http.DefaultServeMux r.Handle("/fiscalPeriods/", http.StripPrefix("/fiscalPeriods/", newFiscalPeriodApp(db))) r.Handle("/positions/", http.StripPrefix("/positions/", newPositionsApp(db, currencyAddress))) r.Handle("/accounts/", http.StripPrefix("/accounts/", newAccountingApp(db))) r.Handle("/", http.HandlerFunc(routingHandler)) return http.Handler(logHandler(jsonHandler(r))) }
// NewServer construct rest server listening specific host and port and routes requests by passed routes func NewServer(props properties.Properties, routes PathHandlers) error { bind := props.Get("rest.address") + ":" + props.Get("rest.port") log.Println("start rest server on", bind) listener, err := net.Listen("tcp", bind) if err != nil { return err } s := &server{ listener: listener, m: &sync.Mutex{}, alive: true, wg: &sync.WaitGroup{}, } kit.SafeGo(func() error { router := mux.NewRouter() for path := range routes { mh := handlers.MethodHandler{} for method := range routes[path] { log.Printf("setup rest handler %v %v\n", method, path) mh[method] = s.wrapHandler(routes[path][method]) } router.Path(path).Handler(mh) } handler := http.Handler(router) compression, err := strconv.ParseBool(props.Get("rest.compression")) if err == nil && compression { log.Println("enable compression for rest server") handler = handlers.CompressHandler(handler) } else { log.Println("no compression for rest server") } log.Println("rest server serves") err = http.Serve(listener, handler) if err != nil { return err } return nil }) kit.SafeGo(func() error { <-registry.DoneChannel() s.Stop() return nil }) return nil }
func TestMain(m *testing.M) { cache, err := populateExchangeRateCache("data/eurofxref-hist.xml") if err != nil { log.Fatalf("Unable to populate cache: %v\n", err) } TestServer = testServer{ server: httptest.NewServer(http.Handler(rateHTTP.Handler(cache))), } ret := m.Run() os.Exit(ret) }
// Router constructs the main Devd router that serves all requests func (dd *Devd) Router(logger termlog.TermLog, templates *template.Template) (http.Handler, error) { mux := http.NewServeMux() hasGlobal := false ci := inject.CopyInject{} if dd.HasLivereload() { ci = livereload.Injector } for match, route := range dd.Routes { if match == "/" { hasGlobal = true } handler := dd.WrapHandler( logger, route.Endpoint.Handler(templates, ci), ) handler = http.StripPrefix(route.Path, handler) mux.Handle(match, handler) } if dd.HasLivereload() { lr := livereload.NewServer("livereload", logger) mux.Handle(livereload.EndpointPath, lr) mux.Handle(livereload.ScriptPath, http.HandlerFunc(lr.ServeScript)) if dd.LivereloadRoutes { err := WatchRoutes(dd.Routes, lr, dd.Excludes, logger) if err != nil { return nil, fmt.Errorf("Could not watch routes for livereload: %s", err) } } if len(dd.WatchPaths) > 0 { err := WatchPaths(dd.WatchPaths, dd.Excludes, lr, logger) if err != nil { return nil, fmt.Errorf("Could not watch path for livereload: %s", err) } } dd.lrserver = lr } if !hasGlobal { mux.Handle( "/", dd.WrapHandler(logger, HandleNotFound(templates)), ) } var h = http.Handler(mux) if dd.Credentials != nil { h = httpauth.SimpleBasicAuth( dd.Credentials.username, dd.Credentials.password, )(h) } return hostPortStrip(h), nil }
func TestComposeMiddlewareVariants(t *testing.T) { fn1 := nullHandlerFunc fn2 := http.HandlerFunc(nullHandlerFunc) fn3 := http.Handler(&stubHandler{}) fn4 := stubMiddleware1 fn5 := stubMiddleware2 fn6 := stubMiddleware3 fn7 := Middleware(&stubMiddleware{}) fn8 := MiddlewareFunc(stubMiddleware2) fn9 := func(h http.Handler) http.Handler { return h } Compose(fn1, fn2, fn3, fn4, fn5, fn6, fn7, fn8, fn9) }