func main() { // err := godotenv.Load() // if err != nil { // // production don't use an env file // log.Println("No .env file found") // } dbSession, err := api.StartDb("./") if err != nil { log.Fatal(err) } api.MapRoutes(dbSession) log.Print("Starting Goweb powered server...") // make a http server using the goweb.DefaultHttpHandler() s := &http.Server{ Addr: Address, Handler: goweb.DefaultHttpHandler(), ReadTimeout: 10 * time.Second, WriteTimeout: 10 * time.Second, MaxHeaderBytes: 1 << 20, } listener, listenErr := net.Listen("tcp", Address) log.Printf(" visit: %s", Address) if listenErr != nil { log.Fatalf("Could not listen: %s", listenErr) } log.Println("Routes:") log.Printf("%s", goweb.DefaultHttpHandler()) // listen for exit signal i.e. ctrl + C signalChannel := make(chan os.Signal, 1) signal.Notify(signalChannel, os.Interrupt) go func() { for _ = range signalChannel { // sig is a ^C, handle it log.Println("^C") // stop the HTTP server log.Println("Stopping the server...") listener.Close() os.Exit(0) } }() // begin the server log.Fatalf("Error in Serve: %s", s.Serve(listener)) }
func listenAndServe(addr string) (err error) { s := &http.Server{ Addr: addr, Handler: goweb.DefaultHttpHandler(), ReadTimeout: 10 * time.Second, WriteTimeout: 10 * time.Second, MaxHeaderBytes: 1 << 20, } c := make(chan os.Signal, 1) signal.Notify(c, os.Interrupt) listener, err := net.Listen("tcp", addr) if err != nil { logger.Info("Could not listen", err) } go func() { for _ = range c { listener.Close() } }() err = s.Serve(listener) return }
func main() { flag.StringVar(&basedir, "basedir", currentWorkingDirectory, "basedir") flag.StringVar(&address, "address", ":9090", "address") flag.Parse() basedir = basedir + "/" goweb.Map(ghttp.MethodPut, "/recording/{sessionid}/{tindex}", nuttyPut) goweb.Map(ghttp.MethodGet, "/recording/{sessionid}/rec.json", nuttyGetLength) goweb.Map(ghttp.MethodGet, "/recording/{sessionid}/{tindex}", nuttyGet) goweb.MapBefore(func(c context.Context) error { c.HttpResponseWriter().Header().Set("Access-Control-Allow-Origin", "*") c.HttpResponseWriter().Header().Set("Access-Control-Allow-Headers", "Content-Type") c.HttpResponseWriter().Header().Set("Access-Control-Allow-Methods", "PUT,GET") c.HttpResponseWriter().Header().Set("Content-Type", "application/json") return nil }) s := &http.Server{ Addr: address, Handler: goweb.DefaultHttpHandler(), ReadTimeout: 10 * time.Second, WriteTimeout: 10 * time.Second, MaxHeaderBytes: 1 << 20, } log.Println("Starting server") log.Fatal(s.ListenAndServe()) }
func Run() { // HTTP s := &httplib.Server{ Addr: gokuraku.Config.HttpPort, Handler: goweb.DefaultHttpHandler(), ReadTimeout: 10 * time.Second, WriteTimeout: 10 * time.Second, MaxHeaderBytes: 1 << 20, } c := make(chan os.Signal, 1) signal.Notify(c, os.Interrupt) listener, listenErr := net.Listen("tcp", "0.0.0.0:"+gokuraku.Config.HttpPort) if listenErr != nil { log.Fatalf("Could not listen: 0.0.0.0:%s", gokuraku.Config.HttpPort) } go func() { for _ = range c { // sig is a ^C, handle it log.Print("Stopping the server...") listener.Close() log.Print("Tearing down...") log.Fatal("Finished - bye bye. ;-)") } }() log.Printf("Gokuraku HTTP Server: 0.0.0.0:%s", gokuraku.Config.HttpPort) log.Fatalf("Error in Serve: %s", s.Serve(listener)) }
func main() { log.Println("Starting server...") // API Endpoints goweb.Map("/ping", pingHandler) goweb.Map("/getquote/{apiKey}", AowQuote) // End API Endpoints address := ":3000" if port := os.Getenv("PORT"); port != "" { address = ":" + port } server := &http.Server{ Addr: address, Handler: &LoggedHandler{goweb.DefaultHttpHandler()}, ReadTimeout: 10 * time.Second, WriteTimeout: 10 * time.Second, MaxHeaderBytes: 1 << 20, } listener, listenErr := net.Listen("tcp", address) if listenErr != nil { log.Panicf("Could not listen for TCP on %s: %s", address, listenErr) } log.Println("Server loaded, check localhost" + address) server.Serve(listener) }
func HttpListenAndServe() (err error) { s := http.Server{ Addr: LISTEN_ADDR, Handler: goweb.DefaultHttpHandler(), ReadTimeout: 10 * time.Second, WriteTimeout: 10 * time.Second, MaxHeaderBytes: 1 << 20, } goweb.Map("/cnvt", ConvertHandler) err = s.ListenAndServe() return }
func main() { syslog.Openlog("cinefade", syslog.LOG_PID, syslog.LOG_USER) var action string flag.StringVar(&action, "action", "on", "lights on/off") flag.Parse() bridge := cinefade.GetBridge(false) cinefade.MapRoutes(bridge) // make a http server using the goweb.DefaultHttpHandler() s := &http.Server{ Addr: Address, Handler: goweb.DefaultHttpHandler(), ReadTimeout: 10 * time.Second, WriteTimeout: 10 * time.Second, MaxHeaderBytes: 1 << 20, } c := make(chan os.Signal, 1) signal.Notify(c, os.Interrupt) listener, listenErr := net.Listen("tcp", Address) syslog.Info("Server cinefade started") syslog.Infof("visit: %s", Address) if listenErr != nil { syslog.Critf("Could not listen: %s", listenErr) os.Exit(1) } go func() { for _ = range c { // sig is a ^C, handle it // stop the HTTP server syslog.Info("Stopping the cinefade server...") listener.Close() syslog.Info("Tearing down...") os.Exit(0) } }() syslog.Critf("Error in Serve: %s", s.Serve(listener)) os.Exit(1) }
func main() { api.MapRoutes() address := ":" + os.Getenv("PORT") server := &http.Server{ Addr: address, Handler: goweb.DefaultHttpHandler(), ReadTimeout: 10 * time.Second, WriteTimeout: 10 * time.Second, MaxHeaderBytes: 1 << 20, } listener, listenErr := net.Listen("tcp", address) if listenErr != nil { panic(listenErr) } server.Serve(listener) }
// main initializes and starts the web server. func main() { controllers.MapControllers() MapStaticFiles() log.Print("Mapped URLs, creating server...") address := ":" + os.Getenv("PORT") server := &http.Server{ Addr: address, Handler: goweb.DefaultHttpHandler(), ReadTimeout: 10 * time.Second, WriteTimeout: 10 * time.Second, MaxHeaderBytes: 1 << 20, } log.Print("Created server, listening for requests.") listener, listenErr := net.Listen("tcp", address) if listenErr != nil { log.Printf("Could not listen for tcp connections on address %s: %s", address, listenErr.Error()) panic(listenErr) } server.Serve(listener) }
func (c *Configuration) StartServer() { port := c.Json.Port if os.Getenv("PORT") != "" { port = os.Getenv("PORT") log.Print("Using environmental variable for $PORT") } c.HttpPort = port c.HttpServer = &http.Server{ Addr: port, Handler: goweb.DefaultHttpHandler(), ReadTimeout: 10 * time.Second, WriteTimeout: 10 * time.Second, MaxHeaderBytes: 1 << 20, } b := make(chan os.Signal, 1) signal.Notify(b, os.Interrupt) listener, listenErr := net.Listen("tcp", ":"+c.HttpPort) log.Printf(" visit: %s", ":"+c.HttpPort) if listenErr != nil { log.Fatalf("Could not listen: %s", listenErr) } c.Listener = listener go func() { for _ = range b { c.Listener.Close() } }() log.Fatalf("Error in server: %s", c.HttpServer.Serve(listener)) }
func StartService() { s := &http.Server{ Addr: Address, Handler: goweb.DefaultHttpHandler(), ReadTimeout: 10 * time.Second, WriteTimeout: 10 * time.Second, MaxHeaderBytes: 1 << 20, } listener, _ := net.Listen("tcp", Address) iceController := new(IceController) greenController := new(GreenController) regController := new(RegController) preController := new(PredictController) goweb.MapController(regController) goweb.MapController(preController) goweb.MapController(greenController) goweb.MapController(iceController) fmt.Println("wats up") log.Fatalf("Error in Serve: %s", s.Serve(listener)) }
func main() { log.Info("Glasgow Memories Server") log.Info("=======================") utils.InitEnv() var Address = ":" + utils.EnvPort() var baseURL = utils.EnvUrl() m.Connect() defer m.Close() // prepare the decryption key if utils.LoadCypherKey() != nil { log.Error("Failed to load the decryption key.") return } // GOMNIAUTH gomniauth.SetSecurityKey(signature.RandomKey(64)) gomniauth.WithProviders( facebook.New("1497244403859030", "fbbb08c47e0441bcf23ea82b5f340fe5", baseURL+"/api/auth/facebook/callback/"), ) // Attach the DB collection references to the context in order to pass it around goweb.MapBefore(func(ctx context.Context) error { var user = m.User{} cookieC, err := ctx.HttpRequest().Cookie("token") var cookie string if err != nil { cookie = ctx.FormValue("token") if cookie == "" { return nil } } else { cookie = cookieC.Value } err = m.GetDB("User").Find(bson.M{"token": cookie}).One(&user) if err != nil { // log.Info("MapBefore 2 " + err.Error()) return nil } ctx.Data()["user"] = user return nil }) goweb.MapStatic("/static", "../static") // This is the directory with all static UI files goweb.MapStatic("/uploads", "../uploads") // This is the directory where we should store uploaded files // ENDPOINTS goweb.Map("GET", "/", endpoints.Root) goweb.Map("POST", "api/auth/local/register", endpoints.Register) goweb.Map("POST", "api/auth/local/login", endpoints.Login) goweb.Map("GET", "api/auth/{provider}/callback", endpoints.Callback) goweb.Map([]string{"GET", "POST"}, "api/auth/{provider}/{action}", endpoints.Connect) goweb.Map("POST", "api/upload/image", endpoints.UploadImage) goweb.Map("GET", "api/images/get", endpoints.GetImages) goweb.Map("POST", "api/upload/csv", endpoints.UploadTrail) goweb.Map("GET", "api/trails/get", endpoints.GetTrails) goweb.Map("POST", "api/upload/video", endpoints.UploadVideo) goweb.Map("GET", "api/videos/get", endpoints.GetVideos) goweb.Map("GET", "api/user", endpoints.GetUserInfo) goweb.Map("GET", "api/stats/get", endpoints.GetStats) goweb.Map("GET", "api/popLocations", endpoints.GetPopularLocations) goweb.Map("POST", "api/upload/imagetable", endpoints.UploadImageTable) goweb.Map("POST", "api/upload/zip", endpoints.UploadZip) // TODO: Add new endpoints here goweb.Map(endpoints.NotFound) // Remove the information from the data just in case the call is intercepted goweb.MapAfter(func(ctx context.Context) error { ctx.Data()["user"] = "" return nil }) // setup the API responder codecService := services.NewWebCodecService() codecService.RemoveCodec("text/xml") apiResponder := responders.NewGowebAPIResponder(codecService, goweb.Respond) apiResponder.StandardFieldDataKey = "data" apiResponder.StandardFieldStatusKey = "status" apiResponder.StandardFieldErrorsKey = "errors" goweb.API = apiResponder // SERVER s := &http.Server{ Addr: Address, Handler: goweb.DefaultHttpHandler(), ReadTimeout: 5 * time.Minute, WriteTimeout: 5 * time.Minute, MaxHeaderBytes: 1 << 20, } c := make(chan os.Signal, 1) signal.Notify(c, os.Interrupt) listener, listenErr := net.Listen("tcp", Address) log.Info("Server port: " + Address) log.Info("Server running at: " + baseURL + "\n") if listenErr != nil { log.Error("Could not listen: " + listenErr.Error()) } go func() { for _ = range c { // sig is a ^C, handle it // stop the HTTP server log.Info("Stopping the server...\n") listener.Close() log.Info("Server stopped.\n") } }() // begin the server log.Error("Error in Serve: " + s.Serve(listener).Error()) }
func main() { log.SetFlags(0) log.Printf("Reservoir %s.%s.%s | A GOod Build Server\n", MAJOR_VERSION, MINOR_VERSION, PATCH_VERSION) log.SetFlags(log.Ldate | log.Ltime | log.Lshortfile) log.Print("") var serverConfig map[string]map[string]interface{} err := Config_GetConfig("server", &serverConfig) if err != nil { panic(err) } useFcgi := serverConfig[Config_Environment]["fcgi"].(bool) addr := serverConfig[Config_Environment]["listenon"].(string) runtime.GOMAXPROCS(serverConfig[Config_Environment]["gomaxprocs"].(int)) log.Printf("Starting listener at %s...", addr) listener, err := net.Listen("tcp", addr) if err != nil { log.Panicf("Error starting listener: %s", err) } handler := &AuthHandler{goweb.DefaultHttpHandler()} if useFcgi { log.Print("Starting in FCGI mode.") err = fcgi.Serve(listener, handler) } else { log.Print("Starting in HTTP mode.") err = http.Serve(listener, handler) } if err != nil { log.Panicf("Error starting server mode: %s", err) } log.Print("Starting signal handler...") c := make(chan os.Signal, 1) signal.Notify(c, os.Interrupt) go func() { for _ = range c { // sig is a ^C, handle it // stop the HTTP server log.Print("Stopping the server...") listener.Close() log.Print("Cleaning up remaining tasks...") // FIXME cleanup os.Exit(0) } }() // begin the server log.Fatalf("Error in Serve: %s", s.Serve(listener)) }
func main() { // setup the providers gomniauth.SetSecurityKey("yLiCQYG7CAflDavqGH461IO0MHp7TEbpg6TwHBWdJzNwYod1i5ZTbrIF5bEoO3oP") // NOTE: DO NOT COPY THIS - MAKE YOR OWN! gomniauth.WithProviders( github.New("3d1e6ba69036e0624b61", "7e8938928d802e7582908a5eadaaaf22d64babf1", "http://localhost:8080/auth/github/callback"), google.New("1051709296778.apps.googleusercontent.com", "7oZxBGwpCI3UgFMgCq80Kx94", "http://localhost:8080/auth/google/callback"), facebook.New("537611606322077", "f9f4d77b3d3f4f5775369f5c9f88f65e", "http://localhost:8080/auth/facebook/callback"), uber.New("UBERKEY", "UBERSECRET", "http://localhost:8080/auth/uber/callback"), ) goweb.Map("/", func(ctx context.Context) error { return goweb.Respond.With(ctx, http.StatusOK, []byte(` <html> <body> <h2>Log in with...</h2> <ul> <li> <a href="auth/github/login">GitHub</a> </li> <li> <a href="auth/google/login">Google</a> </li> <li> <a href="auth/facebook/login">Facebook</a> </li> <li> <a href="auth/uber/login">Uber</a> </li> </ul> </body> </html> `)) }) /* GET /auth/{provider}/login Redirects them to the fmtin page for the specified provider. */ goweb.Map("auth/{provider}/login", func(ctx context.Context) error { provider, err := gomniauth.Provider(ctx.PathValue("provider")) if err != nil { return err } state := gomniauth.NewState("after", "success") // if you want to request additional scopes from the provider, // pass them as login?scope=scope1,scope2 //options := objx.MSI("scope", ctx.QueryValue("scope")) authUrl, err := provider.GetBeginAuthURL(state, nil) if err != nil { return err } // redirect return goweb.Respond.WithRedirect(ctx, authUrl) }) goweb.Map("auth/{provider}/callback", func(ctx context.Context) error { provider, err := gomniauth.Provider(ctx.PathValue("provider")) if err != nil { return err } creds, err := provider.CompleteAuth(ctx.QueryParams()) if err != nil { return err } /* // get the state state, stateErr := gomniauth.StateFromParam(ctx.QueryValue("state")) if stateErr != nil { return stateErr } // redirect to the 'after' URL afterUrl := state.GetStringOrDefault("after", "error?e=No after parameter was set in the state") */ // load the user user, userErr := provider.GetUser(creds) if userErr != nil { return userErr } return goweb.API.RespondWithData(ctx, user) // redirect //return goweb.Respond.WithRedirect(ctx, afterUrl) }) /* ---------------------------------------------------------------- START OF WEB SERVER CODE ---------------------------------------------------------------- */ log.Println("Starting...") fmt.Print("Gomniauth - Example web app\n") fmt.Print("by Mat Ryer and Tyler Bunnell\n") fmt.Print(" \n") fmt.Print("Starting Goweb powered server...\n") // make a http server using the goweb.DefaultHttpHandler() s := &http.Server{ Addr: Address, Handler: goweb.DefaultHttpHandler(), ReadTimeout: 10 * time.Second, WriteTimeout: 10 * time.Second, MaxHeaderBytes: 1 << 20, } c := make(chan os.Signal, 1) signal.Notify(c, os.Interrupt) listener, listenErr := net.Listen("tcp", Address) fmt.Printf(" visit: %s\n", Address) if listenErr != nil { log.Fatalf("Could not listen: %s", listenErr) } fmt.Println("\n") fmt.Println("Try some of these routes:\n") fmt.Printf("%s", goweb.DefaultHttpHandler()) fmt.Println("\n\n") go func() { for _ = range c { // sig is a ^C, handle it // stop the HTTP server fmt.Print("Stopping the server...\n") listener.Close() /* Tidy up and tear down */ fmt.Print("Tearing down...\n") // TODO: tidy code up here log.Fatal("Finished - bye bye. ;-)\n") } }() // begin the server log.Fatalf("Error in Serve: %s\n", s.Serve(listener)) /* ---------------------------------------------------------------- END OF WEB SERVER CODE ---------------------------------------------------------------- */ }
func main() { // map the routes mapRoutes() /* START OF WEB SERVER CODE This code is taken from Goweb server by Mat Ryer and Tyler Bunnell */ log.Print("Goweb 2") log.Print("by Mat Ryer and Tyler Bunnell") log.Print(" ") log.Print("Starting Goweb powered server...") // make a http server using the goweb.DefaultHttpHandler() s := &http.Server{ Addr: Address, Handler: goweb.DefaultHttpHandler(), ReadTimeout: 10 * time.Second, WriteTimeout: 10 * time.Second, MaxHeaderBytes: 1 << 20, } c := make(chan os.Signal, 1) signal.Notify(c, os.Interrupt) listener, listenErr := net.Listen("tcp", Address) log.Printf(" visit: %s", Address) if listenErr != nil { log.Fatalf("Could not listen: %s", listenErr) } log.Println("") log.Print("Point your browser to:") log.Printf("\t http://localhost%s", Address) go func() { for _ = range c { // sig is a ^C, handle it // stop the HTTP server log.Print("Stopping the server...") listener.Close() log.Print("Tearing down...") log.Fatal("Finished - bye bye. ;-)") } }() // begin the server log.Fatalf("Error in Serve: %s", s.Serve(listener)) /* END OF WEB SERVER CODE */ }
func init() { api.MapRoutes() http.Handle("/", goweb.DefaultHttpHandler()) }
func Controller_Project() { goweb.Map("/", func(c context.Context) error { return goweb.API.RespondWithData(c, goweb.DefaultHttpHandler().String()) }) // Map main projects view goweb.Map(gowebhttp.MethodGet, "/projects", func(c context.Context) error { list, err := Model_GetProjectList() if err != nil { log.Printf("error in controller: %s", err.Error()) debug.PrintStack() return goweb.API.RespondWithError(c, http.StatusInternalServerError, err.Error()) } jsonresp, err := json.MarshalIndent(list, "", "\t") if err != nil { log.Printf("error in controller: %s", err.Error()) debug.PrintStack() return goweb.API.RespondWithError(c, http.StatusInternalServerError, err.Error()) } return goweb.API.RespondWithData(c, jsonresp) }) goweb.Map(gowebhttp.MethodGet, "/projects/user", func(c context.Context) error { list, err := Model_GetProjectList() if err != nil { log.Printf("error in controller: %s", err.Error()) debug.PrintStack() return goweb.API.RespondWithError(c, http.StatusInternalServerError, err.Error()) } jsonresp, err := json.MarshalIndent(list, "", "\t") if err != nil { log.Printf("error in controller: %s", err.Error()) debug.PrintStack() return goweb.API.RespondWithError(c, http.StatusInternalServerError, err.Error()) } return goweb.API.RespondWithData(c, jsonresp) }) goweb.Map(gowebhttp.MethodGet, "/project/{name}", func(c context.Context) error { proj, err := Model_GetProject(c.PathParam("name")) if err != nil { log.Printf("error in controller: %s", err.Error()) debug.PrintStack() return goweb.API.RespondWithError(c, http.StatusInternalServerError, err.Error()) } jsonresp, err := json.MarshalIndent(proj, "", "\t") if err != nil { log.Printf("error in controller: %s", err.Error()) debug.PrintStack() return goweb.API.RespondWithError(c, http.StatusInternalServerError, err.Error()) } return goweb.API.RespondWithData(c, jsonresp) }) goweb.Map("/project/{name}", func(c context.Context) error { proj, err := Model_GetProject(c.PathParam("name")) if err != nil { log.Printf("error in controller: %s", err.Error()) debug.PrintStack() return goweb.API.RespondWithError(c, http.StatusInternalServerError, err.Error()) } jsonresp, err := json.MarshalIndent(proj, "", "\t") if err != nil { log.Printf("error in controller: %s", err.Error()) debug.PrintStack() return goweb.API.RespondWithError(c, http.StatusInternalServerError, err.Error()) } return goweb.API.RespondWithData(c, jsonresp) }) }
func main() { // map the routes mapRoutes() /* START OF WEB SERVER CODE */ log.Print("Goweb 2") log.Print("by Mat Ryer and Tyler Bunnell") log.Print(" ") log.Print("Starting Goweb powered server...") // make a http server using the goweb.DefaultHttpHandler() s := &http.Server{ Addr: Address, Handler: goweb.DefaultHttpHandler(), ReadTimeout: 10 * time.Second, WriteTimeout: 10 * time.Second, MaxHeaderBytes: 1 << 20, } c := make(chan os.Signal, 1) signal.Notify(c, os.Interrupt) listener, listenErr := net.Listen("tcp", Address) log.Printf(" visit: %s", Address) if listenErr != nil { log.Fatalf("Could not listen: %s", listenErr) } log.Println("") log.Print("Some things to try in your browser:") log.Printf("\t http://localhost%s", Address) log.Printf("\t http://localhost%s/status-code/404", Address) log.Printf("\t http://localhost%s/people", Address) log.Printf("\t http://localhost%s/people/123", Address) log.Printf("\t http://localhost%s/people/anything", Address) log.Printf("\t http://localhost%s/people/me (will redirect)", Address) log.Printf("\t http://localhost%s/errortest", Address) log.Printf("\t http://localhost%s/things (try RESTful actions)", Address) log.Printf("\t http://localhost%s/123", Address) log.Println("") log.Println("Also try some of these routes:") log.Printf("%s", goweb.DefaultHttpHandler()) go func() { for _ = range c { // sig is a ^C, handle it // stop the HTTP server log.Print("Stopping the server...") listener.Close() log.Print("Tearing down...") log.Fatal("Finished - bye bye. ;-)") } }() // begin the server log.Fatalf("Error in Serve: %s", s.Serve(listener)) /* END OF WEB SERVER CODE */ }
func main() { pins := SetupIo() goweb.MapStatic("/static", "static") // this one needs to fail if the hardware is broken in // any way that we can determine, though I'm not sure // what that will mean on rpi goweb.MapStaticFile("/", "index.html") goweb.Map("GET", "/status", func(c context.Context) error { jsonEncode := json.NewEncoder(c.HttpResponseWriter()) jsonEncode.Encode(map[string]interface{}{ "motion": pins.GetMotion(), "switch1": pins.GetSwitch("1"), "switch2": pins.GetSwitch("2"), "switch3": pins.GetSwitch("3"), "doorClosed": pins.GetDoor(), "led": pins.LastOutLed, "strike": pins.LastOutStrike, }) return nil }) goweb.Map("GET", "/trig", func(c context.Context) error { statements := make(chan *goraptor.Statement, 100) close(statements) serializer := goraptor.NewSerializer("trig") defer serializer.Free() str, err := serializer.Serialize(statements, "") if err != nil { panic(err) } return goweb.Respond.With(c, 200, []byte(str)) }) goweb.Map("GET", "/graph", func(c context.Context) error { DC := namespace("http://purl.org/dc/terms/") ROOM := namespace("http://projects.bigasterisk.com/room/") statements := make(chan *goraptor.Statement, 100) graph := ROOM("laundryDoor") _, thisFile, _, _ := runtime.Caller(0) statements <- &(goraptor.Statement{ graph, DC("creator"), literal(thisFile, nil), graph}) statements <- &(goraptor.Statement{ graph, DC("modified"), nowLiteral(), graph}) for subj, state := range map[*goraptor.Uri]*goraptor.Uri{ ROOM("laundryDoorMotion"): ROOM(pins.GetMotion()), ROOM("laundryDoorOpen"): ROOM(pins.GetDoor()), ROOM("laundryDoorSwitch1"): ROOM(pins.GetSwitch("1")), ROOM("laundryDoorSwitch2"): ROOM(pins.GetSwitch("2")), ROOM("laundryDoorSwitch3"): ROOM(pins.GetSwitch("3")), ROOM("laundryDoorLed"): ROOM(pins.GetLed()), ROOM("laundryDoorStrike"): ROOM(pins.GetStrike()), } { statements <- &(goraptor.Statement{subj, ROOM("state"), state, graph}) } close(statements) return serializeGowebResponse(c, "nquads", statements) }) goweb.Map("PUT", "/led", func(c context.Context) error { body, err := c.RequestBody() if err != nil { panic(err) } pins.SetLed(string(body)) return goweb.Respond.WithStatusText(c, http.StatusAccepted) }) goweb.Map("PUT", "/strike", func(c context.Context) error { body, err := c.RequestBody() if err != nil { panic(err) } pins.SetStrike(string(body)) return goweb.Respond.WithStatusText(c, http.StatusAccepted) }) goweb.Map( "PUT", "/strike/temporaryUnlock", func(c context.Context) error { type TemporaryUnlockRequest struct { Seconds float64 } var req TemporaryUnlockRequest err := json.NewDecoder(c.HttpRequest().Body). Decode(&req) if err != nil { panic(err) } // This is not correctly reentrant. There should be a // stack of temporary effects that unpop correctly, // and status should show you any running effects. pins.SetStrike("unlocked") go func() { time.Sleep(time.Duration(req.Seconds * float64(time.Second))) pins.SetStrike("locked") }() return goweb.Respond.WithStatusText( c, http.StatusAccepted) }) goweb.Map("PUT", "/speaker/beep", func(c context.Context) error { // queue a beep return goweb.Respond.WithStatusText(c, http.StatusAccepted) }) // start input posting loop. add nquads to reasoning2 address := ":8081" s := &http.Server{ Addr: address, Handler: goweb.DefaultHttpHandler(), ReadTimeout: 10 * time.Second, WriteTimeout: 10 * time.Second, } log.Printf("Listening on port %s", address) log.Printf("%s", goweb.DefaultHttpHandler()) listener, listenErr := net.Listen("tcp", address) if listenErr != nil { panic(listenErr) } s.Serve(listener) }
func main() { // map the routes mapRoutes() /* START OF WEB SERVER CODE */ log.Print("Webgit 1.0") log.Print("by Gustavo Decarlo") log.Print(" ") log.Print("Starting server...") // make a http server using the goweb.DefaultHttpHandler() s := &http.Server{ Addr: Address, Handler: goweb.DefaultHttpHandler(), ReadTimeout: 10 * time.Second, WriteTimeout: 10 * time.Second, MaxHeaderBytes: 1 << 20, } c := make(chan os.Signal, 1) signal.Notify(c, os.Interrupt) listener, listenErr := net.Listen("tcp", Address) log.Printf(" visit: %s", Address) if listenErr != nil { log.Fatalf("Could not listen: %s", listenErr) } log.Println("") log.Print("Some things to try in your browser:") log.Printf("\t http://localhost%s", Address) log.Printf("\t http://localhost%s/status-code/404", Address) log.Printf("\t http://localhost%s/gitsearch", Address) log.Printf("\t http://localhost%s/reposdeveloper", Address) log.Printf("\t http://localhost%s/followersdevelopers", Address) log.Printf("\t http://localhost%s/developers (try RESTful actions)", Address) log.Println("") log.Println("Also try some of these routes:") log.Printf("%s", goweb.DefaultHttpHandler()) go func() { for _ = range c { // sig is a ^C, handle it // stop the HTTP server log.Print("Stopping the server...") listener.Close() /* Tidy up and tear down */ log.Print("Tearing down...") // TODO: tidy code up here log.Fatal("Finished - bye bye. ;-)") } }() // begin the server log.Fatalf("Error in Serve: %s", s.Serve(listener)) /* END OF WEB SERVER CODE */ }
func main() { // handle every path goweb.Map("***", func(c context.Context) error { method := c.HttpRequest().Method requestUrl := absoluteUrlForRequest(c.HttpRequest()) privateKey := "PRIVATE" body, bodyErr := ioutil.ReadAll(c.HttpRequest().Body) fmt.Printf("URL: %s", requestUrl) if bodyErr != nil { goweb.Respond.With(c, 500, []byte(fmt.Sprintf("Balls! Couldn't read the body because %s", bodyErr))) return nil } t := tracer.New(tracer.LevelEverything) valid, _ := signature.ValidateSignatureWithTrace(method, requestUrl, string(body), privateKey, t) // return the tracing c.HttpResponseWriter().Header().Set("Content Type", "text/html") c.HttpResponseWriter().Write([]byte("<html>")) c.HttpResponseWriter().Write([]byte("<head>")) c.HttpResponseWriter().Write([]byte("<title>Signature</title>")) c.HttpResponseWriter().Write([]byte("<link href='http://reset5.googlecode.com/hg/reset.min.css' rel='stylesheet' />")) c.HttpResponseWriter().Write([]byte("<style>")) c.HttpResponseWriter().Write([]byte(".page{padding:10px}")) c.HttpResponseWriter().Write([]byte(".status{padding:10px}")) if valid { c.HttpResponseWriter().Write([]byte(".status{background-color:green}")) } else { c.HttpResponseWriter().Write([]byte(".status{background-color:red}")) } c.HttpResponseWriter().Write([]byte("</style>")) c.HttpResponseWriter().Write([]byte("</head>")) c.HttpResponseWriter().Write([]byte("<body>")) c.HttpResponseWriter().Write([]byte("<div class='page'>")) c.HttpResponseWriter().Write([]byte("<div class='status'></div>")) c.HttpResponseWriter().Write([]byte("<pre>")) for _, trace := range t.Data() { c.HttpResponseWriter().Write([]byte(trace.Data)) c.HttpResponseWriter().Write([]byte("\n")) } c.HttpResponseWriter().Write([]byte("</pre>")) c.HttpResponseWriter().Write([]byte("</div>")) c.HttpResponseWriter().Write([]byte("</body>")) c.HttpResponseWriter().Write([]byte("</html>")) return nil }) fmt.Println("Signature test webserver") fmt.Println("by Mat Ryer and Tyler Bunnell") fmt.Println(" ") fmt.Println("Start making signed request to: http://localhost:8080/") /* START OF WEB SERVER CODE */ log.Print("Goweb 2") log.Print("by Mat Ryer and Tyler Bunnell") log.Print(" ") log.Print("Starting Goweb powered server...") // make a http server using the goweb.DefaultHttpHandler() s := &http.Server{ Addr: "Address", Handler: goweb.DefaultHttpHandler(), ReadTimeout: 10 * time.Second, WriteTimeout: 10 * time.Second, MaxHeaderBytes: 1 << 20, } c := make(chan os.Signal, 1) signal.Notify(c, os.Interrupt) listener, listenErr := net.Listen("tcp", Address) log.Printf(" visit: %s", Address) if listenErr != nil { log.Fatalf("Could not listen: %s", listenErr) } log.Println("Also try some of these routes:") log.Printf("%s", goweb.DefaultHttpHandler()) go func() { for _ = range c { // sig is a ^C, handle it // stop the HTTP server log.Print("Stopping the server...") listener.Close() /* Tidy up and tear down */ log.Print("Tearing down...") // TODO: tidy code up here log.Fatal("Finished - bye bye. ;-)") } }() // begin the server log.Fatalf("Error in Serve: %s", s.Serve(listener)) /* END OF WEB SERVER CODE */ }
func main() { // init(s) conf.Initialize() logger.Initialize() if err := db.Initialize(); err != nil { logger.Error(err.Error()) } user.Initialize() node.Initialize() preauth.Initialize() auth.Initialize() // print conf printLogo() conf.Print() if _, err := os.Stat(conf.Conf["data-path"] + "/temp"); err != nil && os.IsNotExist(err) { if err := os.Mkdir(conf.Conf["data-path"]+"/temp", 0777); err != nil { fmt.Fprintf(os.Stderr, "ERROR: %v\n", err) logger.Error("ERROR: " + err.Error()) } } // reload if conf.RELOAD != "" { fmt.Println("####### Reloading #######") err := reload(conf.RELOAD) if err != nil { fmt.Fprintf(os.Stderr, "ERROR: %v\n", err) logger.Error("ERROR: " + err.Error()) } fmt.Println("Done") } // setting GOMAXPROCS var procs int avail := runtime.NumCPU() if avail <= 2 { procs = 1 } else if avail == 3 { procs = 2 } else { procs = avail - 2 } fmt.Println("##### Procs #####") fmt.Printf("Number of available CPUs = %d\n", avail) if conf.Conf["GOMAXPROCS"] != "" { if setting, err := strconv.Atoi(conf.Conf["GOMAXPROCS"]); err != nil { fmt.Fprintf(os.Stderr, "ERROR: could not interpret configured GOMAXPROCS value as integer.") } else { procs = setting } } if procs <= avail { fmt.Printf("Running Shock server with GOMAXPROCS = %d\n", procs) runtime.GOMAXPROCS(procs) } else { fmt.Println("GOMAXPROCS config value is greater than available number of CPUs.") fmt.Printf("Running Shock server with GOMAXPROCS = %d\n", avail) runtime.GOMAXPROCS(avail) } Address := ":" + conf.Conf["api-port"] mapRoutes() s := &http.Server{ Addr: ":" + Address, Handler: goweb.DefaultHttpHandler(), ReadTimeout: 100 * time.Second, WriteTimeout: 100 * time.Second, MaxHeaderBytes: 1 << 20, } c := make(chan os.Signal, 1) signal.Notify(c, os.Interrupt) listener, listenErr := net.Listen("tcp", Address) if listenErr != nil { fmt.Fprintf(os.Stderr, "Could not listen: %s\n", listenErr) } go func() { for _ = range c { // sig is a ^C, handle it // stop the HTTP server fmt.Fprintln(os.Stderr, "Stopping the server...") listener.Close() } }() fmt.Fprintf(os.Stderr, "Error in Serve: %s\n", s.Serve(listener)) }