func main() { e := echo.New() // the file server for rice. "app" is the folder where the files come from. assetHandler := http.FileServer(rice.MustFindBox("app").HTTPBox()) // serves the index.html from rice e.GET("/", standard.WrapHandler(assetHandler)) // servers other static files e.GET("/static/*", standard.WrapHandler(http.StripPrefix("/static/", assetHandler))) e.Run(standard.New(":3000")) }
func main() { // Parse command line arguments kingpin.Version("0.0.1") kingpin.Parse() // Prepare (optionally) embedded resources templateBox := rice.MustFindBox("template") staticHTTPBox := rice.MustFindBox("static").HTTPBox() staticServer := http.StripPrefix("/static/", http.FileServer(staticHTTPBox)) e := echo.New() t := &Template{ templates: template.Must(template.New("base").Parse(templateBox.MustString("base.html"))), } e.SetRenderer(t) e.Use(middleware.Logger()) e.Use(middleware.Recover()) e.GET("/static/*", standard.WrapHandler(staticServer)) edit := e.Group("/edit") edit.Get("/*", EditHandler) edit.Post("/*", EditHandlerPost) go WaitForServer() e.Run(standard.New(fmt.Sprintf("127.0.0.1:%d", *args.Port))) }
func main() { e := echo.New() e.SetDebug(true) // enable any filename to be loaded from in-memory file system e.GET("/*", standard.WrapHandler(myEmbeddedFiles.Handler)) // read ufo.html from in-memory file system htmlb, err := myEmbeddedFiles.ReadFile("ufo.html") if err != nil { log.Fatal(err) } // convert to string html := string(htmlb) // serve ufo.html through "/" e.GET("/", func(c echo.Context) error { // serve it return c.HTML(http.StatusOK, html) }) // try it -> http://localhost:1337/ // http://localhost:1337/ufo.html // http://localhost:1337/public/README.md open.Run("http://localhost:1337/") e.Run(standard.New(":1337")) }
func (ceh *customEchoHandler) mustWrapHandleFunc(c echo.Context) echo.HandlerFunc { if _, ok := c.Request().(*standard.Request); ok { return standard.WrapHandler(ceh.httpHandler) } else if _, ok = c.Request().(*fasthttp.Request); ok { return NewFastHTTPEchoAdaptor(ceh.httpHandler) } log.Fatal("Unknown HTTP implementation") return nil }
func client() echo.HandlerFunc { clientFS := http.FileServer( &assetfs.AssetFS{ Asset: Asset, AssetDir: AssetDir, AssetInfo: AssetInfo, Prefix: "client", }, ) return standard.WrapHandler(clientFS) }
// NewServer creates a new server. func NewServer(conf ServerConfig) (*standard.Server, error) { if conf.RootPassword == "" { return nil, errors.New("missing root username") } if conf.RootPassword == "" { return nil, errors.New("missing root password") } if conf.Store == nil { return nil, errors.New("missing store") } if conf.Notifier == nil { conf.Notifier = notifier.NewNOOPNotifier() } e := echo.New() basicAuthMiddleware := AuthMiddleware(conf.RootUsername, conf.RootPassword, conf.Store) e.Use(TraceMiddleware()) e.Use(LogMiddleware()) e.Use(InstrumentMiddleware(conf.Stats)) e.Use(middleware.Recover()) features := NewFeatureResource(conf.Store, conf.Stats, conf.Notifier) environments := NewEnvironmentResource(conf.Store, conf.Stats) users := NewUserResource(conf.Store, conf.Stats) e.Get("/api/health", standard.WrapHandler(healthz.Handler())) e.Get("/api/features/:name", features.Get, basicAuthMiddleware) e.Get("/api/features", features.List, basicAuthMiddleware) e.Post("/api/features", features.Create, basicAuthMiddleware) e.Patch("/api/features/:name", features.Update, basicAuthMiddleware) e.Get("/api/environments/:name", environments.Get, basicAuthMiddleware) e.Get("/api/environments", environments.List, basicAuthMiddleware) e.Post("/api/environments", environments.Create, basicAuthMiddleware) e.Patch("/api/environments/:name", environments.Update, basicAuthMiddleware) e.Get("/api/users/:username", users.Get, basicAuthMiddleware) e.Post("/api/users", users.Create, basicAuthMiddleware) e.Static("/static", "public") e.File("/*", "public/index.html") server := standard.WithConfig(engine.Config{}) server.SetHandler(e) return server, nil }
func (this *WebsocketController) RegisterRoute(g *echo.Group) { g.GET("/ws", standard.WrapHandler(websocket.Handler(this.Ws))) }
func InitializeWebsocket(e *echo.Echo) error { e.GET("/ws/:name", standard.WrapHandler(http.HandlerFunc(ws()))) return nil }
func main() { e := echo.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() { e := echo.New() e.Use(middleware.Logger()) e.Use(middleware.Recover()) e.Use(middleware.Static("public")) handler := Handler{"Hoł hoł"} e.GET("/ws", standard.WrapHandler(websocket.Handler(handler.WS))) e.Run(standard.New(":1323")) }