// ListenAndServe starts a http server on the given port and uses the
// provided router for request dispatching and handling.
func ListenAndServe(port int, router *mux.Router, transformers ...func(http.Handler) http.Handler) {
var handler http.Handler = router
for _, mw := range transformers {
handler = mw(handler)
}
log.Fatal(http.ListenAndServe(fmt.Sprintf(":%d", port),
handlers.LoggingHandler(os.Stdout,
handlers.RecoveryHandler()(handler))))
}
func StartServer() {
l4g.Info(utils.T("api.server.start_server.starting.info"))
l4g.Info(utils.T("api.server.start_server.listening.info"), utils.Cfg.ServiceSettings.ListenAddress)
var handler http.Handler = &CorsWrapper{Srv.Router}
if *utils.Cfg.RateLimitSettings.Enable {
l4g.Info(utils.T("api.server.start_server.rate.info"))
store, err := memstore.New(utils.Cfg.RateLimitSettings.MemoryStoreSize)
if err != nil {
l4g.Critical(utils.T("api.server.start_server.rate_limiting_memory_store"))
return
}
quota := throttled.RateQuota{
MaxRate: throttled.PerSec(utils.Cfg.RateLimitSettings.PerSec),
MaxBurst: *utils.Cfg.RateLimitSettings.MaxBurst,
}
rateLimiter, err := throttled.NewGCRARateLimiter(store, quota)
if err != nil {
l4g.Critical(utils.T("api.server.start_server.rate_limiting_rate_limiter"))
return
}
httpRateLimiter := throttled.HTTPRateLimiter{
RateLimiter: rateLimiter,
VaryBy: &VaryBy{},
DeniedHandler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
l4g.Error("%v: Denied due to throttling settings code=429 ip=%v", r.URL.Path, GetIpAddress(r))
throttled.DefaultDeniedHandler.ServeHTTP(w, r)
}),
}
handler = httpRateLimiter.RateLimit(handler)
}
go func() {
err := manners.ListenAndServe(utils.Cfg.ServiceSettings.ListenAddress, handlers.RecoveryHandler(handlers.PrintRecoveryStack(true))(handler))
if err != nil {
l4g.Critical(utils.T("api.server.start_server.starting.critical"), err)
time.Sleep(time.Second)
}
}()
}
func StartServer() {
l4g.Info(utils.T("api.server.start_server.starting.info"))
l4g.Info(utils.T("api.server.start_server.listening.info"), utils.Cfg.ServiceSettings.ListenAddress)
var handler http.Handler = &CorsWrapper{Srv.Router}
if utils.Cfg.RateLimitSettings.EnableRateLimiter {
l4g.Info(utils.T("api.server.start_server.rate.info"))
vary := throttled.VaryBy{}
if utils.Cfg.RateLimitSettings.VaryByRemoteAddr {
vary.RemoteAddr = true
}
if len(utils.Cfg.RateLimitSettings.VaryByHeader) > 0 {
vary.Headers = strings.Fields(utils.Cfg.RateLimitSettings.VaryByHeader)
if utils.Cfg.RateLimitSettings.VaryByRemoteAddr {
l4g.Warn(utils.T("api.server.start_server.rate.warn"))
vary.RemoteAddr = false
}
}
th := throttled.RateLimit(throttled.PerSec(utils.Cfg.RateLimitSettings.PerSec), &vary, throttledStore.NewMemStore(utils.Cfg.RateLimitSettings.MemoryStoreSize))
th.DeniedHandler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
l4g.Error("%v: code=429 ip=%v", r.URL.Path, GetIpAddress(r))
throttled.DefaultDeniedHandler.ServeHTTP(w, r)
})
handler = th.Throttle(&CorsWrapper{Srv.Router})
}
go func() {
err := manners.ListenAndServe(utils.Cfg.ServiceSettings.ListenAddress, handlers.RecoveryHandler(handlers.PrintRecoveryStack(true))(handler))
if err != nil {
l4g.Critical(utils.T("api.server.start_server.starting.critical"), err)
time.Sleep(time.Second)
}
}()
}
//GetRouter contructs the router hierarchy and registers all handlers and middleware
func GetRouter(sc *siteservice.Service, is *identityservice.Service, oauthsc *oauthservice.Service) http.Handler {
r := mux.NewRouter().StrictSlash(true)
sc.AddRoutes(r)
sc.InitModels()
apiRouter := r.PathPrefix("/api").Subrouter()
is.AddRoutes(apiRouter)
oauthsc.AddRoutes(r)
// Add middlewares
router := NewRouter(r)
dbmw := db.DBMiddleware()
recovery := handlers.RecoveryHandler()
router.Use(recovery, LoggingMiddleware, dbmw, sc.SetWebUserMiddleWare)
return router.Handler()
}
//GetRouter contructs the router hierarchy and registers all handlers and middleware
func GetRouter() http.Handler {
r := mux.NewRouter().StrictSlash(true)
siteservice := siteservice.NewService()
siteservice.AddRoutes(r)
apiRouter := r.PathPrefix("/api").Subrouter()
identityservice.NewService().AddRoutes(apiRouter)
oauthservice.NewService(siteservice).AddRoutes(r)
// Add middlewares
router := NewRouter(r)
dbmw := db.DBMiddleware()
recovery := handlers.RecoveryHandler()
router.Use(recovery, LoggingMiddleware, dbmw)
return router.Handler()
}
// Final app handlers to serve on http server
// Handlers are wrapped into more handlers for adding respective functionality
func AppHandlers(session *mgo.Session) http.Handler {
log.SetFlags(log.LstdFlags | log.Lshortfile)
logger := &lumberjack.Logger{
Filename: "/tmp/go_files_api.log",
MaxSize: 500, // megabytes
MaxBackups: 20,
MaxAge: 30, //days
}
log.SetOutput(logger)
r := mux.NewRouter()
r.HandleFunc("/files/{id}", GetById).Methods("GET")
r.HandleFunc("/files/path/{path}", Upload).Methods("POST")
//Adapters
// Add a RecoveryOption to send 500 error
recoveryHandler := handlers.RecoveryHandler(handlers.PrintRecoveryStack(true)) //for suppressing panics
logHandler := handlers.LoggingHandler(logger, r) //fix this. Should log to a file
dbHandler := MDbHandler(os.Stdout, logHandler, session) //wrap MongoDB session for each handler request
return LogReqHandler(recoveryHandler(dbHandler))
}
func main() {
r := mux.NewRouter()
loggedRouter := handlers.LoggingHandler(os.Stdout, r)
userAuth := controllers.UserAuthMiddleWare(loggedRouter)
recovery := handlers.RecoveryHandler()(userAuth)
s := r.Host("test.datistry.com").Subrouter()
s.HandleFunc("/", controllers.FrontPageHandler)
s.HandleFunc("/about", controllers.AboutPageHandler)
s.HandleFunc("/contact", controllers.ContactPageHandler)
s.HandleFunc("/login", DisplayLoginHandler).Methods("GET")
s.HandleFunc("/login", LoginHandler).Methods("POST")
s.HandleFunc("/logout", LogoutHandler)
s.HandleFunc("/series/edit/{urlid:[a-z0-9]+-[a-z0-9]+-[a-z0-9]+-[a-z0-9]+-[a-z0-9]+}", controllers.SeriesEditFormHandler).Methods("GET")
s.HandleFunc("/series/edit/{urlid:[a-z0-9]+-[a-z0-9]+-[a-z0-9]+-[a-z0-9]+-[a-z0-9]+}", controllers.SeriesEditHandler).Methods("POST")
s.HandleFunc("/series/add", controllers.SeriesAddFormHandler).Methods("GET")
s.HandleFunc("/series/add", controllers.SeriesAddHandler).Methods("POST")
s.HandleFunc("/series/{id:[a-z0-9]+-[a-z0-9]+-[a-z0-9]+-[a-z0-9]+-[a-z0-9]+}", controllers.SeriesIdHandler)
s.HandleFunc("/series/{name}", controllers.SeriesNameHandler)
s.HandleFunc("/series", controllers.SeriesIndexHandler)
staticPath, _ := config.GetString("STATIC")
r.PathPrefix("/public/").Handler(http.StripPrefix("/public/", http.FileServer(http.Dir(staticPath))))
http.ListenAndServe(":3333", recovery)
}
func StartServer() {
l4g.Info(utils.T("api.server.start_server.starting.info"))
var handler http.Handler = &CorsWrapper{Srv.Router}
if *utils.Cfg.RateLimitSettings.Enable {
l4g.Info(utils.T("api.server.start_server.rate.info"))
store, err := memstore.New(utils.Cfg.RateLimitSettings.MemoryStoreSize)
if err != nil {
l4g.Critical(utils.T("api.server.start_server.rate_limiting_memory_store"))
return
}
quota := throttled.RateQuota{
MaxRate: throttled.PerSec(utils.Cfg.RateLimitSettings.PerSec),
MaxBurst: *utils.Cfg.RateLimitSettings.MaxBurst,
}
rateLimiter, err := throttled.NewGCRARateLimiter(store, quota)
if err != nil {
l4g.Critical(utils.T("api.server.start_server.rate_limiting_rate_limiter"))
return
}
httpRateLimiter := throttled.HTTPRateLimiter{
RateLimiter: rateLimiter,
VaryBy: &VaryBy{},
DeniedHandler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
l4g.Error("%v: Denied due to throttling settings code=429 ip=%v", r.URL.Path, GetIpAddress(r))
throttled.DefaultDeniedHandler.ServeHTTP(w, r)
}),
}
handler = httpRateLimiter.RateLimit(handler)
}
Srv.GracefulServer = &graceful.Server{
Timeout: TIME_TO_WAIT_FOR_CONNECTIONS_TO_CLOSE_ON_SERVER_SHUTDOWN,
Server: &http.Server{
Addr: utils.Cfg.ServiceSettings.ListenAddress,
Handler: handlers.RecoveryHandler(handlers.PrintRecoveryStack(true))(handler),
ReadTimeout: time.Duration(*utils.Cfg.ServiceSettings.ReadTimeout) * time.Second,
WriteTimeout: time.Duration(*utils.Cfg.ServiceSettings.WriteTimeout) * time.Second,
},
}
l4g.Info(utils.T("api.server.start_server.listening.info"), utils.Cfg.ServiceSettings.ListenAddress)
if *utils.Cfg.ServiceSettings.Forward80To443 {
go func() {
listener, err := net.Listen("tcp", ":80")
if err != nil {
l4g.Error("Unable to setup forwarding")
return
}
defer listener.Close()
http.Serve(listener, http.HandlerFunc(redirectHTTPToHTTPS))
}()
}
go func() {
var err error
if *utils.Cfg.ServiceSettings.ConnectionSecurity == model.CONN_SECURITY_TLS {
if *utils.Cfg.ServiceSettings.UseLetsEncrypt {
var m letsencrypt.Manager
m.CacheFile(*utils.Cfg.ServiceSettings.LetsEncryptCertificateCacheFile)
tlsConfig := &tls.Config{
GetCertificate: m.GetCertificate,
}
tlsConfig.NextProtos = append(tlsConfig.NextProtos, "h2")
err = Srv.GracefulServer.ListenAndServeTLSConfig(tlsConfig)
} else {
err = Srv.GracefulServer.ListenAndServeTLS(*utils.Cfg.ServiceSettings.TLSCertFile, *utils.Cfg.ServiceSettings.TLSKeyFile)
}
} else {
err = Srv.GracefulServer.ListenAndServe()
}
if err != nil {
l4g.Critical(utils.T("api.server.start_server.starting.critical"), err)
time.Sleep(time.Second)
}
}()
}