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 MapRoutes(bridge *hue.Bridge) { goweb.MapBefore(func(c context.Context) error { c.HttpResponseWriter().Header().Set("X-Custom-Header", "Goweb") return nil }) goweb.MapAfter(func(c context.Context) error { return nil }) goweb.Map("/", func(c context.Context) error { return goweb.Respond.With(c, 200, []byte("Welcome to the cinefade webapp\n")) }) goweb.Map("/cinefade/{action}", func(c context.Context) error { action := c.PathValue("action") cinefadeSwitch(bridge, action) syslog.Infof("action %s was done by cinefade", action) return goweb.Respond.With(c, 200, []byte("Action '"+action+"' was done by cinefade\n")) }) goweb.Map(func(c context.Context) error { return goweb.API.Respond(c, 404, nil, []string{"File not found"}) }) }
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 MapRoutes(dbSession *r.Session) { // before everything // goweb.MapBefore(func(c context.Context) error { // // authentication // c.HttpResponseWriter().Header().Set("X-Custom-Header", "Authentication") // return nil // }) accounts := &controllers.Accounts{DbSession: dbSession} goweb.MapController(accounts) goweb.Map(gowebhttp.MethodPost, "/api/accounts/{id}/adjust", accounts.Adjust) accountTransactions := &controllers.AccountTransactions{DbSession: dbSession} goweb.MapController(accountTransactions) goweb.MapStatic("/public", "src/public") goweb.MapStaticFile("/", "src/index.html") goweb.MapStaticFile("/favicon.ico", "src/favicon.ico") // Catch-all handler for everything that we don't understand goweb.Map(func(c context.Context) error { // just return a 404 message return goweb.API.Respond(c, 404, nil, []string{"File not found"}) }) }
func generateAuthRoutes() { /* Perform the auth */ goweb.Map("/auth/{provider}", func(c context.Context) error { log.Println("Starting authentication") provider, err := gomniauth.Provider(c.PathValue("provider")) log.Println("Created new provider") if err != nil { return err } state := gomniauth.NewState("after", "success") log.Println("Set to new state") authUrl, err := provider.GetBeginAuthURL(state, nil) log.Println("Getting auth url") if err != nil { return err } log.Println("Responding with redirect") return goweb.Respond.WithRedirect(c, authUrl) }) /* Callback from auth */ goweb.Map("/auth/{provider}/callback", func(c context.Context) error { log.Println("Authentication response") provider, err := gomniauth.Provider(c.PathValue("provider")) if err != nil { log.Fatalf("Error with provider") return goweb.Respond.WithRedirect(c, "/auth/status/failed") } creds, err := provider.CompleteAuth(c.QueryParams()) log.Println("Completing authentication") if err != nil { log.Fatalf("Error completing authentication") return goweb.Respond.WithRedirect(c, "/auth/status/failed") } log.Println("Getting user credentials") user, userErr := provider.GetUser(creds) if userErr != nil { log.Fatalf("Get user error") return goweb.Respond.WithRedirect(c, "/auth/status/failed") } log.Println("Authenticated successfully!") log.Println("Username: %s User email: %s", user.Name(), user.Email()) return goweb.Respond.WithRedirect(c, "/auth/status/successful") }) /* Complete auth notification */ goweb.Map("/auth/status/successful", func(c context.Context) error { return goweb.Respond.With(c, 200, []byte("Authentication completed successfully")) }) /* Failed auth notification */ goweb.Map("/auth/status/failed", func(c context.Context) error { return goweb.Respond.With(c, 400, []byte("Authentication failed")) }) }
func mapStatics() { root := os.Getenv("GOPATH") + "/src/github.com/ToQoz/Gokuraku" goweb.MapStaticFile("/", root+"/public/html/index.html") goweb.MapStatic("/js", root+"/public/js") goweb.MapStatic("/css", root+"/public/css") goweb.MapStaticFile("/favicon.ico", root+"/public/favicon.ico") goweb.Map("/soundcloud_client_id", func(ctx context.Context) error { return goweb.API.RespondWithData(ctx, gokuraku.Config.SoundcloudClientId) }) goweb.Map("/websocket_port", func(ctx context.Context) error { return goweb.API.RespondWithData(ctx, gokuraku.Config.WebSocketPort) }) }
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 generateHomePage() { goweb.Map("/", func(c context.Context) error { s1, _ := template.ParseFiles("tmpl/header.tmpl", "tmpl/content.tmpl", "tmpl/footer.tmpl") fbody, err := ioutil.ReadFile("views/home.html") if err != nil { } var buffer bytes.Buffer s1.ExecuteTemplate(&buffer, "header", nil) s1.ExecuteTemplate(&buffer, "content", template.HTML(string(fbody))) s1.ExecuteTemplate(&buffer, "footer", nil) return goweb.Respond.With(c, 200, buffer.Bytes()) }) }
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() { // 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 ---------------------------------------------------------------- */ }
// mapRoutes contains lots of examples of how to map Books in // Goweb. It is in its own function so that test code can call it // without having to run main(). func mapRoutes() { /* Add a pre-handler to save the referrer */ goweb.MapBefore(func(c context.Context) error { // add a custom header c.HttpResponseWriter().Header().Set("X-Custom-Header", "Goweb") return nil }) /* Add a post-handler to log someBook */ goweb.MapAfter(func(c context.Context) error { // TODO: log this return nil }) /* Map the homepage... */ goweb.Map("/", func(c context.Context) error { return goweb.Respond.With(c, 200, []byte("Welcome to the Goweb example app - see the terminal for instructions.")) }) /* /status-code/xxx Where xxx is any HTTP status code. */ goweb.Map("/status-code/{code}", func(c context.Context) error { // get the path value as an integer statusCodeInt, statusCodeIntErr := strconv.Atoi(c.PathValue("code")) if statusCodeIntErr != nil { return goweb.Respond.With(c, http.StatusInternalServerError, []byte("Failed to convert 'code' into a real status code number.")) } // respond with the status return goweb.Respond.WithStatusText(c, statusCodeInt) }) // /errortest should throw a system error and be handled by the // DefaultHttpHandler().ErrorHandler() Handler. goweb.Map("/errortest", func(c context.Context) error { return errors.New("This is a test error!") }) /* Map a RESTful controller (see the BooksController for all the methods that will get mapped) */ BooksController := new(BooksController) goweb.MapController(BooksController) goweb.Map(func(c context.Context) error { return goweb.API.RespondWithData(c, "Just a number!") }, goweb.RegexPath(`^[0-9]+$`)) /* Catch-all handler for everything that we don't understand */ goweb.Map(func(c context.Context) error { // just return a 404 message return goweb.API.Respond(c, 404, nil, []string{"File not found"}) }) }
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) }) }
// mapRoutes contains lots of examples of how to map things in // Goweb. It is in its own function so that test code can call it // without having to run main(). func mapRoutes() { /* Add a pre-handler to save the referrer */ goweb.MapBefore(func(c context.Context) error { // add a custom header c.HttpResponseWriter().Header().Set("X-Custom-Header", "Goweb") return nil }) /* Add a post-handler to log something */ goweb.MapAfter(func(c context.Context) error { // TODO: log this return nil }) /* Map the homepage... */ goweb.Map("/", func(c context.Context) error { return goweb.Respond.With(c, 200, []byte("Welcome to the Goweb example app - see the terminal for instructions.")) }) /* Map a specific route that will redirect */ goweb.Map("GET", "people/me", func(c context.Context) error { hostname, _ := os.Hostname() return goweb.Respond.WithRedirect(c, fmt.Sprintf("/people/%s", hostname)) }) /* /people (with optional ID) */ goweb.Map("GET", "people/[id]", func(c context.Context) error { if c.PathParams().Has("id") { return goweb.API.Respond(c, 200, fmt.Sprintf("Yes, this worked and your ID is %s", c.PathParams().Get("id")), nil) } else { return goweb.API.Respond(c, 200, "Yes, this worked but you didn't specify an ID", nil) } }) /* /status-code/xxx Where xxx is any HTTP status code. */ goweb.Map("/status-code/{code}", func(c context.Context) error { // get the path value as an integer statusCodeInt, statusCodeIntErr := strconv.Atoi(c.PathValue("code")) if statusCodeIntErr != nil { return goweb.Respond.With(c, http.StatusInternalServerError, []byte("Failed to convert 'code' into a real status code number.")) } // respond with the status return goweb.Respond.WithStatusText(c, statusCodeInt) }) // /errortest should throw a system error and be handled by the // DefaultHttpHandler().ErrorHandler() Handler. goweb.Map("/errortest", func(c context.Context) error { return errors.New("This is a test error!") }) /* Map a RESTful controller (see the ThingsController for all the methods that will get mapped) */ thingsController := new(ThingsController) goweb.MapController(thingsController) /* Map a handler for if they hit just numbers using the goweb.RegexPath function. e.g. GET /2468 NOTE: The goweb.RegexPath is a MatcherFunc, and so comes _after_ the handler. */ goweb.Map(func(c context.Context) error { return goweb.API.RespondWithData(c, "Just a number!") }, goweb.RegexPath(`^[0-9]+$`)) /* Catch-all handler for everything that we don't understand */ goweb.Map(func(c context.Context) error { // just return a 404 message return goweb.API.Respond(c, 404, nil, []string{"File not found"}) }) }
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) }
// mapRoutes contains lots of examples of how to map things in // Goweb. It is in its own function so that test code can call it // without having to run main(). func mapRoutes() { goweb.MapBefore(func(c context.Context) error { c.HttpResponseWriter().Header().Set("X-Custom-Header", "WebGit") c.HttpResponseWriter().Header().Set("Connection", "keep-alive") return nil }) goweb.MapAfter(func(c context.Context) error { // TODO: log this return nil }) /* Map the homepage... */ goweb.Map("/", func(c context.Context) error { return goweb.Respond.With(c, 200, []byte("Welcome to the WebGit app - see the terminal for instructions.")) }) /* search git developers */ goweb.Map("GET", "gitsearch", func(c context.Context) error { if c.QueryParams().Has("q") { res, err := http.Get("https://api.github.com/search/users?q=" + c.QueryValue("q")) if err != nil { log.Fatal(err) return goweb.API.Respond(c, 200, fmt.Sprintf("Erro: %s", err), nil) } response, err := ioutil.ReadAll(res.Body) res.Body.Close() if err != nil { log.Fatal(err) return goweb.API.Respond(c, 200, fmt.Sprintf("Erro: %s", err), nil) } return goweb.API.Respond(c, 200, fmt.Sprintf("%s", response), nil) } else { return goweb.API.Respond(c, 200, "Pesquisa vazia", nil) } }) /* repo git developer */ goweb.Map("GET", "reposdeveloper", func(c context.Context) error { if c.QueryParams().Has("user") { res, err := http.Get("https://api.github.com/users/" + c.QueryValue("user") + "/repos") if err != nil { log.Fatal(err) return goweb.API.Respond(c, 200, fmt.Sprintf("Erro: %s", err), nil) } response, err := ioutil.ReadAll(res.Body) res.Body.Close() if err != nil { log.Fatal(err) return goweb.API.Respond(c, 200, fmt.Sprintf("Erro: %s", err), nil) } return goweb.API.Respond(c, 200, fmt.Sprintf("%s", response), nil) } else { return goweb.API.Respond(c, 200, "No user send", nil) } }) /* followers git developer */ goweb.Map("GET", "followersdevelopers", func(c context.Context) error { if c.QueryParams().Has("user") { res, err := http.Get("https://api.github.com/users/" + c.QueryValue("user") + "/followers") if err != nil { log.Fatal(err) return goweb.API.Respond(c, 200, fmt.Sprintf("Erro: %s", err), nil) } response, err := ioutil.ReadAll(res.Body) res.Body.Close() if err != nil { log.Fatal(err) return goweb.API.Respond(c, 200, fmt.Sprintf("Erro: %s", err), nil) } return goweb.API.Respond(c, 200, fmt.Sprintf("%s", response), nil) } else { return goweb.API.Respond(c, 200, "Pesquisa vazia", nil) } }) /* /status-code/xxx Where xxx is any HTTP status code. */ goweb.Map("/status-code/{code}", func(c context.Context) error { // get the path value as an integer statusCodeInt, statusCodeIntErr := strconv.Atoi(c.PathValue("code")) if statusCodeIntErr != nil { return goweb.Respond.With(c, http.StatusInternalServerError, []byte("Failed to convert 'code' into a real status code number.")) } // respond with the status return goweb.Respond.WithStatusText(c, statusCodeInt) }) // /errortest should throw a system error and be handled by the // DefaultHttpHandler().ErrorHandler() Handler. goweb.Map("/errortest", func(c context.Context) error { return errors.New("This is a test error!") }) /* Map a RESTful controller (see the DevelopersController for all the methods that will get mapped) */ developersController := new(DevelopersController) goweb.MapController(developersController) /* Map a handler for if they hit just numbers using the goweb.RegexPath function. e.g. GET /2468 NOTE: The goweb.RegexPath is a MatcherFunc, and so comes _after_ the handler. */ goweb.Map(func(c context.Context) error { return goweb.API.RespondWithData(c, "Just a number!") }, goweb.RegexPath(`^[0-9]+$`)) /* Map the static-files directory so it's exposed as /static */ goweb.MapStatic("/static", "static-files") /* Map the a favicon */ goweb.MapStaticFile("/favicon.ico", "static-files/favicon.ico") /* Catch-all handler for everything that we don't understand */ goweb.Map(func(c context.Context) error { // just return a 404 message return goweb.API.Respond(c, 404, nil, []string{"File not found"}) }) }
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 mapRoutes() { goweb.MapBefore(func(ctx context.Context) error { req := ctx.HttpRequest() host, _, _ := net.SplitHostPort(req.RemoteAddr) if host == "::1" { host = "localhost" } suffix := "" if _, ok := req.Header["Authorization"]; ok { suffix += " AUTH" } if l, has := req.Header["Content-Length"]; has { suffix += " Content-Length: " + l[0] } logger.Info("access", fmt.Sprintf("%s REQ RECEIVED \"%s %s%s\"", host, ctx.MethodString(), req.RequestURI, suffix)) return nil }) goweb.MapAfter(func(ctx context.Context) error { req := ctx.HttpRequest() host, _, _ := net.SplitHostPort(req.RemoteAddr) if host == "::1" { host = "localhost" } suffix := "" if _, ok := req.Header["Authorization"]; ok { suffix += " AUTH" } if l, has := req.Header["Content-Length"]; has { suffix += " Content-Length: " + l[0] } logger.Info("access", fmt.Sprintf("RESPONDED TO %s \"%s %s%s\"", host, ctx.MethodString(), req.RequestURI, suffix)) return nil }) goweb.Map("/preauth/{id}", func(ctx context.Context) error { pcon.PreAuthRequest(ctx) return nil }) goweb.Map("/node/{nid}/acl/{type}", func(ctx context.Context) error { acon.AclTypedRequest(ctx) return nil }) goweb.Map("/node/{nid}/acl/", func(ctx context.Context) error { acon.AclRequest(ctx) return nil }) goweb.Map("/node/{nid}/index/{idxType}", func(ctx context.Context) error { icon.IndexTypedRequest(ctx) return nil }) goweb.Map("/", func(ctx context.Context) error { host := util.ApiUrl(ctx) r := resource{ R: []string{"node"}, U: host + "/", D: host + "/documentation.html", C: conf.Conf["admin-email"], I: "Shock", T: "Shock", } return responder.WriteResponseObject(ctx, http.StatusOK, r) }) nodeController := new(ncon.NodeController) goweb.MapController(nodeController) goweb.MapStatic("/assets", conf.Conf["site-path"]+"/assets") goweb.MapStaticFile("/documentation.html", conf.Conf["site-path"]+"/pages/main.html") // Map the favicon //goweb.MapStaticFile("/favicon.ico", "static-files/favicon.ico") // Catch-all handler for everything that we don't understand goweb.Map(func(ctx context.Context) error { return responder.RespondWithError(ctx, http.StatusNotFound, "File not found") }) }