func main() {
boneSub := bone.New()
gorrilaSub := mux.NewRouter()
httprouterSub := httprouter.New()
boneSub.GetFunc("/test", func(rw http.ResponseWriter, req *http.Request) {
rw.Write([]byte("Hello from bone mux"))
})
gorrilaSub.HandleFunc("/test", func(rw http.ResponseWriter, req *http.Request) {
rw.Write([]byte("Hello from gorilla mux"))
})
httprouterSub.GET("/test", func(rw http.ResponseWriter, req *http.Request, _ httprouter.Params) {
rw.Write([]byte("Hello from httprouter mux"))
})
muxx := bone.New().Prefix("/api")
muxx.SubRoute("/bone", boneSub)
muxx.SubRoute("/gorilla", gorrilaSub)
muxx.SubRoute("/http", httprouterSub)
http.ListenAndServe(":8080", muxx)
}
func main() {
db, err := bolt.Open("proxy.db", 0600, nil)
if err != nil {
log.Fatal("Fatal: %s\n", err.Error())
}
defer db.Close()
adminServer := proxyAdminServer{db}
adminMux := bone.New()
adminMux.Get("/proxy", http.HandlerFunc(adminServer.GetProxies))
adminMux.Delete("/proxy/:id", http.HandlerFunc(adminServer.DeleteProxyIteraction))
adminMux.Post("/proxy", http.HandlerFunc(adminServer.NewProxyIteraction))
proxyServer := proxyServer{&http.Client{}, db}
mux := bone.New()
mux.Handle("/*", http.HandlerFunc(proxyServer.ProxyHandler))
go func(port string) {
log.Println("Starting admin server")
log.Fatal(http.ListenAndServe(port, adminMux))
}(":9080")
log.Println("Starting test proxy")
log.Fatal(http.ListenAndServe(":9090", mux))
}
func main() {
mux := bone.New()
mux.GetFunc("/ctx/:var", rootHandler)
http.ListenAndServe(":8080", mux)
}
// getBoneRouter returns mux for admin interface
func getBoneRouter(d DBClient) *bone.Mux {
mux := bone.New()
mux.Get("/records", http.HandlerFunc(d.AllRecordsHandler))
mux.Delete("/records", http.HandlerFunc(d.DeleteAllRecordsHandler))
mux.Post("/records", http.HandlerFunc(d.ImportRecordsHandler))
mux.Get("/count", http.HandlerFunc(d.RecordsCount))
mux.Get("/stats", http.HandlerFunc(d.StatsHandler))
mux.Get("/statsws", http.HandlerFunc(d.StatsWSHandler))
mux.Get("/state", http.HandlerFunc(d.CurrentStateHandler))
mux.Post("/state", http.HandlerFunc(d.StateHandler))
if d.Cfg.Development {
// since hoverfly is not started from cmd/hoverfly/hoverfly
// we have to target to that directory
log.Warn("Hoverfly is serving files from /static/dist instead of statik binary!")
mux.Handle("/*", http.FileServer(http.Dir("../../static/dist")))
} else {
// preparing static assets for embedded admin
statikFS, err := fs.New()
if err != nil {
log.WithFields(log.Fields{
"Error": err.Error(),
}).Error("Failed to load statikFS, admin UI might not work :(")
}
mux.Handle("/*", http.FileServer(statikFS))
}
return mux
}
// NewServer creates a server that will listen for requests over HTTP and interact with the RCON server specified
// non-/api prefixed routes are served from static files compiled into bindata_assetfs.go
func NewRestServer(c *ServerConfig) {
var err error
rcon_client, err = mcrcon.NewClient(c.RCON_address, c.RCON_port, c.RCON_password)
if err != nil {
panic(fmt.Errorf("Could not connect to RCON server at %s:%d. (Error was: %s)", c.RCON_address, c.RCON_port, err))
}
router := bone.New()
// Redirect static resources, and then handle the static resources (/gui/) routes with the static asset file
router.Handle("/", http.HandlerFunc(func(response http.ResponseWriter, request *http.Request) {
http.Redirect(response, request, "/gui/", 302)
}))
router.Get("/gui/", http.StripPrefix("/gui/", http.FileServer(&assetfs.AssetFS{Asset: Asset, AssetDir: AssetDir, Prefix: ""})))
// Define the API (JSON) routes
router.GetFunc("/api", apiRootHandler)
router.GetFunc("/api/users", usersRootHandler)
router.GetFunc("/api/users/:username", usernameHandler)
// TODO: Require a http basic auth username and password if passed in.
// Start the server
fmt.Println("Starting server on port", c.Port)
http.ListenAndServe(fmt.Sprintf(":%d", c.Port), router)
}
func main() {
db, err := sql.Open("postgres", "user=laptop dbname=estelle_test sslmode=disable")
if err != nil {
log.Fatal(err)
}
r := render.New(render.Options{
Directory: "views",
Extensions: []string{".html"},
})
mux := bone.New()
ServeResource := assets.ServeResource
mux.HandleFunc("/img/", ServeResource)
mux.HandleFunc("/css/", ServeResource)
mux.HandleFunc("/js/", ServeResource)
mux.HandleFunc("/pages", func(w http.ResponseWriter, req *http.Request) {
rows, err := db.Query("SELECT id, title FROM pages")
if err != nil {
log.Fatal(err)
}
defer rows.Close()
type yourtype struct {
Id int
Title string
}
s := []yourtype{}
for rows.Next() {
var t yourtype
if err := rows.Scan(&t.Id, &t.Title); err != nil {
log.Fatal(err)
}
fmt.Printf("%s", t.Title)
s = append(s, t)
}
r.HTML(w, http.StatusOK, "foofoo", s)
})
mux.HandleFunc("/bar", func(w http.ResponseWriter, req *http.Request) {
r.HTML(w, http.StatusOK, "bar", nil)
})
mux.HandleFunc("/home/:id", func(w http.ResponseWriter, req *http.Request) {
id := bone.GetValue(req, "id")
r.HTML(w, http.StatusOK, "index", id)
})
mux.HandleFunc("/foo", func(w http.ResponseWriter, req *http.Request) {
r.HTML(w, http.StatusOK, "foo", nil)
})
mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
r.HTML(w, http.StatusOK, "index", nil)
})
http.ListenAndServe(":8080", mux)
}
func main() {
mux := bone.New()
mux.GetFunc("/image/:rows", ImageHandler)
mux.GetFunc("/html/:rows", HtmlHandler)
http.ListenAndServe(":3000", mux)
}
func getBoneRouter(h HTTPClientHandler) *bone.Mux {
mux := bone.New()
mux.Get("/query", http.HandlerFunc(h.queryTwitter))
mux.Get("/", http.HandlerFunc(h.homeHandler))
// handling static files
mux.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.Dir("static"))))
return mux
}
func main() {
router := bone.New()
router.GetFunc("/", index)
router.GetFunc("/hello/:name", hello)
log.Println("Starting server on port 9090")
log.Fatal(http.ListenAndServe(":9090", router))
}
func main() {
// looking for option args when starting App
// like ./overeer -port=":3000" would start on port 3000
var port = flag.String("port", ":3000", "Server port")
var dbActions = flag.String("db", "", "Database actions - create, migrate, drop")
flag.Parse() // parse the flag
// init connection
db, err := gorm.Open("sqlite3", "gorm.db")
if err != nil {
log.WithFields(log.Fields{"error": err.Error()}).Fatal("Failed to open sqlite DB")
}
defer db.Close()
db.DB()
db.DB().Ping()
db.DB().SetMaxIdleConns(10)
db.DB().SetMaxOpenConns(100)
// flag to do something with the database
if *dbActions != "" {
log.WithFields(log.Fields{"action": dbActions}).Info("Database action initiated.")
d := DBActions{db: &db}
// create tables
if *dbActions == "create" {
d.createTables()
}
// drop tables
if *dbActions == "drop" {
d.dropTables()
}
return
}
r := render.New(render.Options{Layout: "layout"})
h := DBHandler{db: &db, r: r}
mux := bone.New()
mux.Get("/", http.HandlerFunc(homeHandler))
mux.Post("/stubos", http.HandlerFunc(h.stubosCreateHandler))
mux.Get("/stubos", http.HandlerFunc(h.stuboShowHandler))
mux.Delete("/stubos/:id", http.HandlerFunc(h.stuboDestroyHandler))
mux.Get("/stubos/:id", http.HandlerFunc(h.stuboDetailedHandler))
mux.Get("/stubos/:id/scenarios/:scenario", http.HandlerFunc(h.scenarioDetailedHandler))
mux.Get("/stubos/:id/scenarios/:scenario/stubs", http.HandlerFunc(h.scenarioStubsHandler))
// handling static files
mux.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.Dir("static"))))
n := negroni.Classic()
n.Use(negronilogrus.NewMiddleware())
n.UseHandler(mux)
log.WithFields(log.Fields{
"port": port,
}).Info("Overseer is starting")
n.Run(*port)
}
func init() {
mux := bone.New()
mux.PostFunc("/buy_request", BuyRequestHandler)
mux.GetFunc("/request/:key", RequestHandler)
mux.GetFunc("/delivery_status/:key", DeliveryHandler)
mux.PostFunc("/accept_request/:key", AcceptRequestHandler)
mux.PostFunc("/get_cl", GetCL)
http.Handle("/", mux)
}
func main() {
mux := bone.New()
mux.GetFunc("/", defaultHandler)
mux.GetFunc("/reg/#var^[a-z]$/#var2^[0-9]$", ShowVar)
mux.GetFunc("/test", defaultHandler)
mux.Get("/file/", http.StripPrefix("/file/", http.FileServer(http.Dir("assets"))))
http.ListenAndServe(":8080", mux)
}
func runServer() error {
mux := bone.New()
mux.HandleFunc("/", inputs)
mux.HandleFunc("/api/", serveArticle)
mux.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.Dir("static"))))
err := http.ListenAndServe(*listenAddr, httpLogger(mux))
return err
}
func init() {
mux := bone.New()
mux.GetFunc("/image/:rows", ImageHandler)
mux.GetFunc("/html/:rows", HtmlHandler)
mux.GetFunc("/", func(w http.ResponseWriter, r *http.Request) {
http.Redirect(w, r, "http://github.com/matthewdu/rule110-go", 301)
})
http.Handle("/", mux)
}
func getBoneRouter(h HTTPClientHandler) *bone.Mux {
mux := bone.New()
mux.Get("/1.1/search/tweets.json", http.HandlerFunc(h.tweetSearchEndpoint))
mux.Get("/admin", http.HandlerFunc(h.adminHandler))
mux.Post("/admin/state", http.HandlerFunc(h.stateHandler))
mux.Get("/admin/state", http.HandlerFunc(h.getStateHandler))
// handling static files
mux.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.Dir("static"))))
return mux
}
// getBoneRouter returns mux for admin interface
func (this *AdminApi) getBoneRouter(d *Hoverfly) *bone.Mux {
mux := bone.New()
authHandler := &handlers.AuthHandler{
d.Authentication,
d.Cfg.SecretKey,
d.Cfg.JWTExpirationDelta,
d.Cfg.AuthEnabled,
}
authHandler.RegisterRoutes(mux)
handlers := GetAllHandlers(d)
for _, handler := range handlers {
handler.RegisterRoutes(mux, authHandler)
}
if d.Cfg.Development {
// since hoverfly is not started from cmd/hoverfly/hoverfly
// we have to target to that directory
log.Warn("Hoverfly is serving files from /static/admin/dist instead of statik binary!")
mux.Handle("/js/*", http.StripPrefix("/js/", http.FileServer(http.Dir("../../static/admin/dist/js"))))
mux.HandleFunc("/*", func(w http.ResponseWriter, r *http.Request) {
http.ServeFile(w, r, "../../static/admin/dist/index.html")
})
} else {
// preparing static assets for embedded admin
statikFS, err := fs.New()
if err != nil {
log.WithFields(log.Fields{
"Error": err.Error(),
}).Error("Failed to load statikFS, admin UI might not work :(")
}
mux.Handle("/js/*", http.FileServer(statikFS))
mux.Handle("/app.32dc9945fd902da8ed2cccdc8703129f.css", http.FileServer(statikFS))
mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
file, err := statikFS.Open("/index.html")
if err != nil {
w.WriteHeader(500)
log.WithFields(log.Fields{
"error": err,
}).Error("got error while opening index file")
return
}
io.Copy(w, file)
w.WriteHeader(200)
})
}
return mux
}
// getBoneRouter returns mux for admin interface
func getBoneRouter(d DBClient) *bone.Mux {
mux := bone.New()
mux.Get("/records", http.HandlerFunc(d.AllRecordsHandler))
mux.Delete("/records", http.HandlerFunc(d.DeleteAllRecordsHandler))
mux.Post("/records", http.HandlerFunc(d.ImportRecordsHandler))
mux.Get("/state", http.HandlerFunc(d.CurrentStateHandler))
mux.Post("/state", http.HandlerFunc(d.stateHandler))
return mux
}
func NewHostBasedDispatcher(
cfg *config.Configuration,
log *logging.Logger,
prx *proxy.ProxyHandler,
) (Dispatcher, error) {
disp := new(hostBasedDispatcher)
disp.cfg = cfg
disp.log = log
disp.prx = prx
disp.mux = bone.New()
disp.handlers = make(map[string]handlerPair)
return disp, nil
}
func main() {
mux := bone.New()
mux.NotFoundFunc(func(rw http.ResponseWriter, req *http.Request) {
rw.WriteHeader(http.StatusTeapot)
})
mux.GetFunc("/", defaultHandler)
mux.GetFunc("/reg/#var^[a-z]$/#var2^[0-9]$", ShowVar)
mux.GetFunc("/test", defaultHandler)
mux.Get("/file/", http.StripPrefix("/file/", http.FileServer(http.Dir("assets"))))
http.ListenAndServe(":8080", mux)
}
func getRouter(h HandlerHTTPClient) *bone.Mux {
mux := bone.New()
mux.Post("/stubo/api/put/stub", http.HandlerFunc(h.putStubHandler))
mux.Post("/stubo/api/get/response", http.HandlerFunc(h.getStubResponseHandler))
mux.Get("/stubo/api/get/stublist", http.HandlerFunc(h.stublistHandler))
mux.Get("/stubo/api/delete/stubs", http.HandlerFunc(h.deleteStubsHandler))
mux.Get("/stubo/api/put/delay_policy", http.HandlerFunc(h.putDelayPolicyHandler))
mux.Get("/stubo/api/get/delay_policy", http.HandlerFunc(h.getDelayPolicyHandler))
mux.Get("/stubo/api/delete/delay_policy", http.HandlerFunc(h.deleteDelayPolicyHandler))
mux.Get("/stubo/api/begin/session", http.HandlerFunc(h.beginSessionHandler))
mux.Get("/stubo/api/end/sessions", http.HandlerFunc(h.endSessionsHandler))
mux.Get("/stubo/api/get/scenarios", http.HandlerFunc(h.getScenariosHandler))
return mux
}
func NewPathBasedDispatcher(
cfg *config.Configuration,
log *logging.Logger,
prx *proxy.ProxyHandler,
) (*pathBasedDispatcher, error) {
dispatcher := new(pathBasedDispatcher)
dispatcher.cfg = cfg
dispatcher.mux = bone.New()
dispatcher.log = log
dispatcher.prx = prx
dispatcher.behaviours = make([]DispatcherBehaviour, 0, 8)
return dispatcher, nil
}
func main() {
flagParse()
mux := bone.New()
mux.NotFound(func(w http.ResponseWriter, req *http.Request) {
w.Write([]byte("knick-knack paddywhack give a dog a bone, this old man is no longer home"))
})
go databaseDumper(workers)
mux.Get("/database/:name", http.HandlerFunc(dumpHandler))
log.Printf("Listening on %s\n", host)
log.Fatal(http.ListenAndServe(host, mux))
}
func main() {
runtime.GOMAXPROCS(runtime.NumCPU())
db := storage.NewRedis()
router := bone.New()
router.Post("/", http.HandlerFunc(handlers.CreateKey(db)))
router.Get("/:key", http.HandlerFunc(handlers.RedirectKey(db)))
router.Get("/get/:key", http.HandlerFunc(handlers.GetKey(db)))
port := os.Getenv("PORT")
if port == "" {
port = "8080"
}
log.Printf("Service started on port %s", port)
http.ListenAndServe(":"+port, router)
}
func main() {
if err := db.UseProd(); err != nil {
panic(err)
}
db.LogMode(true)
if err := setConfig(); err != nil {
panic(err)
}
mux := bone.New()
mux.GetFunc("/authorize", Auth)
mux.GetFunc("/auth_callback", Callback)
log.Printf("Start HTTP Server with port %d", config.Port)
http.ListenAndServe(fmt.Sprintf(":%d", config.Port), hlog.Wrap(mux.ServeHTTP))
}
func main() {
// New mux instance
mux := bone.New()
// Custom 404
mux.NotFound(Handler404)
// Handle with any http method, Handle takes http.Handler as argument.
mux.Handle("/index", http.HandlerFunc(homeHandler))
mux.Handle("/index/:var/info/:test", http.HandlerFunc(varHandler))
// Get, Post etc... takes http.HandlerFunc as argument.
mux.Post("/home", http.HandlerFunc(homeHandler))
mux.Get("/home/:var", http.HandlerFunc(varHandler))
mux.Get("/:any", http.HandlerFunc(homeHandler))
// Start Listening
log.Fatal(http.ListenAndServe(":8080", mux))
}
func main() {
c := xhandler.Chain{}
c.Use(recoverMiddleware)
c.Use(normalLoggingMiddleware)
c.Use(log15LoggingMiddleware)
c.Use(logrusLoggingMiddleware)
simpleHandler := xhandler.HandlerFuncC(simple)
accountHandler := xhandler.HandlerFuncC(account)
noteHandler := xhandler.HandlerFuncC(note)
mux := bone.New()
mux.Get("/account/:id", c.Handler(accountHandler))
mux.Get("/note/:id", c.Handler(noteHandler))
mux.Get("/simple", c.Handler(simpleHandler))
http.ListenAndServe(":8080", mux)
}
func loadBoneSingle(method, path string, handler http.Handler) http.Handler {
router := bone.New()
switch method {
case "GET":
router.Get(path, handler)
case "POST":
router.Post(path, handler)
case "PUT":
router.Put(path, handler)
case "PATCH":
router.Patch(path, handler)
case "DELETE":
router.Delete(path, handler)
default:
panic("Unknow HTTP method: " + method)
}
return router
}
// bone
func loadBone(routes []route) http.Handler {
router := bone.New()
for _, route := range routes {
switch route.method {
case "GET":
router.Get(route.path, http.HandlerFunc(httpHandlerFunc))
case "POST":
router.Post(route.path, http.HandlerFunc(httpHandlerFunc))
case "PUT":
router.Put(route.path, http.HandlerFunc(httpHandlerFunc))
case "PATCH":
router.Patch(route.path, http.HandlerFunc(httpHandlerFunc))
case "DELETE":
router.Delete(route.path, http.HandlerFunc(httpHandlerFunc))
default:
panic("Unknow HTTP method: " + route.method)
}
}
return router
}
func main() {
port := flag.String("port", "80", "-port [your port]")
flag.Parse()
mux := bone.New()
clw := claw.New(mw.Logger)
// GET Handler
mux.Get("/", clw.Use(handle.Handler))
mux.Get("/profil", clw.Use(handle.ProfilHandler))
mux.Get("/home", clw.Use(handle.HomeHandler))
mux.Get("/find", clw.Use(handle.FindHandler))
// POST Handler
mux.Post("/signin", clw.Use(handle.SignIn))
mux.Post("/logout", clw.Use(handle.LogOut))
mux.Post("/add", clw.Use(handle.AddUser))
mux.Post("/fish", clw.Use(handle.AddFish))
mux.Post("/delete", clw.Use(handle.DeleteFish))
// Ressources
mux.Handle("/public/", http.StripPrefix("/public/", http.FileServer(http.Dir("public"))))
// Start to serve
http.ListenAndServe(":"+*port, mux)
}
func main() {
muxx := bone.New()
clw := claw.New(mw.Logger)
// API ROUTE
muxx.Get("/api/:user", clw.Use(func(rw http.ResponseWriter, req *http.Request) {
}))
muxx.Post("/api/:user", clw.Use(func(rw http.ResponseWriter, req *http.Request) {
m := &Mail{}
err := json.NewDecoder(req.Body).Decode(m)
if err != nil {
json.NewEncoder(rw).Encode(err)
return
}
fmt.Printf("Sending mail to %s ...\n", m.To)
go m.Send()
}))
http.ListenAndServe(":8000", muxx)
}