mirror of
https://github.com/astaxie/beego.git
synced 2024-12-23 14:20:49 +00:00
173 lines
5.2 KiB
Go
173 lines
5.2 KiB
Go
package beego
|
|
|
|
import (
|
|
"fmt"
|
|
"net"
|
|
"net/http"
|
|
"net/http/fcgi"
|
|
"time"
|
|
|
|
"github.com/astaxie/beego/context"
|
|
)
|
|
|
|
// FilterFunc defines filter function type.
|
|
type FilterFunc func(*context.Context)
|
|
|
|
// App defines beego application with a new PatternServeMux.
|
|
type App struct {
|
|
Handlers *ControllerRegistor
|
|
}
|
|
|
|
// NewApp returns a new beego application.
|
|
func NewApp() *App {
|
|
cr := NewControllerRegistor()
|
|
app := &App{Handlers: cr}
|
|
return app
|
|
}
|
|
|
|
// Run beego application.
|
|
func (app *App) Run() {
|
|
addr := HttpAddr
|
|
|
|
if HttpPort != 0 {
|
|
addr = fmt.Sprintf("%s:%d", HttpAddr, HttpPort)
|
|
}
|
|
|
|
BeeLogger.Info("Running on %s", addr)
|
|
|
|
var (
|
|
err error
|
|
l net.Listener
|
|
)
|
|
|
|
if UseFcgi {
|
|
if HttpPort == 0 {
|
|
l, err = net.Listen("unix", addr)
|
|
} else {
|
|
l, err = net.Listen("tcp", addr)
|
|
}
|
|
if err != nil {
|
|
BeeLogger.Critical("Listen: ", err)
|
|
}
|
|
err = fcgi.Serve(l, app.Handlers)
|
|
} else {
|
|
if EnableHotUpdate {
|
|
server := &http.Server{
|
|
Handler: app.Handlers,
|
|
ReadTimeout: time.Duration(HttpServerTimeOut) * time.Second,
|
|
WriteTimeout: time.Duration(HttpServerTimeOut) * time.Second,
|
|
}
|
|
laddr, err := net.ResolveTCPAddr("tcp", addr)
|
|
if nil != err {
|
|
BeeLogger.Critical("ResolveTCPAddr:", err)
|
|
}
|
|
l, err = GetInitListener(laddr)
|
|
theStoppable = newStoppable(l)
|
|
err = server.Serve(theStoppable)
|
|
theStoppable.wg.Wait()
|
|
CloseSelf()
|
|
} else {
|
|
s := &http.Server{
|
|
Addr: addr,
|
|
Handler: app.Handlers,
|
|
ReadTimeout: time.Duration(HttpServerTimeOut) * time.Second,
|
|
WriteTimeout: time.Duration(HttpServerTimeOut) * time.Second,
|
|
}
|
|
if HttpTLS {
|
|
err = s.ListenAndServeTLS(HttpCertFile, HttpKeyFile)
|
|
} else {
|
|
err = s.ListenAndServe()
|
|
}
|
|
}
|
|
}
|
|
|
|
if err != nil {
|
|
BeeLogger.Critical("ListenAndServe: ", err)
|
|
time.Sleep(100 * time.Microsecond)
|
|
}
|
|
}
|
|
|
|
// Router adds a url-patterned controller handler.
|
|
// The path argument supports regex rules and specific placeholders.
|
|
// The c argument needs a controller handler implemented beego.ControllerInterface.
|
|
// The mapping methods argument only need one string to define custom router rules.
|
|
// usage:
|
|
// simple router
|
|
// beego.Router("/admin", &admin.UserController{})
|
|
// beego.Router("/admin/index", &admin.ArticleController{})
|
|
//
|
|
// regex router
|
|
//
|
|
// beego.Router(“/api/:id([0-9]+)“, &controllers.RController{})
|
|
//
|
|
// custom rules
|
|
// beego.Router("/api/list",&RestController{},"*:ListFood")
|
|
// beego.Router("/api/create",&RestController{},"post:CreateFood")
|
|
// beego.Router("/api/update",&RestController{},"put:UpdateFood")
|
|
// beego.Router("/api/delete",&RestController{},"delete:DeleteFood")
|
|
func (app *App) Router(path string, c ControllerInterface, mappingMethods ...string) *App {
|
|
app.Handlers.Add(path, c, mappingMethods...)
|
|
return app
|
|
}
|
|
|
|
// AutoRouter adds beego-defined controller handler.
|
|
// if beego.AddAuto(&MainContorlller{}) and MainController has methods List and Page,
|
|
// visit the url /main/list to exec List function or /main/page to exec Page function.
|
|
func (app *App) AutoRouter(c ControllerInterface) *App {
|
|
app.Handlers.AddAuto(c)
|
|
return app
|
|
}
|
|
|
|
// AutoRouterWithPrefix adds beego-defined controller handler with prefix.
|
|
// if beego.AutoPrefix("/admin",&MainContorlller{}) and MainController has methods List and Page,
|
|
// visit the url /admin/main/list to exec List function or /admin/main/page to exec Page function.
|
|
func (app *App) AutoRouterWithPrefix(prefix string, c ControllerInterface) *App {
|
|
app.Handlers.AddAutoPrefix(prefix, c)
|
|
return app
|
|
}
|
|
|
|
// UrlFor creates a url with another registered controller handler with params.
|
|
// The endpoint is formed as path.controller.name to defined the controller method which will run.
|
|
// The values need key-pair data to assign into controller method.
|
|
func (app *App) UrlFor(endpoint string, values ...string) string {
|
|
return app.Handlers.UrlFor(endpoint, values...)
|
|
}
|
|
|
|
// [Deprecated] use InsertFilter.
|
|
// Filter adds a FilterFunc under pattern condition and named action.
|
|
// The actions contains BeforeRouter,AfterStatic,BeforeExec,AfterExec and FinishRouter.
|
|
func (app *App) Filter(pattern, action string, filter FilterFunc) *App {
|
|
app.Handlers.AddFilter(pattern, action, filter)
|
|
return app
|
|
}
|
|
|
|
// InsertFilter adds a FilterFunc with pattern condition and action constant.
|
|
// The pos means action constant including
|
|
// beego.BeforeRouter, beego.AfterStatic, beego.BeforeExec, beego.AfterExec and beego.FinishRouter.
|
|
func (app *App) InsertFilter(pattern string, pos int, filter FilterFunc) *App {
|
|
app.Handlers.InsertFilter(pattern, pos, filter)
|
|
return app
|
|
}
|
|
|
|
// SetViewsPath sets view directory path in beego application.
|
|
// it returns beego application self.
|
|
func (app *App) SetViewsPath(path string) *App {
|
|
ViewsPath = path
|
|
return app
|
|
}
|
|
|
|
// SetStaticPath sets static directory path and proper url pattern in beego application.
|
|
// if beego.SetStaticPath("static","public"), visit /static/* to load static file in folder "public".
|
|
// it returns beego application self.
|
|
func (app *App) SetStaticPath(url string, path string) *App {
|
|
StaticDir[url] = path
|
|
return app
|
|
}
|
|
|
|
// DelStaticPath removes the static folder setting in this url pattern in beego application.
|
|
// it returns beego application self.
|
|
func (app *App) DelStaticPath(url string) *App {
|
|
delete(StaticDir, url)
|
|
return app
|
|
}
|