func (b *Broker) Run() {
b.running = true
b.RegisterMiddleware()
b.RegisterURL()
go b.HandleFailTask()
graceful.ListenAndServe(b.web.Server(b.addr), 5*time.Second)
}
func main() {
// inti config and component
componentInit()
// Echo instance
e := echo.New()
// Middleware
e.Use(mw.Logger())
e.Use(mw.Recover())
// e.Use(handler.CrossDomain)
// Routes
e.Get("/hello", handler.Hello)
e.Get("/api/v1/seckill", handler.Tickets)
e.Get("/api/v1/reset", handler.Reset)
// go cache.StartUpdateEventStatus()
// go kafka.StartKafkaProducer()
// Start server
port := viper.GetString("port")
log.Println("server port: ", port)
graceful.ListenAndServe(e.Server(port), 1*time.Second)
}
func main() {
port := "8080"
e := echo.New()
e.SetDebug(true)
e.Use(mw.Logger())
e.Use(mw.Recover())
e.StripTrailingSlash()
assetHandler := http.FileServer(assetFS())
e.Get("/clicks", buttonsStateHandler)
e.Post("/click/:button", buttonClicker)
e.WebSocket("/ws", socketHandler)
e.Get("/*", func(c *echo.Context) error {
assetHandler.ServeHTTP(c.Response().Writer(), c.Request())
return nil
})
// Start the "message hub"
go hub.Run()
// Detect clicks on buttons
btns = newButtons()
defer btns.Close()
btns.Run()
// Control the leds based on clicks
newLeds(btns, hub)
// Start server
log.Println("Starting server on port " + port)
graceful.ListenAndServe(e.Server(":"+port), 2*time.Second)
}
func main() {
cfg := readConfig()
jwtKey := []byte(cfg.JwtKey)
mongoSession := createMongoSession()
defer mongoSession.Close()
db := mongoSession.DB(cfg.Database)
userCollection := db.C(collections.UserCollectionName)
e := echo.New()
e.Get("/ping", func(c echo.Context) error {
return c.String(http.StatusOK, "pong")
})
restService := rest.NewService(db)
restGroup := e.Group("/collection")
restGroup.Get("/:collection", restService.Get)
restGroup.Post("/:collection", restService.Post)
restGroup.Put("/:collection", restService.Put)
restGroup.Delete("/:collection", restService.Delete)
userService := user.NewService(userCollection, jwtKey)
userGroup := e.Group("/user")
userGroup.Post("/signup", userService.Signup)
userGroup.Post("/confirm", userService.ConfirmSignup)
userGroup.Post("/signin", userService.Signin)
userGroup.Post("/forgot-password", userService.ForgotPassword)
userGroup.Post("/reset-password", userService.ResetPassword)
sessionService := session.NewService(userCollection, jwtKey)
sessionMiddleware := middleware.CreateSessionMiddleware(userCollection, jwtKey)
sessionGroup := e.Group("/session", sessionMiddleware)
sessionGroup.Post("/signout", sessionService.Signout)
sessionGroup.Post("/change-password", sessionService.ChangePassword)
sessionGroup.Post("/change-email", sessionService.ChangeEmail)
sessionGroup.Post("/set-profile", sessionService.SetProfile)
adminService := admin.NewService(userCollection, jwtKey)
adminSessionMiddleware := middleware.CreateAdminSessionMiddleware(userCollection, jwtKey)
adminGroup := e.Group("/admin", adminSessionMiddleware)
adminGroup.Get("/get-users", adminService.GetUsers)
adminGroup.Post("/create-user", adminService.CreateUser)
adminGroup.Post("/change-user-password", adminService.ChangeUserPassword)
adminGroup.Post("/change-user-email", adminService.ChangeUserEmail)
adminGroup.Post("/set-user-roles", adminService.SetUserRoles)
adminGroup.Post("/set-user-profile", adminService.SetUserProfile)
adminGroup.Delete("/remove-users", adminService.RemoveUsers)
adminGroup.Post("/signout-users", adminService.SignoutUsers)
adminGroup.Post("/suspend-users", adminService.SuspendUsers)
adminGroup.Post("/unsuspend-users", adminService.UnsuspendUsers)
adminGroup.Delete("/remove-unconfirmed-users", adminService.RemoveUnconfirmedUsers)
adminGroup.Post("/remove-expired-reset-keys", adminService.RemoveExpiredResetKeys)
fmt.Println("Listening at http://localhost:5025")
std := standard.New(":5025")
std.SetHandler(e)
graceful.ListenAndServe(std.Server, 5*time.Second)
}
func main() {
// ---------------------------
// Setting Active Environment
// ---------------------------
if len(os.Args) > 1 {
err := environment.Set(os.Args[1])
if err != nil {
log.Fatal(err)
}
} else {
log.Fatal("Running requires an environment argument")
}
// ---------
// Database
// ---------
db.Open()
defer db.Close()
// -----
// Echo
// -----
e := request.BuildEcho()
// ----
// Run
// ----
port := environment.GetEnvVar(environment.PORT)
log.Println("Server started on :" + port)
graceful.ListenAndServe(e.Server(":"+port), 5*time.Second) // Graceful shutdown
}
func (s *ApiServer) Run() error {
s.RegisterMiddleware()
s.RegisterURL()
std := standard.New(s.webAddr)
std.SetHandler(s)
graceful.ListenAndServe(std.Server, 5*time.Second)
return nil
}
func main() {
// Setup
e := echo.New()
e.Get("/", func(c *echo.Context) error {
return c.String(http.StatusOK, "Sue sews rose on slow jor crows nose")
})
graceful.ListenAndServe(e.Server(":1323"), 5*time.Second)
}
func main() {
e := echo.New()
e.Use(mw.Logger())
e.Use(mw.Recover())
e.Post("/auth/register", controllers.AuthRegister)
graceful.ListenAndServe(e.Server(":9000"), 10*time.Second)
}
func main() {
// Setup
e := echo.New()
e.GET("/", func(c echo.Context) error {
return c.String(http.StatusOK, "Sue sews rose on slow joe crows nose")
})
std := standard.New(":1323")
std.SetHandler(e)
graceful.ListenAndServe(std.Server, 5*time.Second)
}
func main() {
// Setup
e := echo.New()
e.Get("/", func(c *echo.Context) error {
c.String(http.StatusOK, "Sue sews rose on slow jor crows nose")
return nil
})
// Use github.com/tylerb/graceful
graceful.ListenAndServe(e.Server(":1323"), 5*time.Second)
}
// main runs the jumphash program.
// There are two optional arguments, addr and seconds.
func main() {
var addr = flag.String("address", "127.0.0.1:8080", "tcp address to listen on")
var seconds = flag.Int("sleep", 5, "time in seconds to sleep each POST request")
flag.Parse()
e := echo.New()
e.Use(middleware.Logger())
e.Use(server.Shutdown())
e.Use(server.Sleep(*seconds))
e.Post("/", server.Hash)
log.Printf("listening on %s", *addr)
graceful.ListenAndServe(e.Server(*addr), 0)
}
func main() {
// Echo instance
e := echo.New()
// Middleware
e.Use(middleware.Logger())
e.Use(middleware.Recover())
// Routes
e.Get("/", hello)
// Start server
port := "8080"
std := standard.New(":" + port)
std.SetHandler(e)
log.Printf("Starting app on port %+v\n", port)
graceful.ListenAndServe(std.Server, 1*time.Second)
}
func (suite *ApiTestSuite) SetupTest() {
// Loading .env file. We're not failing here in the
// event that the .env file can't be loaded. The
// project might be running through a CI system
// and the environment variables. Will fail later
// rather than early
environment.SetWithRelativeDirectory("../", environment.TESTING)
// Starting database
db.Open()
// Getting our Echo instance
e := BuildEcho()
// Running the server
port := environment.GetEnvVar(environment.PORT)
suite.wreckerClient = wrecker.New("http://localhost:" + port)
log.Println("Server started on :" + port)
go graceful.ListenAndServe(e.Server(":"+port), 5*time.Second) // Graceful shutdown
}
func main() {
e := echo.New()
// Enable colored log
e.ColoredLog(true)
// Middleware
e.Use(mw.Logger())
e.Use(mw.Recover())
e.Use(mw.Gzip())
// https://github.com/thoas/stats
s := stats.New()
e.Use(s.Handler)
// Route
e.Get("/stats", func(c *echo.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")
//-----------
// Templates
//-----------
e.SetRenderer(controllers.CreateRenderer())
e.Get("/page1", controllers.Page1Handler)
e.Get("/page2", controllers.Page2Handler)
// Start server
log.Println("Server is starting for port 8080...")
graceful.ListenAndServe(e.Server(":8080"), 2*time.Second)
log.Println("Server stoped")
}
func main() {
rand.Seed(time.Now().UnixNano())
fmt.Println("Running...")
ctx = new(req.Context)
l := new(store.Leveldb)
l.SetBloomFilter(13)
ctx.Store = l
ctx.Store.Init("leveldb", "test")
e := echo.New()
e.SetDebug(true)
e.Use(mw.Recover())
e.Static("/assets/", "public/assets")
e.Get("/webms/:name", func(c *echo.Context) error {
resp := c.Response()
name := c.Param("name")
resp.Header().Add("Content-Type", "video/webm")
http.ServeFile(resp, c.Request(), "webms/"+name)
return nil
})
e.Static("/webms/", "webms")
//e.ServeFile("/", "public/index.html")
e.Get("/", func(c *echo.Context) error {
http.ServeFile(c.Response(), c.Request(), "public/index.html")
return nil
})
e.ServeFile("/upload", "public/upload.html")
e.Post("/upload", func(c *echo.Context) error {
req := c.Request()
name := req.FormValue("name")
ttags := req.FormValue("tags")
tags := strings.Split(ttags, " ")
path := x.UniqueString(10)
// Read files
file := req.MultipartForm.File["file"]
src, err := file[0].Open()
if err != nil {
return err
}
defer src.Close()
// Destination file
dst, err := os.Create("webms/" + path + ".webm")
if err != nil {
return err
}
defer dst.Close()
if _, err = io.Copy(dst, src); err != nil {
return err
}
if err = api.Get("WebmCont", rootid).SetSource(rootid).AddChild("Webm").Set("path", path).
Set("tags", tags).Set("name", name).Execute(ctx); err != nil {
return err
}
return c.String(http.StatusOK, "eyo uploaded file")
})
e.Get("/webm", func(c *echo.Context) error {
result, err := api.NewQuery("WebmCont", rootid).Collect("Webm").Run(ctx)
if err != nil {
return err
}
by, err := result.ToJson()
if err != nil {
return err
}
return c.String(200, string(by))
})
e.Get("/webm/filter/:filter", func(c *echo.Context) error {
tags := strings.Split(c.Param("filter"), "+")
result, err := api.NewQuery("WebmCont", rootid).Collect("Webm").Run(ctx)
if err != nil {
return err
}
by, err := filter(result, tags...)
if err != nil {
return err
}
return c.String(200, string(by))
})
e.Get("/webm/:id", func(c *echo.Context) error {
result, err := api.NewQuery("Webm", c.Param("id")).Run(ctx)
if err != nil {
return err
}
by, err := result.ToJson()
if err != nil {
return err
}
return c.String(200, string(by))
})
e.Get("/webm/:id/tag/:tag", func(c *echo.Context) error {
result, err := api.NewQuery("Webm", c.Param("id")).Run(ctx)
if err != nil {
return err
}
var tags []interface{}
tagb, ok := result.Columns["tags"].Value.([]interface{})
if ok {
tags = tagb
}
cont := contains(tags, c.Param("tag"))
var atags []string
var resp string
if cont {
resp = "removed"
atags = convertButLeave(tags, c.Param("tag"))
} else {
resp = "added"
atags = convert(tags)
atags = append(atags, c.Param("tag"))
}
err = api.Get("Webm", c.Param("id")).SetSource(rootid).Set("tags", atags).Execute(ctx)
if err != nil {
return err
}
return c.String(200, resp)
})
graceful.ListenAndServe(e.Server(":8080"), 5*time.Second)
}
func (s *Server) Run() {
s.registerGlobalMiddlewares()
controller.RegisterURLs(s.web)
fmt.Printf("runing on %s\n", s.httpAddr)
graceful.ListenAndServe(s.web.Server(s.httpAddr), 5*time.Second)
}
func main() {
var port string
if port = os.Getenv("VCAP_APP_PORT"); len(port) == 0 {
port = DEFAULT_PORT
}
var host string
if host = os.Getenv("VCAP_APP_HOST"); len(host) == 0 {
host = DEFAULT_HOST
}
// prepare folder for DB with sample data
dir := "./.fakedata-db"
os.RemoveAll(dir)
defer os.RemoveAll(dir)
var tiedot *db.DB
var err error
// init sample data
if tiedot, err = db.OpenDB(dir); err != nil {
log.Panic(err)
}
defer tiedot.Close()
// init sample data
if err = fakedata.AddData(tiedot); err != nil {
log.Panic(err)
}
// init persistence stores
rest.SetProductStore(data.GetProductStore(tiedot))
// Echo instance
e := echo.New()
// Static test web pages
e.Static("/", "website")
e.Index("website/index.html")
// Customization
e.SetDebug(true)
// Middleware
e.Use(mw.Logger())
e.Use(mw.Recover())
// Routes
routes(e)
s := e.Server(host + ":" + port)
// HTTP2 is currently enabled by default in echo.New(). To override TLS handshake errors
// you will need to override the TLSConfig for the server so it does not attempt to validate
// the connection using TLS as required by HTTP2
s.TLSConfig = nil
// Start server
log.Printf("Starting app on %+v:%+v\n", host, port)
graceful.ListenAndServe(s, 5*time.Second)
}
func main() {
routes := NewRoutes()
graceful.ListenAndServe(routes.Server(":60000"), 5*time.Second)
}
func gracefulRun(std *standard.Server) {
log.Fatal(graceful.ListenAndServe(std.Server, 5*time.Second))
}
func main() {
e := echo.New()
e.Use(func(next echo.HandlerFunc) echo.HandlerFunc {
return func(c *echo.Context) error {
start := time.Now()
entry := log.WithFields(log.Fields{
"uuid": uuid4(),
"path": c.Request().RequestURI,
"method": c.Request().Method,
"ip": c.Request().RemoteAddr,
})
if reqID := c.Request().Header.Get("X-Request-Id"); reqID != "" {
entry = entry.WithField("request_id", reqID)
}
entry.Info("started handling request")
if err := next(c); err != nil {
c.Error(err)
}
latency := time.Since(start)
entry.WithFields(log.Fields{
"status": c.Response().Status(),
"text_status": http.StatusText(c.Response().Status()),
"took": latency,
fmt.Sprintf("measure#%s.latency", "web"): latency.Nanoseconds(),
}).Info("completed handling request")
return nil
}
})
e.Use(mw.Recover())
startTime := time.Now()
if time.Since(startTime).Minutes() >= 3 {
// finish game
}
e.Static("/", "public")
e.WebSocket("/ws", func(c *echo.Context) (err error) {
ws := c.Socket()
if err = websocket.Message.Send(ws, "Please Login"); err != nil {
return err
}
msg := ""
for {
// if err = websocket.Message.Send(ws, "Hello, Client!"); err != nil {
// return err
// }
if err = websocket.Message.Receive(ws, &msg); err != nil {
if err == io.EOF {
return nil
}
}
if strings.Contains(msg, "login") {
// split get tokenString
// checkToken(tokenString)
// if valid {
// login
// } else {
// return
// }
} else if strings.Contains(msg, "join_game") {
} else if strings.Contains(msg, "leave_game") {
}
log.Info(msg)
}
ws.Close()
return nil
})
log.Info("Starting websocket server at localhost:4000")
graceful.ListenAndServe(e.Server(":4000"), 3*time.Minute)
}
func main() {
// Echo instance
e := echo.New()
// Middleware echo
e.Use(middleware.Logger())
logg := e.Logger()
e.Use(middleware.Recover())
e.Use(middleware.Gzip())
e.Use(middleware.Secure())
e.Use(middleware.CORS())
e.Use(middleware.BodyLimit("200M"))
// gopkg.in/mgo.v2
db := midd.NewMgo(viper.GetString("db.url"), viper.GetString("db.name"))
defer db.Session.Close()
e.Use(midd.Mgo(db))
// github.com/thoas/stats
middStat := stats.New()
e.Use(standard.WrapMiddleware(middStat.Handler))
// Route for stats
e.Get("/stats", echo.HandlerFunc(func(c echo.Context) error {
return c.JSON(http.StatusOK, middStat.Data())
}))
// API v1 Restricted group Token in header
api := e.Group("/apiv1")
api.Use(middleware.JWTWithConfig(middleware.JWTConfig{
SigningKey: []byte(midd.SigningKey),
TokenLookup: "header:Authorization"}))
api.Post("/user", handler.PostUser)
api.Get("/user/:id", handler.GetUser)
// API v1 Token as first param
apit := e.Group("/apiv1token")
apit.Use(middleware.JWTWithConfig(middleware.JWTConfig{
SigningKey: []byte(midd.SigningKey),
TokenLookup: "query:token"}))
apit.Post("/user", handler.PostUser)
apit.Get("/user/:id", handler.GetUser)
// Serve index file
e.File("/", "public/index.html")
// Serve favicon
e.File("/favicon.ico", "public/favicon.ico")
// Serve static files
e.Static("/scripts", "public/scripts")
midd.GenerateToken()
// Get server info
var svrHostname string
if runtime.GOOS == "windows" {
svrHostname = fmt.Sprintf("%s.%s", os.Getenv("COMPUTERNAME"), os.Getenv("USERDNSDOMAIN"))
} else {
svrHostname, _ = os.Hostname()
}
webInterfacePort := viper.GetString("web.interface")
logg.Printf("%s for %s %s on %d cores\n%s%s\n",
runtime.Version(), runtime.GOOS, runtime.GOARCH, runtime.NumCPU(), svrHostname, webInterfacePort)
mgoInfo, _ := db.Session.BuildInfo()
logg.Printf("MongoDB %s %d bits\n", mgoInfo.Version, mgoInfo.Bits)
// github.com/tylerb/graceful
std := standard.New(webInterfacePort)
std.SetHandler(e)
graceful.ListenAndServe(std.Server, 5*time.Second)
}