// Beego (http://beego.me/) // @description beego is an open-source, high-performance web framework for the Go programming language. // @link http://github.com/astaxie/beego for the canonical source repository // @license http://github.com/astaxie/beego/blob/master/LICENSE // @authors astaxie package beego import ( "net/http" "os" "path" "path/filepath" "strconv" "strings" "github.com/astaxie/beego/middleware" "github.com/astaxie/beego/session" ) // beego web framework version. const VERSION = "1.2.0" type hookfunc func() error //hook function to run var hooks []hookfunc //hook function slice to store the hookfunc type groupRouter struct { pattern string controller ControllerInterface mappingMethods string } // RouterGroups which will store routers type GroupRouters []groupRouter // Get a new GroupRouters func NewGroupRouters() GroupRouters { return make(GroupRouters, 0) } // Add Router in the GroupRouters // it is for plugin or module to register router func (gr *GroupRouters) AddRouter(pattern string, c ControllerInterface, mappingMethod ...string) { var newRG groupRouter if len(mappingMethod) > 0 { newRG = groupRouter{ pattern, c, mappingMethod[0], } } else { newRG = groupRouter{ pattern, c, "", } } *gr = append(*gr, newRG) } func (gr *GroupRouters) AddAuto(c ControllerInterface) { newRG := groupRouter{ "", c, "", } *gr = append(*gr, newRG) } // AddGroupRouter with the prefix // it will register the router in BeeApp // the follow code is write in modules: // GR:=NewGroupRouters() // GR.AddRouter("/login",&UserController,"get:Login") // GR.AddRouter("/logout",&UserController,"get:Logout") // GR.AddRouter("/register",&UserController,"get:Reg") // the follow code is write in app: // import "github.com/beego/modules/auth" // AddRouterGroup("/admin", auth.GR) func AddGroupRouter(prefix string, groups GroupRouters) *App { for _, v := range groups { if v.pattern == "" { BeeApp.Handlers.AddAutoPrefix(prefix, v.controller) } else if v.mappingMethods != "" { BeeApp.Handlers.Add(prefix+v.pattern, v.controller, v.mappingMethods) } else { BeeApp.Handlers.Add(prefix+v.pattern, v.controller) } } return BeeApp } // Router adds a patterned controller handler to BeeApp. // it's an alias method of App.Router. // 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 Router(rootpath string, c ControllerInterface, mappingMethods ...string) *App { BeeApp.Handlers.Add(rootpath, c, mappingMethods...) return BeeApp } // RESTRouter adds a restful controller handler to BeeApp. // its' controller implements beego.ControllerInterface and // defines a param "pattern/:objectId" to visit each resource. func RESTRouter(rootpath string, c ControllerInterface) *App { Router(rootpath, c) Router(path.Join(rootpath, ":objectId"), c) return BeeApp } // AutoRouter adds defined controller handler to BeeApp. // it's same to App.AutoRouter. // 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 AutoRouter(c ControllerInterface) *App { BeeApp.Handlers.AddAuto(c) return BeeApp } // AutoPrefix adds controller handler to BeeApp with prefix. // it's same to App.AutoRouterWithPrefix. // 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 AutoPrefix(prefix string, c ControllerInterface) *App { BeeApp.Handlers.AddAutoPrefix(prefix, c) return BeeApp } // register router for Get method // usage: // beego.Get("/", func(ctx *context.Context){ // ctx.Output.Body("hello world") // }) func Get(rootpath string, f FilterFunc) *App { BeeApp.Handlers.Get(rootpath, f) return BeeApp } // register router for Post method // usage: // beego.Post("/api", func(ctx *context.Context){ // ctx.Output.Body("hello world") // }) func Post(rootpath string, f FilterFunc) *App { BeeApp.Handlers.Post(rootpath, f) return BeeApp } // register router for Delete method // usage: // beego.Delete("/api", func(ctx *context.Context){ // ctx.Output.Body("hello world") // }) func Delete(rootpath string, f FilterFunc) *App { BeeApp.Handlers.Delete(rootpath, f) return BeeApp } // register router for Put method // usage: // beego.Put("/api", func(ctx *context.Context){ // ctx.Output.Body("hello world") // }) func Put(rootpath string, f FilterFunc) *App { BeeApp.Handlers.Put(rootpath, f) return BeeApp } // register router for Head method // usage: // beego.Head("/api", func(ctx *context.Context){ // ctx.Output.Body("hello world") // }) func Head(rootpath string, f FilterFunc) *App { BeeApp.Handlers.Head(rootpath, f) return BeeApp } // register router for Options method // usage: // beego.Options("/api", func(ctx *context.Context){ // ctx.Output.Body("hello world") // }) func Options(rootpath string, f FilterFunc) *App { BeeApp.Handlers.Options(rootpath, f) return BeeApp } // register router for Patch method // usage: // beego.Patch("/api", func(ctx *context.Context){ // ctx.Output.Body("hello world") // }) func Patch(rootpath string, f FilterFunc) *App { BeeApp.Handlers.Patch(rootpath, f) return BeeApp } // register router for all method // usage: // beego.Any("/api", func(ctx *context.Context){ // ctx.Output.Body("hello world") // }) func Any(rootpath string, f FilterFunc) *App { BeeApp.Handlers.Any(rootpath, f) return BeeApp } // register router for own Handler // usage: // beego.Handler("/api", func(ctx *context.Context){ // ctx.Output.Body("hello world") // }) func Handler(rootpath string, h http.Handler, options ...interface{}) *App { BeeApp.Handlers.Handler(rootpath, h, options...) return BeeApp } // ErrorHandler registers http.HandlerFunc to each http err code string. // usage: // beego.ErrorHandler("404",NotFound) // beego.ErrorHandler("500",InternalServerError) func Errorhandler(err string, h http.HandlerFunc) *App { middleware.Errorhandler(err, h) return BeeApp } // SetViewsPath sets view directory path in beego application. func SetViewsPath(path string) *App { ViewsPath = path return BeeApp } // 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". func SetStaticPath(url string, path string) *App { if !strings.HasPrefix(url, "/") { url = "/" + url } url = strings.TrimRight(url, "/") StaticDir[url] = path return BeeApp } // DelStaticPath removes the static folder setting in this url pattern in beego application. func DelStaticPath(url string) *App { delete(StaticDir, url) return BeeApp } // [Deprecated] use InsertFilter. // Filter adds a FilterFunc under pattern condition and named action. // The actions contains BeforeRouter,AfterStatic,BeforeExec,AfterExec and FinishRouter. func AddFilter(pattern, action string, filter FilterFunc) *App { BeeApp.Handlers.AddFilter(pattern, action, filter) return BeeApp } // 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 InsertFilter(pattern string, pos int, filter FilterFunc) *App { BeeApp.Handlers.InsertFilter(pattern, pos, filter) return BeeApp } // The hookfunc will run in beego.Run() // such as sessionInit, middlerware start, buildtemplate, admin start func AddAPPStartHook(hf hookfunc) { hooks = append(hooks, hf) } // Run beego application. // beego.Run() default run on HttpPort // beego.Run(":8089") // beego.Run("127.0.0.1:8089") func Run(params ...string) { if len(params) > 0 && params[0] != "" { strs := strings.Split(params[0], ":") if len(strs) > 0 && strs[0] != "" { HttpAddr = strs[0] } if len(strs) > 1 && strs[1] != "" { HttpPort, _ = strconv.Atoi(strs[1]) } } initBeforeHttpRun() if EnableAdmin { go beeAdminApp.Run() } BeeApp.Run() } func initBeforeHttpRun() { // if AppConfigPath not In the conf/app.conf reParse config if AppConfigPath != filepath.Join(AppPath, "conf", "app.conf") { err := ParseConfig() if err != nil && AppConfigPath != filepath.Join(workPath, "conf", "app.conf") { // configuration is critical to app, panic here if parse failed panic(err) } } // do hooks function for _, hk := range hooks { err := hk() if err != nil { panic(err) } } if SessionOn { var err error sessionConfig := AppConfig.String("sessionConfig") if sessionConfig == "" { sessionConfig = `{"cookieName":"` + SessionName + `",` + `"gclifetime":` + strconv.FormatInt(SessionGCMaxLifetime, 10) + `,` + `"providerConfig":"` + SessionSavePath + `",` + `"secure":` + strconv.FormatBool(EnableHttpTLS) + `,` + `"sessionIDHashFunc":"` + SessionHashFunc + `",` + `"sessionIDHashKey":"` + SessionHashKey + `",` + `"enableSetCookie":` + strconv.FormatBool(SessionAutoSetCookie) + `,` + `"cookieLifeTime":` + strconv.Itoa(SessionCookieLifeTime) + `}` } GlobalSessions, err = session.NewManager(SessionProvider, sessionConfig) if err != nil { panic(err) } go GlobalSessions.GC() } err := BuildTemplate(ViewsPath) if err != nil { if RunMode == "dev" { Warn(err) } } middleware.VERSION = VERSION middleware.AppName = AppName middleware.RegisterErrorHandler() } // this function is for test package init func TestBeegoInit(apppath string) { AppPath = apppath AppConfigPath = filepath.Join(AppPath, "conf", "app.conf") err := ParseConfig() if err != nil && !os.IsNotExist(err) { // for init if doesn't have app.conf will not panic Info(err) } os.Chdir(AppPath) initBeforeHttpRun() } func init() { hooks = make([]hookfunc, 0) //init mime AddAPPStartHook(initMime) }