Golang graceful.ListenAndServe函数代码示例

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")
}

//.........这里部分代码省略.........
		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)
}