func main() {
// Host map
hosts := make(Hosts)
//-----
// API
//-----
api := vodka.New()
api.Use(mw.Logger())
api.Use(mw.Recover())
hosts["api.localhost:1323"] = api
api.Get("/", func(c *vodka.Context) error {
return c.String(http.StatusOK, "API")
})
//------
// Blog
//------
blog := vodka.New()
blog.Use(mw.Logger())
blog.Use(mw.Recover())
hosts["blog.localhost:1323"] = blog
blog.Get("/", func(c *vodka.Context) error {
return c.String(http.StatusOK, "Blog")
})
//---------
// Website
//---------
site := vodka.New()
site.Use(mw.Logger())
site.Use(mw.Recover())
hosts["localhost:1323"] = site
site.Get("/", func(c *vodka.Context) error {
return c.String(http.StatusOK, "Welcome!")
})
http.ListenAndServe(":1323", hosts)
}
func main() {
e := vodka.New()
e.Use(mw.Logger())
e.Use(mw.Recover())
e.Static("/", "public")
e.WebSocket("/ws", func(c *vodka.Context) (err error) {
ws := c.Socket()
msg := ""
for {
if err = websocket.Message.Send(ws, "Hello, Client!"); err != nil {
return
}
if err = websocket.Message.Receive(ws, &msg); err != nil {
return
}
fmt.Println(msg)
}
return
})
e.Run(":1323")
}
func main() {
// Echo instance
e := vodka.New()
// Debug mode
e.Debug()
//------------
// Middleware
//------------
// Logger
e.Use(mw.Logger())
// Recover
e.Use(mw.Recover())
// Basic auth
e.Use(mw.BasicAuth(func(usr, pwd string) bool {
if usr == "joe" && pwd == "secret" {
return true
}
return false
}))
// Gzip
e.Use(mw.Gzip())
// Routes
e.Get("/", hello)
// Start server
e.Run(":1323")
}
func main() {
e := vodka.New()
// Middleware
e.Use(middleware.Logger())
e.Use(middleware.Recover())
// Login route
e.POST("/login", login)
// Unauthenticated route
e.GET("/", accessible)
// Restricted group
r := e.Group("/restricted")
// Configure middleware with the custom claims type
config := middleware.JWTConfig{
Claims: &jwtCustomClaims{},
SigningKey: []byte("secret"),
}
r.Use(middleware.JWTWithConfig(config))
r.GET("", restricted)
e.Run(standard.New(":1323"))
}
func main() {
e := vodka.New()
e.Use(middleware.Logger())
e.Use(middleware.Recover())
e.Use(middleware.Static("../public"))
e.GET("/ws", standard.WrapHandler(http.HandlerFunc(hello())))
e.Run(standard.New(":1323"))
}
func main() {
v := vodka.New()
v.Use(m.Logger())
v.Use(m.Recover())
v.Use(m.Gzip())
v.GET("/", HelloHandler)
v.Run(fasthttp.New(":1987"))
}
func main() {
e := vodka.New()
e.Use(mw.Logger())
e.Use(mw.Recover())
e.Static("/", "public")
e.Post("/upload", upload)
e.Run(":1323")
}
func main() {
e := vodka.New()
e.Use(middleware.Logger())
e.Use(middleware.Recover())
e.Use(middleware.Static("public"))
e.POST("/upload", upload)
e.Run(standard.New(":1323"))
}
func createMux() *vodka.Vodka {
e := vodka.New()
e.Use(middleware.Recover())
e.Use(middleware.Logger())
e.Use(middleware.Gzip())
e.Use(middleware.Static("public"))
return e
}
func main() {
// Echo instance
e := vodka.New()
// Middleware
e.Use(mw.Logger())
e.Use(mw.Recover())
// Routes
e.Get("/", hello)
// Start server
e.Run(":1323")
}
func main() {
e := vodka.New()
// Middleware
e.Use(middleware.Logger())
e.Use(middleware.Recover())
// Routes
e.POST("/users", createUser)
e.GET("/users/:id", getUser)
e.PUT("/users/:id", updateUser)
e.DELETE("/users/:id", deleteUser)
// Start server
e.Run(standard.New(":1323"))
}
func main() {
// Vodka instance
e := vodka.New()
// Middleware
e.Use(middleware.Logger())
e.Use(middleware.Recover())
// Route => handler
e.GET("/", func(c vodka.Context) error {
return c.String(http.StatusOK, "Hello, World!\n")
})
// Start server
e.Run(standard.New(":1323"))
}
func main() {
e := vodka.New()
// Middleware
e.Use(mw.Logger())
e.Use(mw.Recover())
// Routes
e.Post("/users", createUser)
e.Get("/users/:id", getUser)
e.Patch("/users/:id", updateUser)
e.Delete("/users/:id", deleteUser)
// Start server
e.Run(":1323")
}
func main() {
e := vodka.New()
// Middleware
e.Use(middleware.Logger())
e.Use(middleware.Recover())
// Login route
e.POST("/login", login)
// Unauthenticated route
e.GET("/", accessible)
// Restricted group
r := e.Group("/restricted")
r.Use(middleware.JWT([]byte("secret")))
r.GET("", restricted)
e.Run(standard.New(":1323"))
}
func main() {
e := vodka.New()
e.Use(middleware.Logger())
e.Use(middleware.Recover())
// CORS default
// Allows requests from any origin wth GET, HEAD, PUT, POST or DELETE method.
// e.Use(middleware.CORS())
// CORS restricted
// Allows requests from any `https://insionng.com` or `https://insionng.net` origin
// wth GET, PUT, POST or DELETE method.
e.Use(middleware.CORSWithConfig(middleware.CORSConfig{
AllowOrigins: []string{"https://insionng.com", "https://insionng.net"},
AllowMethods: []string{vodka.GET, vodka.PUT, vodka.POST, vodka.DELETE},
}))
e.GET("/api/users", getUsers)
e.Run(standard.New(":1323"))
}
func main() {
v := vodka.New()
v.Use(middleware.Logger())
v.Use(middleware.Recover())
r := pongor.Renderor()
v.SetRenderer(r)
v.Static("/static", "static")
v.Get("/", func(ctx vodka.Context) error {
var data = make(map[string]interface{})
data["name"] = "Insion Ng"
ctx.SetStore(data)
ctx.SetStore(map[string]interface{}{
"title": "你好，世界",
"oh": "no",
})
ctx.Set("oh", "yes") //覆盖前面指定KEY
return ctx.Render(200, "index")
})
v.Run(fasthttp.New(":9000"))
}
func main() {
e := vodka.New()
e.Use(middleware.Logger())
e.Use(middleware.Recover())
e.Use(middleware.Static("public"))
// JSONP
e.GET("/jsonp", func(c vodka.Context) error {
callback := c.QueryParam("callback")
var content struct {
Response string `json:"response"`
Timestamp time.Time `json:"timestamp"`
Random int `json:"random"`
}
content.Response = "Sent via JSONP"
content.Timestamp = time.Now().UTC()
content.Random = rand.Intn(1000)
return c.JSONP(http.StatusOK, callback, &content)
})
// Start server
e.Run(standard.New(":1323"))
}
func main() {
// Hosts
hosts := make(map[string]*Host)
//-----
// API
//-----
api := vodka.New()
api.Use(middleware.Logger())
api.Use(middleware.Recover())
hosts["api.localhost:1323"] = &Host{api}
api.GET("/", func(c vodka.Context) error {
return c.String(http.StatusOK, "API")
})
//------
// Blog
//------
blog := vodka.New()
blog.Use(middleware.Logger())
blog.Use(middleware.Recover())
hosts["blog.localhost:1323"] = &Host{blog}
blog.GET("/", func(c vodka.Context) error {
return c.String(http.StatusOK, "Blog")
})
//---------
// Website
//---------
site := vodka.New()
site.Use(middleware.Logger())
site.Use(middleware.Recover())
hosts["localhost:1323"] = &Host{site}
site.GET("/", func(c vodka.Context) error {
return c.String(http.StatusOK, "Website")
})
// Server
e := vodka.New()
e.Any("/*", func(c vodka.Context) (err error) {
req := c.Request()
res := c.Response()
host := hosts[req.Host()]
if host == nil {
err = vodka.ErrNotFound
} else {
host.Vodka.ServeHTTP(req, res)
}
return
})
e.Run(standard.New(":1323"))
}
func main() {
v := vodka.New()
store := sessions.NewCookieStore()
v.Use(sessions.Sessions("vodka", store))
v.Use(m.Logger())
v.Use(m.Recover())
v.Use(m.Gzip())
v.Static("/static/", "static")
v.Favicon("static/ico/favicon.ico")
v.SetRenderer(pongor.Renderor())
g := v.Group("")
g.Get("/", handler.MainHandler)
g.Get("/signup/", handler.SignupGetHandler)
g.Post("/signup/", handler.SignupPostHandler)
g.Get("/signin/", handler.SigninGetHandler)
g.Post("/signin/", handler.SigninPostHandler)
g.Get("/signout/", handler.SignoutHandler)
g.Any("/search/", handler.SearchHandler)
g.Get("/node/:nid/", handler.NodeHandler)
g.Get("/view/:tid/", handler.ViewHandler)
g.Get("/category/:cid/", handler.MainHandler)
// Restricted group
r := v.Group("")
jwt.JWTContextKey = key
jwt.Bearer = "Zenpress"
r.Use(jwt.JWTAuther(jwt.Options{
KeyFunc: func(ctx *vodka.Context) (string, error) {
return jwt.JWTContextKey, nil
},
}))
r.Get("/new/category/", handler.NewCategoryGetHandler)
r.Post("/new/category/", handler.NewCategoryPostHandler)
r.Get("/new/node/", handler.NewNodeGetHandler)
r.Post("/new/node/", handler.NewNodePostHandler)
r.Get("/new/topic/", handler.NewTopicGetHandler)
r.Post("/new/topic/", handler.NewTopicPostHandler)
r.Post("/new/reply/:tid/", handler.NewReplyPostHandler)
r.Get("/modify/category/", handler.ModifyCatGetHandler)
r.Post("/modify/category/", handler.ModifyCatPostHandler)
r.Get("/modify/node/", handler.ModifyNodeGetHandler)
r.Post("/modify/node/", handler.ModifyNodePostHandler)
r.Any("/topic/delete/:tid/", handler.TopicDeleteHandler)
r.Get("/topic/edit/:tid/", handler.TopicEditGetHandler)
r.Post("/topic/edit/:tid/", handler.TopicEditPostHandler)
r.Any("/node/delete/:nid/", handler.NodeDeleteHandler)
r.Get("/node/edit/:nid/", handler.NodeEditGetHandler)
r.Post("/node/edit/:nid/", handler.NodeEditPostHandler)
r.Any("/delete/reply/:rid/", handler.DeleteReplyHandler)
//hotness
r.Any("/like/:name/:id/", handler.LikeHandler)
r.Any("/hate/:name/:id/", handler.HateHandler)
// e.g. /debug/pprof, /debug/pprof/heap, etc.
vodkapprof.Wrapper(v)
v.Run(9000)
}
func main() {
e := vodka.New()
// Middleware
e.Use(mw.Logger())
e.Use(mw.Recover())
e.Use(mw.Gzip())
//------------------------
// Third-party middleware
//------------------------
// https://github.com/rs/cors
e.Use(cors.Default().Handler)
// https://github.com/thoas/stats
s := stats.New()
e.Use(s.Handler)
// Route
e.Get("/stats", func(c *vodka.Context) error {
return c.JSON(http.StatusOK, s.Data())
})
// Serve index file
e.Index("public/index.html")
// Serve favicon
e.Favicon("public/favicon.ico")
// Serve static files
e.Static("/scripts", "public/scripts")
//--------
// Routes
//--------
e.Post("/users", createUser)
e.Get("/users", getUsers)
e.Get("/users/:id", getUser)
//-----------
// Templates
//-----------
t := &Template{
// Cached templates
templates: template.Must(template.ParseFiles("public/views/welcome.html")),
}
e.SetRenderer(t)
e.Get("/welcome", welcome)
//-------
// Group
//-------
// Group with parent middleware
a := e.Group("/admin")
a.Use(func(c *vodka.Context) error {
// Security middleware
return nil
})
a.Get("", func(c *vodka.Context) error {
return c.String(http.StatusOK, "Welcome admin!")
})
// Group with no parent middleware
g := e.Group("/files", func(c *vodka.Context) error {
// Security middleware
return nil
})
g.Get("", func(c *vodka.Context) error {
return c.String(http.StatusOK, "Your files!")
})
// Start server
e.Run(":1323")
}