--- /dev/null
+// Copyright (c) 2012-2016 The Revel Framework Authors, All rights reserved.
+// Revel Framework source code and usage is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package revel
+
+import (
+ "errors"
+ "fmt"
+ "io"
+ "net/http"
+ "os"
+ "path/filepath"
+ "reflect"
+ "runtime"
+ "strings"
+ "time"
+
+ "github.com/revel/revel/logger"
+ "github.com/revel/revel/session"
+ "github.com/revel/revel/utils"
+)
+
+// Controller Revel's controller structure that gets embedded in user defined
+// controllers
+type Controller struct {
+ Name string // The controller name, e.g. "Application"
+ Type *ControllerType // A description of the controller type.
+ MethodName string // The method name, e.g. "Index"
+ MethodType *MethodType // A description of the invoked action type.
+ AppController interface{} // The controller that was instantiated. embeds revel.Controller
+ Action string // The fully qualified action name, e.g. "App.Index"
+ ClientIP string // holds IP address of request came from
+
+ Request *Request
+ Response *Response
+ Result Result
+
+ Flash Flash // User cookie, cleared after 1 request.
+ Session session.Session // Session, stored using the session engine specified
+ Params *Params // Parameters from URL and form (including multipart).
+ Args map[string]interface{} // Per-request scratch space.
+ ViewArgs map[string]interface{} // Variables passed to the template.
+ Validation *Validation // Data validation helpers
+ Log logger.MultiLogger // Context Logger
+}
+
+// The map of controllers, controllers are mapped by using the namespace|controller_name as the key
+var controllers = make(map[string]*ControllerType)
+var controllerLog = RevelLog.New("section", "controller")
+
+// NewController returns new controller instance for Request and Response
+func NewControllerEmpty() *Controller {
+ return &Controller{Request: NewRequest(nil), Response: NewResponse(nil)}
+}
+
+// New controller, creates a new instance wrapping the request and response in it
+func NewController(context ServerContext) *Controller {
+ c := NewControllerEmpty()
+ c.SetController(context)
+ return c
+}
+
+// Sets the request and the response for the controller
+func (c *Controller) SetController(context ServerContext) {
+
+ c.Request.SetRequest(context.GetRequest())
+ c.Response.SetResponse(context.GetResponse())
+ c.Request.controller = c
+ c.Params = new(Params)
+ c.Args = map[string]interface{}{}
+ c.ViewArgs = map[string]interface{}{
+ "RunMode": RunMode,
+ "DevMode": DevMode,
+ }
+
+}
+func (c *Controller) Destroy() {
+ // When the instantiated controller gets injected
+ // It inherits this method, so we need to
+ // check to see if the controller is nil before performing
+ // any actions
+ if c == nil {
+ return
+ }
+ if c.AppController != nil {
+ c.resetAppControllerFields()
+ // Return this instance to the pool
+ appController := c.AppController
+ c.AppController = nil
+ if RevelConfig.Controller.Reuse {
+ RevelConfig.Controller.CachedMap[c.Name].Push(appController)
+ }
+ c.AppController = nil
+ }
+
+ c.Request.Destroy()
+ c.Response.Destroy()
+ c.Params = nil
+ c.Args = nil
+ c.ViewArgs = nil
+ c.Name = ""
+ c.Type = nil
+ c.MethodName = ""
+ c.MethodType = nil
+ c.Action = ""
+ c.ClientIP = ""
+ c.Result = nil
+ c.Flash = Flash{}
+ c.Session = session.NewSession()
+ c.Params = nil
+ c.Validation = nil
+ c.Log = nil
+}
+
+// FlashParams serializes the contents of Controller.Params to the Flash
+// cookie.
+func (c *Controller) FlashParams() {
+ for key, vals := range c.Params.Values {
+ c.Flash.Out[key] = strings.Join(vals, ",")
+ }
+}
+
+func (c *Controller) SetCookie(cookie *http.Cookie) {
+ c.Response.Out.internalHeader.SetCookie(cookie.String())
+}
+
+type ErrorCoder interface {
+ HTTPCode() int
+}
+
+func (c *Controller) RenderError(err error) Result {
+ if coder, ok := err.(ErrorCoder); ok {
+ c.setStatusIfNil(coder.HTTPCode())
+ } else {
+ c.setStatusIfNil(http.StatusInternalServerError)
+ }
+
+ return ErrorResult{c.ViewArgs, err}
+}
+
+func (c *Controller) setStatusIfNil(status int) {
+ if c.Response.Status == 0 {
+ c.Response.Status = status
+ }
+}
+
+// Render a template corresponding to the calling Controller method.
+// Arguments will be added to c.ViewArgs prior to rendering the template.
+// They are keyed on their local identifier.
+//
+// For example:
+//
+// func (c Users) ShowUser(id int) revel.Result {
+// user := loadUser(id)
+// return c.Render(user)
+// }
+//
+// This action will render views/Users/ShowUser.html, passing in an extra
+// key-value "user": (User).
+//
+// This is the slower magical version which uses the runtime
+// to determine
+// 1) Set c.ViewArgs to the arguments passed into this function
+// 2) How to call the RenderTemplate by building the following line
+// c.RenderTemplate(c.Name + "/" + c.MethodType.Name + "." + c.Request.Format)
+//
+// If you want your code to run faster it is recommended you add the template values directly
+// to the c.ViewArgs and call c.RenderTemplate directly
+func (c *Controller) Render(extraViewArgs ...interface{}) Result {
+ c.setStatusIfNil(http.StatusOK)
+
+ // Get the calling function line number.
+ _, _, line, ok := runtime.Caller(1)
+ if !ok {
+ controllerLog.Error("Render: Failed to get Caller information")
+ }
+
+ // Get the extra ViewArgs passed in.
+ if renderArgNames, ok := c.MethodType.RenderArgNames[line]; ok {
+ if len(renderArgNames) == len(extraViewArgs) {
+ for i, extraRenderArg := range extraViewArgs {
+ c.ViewArgs[renderArgNames[i]] = extraRenderArg
+ }
+ } else {
+ controllerLog.Error(fmt.Sprint(len(renderArgNames), "RenderArg names found for",
+ len(extraViewArgs), "extra ViewArgs"))
+ }
+ } else {
+ controllerLog.Error(fmt.Sprint("No RenderArg names found for Render call on line", line,
+ "(Action", c.Action, ")"),"stack",logger.NewCallStack())
+ }
+
+ return c.RenderTemplate(c.Name + "/" + c.MethodType.Name + "." + c.Request.Format)
+}
+
+// RenderTemplate method does less magical way to render a template.
+// Renders the given template, using the current ViewArgs.
+func (c *Controller) RenderTemplate(templatePath string) Result {
+ c.setStatusIfNil(http.StatusOK)
+
+ // Get the Template.
+ lang, _ := c.ViewArgs[CurrentLocaleViewArg].(string)
+ template, err := MainTemplateLoader.TemplateLang(templatePath, lang)
+ if err != nil {
+ return c.RenderError(err)
+ }
+
+ return &RenderTemplateResult{
+ Template: template,
+ ViewArgs: c.ViewArgs,
+ }
+}
+
+// TemplateOutput returns the result of the template rendered using the controllers ViewArgs.
+func (c *Controller) TemplateOutput(templatePath string) (data []byte, err error) {
+ return TemplateOutputArgs(templatePath, c.ViewArgs)
+}
+
+// RenderJSON uses encoding/json.Marshal to return JSON to the client.
+func (c *Controller) RenderJSON(o interface{}) Result {
+ c.setStatusIfNil(http.StatusOK)
+
+ return RenderJSONResult{o, ""}
+}
+
+// RenderJSONP renders JSONP result using encoding/json.Marshal
+func (c *Controller) RenderJSONP(callback string, o interface{}) Result {
+ c.setStatusIfNil(http.StatusOK)
+
+ return RenderJSONResult{o, callback}
+}
+
+// RenderXML uses encoding/xml.Marshal to return XML to the client.
+func (c *Controller) RenderXML(o interface{}) Result {
+ c.setStatusIfNil(http.StatusOK)
+
+ return RenderXMLResult{o}
+}
+
+// RenderText renders plaintext in response, printf style.
+func (c *Controller) RenderText(text string, objs ...interface{}) Result {
+ c.setStatusIfNil(http.StatusOK)
+
+ finalText := text
+ if len(objs) > 0 {
+ finalText = fmt.Sprintf(text, objs...)
+ }
+ return &RenderTextResult{finalText}
+}
+
+// RenderHTML renders html in response
+func (c *Controller) RenderHTML(html string) Result {
+ c.setStatusIfNil(http.StatusOK)
+
+ return &RenderHTMLResult{html}
+}
+
+// Todo returns an HTTP 501 Not Implemented "todo" indicating that the
+// action isn't done yet.
+func (c *Controller) Todo() Result {
+ c.Response.Status = http.StatusNotImplemented
+ controllerLog.Debug("Todo: Not implemented function", "action", c.Action)
+ return c.RenderError(&Error{
+ Title: "TODO",
+ Description: "This action is not implemented",
+ })
+}
+
+// NotFound returns an HTTP 404 Not Found response whose body is the
+// formatted string of msg and objs.
+func (c *Controller) NotFound(msg string, objs ...interface{}) Result {
+ finalText := msg
+ if len(objs) > 0 {
+ finalText = fmt.Sprintf(msg, objs...)
+ }
+ c.Response.Status = http.StatusNotFound
+ return c.RenderError(&Error{
+ Title: "Not Found",
+ Description: finalText,
+ })
+}
+
+// Forbidden returns an HTTP 403 Forbidden response whose body is the
+// formatted string of msg and objs.
+func (c *Controller) Forbidden(msg string, objs ...interface{}) Result {
+ finalText := msg
+ if len(objs) > 0 {
+ finalText = fmt.Sprintf(msg, objs...)
+ }
+ c.Response.Status = http.StatusForbidden
+ return c.RenderError(&Error{
+ Title: "Forbidden",
+ Description: finalText,
+ })
+}
+
+// RenderFileName returns a file indicated by the path as provided via the filename.
+// It can be either displayed inline or downloaded as an attachment.
+// The name and size are taken from the file info.
+func (c *Controller) RenderFileName(filename string, delivery ContentDisposition) Result {
+ f, err := os.Open(filename)
+ if err != nil {
+ c.Log.Errorf("Cant open file: %v", err)
+ return c.RenderError(err)
+ }
+ return c.RenderFile(f, delivery)
+}
+
+// RenderFile returns a file, either displayed inline or downloaded
+// as an attachment. The name and size are taken from the file info.
+func (c *Controller) RenderFile(file *os.File, delivery ContentDisposition) Result {
+ c.setStatusIfNil(http.StatusOK)
+
+ var (
+ modtime = time.Now()
+ fileInfo, err = file.Stat()
+ )
+ if err != nil {
+ controllerLog.Error("RenderFile: error", "error", err)
+ }
+ if fileInfo != nil {
+ modtime = fileInfo.ModTime()
+ }
+ return c.RenderBinary(file, filepath.Base(file.Name()), delivery, modtime)
+}
+
+// RenderBinary is like RenderFile() except that it instead of a file on disk,
+// it renders data from memory (which could be a file that has not been written,
+// the output from some function, or bytes streamed from somewhere else, as long
+// it implements io.Reader). When called directly on something generated or
+// streamed, modtime should mostly likely be time.Now().
+func (c *Controller) RenderBinary(memfile io.Reader, filename string, delivery ContentDisposition, modtime time.Time) Result {
+ c.setStatusIfNil(http.StatusOK)
+
+ return &BinaryResult{
+ Reader: memfile,
+ Name: filename,
+ Delivery: delivery,
+ Length: -1, // http.ServeContent gets the length itself unless memfile is a stream.
+ ModTime: modtime,
+ }
+}
+
+// Redirect to an action or to a URL.
+// c.Redirect(Controller.Action)
+// c.Redirect("/controller/action")
+// c.Redirect("/controller/%d/action", id)
+func (c *Controller) Redirect(val interface{}, args ...interface{}) Result {
+ c.setStatusIfNil(http.StatusFound)
+
+ if url, ok := val.(string); ok {
+ if len(args) == 0 {
+ return &RedirectToURLResult{url}
+ }
+ return &RedirectToURLResult{fmt.Sprintf(url, args...)}
+ }
+ return &RedirectToActionResult{val, args}
+}
+
+// This stats returns some interesting stats based on what is cached in memory
+// and what is available directly
+func (c *Controller) Stats() map[string]interface{} {
+ result := CurrentEngine.Stats()
+ if RevelConfig.Controller.Reuse {
+ result["revel-controllers"] = RevelConfig.Controller.Stack.String()
+ for key, appStack := range RevelConfig.Controller.CachedMap {
+ result["app-" + key] = appStack.String()
+ }
+ }
+ return result
+}
+
+// Message performs a lookup for the given message name using the given
+// arguments using the current language defined for this controller.
+//
+// The current language is set by the i18n plugin.
+func (c *Controller) Message(message string, args ...interface{}) string {
+ return MessageFunc(c.Request.Locale, message, args...)
+}
+
+// SetAction sets the action that is being invoked in the current request.
+// It sets the following properties: Name, Action, Type, MethodType
+func (c *Controller) SetAction(controllerName, methodName string) error {
+
+ return c.SetTypeAction(controllerName, methodName, nil)
+}
+
+// SetAction sets the assigns the Controller type, sets the action and initializes the controller
+func (c *Controller) SetTypeAction(controllerName, methodName string, typeOfController *ControllerType) error {
+
+ // Look up the controller and method types.
+ if typeOfController == nil {
+ if c.Type = ControllerTypeByName(controllerName, anyModule); c.Type == nil {
+ return errors.New("revel/controller: failed to find controller " + controllerName)
+ }
+ } else {
+ c.Type = typeOfController
+ }
+
+ // Note method name is case insensitive search
+ if c.MethodType = c.Type.Method(methodName); c.MethodType == nil {
+ return errors.New("revel/controller: failed to find action " + controllerName + "." + methodName)
+ }
+
+ c.Name, c.MethodName = c.Type.Type.Name(), c.MethodType.Name
+ c.Action = c.Name + "." + c.MethodName
+
+ // Update Logger with controller and namespace
+ if c.Log != nil {
+ c.Log = c.Log.New("action", c.Action, "namespace", c.Type.Namespace)
+ }
+
+ if RevelConfig.Controller.Reuse {
+ if _, ok := RevelConfig.Controller.CachedMap[c.Name]; !ok {
+ // Create a new stack for this controller
+ localType := c.Type.Type
+ RevelConfig.Controller.CachedMap[c.Name] = utils.NewStackLock(
+ RevelConfig.Controller.CachedStackSize,
+ RevelConfig.Controller.CachedStackMaxSize,
+ func() interface{} {
+ return reflect.New(localType).Interface()
+ })
+ }
+ // Instantiate the controller.
+ c.AppController = RevelConfig.Controller.CachedMap[c.Name].Pop()
+ } else {
+ c.AppController = reflect.New(c.Type.Type).Interface()
+ }
+ c.setAppControllerFields()
+
+ return nil
+}
+
+func ControllerTypeByName(controllerName string, moduleSource *Module) (c *ControllerType) {
+ var found bool
+ if c, found = controllers[controllerName]; !found {
+ // Backup, passed in controllerName should be in lower case, but may not be
+ if c, found = controllers[strings.ToLower(controllerName)]; !found {
+ controllerLog.Debug("ControllerTypeByName: Cannot find controller in controllers map ", "controller", controllerName)
+ // Search for the controller by name
+ for _, cType := range controllers {
+ testControllerName := strings.ToLower(cType.Type.Name())
+ if testControllerName == strings.ToLower(controllerName) && (cType.ModuleSource == moduleSource || moduleSource == anyModule) {
+ controllerLog.Warn("ControllerTypeByName: Matched empty namespace controller ", "controller", controllerName, "namespace", cType.ModuleSource.Name)
+ c = cType
+ found = true
+ break
+ }
+ }
+ }
+ }
+ return
+}
+
+// Injects this instance (c) into the AppController instance
+func (c *Controller) setAppControllerFields() {
+ appController := reflect.ValueOf(c.AppController).Elem()
+ cValue := reflect.ValueOf(c)
+ for _, index := range c.Type.ControllerIndexes {
+ appController.FieldByIndex(index).Set(cValue)
+ }
+}
+
+// Removes this instance (c) from the AppController instance
+func (c *Controller) resetAppControllerFields() {
+ appController := reflect.ValueOf(c.AppController).Elem()
+ // Zero out controller
+ for _, index := range c.Type.ControllerIndexes {
+ appController.FieldByIndex(index).Set(reflect.Zero(reflect.TypeOf(c.AppController).Elem().FieldByIndex(index).Type))
+ }
+}
+
+func findControllers(appControllerType reflect.Type) (indexes [][]int) {
+ // It might be a multi-level embedding. To find the controllers, we follow
+ // every anonymous field, using breadth-first search.
+ type nodeType struct {
+ val reflect.Value
+ index []int
+ }
+ appControllerPtr := reflect.New(appControllerType)
+ queue := []nodeType{{appControllerPtr, []int{}}}
+ for len(queue) > 0 {
+ // Get the next value and de-reference it if necessary.
+ var (
+ node = queue[0]
+ elem = node.val
+ elemType = elem.Type()
+ )
+ if elemType.Kind() == reflect.Ptr {
+ elem = elem.Elem()
+ elemType = elem.Type()
+ }
+ queue = queue[1:]
+
+ // #944 if the type's Kind is not `Struct` move on,
+ // otherwise `elem.NumField()` will panic
+ if elemType.Kind() != reflect.Struct {
+ continue
+ }
+
+ // Look at all the struct fields.
+ for i := 0; i < elem.NumField(); i++ {
+ // If this is not an anonymous field, skip it.
+ structField := elemType.Field(i)
+ if !structField.Anonymous {
+ continue
+ }
+
+ fieldValue := elem.Field(i)
+ fieldType := structField.Type
+
+ // If it's a Controller, record the field indexes to get here.
+ if fieldType == controllerPtrType {
+ indexes = append(indexes, append(node.index, i))
+ continue
+ }
+
+ queue = append(queue,
+ nodeType{fieldValue, append(append([]int{}, node.index...), i)})
+ }
+ }
+ return
+}
+
+// RegisterController registers a Controller and its Methods with Revel.
+func RegisterController(c interface{}, methods []*MethodType) {
+ // De-star the controller type
+ // (e.g. given TypeOf((*Application)(nil)), want TypeOf(Application))
+ elem := reflect.TypeOf(c).Elem()
+
+ // De-star all of the method arg types too.
+ for _, m := range methods {
+ m.lowerName = strings.ToLower(m.Name)
+ for _, arg := range m.Args {
+ arg.Type = arg.Type.Elem()
+ }
+ }
+
+ // Fetch module for controller, if none found controller must be part of the app
+ controllerModule := ModuleFromPath(elem.PkgPath(), true)
+
+ controllerType := AddControllerType(controllerModule, elem, methods)
+
+ controllerLog.Debug("RegisterController:Registered controller", "controller", controllerType.Name())
+}
Code Review / iec.git / blobdiff