From a06022f75cc05601921ecc950ed5f53c6a544f01 Mon Sep 17 00:00:00 2001 From: fuxiaohei Date: Sat, 12 Dec 2015 14:10:02 +0800 Subject: [PATCH] clean compliated codes, refactor if sections in app.go --- admin.go | 236 +++++++++++++++++++++++++++---------------------------- app.go | 213 +++++++++++++++++++++++++------------------------ 2 files changed, 222 insertions(+), 227 deletions(-) diff --git a/admin.go b/admin.go index a1f48fa0..0be95e04 100644 --- a/admin.go +++ b/admin.go @@ -81,91 +81,93 @@ func qpsIndex(rw http.ResponseWriter, r *http.Request) { func listConf(rw http.ResponseWriter, r *http.Request) { r.ParseForm() command := r.Form.Get("command") - if command != "" { - data := make(map[interface{}]interface{}) - switch command { - case "conf": - tmpl := template.Must(template.New("dashboard").Parse(dashboardTpl)) - tmpl = template.Must(tmpl.Parse(configTpl)) - tmpl = template.Must(tmpl.Parse(defaultScriptsTpl)) + if command == "" { + rw.Write([]byte("command not support")) + return + } - data["Content"] = BConfig + data := make(map[interface{}]interface{}) + switch command { + case "conf": + tmpl := template.Must(template.New("dashboard").Parse(dashboardTpl)) + tmpl = template.Must(tmpl.Parse(configTpl)) + tmpl = template.Must(tmpl.Parse(defaultScriptsTpl)) - tmpl.Execute(rw, data) + data["Content"] = BConfig - case "router": - content := make(map[string]interface{}) + tmpl.Execute(rw, data) - var fields = []string{ - fmt.Sprintf("Router Pattern"), - fmt.Sprintf("Methods"), - fmt.Sprintf("Controller"), + case "router": + var ( + content = map[string]interface{}{ + "Fields": []string{ + "Router Pattern", + "Methods", + "Controller", + }, } - content["Fields"] = fields + methods = []string{} + methodsData = make(map[string]interface{}) + ) + for method, t := range BeeApp.Handlers.routers { - methods := []string{} - methodsData := make(map[string]interface{}) - for method, t := range BeeApp.Handlers.routers { + resultList := new([][]string) - resultList := new([][]string) + printTree(resultList, t) - printTree(resultList, t) + methods = append(methods, method) + methodsData[method] = resultList + } - methods = append(methods, method) - methodsData[method] = resultList + content["Data"] = methodsData + content["Methods"] = methods + data["Content"] = content + data["Title"] = "Routers" + execTpl(rw, data, routerAndFilterTpl, defaultScriptsTpl) + case "filter": + var ( + content = map[string]interface{}{ + "Fields": []string{ + "Router Pattern", + "Filter Function", + }, } + filterTypes = []string{} + filterTypeData = make(map[string]interface{}) + ) - content["Data"] = methodsData - content["Methods"] = methods - data["Content"] = content - data["Title"] = "Routers" - execTpl(rw, data, routerAndFilterTpl, defaultScriptsTpl) - case "filter": - content := make(map[string]interface{}) - - var fields = []string{ - fmt.Sprintf("Router Pattern"), - fmt.Sprintf("Filter Function"), - } - content["Fields"] = fields - - filterTypes := []string{} - filterTypeData := make(map[string]interface{}) - - if BeeApp.Handlers.enableFilter { - var filterType string - for k, fr := range map[int]string{ - BeforeStatic: "Before Static", - BeforeRouter: "Before Router", - BeforeExec: "Before Exec", - AfterExec: "After Exec", - FinishRouter: "Finish Router"} { - if bf, ok := BeeApp.Handlers.filters[k]; ok { - filterType = fr - filterTypes = append(filterTypes, filterType) - resultList := new([][]string) - for _, f := range bf { - var result = []string{ - fmt.Sprintf("%s", f.pattern), - fmt.Sprintf("%s", utils.GetFuncName(f.filterFunc)), - } - *resultList = append(*resultList, result) + if BeeApp.Handlers.enableFilter { + var filterType string + for k, fr := range map[int]string{ + BeforeStatic: "Before Static", + BeforeRouter: "Before Router", + BeforeExec: "Before Exec", + AfterExec: "After Exec", + FinishRouter: "Finish Router"} { + if bf, ok := BeeApp.Handlers.filters[k]; ok { + filterType = fr + filterTypes = append(filterTypes, filterType) + resultList := new([][]string) + for _, f := range bf { + var result = []string{ + fmt.Sprintf("%s", f.pattern), + fmt.Sprintf("%s", utils.GetFuncName(f.filterFunc)), } - filterTypeData[filterType] = resultList + *resultList = append(*resultList, result) } + filterTypeData[filterType] = resultList } } - - content["Data"] = filterTypeData - content["Methods"] = filterTypes - - data["Content"] = content - data["Title"] = "Filters" - execTpl(rw, data, routerAndFilterTpl, defaultScriptsTpl) - default: - rw.Write([]byte("command not support")) } - } else { + + content["Data"] = filterTypeData + content["Methods"] = filterTypes + + data["Content"] = content + data["Title"] = "Filters" + execTpl(rw, data, routerAndFilterTpl, defaultScriptsTpl) + default: + rw.Write([]byte("command not support")) } } @@ -180,23 +182,23 @@ func printTree(resultList *[][]string, t *Tree) { if v, ok := l.runObject.(*controllerInfo); ok { if v.routerType == routerTypeBeego { var result = []string{ - fmt.Sprintf("%s", v.pattern), + v.pattern, fmt.Sprintf("%s", v.methods), fmt.Sprintf("%s", v.controllerType), } *resultList = append(*resultList, result) } else if v.routerType == routerTypeRESTFul { var result = []string{ - fmt.Sprintf("%s", v.pattern), + v.pattern, fmt.Sprintf("%s", v.methods), - fmt.Sprintf(""), + "", } *resultList = append(*resultList, result) } else if v.routerType == routerTypeHandler { var result = []string{ - fmt.Sprintf("%s", v.pattern), - fmt.Sprintf(""), - fmt.Sprintf(""), + v.pattern, + "", + "", } *resultList = append(*resultList, result) } @@ -209,49 +211,49 @@ func printTree(resultList *[][]string, t *Tree) { func profIndex(rw http.ResponseWriter, r *http.Request) { r.ParseForm() command := r.Form.Get("command") - format := r.Form.Get("format") - data := make(map[interface{}]interface{}) + if command == "" { + return + } - var result bytes.Buffer - if command != "" { - toolbox.ProcessInput(command, &result) - data["Content"] = result.String() + var ( + format = r.Form.Get("format") + data = make(map[interface{}]interface{}) + result bytes.Buffer + ) + toolbox.ProcessInput(command, &result) + data["Content"] = result.String() - if format == "json" && command == "gc summary" { - dataJSON, err := json.Marshal(data) - if err != nil { - http.Error(rw, err.Error(), http.StatusInternalServerError) - return - } - - rw.Header().Set("Content-Type", "application/json") - rw.Write(dataJSON) + if format == "json" && command == "gc summary" { + dataJSON, err := json.Marshal(data) + if err != nil { + http.Error(rw, err.Error(), http.StatusInternalServerError) return } - data["Title"] = command - defaultTpl := defaultScriptsTpl - if command == "gc summary" { - defaultTpl = gcAjaxTpl - } - execTpl(rw, data, profillingTpl, defaultTpl) + rw.Header().Set("Content-Type", "application/json") + rw.Write(dataJSON) + return } + + data["Title"] = command + defaultTpl := defaultScriptsTpl + if command == "gc summary" { + defaultTpl = gcAjaxTpl + } + execTpl(rw, data, profillingTpl, defaultTpl) } // Healthcheck is a http.Handler calling health checking and showing the result. // it's in "/healthcheck" pattern in admin module. func healthcheck(rw http.ResponseWriter, req *http.Request) { - data := make(map[interface{}]interface{}) - - var result = []string{} - fields := []string{ - fmt.Sprintf("Name"), - fmt.Sprintf("Message"), - fmt.Sprintf("Status"), - } - resultList := new([][]string) - - content := make(map[string]interface{}) + var ( + data = make(map[interface{}]interface{}) + result = []string{} + resultList = new([][]string) + content = map[string]interface{}{ + "Fields": []string{"Name", "Message", "Status"}, + } + ) for name, h := range toolbox.AdminCheckList { if err := h.Check(); err != nil { @@ -271,8 +273,6 @@ func healthcheck(rw http.ResponseWriter, req *http.Request) { } *resultList = append(*resultList, result) } - - content["Fields"] = fields content["Data"] = resultList data["Content"] = content data["Title"] = "Health Check" @@ -288,10 +288,8 @@ func taskStatus(rw http.ResponseWriter, req *http.Request) { req.ParseForm() taskname := req.Form.Get("taskname") if taskname != "" { - if t, ok := toolbox.AdminTaskList[taskname]; ok { - err := t.Run() - if err != nil { + if err := t.Run(); err != nil { data["Message"] = []string{"error", fmt.Sprintf("%s", err)} } data["Message"] = []string{"success", fmt.Sprintf("%s run success,Now the Status is
%s", taskname, t.GetStatus())} @@ -305,18 +303,18 @@ func taskStatus(rw http.ResponseWriter, req *http.Request) { resultList := new([][]string) var result = []string{} var fields = []string{ - fmt.Sprintf("Task Name"), - fmt.Sprintf("Task Spec"), - fmt.Sprintf("Task Status"), - fmt.Sprintf("Last Time"), - fmt.Sprintf(""), + "Task Name", + "Task Spec", + "Task Status", + "Last Time", + "", } for tname, tk := range toolbox.AdminTaskList { result = []string{ - fmt.Sprintf("%s", tname), + tname, fmt.Sprintf("%s", tk.GetSpec()), fmt.Sprintf("%s", tk.GetStatus()), - fmt.Sprintf("%s", tk.GetPrev().String()), + tk.GetPrev().String(), } *resultList = append(*resultList, result) } diff --git a/app.go b/app.go index e8d1bc47..548bff66 100644 --- a/app.go +++ b/app.go @@ -59,128 +59,125 @@ func (app *App) Run() { } var ( - err error - l net.Listener + err error + l net.Listener + endRunning = make(chan bool, 1) ) - endRunning := make(chan bool, 1) + // run cgi server if BConfig.Listen.EnableFcgi { if BConfig.Listen.EnableStdIo { - err = fcgi.Serve(nil, app.Handlers) // standard I/O - if err == nil { + if err = fcgi.Serve(nil, app.Handlers); err == nil { // standard I/O BeeLogger.Info("Use FCGI via standard I/O") } else { - BeeLogger.Info("Cannot use FCGI via standard I/O", err) + BeeLogger.Critical("Cannot use FCGI via standard I/O", err) } + return + } + if BConfig.Listen.HTTPPort == 0 { + // remove the Socket file before start + if utils.FileExists(addr) { + os.Remove(addr) + } + l, err = net.Listen("unix", addr) } else { - if BConfig.Listen.HTTPPort == 0 { - // remove the Socket file before start - if utils.FileExists(addr) { - os.Remove(addr) + l, err = net.Listen("tcp", addr) + } + if err != nil { + BeeLogger.Critical("Listen: ", err) + } + if err = fcgi.Serve(l, app.Handlers); err != nil { + BeeLogger.Critical("fcgi.Serve: ", err) + } + return + } + + app.Server.Handler = app.Handlers + app.Server.ReadTimeout = time.Duration(BConfig.Listen.ServerTimeOut) * time.Second + app.Server.WriteTimeout = time.Duration(BConfig.Listen.ServerTimeOut) * time.Second + + // run graceful mode + if BConfig.Listen.Graceful { + httpsAddr := BConfig.Listen.HTTPSAddr + app.Server.Addr = httpsAddr + if BConfig.Listen.HTTPSEnable { + go func() { + time.Sleep(20 * time.Microsecond) + if BConfig.Listen.HTTPSPort != 0 { + httpsAddr = fmt.Sprintf("%s:%d", BConfig.Listen.HTTPSAddr, BConfig.Listen.HTTPSPort) + app.Server.Addr = httpsAddr } - 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) + server := grace.NewServer(httpsAddr, app.Handlers) + server.Server.ReadTimeout = app.Server.ReadTimeout + server.Server.WriteTimeout = app.Server.WriteTimeout + if err := server.ListenAndServeTLS(BConfig.Listen.HTTPSCertFile, BConfig.Listen.HTTPSKeyFile); err != nil { + BeeLogger.Critical("ListenAndServeTLS: ", err, fmt.Sprintf("%d", os.Getpid())) + time.Sleep(100 * time.Microsecond) + endRunning <- true + } + }() } - } else { - if BConfig.Listen.Graceful { - httpsAddr := BConfig.Listen.HTTPSAddr - app.Server.Addr = httpsAddr - app.Server.Handler = app.Handlers - app.Server.ReadTimeout = time.Duration(BConfig.Listen.ServerTimeOut) * time.Second - app.Server.WriteTimeout = time.Duration(BConfig.Listen.ServerTimeOut) * time.Second - if BConfig.Listen.HTTPSEnable { - go func() { - time.Sleep(20 * time.Microsecond) - if BConfig.Listen.HTTPSPort != 0 { - httpsAddr = fmt.Sprintf("%s:%d", BConfig.Listen.HTTPSAddr, BConfig.Listen.HTTPSPort) - app.Server.Addr = httpsAddr - } - server := grace.NewServer(httpsAddr, app.Handlers) - server.Server.ReadTimeout = app.Server.ReadTimeout - server.Server.WriteTimeout = app.Server.WriteTimeout - err := server.ListenAndServeTLS(BConfig.Listen.HTTPSCertFile, BConfig.Listen.HTTPSKeyFile) - if err != nil { - BeeLogger.Critical("ListenAndServeTLS: ", err, fmt.Sprintf("%d", os.Getpid())) - time.Sleep(100 * time.Microsecond) - endRunning <- true - } - }() + if BConfig.Listen.HTTPEnable { + go func() { + server := grace.NewServer(addr, app.Handlers) + server.Server.ReadTimeout = app.Server.ReadTimeout + server.Server.WriteTimeout = app.Server.WriteTimeout + if BConfig.Listen.ListenTCP4 { + server.Network = "tcp4" + } + if err := server.ListenAndServe(); err != nil { + BeeLogger.Critical("ListenAndServe: ", err, fmt.Sprintf("%d", os.Getpid())) + time.Sleep(100 * time.Microsecond) + endRunning <- true + } + }() + } + <-endRunning + return + } + + // run normal mode + app.Server.Addr = addr + if BConfig.Listen.HTTPSEnable { + go func() { + time.Sleep(20 * time.Microsecond) + if BConfig.Listen.HTTPSPort != 0 { + app.Server.Addr = fmt.Sprintf("%s:%d", BConfig.Listen.HTTPSAddr, BConfig.Listen.HTTPSPort) } - if BConfig.Listen.HTTPEnable { - go func() { - server := grace.NewServer(addr, app.Handlers) - server.Server.ReadTimeout = app.Server.ReadTimeout - server.Server.WriteTimeout = app.Server.WriteTimeout - if BConfig.Listen.ListenTCP4 { - server.Network = "tcp4" - } - err := server.ListenAndServe() - if err != nil { - BeeLogger.Critical("ListenAndServe: ", err, fmt.Sprintf("%d", os.Getpid())) - time.Sleep(100 * time.Microsecond) - endRunning <- true - } - }() + BeeLogger.Info("https server Running on %s", app.Server.Addr) + if err := app.Server.ListenAndServeTLS(BConfig.Listen.HTTPSCertFile, BConfig.Listen.HTTPSKeyFile); err != nil { + BeeLogger.Critical("ListenAndServeTLS: ", err) + time.Sleep(100 * time.Microsecond) + endRunning <- true } - } else { + }() + } + if BConfig.Listen.HTTPEnable { + go func() { app.Server.Addr = addr - app.Server.Handler = app.Handlers - app.Server.ReadTimeout = time.Duration(BConfig.Listen.ServerTimeOut) * time.Second - app.Server.WriteTimeout = time.Duration(BConfig.Listen.ServerTimeOut) * time.Second - - if BConfig.Listen.HTTPSEnable { - go func() { - time.Sleep(20 * time.Microsecond) - if BConfig.Listen.HTTPSPort != 0 { - app.Server.Addr = fmt.Sprintf("%s:%d", BConfig.Listen.HTTPSAddr, BConfig.Listen.HTTPSPort) - } - BeeLogger.Info("https server Running on %s", app.Server.Addr) - err := app.Server.ListenAndServeTLS(BConfig.Listen.HTTPSCertFile, BConfig.Listen.HTTPSKeyFile) - if err != nil { - BeeLogger.Critical("ListenAndServeTLS: ", err) - time.Sleep(100 * time.Microsecond) - endRunning <- true - } - }() + BeeLogger.Info("http server Running on %s", app.Server.Addr) + if BConfig.Listen.ListenTCP4 { + ln, err := net.Listen("tcp4", app.Server.Addr) + if err != nil { + BeeLogger.Critical("ListenAndServe: ", err) + time.Sleep(100 * time.Microsecond) + endRunning <- true + return + } + if err = app.Server.Serve(ln); err != nil { + BeeLogger.Critical("ListenAndServe: ", err) + time.Sleep(100 * time.Microsecond) + endRunning <- true + return + } + } else { + if err := app.Server.ListenAndServe(); err != nil { + BeeLogger.Critical("ListenAndServe: ", err) + time.Sleep(100 * time.Microsecond) + endRunning <- true + } } - - if BConfig.Listen.HTTPEnable { - go func() { - app.Server.Addr = addr - BeeLogger.Info("http server Running on %s", app.Server.Addr) - if BConfig.Listen.ListenTCP4 { - ln, err := net.Listen("tcp4", app.Server.Addr) - if err != nil { - BeeLogger.Critical("ListenAndServe: ", err) - time.Sleep(100 * time.Microsecond) - endRunning <- true - return - } - err = app.Server.Serve(ln) - if err != nil { - BeeLogger.Critical("ListenAndServe: ", err) - time.Sleep(100 * time.Microsecond) - endRunning <- true - return - } - } else { - err := app.Server.ListenAndServe() - if err != nil { - BeeLogger.Critical("ListenAndServe: ", err) - time.Sleep(100 * time.Microsecond) - endRunning <- true - } - } - }() - } - } - + }() } <-endRunning }