Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "(", "h", "*", "RevelHeader", ")", "Set", "(", "key", ",", "value", "string", ")", "{", "if", "h", ".", "Server", "!=", "nil", "{", "h", ".", "Server", ".", "Set", "(", "key", ",", "value", ")", "\n", "}", "\n", "}" ]

[ "Set", "a", "value", "in", "the", "header" ]

[ "func", "(", "h", "*", "RevelHeader", ")", "Add", "(", "key", ",", "value", "string", ")", "{", "if", "h", ".", "Server", "!=", "nil", "{", "h", ".", "Server", ".", "Add", "(", "key", ",", "value", ")", "\n", "}", "\n", "}" ]

[ "Add", "a", "key", "to", "the", "header" ]

[ "func", "(", "h", "*", "RevelHeader", ")", "SetCookie", "(", "cookie", "string", ")", "{", "if", "h", ".", "Server", "!=", "nil", "{", "h", ".", "Server", ".", "SetCookie", "(", "cookie", ")", "\n", "}", "\n", "}" ]

[ "Set", "a", "cookie", "in", "the", "header" ]

[ "func", "(", "h", "*", "RevelHeader", ")", "SetStatus", "(", "status", "int", ")", "{", "if", "h", ".", "Server", "!=", "nil", "{", "h", ".", "Server", ".", "SetStatus", "(", "status", ")", "\n", "}", "\n", "}" ]

[ "Set", "the", "status", "for", "the", "header" ]

[ "func", "(", "h", "*", "RevelHeader", ")", "Get", "(", "key", "string", ")", "(", "value", "string", ")", "{", "values", ":=", "h", ".", "GetAll", "(", "key", ")", "\n", "if", "len", "(", "values", ")", ">", "0", "{", "value", "=", "values", "[", "0", "]", "\n", "}", "\n", "return", "\n", "}" ]

[ "Get", "a", "key", "from", "the", "header" ]

[ "func", "(", "conf", "FilterConfigurator", ")", "Remove", "(", "target", "Filter", ")", "FilterConfigurator", "{", "conf", ".", "apply", "(", "func", "(", "fc", "[", "]", "Filter", ")", "[", "]", "Filter", "{", "return", "conf", ".", "rmFilter", "(", "target", ",", "fc", ")", "\n", "}", ")", "\n", "return", "conf", "\n", "}" ]

[ "Remove", "a", "filter", "from", "the", "filter", "chain", "." ]

[ "func", "(", "conf", "FilterConfigurator", ")", "getChain", "(", ")", "[", "]", "Filter", "{", "var", "filters", "[", "]", "Filter", "\n", "if", "filters", "=", "getOverrideChain", "(", "conf", ".", "controllerName", ",", "conf", ".", "key", ")", ";", "filters", "==", "nil", "{", "// The override starts with all filters after FilterConfiguringFilter", "for", "i", ",", "f", ":=", "range", "Filters", "{", "if", "FilterEq", "(", "f", ",", "FilterConfiguringFilter", ")", "{", "filters", "=", "make", "(", "[", "]", "Filter", ",", "len", "(", "Filters", ")", "-", "i", "-", "1", ")", "\n", "copy", "(", "filters", ",", "Filters", "[", "i", "+", "1", ":", "]", ")", "\n", "break", "\n", "}", "\n", "}", "\n", "if", "filters", "==", "nil", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "return", "filters", "\n", "}" ]

[ "getChain", "returns", "the", "filter", "chain", "that", "applies", "to", "the", "given", "controller", "or", "action", ".", "If", "no", "overrides", "are", "configured", "then", "a", "copy", "of", "the", "default", "filter", "chain", "is", "returned", "." ]

[ "func", "(", "conf", "FilterConfigurator", ")", "apply", "(", "f", "func", "(", "[", "]", "Filter", ")", "[", "]", "Filter", ")", "{", "// Updates any actions that have had their filters overridden, if this is a", "// Controller configurator.", "if", "conf", ".", "controllerName", "==", "conf", ".", "key", "{", "for", "k", ",", "v", ":=", "range", "filterOverrides", "{", "if", "strings", ".", "HasPrefix", "(", "k", ",", "conf", ".", "controllerName", "+", "\"", "\"", ")", "{", "filterOverrides", "[", "k", "]", "=", "f", "(", "v", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "// Update the Controller or Action overrides.", "filterOverrides", "[", "conf", ".", "key", "]", "=", "f", "(", "conf", ".", "getChain", "(", ")", ")", "\n", "}" ]

[ "apply", "applies", "the", "given", "functional", "change", "to", "the", "filter", "overrides", ".", "No", "other", "function", "modifies", "the", "filterOverrides", "map", "." ]

[ "func", "FilterEq", "(", "a", ",", "b", "Filter", ")", "bool", "{", "return", "reflect", ".", "ValueOf", "(", "a", ")", ".", "Pointer", "(", ")", "==", "reflect", ".", "ValueOf", "(", "b", ")", ".", "Pointer", "(", ")", "\n", "}" ]

[ "FilterEq", "returns", "true", "if", "the", "two", "filters", "reference", "the", "same", "filter", "." ]

[ "func", "FilterConfiguringFilter", "(", "c", "*", "Controller", ",", "fc", "[", "]", "Filter", ")", "{", "if", "newChain", ":=", "getOverrideChain", "(", "c", ".", "Name", ",", "c", ".", "Action", ")", ";", "newChain", "!=", "nil", "{", "newChain", "[", "0", "]", "(", "c", ",", "newChain", "[", "1", ":", "]", ")", "\n", "return", "\n", "}", "\n", "fc", "[", "0", "]", "(", "c", ",", "fc", "[", "1", ":", "]", ")", "\n", "}" ]

[ "FilterConfiguringFilter", "is", "a", "filter", "stage", "that", "customizes", "the", "remaining", "filter", "chain", "for", "the", "action", "being", "invoked", "." ]

[ "func", "getOverrideChain", "(", "controllerName", ",", "action", "string", ")", "[", "]", "Filter", "{", "if", "newChain", ",", "ok", ":=", "filterOverrides", "[", "action", "]", ";", "ok", "{", "return", "newChain", "\n", "}", "\n", "if", "newChain", ",", "ok", ":=", "filterOverrides", "[", "controllerName", "]", ";", "ok", "{", "return", "newChain", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "getOverrideChain", "retrieves", "the", "overrides", "for", "the", "action", "that", "is", "set" ]

[ "func", "(", "h", "LevelFilterHandler", ")", "Log", "(", "r", "*", "Record", ")", "error", "{", "if", "r", ".", "Level", "==", "h", ".", "Level", "{", "return", "h", ".", "h", ".", "Log", "(", "r", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "The", "implementation", "of", "the", "Log" ]

[ "func", "MinLevelHandler", "(", "lvl", "LogLevel", ",", "h", "LogHandler", ")", "LogHandler", "{", "return", "FilterHandler", "(", "func", "(", "r", "*", "Record", ")", "(", "pass", "bool", ")", "{", "return", "r", ".", "Level", "<=", "lvl", "\n", "}", ",", "h", ")", "\n", "}" ]

[ "Filters", "out", "records", "which", "do", "not", "match", "the", "level", "Uses", "the", "log15", ".", "FilterHandler", "to", "perform", "this", "task" ]

[ "func", "MatchHandler", "(", "key", "string", ",", "value", "interface", "{", "}", ",", "h", "LogHandler", ")", "LogHandler", "{", "return", "MatchFilterHandler", "(", "key", ",", "value", ",", "h", ")", "\n", "}" ]

[ "Filters", "out", "records", "which", "match", "the", "key", "value", "pair", "Uses", "the", "log15", ".", "MatchFilterHandler", "to", "perform", "this", "task" ]

[ "func", "MatchAbHandler", "(", "key", "string", ",", "value", "interface", "{", "}", ",", "a", ",", "b", "LogHandler", ")", "LogHandler", "{", "return", "FuncHandler", "(", "func", "(", "r", "*", "Record", ")", "error", "{", "if", "r", ".", "Context", "[", "key", "]", "==", "value", "{", "return", "a", ".", "Log", "(", "r", ")", "\n", "}", "else", "if", "b", "!=", "nil", "{", "return", "b", ".", "Log", "(", "r", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}", ")", "\n", "}" ]

[ "If", "match", "then", "A", "handler", "is", "called", "otherwise", "B", "handler", "is", "called" ]

[ "func", "MatchMapHandler", "(", "matchMap", "map", "[", "string", "]", "interface", "{", "}", ",", "a", "LogHandler", ")", "LogHandler", "{", "return", "matchMapHandler", "(", "matchMap", ",", "false", ",", "a", ")", "\n", "}" ]

[ "Match", "all", "values", "in", "map", "to", "log" ]

[ "func", "matchMapHandler", "(", "matchMap", "map", "[", "string", "]", "interface", "{", "}", ",", "inverse", "bool", ",", "a", "LogHandler", ")", "LogHandler", "{", "return", "FuncHandler", "(", "func", "(", "r", "*", "Record", ")", "error", "{", "matchCount", ":=", "0", "\n", "for", "k", ",", "v", ":=", "range", "matchMap", "{", "value", ",", "found", ":=", "r", ".", "Context", "[", "k", "]", "\n", "if", "!", "found", "{", "return", "nil", "\n", "}", "\n", "// Test for two failure cases", "if", "value", "==", "v", "&&", "inverse", "||", "value", "!=", "v", "&&", "!", "inverse", "{", "return", "nil", "\n", "}", "else", "{", "matchCount", "++", "\n", "}", "\n", "}", "\n", "if", "matchCount", "!=", "len", "(", "matchMap", ")", "{", "return", "nil", "\n", "}", "\n", "return", "a", ".", "Log", "(", "r", ")", "\n", "}", ")", "\n", "}" ]

[ "Rather", "then", "chaining", "multiple", "filter", "handlers", "process", "all", "here" ]

[ "func", "NotMatchHandler", "(", "key", "string", ",", "value", "interface", "{", "}", ",", "h", "LogHandler", ")", "LogHandler", "{", "return", "FilterHandler", "(", "func", "(", "r", "*", "Record", ")", "(", "pass", "bool", ")", "{", "return", "r", ".", "Context", "[", "key", "]", "!=", "value", "\n", "}", ",", "h", ")", "\n", "}" ]

[ "Filters", "out", "records", "which", "do", "not", "match", "the", "key", "value", "pair", "Uses", "the", "log15", ".", "FilterHandler", "to", "perform", "this", "task" ]

[ "func", "StreamHandler", "(", "wr", "io", ".", "Writer", ",", "fmtr", "LogFormat", ")", "LogHandler", "{", "h", ":=", "FuncHandler", "(", "func", "(", "r", "*", "Record", ")", "error", "{", "_", ",", "err", ":=", "wr", ".", "Write", "(", "fmtr", ".", "Format", "(", "r", ")", ")", "\n", "return", "err", "\n", "}", ")", "\n", "return", "LazyHandler", "(", "SyncHandler", "(", "h", ")", ")", "\n", "}" ]

[ "StreamHandler", "writes", "log", "records", "to", "an", "io", ".", "Writer", "with", "the", "given", "format", ".", "StreamHandler", "can", "be", "used", "to", "easily", "begin", "writing", "log", "records", "to", "other", "outputs", ".", "StreamHandler", "wraps", "itself", "with", "LazyHandler", "and", "SyncHandler", "to", "evaluate", "Lazy", "objects", "and", "perform", "safe", "concurrent", "writes", "." ]

[ "func", "NewListLogHandler", "(", "h1", ",", "h2", "LogHandler", ")", "*", "ListLogHandler", "{", "ll", ":=", "&", "ListLogHandler", "{", "handlers", ":", "[", "]", "LogHandler", "{", "h1", ",", "h2", "}", "}", "\n", "return", "ll", "\n", "}" ]

[ "Create", "a", "new", "list", "of", "log", "handlers" ]

[ "func", "(", "ll", "*", "ListLogHandler", ")", "Log", "(", "r", "*", "Record", ")", "(", "err", "error", ")", "{", "for", "_", ",", "handler", ":=", "range", "ll", ".", "handlers", "{", "if", "err", "==", "nil", "{", "err", "=", "handler", ".", "Log", "(", "r", ")", "\n", "}", "else", "{", "handler", ".", "Log", "(", "r", ")", "\n", "}", "\n", "}", "\n", "return", "\n", "}" ]

[ "Log", "the", "record" ]

[ "func", "(", "ll", "*", "ListLogHandler", ")", "Add", "(", "h", "LogHandler", ")", "{", "if", "h", "!=", "nil", "{", "ll", ".", "handlers", "=", "append", "(", "ll", ".", "handlers", ",", "h", ")", "\n", "}", "\n", "}" ]

[ "Add", "another", "log", "handler" ]

[ "func", "(", "ll", "*", "ListLogHandler", ")", "Del", "(", "h", "LogHandler", ")", "{", "if", "h", "!=", "nil", "{", "for", "i", ",", "handler", ":=", "range", "ll", ".", "handlers", "{", "if", "handler", "==", "h", "{", "ll", ".", "handlers", "=", "append", "(", "ll", ".", "handlers", "[", ":", "i", "]", ",", "ll", ".", "handlers", "[", "i", "+", "1", ":", "]", "...", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}" ]

[ "Remove", "a", "log", "handler" ]

[ "func", "(", "r", "*", "ValidationResult", ")", "Key", "(", "key", "string", ")", "*", "ValidationResult", "{", "if", "r", ".", "Error", "!=", "nil", "{", "r", ".", "Error", ".", "Key", "=", "key", "\n", "}", "\n", "return", "r", "\n", "}" ]

[ "Key", "sets", "the", "ValidationResult", "s", "Error", "key", "and", "returns", "itself", "for", "chaining" ]

[ "func", "(", "r", "*", "ValidationResult", ")", "MessageKey", "(", "message", "string", ",", "args", "...", "interface", "{", "}", ")", "*", "ValidationResult", "{", "if", "r", ".", "Error", "==", "nil", "{", "return", "r", "\n", "}", "\n\n", "// If translator found, use that to create the message, otherwise call Message method", "if", "r", ".", "Translator", "!=", "nil", "{", "r", ".", "Error", ".", "Message", "=", "r", ".", "Translator", "(", "r", ".", "Locale", ",", "message", ",", "args", "...", ")", "\n", "}", "else", "{", "r", ".", "Message", "(", "message", ",", "args", "...", ")", "\n", "}", "\n\n", "return", "r", "\n", "}" ]

[ "Allow", "a", "message", "key", "to", "be", "passed", "into", "the", "validation", "result", ".", "The", "Validation", "has", "already", "setup", "the", "translator", "to", "translate", "the", "message", "key" ]

[ "func", "(", "v", "*", "Validation", ")", "Check", "(", "obj", "interface", "{", "}", ",", "checks", "...", "Validator", ")", "*", "ValidationResult", "{", "var", "result", "*", "ValidationResult", "\n", "for", "_", ",", "check", ":=", "range", "checks", "{", "result", "=", "v", ".", "apply", "(", "check", ",", "obj", ")", "\n", "if", "!", "result", ".", "Ok", "{", "return", "result", "\n", "}", "\n", "}", "\n", "return", "result", "\n", "}" ]

[ "Check", "applies", "a", "group", "of", "validators", "to", "a", "field", "in", "order", "and", "return", "the", "ValidationResult", "from", "the", "first", "one", "that", "fails", "or", "the", "last", "one", "that", "succeeds", "." ]

[ "func", "ValidationFilter", "(", "c", "*", "Controller", ",", "fc", "[", "]", "Filter", ")", "{", "// If json request, we shall assume json response is intended,", "// as such no validation cookies should be tied response", "if", "c", ".", "Params", "!=", "nil", "&&", "c", ".", "Params", ".", "JSON", "!=", "nil", "{", "c", ".", "Validation", "=", "&", "Validation", "{", "Request", ":", "c", ".", "Request", ",", "Translator", ":", "MessageFunc", "}", "\n", "fc", "[", "0", "]", "(", "c", ",", "fc", "[", "1", ":", "]", ")", "\n", "}", "else", "{", "errors", ",", "err", ":=", "restoreValidationErrors", "(", "c", ".", "Request", ")", "\n", "c", ".", "Validation", "=", "&", "Validation", "{", "Errors", ":", "errors", ",", "keep", ":", "false", ",", "Request", ":", "c", ".", "Request", ",", "Translator", ":", "MessageFunc", ",", "}", "\n", "hasCookie", ":=", "(", "err", "!=", "http", ".", "ErrNoCookie", ")", "\n\n", "fc", "[", "0", "]", "(", "c", ",", "fc", "[", "1", ":", "]", ")", "\n\n", "// Add Validation errors to ViewArgs.", "c", ".", "ViewArgs", "[", "\"", "\"", "]", "=", "c", ".", "Validation", ".", "ErrorMap", "(", ")", "\n\n", "// Store the Validation errors", "var", "errorsValue", "string", "\n", "if", "c", ".", "Validation", ".", "keep", "{", "for", "_", ",", "err", ":=", "range", "c", ".", "Validation", ".", "Errors", "{", "if", "err", ".", "Message", "!=", "\"", "\"", "{", "errorsValue", "+=", "\"", "\\x00", "\"", "+", "err", ".", "Key", "+", "\"", "\"", "+", "err", ".", "Message", "+", "\"", "\\x00", "\"", "\n", "}", "\n", "}", "\n", "}", "\n\n", "// When there are errors from Validation and Keep() has been called, store the", "// values in a cookie. If there previously was a cookie but no errors, remove", "// the cookie.", "if", "errorsValue", "!=", "\"", "\"", "{", "c", ".", "SetCookie", "(", "&", "http", ".", "Cookie", "{", "Name", ":", "CookiePrefix", "+", "\"", "\"", ",", "Value", ":", "url", ".", "QueryEscape", "(", "errorsValue", ")", ",", "Domain", ":", "CookieDomain", ",", "Path", ":", "\"", "\"", ",", "HttpOnly", ":", "true", ",", "Secure", ":", "CookieSecure", ",", "}", ")", "\n", "}", "else", "if", "hasCookie", "{", "c", ".", "SetCookie", "(", "&", "http", ".", "Cookie", "{", "Name", ":", "CookiePrefix", "+", "\"", "\"", ",", "MaxAge", ":", "-", "1", ",", "Domain", ":", "CookieDomain", ",", "Path", ":", "\"", "\"", ",", "HttpOnly", ":", "true", ",", "Secure", ":", "CookieSecure", ",", "}", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "ValidationFilter", "revel", "Filter", "function", "to", "be", "hooked", "into", "the", "filter", "chain", "." ]

[ "func", "restoreValidationErrors", "(", "req", "*", "Request", ")", "(", "[", "]", "*", "ValidationError", ",", "error", ")", "{", "var", "(", "err", "error", "\n", "cookie", "ServerCookie", "\n", "errors", "=", "make", "(", "[", "]", "*", "ValidationError", ",", "0", ",", "5", ")", "\n", ")", "\n", "if", "cookie", ",", "err", "=", "req", ".", "Cookie", "(", "CookiePrefix", "+", "\"", "\"", ")", ";", "err", "==", "nil", "{", "ParseKeyValueCookie", "(", "cookie", ".", "GetValue", "(", ")", ",", "func", "(", "key", ",", "val", "string", ")", "{", "errors", "=", "append", "(", "errors", ",", "&", "ValidationError", "{", "Key", ":", "key", ",", "Message", ":", "val", ",", "}", ")", "\n", "}", ")", "\n", "}", "\n", "return", "errors", ",", "err", "\n", "}" ]

[ "Restore", "Validation", ".", "Errors", "from", "a", "request", "." ]

[ "func", "SetDefaultLog", "(", "fromLog", "MultiLogger", ")", "{", "log", ".", "SetOutput", "(", "loggerRewrite", "{", "Logger", ":", "fromLog", ",", "Level", ":", "log15", ".", "LvlInfo", ",", "hideDeprecated", ":", "true", "}", ")", "\n", "// No need to show date and time, that will be logged with revel", "log", ".", "SetFlags", "(", "0", ")", "\n", "}" ]

[ "Set", "the", "systems", "default", "logger", "Default", "logs", "will", "be", "captured", "and", "handled", "by", "revel", "at", "level", "info" ]

[ "func", "(", "rl", "*", "RevelLogger", ")", "Infof", "(", "msg", "string", ",", "param", "...", "interface", "{", "}", ")", "{", "rl", ".", "Info", "(", "fmt", ".", "Sprintf", "(", "msg", ",", "param", "...", ")", ")", "\n", "}" ]

[ "Print", "a", "formatted", "info", "message" ]

[ "func", "(", "rl", "*", "RevelLogger", ")", "Warnf", "(", "msg", "string", ",", "param", "...", "interface", "{", "}", ")", "{", "rl", ".", "Warn", "(", "fmt", ".", "Sprintf", "(", "msg", ",", "param", "...", ")", ")", "\n", "}" ]

[ "Print", "a", "formatted", "warn", "message" ]

[ "func", "(", "rl", "*", "RevelLogger", ")", "Errorf", "(", "msg", "string", ",", "param", "...", "interface", "{", "}", ")", "{", "rl", ".", "Error", "(", "fmt", ".", "Sprintf", "(", "msg", ",", "param", "...", ")", ")", "\n", "}" ]

[ "Print", "a", "formatted", "error", "message" ]

[ "func", "(", "rl", "*", "RevelLogger", ")", "Critf", "(", "msg", "string", ",", "param", "...", "interface", "{", "}", ")", "{", "rl", ".", "Crit", "(", "fmt", ".", "Sprintf", "(", "msg", ",", "param", "...", ")", ")", "\n", "}" ]

[ "Print", "a", "formatted", "critical", "message" ]

[ "func", "(", "rl", "*", "RevelLogger", ")", "Fatalf", "(", "msg", "string", ",", "param", "...", "interface", "{", "}", ")", "{", "rl", ".", "Fatal", "(", "fmt", ".", "Sprintf", "(", "msg", ",", "param", "...", ")", ")", "\n", "}" ]

[ "Print", "a", "formatted", "fatal", "message" ]

[ "func", "(", "rl", "*", "RevelLogger", ")", "Panicf", "(", "msg", "string", ",", "param", "...", "interface", "{", "}", ")", "{", "rl", ".", "Panic", "(", "fmt", ".", "Sprintf", "(", "msg", ",", "param", "...", ")", ")", "\n", "}" ]

[ "Print", "a", "formatted", "panic", "message" ]

[ "func", "(", "rl", "*", "RevelLogger", ")", "Panic", "(", "msg", "string", ",", "ctx", "...", "interface", "{", "}", ")", "{", "rl", ".", "Crit", "(", "msg", ",", "ctx", "...", ")", "\n", "panic", "(", "msg", ")", "\n", "}" ]

[ "Print", "a", "critical", "message", "and", "panic" ]

[ "func", "(", "rl", "*", "RevelLogger", ")", "New", "(", "ctx", "...", "interface", "{", "}", ")", "MultiLogger", "{", "old", ":=", "&", "RevelLogger", "{", "Logger", ":", "rl", ".", "Logger", ".", "New", "(", "ctx", "...", ")", "}", "\n", "return", "old", "\n", "}" ]

[ "Override", "log15", "method" ]

[ "func", "(", "rl", "*", "RevelLogger", ")", "SetStackDepth", "(", "amount", "int", ")", "MultiLogger", "{", "rl", ".", "Logger", ".", "SetStackDepth", "(", "amount", ")", "// Ignore the logger returned", "\n", "return", "rl", "\n", "}" ]

[ "Set", "the", "stack", "level", "to", "check", "for", "the", "caller" ]

[ "func", "New", "(", "ctx", "...", "interface", "{", "}", ")", "MultiLogger", "{", "r", ":=", "&", "RevelLogger", "{", "Logger", ":", "log15", ".", "New", "(", "ctx", "...", ")", "}", "\n", "r", ".", "SetStackDepth", "(", "1", ")", "\n", "return", "r", "\n", "}" ]

[ "Create", "a", "new", "logger" ]

[ "func", "(", "rl", "*", "RevelLogger", ")", "SetHandler", "(", "h", "LogHandler", ")", "{", "rl", ".", "Logger", ".", "SetHandler", "(", "callHandler", "(", "h", ".", "Log", ")", ")", "\n", "}" ]

[ "Set", "the", "handler", "in", "the", "Logger" ]

[ "func", "(", "c", "callHandler", ")", "Log", "(", "log", "*", "log15", ".", "Record", ")", "error", "{", "ctx", ":=", "log", ".", "Ctx", "\n", "var", "ctxMap", "ContextMap", "\n", "if", "len", "(", "ctx", ")", ">", "0", "{", "ctxMap", "=", "make", "(", "ContextMap", ",", "len", "(", "ctx", ")", "/", "2", ")", "\n\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "ctx", ")", ";", "i", "+=", "2", "{", "v", ":=", "ctx", "[", "i", "]", "\n", "key", ",", "ok", ":=", "v", ".", "(", "string", ")", "\n", "if", "!", "ok", "{", "key", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "v", ")", "\n", "}", "\n", "var", "value", "interface", "{", "}", "\n", "if", "len", "(", "ctx", ")", ">", "i", "+", "1", "{", "value", "=", "ctx", "[", "i", "+", "1", "]", "\n", "}", "else", "{", "value", "=", "\"", "\"", "\n", "}", "\n", "ctxMap", "[", "key", "]", "=", "value", "\n", "}", "\n", "}", "else", "{", "ctxMap", "=", "make", "(", "ContextMap", ",", "0", ")", "\n", "}", "\n", "r", ":=", "&", "Record", "{", "Message", ":", "log", ".", "Msg", ",", "Context", ":", "ctxMap", ",", "Time", ":", "log", ".", "Time", ",", "Level", ":", "LogLevel", "(", "log", ".", "Lvl", ")", ",", "Call", ":", "CallStack", "(", "log", ".", "Call", ")", "}", "\n", "return", "c", "(", "r", ")", "\n", "}" ]

[ "Log", "implementation", "reads", "the", "record", "and", "extracts", "the", "details", "from", "the", "log", "record", "Hiding", "the", "implementation", "." ]

[ "func", "(", "m", "ContextMap", ")", "StringMap", "(", ")", "(", "newMap", "map", "[", "string", "]", "string", ")", "{", "if", "m", "!=", "nil", "{", "newMap", "=", "map", "[", "string", "]", "string", "{", "}", "\n", "for", "key", ",", "value", ":=", "range", "m", "{", "if", "svalue", ",", "isstring", ":=", "value", ".", "(", "string", ")", ";", "isstring", "{", "newMap", "[", "key", "]", "=", "svalue", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "\n", "}" ]

[ "Convert", "the", "context", "map", "to", "be", "string", "only", "values", "any", "non", "string", "values", "are", "ignored" ]

[ "func", "PanicFilter", "(", "c", "*", "Controller", ",", "fc", "[", "]", "Filter", ")", "{", "defer", "func", "(", ")", "{", "if", "err", ":=", "recover", "(", ")", ";", "err", "!=", "nil", "{", "handleInvocationPanic", "(", "c", ",", "err", ")", "\n", "}", "\n", "}", "(", ")", "\n", "fc", "[", "0", "]", "(", "c", ",", "fc", "[", "1", ":", "]", ")", "\n", "}" ]

[ "PanicFilter", "wraps", "the", "action", "invocation", "in", "a", "protective", "defer", "blanket", "that", "converts", "panics", "into", "500", "error", "pages", "." ]

[ "func", "handleInvocationPanic", "(", "c", "*", "Controller", ",", "err", "interface", "{", "}", ")", "{", "error", ":=", "NewErrorFromPanic", "(", "err", ")", "\n", "if", "error", "!=", "nil", "{", "utilLog", ".", "Error", "(", "\"", "\"", ",", "\"", "\"", ",", "err", ",", "\"", "\"", ",", "error", ".", "Stack", ")", "\n", "if", "DevMode", "{", "fmt", ".", "Println", "(", "err", ")", "\n", "fmt", ".", "Println", "(", "error", ".", "Stack", ")", "\n", "}", "\n", "}", "else", "{", "utilLog", ".", "Error", "(", "\"", "\"", ",", "\"", "\"", ",", "err", ",", "\"", "\"", ",", "string", "(", "debug", ".", "Stack", "(", ")", ")", ")", "\n", "if", "DevMode", "{", "fmt", ".", "Println", "(", "err", ")", "\n", "fmt", ".", "Println", "(", "\"", "\"", ",", "string", "(", "debug", ".", "Stack", "(", ")", ")", ")", "\n", "}", "\n", "}", "\n\n", "if", "error", "==", "nil", "&&", "DevMode", "{", "// Only show the sensitive information in the debug stack trace in development mode, not production", "c", ".", "Response", ".", "SetStatus", "(", "http", ".", "StatusInternalServerError", ")", "\n", "_", ",", "_", "=", "c", ".", "Response", ".", "GetWriter", "(", ")", ".", "Write", "(", "debug", ".", "Stack", "(", ")", ")", "\n", "return", "\n", "}", "\n\n", "c", ".", "Result", "=", "c", ".", "RenderError", "(", "error", ")", "\n", "}" ]

[ "This", "function", "handles", "a", "panic", "in", "an", "action", "invocation", ".", "It", "cleans", "up", "the", "stack", "trace", "logs", "it", "and", "displays", "an", "error", "page", "." ]

[ "func", "init", "(", ")", "{", "AddInitEventHandler", "(", "func", "(", "typeOf", "Event", ",", "value", "interface", "{", "}", ")", "(", "responseOf", "EventResponse", ")", "{", "if", "typeOf", "==", "REVEL_BEFORE_MODULES_LOADED", "{", "RegisterTemplateLoader", "(", "GO_TEMPLATE", ",", "func", "(", "loader", "*", "TemplateLoader", ")", "(", "TemplateEngine", ",", "error", ")", "{", "// Set the template delimiters for the project if present, then split into left", "// and right delimiters around a space character", "TemplateDelims", ":=", "Config", ".", "StringDefault", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "var", "splitDelims", "[", "]", "string", "\n", "if", "TemplateDelims", "!=", "\"", "\"", "{", "splitDelims", "=", "strings", ".", "Split", "(", "TemplateDelims", ",", "\"", "\"", ")", "\n", "if", "len", "(", "splitDelims", ")", "!=", "2", "{", "log", ".", "Fatalln", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n\n", "return", "&", "GoEngine", "{", "loader", ":", "loader", ",", "templateSet", ":", "template", ".", "New", "(", "\"", "\"", ")", ".", "Funcs", "(", "TemplateFuncs", ")", ",", "templatesByName", ":", "map", "[", "string", "]", "*", "GoTemplate", "{", "}", ",", "splitDelims", ":", "splitDelims", ",", "}", ",", "nil", "\n", "}", ")", "\n", "}", "\n", "return", "\n", "}", ")", "\n", "}" ]

[ "Called", "on", "startup", "initialized", "when", "the", "REVEL_BEFORE_MODULES_LOADED", "is", "called" ]

[ "func", "(", "gotmpl", "GoTemplate", ")", "Render", "(", "wr", "io", ".", "Writer", ",", "arg", "interface", "{", "}", ")", "error", "{", "return", "gotmpl", ".", "Execute", "(", "wr", ",", "arg", ")", "\n", "}" ]

[ "return", "a", "revel", ".", "Template", "from", "Go", "s", "template", "." ]

[ "func", "(", "i", "*", "GoEngine", ")", "ConvertPath", "(", "path", "string", ")", "string", "{", "if", "i", ".", "CaseInsensitive", "{", "return", "strings", ".", "ToLower", "(", "path", ")", "\n", "}", "\n", "return", "path", "\n", "}" ]

[ "Convert", "the", "path", "to", "lower", "case", "if", "needed" ]

[ "func", "(", "engine", "*", "GoEngine", ")", "ParseAndAdd", "(", "baseTemplate", "*", "TemplateView", ")", "error", "{", "// If alternate delimiters set for the project, change them for this set", "if", "engine", ".", "splitDelims", "!=", "nil", "&&", "strings", ".", "Index", "(", "baseTemplate", ".", "Location", "(", ")", ",", "ViewsPath", ")", ">", "-", "1", "{", "engine", ".", "templateSet", ".", "Delims", "(", "engine", ".", "splitDelims", "[", "0", "]", ",", "engine", ".", "splitDelims", "[", "1", "]", ")", "\n", "}", "else", "{", "// Reset to default otherwise", "engine", ".", "templateSet", ".", "Delims", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "}", "\n", "templateSource", ":=", "string", "(", "baseTemplate", ".", "FileBytes", ")", "\n", "templateName", ":=", "engine", ".", "ConvertPath", "(", "baseTemplate", ".", "TemplateName", ")", "\n", "tpl", ",", "err", ":=", "engine", ".", "templateSet", ".", "New", "(", "baseTemplate", ".", "TemplateName", ")", ".", "Parse", "(", "templateSource", ")", "\n", "if", "nil", "!=", "err", "{", "_", ",", "line", ",", "description", ":=", "ParseTemplateError", "(", "err", ")", "\n", "return", "&", "Error", "{", "Title", ":", "\"", "\"", ",", "Path", ":", "baseTemplate", ".", "TemplateName", ",", "Description", ":", "description", ",", "Line", ":", "line", ",", "SourceLines", ":", "strings", ".", "Split", "(", "templateSource", ",", "\"", "\\n", "\"", ")", ",", "}", "\n", "}", "\n", "engine", ".", "templatesByName", "[", "templateName", "]", "=", "&", "GoTemplate", "{", "Template", ":", "tpl", ",", "engine", ":", "engine", ",", "TemplateView", ":", "baseTemplate", "}", "\n", "return", "nil", "\n", "}" ]

[ "Parses", "the", "template", "vide", "and", "adds", "it", "to", "the", "template", "set" ]

[ "func", "(", "engine", "*", "GoEngine", ")", "Lookup", "(", "templateName", "string", ")", "Template", "{", "// Case-insensitive matching of template file name", "if", "tpl", ",", "found", ":=", "engine", ".", "templatesByName", "[", "engine", ".", "ConvertPath", "(", "templateName", ")", "]", ";", "found", "{", "return", "tpl", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Lookups", "the", "template", "name", "to", "see", "if", "it", "is", "contained", "in", "this", "engine" ]

[ "func", "(", "engine", "*", "GoEngine", ")", "Event", "(", "action", "Event", ",", "i", "interface", "{", "}", ")", "{", "if", "action", "==", "TEMPLATE_REFRESH_REQUESTED", "{", "// At this point all the templates have been passed into the", "engine", ".", "templatesByName", "=", "map", "[", "string", "]", "*", "GoTemplate", "{", "}", "\n", "engine", ".", "templateSet", "=", "template", ".", "New", "(", "\"", "\"", ")", ".", "Funcs", "(", "TemplateFuncs", ")", "\n", "// Check to see what should be used for case sensitivity", "engine", ".", "CaseInsensitive", "=", "Config", ".", "BoolDefault", "(", "\"", "\"", ",", "true", ")", "\n", "}", "\n", "}" ]

[ "An", "event", "listener", "to", "listen", "for", "Revel", "INIT", "events" ]

[ "func", "setAppLog", "(", "appLog", "logger", ".", "MultiLogger", ",", "appHandler", "*", "logger", ".", "CompositeMultiHandler", ")", "{", "if", "appLog", "!=", "nil", "{", "AppLog", "=", "appLog", "\n", "}", "\n", "if", "appHandler", "!=", "nil", "{", "appLogHandler", "=", "appHandler", "\n", "// Set the app log and the handler for all forked loggers", "RootLog", ".", "SetHandler", "(", "appLogHandler", ")", "\n\n", "// Set the system log handler - this sets golang writer stream to the", "// sysLog router", "logger", ".", "SetDefaultLog", "(", "SysLog", ")", "\n", "SysLog", ".", "SetStackDepth", "(", "5", ")", "\n", "SysLog", ".", "SetHandler", "(", "appLogHandler", ")", "\n", "}", "\n", "}" ]

[ "Set", "the", "application", "log", "and", "handler", "if", "handler", "is", "nil", "it", "will", "use", "the", "same", "handler", "used", "to", "configure", "the", "application", "log", "before" ]

[ "func", "NewLogOptions", "(", "cfg", "*", "config", ".", "Context", ",", "replaceHandler", "bool", ",", "phandler", "ParentLogHandler", ",", "lvl", "...", "LogLevel", ")", "(", "logOptions", "*", "LogOptions", ")", "{", "logOptions", "=", "&", "LogOptions", "{", "Ctx", ":", "cfg", ",", "ReplaceExistingHandler", ":", "replaceHandler", ",", "HandlerWrap", ":", "phandler", ",", "Levels", ":", "lvl", ",", "ExtendedOptions", ":", "map", "[", "string", "]", "interface", "{", "}", "{", "}", ",", "}", "\n", "return", "\n", "}" ]

[ "Create", "a", "new", "log", "options" ]

[ "func", "(", "l", "*", "LogOptions", ")", "SetExtendedOptions", "(", "options", "...", "interface", "{", "}", ")", "{", "for", "x", ":=", "0", ";", "x", "<", "len", "(", "options", ")", ";", "x", "+=", "2", "{", "l", ".", "ExtendedOptions", "[", "options", "[", "x", "]", ".", "(", "string", ")", "]", "=", "options", "[", "x", "+", "1", "]", "\n", "}", "\n", "}" ]

[ "Assumes", "options", "will", "be", "an", "even", "number", "and", "have", "a", "string", "value", "syntax" ]

[ "func", "(", "l", "*", "LogOptions", ")", "GetStringDefault", "(", "option", ",", "value", "string", ")", "string", "{", "if", "v", ",", "found", ":=", "l", ".", "ExtendedOptions", "[", "option", "]", ";", "found", "{", "return", "v", ".", "(", "string", ")", "\n", "}", "\n", "return", "value", "\n", "}" ]

[ "Gets", "a", "string", "option", "with", "default" ]

[ "func", "(", "l", "*", "LogOptions", ")", "GetIntDefault", "(", "option", "string", ",", "value", "int", ")", "int", "{", "if", "v", ",", "found", ":=", "l", ".", "ExtendedOptions", "[", "option", "]", ";", "found", "{", "return", "v", ".", "(", "int", ")", "\n", "}", "\n", "return", "value", "\n", "}" ]

[ "Gets", "an", "int", "option", "with", "default" ]

[ "func", "(", "l", "*", "LogOptions", ")", "GetBoolDefault", "(", "option", "string", ",", "value", "bool", ")", "bool", "{", "if", "v", ",", "found", ":=", "l", ".", "ExtendedOptions", "[", "option", "]", ";", "found", "{", "return", "v", ".", "(", "bool", ")", "\n", "}", "\n", "return", "value", "\n", "}" ]

[ "Gets", "a", "boolean", "option", "with", "default" ]

[ "func", "init", "(", ")", "{", "AddInitEventHandler", "(", "func", "(", "typeOf", "Event", ",", "value", "interface", "{", "}", ")", "(", "responseOf", "EventResponse", ")", "{", "if", "typeOf", "==", "REVEL_BEFORE_MODULES_LOADED", "{", "RegisterServerEngine", "(", "GO_NATIVE_SERVER_ENGINE", ",", "func", "(", ")", "ServerEngine", "{", "return", "&", "GoHttpServer", "{", "}", "}", ")", "\n", "}", "\n", "return", "\n", "}", ")", "\n", "}" ]

[ "Register", "the", "GoHttpServer", "engine" ]

[ "func", "(", "g", "*", "GoHttpServer", ")", "Init", "(", "init", "*", "EngineInit", ")", "{", "g", ".", "MaxMultipartSize", "=", "int64", "(", "Config", ".", "IntDefault", "(", "\"", "\"", ",", "32", ")", ")", "<<", "20", "/* 32 MB */", "\n", "g", ".", "goContextStack", "=", "utils", ".", "NewStackLock", "(", "Config", ".", "IntDefault", "(", "\"", "\"", ",", "100", ")", ",", "Config", ".", "IntDefault", "(", "\"", "\"", ",", "200", ")", ",", "func", "(", ")", "interface", "{", "}", "{", "return", "NewGoContext", "(", "g", ")", "\n", "}", ")", "\n", "g", ".", "goMultipartFormStack", "=", "utils", ".", "NewStackLock", "(", "Config", ".", "IntDefault", "(", "\"", "\"", ",", "100", ")", ",", "Config", ".", "IntDefault", "(", "\"", "\"", ",", "200", ")", ",", "func", "(", ")", "interface", "{", "}", "{", "return", "&", "GoMultipartForm", "{", "}", "}", ")", "\n", "g", ".", "ServerInit", "=", "init", "\n\n", "revelHandler", ":=", "http", ".", "HandlerFunc", "(", "func", "(", "writer", "http", ".", "ResponseWriter", ",", "request", "*", "http", ".", "Request", ")", "{", "g", ".", "Handle", "(", "writer", ",", "request", ")", "\n", "}", ")", "\n\n", "// Adds the mux list", "g", ".", "HttpMuxList", "=", "init", ".", "HTTPMuxList", "\n", "sort", ".", "Sort", "(", "g", ".", "HttpMuxList", ")", "\n", "g", ".", "HasAppMux", "=", "len", "(", "g", ".", "HttpMuxList", ")", ">", "0", "\n", "g", ".", "signalChan", "=", "make", "(", "chan", "os", ".", "Signal", ")", "\n\n", "g", ".", "Server", "=", "&", "http", ".", "Server", "{", "Addr", ":", "init", ".", "Address", ",", "Handler", ":", "revelHandler", ",", "ReadTimeout", ":", "time", ".", "Duration", "(", "Config", ".", "IntDefault", "(", "\"", "\"", ",", "0", ")", ")", "*", "time", ".", "Second", ",", "WriteTimeout", ":", "time", ".", "Duration", "(", "Config", ".", "IntDefault", "(", "\"", "\"", ",", "0", ")", ")", "*", "time", ".", "Second", ",", "}", "\n\n", "}" ]

[ "Called", "to", "initialize", "the", "server", "with", "this", "EngineInit" ]

[ "func", "(", "g", "*", "GoHttpServer", ")", "Handle", "(", "w", "http", ".", "ResponseWriter", ",", "r", "*", "http", ".", "Request", ")", "{", "// This section is called if the developer has added custom mux to the app", "if", "g", ".", "HasAppMux", "&&", "g", ".", "handleAppMux", "(", "w", ",", "r", ")", "{", "return", "\n", "}", "\n", "g", ".", "handleMux", "(", "w", ",", "r", ")", "\n", "}" ]

[ "Handle", "the", "request", "and", "response", "for", "the", "server" ]

[ "func", "(", "g", "*", "GoHttpServer", ")", "handleMux", "(", "w", "http", ".", "ResponseWriter", ",", "r", "*", "http", ".", "Request", ")", "{", "if", "maxRequestSize", ":=", "int64", "(", "Config", ".", "IntDefault", "(", "\"", "\"", ",", "0", ")", ")", ";", "maxRequestSize", ">", "0", "{", "r", ".", "Body", "=", "http", ".", "MaxBytesReader", "(", "w", ",", "r", ".", "Body", ",", "maxRequestSize", ")", "\n", "}", "\n\n", "upgrade", ":=", "r", ".", "Header", ".", "Get", "(", "\"", "\"", ")", "\n", "context", ":=", "g", ".", "goContextStack", ".", "Pop", "(", ")", ".", "(", "*", "GoContext", ")", "\n", "defer", "func", "(", ")", "{", "g", ".", "goContextStack", ".", "Push", "(", "context", ")", "\n", "}", "(", ")", "\n", "context", ".", "Request", ".", "SetRequest", "(", "r", ")", "\n", "context", ".", "Response", ".", "SetResponse", "(", "w", ")", "\n\n", "if", "upgrade", "==", "\"", "\"", "||", "upgrade", "==", "\"", "\"", "{", "websocket", ".", "Handler", "(", "func", "(", "ws", "*", "websocket", ".", "Conn", ")", "{", "//Override default Read/Write timeout with sane value for a web socket request", "if", "err", ":=", "ws", ".", "SetDeadline", "(", "time", ".", "Now", "(", ")", ".", "Add", "(", "time", ".", "Hour", "*", "24", ")", ")", ";", "err", "!=", "nil", "{", "serverLogger", ".", "Error", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "r", ".", "Method", "=", "\"", "\"", "\n", "context", ".", "Request", ".", "WebSocket", "=", "ws", "\n", "context", ".", "WebSocket", "=", "&", "GoWebSocket", "{", "Conn", ":", "ws", ",", "GoResponse", ":", "*", "context", ".", "Response", "}", "\n", "g", ".", "ServerInit", ".", "Callback", "(", "context", ")", "\n", "}", ")", ".", "ServeHTTP", "(", "w", ",", "r", ")", "\n", "}", "else", "{", "g", ".", "ServerInit", ".", "Callback", "(", "context", ")", "\n", "}", "\n", "}" ]

[ "Passes", "the", "server", "request", "to", "Revel" ]

[ "func", "(", "g", "*", "GoHttpServer", ")", "Stats", "(", ")", "map", "[", "string", "]", "interface", "{", "}", "{", "return", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "g", ".", "goContextStack", ".", "String", "(", ")", ",", "\"", "\"", ":", "g", ".", "goMultipartFormStack", ".", "String", "(", ")", ",", "}", "\n", "}" ]

[ "Returns", "stats", "for", "this", "engine" ]

[ "func", "(", "g", "*", "GoHttpServer", ")", "Event", "(", "event", "Event", ",", "args", "interface", "{", "}", ")", "(", "r", "EventResponse", ")", "{", "switch", "event", "{", "case", "ENGINE_STARTED", ":", "signal", ".", "Notify", "(", "g", ".", "signalChan", ",", "os", ".", "Interrupt", ",", "os", ".", "Kill", ")", "\n", "go", "func", "(", ")", "{", "_", "=", "<-", "g", ".", "signalChan", "\n", "serverLogger", ".", "Info", "(", "\"", "\"", ")", "\n", "RaiseEvent", "(", "ENGINE_SHUTDOWN_REQUEST", ",", "nil", ")", "\n", "}", "(", ")", "\n", "case", "ENGINE_SHUTDOWN_REQUEST", ":", "ctx", ",", "cancel", ":=", "context", ".", "WithTimeout", "(", "context", ".", "Background", "(", ")", ",", "time", ".", "Second", "*", "time", ".", "Duration", "(", "Config", ".", "IntDefault", "(", "\"", "\"", ",", "60", ")", ")", ")", "\n", "defer", "cancel", "(", ")", "\n", "g", ".", "Server", ".", "Shutdown", "(", "ctx", ")", "\n", "default", ":", "}", "\n\n", "return", "\n", "}" ]

[ "Handles", "an", "event", "from", "Revel" ]

[ "func", "NewGoContext", "(", "instance", "*", "GoHttpServer", ")", "*", "GoContext", "{", "// This bit in here is for the test cases, which pass in a nil value", "if", "instance", "==", "nil", "{", "instance", "=", "&", "GoHttpServer", "{", "MaxMultipartSize", ":", "32", "<<", "20", "}", "\n", "instance", ".", "goContextStack", "=", "utils", ".", "NewStackLock", "(", "100", ",", "200", ",", "func", "(", ")", "interface", "{", "}", "{", "return", "NewGoContext", "(", "instance", ")", "\n", "}", ")", "\n", "instance", ".", "goMultipartFormStack", "=", "utils", ".", "NewStackLock", "(", "100", ",", "200", ",", "func", "(", ")", "interface", "{", "}", "{", "return", "&", "GoMultipartForm", "{", "}", "}", ")", "\n", "}", "\n", "c", ":=", "&", "GoContext", "{", "Request", ":", "&", "GoRequest", "{", "Goheader", ":", "&", "GoHeader", "{", "}", ",", "Engine", ":", "instance", "}", "}", "\n", "c", ".", "Response", "=", "&", "GoResponse", "{", "Goheader", ":", "&", "GoHeader", "{", "}", ",", "Request", ":", "c", ".", "Request", ",", "Engine", ":", "instance", "}", "\n", "return", "c", "\n", "}" ]

[ "Create", "a", "new", "go", "context" ]

[ "func", "(", "c", "*", "GoContext", ")", "GetResponse", "(", ")", "ServerResponse", "{", "if", "c", ".", "WebSocket", "!=", "nil", "{", "return", "c", ".", "WebSocket", "\n", "}", "\n", "return", "c", ".", "Response", "\n", "}" ]

[ "Get", "the", "response" ]

[ "func", "(", "c", "*", "GoContext", ")", "Destroy", "(", ")", "{", "c", ".", "Response", ".", "Destroy", "(", ")", "\n", "c", ".", "Request", ".", "Destroy", "(", ")", "\n", "if", "c", ".", "WebSocket", "!=", "nil", "{", "c", ".", "WebSocket", ".", "Destroy", "(", ")", "\n", "c", ".", "WebSocket", "=", "nil", "\n", "}", "\n", "}" ]

[ "Destroy", "the", "context" ]

[ "func", "(", "r", "*", "GoRequest", ")", "Get", "(", "key", "int", ")", "(", "value", "interface", "{", "}", ",", "err", "error", ")", "{", "switch", "key", "{", "case", "HTTP_SERVER_HEADER", ":", "value", "=", "r", ".", "GetHeader", "(", ")", "\n", "case", "HTTP_MULTIPART_FORM", ":", "value", ",", "err", "=", "r", ".", "GetMultipartForm", "(", ")", "\n", "case", "HTTP_QUERY", ":", "value", "=", "r", ".", "Original", ".", "URL", ".", "Query", "(", ")", "\n", "case", "HTTP_FORM", ":", "value", ",", "err", "=", "r", ".", "GetForm", "(", ")", "\n", "case", "HTTP_REQUEST_URI", ":", "value", "=", "r", ".", "Original", ".", "URL", ".", "String", "(", ")", "\n", "case", "HTTP_REQUEST_CONTEXT", ":", "value", "=", "r", ".", "Original", ".", "Context", "(", ")", "\n", "case", "HTTP_REMOTE_ADDR", ":", "value", "=", "r", ".", "Original", ".", "RemoteAddr", "\n", "case", "HTTP_METHOD", ":", "value", "=", "r", ".", "Original", ".", "Method", "\n", "case", "HTTP_PATH", ":", "value", "=", "r", ".", "Original", ".", "URL", ".", "Path", "\n", "case", "HTTP_HOST", ":", "value", "=", "r", ".", "Original", ".", "Host", "\n", "case", "HTTP_URL", ":", "value", "=", "r", ".", "Original", ".", "URL", "\n", "case", "HTTP_BODY", ":", "value", "=", "r", ".", "Original", ".", "Body", "\n", "default", ":", "err", "=", "ENGINE_UNKNOWN_GET", "\n", "}", "\n\n", "return", "\n", "}" ]

[ "Communicate", "with", "the", "server", "engine", "to", "exchange", "data" ]

[ "func", "(", "r", "*", "GoRequest", ")", "SetRequest", "(", "req", "*", "http", ".", "Request", ")", "{", "r", ".", "Original", "=", "req", "\n", "r", ".", "Goheader", ".", "Source", "=", "r", "\n", "r", ".", "Goheader", ".", "isResponse", "=", "false", "\n\n", "}" ]

[ "Sets", "the", "request" ]

[ "func", "(", "r", "*", "GoResponse", ")", "WriteStream", "(", "name", "string", ",", "contentlen", "int64", ",", "modtime", "time", ".", "Time", ",", "reader", "io", ".", "Reader", ")", "error", "{", "// Check to see if the output stream is modified, if not send it using the", "// Native writer", "written", ":=", "false", "\n", "if", "_", ",", "ok", ":=", "r", ".", "Writer", ".", "(", "http", ".", "ResponseWriter", ")", ";", "ok", "{", "if", "rs", ",", "ok", ":=", "reader", ".", "(", "io", ".", "ReadSeeker", ")", ";", "ok", "{", "http", ".", "ServeContent", "(", "r", ".", "Original", ",", "r", ".", "Request", ".", "Original", ",", "name", ",", "modtime", ",", "rs", ")", "\n", "written", "=", "true", "\n", "}", "\n", "}", "\n", "if", "!", "written", "{", "// Else, do a simple io.Copy.", "ius", ":=", "r", ".", "Request", ".", "Original", ".", "Header", ".", "Get", "(", "\"", "\"", ")", "\n", "if", "t", ",", "err", ":=", "http", ".", "ParseTime", "(", "ius", ")", ";", "err", "==", "nil", "&&", "!", "modtime", ".", "IsZero", "(", ")", "{", "// The Date-Modified header truncates sub-second precision, so", "// use mtime < t+1s instead of mtime <= t to check for unmodified.", "if", "modtime", ".", "Before", "(", "t", ".", "Add", "(", "1", "*", "time", ".", "Second", ")", ")", "{", "h", ":=", "r", ".", "Original", ".", "Header", "(", ")", "\n", "delete", "(", "h", ",", "\"", "\"", ")", "\n", "delete", "(", "h", ",", "\"", "\"", ")", "\n", "if", "h", ".", "Get", "(", "\"", "\"", ")", "!=", "\"", "\"", "{", "delete", "(", "h", ",", "\"", "\"", ")", "\n", "}", "\n", "r", ".", "Original", ".", "WriteHeader", "(", "http", ".", "StatusNotModified", ")", "\n", "return", "nil", "\n", "}", "\n", "}", "\n\n", "if", "contentlen", "!=", "-", "1", "{", "header", ":=", "ServerHeader", "(", "r", ".", "Goheader", ")", "\n", "if", "writer", ",", "found", ":=", "r", ".", "Writer", ".", "(", "*", "CompressResponseWriter", ")", ";", "found", "{", "header", "=", "ServerHeader", "(", "writer", ".", "Header", ")", "\n", "}", "\n", "header", ".", "Set", "(", "\"", "\"", ",", "strconv", ".", "FormatInt", "(", "contentlen", ",", "10", ")", ")", "\n", "}", "\n", "if", "_", ",", "err", ":=", "io", ".", "Copy", "(", "r", ".", "Writer", ",", "reader", ")", ";", "err", "!=", "nil", "{", "r", ".", "Original", ".", "WriteHeader", "(", "http", ".", "StatusInternalServerError", ")", "\n", "return", "err", "\n", "}", "else", "{", "r", ".", "Original", ".", "WriteHeader", "(", "http", ".", "StatusOK", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Write", "output", "to", "stream" ]

[ "func", "(", "r", "*", "GoResponse", ")", "SetResponse", "(", "w", "http", ".", "ResponseWriter", ")", "{", "r", ".", "Original", "=", "w", "\n", "r", ".", "Writer", "=", "w", "\n", "r", ".", "Goheader", ".", "Source", "=", "r", "\n", "r", ".", "Goheader", ".", "isResponse", "=", "true", "\n\n", "}" ]

[ "Sets", "the", "response" ]

[ "func", "(", "r", "*", "GoHeader", ")", "GetCookie", "(", "key", "string", ")", "(", "value", "ServerCookie", ",", "err", "error", ")", "{", "if", "!", "r", ".", "isResponse", "{", "var", "cookie", "*", "http", ".", "Cookie", "\n", "if", "cookie", ",", "err", "=", "r", ".", "Source", ".", "(", "*", "GoRequest", ")", ".", "Original", ".", "Cookie", "(", "key", ")", ";", "err", "==", "nil", "{", "value", "=", "GoCookie", "(", "*", "cookie", ")", "\n\n", "}", "\n\n", "}", "\n", "return", "\n", "}" ]

[ "Gets", "the", "cookie" ]

[ "func", "(", "r", "*", "GoHeader", ")", "Del", "(", "key", "string", ")", "{", "if", "r", ".", "isResponse", "{", "r", ".", "Source", ".", "(", "*", "GoResponse", ")", ".", "Original", ".", "Header", "(", ")", ".", "Del", "(", "key", ")", "\n", "}", "\n", "}" ]

[ "Deletes", "the", "header", "key" ]

[ "func", "(", "r", "*", "GoHeader", ")", "Get", "(", "key", "string", ")", "(", "value", "[", "]", "string", ")", "{", "if", "!", "r", ".", "isResponse", "{", "value", "=", "r", ".", "Source", ".", "(", "*", "GoRequest", ")", ".", "Original", ".", "Header", "[", "key", "]", "\n", "if", "len", "(", "value", ")", "==", "0", "{", "if", "ihead", ":=", "r", ".", "Source", ".", "(", "*", "GoRequest", ")", ".", "Original", ".", "Header", ".", "Get", "(", "key", ")", ";", "ihead", "!=", "\"", "\"", "{", "value", "=", "append", "(", "value", ",", "ihead", ")", "\n", "}", "\n", "}", "\n", "}", "else", "{", "value", "=", "r", ".", "Source", ".", "(", "*", "GoResponse", ")", ".", "Original", ".", "Header", "(", ")", "[", "key", "]", "\n", "}", "\n", "return", "\n", "}" ]

[ "Gets", "the", "header", "key" ]

[ "func", "(", "r", "*", "GoHeader", ")", "GetKeys", "(", ")", "(", "value", "[", "]", "string", ")", "{", "if", "!", "r", ".", "isResponse", "{", "for", "key", ":=", "range", "r", ".", "Source", ".", "(", "*", "GoRequest", ")", ".", "Original", ".", "Header", "{", "value", "=", "append", "(", "value", ",", "key", ")", "\n", "}", "\n", "}", "else", "{", "for", "key", ":=", "range", "r", ".", "Source", ".", "(", "*", "GoResponse", ")", ".", "Original", ".", "Header", "(", ")", "{", "value", "=", "append", "(", "value", ",", "key", ")", "\n", "}", "\n", "}", "\n", "return", "\n", "}" ]

[ "Returns", "list", "of", "header", "keys" ]

[ "func", "(", "r", "*", "GoHeader", ")", "SetStatus", "(", "statusCode", "int", ")", "{", "if", "r", ".", "isResponse", "{", "r", ".", "Source", ".", "(", "*", "GoResponse", ")", ".", "Original", ".", "WriteHeader", "(", "statusCode", ")", "\n", "}", "\n", "}" ]

[ "Sets", "the", "status", "of", "the", "header" ]

[ "func", "(", "f", "*", "GoMultipartForm", ")", "GetValues", "(", ")", "url", ".", "Values", "{", "return", "url", ".", "Values", "(", "f", ".", "Form", ".", "Value", ")", "\n", "}" ]

[ "Return", "values", "from", "the", "form" ]

[ "func", "(", "g", "*", "GoWebSocket", ")", "MessageSendJSON", "(", "v", "interface", "{", "}", ")", "error", "{", "return", "websocket", ".", "JSON", ".", "Send", "(", "g", ".", "Conn", ",", "v", ")", "\n", "}" ]

[ "Message", "send", "JSON" ]

[ "func", "(", "g", "*", "GoWebSocket", ")", "MessageReceiveJSON", "(", "v", "interface", "{", "}", ")", "error", "{", "return", "websocket", ".", "JSON", ".", "Receive", "(", "g", ".", "Conn", ",", "v", ")", "\n", "}" ]

[ "Message", "receive", "JSON" ]

[ "func", "initCookieEngine", "(", ")", "SessionEngine", "{", "ce", ":=", "&", "SessionCookieEngine", "{", "}", "\n\n", "var", "err", "error", "\n", "if", "expiresString", ",", "ok", ":=", "Config", ".", "String", "(", "\"", "\"", ")", ";", "!", "ok", "{", "ce", ".", "ExpireAfterDuration", "=", "30", "*", "24", "*", "time", ".", "Hour", "\n", "}", "else", "if", "expiresString", "==", "session", ".", "SessionValueName", "{", "ce", ".", "ExpireAfterDuration", "=", "0", "\n", "}", "else", "if", "ce", ".", "ExpireAfterDuration", ",", "err", "=", "time", ".", "ParseDuration", "(", "expiresString", ")", ";", "err", "!=", "nil", "{", "panic", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", ")", "\n", "}", "\n\n", "return", "ce", "\n", "}" ]

[ "Called", "when", "the", "the", "application", "starts", "retrieves", "data", "from", "the", "app", "config", "so", "cannot", "be", "run", "until", "then" ]

[ "func", "(", "cse", "*", "SessionCookieEngine", ")", "Decode", "(", "c", "*", "Controller", ")", "{", "// Decode the session from a cookie.", "c", ".", "Session", "=", "map", "[", "string", "]", "interface", "{", "}", "{", "}", "\n", "sessionMap", ":=", "c", ".", "Session", "\n", "if", "cookie", ",", "err", ":=", "c", ".", "Request", ".", "Cookie", "(", "CookiePrefix", "+", "session", ".", "SessionCookieSuffix", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "else", "{", "cse", ".", "DecodeCookie", "(", "cookie", ",", "sessionMap", ")", "\n", "c", ".", "Session", "=", "sessionMap", "\n", "}", "\n", "}" ]

[ "Decode", "the", "session", "information", "from", "the", "cookie", "retrieved", "from", "the", "controller", "request" ]

[ "func", "(", "cse", "*", "SessionCookieEngine", ")", "Encode", "(", "c", "*", "Controller", ")", "{", "c", ".", "SetCookie", "(", "cse", ".", "GetCookie", "(", "c", ".", "Session", ")", ")", "\n", "}" ]

[ "Encode", "the", "session", "information", "to", "the", "cookie", "set", "the", "cookie", "on", "the", "controller" ]

[ "func", "(", "cse", "*", "SessionCookieEngine", ")", "DecodeCookie", "(", "cookie", "ServerCookie", ",", "s", "session", ".", "Session", ")", "{", "// Decode the session from a cookie.", "// Separate the data from the signature.", "cookieValue", ":=", "cookie", ".", "GetValue", "(", ")", "\n", "hyphen", ":=", "strings", ".", "Index", "(", "cookieValue", ",", "\"", "\"", ")", "\n", "if", "hyphen", "==", "-", "1", "||", "hyphen", ">=", "len", "(", "cookieValue", ")", "-", "1", "{", "return", "\n", "}", "\n", "sig", ",", "data", ":=", "cookieValue", "[", ":", "hyphen", "]", ",", "cookieValue", "[", "hyphen", "+", "1", ":", "]", "\n\n", "// Verify the signature.", "if", "!", "Verify", "(", "data", ",", "sig", ")", "{", "sessionEngineLog", ".", "Warn", "(", "\"", "\"", ")", "\n", "return", "\n", "}", "\n\n", "// Parse the cookie into a temp map, and then load it into the session object", "tempMap", ":=", "map", "[", "string", "]", "string", "{", "}", "\n", "ParseKeyValueCookie", "(", "data", ",", "func", "(", "key", ",", "val", "string", ")", "{", "tempMap", "[", "key", "]", "=", "val", "\n", "}", ")", "\n", "s", ".", "Load", "(", "tempMap", ")", "\n\n", "// Check timeout after unpacking values - if timeout missing (or removed) destroy all session", "// objects", "if", "s", ".", "SessionTimeoutExpiredOrMissing", "(", ")", "{", "// If this fails we need to delete all the keys from the session", "for", "key", ":=", "range", "s", "{", "delete", "(", "s", ",", "key", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "Exposed", "only", "for", "testing", "purposes" ]

[ "func", "(", "cse", "*", "SessionCookieEngine", ")", "GetCookie", "(", "s", "session", ".", "Session", ")", "*", "http", ".", "Cookie", "{", "var", "sessionValue", "string", "\n", "ts", ":=", "s", ".", "GetExpiration", "(", "cse", ".", "ExpireAfterDuration", ")", "\n", "if", "ts", ".", "IsZero", "(", ")", "{", "s", "[", "session", ".", "TimestampKey", "]", "=", "session", ".", "SessionValueName", "\n", "}", "else", "{", "s", "[", "session", ".", "TimestampKey", "]", "=", "strconv", ".", "FormatInt", "(", "ts", ".", "Unix", "(", ")", ",", "10", ")", "\n", "}", "\n\n", "// Convert the key to a string map", "stringMap", ":=", "s", ".", "Serialize", "(", ")", "\n\n", "for", "key", ",", "value", ":=", "range", "stringMap", "{", "if", "strings", ".", "ContainsAny", "(", "key", ",", "\"", "\\x00", "\"", ")", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "strings", ".", "Contains", "(", "value", ",", "\"", "\\x00", "\"", ")", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "sessionValue", "+=", "\"", "\\x00", "\"", "+", "key", "+", "\"", "\"", "+", "value", "+", "\"", "\\x00", "\"", "\n", "}", "\n\n", "if", "len", "(", "sessionValue", ")", ">", "1024", "*", "4", "{", "sessionEngineLog", ".", "Error", "(", "\"", "\"", ",", "\"", "\"", ",", "len", "(", "sessionValue", ")", ")", "\n", "}", "\n\n", "sessionData", ":=", "url", ".", "QueryEscape", "(", "sessionValue", ")", "\n", "sessionCookie", ":=", "&", "http", ".", "Cookie", "{", "Name", ":", "CookiePrefix", "+", "session", ".", "SessionCookieSuffix", ",", "Value", ":", "Sign", "(", "sessionData", ")", "+", "\"", "\"", "+", "sessionData", ",", "Domain", ":", "CookieDomain", ",", "Path", ":", "\"", "\"", ",", "HttpOnly", ":", "true", ",", "Secure", ":", "CookieSecure", ",", "Expires", ":", "ts", ".", "UTC", "(", ")", ",", "MaxAge", ":", "int", "(", "cse", ".", "ExpireAfterDuration", ".", "Seconds", "(", ")", ")", ",", "}", "\n", "return", "sessionCookie", "\n\n", "}" ]

[ "Convert", "session", "to", "cookie" ]

[ "func", "(", "f", "Flash", ")", "Error", "(", "msg", "string", ",", "args", "...", "interface", "{", "}", ")", "{", "if", "len", "(", "args", ")", "==", "0", "{", "f", ".", "Out", "[", "\"", "\"", "]", "=", "msg", "\n", "}", "else", "{", "f", ".", "Out", "[", "\"", "\"", "]", "=", "fmt", ".", "Sprintf", "(", "msg", ",", "args", "...", ")", "\n", "}", "\n", "}" ]

[ "Error", "serializes", "the", "given", "msg", "and", "args", "to", "an", "error", "key", "within", "the", "Flash", "cookie", "." ]

[ "func", "FlashFilter", "(", "c", "*", "Controller", ",", "fc", "[", "]", "Filter", ")", "{", "c", ".", "Flash", "=", "restoreFlash", "(", "c", ".", "Request", ")", "\n", "c", ".", "ViewArgs", "[", "\"", "\"", "]", "=", "c", ".", "Flash", ".", "Data", "\n\n", "fc", "[", "0", "]", "(", "c", ",", "fc", "[", "1", ":", "]", ")", "\n\n", "// Store the flash.", "var", "flashValue", "string", "\n", "for", "key", ",", "value", ":=", "range", "c", ".", "Flash", ".", "Out", "{", "flashValue", "+=", "\"", "\\x00", "\"", "+", "key", "+", "\"", "\"", "+", "value", "+", "\"", "\\x00", "\"", "\n", "}", "\n", "c", ".", "SetCookie", "(", "&", "http", ".", "Cookie", "{", "Name", ":", "CookiePrefix", "+", "\"", "\"", ",", "Value", ":", "url", ".", "QueryEscape", "(", "flashValue", ")", ",", "HttpOnly", ":", "true", ",", "Secure", ":", "CookieSecure", ",", "Path", ":", "\"", "\"", ",", "}", ")", "\n", "}" ]

[ "FlashFilter", "is", "a", "Revel", "Filter", "that", "retrieves", "and", "sets", "the", "flash", "cookie", ".", "Within", "Revel", "it", "is", "available", "as", "a", "Flash", "attribute", "on", "Controller", "instances", ".", "The", "name", "of", "the", "Flash", "cookie", "is", "set", "as", "CookiePrefix", "+", "_FLASH", "." ]

[ "func", "restoreFlash", "(", "req", "*", "Request", ")", "Flash", "{", "flash", ":=", "Flash", "{", "Data", ":", "make", "(", "map", "[", "string", "]", "string", ")", ",", "Out", ":", "make", "(", "map", "[", "string", "]", "string", ")", ",", "}", "\n", "if", "cookie", ",", "err", ":=", "req", ".", "Cookie", "(", "CookiePrefix", "+", "\"", "\"", ")", ";", "err", "==", "nil", "{", "ParseKeyValueCookie", "(", "cookie", ".", "GetValue", "(", ")", ",", "func", "(", "key", ",", "val", "string", ")", "{", "flash", ".", "Data", "[", "key", "]", "=", "val", "\n", "}", ")", "\n", "}", "\n", "return", "flash", "\n", "}" ]

[ "restoreFlash", "deserializes", "a", "Flash", "cookie", "struct", "from", "a", "request", "." ]

[ "func", "(", "r", "PlaintextErrorResult", ")", "Apply", "(", "req", "*", "Request", ",", "resp", "*", "Response", ")", "{", "resp", ".", "WriteHeader", "(", "http", ".", "StatusInternalServerError", ",", "\"", "\"", ")", "\n", "if", "_", ",", "err", ":=", "resp", ".", "GetWriter", "(", ")", ".", "Write", "(", "[", "]", "byte", "(", "r", ".", "Error", ".", "Error", "(", ")", ")", ")", ";", "err", "!=", "nil", "{", "resultsLog", ".", "Error", "(", "\"", "\"", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}" ]

[ "Apply", "method", "is", "used", "when", "the", "template", "loader", "or", "error", "template", "is", "not", "available", "." ]

[ "func", "(", "r", "*", "RenderTemplateResult", ")", "ToBytes", "(", ")", "(", "b", "*", "bytes", ".", "Buffer", ",", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "if", "rerr", ":=", "recover", "(", ")", ";", "rerr", "!=", "nil", "{", "resultsLog", ".", "Error", "(", "\"", "\"", ",", "\"", "\"", ",", "rerr", ")", "\n", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\\n", "\"", ",", "r", ".", "Template", ".", "Name", "(", ")", ",", "rerr", ")", "\n", "}", "\n", "}", "(", ")", "\n", "b", "=", "&", "bytes", ".", "Buffer", "{", "}", "\n", "if", "err", "=", "r", ".", "renderOutput", "(", "b", ")", ";", "err", "==", "nil", "{", "if", "Config", ".", "BoolDefault", "(", "\"", "\"", ",", "false", ")", "{", "b", "=", "r", ".", "compressHtml", "(", "b", ")", "\n", "}", "\n", "}", "\n", "return", "\n", "}" ]

[ "Return", "a", "byte", "array", "and", "or", "an", "error", "object", "if", "the", "template", "failed", "to", "render" ]

[ "func", "(", "r", "*", "RenderTemplateResult", ")", "renderOutput", "(", "wr", "io", ".", "Writer", ")", "(", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "if", "rerr", ":=", "recover", "(", ")", ";", "rerr", "!=", "nil", "{", "resultsLog", ".", "Error", "(", "\"", "\"", ",", "\"", "\"", ",", "rerr", ")", "\n", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\\n", "\"", ",", "r", ".", "Template", ".", "Name", "(", ")", ",", "rerr", ")", "\n", "}", "\n", "}", "(", ")", "\n", "err", "=", "r", ".", "Template", ".", "Render", "(", "wr", ",", "r", ".", "ViewArgs", ")", "\n", "return", "\n", "}" ]

[ "Output", "the", "template", "to", "the", "writer", "catch", "any", "panics", "and", "return", "as", "an", "error" ]

[ "func", "(", "r", "*", "RenderTemplateResult", ")", "renderError", "(", "err", "error", ",", "req", "*", "Request", ",", "resp", "*", "Response", ")", "{", "compileError", ",", "found", ":=", "err", ".", "(", "*", "Error", ")", "\n", "if", "!", "found", "{", "var", "templateContent", "[", "]", "string", "\n", "templateName", ",", "line", ",", "description", ":=", "ParseTemplateError", "(", "err", ")", "\n", "if", "templateName", "==", "\"", "\"", "{", "templateLog", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "err", ")", "\n", "templateName", "=", "r", ".", "Template", ".", "Name", "(", ")", "\n", "templateContent", "=", "r", ".", "Template", ".", "Content", "(", ")", "\n\n", "}", "else", "{", "lang", ",", "_", ":=", "r", ".", "ViewArgs", "[", "CurrentLocaleViewArg", "]", ".", "(", "string", ")", "\n", "if", "tmpl", ",", "err", ":=", "MainTemplateLoader", ".", "TemplateLang", "(", "templateName", ",", "lang", ")", ";", "err", "==", "nil", "{", "templateContent", "=", "tmpl", ".", "Content", "(", ")", "\n", "}", "else", "{", "templateLog", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n", "compileError", "=", "&", "Error", "{", "Title", ":", "\"", "\"", ",", "Path", ":", "templateName", ",", "Description", ":", "description", ",", "Line", ":", "line", ",", "SourceLines", ":", "templateContent", ",", "}", "\n", "}", "\n", "resp", ".", "Status", "=", "500", "\n", "resultsLog", ".", "Errorf", "(", "\"", "\"", ",", "compileError", ".", "Path", ",", "compileError", ".", "Description", ")", "\n", "ErrorResult", "{", "r", ".", "ViewArgs", ",", "compileError", "}", ".", "Apply", "(", "req", ",", "resp", ")", "\n", "}" ]

[ "Render", "the", "error", "in", "the", "response" ]

[ "func", "InitServer", "(", ")", "{", "CurrentEngine", ".", "Init", "(", "ServerEngineInit", ")", "\n", "initControllerStack", "(", ")", "\n", "startupHooks", ".", "Run", "(", ")", "\n\n", "// Load templates", "MainTemplateLoader", "=", "NewTemplateLoader", "(", "TemplatePaths", ")", "\n", "if", "err", ":=", "MainTemplateLoader", ".", "Refresh", "(", ")", ";", "err", "!=", "nil", "{", "serverLogger", ".", "Debug", "(", "\"", "\"", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// The \"watch\" config variable can turn on and off all watching.", "// (As a convenient way to control it all together.)", "if", "Config", ".", "BoolDefault", "(", "\"", "\"", ",", "true", ")", "{", "MainWatcher", "=", "NewWatcher", "(", ")", "\n", "Filters", "=", "append", "(", "[", "]", "Filter", "{", "WatchFilter", "}", ",", "Filters", "...", ")", "\n", "}", "\n\n", "// If desired (or by default), create a watcher for templates and routes.", "// The watcher calls Refresh() on things on the first request.", "if", "MainWatcher", "!=", "nil", "&&", "Config", ".", "BoolDefault", "(", "\"", "\"", ",", "true", ")", "{", "MainWatcher", ".", "Listen", "(", "MainTemplateLoader", ",", "MainTemplateLoader", ".", "paths", "...", ")", "\n", "}", "\n\n", "}" ]

[ "InitServer", "initializes", "the", "server", "and", "returns", "the", "handler", "It", "can", "be", "used", "as", "an", "alternative", "entry", "-", "point", "if", "one", "needs", "the", "http", "handler", "to", "be", "exposed", ".", "E", ".", "g", ".", "to", "run", "on", "multiple", "addresses", "and", "ports", "or", "to", "set", "custom", "TLS", "options", "." ]

[ "func", "Run", "(", "port", "int", ")", "{", "defer", "func", "(", ")", "{", "if", "r", ":=", "recover", "(", ")", ";", "r", "!=", "nil", "{", "RevelLog", ".", "Crit", "(", "\"", "\"", ",", "\"", "\"", ",", "r", ")", "\n", "RaiseEvent", "(", "REVEL_FAILURE", ",", "r", ")", "\n", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "// Initialize the session logger, must be initiated from this app to avoid", "// circular references", "session", ".", "InitSession", "(", "RevelLog", ")", "\n\n", "// Create the CurrentEngine instance from the application config", "InitServerEngine", "(", "port", ",", "Config", ".", "StringDefault", "(", "\"", "\"", ",", "GO_NATIVE_SERVER_ENGINE", ")", ")", "\n", "RaiseEvent", "(", "ENGINE_BEFORE_INITIALIZED", ",", "nil", ")", "\n", "InitServer", "(", ")", "\n", "RaiseEvent", "(", "ENGINE_STARTED", ",", "nil", ")", "\n", "// This is needed for the harness to recognize that the server is started, it looks for the word", "// \"Listening\" in the stdout stream", "fmt", ".", "Fprintf", "(", "os", ".", "Stdout", ",", "\"", "\\n", "\"", ",", "ServerEngineInit", ".", "Address", ")", "\n", "// Start never returns,", "CurrentEngine", ".", "Start", "(", ")", "\n", "fmt", ".", "Fprintf", "(", "os", ".", "Stdout", ",", "\"", "\\n", "\"", ",", "ServerEngineInit", ".", "Address", ")", "\n", "RaiseEvent", "(", "ENGINE_SHUTDOWN", ",", "nil", ")", "\n", "shutdownHooks", ".", "Run", "(", ")", "\n", "println", "(", "\"", "\\n", "\\n", "\"", ")", "\n", "}" ]

[ "Run", "the", "server", ".", "This", "is", "called", "from", "the", "generated", "main", "file", ".", "If", "port", "is", "non", "-", "zero", "use", "that", ".", "Else", "read", "the", "port", "from", "app", ".", "conf", "." ]

[ "func", "InitServerEngine", "(", "port", "int", ",", "serverEngine", "string", ")", "{", "address", ":=", "HTTPAddr", "\n", "if", "address", "==", "\"", "\"", "{", "address", "=", "\"", "\"", "\n", "}", "\n", "if", "port", "==", "0", "{", "port", "=", "HTTPPort", "\n", "}", "\n\n", "var", "network", "=", "\"", "\"", "\n", "var", "localAddress", "string", "\n\n", "// If the port is zero, treat the address as a fully qualified local address.", "// This address must be prefixed with the network type followed by a colon,", "// e.g. unix:/tmp/app.socket or tcp6:::1 (equivalent to tcp6:0:0:0:0:0:0:0:1)", "if", "port", "==", "0", "{", "parts", ":=", "strings", ".", "SplitN", "(", "address", ",", "\"", "\"", ",", "2", ")", "\n", "network", "=", "parts", "[", "0", "]", "\n", "localAddress", "=", "parts", "[", "1", "]", "\n", "}", "else", "{", "localAddress", "=", "address", "+", "\"", "\"", "+", "strconv", ".", "Itoa", "(", "port", ")", "\n", "}", "\n\n", "if", "engineLoader", ",", "ok", ":=", "serverEngineMap", "[", "serverEngine", "]", ";", "!", "ok", "{", "panic", "(", "\"", "\"", "+", "serverEngine", "+", "\"", "\"", ")", "\n", "}", "else", "{", "CurrentEngine", "=", "engineLoader", "(", ")", "\n", "serverLogger", ".", "Debug", "(", "\"", "\"", ",", "\"", "\"", ",", "CurrentEngine", ".", "Name", "(", ")", ")", "\n", "ServerEngineInit", "=", "&", "EngineInit", "{", "Address", ":", "localAddress", ",", "Network", ":", "network", ",", "Port", ":", "port", ",", "Callback", ":", "handleInternal", ",", "}", "\n", "}", "\n", "AddInitEventHandler", "(", "CurrentEngine", ".", "Event", ")", "\n", "}" ]

[ "Build", "an", "engine", "initialization", "object", "and", "start", "the", "engine" ]

[ "func", "initControllerStack", "(", ")", "{", "RevelConfig", ".", "Controller", ".", "Reuse", "=", "Config", ".", "BoolDefault", "(", "\"", "\"", ",", "true", ")", "\n\n", "if", "RevelConfig", ".", "Controller", ".", "Reuse", "{", "RevelConfig", ".", "Controller", ".", "Stack", "=", "utils", ".", "NewStackLock", "(", "Config", ".", "IntDefault", "(", "\"", "\"", ",", "10", ")", ",", "Config", ".", "IntDefault", "(", "\"", "\"", ",", "200", ")", ",", "func", "(", ")", "interface", "{", "}", "{", "return", "NewControllerEmpty", "(", ")", "\n", "}", ")", "\n", "RevelConfig", ".", "Controller", ".", "CachedStackSize", "=", "Config", ".", "IntDefault", "(", "\"", "\"", ",", "10", ")", "\n", "RevelConfig", ".", "Controller", ".", "CachedStackMaxSize", "=", "Config", ".", "IntDefault", "(", "\"", "\"", ",", "100", ")", "\n", "RevelConfig", ".", "Controller", ".", "CachedMap", "=", "map", "[", "string", "]", "*", "utils", ".", "SimpleLockStack", "{", "}", "\n", "}", "\n", "}" ]

[ "Initialize", "the", "controller", "stack", "for", "the", "application" ]

[ "func", "AddControllerType", "(", "moduleSource", "*", "Module", ",", "controllerType", "reflect", ".", "Type", ",", "methods", "[", "]", "*", "MethodType", ")", "(", "newControllerType", "*", "ControllerType", ")", "{", "if", "moduleSource", "==", "nil", "{", "moduleSource", "=", "appModule", "\n", "}", "\n\n", "newControllerType", "=", "&", "ControllerType", "{", "ModuleSource", ":", "moduleSource", ",", "Type", ":", "controllerType", ",", "Methods", ":", "methods", ",", "ControllerIndexes", ":", "findControllers", "(", "controllerType", ")", "}", "\n", "newControllerType", ".", "ControllerEvents", "=", "NewControllerTypeEvents", "(", "newControllerType", ")", "\n", "newControllerType", ".", "Namespace", "=", "moduleSource", ".", "Namespace", "(", ")", "\n", "controllerName", ":=", "newControllerType", ".", "Name", "(", ")", "\n\n", "// Store the first controller only in the controllers map with the unmapped namespace.", "if", "_", ",", "found", ":=", "controllers", "[", "controllerName", "]", ";", "!", "found", "{", "controllers", "[", "controllerName", "]", "=", "newControllerType", "\n", "newControllerType", ".", "ModuleSource", ".", "AddController", "(", "newControllerType", ")", "\n", "if", "newControllerType", ".", "ModuleSource", "==", "appModule", "{", "// Add the controller mapping into the global namespace", "controllers", "[", "newControllerType", ".", "ShortName", "(", ")", "]", "=", "newControllerType", "\n", "}", "\n", "}", "else", "{", "controllerLog", ".", "Errorf", "(", "\"", "\"", ",", "controllerName", ")", "\n", "}", "\n", "controllerLog", ".", "Debugf", "(", "\"", "\"", ",", "controllerName", ")", "\n\n", "return", "\n", "}" ]

[ "Adds", "the", "controller", "to", "the", "controllers", "map", "using", "its", "namespace", "also", "adds", "it", "to", "the", "module", "list", "of", "controllers", ".", "If", "the", "controller", "is", "in", "the", "main", "application", "it", "is", "added", "without", "its", "namespace", "as", "well", "." ]

[ "func", "(", "cte", "*", "ControllerTypeEvents", ")", "check", "(", "theType", "reflect", ".", "Type", ",", "fieldPath", "[", "]", "int", ")", "{", "typeChecker", ":=", "func", "(", "checkType", "reflect", ".", "Type", ")", "{", "for", "index", ":=", "0", ";", "index", "<", "checkType", ".", "NumMethod", "(", ")", ";", "index", "++", "{", "m", ":=", "checkType", ".", "Method", "(", "index", ")", "\n", "// Must be two arguments, the second returns the controller type", "// Go cannot differentiate between promoted methods and", "// embedded methods, this allows the embedded method to be run", "// https://github.com/golang/go/issues/21162", "if", "m", ".", "Type", ".", "NumOut", "(", ")", "==", "2", "&&", "m", ".", "Type", ".", "Out", "(", "1", ")", "==", "checkType", "{", "if", "checkType", ".", "Kind", "(", ")", "==", "reflect", ".", "Ptr", "{", "controllerLog", ".", "Debug", "(", "\"", "\"", ",", "\"", "\"", ",", "checkType", ".", "Elem", "(", ")", ".", "Name", "(", ")", ",", "\"", "\"", ",", "m", ".", "Name", ")", "\n", "}", "else", "{", "controllerLog", ".", "Debug", "(", "\"", "\"", ",", "\"", "\"", ",", "checkType", ".", "Name", "(", ")", ",", "\"", "\"", ",", "m", ".", "Name", ")", "\n", "}", "\n", "controllerFieldPath", ":=", "newFieldPath", "(", "checkType", ".", "Kind", "(", ")", "==", "reflect", ".", "Ptr", ",", "m", ".", "Func", ",", "fieldPath", ")", "\n", "switch", "strings", ".", "ToLower", "(", "m", ".", "Name", ")", "{", "case", "\"", "\"", ":", "cte", ".", "Before", "=", "append", "(", "[", "]", "*", "ControllerFieldPath", "{", "controllerFieldPath", "}", ",", "cte", ".", "Before", "...", ")", "\n", "case", "\"", "\"", ":", "cte", ".", "After", "=", "append", "(", "cte", ".", "After", ",", "controllerFieldPath", ")", "\n", "case", "\"", "\"", ":", "cte", ".", "Panic", "=", "append", "(", "cte", ".", "Panic", ",", "controllerFieldPath", ")", "\n", "case", "\"", "\"", ":", "cte", ".", "Finally", "=", "append", "(", "cte", ".", "Finally", ",", "controllerFieldPath", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n\n", "// Check methods of both types", "typeChecker", "(", "theType", ")", "\n", "typeChecker", "(", "reflect", ".", "PtrTo", "(", "theType", ")", ")", "\n\n", "// Check for any sub controllers, ignore any pointers to controllers revel.Controller", "for", "i", ":=", "0", ";", "i", "<", "theType", ".", "NumField", "(", ")", ";", "i", "++", "{", "v", ":=", "theType", ".", "Field", "(", "i", ")", "\n\n", "switch", "v", ".", "Type", ".", "Kind", "(", ")", "{", "case", "reflect", ".", "Struct", ":", "cte", ".", "check", "(", "v", ".", "Type", ",", "append", "(", "fieldPath", ",", "i", ")", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "Add", "in", "before", "after", "panic", "and", "finally", "recursive", "call", "Befores", "are", "ordered", "in", "revers", "everything", "else", "is", "in", "order", "of", "first", "encountered" ]

[ "func", "(", "r", "ServerMuxList", ")", "Find", "(", "path", "string", ")", "(", "interface", "{", "}", ",", "bool", ")", "{", "for", "_", ",", "p", ":=", "range", "r", "{", "if", "p", ".", "PathPrefix", "==", "path", "||", "strings", ".", "HasPrefix", "(", "path", ",", "p", ".", "PathPrefix", ")", "{", "return", "p", ".", "Callback", ",", "true", "\n", "}", "\n", "}", "\n", "return", "nil", ",", "false", "\n", "}" ]

[ "Search", "function", "returns", "the", "largest", "path", "matching", "this" ]

[ "func", "handleInternal", "(", "ctx", "ServerContext", ")", "{", "start", ":=", "time", ".", "Now", "(", ")", "\n", "var", "c", "*", "Controller", "\n", "if", "RevelConfig", ".", "Controller", ".", "Reuse", "{", "c", "=", "RevelConfig", ".", "Controller", ".", "Stack", ".", "Pop", "(", ")", ".", "(", "*", "Controller", ")", "\n", "defer", "func", "(", ")", "{", "RevelConfig", ".", "Controller", ".", "Stack", ".", "Push", "(", "c", ")", "\n", "}", "(", ")", "\n", "}", "else", "{", "c", "=", "NewControllerEmpty", "(", ")", "\n", "}", "\n\n", "var", "(", "req", ",", "resp", "=", "c", ".", "Request", ",", "c", ".", "Response", "\n", ")", "\n", "c", ".", "SetController", "(", "ctx", ")", "\n", "req", ".", "WebSocket", ",", "_", "=", "ctx", ".", "GetResponse", "(", ")", ".", "(", "ServerWebSocket", ")", "\n\n", "clientIP", ":=", "ClientIP", "(", "req", ")", "\n\n", "// Once finished in the internal, we can return these to the stack", "c", ".", "ClientIP", "=", "clientIP", "\n", "c", ".", "Log", "=", "AppLog", ".", "New", "(", "\"", "\"", ",", "clientIP", ",", "\"", "\"", ",", "req", ".", "GetPath", "(", ")", ",", "\"", "\"", ",", "req", ".", "Method", ")", "\n", "// Call the first filter, this will process the request", "Filters", "[", "0", "]", "(", "c", ",", "Filters", "[", "1", ":", "]", ")", "\n", "if", "c", ".", "Result", "!=", "nil", "{", "c", ".", "Result", ".", "Apply", "(", "req", ",", "resp", ")", "\n", "}", "else", "if", "c", ".", "Response", ".", "Status", "!=", "0", "{", "c", ".", "Response", ".", "SetStatus", "(", "c", ".", "Response", ".", "Status", ")", "\n", "}", "\n", "// Close the Writer if we can", "if", "w", ",", "ok", ":=", "resp", ".", "GetWriter", "(", ")", ".", "(", "io", ".", "Closer", ")", ";", "ok", "{", "_", "=", "w", ".", "Close", "(", ")", "\n", "}", "\n\n", "// Revel request access log format", "// RequestStartTime ClientIP ResponseStatus RequestLatency HTTPMethod URLPath", "// Sample format: terminal format", "// INFO 2017/08/02 22:31:41 server-engine.go:168: Request Stats ip=::1 path=/public/img/favicon.png method=GET action=Static.Serve namespace=static\\\\ start=2017/08/02 22:31:41 status=200 duration_seconds=0.0007656", "// Recommended storing format to json code which looks like", "// {\"action\":\"Static.Serve\",\"caller\":\"server-engine.go:168\",\"duration_seconds\":0.00058336,\"ip\":\"::1\",\"lvl\":3,", "// \"method\":\"GET\",\"msg\":\"Request Stats\",\"namespace\":\"static\\\\\",\"path\":\"/public/img/favicon.png\",", "// \"start\":\"2017-08-02T22:34:08-0700\",\"status\":200,\"t\":\"2017-08-02T22:34:08.303112145-07:00\"}", "c", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "start", ",", "\"", "\"", ",", "c", ".", "Response", ".", "Status", ",", "\"", "\"", ",", "time", ".", "Since", "(", "start", ")", ".", "Seconds", "(", ")", ",", "\"", "\"", ",", "\"", "\"", ",", ")", "\n", "}" ]

[ "Callback", "point", "for", "the", "server", "to", "handle", "the" ]

[ "func", "MessageLanguages", "(", ")", "[", "]", "string", "{", "languages", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "messages", ")", ")", "\n", "i", ":=", "0", "\n", "for", "language", ":=", "range", "messages", "{", "languages", "[", "i", "]", "=", "language", "\n", "i", "++", "\n", "}", "\n", "return", "languages", "\n", "}" ]

[ "MessageLanguages", "returns", "all", "currently", "loaded", "message", "languages", "." ]

[ "func", "Message", "(", "locale", ",", "message", "string", ",", "args", "...", "interface", "{", "}", ")", "string", "{", "language", ",", "region", ":=", "parseLocale", "(", "locale", ")", "\n", "unknownValueFormat", ":=", "getUnknownValueFormat", "(", ")", "\n\n", "messageConfig", ",", "knownLanguage", ":=", "messages", "[", "language", "]", "\n", "if", "!", "knownLanguage", "{", "i18nLog", ".", "Debugf", "(", "\"", "\"", ",", "locale", ",", "message", ")", "\n\n", "if", "defaultLanguage", ",", "found", ":=", "Config", ".", "String", "(", "defaultLanguageOption", ")", ";", "found", "{", "i18nLog", ".", "Debugf", "(", "\"", "\"", ",", "defaultLanguage", ")", "\n\n", "messageConfig", ",", "knownLanguage", "=", "messages", "[", "defaultLanguage", "]", "\n", "if", "!", "knownLanguage", "{", "i18nLog", ".", "Debugf", "(", "\"", "\"", ",", "defaultLanguage", ",", "message", ")", "\n", "return", "fmt", ".", "Sprintf", "(", "unknownValueFormat", ",", "message", ")", "\n", "}", "\n", "}", "else", "{", "i18nLog", ".", "Warnf", "(", "\"", "\"", ",", "defaultLanguageOption", ")", "\n", "return", "fmt", ".", "Sprintf", "(", "unknownValueFormat", ",", "message", ")", "\n", "}", "\n", "}", "\n\n", "// This works because unlike the goconfig documentation suggests it will actually", "// try to resolve message in DEFAULT if it did not find it in the given section.", "value", ",", "err", ":=", "messageConfig", ".", "String", "(", "region", ",", "message", ")", "\n", "if", "err", "!=", "nil", "{", "i18nLog", ".", "Warnf", "(", "\"", "\"", ",", "message", ",", "locale", ")", "\n", "return", "fmt", ".", "Sprintf", "(", "unknownValueFormat", ",", "message", ")", "\n", "}", "\n\n", "if", "len", "(", "args", ")", ">", "0", "{", "i18nLog", ".", "Debugf", "(", "\"", "\"", ",", "value", ",", "args", ")", "\n", "safeArgs", ":=", "make", "(", "[", "]", "interface", "{", "}", ",", "0", ",", "len", "(", "args", ")", ")", "\n", "for", "_", ",", "arg", ":=", "range", "args", "{", "switch", "a", ":=", "arg", ".", "(", "type", ")", "{", "case", "template", ".", "HTML", ":", "safeArgs", "=", "append", "(", "safeArgs", ",", "a", ")", "\n", "case", "string", ":", "safeArgs", "=", "append", "(", "safeArgs", ",", "template", ".", "HTML", "(", "template", ".", "HTMLEscapeString", "(", "a", ")", ")", ")", "\n", "default", ":", "safeArgs", "=", "append", "(", "safeArgs", ",", "a", ")", "\n", "}", "\n", "}", "\n", "value", "=", "fmt", ".", "Sprintf", "(", "value", ",", "safeArgs", "...", ")", "\n", "}", "\n\n", "return", "value", "\n", "}" ]

[ "Message", "performs", "a", "message", "look", "-", "up", "for", "the", "given", "locale", "and", "message", "using", "the", "given", "arguments", ".", "When", "either", "an", "unknown", "locale", "or", "message", "is", "detected", "a", "specially", "formatted", "string", "is", "returned", "." ]

[ "func", "loadMessages", "(", "path", "string", ")", "{", "messages", "=", "make", "(", "map", "[", "string", "]", "*", "config", ".", "Config", ")", "\n\n", "// Read in messages from the modules. Load the module messges first,", "// so that it can be override in parent application", "for", "_", ",", "module", ":=", "range", "Modules", "{", "i18nLog", ".", "Debug", "(", "\"", "\"", ",", "\"", "\"", ",", "module", ".", "ImportPath", ")", "\n", "if", "err", ":=", "Walk", "(", "filepath", ".", "Join", "(", "module", ".", "Path", ",", "messageFilesDirectory", ")", ",", "loadMessageFile", ")", ";", "err", "!=", "nil", "&&", "!", "os", ".", "IsNotExist", "(", "err", ")", "{", "i18nLog", ".", "Error", "(", "\"", "\"", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n\n", "if", "err", ":=", "Walk", "(", "path", ",", "loadMessageFile", ")", ";", "err", "!=", "nil", "&&", "!", "os", ".", "IsNotExist", "(", "err", ")", "{", "i18nLog", ".", "Error", "(", "\"", "\"", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}" ]

[ "Recursively", "read", "and", "cache", "all", "available", "messages", "from", "all", "message", "files", "on", "the", "given", "path", "." ]