atcoder
diff --git a/‎.codebeatsettings
Copy file name to clipboard
+8Lines changed: 8 additions & 0 deletions b/‎.codebeatsettings
Copy file name to clipboard
+8Lines changed: 8 additions & 0 deletions
diff --git a/‎controller.go
Copy file name to clipboardExpand all lines: controller.go
-1Lines changed: 0 additions & 1 deletion b/‎controller.go
Copy file name to clipboardExpand all lines: controller.go
-1Lines changed: 0 additions & 1 deletion
diff --git a/‎module.go
Copy file name to clipboardExpand all lines: module.go
+47-13Lines changed: 47 additions & 13 deletions b/‎module.go
Copy file name to clipboardExpand all lines: module.go
+47-13Lines changed: 47 additions & 13 deletions
diff --git a/‎router.go
Copy file name to clipboardExpand all lines: router.go
+6Lines changed: 6 additions & 0 deletions b/‎router.go
Copy file name to clipboardExpand all lines: router.go
+6Lines changed: 6 additions & 0 deletions
diff --git a/‎server-engine.go
Copy file name to clipboardExpand all lines: server-engine.go
+1-5Lines changed: 1 addition & 5 deletions b/‎server-engine.go
Copy file name to clipboardExpand all lines: server-engine.go
+1-5Lines changed: 1 addition & 5 deletions
@@ -0,0 +1,8 @@
+{
+  "GOLANG": {
+    "TOO_MANY_IVARS": [15, 18, 20, 25],
+    "TOO_MANY_FUNCTIONS": [20, 30, 40, 50],
+    "TOTAL_COMPLEXITY": [150, 250, 400, 500],
+    "LOC": [50, 75, 90, 120]
+  }
+}
@@ -28,7 +28,6 @@ type Controller struct {
 	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
-	module        *Module         // The module for the parent controller (if available)
 
 	Request  *Request
 	Response *Response
 
@@ -1,30 +1,49 @@
 package revel
 
 import (
+	"fmt"
+	"github.com/go-stack/stack"
+	"github.com/revel/revel/logger"
 	"go/build"
 	"path/filepath"
 	"sort"
 	"strings"
-	"github.com/revel/revel/logger"
 )
 
 // Module specific functions
 type Module struct {
 	Name, ImportPath, Path string
 	ControllerTypeList     []*ControllerType
-	Log logger.MultiLogger
+	Log                    logger.MultiLogger
+	initializedModules     map[string]ModuleCallbackInterface
 }
 
+// Modules can be called back after they are loaded in revel by using this interface.
+type ModuleCallbackInterface func(*Module)
+
 // The namespace separator constant
 const namespaceSeperator = `\` // (note cannot be . or : as this is already used for routes)
 
 var (
-	Modules      []*Module              // The list of modules in use
-	anyModule    = &Module{}            // Wildcard search for controllers for a module (for backward compatible lookups)
-	appModule    = &Module{Name: "App"} // The app module
-	moduleLogger = RevelLog.New("section", "module")
+	Modules   []*Module                                                                                     // The list of modules in use
+	anyModule = &Module{}                                                                                   // Wildcard search for controllers for a module (for backward compatible lookups)
+	appModule = &Module{Name: "App", initializedModules: map[string]ModuleCallbackInterface{}, Log: AppLog} // The app module
+	moduleLog = RevelLog.New("section", "module")
 )
 
+// Called by a module init() function, caller will receive the *Module object created for that module
+// This would be useful for assigning a logger for logging information in the module (since the module context would be correct)
+func RegisterModuleInit(callback ModuleCallbackInterface) {
+	// Store the module that called this so we can do a callback when the app is initialized
+	// The format %+k is from go-stack/Call.Format and returns the package path
+	key := fmt.Sprintf("%+k", stack.Caller(1))
+	appModule.initializedModules[key] = callback
+	if Initialized {
+		RevelLog.Error("Application already initialized, initializing using app module", "key", key)
+		callback(appModule)
+	}
+
+}
 func init() {
 	AddInitEventHandler(func(typeOf int, value interface{}) (responseOf int) {
 		if typeOf == REVEL_BEFORE_MODULES_LOADED {
@@ -117,7 +136,7 @@ func loadModules() {
 	// Reorder module order by key name, a poor mans sort but at least it is consistent
 	sort.Strings(keys)
 	for _, key := range keys {
-		moduleLogger.Debug("Sorted keys", "keys", key)
+		moduleLog.Debug("Sorted keys", "keys", key)
 
 	}
 	for _, key := range keys {
@@ -128,7 +147,7 @@ func loadModules() {
 
 		modulePath, err := ResolveImportPath(moduleImportPath)
 		if err != nil {
-			moduleLogger.Error("Failed to load module.  Import of path failed", "modulePath", moduleImportPath, "error", err)
+			moduleLog.Error("Failed to load module.  Import of path failed", "modulePath", moduleImportPath, "error", err)
 		}
 		// Drop anything between module.???.<name of module>
 		subKey := key[len("module."):]
@@ -137,32 +156,47 @@ func loadModules() {
 		}
 		addModule(subKey, moduleImportPath, modulePath)
 	}
+
+	// Modules loaded, now show module path
+	for key, callback := range appModule.initializedModules {
+		found := false
+		for _, m := range Modules {
+			if strings.HasPrefix(key, m.ImportPath) {
+				moduleLog.Debug("Module called callback", "moduleKey", m.ImportPath, "callbackKey", key)
+				callback(m)
+			}
+		}
+		if !found {
+			RevelLog.Error("Callback for non registered module initializing with application module","modulePath",key)
+			callback(appModule)
+		}
+	}
 }
 
 //
 func addModule(name, importPath, modulePath string) {
 	if _, found := ModuleByName(name); found {
-		moduleLogger.Panic("Attempt to import duplicate module %s path %s aborting startup", "name", name, "path", modulePath)
+		moduleLog.Panic("Attempt to import duplicate module %s path %s aborting startup", "name", name, "path", modulePath)
 	}
-	Modules = append(Modules, &Module{Name: name, ImportPath: importPath, Path: modulePath, Log:AppLog.New("module", name)})
+	Modules = append(Modules, &Module{Name: name, ImportPath: importPath, Path: modulePath, Log: RootLog.New("module", name)})
 	if codePath := filepath.Join(modulePath, "app"); DirExists(codePath) {
 		CodePaths = append(CodePaths, codePath)
 		if viewsPath := filepath.Join(modulePath, "app", "views"); DirExists(viewsPath) {
 			TemplatePaths = append(TemplatePaths, viewsPath)
 		}
 	}
 
-	moduleLogger.Debug("Loaded module ", "module", filepath.Base(modulePath))
+	moduleLog.Debug("Loaded module ", "module", filepath.Base(modulePath))
 
 	// Hack: There is presently no way for the testrunner module to add the
 	// "test" subdirectory to the CodePaths.  So this does it instead.
 	if importPath == Config.StringDefault("module.testrunner", "github.com/revel/modules/testrunner") {
 		joinedPath := filepath.Join(BasePath, "tests")
-		moduleLogger.Debug("Found testrunner module, adding `tests` path ", "path", joinedPath)
+		moduleLog.Debug("Found testrunner module, adding `tests` path ", "path", joinedPath)
 		CodePaths = append(CodePaths, joinedPath)
 	}
 	if testsPath := filepath.Join(modulePath, "tests"); DirExists(testsPath) {
-		moduleLogger.Debug("Found tests path ", "path", testsPath)
+		moduleLog.Debug("Found tests path ", "path", testsPath)
 		CodePaths = append(CodePaths, testsPath)
 	}
 }
@@ -749,6 +749,12 @@ func RouterFilter(c *Controller, fc []Filter) {
 
 	// Add the route and fixed params to the Request Params.
 	c.Params.Route = route.Params
+	// Assign logger if from module
+	if c.Type.ModuleSource!=nil && c.Type.ModuleSource!=appModule {
+		c.Log = c.Type.ModuleSource.Log.New("ip", c.ClientIP,
+			"path", c.Request.URL.Path, "method", c.Request.Method)
+	}
+
 
 	// Add the fixed parameters mapped by name.
 	// TODO: Pre-calculate this mapping.
 
@@ -139,11 +139,7 @@ func handleInternal(ctx ServerContext) {
 	}()
 
 	c.ClientIP = clientIP
-	controllerLog := AppLog
-	if c.module!=nil {
-		controllerLog = c.module.Log
-	}
-	c.Log = controllerLog.New("ip", clientIP,
+	c.Log = AppLog.New("ip", clientIP,
 		"path", req.GetPath(), "method", req.Method)
 	// Call the first filter, this will process the request
 	Filters[0](c, Filters[1:])