func main() { r := mux.NewRouter() conn, err := db.Connect(os.Getenv("DB_URL"), os.Getenv("DB_NAME")) if err != nil { log.Fatal(err) } defer conn.Close() r.Handle("/register.json", controllers.Register(conn)).Methods("POST") r.Handle("/login.json", controllers.Login(conn)).Methods("POST") r.Handle("/me.json", controllers.Me(conn)).Methods("GET") r.Handle("/devices.json", controllers.RegisterDevice(conn)).Methods("PUT") r.Handle("/listings.json", controllers.Listings(conn)).Methods("GET") r.Handle("/listings.json", controllers.CreateListing(conn)).Methods("POST") r.Handle("/listings/{id}.json", controllers.Listing(conn)).Methods("GET") r.Handle("/listings/{id}/rent.json", controllers.Rent(conn)).Methods("POST") r.Handle("/rentals.json", controllers.Rentals(conn)).Methods("GET") r.Handle("/rentals/{id}.json", controllers.Rental(conn)).Methods("GET") r.Handle("/rentals/{id}/confirm.json", controllers.ConfirmRental(conn)).Methods("PUT") r.Handle("/rentals/{id}/deny.json", controllers.DenyRental(conn)).Methods("PUT") r.Handle("/search.json", controllers.Search(conn)).Methods("GET") if os.Getenv("ENV") == "production" { log.Fatal(http.ListenAndServeTLS(":"+os.Getenv("PORT"), os.Getenv("SSL_CERT_PATH"), os.Getenv("SSL_KEY_PATH"), handlers.LoggingHandler(os.Stdout, r))) } else { log.Fatal(http.ListenAndServe(":"+os.Getenv("PORT"), handlers.LoggingHandler(os.Stdout, r))) } }
func main() { db := sqlx.MustOpen("sqlite3", ":memory:") db.MustExec(`CREATE TABLE Products ( id INTEGER PRIMARY KEY, name TEXT ); INSERT INTO Products VALUES (1, 'TV'); INSERT INTO Products VALUES (2, 'Microwave');`) inventory := &DatabaseInventoryRepository{db} env := &Env{ inventory: inventory, decoder: schema.NewDecoder(), } r := mux.NewRouter() r.Handle("/products", handlers.LoggingHandler(os.Stdout, Handler{env, ProductsHandler})) r.Handle("/products/search", handlers.LoggingHandler(os.Stdout, Handler{env, SearchHandler})) r.Handle("/docs/", http.StripPrefix("/docs/", http.FileServer(http.Dir("docs")))) http.ListenAndServe(":8080", r) }
func main() { if os.Getenv("MEMCACHED") == "" { log.Println("MEMCACHED environment variable must be specified") os.Exit(1) } mc := memcached{memcache.New(os.Getenv("MEMCACHED"))} mx := mux.NewRouter() // GET secret mx.HandleFunc("/secret/{uuid:([0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12})}", func(response http.ResponseWriter, request *http.Request) { getHandler(response, request, mc) }).Methods("GET") // Check secret status mx.HandleFunc("/secret/{uuid:([0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12})}", func(response http.ResponseWriter, request *http.Request) { messageStatus(response, request, mc) }).Methods("HEAD") // Save secret mx.HandleFunc("/secret", func(response http.ResponseWriter, request *http.Request) { saveHandler(response, request, mc) }).Methods("POST") // Serve static files mx.PathPrefix("/").Handler(http.FileServer(http.Dir("public"))) log.Println("Starting yopass. Listening on port 1337") if os.Getenv("TLS_CERT") != "" && os.Getenv("TLS_KEY") != "" { // Configure TLS with sane ciphers config := &tls.Config{MinVersion: tls.VersionTLS12, PreferServerCipherSuites: true, CipherSuites: []uint16{ tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256, tls.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA, tls.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA, tls.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA, tls.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA, tls.TLS_RSA_WITH_AES_128_CBC_SHA, tls.TLS_RSA_WITH_AES_256_CBC_SHA, tls.TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA, tls.TLS_RSA_WITH_3DES_EDE_CBC_SHA, }} server := &http.Server{Addr: ":1337", Handler: handlers.LoggingHandler(os.Stdout, mx), TLSConfig: config} log.Fatal(server.ListenAndServeTLS(os.Getenv("TLS_CERT"), os.Getenv("TLS_KEY"))) } else { log.Fatal(http.ListenAndServe(":1337", handlers.LoggingHandler(os.Stdout, mx))) } }
func main() { var upgrader = websocket.Upgrader{ ReadBufferSize: 1024, WriteBufferSize: 1024, } http.Handle("/", handlers.LoggingHandler(os.Stderr, http.FileServer(http.Dir(".")))) http.HandleFunc("/ws", func(w http.ResponseWriter, r *http.Request) { conn, err := upgrader.Upgrade(w, r, nil) if err != nil { log.Println(err) return } defer conn.Close() for { t, msg, err := conn.ReadMessage() if err != nil { log.Println(err) return } log.Println("Received:", string(msg)) err = conn.WriteMessage(t, msg) if err != nil { log.Println(err) return } } }) host := "localhost:3030" log.Printf("http://%v", host) log.Fatal(http.ListenAndServe(host, nil)) }
func main() { if os.Getenv("BASE_URL") == "" { log.Fatal("BASE_URL environment variable must be set") } if os.Getenv("DB_PATH") == "" { log.Fatal("DB_PATH environment variable must be set") } db := sqlite{Path: path.Join(os.Getenv("DB_PATH"), "db.sqlite")} db.Init() baseURL := os.Getenv("BASE_URL") if !strings.HasSuffix(baseURL, "/") { baseURL += "/" } r := mux.NewRouter() r.HandleFunc("/save", func(response http.ResponseWriter, request *http.Request) { encodeHandler(response, request, db, baseURL) }).Methods("POST") r.HandleFunc("/{id}", func(response http.ResponseWriter, request *http.Request) { decodeHandler(response, request, db) }) r.PathPrefix("/").Handler(http.FileServer(http.Dir("public"))) log.Println("Starting server on port :1337") log.Fatal(http.ListenAndServe(":1337", handlers.LoggingHandler(os.Stdout, r))) }
func main() { counter, err := NewPostgresCounter(os.Getenv("POSTGRES_URL")) if err != nil { log.Printf("Error initializing counter: %#v", err) os.Exit(1) } router := mux.NewRouter().StrictSlash(false) router.HandleFunc("/", renderHandler(counter)) router.HandleFunc("/index.html", renderHandler(counter)) router.HandleFunc("/counter", counterHandler(counter)) router.PathPrefix("/").Handler(http.FileServer(http.Dir("./static"))) loggedRouter := handlers.LoggingHandler(os.Stdout, router) port := os.Getenv("PORT") if port == "" { port = "8080" } log.Printf("Server listening on port: %s", port) http.ListenAndServe(":"+port, loggedRouter) }
func main() { http.HandleFunc("/favicon.ico", iconHandler) indexHandler := http.HandlerFunc(index) aboutHandler := http.HandlerFunc(about) logFile, err := os.OpenFile("server.log", os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0666) if err != nil { panic(err) } http.Handle("/", handlers.LoggingHandler(logFile, handlers.CompressHandler(indexHandler))) http.Handle("/about", handlers.LoggingHandler(logFile, handlers.CompressHandler(aboutHandler))) server := &http.Server{ Addr: ":8080", } log.Println("Listening...") server.ListenAndServe() }
func main() { log.Println("Starting journlr...") var err error db, err = sql.Open("postgres", os.Getenv("JOURNLR_DB")) if err != nil { log.Fatal("No database for journl") } r := mux.NewRouter() r.HandleFunc("/", indexHandler).Methods("GET") r.HandleFunc("/receive", receiveHandler).Methods("POST") // make is used to construct a channel otherwise nothing can be put into it. mailgunStorage = make(chan receiveMsg) // go keyword here is used to make this a goroutine. This is a // lightweight thread that doesn't block execution. If we // expect heavy traffic we can start 5 of these and they'd all // go and process reading off of the mailgunStorage channel. go fetchEmails() http.ListenAndServe(":80", handlers.LoggingHandler(os.Stdout, r)) }
func main() { flag.Parse() setupLogging(*HTTPLogLocation) log.Printf("Now serving on http://localhost:%d\n", *port) runtime.GOMAXPROCS(runtime.NumCPU()) session, err := r.Connect(*DBConnection, "urls") if err != nil { log.Fatal(err) } defer session.Close() router := mux.NewRouter() // UUID format router.HandleFunc("/{key:[a-z0-9-]+}", func(w http.ResponseWriter, request *http.Request) { views.EmbiggenHandler(w, request, session) }).Methods("GET") router.HandleFunc("/", func(w http.ResponseWriter, request *http.Request) { views.ShortenHandler(w, request, session) }).Methods("POST") router.HandleFunc("/", views.IndexHandler).Methods("GET") http.Handle("/", router) err = http.ListenAndServe(fmt.Sprintf(":%d", *port), handlers.LoggingHandler(HTTPLogger, http.DefaultServeMux)) if err != nil { log.Fatal(err) } }
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) } }
func loggingHandler(next http.Handler) http.Handler { logFile, err := os.OpenFile("server.log", os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0777) if err != nil { panic(err) } return handlers.LoggingHandler(logFile, next) }
func main() { var ( socksProxy = flag.String("socks-proxy", "", "Use specified SOCKS proxy (e.g. localhost:2323)") fleetEndpoint = flag.String("fleetEndpoint", "", "Fleet API http endpoint: `http://host:port`") whitelist = flag.String("timerBasedServices", "", "List of timer based services separated by a comma: deployer.service,image-cleaner.service,tunnel-register.service") ) flag.Parse() fleetAPIClient, err := newFleetAPIClient(*fleetEndpoint, *socksProxy) if err != nil { panic(err) } wl := strings.Split(*whitelist, ",") log.Printf("whitelisted services: %v", wl) wlRegexp := make([]*regexp.Regexp, len(wl)) for i, s := range wl { wlRegexp[i] = regexp.MustCompile(s) } handler := fleetUnitHealthHandler(fleetAPIClient, fleetUnitHealthChecker{wlRegexp}) r := mux.NewRouter() r.HandleFunc("/", handler) r.HandleFunc("/__health", handler) err = http.ListenAndServe(":8080", handlers.LoggingHandler(os.Stdout, r)) if err != nil { panic(err) } }
func main() { directory := flag.String("directory", "/usr/local/rct", "Path to the folder storing RCT experiment data") templateDirectory := flag.String("template-directory", "/usr/local/rct/server/templates", "Path to the folder storing RCT server templates (this file -> server/templates)") staticDirectory := flag.String("static-directory", "/usr/local/rct/server/static", "Path to the folder storing RCT server templates (this file -> server/static)") flag.Parse() if len(flag.Args()) > 0 { log.Fatalf("Usage: server [-directory DIRECTORY] ") } h := new(RegexpHandler) renderRoute, err := regexp.Compile("/experiments/.*/iterations/.+/.+/render") if err != nil { log.Fatal(err) } iterationRoute, err := regexp.Compile("/experiments/.*/iterations/.+/.+") if err != nil { log.Fatal(err) } staticRoute, err := regexp.Compile("/static") if err != nil { log.Fatal(err) } defaultRoute, err := regexp.Compile("/") if err != nil { log.Fatal(err) } h.HandleFunc(renderRoute, renderHandler(*directory, *templateDirectory)) h.HandleFunc(iterationRoute, newRctHandler(*directory, *templateDirectory)) h.Handler(staticRoute, http.StripPrefix("/static", http.FileServer(http.Dir(*staticDirectory)))) h.Handler(defaultRoute, http.FileServer(http.Dir(*directory))) allHandlers := jsonStripper(serverHeaderHandler(h)) log.Fatal(http.ListenAndServe(":8080", handlers.LoggingHandler(os.Stdout, allHandlers))) }
func StartWebServer() error { conf, err := config.GetConfig() if err != nil { return err } var hystrixTimeout time.Duration conf.Hystrix.Timeout = strings.TrimSpace(conf.Hystrix.Timeout) if conf.Hystrix.Timeout != "" { hystrixTimeout, err = time.ParseDuration(conf.Hystrix.Timeout) if err != nil || hystrixTimeout < time.Millisecond { hystrixTimeout = time.Second log15.Error("Use default time", "module", "hystrix", "timeout", hystrixTimeout) } } hystrix.ConfigureCommand("waitFor", hystrix.CommandConfig{ Timeout: int(int64(hystrixTimeout) / int64(time.Millisecond)), // converted into Millisecond. MaxConcurrentRequests: conf.Hystrix.MaxConcurrentRequests, ErrorPercentThreshold: conf.Hystrix.ErrorPercentThreshold, RequestVolumeThreshold: conf.Hystrix.RequestVolumeThreshold, SleepWindow: conf.Hystrix.SleepWindow, }) e := echo.New() e.Post("/api/v1/tweet", createTweetV1) e.Get("/api/v1/tweets/:id", getAllTweetForV1) e.Get("/api/v1/wait/:timeout", waitFor) e.Get("/api/v1/wait_protected/:timeout", waitForProtected) e.Static("/", "www/static/") logsrv := log15.New("pid", os.Getpid(), "addr", conf.Web.Address) return listenAndServer(logsrv, conf.Web.Address, handlers.LoggingHandler(os.Stdout, handlers.CompressHandler(e.Router()))) }
func main() { flag.Usage = usage flag.Parse() args := flag.Args() if len(args) != 3 { usage() return } if gpgpubkey == nil { fmt.Fprintf(os.Stderr, "internal error: gpgpubkey is nil") return } if https == nil { fmt.Fprintf(os.Stderr, "internal error: https is nil") return } if port == nil { fmt.Fprintf(os.Stderr, "internal error: port is nil") return } directory = args[0] username = args[1] password = args[2] os.RemoveAll(path.Join(directory, "tmp")) err := os.MkdirAll(path.Join(directory, "tmp"), 0755) if err != nil { fmt.Fprintf(os.Stderr, "%v", err) return } uploads = make(map[int]*upload) authHandler := func(h http.HandlerFunc) http.Handler { return authBasic(username, password, h) } r := mux.NewRouter() r.HandleFunc("/", renderListOfACIs) r.HandleFunc("/pubkeys.gpg", getPubkeys) r.Handle("/{image}/startupload", authHandler(initiateUpload)) r.Handle("/manifest/{num}", authHandler(uploadManifest)) r.Handle("/signature/{num}", authHandler(receiveUpload(tmpSigPath, gotSig))) r.Handle("/aci/{num}", authHandler(receiveUpload(tmpACIPath, gotACI))) r.Handle("/complete/{num}", authHandler(completeUpload)) r.HandleFunc("/find", find) r.NotFoundHandler = http.FileServer(http.Dir(directory)) h := handlers.LoggingHandler(os.Stderr, r) addr := ":" + strconv.Itoa(*port) log.Println("Listening on", addr) log.Fatal(http.ListenAndServe(addr, h)) }
func FilteredLoggingHandler(filteredPaths map[string]struct{}, writer io.Writer, router http.Handler) http.Handler { return filteredLoggingHandler{ filteredPaths: filteredPaths, handler: router, loggingHandler: handlers.LoggingHandler(writer, router), } }
func main() { webroot := "/var/www" bind := "localhost:8000" flag.StringVar(&webroot, "webroot", "/var/www", "web application root") flag.StringVar(&bind, "bind", "localhost:8000", "<host>:<port> or just <host> or <port>") flag.Parse() log.Println("") log.Println(" `( ◔ ౪◔)´") log.Println("") log.Println(" Server running on :8000") r := mux.NewRouter() r.HandleFunc("/ping", PingHandler) r.HandleFunc("/settings", SettingsHandler) r.HandleFunc("/test/lastfm", testArtistSearch) r.PathPrefix("/").Handler( handlers.LoggingHandler(os.Stdout, http.FileServer(http.Dir(webroot)))) //r.HandleFunc("/socket.io", SocketHandler) err := http.ListenAndServe(bind, r) if err != nil { panic(err) } }
func main() { //start a db session session, err := mgo.Dial("localhost") if err != nil { fmt.Println(err) return //UGLY HACK: there are "too many" errors here. } ctx := appContext{db: session, decoder: schema.NewDecoder()} //db, templates map, decoder loggedRouter := handlers.LoggingHandler(os.Stdout, http.DefaultServeMux) fs := handlers.LoggingHandler(os.Stdout, http.FileServer(http.Dir("assets"))) http.Handle("/", fs) http.HandleFunc("/submit", ctx.receiveSubmission ) http.HandleFunc("/unlock/", ctx.unlockHandler) log.Fatal(http.ListenAndServe(":3000", loggedRouter)) }
func main() { flag.Parse() if *helpFlag { fmt.Fprintf(os.Stderr, "Usage of %s\n", os.Args[0]) flag.PrintDefaults() os.Exit(1) } config := loadConfig(*configFile) logger := setupLogging(config.Log.File) mysqlDbmap := iamok.PrepareDBMap(config.MySql.ConnectionString) defer mysqlDbmap.Db.Close() mysqlDbmap.TraceOn("[gorp]", &Foo{}) router := iamok.NewRouter() //Logs the http requests status logHandler := handlers.LoggingHandler(logger, router) c := cors.New(cors.Options{ AllowedMethods: []string{"GET", "POST", "DELETE", "OPTIONS", "PUT"}, AllowedHeaders: []string{"X-Requested-With", "Accept", "Content-Type"}, Debug: true, }) //for accepting CORS requests http.ListenAndServe(":8080", iamok.RecoveryHandler{Handler: c.Handler(logHandler)}) }
func RunAPI() { r := mux.NewRouter() r.HandleFunc("/groups", func(w http.ResponseWriter, r *http.Request) { group_server.HandleCreate(w, r) }).Methods("POST") r.HandleFunc("/groups/{gid}", func(w http.ResponseWriter, r *http.Request) { group_server.HandleDisband(w, r) }).Methods("DELETE") r.HandleFunc("/groups/{gid}/members", func(w http.ResponseWriter, r *http.Request) { group_server.HandleAddGroupMember(w, r) }).Methods("POST") r.HandleFunc("/groups/{gid}/members/{mid}", func(w http.ResponseWriter, r *http.Request) { group_server.HandleQuitGroup(w, r) }).Methods("DELETE") r.HandleFunc("/device/bind", BindToken).Methods("POST") r.HandleFunc("/device/unbind", UnbindToken).Methods("POST") r.HandleFunc("/notification/groups/{gid}", SetGroupQuiet).Methods("POST") r.HandleFunc("/auth/grant", AuthGrant).Methods("POST") r.HandleFunc("/messages", PostIMMessage).Methods("POST") r.HandleFunc("/messages", LoadLatestMessage).Methods("GET") http.Handle("/", handlers.LoggingHandler(os.Stdout, r)) var PORT = config.port var BIND_ADDR = "" addr := fmt.Sprintf("%s:%d", BIND_ADDR, PORT) SingleHTTPService(addr, nil) }
func main() { if flgVersion { fmt.Println(VERSION) return } r := http.NewServeMux() loggingHandler := func(h http.Handler) http.Handler { return gh.LoggingHandler(os.Stdout, h) } commonHandlers := alice.New(handlers.RecoverHandler, gh.ProxyHeaders, loggingHandler) r.Handle("/", commonHandlers.ThenFunc(RootHandler)) r.Handle("/robots.txt", commonHandlers.ThenFunc(RobotsTxtHandler)) r.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.Dir(flgStaticPath)))) addr := fmt.Sprintf("%s:%d", flgHost, flgPort) log.Printf("Listening on %s", addr) err := http.ListenAndServe(addr, r) if err != nil { log.Fatal("ListenAndServe error: ", err) } }
func main() { r := mux.NewRouter() r.HandleFunc("/", hello) fmt.Println("Listening to port :3000") lr := handlers.LoggingHandler(os.Stdout, r) log.Fatal(http.ListenAndServe(":3000", lr)) }
func main() { flag.Parse() k := new(Kasse) k.log = log.New(os.Stderr, "", log.LstdFlags) if db, err := sqlx.Connect(*driver, *connect); err != nil { log.Fatal("Could not open database:", err) } else { k.db = db } defer func() { if err := k.db.Close(); err != nil { log.Println("Error closing database:", err) } }() k.sessions = sessions.NewCookieStore([]byte("TODO: Set up safer password")) http.Handle("/", handlers.LoggingHandler(os.Stderr, k.Handler())) var lcd *lcd2usb.Device if *hardware { var err error if lcd, err = lcd2usb.Open("/dev/ttyACM0", 2, 16); err != nil { log.Fatal(err) } } events := make(chan NFCEvent) // We have to wrap the call in a func(), because the go statement evaluates // it's arguments in the current goroutine, and the argument to log.Fatal // blocks in these cases. if *hardware { go func() { log.Fatal(ConnectAndPollNFCReader("", events)) }() } RegisterHTTPReader(k) go func() { log.Fatal(http.ListenAndServe(*listen, context.ClearHandler(http.DefaultServeMux))) }() for { ev := <-events if ev.Err != nil { log.Println(ev.Err) continue } res, err := k.HandleCard(ev.UID) if res != nil { res.Print(lcd) } else { // TODO: Distinguish between user-facing errors and internal errors flashLCD(lcd, err.Error(), 255, 0, 0) } } }
func LoggingHandler(h http.Handler) http.Handler { logFile, err := os.OpenFile("/usr/amagi/logs/server.log", os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0666) if err != nil { panic(err) } return handlers.LoggingHandler(logFile, h) }
func RestLoggingHandler(h http.Handler) http.Handler { // Middleware to log the incoming request as per the Apache Common logging framework logFile, err := os.OpenFile(grutil.SERVER_LOG, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0666) if err != nil { panic(err) } return handlers.LoggingHandler(logFile, h) }
// Run server. func (c *config) Run() error { session = c.session log.Infof("Bind to: %s", c.bind) log.Infof("Using server URI: %s", c.serverURI) logr := handlers.LoggingHandler(os.Stderr, c.router) return http.ListenAndServe(c.bind, logr) }
// New constructs a pointer to a new App and returns any error encountered. func New(config *Config) (*App, error) { if config.Web.PublicDir == "" { config.Web.PublicDir = "/var/workload-simulator/public/static" } // create a new app config from config yaml and a new App. // OpsConfig can be nil on start since it is specified by the UI. appCfg := AppConfig{ Host: config.Web.Hostname, Port: config.Web.HttpPort, PublicDir: config.Web.PublicDir, ViewsDir: config.Web.ViewsDir, ReportDir: config.Web.ReportDir, MaxDial: config.Settings.MaxDial, MaxWorkers: config.Settings.MaxWorkers, } app := App{ config: &appCfg, templates: make(map[string]*template.Template), } // Register handlers with ServeMux. r := http.NewServeMux() // Static assets. pubDir := config.Web.PublicDir serveStatic := func(name string) { fs := http.FileServer(http.Dir(filepath.Join(pubDir, name))) prefix := "/static/" + name + "/" r.Handle(prefix, http.StripPrefix(prefix, fs)) } serveStatic(`img`) serveStatic(`css`) serveStatic(`js`) serveStatic(`lang`) r.HandleFunc("/", app.handleRoot) r.HandleFunc("/workload", app.handleWorkload) r.HandleFunc("/ping", app.handlePing) r.HandleFunc("/unload", app.handleUnload) r.HandleFunc("/pause", app.handlePause) r.HandleFunc("/stats", app.handleStats) r.HandleFunc("/status", app.handleStatus) r.HandleFunc("/live", app.handleLive) r.HandleFunc("/live/stats", app.handleLiveStats) r.HandleFunc("/sql", app.handleSql) r.HandleFunc("/save", app.handleSave) r.HandleFunc("/kill", app.handleKill) // Add router to app. loggedRouter := handlers.LoggingHandler(os.Stdout, r) app.router = loggedRouter return &app, nil }
func main() { flag.Parse() if *file != "" { in, err := os.Open(*file) if err != nil { log.Fatal(err) } h := hasher.New(in) sng := h.Hash() in.Close() wav := wave.New(wave.Stereo, 22000) ks := karplus.Song{ Song: *sng, SamplingRate: 22000, } ks.Sound(&wav) out, err := os.Create(strings.TrimSuffix(*file, filepath.Ext(*file)) + ".wav") if err != nil { log.Fatal(err) } io.Copy(out, wav.Reader()) return } if *seed != 0 { in := NewRandReader(2*1024*1024, *seed) h := hasher.New(in) sng := h.Hash() wav := wave.New(wave.Stereo, 22000) ks := karplus.Song{ Song: *sng, SamplingRate: 22000, } ks.Sound(&wav) out, err := os.Create(fmt.Sprintf("%v.wav", *seed)) if err != nil { log.Fatal(err) } io.Copy(out, wav.Reader()) return } port := os.Getenv("PORT") if port == "" { port = "8000" } r := mux.NewRouter() r.StrictSlash(true) r.PathPrefix("/").Handler(http.FileServer(http.Dir("./static/"))).Methods("GET") r.HandleFunc("/upload", api.FileUploadHandler).Methods("POST") http.ListenAndServe(":"+port, handlers.LoggingHandler(os.Stdout, r)) }
func main() { logFile, err := os.OpenFile("logs/app.log", os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0666) if err != nil { fmt.Println("Error accessing log file:", err) os.Exit(1) } r := mux.NewRouter() r.Handle("/", handlers.ProxyHeaders(handlers.LoggingHandler(logFile, repsheetHandler(http.HandlerFunc(LoginHandler))))) r.Handle("/admin", handlers.ProxyHeaders(handlers.LoggingHandler(logFile, repsheetHandler(http.HandlerFunc(AdminHandler))))) r.PathPrefix("/static/").Handler(http.StripPrefix("/static/", http.FileServer(http.Dir("static")))) http.Handle("/", r) err = http.ListenAndServe("localhost:8080", r) if err != nil { log.Fatal("Error starting server: ", err) } }
func main() { log.SetFlags(log.LstdFlags | log.Lshortfile) r := mux.NewRouter() r.StrictSlash(true) r.Path("/login").Handler(Handler(GetLogin)).Methods("GET") // r.Path("/login").Handler(Handler(PostLogin)).Methods("POST") // r.Path("/logout").Handler(middleware.Restrict(Handler(PostLogout))).Methods("POST") log.Fatal(http.ListenAndServe(":8080", handlers.LoggingHandler(os.Stdout, r))) }