Datasets:

CM

/

codexglue_code2text_go

like 0

[ "func", "(", "rc", "*", "RequestConfig", ")", "SetFileFromPath", "(", "uploads", "[", "]", "UploadFile", ",", "params", "...", "H", ")", "*", "RequestConfig", "{", "body", ":=", "new", "(", "bytes", ".", "Buffer", ")", "\n", "writer", ":=", "multipart", ".", "NewWriter", "(", "body", ")", "\n\n", "for", "_", ",", "f", ":=", "range", "uploads", "{", "reader", ":=", "bytes", ".", "NewReader", "(", "f", ".", "Content", ")", "\n", "if", "reader", ".", "Size", "(", ")", "==", "0", "{", "file", ",", "err", ":=", "os", ".", "Open", "(", "f", ".", "Path", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Fatal", "(", "err", ")", "\n", "}", "\n\n", "defer", "file", ".", "Close", "(", ")", "\n", "part", ",", "err", ":=", "writer", ".", "CreateFormFile", "(", "f", ".", "Name", ",", "filepath", ".", "Base", "(", "f", ".", "Path", ")", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Fatal", "(", "err", ")", "\n", "}", "\n", "_", ",", "err", "=", "io", ".", "Copy", "(", "part", ",", "file", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Fatal", "(", "err", ")", "\n", "}", "\n", "}", "else", "{", "part", ",", "err", ":=", "writer", ".", "CreateFormFile", "(", "f", ".", "Name", ",", "filepath", ".", "Base", "(", "f", ".", "Path", ")", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Fatal", "(", "err", ")", "\n", "}", "\n", "_", ",", "err", "=", "reader", ".", "WriteTo", "(", "part", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Fatal", "(", "err", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "if", "len", "(", "params", ")", ">", "0", "{", "for", "key", ",", "val", ":=", "range", "params", "[", "0", "]", "{", "_", "=", "writer", ".", "WriteField", "(", "key", ",", "val", ")", "\n", "}", "\n", "}", "\n\n", "err", ":=", "writer", ".", "Close", "(", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Fatal", "(", "err", ")", "\n", "}", "\n\n", "rc", ".", "ContentType", "=", "writer", ".", "FormDataContentType", "(", ")", "\n", "rc", ".", "Body", "=", "body", ".", "String", "(", ")", "\n\n", "return", "rc", "\n", "}" ]

[ "SetFileFromPath", "upload", "new", "file", "." ]

[ "func", "(", "rc", "*", "RequestConfig", ")", "SetQuery", "(", "query", "H", ")", "*", "RequestConfig", "{", "f", ":=", "make", "(", "url", ".", "Values", ")", "\n\n", "for", "k", ",", "v", ":=", "range", "query", "{", "f", ".", "Set", "(", "k", ",", "v", ")", "\n", "}", "\n\n", "if", "strings", ".", "Contains", "(", "rc", ".", "Path", ",", "\"", "\"", ")", "{", "rc", ".", "Path", "=", "rc", ".", "Path", "+", "\"", "\"", "+", "f", ".", "Encode", "(", ")", "\n", "}", "else", "{", "rc", ".", "Path", "=", "rc", ".", "Path", "+", "\"", "\"", "+", "f", ".", "Encode", "(", ")", "\n", "}", "\n\n", "return", "rc", "\n", "}" ]

[ "SetQuery", "supply", "query", "string", "." ]

[ "func", "(", "rc", "*", "RequestConfig", ")", "SetBody", "(", "body", "string", ")", "*", "RequestConfig", "{", "if", "len", "(", "body", ")", ">", "0", "{", "rc", ".", "Body", "=", "body", "\n", "}", "\n\n", "return", "rc", "\n", "}" ]

[ "SetBody", "supply", "raw", "body", "." ]

[ "func", "(", "rc", "*", "RequestConfig", ")", "SetCookie", "(", "cookies", "H", ")", "*", "RequestConfig", "{", "if", "len", "(", "cookies", ")", ">", "0", "{", "rc", ".", "Cookies", "=", "cookies", "\n", "}", "\n\n", "return", "rc", "\n", "}" ]

[ "SetCookie", "supply", "cookies", "what", "you", "defined", "." ]

[ "func", "(", "rc", "*", "RequestConfig", ")", "Run", "(", "r", "http", ".", "Handler", ",", "response", "ResponseFunc", ")", "{", "req", ",", "w", ":=", "rc", ".", "initTest", "(", ")", "\n", "r", ".", "ServeHTTP", "(", "w", ",", "req", ")", "\n", "response", "(", "w", ",", "req", ")", "\n", "}" ]

[ "Run", "execute", "http", "request" ]

[ "func", "MuxEngine", "(", ")", "*", "mux", ".", "Router", "{", "r", ":=", "mux", ".", "NewRouter", "(", ")", "\n", "r", ".", "HandleFunc", "(", "\"", "\"", ",", "muxHelloHandler", ")", "\n\n", "return", "r", "\n", "}" ]

[ "MuxEngine", "is", "mux", "router", "." ]

[ "func", "fillOptions", "(", "opts", "*", "Options", ")", "*", "Options", "{", "if", "opts", "==", "nil", "{", "opts", "=", "&", "Options", "{", "}", "\n", "}", "\n", "// copy and reassign the options", "nopts", ":=", "*", "opts", "\n", "if", "nopts", ".", "LogOutput", "==", "nil", "{", "nopts", ".", "LogOutput", "=", "os", ".", "Stderr", "\n", "}", "\n", "return", "&", "nopts", "\n", "}" ]

[ "fillOptions", "fills", "in", "default", "options" ]

[ "func", "(", "n", "*", "Node", ")", "Close", "(", ")", "error", "{", "n", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "n", ".", "mu", ".", "Unlock", "(", ")", "\n", "// shutdown the raft, but do not handle the future error. :PPA:", "if", "n", ".", "raft", "!=", "nil", "{", "n", ".", "raft", ".", "Shutdown", "(", ")", ".", "Error", "(", ")", "\n", "}", "\n", "if", "n", ".", "trans", "!=", "nil", "{", "n", ".", "trans", ".", "Close", "(", ")", "\n", "}", "\n", "// close the raft database", "if", "n", ".", "store", "!=", "nil", "{", "n", ".", "store", ".", "Close", "(", ")", "\n", "}", "\n", "n", ".", "closed", "=", "true", "\n", "return", "nil", "\n", "}" ]

[ "Close", "closes", "the", "node" ]

[ "func", "reqRaftJoin", "(", "join", ",", "raftAddr", "string", ")", "error", "{", "resp", ",", "_", ",", "err", ":=", "raftredcon", ".", "Do", "(", "join", ",", "nil", ",", "[", "]", "byte", "(", "\"", "\"", ")", ",", "[", "]", "byte", "(", "raftAddr", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "string", "(", "resp", ")", "!=", "\"", "\"", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "reqRaftJoin", "does", "a", "remote", "RAFTJOIN", "command", "at", "the", "specified", "address", "." ]

[ "func", "scanForErrors", "(", "buf", "[", "]", "byte", ")", "[", "]", "[", "]", "byte", "{", "var", "res", "[", "]", "[", "]", "byte", "\n", "for", "len", "(", "buf", ")", ">", "0", "{", "if", "buf", "[", "0", "]", "!=", "'-'", "{", "return", "nil", "\n", "}", "\n", "buf", "=", "buf", "[", "1", ":", "]", "\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "buf", ")", ";", "i", "++", "{", "if", "buf", "[", "i", "]", "==", "'\\n'", "&&", "i", ">", "0", "&&", "buf", "[", "i", "-", "1", "]", "==", "'\\r'", "{", "res", "=", "append", "(", "res", ",", "buf", "[", ":", "i", "-", "1", "]", ")", "\n", "buf", "=", "buf", "[", "i", "+", "1", ":", "]", "\n", "break", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "res", "\n", "}" ]

[ "scanForErrors", "returns", "pipeline", "errors", ".", "All", "messages", "must", "be", "errors" ]

[ "func", "(", "n", "*", "Node", ")", "doCommand", "(", "conn", "redcon", ".", "Conn", ",", "cmd", "redcon", ".", "Command", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "if", "len", "(", "cmd", ".", "Args", ")", "==", "0", "{", "return", "nil", ",", "nil", "\n", "}", "\n", "var", "val", "interface", "{", "}", "\n", "var", "err", "error", "\n", "switch", "strings", ".", "ToLower", "(", "string", "(", "cmd", ".", "Args", "[", "0", "]", ")", ")", "{", "default", ":", "val", ",", "err", "=", "n", ".", "handler", ".", "Command", "(", "(", "*", "nodeApplier", ")", "(", "n", ")", ",", "conn", ",", "cmd", ")", "\n", "if", "err", "==", "ErrDisabled", "{", "err", "=", "ErrUnknownCommand", "\n", "}", "\n", "case", "\"", "\"", ":", "val", ",", "err", "=", "n", ".", "doRaftAddPeer", "(", "conn", ",", "cmd", ")", "\n", "case", "\"", "\"", ":", "val", ",", "err", "=", "n", ".", "doRaftRemovePeer", "(", "conn", ",", "cmd", ")", "\n", "case", "\"", "\"", ":", "val", ",", "err", "=", "n", ".", "doRaftLeader", "(", "conn", ",", "cmd", ")", "\n", "case", "\"", "\"", ":", "val", ",", "err", "=", "n", ".", "doRaftSnapshot", "(", "conn", ",", "cmd", ")", "\n", "case", "\"", "\"", ":", "val", ",", "err", "=", "n", ".", "doRaftShrinkLog", "(", "conn", ",", "cmd", ")", "\n", "case", "\"", "\"", ":", "val", ",", "err", "=", "n", ".", "doRaftState", "(", "conn", ",", "cmd", ")", "\n", "case", "\"", "\"", ":", "val", ",", "err", "=", "n", ".", "doRaftStats", "(", "conn", ",", "cmd", ")", "\n", "case", "\"", "\"", ":", "val", ",", "err", "=", "n", ".", "doRaftPeers", "(", "conn", ",", "cmd", ")", "\n", "case", "\"", "\"", ":", "val", ",", "err", "=", "n", ".", "doQuit", "(", "conn", ",", "cmd", ")", "\n", "case", "\"", "\"", ":", "val", ",", "err", "=", "n", ".", "doPing", "(", "conn", ",", "cmd", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "&&", "conn", "!=", "nil", "{", "// it's possible that this was a pipelined response.", "wr", ":=", "redcon", ".", "BaseWriter", "(", "conn", ")", "\n", "if", "wr", "!=", "nil", "{", "buf", ":=", "wr", ".", "Buffer", "(", ")", "\n", "rerrs", ":=", "scanForErrors", "(", "buf", ")", "\n", "if", "len", "(", "rerrs", ")", ">", "0", "{", "wr", ".", "SetBuffer", "(", "nil", ")", "\n", "for", "_", ",", "rerr", ":=", "range", "rerrs", "{", "conn", ".", "WriteError", "(", "n", ".", "translateError", "(", "errors", ".", "New", "(", "string", "(", "rerr", ")", ")", ",", "string", "(", "cmd", ".", "Args", "[", "0", "]", ")", ")", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "conn", ".", "WriteError", "(", "n", ".", "translateError", "(", "err", ",", "string", "(", "cmd", ".", "Args", "[", "0", "]", ")", ")", ")", "\n", "}", "\n", "return", "val", ",", "err", "\n", "}" ]

[ "doCommand", "executes", "a", "client", "command", "which", "is", "processed", "through", "the", "raft", "pipeline", "." ]

[ "func", "(", "n", "*", "Node", ")", "doPing", "(", "conn", "redcon", ".", "Conn", ",", "cmd", "redcon", ".", "Command", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "switch", "len", "(", "cmd", ".", "Args", ")", "{", "default", ":", "return", "nil", ",", "ErrWrongNumberOfArguments", "\n", "case", "1", ":", "conn", ".", "WriteString", "(", "\"", "\"", ")", "\n", "case", "2", ":", "conn", ".", "WriteBulk", "(", "cmd", ".", "Args", "[", "1", "]", ")", "\n", "}", "\n", "return", "nil", ",", "nil", "\n", "}" ]

[ "doPing", "handles", "a", "PING", "client", "command", "." ]

[ "func", "(", "n", "*", "Node", ")", "doRaftLeader", "(", "conn", "redcon", ".", "Conn", ",", "cmd", "redcon", ".", "Command", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "if", "len", "(", "cmd", ".", "Args", ")", "!=", "1", "{", "return", "nil", ",", "ErrWrongNumberOfArguments", "\n", "}", "\n", "leader", ":=", "n", ".", "raft", ".", "Leader", "(", ")", "\n", "if", "leader", "==", "\"", "\"", "{", "conn", ".", "WriteNull", "(", ")", "\n", "}", "else", "{", "conn", ".", "WriteBulkString", "(", "leader", ")", "\n", "}", "\n", "return", "nil", ",", "nil", "\n", "}" ]

[ "doRaftLeader", "handles", "a", "RAFTLEADER", "client", "command", "." ]

[ "func", "(", "n", "*", "Node", ")", "doRaftSnapshot", "(", "conn", "redcon", ".", "Conn", ",", "cmd", "redcon", ".", "Command", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "if", "len", "(", "cmd", ".", "Args", ")", "!=", "1", "{", "return", "nil", ",", "ErrWrongNumberOfArguments", "\n", "}", "\n", "f", ":=", "n", ".", "raft", ".", "Snapshot", "(", ")", "\n", "err", ":=", "f", ".", "Error", "(", ")", "\n", "if", "err", "!=", "nil", "{", "conn", ".", "WriteError", "(", "\"", "\"", "+", "err", ".", "Error", "(", ")", ")", "\n", "return", "nil", ",", "nil", "\n", "}", "\n", "conn", ".", "WriteString", "(", "\"", "\"", ")", "\n", "return", "nil", ",", "nil", "\n", "}" ]

[ "doRaftSnapshot", "handles", "a", "RAFTSNAPSHOT", "client", "command", "." ]

[ "func", "(", "n", "*", "Node", ")", "doRaftShrinkLog", "(", "conn", "redcon", ".", "Conn", ",", "cmd", "redcon", ".", "Command", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "if", "len", "(", "cmd", ".", "Args", ")", "!=", "1", "{", "return", "nil", ",", "ErrWrongNumberOfArguments", "\n", "}", "\n", "if", "s", ",", "ok", ":=", "n", ".", "store", ".", "(", "shrinkable", ")", ";", "ok", "{", "err", ":=", "s", ".", "Shrink", "(", ")", "\n", "if", "err", "!=", "nil", "{", "conn", ".", "WriteError", "(", "\"", "\"", "+", "err", ".", "Error", "(", ")", ")", "\n", "return", "nil", ",", "nil", "\n", "}", "\n", "conn", ".", "WriteString", "(", "\"", "\"", ")", "\n", "return", "nil", ",", "nil", "\n", "}", "\n", "conn", ".", "WriteError", "(", "\"", "\"", ")", "\n", "return", "nil", ",", "nil", "\n", "}" ]

[ "doRaftShrinkLog", "handles", "a", "RAFTSHRINKLOG", "client", "command", "." ]

[ "func", "(", "n", "*", "Node", ")", "doRaftState", "(", "conn", "redcon", ".", "Conn", ",", "cmd", "redcon", ".", "Command", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "if", "len", "(", "cmd", ".", "Args", ")", "!=", "1", "{", "return", "nil", ",", "ErrWrongNumberOfArguments", "\n", "}", "\n", "conn", ".", "WriteBulkString", "(", "n", ".", "raft", ".", "State", "(", ")", ".", "String", "(", ")", ")", "\n", "return", "nil", ",", "nil", "\n", "}" ]

[ "doRaftState", "handles", "a", "RAFTSTATE", "client", "command", "." ]

[ "func", "(", "n", "*", "Node", ")", "doQuit", "(", "conn", "redcon", ".", "Conn", ",", "cmd", "redcon", ".", "Command", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "conn", ".", "WriteString", "(", "\"", "\"", ")", "\n", "conn", ".", "Close", "(", ")", "\n", "return", "nil", ",", "nil", "\n", "}" ]

[ "doQuit", "handles", "a", "QUIT", "client", "command", "." ]

[ "func", "(", "n", "*", "Node", ")", "doRaftAddPeer", "(", "conn", "redcon", ".", "Conn", ",", "cmd", "redcon", ".", "Command", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "if", "len", "(", "cmd", ".", "Args", ")", "!=", "2", "{", "return", "nil", ",", "ErrWrongNumberOfArguments", "\n", "}", "\n", "n", ".", "log", ".", "Noticef", "(", "\"", "\"", ",", "string", "(", "cmd", ".", "Args", "[", "1", "]", ")", ")", "\n", "f", ":=", "n", ".", "raft", ".", "AddPeer", "(", "string", "(", "cmd", ".", "Args", "[", "1", "]", ")", ")", "\n", "if", "f", ".", "Error", "(", ")", "!=", "nil", "{", "return", "nil", ",", "f", ".", "Error", "(", ")", "\n", "}", "\n", "n", ".", "log", ".", "Noticef", "(", "\"", "\"", ",", "string", "(", "cmd", ".", "Args", "[", "1", "]", ")", ")", "\n", "conn", ".", "WriteString", "(", "\"", "\"", ")", "\n", "return", "nil", ",", "nil", "\n", "}" ]

[ "doRaftAddPeer", "handles", "a", "RAFTADDPEER", "address", "client", "command", "." ]

[ "func", "(", "n", "*", "Node", ")", "raftApplyCommand", "(", "cmd", "redcon", ".", "Command", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "f", ":=", "n", ".", "raft", ".", "Apply", "(", "cmd", ".", "Raw", ",", "raftTimeout", ")", "\n", "if", "err", ":=", "f", ".", "Error", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "// we check for the response to be an error and return it as such.", "switch", "v", ":=", "f", ".", "Response", "(", ")", ".", "(", "type", ")", "{", "default", ":", "return", "v", ",", "nil", "\n", "case", "error", ":", "return", "nil", ",", "v", "\n", "}", "\n", "}" ]

[ "raftApplyCommand", "encodes", "a", "series", "of", "args", "into", "a", "raft", "command", "and", "applies", "it", "to", "the", "index", "." ]

[ "func", "(", "m", "*", "nodeApplier", ")", "Apply", "(", "conn", "redcon", ".", "Conn", ",", "cmd", "redcon", ".", "Command", ",", "mutate", "func", "(", ")", "(", "interface", "{", "}", ",", "error", ")", ",", "respond", "func", "(", "interface", "{", "}", ")", "(", "interface", "{", "}", ",", "error", ")", ",", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "var", "val", "interface", "{", "}", "\n", "var", "err", "error", "\n", "if", "mutate", "==", "nil", "{", "// no apply, just do a level guard.", "if", "err", ":=", "(", "*", "Node", ")", "(", "m", ")", ".", "raftLevelGuard", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "else", "if", "conn", "==", "nil", "{", "// this is happening on a follower node.", "return", "mutate", "(", ")", "\n", "}", "else", "{", "// this is happening on the leader node.", "// apply the command to the raft log.", "val", ",", "err", "=", "(", "*", "Node", ")", "(", "m", ")", ".", "raftApplyCommand", "(", "cmd", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "// responde", "return", "respond", "(", "val", ")", "\n", "}" ]

[ "Apply", "executes", "a", "command", "through", "raft", ".", "The", "mutate", "param", "should", "be", "set", "to", "nil", "for", "readonly", "commands", ".", "The", "repsond", "param", "is", "required", "and", "any", "response", "to", "conn", "happens", "here", ".", "The", "return", "value", "from", "mutate", "will", "be", "passed", "into", "the", "respond", "param", "." ]

[ "func", "(", "m", "*", "nodeFSM", ")", "Apply", "(", "l", "*", "raft", ".", "Log", ")", "interface", "{", "}", "{", "if", "len", "(", "l", ".", "Data", ")", "==", "0", "{", "// blank data", "return", "nil", "\n", "}", "\n", "cmd", ",", "err", ":=", "redcon", ".", "Parse", "(", "l", ".", "Data", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "val", ",", "err", ":=", "(", "*", "Node", ")", "(", "m", ")", ".", "doCommand", "(", "nil", ",", "cmd", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "val", "\n", "}" ]

[ "Apply", "applies", "a", "Raft", "log", "entry", "to", "the", "key", "-", "value", "store", "." ]

[ "func", "(", "m", "*", "nodeFSM", ")", "Restore", "(", "rc", "io", ".", "ReadCloser", ")", "error", "{", "defer", "rc", ".", "Close", "(", ")", "\n", "return", "(", "*", "Node", ")", "(", "m", ")", ".", "handler", ".", "Restore", "(", "rc", ")", "\n", "}" ]

[ "Restore", "stores", "the", "key", "-", "value", "store", "to", "a", "previous", "state", "." ]

[ "func", "(", "kvm", "*", "Clone", ")", "Restore", "(", "rd", "io", ".", "Reader", ")", "error", "{", "kvm", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "kvm", ".", "mu", ".", "Unlock", "(", ")", "\n", "data", ",", "err", ":=", "ioutil", ".", "ReadAll", "(", "rd", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "var", "keys", "map", "[", "string", "]", "[", "]", "byte", "\n", "if", "err", ":=", "json", ".", "Unmarshal", "(", "data", ",", "&", "keys", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "kvm", ".", "keys", "=", "keys", "\n", "return", "nil", "\n", "}" ]

[ "Restore", "restores", "a", "snapshot" ]

[ "func", "(", "pm", "*", "pointerMap", ")", "consider", "(", "v", "reflect", ".", "Value", ")", "{", "if", "v", ".", "Kind", "(", ")", "==", "reflect", ".", "Invalid", "{", "return", "\n", "}", "\n", "// fmt.Printf(\"Considering [%s] %#v\\n\\r\", v.Type().String(), v.Interface())", "if", "isPointerValue", "(", "v", ")", "&&", "v", ".", "Pointer", "(", ")", "!=", "0", "{", "// pointer is 0 for unexported fields", "// fmt.Printf(\"Ptr is %d\\n\\r\", v.Pointer())", "reused", ":=", "pm", ".", "addPointerReturnTrueIfWasReused", "(", "v", ".", "Pointer", "(", ")", ")", "\n", "if", "reused", "{", "// No use descending inside this value, since it have been seen before and all its descendants", "// have been considered", "return", "\n", "}", "\n", "}", "\n\n", "// Now descend into any children of this value", "switch", "v", ".", "Kind", "(", ")", "{", "case", "reflect", ".", "Slice", ",", "reflect", ".", "Array", ":", "numEntries", ":=", "v", ".", "Len", "(", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "numEntries", ";", "i", "++", "{", "pm", ".", "consider", "(", "v", ".", "Index", "(", "i", ")", ")", "\n", "}", "\n\n", "case", "reflect", ".", "Interface", ":", "pm", ".", "consider", "(", "v", ".", "Elem", "(", ")", ")", "\n\n", "case", "reflect", ".", "Ptr", ":", "pm", ".", "consider", "(", "v", ".", "Elem", "(", ")", ")", "\n\n", "case", "reflect", ".", "Map", ":", "keys", ":=", "v", ".", "MapKeys", "(", ")", "\n", "sort", ".", "Sort", "(", "mapKeySorter", "{", "keys", ":", "keys", ",", "options", ":", "&", "Config", ",", "}", ")", "\n", "for", "_", ",", "key", ":=", "range", "keys", "{", "pm", ".", "consider", "(", "v", ".", "MapIndex", "(", "key", ")", ")", "\n", "}", "\n\n", "case", "reflect", ".", "Struct", ":", "numFields", ":=", "v", ".", "NumField", "(", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "numFields", ";", "i", "++", "{", "pm", ".", "consider", "(", "v", ".", "Field", "(", "i", ")", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "Recursively", "consider", "v", "and", "each", "of", "its", "children", "updating", "the", "map", "according", "to", "the", "semantics", "of", "MapReusedPointers" ]

[ "func", "(", "s", "*", "dumpState", ")", "pointerNameFor", "(", "v", "reflect", ".", "Value", ")", "(", "string", ",", "bool", ")", "{", "if", "isPointerValue", "(", "v", ")", "{", "ptr", ":=", "v", ".", "Pointer", "(", ")", "\n", "for", "i", ",", "addr", ":=", "range", "s", ".", "pointers", "{", "if", "ptr", "==", "addr", "{", "firstVisit", ":=", "s", ".", "visitPointerAndCheckIfItIsTheFirstTime", "(", "ptr", ")", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "i", ")", ",", "firstVisit", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "\"", "\"", ",", "false", "\n", "}" ]

[ "registers", "that", "the", "value", "has", "been", "visited", "and", "checks", "to", "see", "if", "it", "is", "one", "of", "the", "pointers", "we", "will", "see", "multiple", "times", ".", "If", "it", "is", "it", "returns", "a", "temporary", "name", "for", "this", "pointer", ".", "It", "also", "returns", "a", "boolean", "value", "indicating", "whether", "this", "is", "the", "first", "time", "this", "name", "is", "returned", "so", "the", "caller", "can", "decide", "whether", "the", "contents", "of", "the", "pointer", "has", "been", "dumped", "before", "or", "not", "." ]

[ "func", "NewDRWMutex", "(", "name", "string", ",", "clnt", "*", "Dsync", ")", "*", "DRWMutex", "{", "return", "&", "DRWMutex", "{", "Name", ":", "name", ",", "writeLocks", ":", "make", "(", "[", "]", "string", ",", "clnt", ".", "dNodeCount", ")", ",", "clnt", ":", "clnt", ",", "}", "\n", "}" ]

[ "NewDRWMutex", "-", "initializes", "a", "new", "dsync", "RW", "mutex", "." ]

[ "func", "(", "dm", "*", "DRWMutex", ")", "Lock", "(", "id", ",", "source", "string", ")", "{", "isReadLock", ":=", "false", "\n", "dm", ".", "lockBlocking", "(", "drwMutexInfinite", ",", "id", ",", "source", ",", "isReadLock", ")", "\n", "}" ]

[ "Lock", "holds", "a", "write", "lock", "on", "dm", ".", "If", "the", "lock", "is", "already", "in", "use", "the", "calling", "go", "routine", "blocks", "until", "the", "mutex", "is", "available", "." ]

[ "func", "(", "dm", "*", "DRWMutex", ")", "GetLock", "(", "id", ",", "source", "string", ",", "timeout", "time", ".", "Duration", ")", "(", "locked", "bool", ")", "{", "isReadLock", ":=", "false", "\n", "return", "dm", ".", "lockBlocking", "(", "timeout", ",", "id", ",", "source", ",", "isReadLock", ")", "\n", "}" ]

[ "GetLock", "tries", "to", "get", "a", "write", "lock", "on", "dm", "before", "the", "timeout", "elapses", ".", "If", "the", "lock", "is", "already", "in", "use", "the", "calling", "go", "routine", "blocks", "until", "either", "the", "mutex", "becomes", "available", "and", "return", "success", "or", "more", "time", "has", "passed", "than", "the", "timeout", "value", "and", "return", "false", "." ]

[ "func", "(", "dm", "*", "DRWMutex", ")", "RLock", "(", "id", ",", "source", "string", ")", "{", "isReadLock", ":=", "true", "\n", "dm", ".", "lockBlocking", "(", "drwMutexInfinite", ",", "id", ",", "source", ",", "isReadLock", ")", "\n", "}" ]

[ "RLock", "holds", "a", "read", "lock", "on", "dm", ".", "If", "one", "or", "more", "read", "locks", "are", "already", "in", "use", "it", "will", "grant", "another", "lock", ".", "Otherwise", "the", "calling", "go", "routine", "blocks", "until", "the", "mutex", "is", "available", "." ]

[ "func", "(", "dm", "*", "DRWMutex", ")", "GetRLock", "(", "id", ",", "source", "string", ",", "timeout", "time", ".", "Duration", ")", "(", "locked", "bool", ")", "{", "isReadLock", ":=", "true", "\n", "return", "dm", ".", "lockBlocking", "(", "timeout", ",", "id", ",", "source", ",", "isReadLock", ")", "\n", "}" ]

[ "GetRLock", "tries", "to", "get", "a", "read", "lock", "on", "dm", "before", "the", "timeout", "elapses", ".", "If", "one", "or", "more", "read", "locks", "are", "already", "in", "use", "it", "will", "grant", "another", "lock", ".", "Otherwise", "the", "calling", "go", "routine", "blocks", "until", "either", "the", "mutex", "becomes", "available", "and", "return", "success", "or", "more", "time", "has", "passed", "than", "the", "timeout", "value", "and", "return", "false", "." ]

[ "func", "(", "dm", "*", "DRWMutex", ")", "lockBlocking", "(", "timeout", "time", ".", "Duration", ",", "id", ",", "source", "string", ",", "isReadLock", "bool", ")", "(", "locked", "bool", ")", "{", "doneCh", ",", "start", ":=", "make", "(", "chan", "struct", "{", "}", ")", ",", "time", ".", "Now", "(", ")", ".", "UTC", "(", ")", "\n", "defer", "close", "(", "doneCh", ")", "\n\n", "// Use incremental back-off algorithm for repeated attempts to acquire the lock", "for", "range", "newRetryTimerSimple", "(", "doneCh", ")", "{", "// Create temp array on stack.", "locks", ":=", "make", "(", "[", "]", "string", ",", "dm", ".", "clnt", ".", "dNodeCount", ")", "\n\n", "// Try to acquire the lock.", "success", ":=", "lock", "(", "dm", ".", "clnt", ",", "&", "locks", ",", "dm", ".", "Name", ",", "id", ",", "source", ",", "isReadLock", ")", "\n", "if", "success", "{", "dm", ".", "m", ".", "Lock", "(", ")", "\n", "defer", "dm", ".", "m", ".", "Unlock", "(", ")", "\n\n", "// If success, copy array to object", "if", "isReadLock", "{", "// Append new array of strings at the end", "dm", ".", "readersLocks", "=", "append", "(", "dm", ".", "readersLocks", ",", "make", "(", "[", "]", "string", ",", "dm", ".", "clnt", ".", "dNodeCount", ")", ")", "\n", "// and copy stack array into last spot", "copy", "(", "dm", ".", "readersLocks", "[", "len", "(", "dm", ".", "readersLocks", ")", "-", "1", "]", ",", "locks", "[", ":", "]", ")", "\n", "}", "else", "{", "copy", "(", "dm", ".", "writeLocks", ",", "locks", "[", ":", "]", ")", "\n", "}", "\n\n", "return", "true", "\n", "}", "\n", "if", "time", ".", "Now", "(", ")", ".", "UTC", "(", ")", ".", "Sub", "(", "start", ")", ">=", "timeout", "{", "// Are we past the timeout?", "break", "\n", "}", "\n", "// Failed to acquire the lock on this attempt, incrementally wait", "// for a longer back-off time and try again afterwards.", "}", "\n", "return", "false", "\n", "}" ]

[ "lockBlocking", "will", "try", "to", "acquire", "either", "a", "read", "or", "a", "write", "lock", "The", "function", "will", "loop", "using", "a", "built", "-", "in", "timing", "randomized", "back", "-", "off", "algorithm", "until", "either", "the", "lock", "is", "acquired", "successfully", "or", "more", "time", "has", "elapsed", "than", "the", "timeout", "value", "." ]

[ "func", "quorumMet", "(", "locks", "*", "[", "]", "string", ",", "isReadLock", "bool", ",", "quorum", ",", "quorumReads", "int", ")", "bool", "{", "count", ":=", "0", "\n", "for", "_", ",", "uid", ":=", "range", "*", "locks", "{", "if", "isLocked", "(", "uid", ")", "{", "count", "++", "\n", "}", "\n", "}", "\n\n", "var", "metQuorum", "bool", "\n", "if", "isReadLock", "{", "metQuorum", "=", "count", ">=", "quorumReads", "\n", "}", "else", "{", "metQuorum", "=", "count", ">=", "quorum", "\n", "}", "\n\n", "return", "metQuorum", "\n", "}" ]

[ "quorumMet", "determines", "whether", "we", "have", "acquired", "the", "required", "quorum", "of", "underlying", "locks", "or", "not" ]

[ "func", "releaseAll", "(", "ds", "*", "Dsync", ",", "locks", "*", "[", "]", "string", ",", "lockName", "string", ",", "isReadLock", "bool", ")", "{", "for", "lock", ":=", "0", ";", "lock", "<", "ds", ".", "dNodeCount", ";", "lock", "++", "{", "if", "isLocked", "(", "(", "*", "locks", ")", "[", "lock", "]", ")", "{", "sendRelease", "(", "ds", ",", "ds", ".", "rpcClnts", "[", "lock", "]", ",", "lockName", ",", "(", "*", "locks", ")", "[", "lock", "]", ",", "isReadLock", ")", "\n", "(", "*", "locks", ")", "[", "lock", "]", "=", "\"", "\"", "\n", "}", "\n", "}", "\n", "}" ]

[ "releaseAll", "releases", "all", "locks", "that", "are", "marked", "as", "locked" ]

[ "func", "(", "dm", "*", "DRWMutex", ")", "Unlock", "(", ")", "{", "// create temp array on stack", "locks", ":=", "make", "(", "[", "]", "string", ",", "dm", ".", "clnt", ".", "dNodeCount", ")", "\n\n", "{", "dm", ".", "m", ".", "Lock", "(", ")", "\n", "defer", "dm", ".", "m", ".", "Unlock", "(", ")", "\n\n", "// Check if minimally a single bool is set in the writeLocks array", "lockFound", ":=", "false", "\n", "for", "_", ",", "uid", ":=", "range", "dm", ".", "writeLocks", "{", "if", "isLocked", "(", "uid", ")", "{", "lockFound", "=", "true", "\n", "break", "\n", "}", "\n", "}", "\n", "if", "!", "lockFound", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// Copy write locks to stack array", "copy", "(", "locks", ",", "dm", ".", "writeLocks", "[", ":", "]", ")", "\n", "// Clear write locks array", "dm", ".", "writeLocks", "=", "make", "(", "[", "]", "string", ",", "dm", ".", "clnt", ".", "dNodeCount", ")", "\n", "}", "\n\n", "isReadLock", ":=", "false", "\n", "unlock", "(", "dm", ".", "clnt", ",", "locks", ",", "dm", ".", "Name", ",", "isReadLock", ")", "\n", "}" ]

[ "Unlock", "unlocks", "the", "write", "lock", ".", "It", "is", "a", "run", "-", "time", "error", "if", "dm", "is", "not", "locked", "on", "entry", "to", "Unlock", "." ]

[ "func", "(", "dm", "*", "DRWMutex", ")", "RUnlock", "(", ")", "{", "// create temp array on stack", "locks", ":=", "make", "(", "[", "]", "string", ",", "dm", ".", "clnt", ".", "dNodeCount", ")", "\n\n", "{", "dm", ".", "m", ".", "Lock", "(", ")", "\n", "defer", "dm", ".", "m", ".", "Unlock", "(", ")", "\n", "if", "len", "(", "dm", ".", "readersLocks", ")", "==", "0", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "// Copy out first element to release it first (FIFO)", "copy", "(", "locks", ",", "dm", ".", "readersLocks", "[", "0", "]", "[", ":", "]", ")", "\n", "// Drop first element from array", "dm", ".", "readersLocks", "=", "dm", ".", "readersLocks", "[", "1", ":", "]", "\n", "}", "\n\n", "isReadLock", ":=", "true", "\n", "unlock", "(", "dm", ".", "clnt", ",", "locks", ",", "dm", ".", "Name", ",", "isReadLock", ")", "\n", "}" ]

[ "RUnlock", "releases", "a", "read", "lock", "held", "on", "dm", ".", "It", "is", "a", "run", "-", "time", "error", "if", "dm", "is", "not", "locked", "on", "entry", "to", "RUnlock", "." ]

[ "func", "(", "dm", "*", "DRWMutex", ")", "ForceUnlock", "(", ")", "{", "{", "dm", ".", "m", ".", "Lock", "(", ")", "\n", "defer", "dm", ".", "m", ".", "Unlock", "(", ")", "\n\n", "// Clear write locks array", "dm", ".", "writeLocks", "=", "make", "(", "[", "]", "string", ",", "dm", ".", "clnt", ".", "dNodeCount", ")", "\n", "// Clear read locks array", "dm", ".", "readersLocks", "=", "nil", "\n", "}", "\n\n", "for", "_", ",", "c", ":=", "range", "dm", ".", "clnt", ".", "rpcClnts", "{", "// broadcast lock release to all nodes that granted the lock", "sendRelease", "(", "dm", ".", "clnt", ",", "c", ",", "dm", ".", "Name", ",", "\"", "\"", ",", "false", ")", "\n", "}", "\n", "}" ]

[ "ForceUnlock", "will", "forcefully", "clear", "a", "write", "or", "read", "lock", "." ]

[ "func", "sendRelease", "(", "ds", "*", "Dsync", ",", "c", "NetLocker", ",", "name", ",", "uid", "string", ",", "isReadLock", "bool", ")", "{", "args", ":=", "LockArgs", "{", "UID", ":", "uid", ",", "Resource", ":", "name", ",", "ServerAddr", ":", "ds", ".", "rpcClnts", "[", "ds", ".", "ownNode", "]", ".", "ServerAddr", "(", ")", ",", "ServiceEndpoint", ":", "ds", ".", "rpcClnts", "[", "ds", ".", "ownNode", "]", ".", "ServiceEndpoint", "(", ")", ",", "}", "\n", "if", "len", "(", "uid", ")", "==", "0", "{", "if", "_", ",", "err", ":=", "c", ".", "ForceUnlock", "(", "args", ")", ";", "err", "!=", "nil", "{", "log", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "else", "if", "isReadLock", "{", "if", "_", ",", "err", ":=", "c", ".", "RUnlock", "(", "args", ")", ";", "err", "!=", "nil", "{", "log", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "else", "{", "if", "_", ",", "err", ":=", "c", ".", "Unlock", "(", "args", ")", ";", "err", "!=", "nil", "{", "log", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "sendRelease", "sends", "a", "release", "message", "to", "a", "node", "that", "previously", "granted", "a", "lock" ]

[ "func", "New", "(", "rpcClnts", "[", "]", "NetLocker", ",", "rpcOwnNode", "int", ")", "(", "*", "Dsync", ",", "error", ")", "{", "if", "len", "(", "rpcClnts", ")", "<", "2", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "else", "if", "len", "(", "rpcClnts", ")", ">", "32", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "rpcOwnNode", ">", "len", "(", "rpcClnts", ")", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "ds", ":=", "&", "Dsync", "{", "}", "\n", "ds", ".", "dNodeCount", "=", "len", "(", "rpcClnts", ")", "\n\n", "// With odd number of nodes, write and read quorum is basically the same", "ds", ".", "dquorum", "=", "int", "(", "ds", ".", "dNodeCount", "/", "2", ")", "+", "1", "\n", "ds", ".", "dquorumReads", "=", "int", "(", "math", ".", "Ceil", "(", "float64", "(", "ds", ".", "dNodeCount", ")", "/", "2.0", ")", ")", "\n", "ds", ".", "ownNode", "=", "rpcOwnNode", "\n\n", "// Initialize node name and rpc path for each NetLocker object.", "ds", ".", "rpcClnts", "=", "make", "(", "[", "]", "NetLocker", ",", "ds", ".", "dNodeCount", ")", "\n", "copy", "(", "ds", ".", "rpcClnts", ",", "rpcClnts", ")", "\n\n", "return", "ds", ",", "nil", "\n", "}" ]

[ "New", "-", "initializes", "a", "new", "dsync", "object", "with", "input", "rpcClnts", "." ]

[ "func", "newClient", "(", "addr", ",", "endpoint", "string", ")", "*", "ReconnectRPCClient", "{", "return", "&", "ReconnectRPCClient", "{", "addr", ":", "addr", ",", "endpoint", ":", "endpoint", ",", "}", "\n", "}" ]

[ "newClient", "constructs", "a", "ReconnectRPCClient", "object", "with", "addr", "and", "endpoint", "initialized", ".", "It", "_doesn", "t_", "connect", "to", "the", "remote", "endpoint", ".", "See", "Call", "method", "to", "see", "when", "the", "connect", "happens", "." ]

[ "func", "(", "l", "*", "lockServer", ")", "RLock", "(", "args", "*", "dsync", ".", "LockArgs", ",", "reply", "*", "bool", ")", "error", "{", "l", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "l", ".", "mutex", ".", "Unlock", "(", ")", "\n", "lrInfo", ":=", "lockRequesterInfo", "{", "writer", ":", "false", ",", "serverAddr", ":", "args", ".", "ServerAddr", ",", "rpcPath", ":", "args", ".", "ServiceEndpoint", ",", "uid", ":", "args", ".", "UID", ",", "timestamp", ":", "time", ".", "Now", "(", ")", ".", "UTC", "(", ")", ",", "timeLastCheck", ":", "time", ".", "Now", "(", ")", ".", "UTC", "(", ")", ",", "}", "\n", "if", "lri", ",", "ok", ":=", "l", ".", "lockMap", "[", "args", ".", "Resource", "]", ";", "ok", "{", "if", "*", "reply", "=", "!", "isWriteLock", "(", "lri", ")", ";", "*", "reply", "{", "// Unless there is a write lock", "l", ".", "lockMap", "[", "args", ".", "Resource", "]", "=", "append", "(", "l", ".", "lockMap", "[", "args", ".", "Resource", "]", ",", "lrInfo", ")", "\n", "}", "\n", "}", "else", "{", "// No locks held on the given name, so claim (first) read lock", "l", ".", "lockMap", "[", "args", ".", "Resource", "]", "=", "[", "]", "lockRequesterInfo", "{", "lrInfo", "}", "\n", "*", "reply", "=", "true", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "RLock", "-", "rpc", "handler", "for", "read", "lock", "operation", "." ]

[ "func", "(", "l", "*", "lockServer", ")", "ForceUnlock", "(", "args", "*", "dsync", ".", "LockArgs", ",", "reply", "*", "bool", ")", "error", "{", "l", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "l", ".", "mutex", ".", "Unlock", "(", ")", "\n", "if", "len", "(", "args", ".", "UID", ")", "!=", "0", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "args", ".", "UID", ")", "\n", "}", "\n", "if", "_", ",", "ok", ":=", "l", ".", "lockMap", "[", "args", ".", "Resource", "]", ";", "ok", "{", "// Only clear lock when set", "delete", "(", "l", ".", "lockMap", ",", "args", ".", "Resource", ")", "// Remove the lock (irrespective of write or read lock)", "\n", "}", "\n", "*", "reply", "=", "true", "\n", "return", "nil", "\n", "}" ]

[ "ForceUnlock", "-", "rpc", "handler", "for", "force", "unlock", "operation", "." ]

[ "func", "(", "l", "*", "lockServer", ")", "Expired", "(", "args", "*", "dsync", ".", "LockArgs", ",", "reply", "*", "bool", ")", "error", "{", "l", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "l", ".", "mutex", ".", "Unlock", "(", ")", "\n", "if", "lri", ",", "ok", ":=", "l", ".", "lockMap", "[", "args", ".", "Resource", "]", ";", "ok", "{", "// Check whether uid is still active for this name", "for", "_", ",", "entry", ":=", "range", "lri", "{", "if", "entry", ".", "uid", "==", "args", ".", "UID", "{", "*", "reply", "=", "false", "// When uid found, lock is still active so return not expired", "\n", "return", "nil", "\n", "}", "\n", "}", "\n", "}", "\n", "// When we get here, lock is no longer active due to either args.Resource being absent from map", "// or uid not found for given args.Resource", "*", "reply", "=", "true", "\n", "return", "nil", "\n", "}" ]

[ "Expired", "-", "rpc", "handler", "for", "expired", "lock", "status", "." ]

[ "func", "newRetryTimer", "(", "unit", "time", ".", "Duration", ",", "cap", "time", ".", "Duration", ",", "doneCh", "chan", "struct", "{", "}", ")", "<-", "chan", "int", "{", "return", "newRetryTimerWithJitter", "(", "unit", ",", "cap", ",", "MaxJitter", ",", "doneCh", ")", "\n", "}" ]

[ "newRetryTimer", "creates", "a", "timer", "with", "exponentially", "increasing", "delays", "until", "the", "maximum", "retry", "attempts", "are", "reached", ".", "-", "this", "function", "provides", "resulting", "retry", "values", "to", "be", "of", "maximum", "jitter", "." ]

[ "func", "(", "rpcClient", "*", "ReconnectRPCClient", ")", "dial", "(", ")", "(", "*", "rpc", ".", "Client", ",", "error", ")", "{", "rpcClient", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "rpcClient", ".", "mutex", ".", "Unlock", "(", ")", "\n\n", "// Nothing to do as we already have valid connection.", "if", "rpcClient", ".", "netRPCClient", "!=", "nil", "{", "return", "rpcClient", ".", "netRPCClient", ",", "nil", "\n", "}", "\n\n", "// Dial with 3 seconds timeout.", "conn", ",", "err", ":=", "net", ".", "DialTimeout", "(", "\"", "\"", ",", "rpcClient", ".", "serverAddr", ",", "defaultDialTimeout", ")", "\n", "if", "err", "!=", "nil", "{", "// Print RPC connection errors that are worthy to display in log", "switch", "err", ".", "(", "type", ")", "{", "case", "x509", ".", "HostnameError", ":", "log", ".", "Println", "(", "\"", "\"", ",", "rpcClient", ".", "serverAddr", ")", "\n", "log", ".", "Println", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "nil", ",", "&", "net", ".", "OpError", "{", "Op", ":", "\"", "\"", ",", "Net", ":", "rpcClient", ".", "serverAddr", "+", "\"", "\"", "+", "rpcClient", ".", "serviceEndpoint", ",", "Addr", ":", "nil", ",", "Err", ":", "err", ",", "}", "\n", "}", "\n\n", "io", ".", "WriteString", "(", "conn", ",", "\"", "\"", "+", "rpcClient", ".", "serviceEndpoint", "+", "\"", "\\n", "\\n", "\"", ")", "\n\n", "// Require successful HTTP response before switching to RPC protocol.", "resp", ",", "err", ":=", "http", ".", "ReadResponse", "(", "bufio", ".", "NewReader", "(", "conn", ")", ",", "&", "http", ".", "Request", "{", "Method", ":", "\"", "\"", "}", ")", "\n", "if", "err", "==", "nil", "&&", "resp", ".", "Status", "==", "\"", "\"", "{", "netRPCClient", ":=", "rpc", ".", "NewClient", "(", "conn", ")", "\n", "if", "netRPCClient", "==", "nil", "{", "return", "nil", ",", "&", "net", ".", "OpError", "{", "Op", ":", "\"", "\"", ",", "Net", ":", "rpcClient", ".", "serverAddr", "+", "\"", "\"", "+", "rpcClient", ".", "serviceEndpoint", ",", "Addr", ":", "nil", ",", "Err", ":", "fmt", ".", "Errorf", "(", "\"", "\"", ")", ",", "}", "\n", "}", "\n\n", "rpcClient", ".", "netRPCClient", "=", "netRPCClient", "\n\n", "return", "netRPCClient", ",", "nil", "\n", "}", "\n\n", "if", "err", "==", "nil", "{", "err", "=", "errors", ".", "New", "(", "\"", "\"", "+", "resp", ".", "Status", ")", "\n", "}", "\n\n", "conn", ".", "Close", "(", ")", "\n", "return", "nil", ",", "&", "net", ".", "OpError", "{", "Op", ":", "\"", "\"", ",", "Net", ":", "rpcClient", ".", "serverAddr", "+", "\"", "\"", "+", "rpcClient", ".", "serviceEndpoint", ",", "Addr", ":", "nil", ",", "Err", ":", "err", ",", "}", "\n", "}" ]

[ "dial", "tries", "to", "establish", "a", "connection", "to", "serverAddr", "in", "a", "safe", "manner", ".", "If", "there", "is", "a", "valid", "rpc", ".", "Cliemt", "it", "returns", "that", "else", "creates", "a", "new", "one", "." ]

[ "func", "FuncHasQuery", "(", "sqlPackages", "sqlPackage", ",", "s", "*", "types", ".", "Signature", ")", "(", "offset", "int", ",", "ok", "bool", ")", "{", "params", ":=", "s", ".", "Params", "(", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "params", ".", "Len", "(", ")", ";", "i", "++", "{", "v", ":=", "params", ".", "At", "(", "i", ")", "\n", "for", "_", ",", "paramName", ":=", "range", "sqlPackages", ".", "paramNames", "{", "if", "v", ".", "Name", "(", ")", "==", "paramName", "{", "return", "i", ",", "true", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "0", ",", "false", "\n", "}" ]

[ "FuncHasQuery", "returns", "the", "offset", "of", "the", "string", "parameter", "named", "query", "or", "none", "if", "no", "such", "parameter", "exists", "." ]

[ "func", "FindMains", "(", "p", "*", "loader", ".", "Program", ",", "s", "*", "ssa", ".", "Program", ")", "[", "]", "*", "ssa", ".", "Package", "{", "ips", ":=", "p", ".", "InitialPackages", "(", ")", "\n", "mains", ":=", "make", "(", "[", "]", "*", "ssa", ".", "Package", ",", "0", ",", "len", "(", "ips", ")", ")", "\n", "for", "_", ",", "info", ":=", "range", "ips", "{", "ssaPkg", ":=", "s", ".", "Package", "(", "info", ".", "Pkg", ")", "\n", "if", "ssaPkg", ".", "Func", "(", "\"", "\"", ")", "!=", "nil", "{", "mains", "=", "append", "(", "mains", ",", "ssaPkg", ")", "\n", "}", "\n", "}", "\n", "return", "mains", "\n", "}" ]

[ "FindMains", "returns", "the", "set", "of", "all", "packages", "loaded", "into", "the", "given", "loader", ".", "Program", "which", "contain", "main", "functions" ]

[ "func", "FindNonConstCalls", "(", "cg", "*", "callgraph", ".", "Graph", ",", "qms", "[", "]", "*", "QueryMethod", ")", "[", "]", "ssa", ".", "CallInstruction", "{", "cg", ".", "DeleteSyntheticNodes", "(", ")", "\n\n", "// package database/sql has a couple helper functions which are thin", "// wrappers around other sensitive functions. Instead of handling the", "// general case by tracing down callsites of wrapper functions", "// recursively, let's just whitelist the functions we're already", "// tracking, since it happens to be good enough for our use case.", "okFuncs", ":=", "make", "(", "map", "[", "*", "ssa", ".", "Function", "]", "struct", "{", "}", ",", "len", "(", "qms", ")", ")", "\n", "for", "_", ",", "m", ":=", "range", "qms", "{", "okFuncs", "[", "m", ".", "SSA", "]", "=", "struct", "{", "}", "{", "}", "\n", "}", "\n\n", "bad", ":=", "make", "(", "[", "]", "ssa", ".", "CallInstruction", ",", "0", ")", "\n", "for", "_", ",", "m", ":=", "range", "qms", "{", "node", ":=", "cg", ".", "CreateNode", "(", "m", ".", "SSA", ")", "\n", "for", "_", ",", "edge", ":=", "range", "node", ".", "In", "{", "if", "_", ",", "ok", ":=", "okFuncs", "[", "edge", ".", "Site", ".", "Parent", "(", ")", "]", ";", "ok", "{", "continue", "\n", "}", "\n\n", "isInternalSQLPkg", ":=", "false", "\n", "for", "_", ",", "pkg", ":=", "range", "sqlPackages", "{", "if", "pkg", ".", "packageName", "==", "edge", ".", "Caller", ".", "Func", ".", "Pkg", ".", "Pkg", ".", "Path", "(", ")", "{", "isInternalSQLPkg", "=", "true", "\n", "break", "\n", "}", "\n", "}", "\n", "if", "isInternalSQLPkg", "{", "continue", "\n", "}", "\n\n", "cc", ":=", "edge", ".", "Site", ".", "Common", "(", ")", "\n", "args", ":=", "cc", ".", "Args", "\n", "// The first parameter is occasionally the receiver.", "if", "len", "(", "args", ")", "==", "m", ".", "ArgCount", "+", "1", "{", "args", "=", "args", "[", "1", ":", "]", "\n", "}", "else", "if", "len", "(", "args", ")", "!=", "m", ".", "ArgCount", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "v", ":=", "args", "[", "m", ".", "Param", "]", "\n\n", "if", "_", ",", "ok", ":=", "v", ".", "(", "*", "ssa", ".", "Const", ")", ";", "!", "ok", "{", "if", "inter", ",", "ok", ":=", "v", ".", "(", "*", "ssa", ".", "MakeInterface", ")", ";", "ok", "&&", "types", ".", "IsInterface", "(", "v", ".", "(", "*", "ssa", ".", "MakeInterface", ")", ".", "Type", "(", ")", ")", "{", "if", "inter", ".", "X", ".", "Referrers", "(", ")", "==", "nil", "||", "inter", ".", "X", ".", "Type", "(", ")", "!=", "types", ".", "Typ", "[", "types", ".", "String", "]", "{", "continue", "\n", "}", "\n", "}", "\n\n", "bad", "=", "append", "(", "bad", ",", "edge", ".", "Site", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "bad", "\n", "}" ]

[ "FindNonConstCalls", "returns", "the", "set", "of", "callsites", "of", "the", "given", "set", "of", "methods", "for", "which", "the", "query", "parameter", "is", "not", "a", "compile", "-", "time", "constant", "." ]

[ "func", "FindPackage", "(", "ctxt", "*", "build", ".", "Context", ",", "path", ",", "dir", "string", ",", "mode", "build", ".", "ImportMode", ")", "(", "*", "build", ".", "Package", ",", "error", ")", "{", "if", "!", "useVendor", "{", "return", "ctxt", ".", "Import", "(", "path", ",", "dir", ",", "mode", ")", "\n", "}", "\n\n", "// First, walk up the filesystem from dir looking for vendor directories", "var", "vendorDir", "string", "\n", "for", "tmp", ":=", "dir", ";", "vendorDir", "==", "\"", "\"", "&&", "tmp", "!=", "\"", "\"", ";", "tmp", "=", "filepath", ".", "Dir", "(", "tmp", ")", "{", "dname", ":=", "filepath", ".", "Join", "(", "tmp", ",", "\"", "\"", ",", "filepath", ".", "FromSlash", "(", "path", ")", ")", "\n", "fd", ",", "err", ":=", "os", ".", "Open", "(", "dname", ")", "\n", "if", "err", "!=", "nil", "{", "continue", "\n", "}", "\n", "// Directories are only valid if they contain at least one file", "// with suffix \".go\" (this also ensures that the file descriptor", "// we have is in fact a directory)", "names", ",", "err", ":=", "fd", ".", "Readdirnames", "(", "-", "1", ")", "\n", "if", "err", "!=", "nil", "{", "continue", "\n", "}", "\n", "for", "_", ",", "name", ":=", "range", "names", "{", "if", "strings", ".", "HasSuffix", "(", "name", ",", "\"", "\"", ")", "{", "vendorDir", "=", "filepath", ".", "ToSlash", "(", "dname", ")", "\n", "break", "\n", "}", "\n", "}", "\n", "}", "\n\n", "if", "vendorDir", "!=", "\"", "\"", "{", "pkg", ",", "err", ":=", "ctxt", ".", "ImportDir", "(", "vendorDir", ",", "mode", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "// Go tries to derive a valid import path for the package, but", "// it's wrong (it includes \"/vendor/\"). Overwrite it here.", "pkg", ".", "ImportPath", "=", "path", "\n", "return", "pkg", ",", "nil", "\n", "}", "\n\n", "return", "ctxt", ".", "Import", "(", "path", ",", "dir", ",", "mode", ")", "\n", "}" ]

[ "Deal", "with", "GO15VENDOREXPERIMENT" ]

[ "func", "IsShortReadTagValueError", "(", "err", "error", ")", "bool", "{", "de", ",", "ok", ":=", "err", ".", "(", "decodeError", ")", "\n", "if", "ok", "{", "return", "de", ".", "cause", "==", "tiff", ".", "ErrShortReadTagValue", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "IsShortReadTagValueError", "identifies", "a", "ErrShortReadTagValue", "error", "." ]

[ "func", "IsExifError", "(", "err", "error", ")", "bool", "{", "if", "te", ",", "ok", ":=", "err", ".", "(", "tiffErrors", ")", ";", "ok", "{", "_", ",", "isExif", ":=", "te", "[", "loadExif", "]", "\n", "return", "isExif", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "IsExifError", "reports", "whether", "the", "error", "happened", "while", "decoding", "the", "EXIF", "sub", "-", "IFD", "." ]

[ "func", "IsGPSError", "(", "err", "error", ")", "bool", "{", "if", "te", ",", "ok", ":=", "err", ".", "(", "tiffErrors", ")", ";", "ok", "{", "_", ",", "isGPS", ":=", "te", "[", "loadExif", "]", "\n", "return", "isGPS", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "IsGPSError", "reports", "whether", "the", "error", "happened", "while", "decoding", "the", "GPS", "sub", "-", "IFD", "." ]

[ "func", "IsInteroperabilityError", "(", "err", "error", ")", "bool", "{", "if", "te", ",", "ok", ":=", "err", ".", "(", "tiffErrors", ")", ";", "ok", "{", "_", ",", "isInterop", ":=", "te", "[", "loadInteroperability", "]", "\n", "return", "isInterop", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "IsInteroperabilityError", "reports", "whether", "the", "error", "happened", "while", "decoding", "the", "Interoperability", "sub", "-", "IFD", "." ]

[ "func", "(", "p", "*", "parser", ")", "Parse", "(", "x", "*", "Exif", ")", "error", "{", "if", "len", "(", "x", ".", "Tiff", ".", "Dirs", ")", "==", "0", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "x", ".", "LoadTags", "(", "x", ".", "Tiff", ".", "Dirs", "[", "0", "]", ",", "exifFields", ",", "false", ")", "\n\n", "// thumbnails", "if", "len", "(", "x", ".", "Tiff", ".", "Dirs", ")", ">=", "2", "{", "x", ".", "LoadTags", "(", "x", ".", "Tiff", ".", "Dirs", "[", "1", "]", ",", "thumbnailFields", ",", "false", ")", "\n", "}", "\n\n", "te", ":=", "make", "(", "tiffErrors", ")", "\n\n", "// recurse into exif, gps, and interop sub-IFDs", "if", "err", ":=", "loadSubDir", "(", "x", ",", "ExifIFDPointer", ",", "exifFields", ")", ";", "err", "!=", "nil", "{", "te", "[", "loadExif", "]", "=", "err", ".", "Error", "(", ")", "\n", "}", "\n", "if", "err", ":=", "loadSubDir", "(", "x", ",", "GPSInfoIFDPointer", ",", "gpsFields", ")", ";", "err", "!=", "nil", "{", "te", "[", "loadGPS", "]", "=", "err", ".", "Error", "(", ")", "\n", "}", "\n\n", "if", "err", ":=", "loadSubDir", "(", "x", ",", "InteroperabilityIFDPointer", ",", "interopFields", ")", ";", "err", "!=", "nil", "{", "te", "[", "loadInteroperability", "]", "=", "err", ".", "Error", "(", ")", "\n", "}", "\n", "if", "len", "(", "te", ")", ">", "0", "{", "return", "te", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Parse", "reads", "data", "from", "the", "tiff", "data", "in", "x", "and", "populates", "the", "tags", "in", "x", ".", "If", "parsing", "a", "sub", "-", "IFD", "fails", "the", "error", "is", "recorded", "and", "parsing", "continues", "with", "the", "remaining", "sub", "-", "IFDs", "." ]

[ "func", "(", "x", "*", "Exif", ")", "Get", "(", "name", "FieldName", ")", "(", "*", "tiff", ".", "Tag", ",", "error", ")", "{", "if", "tg", ",", "ok", ":=", "x", ".", "main", "[", "name", "]", ";", "ok", "{", "return", "tg", ",", "nil", "\n", "}", "\n", "return", "nil", ",", "TagNotPresentError", "(", "name", ")", "\n", "}" ]

[ "Get", "retrieves", "the", "EXIF", "tag", "for", "the", "given", "field", "name", ".", "If", "the", "tag", "is", "not", "known", "or", "not", "present", "an", "error", "is", "returned", ".", "If", "the", "tag", "name", "is", "known", "the", "error", "will", "be", "a", "TagNotPresentError", "." ]

[ "func", "(", "x", "*", "Exif", ")", "Walk", "(", "w", "Walker", ")", "error", "{", "for", "name", ",", "tag", ":=", "range", "x", ".", "main", "{", "if", "err", ":=", "w", ".", "Walk", "(", "name", ",", "tag", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Walk", "calls", "the", "Walk", "method", "of", "w", "with", "the", "name", "and", "tag", "for", "every", "non", "-", "nil", "EXIF", "field", ".", "If", "w", "aborts", "the", "walk", "with", "an", "error", "that", "error", "is", "returned", "." ]

[ "func", "(", "x", "*", "Exif", ")", "LatLong", "(", ")", "(", "lat", ",", "long", "float64", ",", "err", "error", ")", "{", "// All calls of x.Get might return an TagNotPresentError", "longTag", ",", "err", ":=", "x", ".", "Get", "(", "FieldName", "(", "\"", "\"", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "ewTag", ",", "err", ":=", "x", ".", "Get", "(", "FieldName", "(", "\"", "\"", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "latTag", ",", "err", ":=", "x", ".", "Get", "(", "FieldName", "(", "\"", "\"", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "nsTag", ",", "err", ":=", "x", ".", "Get", "(", "FieldName", "(", "\"", "\"", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "if", "long", ",", "err", "=", "tagDegrees", "(", "longTag", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "0", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "if", "lat", ",", "err", "=", "tagDegrees", "(", "latTag", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "0", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "ew", ",", "err", ":=", "ewTag", ".", "StringVal", "(", ")", "\n", "if", "err", "==", "nil", "&&", "ew", "==", "\"", "\"", "{", "long", "*=", "-", "1.0", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "0", ",", "0", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "ns", ",", "err", ":=", "nsTag", ".", "StringVal", "(", ")", "\n", "if", "err", "==", "nil", "&&", "ns", "==", "\"", "\"", "{", "lat", "*=", "-", "1.0", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "0", ",", "0", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "lat", ",", "long", ",", "nil", "\n", "}" ]

[ "LatLong", "returns", "the", "latitude", "and", "longitude", "of", "the", "photo", "and", "whether", "it", "was", "present", "." ]

[ "func", "(", "x", "*", "Exif", ")", "String", "(", ")", "string", "{", "var", "buf", "bytes", ".", "Buffer", "\n", "for", "name", ",", "tag", ":=", "range", "x", ".", "main", "{", "fmt", ".", "Fprintf", "(", "&", "buf", ",", "\"", "\\n", "\"", ",", "name", ",", "tag", ")", "\n", "}", "\n", "return", "buf", ".", "String", "(", ")", "\n", "}" ]

[ "String", "returns", "a", "pretty", "text", "representation", "of", "the", "decoded", "exif", "data", "." ]

[ "func", "(", "x", "*", "Exif", ")", "JpegThumbnail", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "offset", ",", "err", ":=", "x", ".", "Get", "(", "ThumbJPEGInterchangeFormat", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "start", ",", "err", ":=", "offset", ".", "Int", "(", "0", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "length", ",", "err", ":=", "x", ".", "Get", "(", "ThumbJPEGInterchangeFormatLength", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "l", ",", "err", ":=", "length", ".", "Int", "(", "0", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "x", ".", "Raw", "[", "start", ":", "start", "+", "l", "]", ",", "nil", "\n", "}" ]

[ "JpegThumbnail", "returns", "the", "jpeg", "thumbnail", "if", "it", "exists", ".", "If", "it", "doesn", "t", "exist", "TagNotPresentError", "will", "be", "returned" ]

[ "func", "newAppSec", "(", "marker", "byte", ",", "r", "io", ".", "Reader", ")", "(", "*", "appSec", ",", "error", ")", "{", "br", ":=", "bufio", ".", "NewReader", "(", "r", ")", "\n", "app", ":=", "&", "appSec", "{", "marker", ":", "marker", "}", "\n", "var", "dataLen", "int", "\n\n", "// seek to marker", "for", "dataLen", "==", "0", "{", "if", "_", ",", "err", ":=", "br", ".", "ReadBytes", "(", "0xFF", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "c", ",", "err", ":=", "br", ".", "ReadByte", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "else", "if", "c", "!=", "marker", "{", "continue", "\n", "}", "\n\n", "dataLenBytes", ":=", "make", "(", "[", "]", "byte", ",", "2", ")", "\n", "for", "k", ",", "_", ":=", "range", "dataLenBytes", "{", "c", ",", "err", ":=", "br", ".", "ReadByte", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "dataLenBytes", "[", "k", "]", "=", "c", "\n", "}", "\n", "dataLen", "=", "int", "(", "binary", ".", "BigEndian", ".", "Uint16", "(", "dataLenBytes", ")", ")", "-", "2", "\n", "}", "\n\n", "// read section data", "nread", ":=", "0", "\n", "for", "nread", "<", "dataLen", "{", "s", ":=", "make", "(", "[", "]", "byte", ",", "dataLen", "-", "nread", ")", "\n", "n", ",", "err", ":=", "br", ".", "Read", "(", "s", ")", "\n", "nread", "+=", "n", "\n", "if", "err", "!=", "nil", "&&", "nread", "<", "dataLen", "{", "return", "nil", ",", "err", "\n", "}", "\n", "app", ".", "data", "=", "append", "(", "app", ".", "data", ",", "s", "[", ":", "n", "]", "...", ")", "\n", "}", "\n", "return", "app", ",", "nil", "\n", "}" ]

[ "newAppSec", "finds", "marker", "in", "r", "and", "returns", "the", "corresponding", "application", "data", "section", "." ]

[ "func", "(", "app", "*", "appSec", ")", "exifReader", "(", ")", "(", "*", "bytes", ".", "Reader", ",", "error", ")", "{", "if", "len", "(", "app", ".", "data", ")", "<", "6", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// read/check for exif special mark", "exif", ":=", "app", ".", "data", "[", ":", "6", "]", "\n", "if", "!", "bytes", ".", "Equal", "(", "exif", ",", "append", "(", "[", "]", "byte", "(", "\"", "\"", ")", ",", "0x00", ",", "0x00", ")", ")", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "bytes", ".", "NewReader", "(", "app", ".", "data", "[", "6", ":", "]", ")", ",", "nil", "\n", "}" ]

[ "exifReader", "returns", "a", "reader", "on", "this", "appSec", "with", "the", "read", "cursor", "advanced", "to", "the", "start", "of", "the", "exif", "s", "tiff", "encoded", "portion", "." ]

[ "func", "(", "t", "*", "Tag", ")", "Rat", "(", "i", "int", ")", "(", "*", "big", ".", "Rat", ",", "error", ")", "{", "n", ",", "d", ",", "err", ":=", "t", ".", "Rat2", "(", "i", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "big", ".", "NewRat", "(", "n", ",", "d", ")", ",", "nil", "\n", "}" ]

[ "Rat", "returns", "the", "tag", "s", "i", "th", "value", "as", "a", "rational", "number", ".", "It", "returns", "a", "nil", "and", "an", "error", "if", "this", "tag", "s", "Format", "is", "not", "RatVal", ".", "It", "panics", "for", "zero", "deminators", "or", "if", "i", "is", "out", "of", "range", "." ]

[ "func", "(", "t", "*", "Tag", ")", "Rat2", "(", "i", "int", ")", "(", "num", ",", "den", "int64", ",", "err", "error", ")", "{", "if", "t", ".", "format", "!=", "RatVal", "{", "return", "0", ",", "0", ",", "t", ".", "typeErr", "(", "RatVal", ")", "\n", "}", "\n", "return", "t", ".", "ratVals", "[", "i", "]", "[", "0", "]", ",", "t", ".", "ratVals", "[", "i", "]", "[", "1", "]", ",", "nil", "\n", "}" ]

[ "Rat2", "returns", "the", "tag", "s", "i", "th", "value", "as", "a", "rational", "number", "represented", "by", "a", "numerator", "-", "denominator", "pair", ".", "It", "returns", "an", "error", "if", "the", "tag", "s", "Format", "is", "not", "RatVal", ".", "It", "panics", "if", "i", "is", "out", "of", "range", "." ]

[ "func", "(", "t", "*", "Tag", ")", "Int64", "(", "i", "int", ")", "(", "int64", ",", "error", ")", "{", "if", "t", ".", "format", "!=", "IntVal", "{", "return", "0", ",", "t", ".", "typeErr", "(", "IntVal", ")", "\n", "}", "\n", "return", "t", ".", "intVals", "[", "i", "]", ",", "nil", "\n", "}" ]

[ "Int64", "returns", "the", "tag", "s", "i", "th", "value", "as", "an", "integer", ".", "It", "returns", "an", "error", "if", "the", "tag", "s", "Format", "is", "not", "IntVal", ".", "It", "panics", "if", "i", "is", "out", "of", "range", "." ]

[ "func", "(", "t", "*", "Tag", ")", "Int", "(", "i", "int", ")", "(", "int", ",", "error", ")", "{", "if", "t", ".", "format", "!=", "IntVal", "{", "return", "0", ",", "t", ".", "typeErr", "(", "IntVal", ")", "\n", "}", "\n", "return", "int", "(", "t", ".", "intVals", "[", "i", "]", ")", ",", "nil", "\n", "}" ]

[ "Int", "returns", "the", "tag", "s", "i", "th", "value", "as", "an", "integer", ".", "It", "returns", "an", "error", "if", "the", "tag", "s", "Format", "is", "not", "IntVal", ".", "It", "panics", "if", "i", "is", "out", "of", "range", "." ]

[ "func", "(", "t", "*", "Tag", ")", "Float", "(", "i", "int", ")", "(", "float64", ",", "error", ")", "{", "if", "t", ".", "format", "!=", "FloatVal", "{", "return", "0", ",", "t", ".", "typeErr", "(", "FloatVal", ")", "\n", "}", "\n", "return", "t", ".", "floatVals", "[", "i", "]", ",", "nil", "\n", "}" ]

[ "Float", "returns", "the", "tag", "s", "i", "th", "value", "as", "a", "float", ".", "It", "returns", "an", "error", "if", "the", "tag", "s", "Format", "is", "not", "IntVal", ".", "It", "panics", "if", "i", "is", "out", "of", "range", "." ]

[ "func", "(", "t", "*", "Tag", ")", "StringVal", "(", ")", "(", "string", ",", "error", ")", "{", "if", "t", ".", "format", "!=", "StringVal", "{", "return", "\"", "\"", ",", "t", ".", "typeErr", "(", "StringVal", ")", "\n", "}", "\n", "return", "t", ".", "strVal", ",", "nil", "\n", "}" ]

[ "StringVal", "returns", "the", "tag", "s", "value", "as", "a", "string", ".", "It", "returns", "an", "error", "if", "the", "tag", "s", "Format", "is", "not", "StringVal", ".", "It", "panics", "if", "i", "is", "out", "of", "range", "." ]

[ "func", "(", "t", "*", "Tag", ")", "String", "(", ")", "string", "{", "data", ",", "err", ":=", "t", ".", "MarshalJSON", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", "+", "err", ".", "Error", "(", ")", "\n", "}", "\n\n", "if", "t", ".", "Count", "==", "1", "{", "return", "strings", ".", "Trim", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "data", ")", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "data", ")", "\n", "}" ]

[ "String", "returns", "a", "nicely", "formatted", "version", "of", "the", "tag", "." ]

[ "func", "Decode", "(", "r", "io", ".", "Reader", ")", "(", "*", "Tiff", ",", "error", ")", "{", "data", ",", "err", ":=", "ioutil", ".", "ReadAll", "(", "r", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "buf", ":=", "bytes", ".", "NewReader", "(", "data", ")", "\n\n", "t", ":=", "new", "(", "Tiff", ")", "\n\n", "// read byte order", "bo", ":=", "make", "(", "[", "]", "byte", ",", "2", ")", "\n", "if", "_", ",", "err", "=", "io", ".", "ReadFull", "(", "buf", ",", "bo", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "string", "(", "bo", ")", "==", "\"", "\"", "{", "t", ".", "Order", "=", "binary", ".", "LittleEndian", "\n", "}", "else", "if", "string", "(", "bo", ")", "==", "\"", "\"", "{", "t", ".", "Order", "=", "binary", ".", "BigEndian", "\n", "}", "else", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// check for special tiff marker", "var", "sp", "int16", "\n", "err", "=", "binary", ".", "Read", "(", "buf", ",", "t", ".", "Order", ",", "&", "sp", ")", "\n", "if", "err", "!=", "nil", "||", "42", "!=", "sp", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// load offset to first IFD", "var", "offset", "int32", "\n", "err", "=", "binary", ".", "Read", "(", "buf", ",", "t", ".", "Order", ",", "&", "offset", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// load IFD's", "var", "d", "*", "Dir", "\n", "prev", ":=", "offset", "\n", "for", "offset", "!=", "0", "{", "// seek to offset", "_", ",", "err", ":=", "buf", ".", "Seek", "(", "int64", "(", "offset", ")", ",", "0", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "buf", ".", "Len", "(", ")", "==", "0", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// load the dir", "d", ",", "offset", ",", "err", "=", "DecodeDir", "(", "buf", ",", "t", ".", "Order", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "offset", "==", "prev", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "prev", "=", "offset", "\n\n", "t", ".", "Dirs", "=", "append", "(", "t", ".", "Dirs", ",", "d", ")", "\n", "}", "\n\n", "return", "t", ",", "nil", "\n", "}" ]

[ "Decode", "parses", "tiff", "-", "encoded", "data", "from", "r", "and", "returns", "a", "Tiff", "struct", "that", "reflects", "the", "structure", "and", "content", "of", "the", "tiff", "data", ".", "The", "first", "read", "from", "r", "should", "be", "the", "first", "byte", "of", "the", "tiff", "-", "encoded", "data", "and", "not", "necessarily", "the", "first", "byte", "of", "an", "os", ".", "File", "object", "." ]

[ "func", "(", "_", "*", "canon", ")", "Parse", "(", "x", "*", "exif", ".", "Exif", ")", "error", "{", "m", ",", "err", ":=", "x", ".", "Get", "(", "exif", ".", "MakerNote", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", "\n", "}", "\n\n", "mk", ",", "err", ":=", "x", ".", "Get", "(", "exif", ".", "Make", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", "\n", "}", "\n\n", "if", "val", ",", "err", ":=", "mk", ".", "StringVal", "(", ")", ";", "err", "!=", "nil", "||", "val", "!=", "\"", "\"", "{", "return", "nil", "\n", "}", "\n\n", "// Canon notes are a single IFD directory with no header.", "// Reader offsets need to be w.r.t. the original tiff structure.", "buf", ":=", "bytes", ".", "NewReader", "(", "append", "(", "make", "(", "[", "]", "byte", ",", "m", ".", "ValOffset", ")", ",", "m", ".", "Val", "...", ")", ")", "\n", "buf", ".", "Seek", "(", "int64", "(", "m", ".", "ValOffset", ")", ",", "0", ")", "\n\n", "mkNotesDir", ",", "_", ",", "err", ":=", "tiff", ".", "DecodeDir", "(", "buf", ",", "x", ".", "Tiff", ".", "Order", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "x", ".", "LoadTags", "(", "mkNotesDir", ",", "makerNoteCanonFields", ",", "false", ")", "\n", "return", "nil", "\n", "}" ]

[ "Parse", "decodes", "all", "Canon", "makernote", "data", "found", "in", "x", "and", "adds", "it", "to", "x", "." ]

[ "func", "(", "_", "*", "nikonV3", ")", "Parse", "(", "x", "*", "exif", ".", "Exif", ")", "error", "{", "m", ",", "err", ":=", "x", ".", "Get", "(", "exif", ".", "MakerNote", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", "\n", "}", "else", "if", "bytes", ".", "Compare", "(", "m", ".", "Val", "[", ":", "6", "]", ",", "[", "]", "byte", "(", "\"", "\\000", "\"", ")", ")", "!=", "0", "{", "return", "nil", "\n", "}", "\n\n", "// Nikon v3 maker note is a self-contained IFD (offsets are relative", "// to the start of the maker note)", "mkNotes", ",", "err", ":=", "tiff", ".", "Decode", "(", "bytes", ".", "NewReader", "(", "m", ".", "Val", "[", "10", ":", "]", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "x", ".", "LoadTags", "(", "mkNotes", ".", "Dirs", "[", "0", "]", ",", "makerNoteNikon3Fields", ",", "false", ")", "\n", "return", "nil", "\n", "}" ]

[ "Parse", "decodes", "all", "Nikon", "makernote", "data", "found", "in", "x", "and", "adds", "it", "to", "x", "." ]

[ "func", "(", "h", "*", "SMTPAPIHeader", ")", "AddTo", "(", "email", "string", ")", "{", "h", ".", "To", "=", "append", "(", "h", ".", "To", ",", "email", ")", "\n", "}" ]

[ "AddTo", "appends", "a", "single", "email", "to", "the", "To", "header" ]

[ "func", "(", "h", "*", "SMTPAPIHeader", ")", "AddTos", "(", "emails", "[", "]", "string", ")", "{", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "emails", ")", ";", "i", "++", "{", "h", ".", "AddTo", "(", "emails", "[", "i", "]", ")", "\n", "}", "\n", "}" ]

[ "AddTos", "appends", "multiple", "emails", "to", "the", "To", "header" ]

[ "func", "(", "h", "*", "SMTPAPIHeader", ")", "AddSubstitution", "(", "key", ",", "sub", "string", ")", "{", "if", "h", ".", "Sub", "==", "nil", "{", "h", ".", "Sub", "=", "make", "(", "map", "[", "string", "]", "[", "]", "string", ")", "\n", "}", "\n", "h", ".", "Sub", "[", "key", "]", "=", "append", "(", "h", ".", "Sub", "[", "key", "]", ",", "sub", ")", "\n", "}" ]

[ "AddSubstitution", "adds", "a", "new", "substitution", "to", "a", "specific", "key" ]

[ "func", "(", "h", "*", "SMTPAPIHeader", ")", "AddSubstitutions", "(", "key", "string", ",", "subs", "[", "]", "string", ")", "{", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "subs", ")", ";", "i", "++", "{", "h", ".", "AddSubstitution", "(", "key", ",", "subs", "[", "i", "]", ")", "\n", "}", "\n", "}" ]

[ "AddSubstitutions", "adds", "a", "multiple", "substitutions", "to", "a", "specific", "key" ]

[ "func", "(", "h", "*", "SMTPAPIHeader", ")", "AddSection", "(", "section", ",", "value", "string", ")", "{", "if", "h", ".", "Section", "==", "nil", "{", "h", ".", "Section", "=", "make", "(", "map", "[", "string", "]", "string", ")", "\n", "}", "\n", "h", ".", "Section", "[", "section", "]", "=", "value", "\n", "}" ]

[ "AddSection", "sets", "the", "value", "for", "a", "specific", "section" ]

[ "func", "(", "h", "*", "SMTPAPIHeader", ")", "AddCategory", "(", "category", "string", ")", "{", "h", ".", "Category", "=", "append", "(", "h", ".", "Category", ",", "category", ")", "\n", "}" ]

[ "AddCategory", "adds", "a", "new", "category", "to", "the", "Category", "header" ]

[ "func", "(", "h", "*", "SMTPAPIHeader", ")", "AddCategories", "(", "categories", "[", "]", "string", ")", "{", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "categories", ")", ";", "i", "++", "{", "h", ".", "AddCategory", "(", "categories", "[", "i", "]", ")", "\n", "}", "\n", "}" ]

[ "AddCategories", "adds", "multiple", "categories", "to", "the", "Category", "header" ]

[ "func", "(", "h", "*", "SMTPAPIHeader", ")", "AddASMGroupToDisplay", "(", "groupID", "int", ")", "{", "h", ".", "ASMGroups", "=", "append", "(", "h", ".", "ASMGroups", ",", "groupID", ")", "\n", "}" ]

[ "AddASMGroupToDisplay", "adds", "a", "new", "ASM", "group", "ID", "to", "be", "displayed" ]

[ "func", "(", "h", "*", "SMTPAPIHeader", ")", "AddASMGroupsToDisplay", "(", "groupIDs", "[", "]", "int", ")", "{", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "groupIDs", ")", ";", "i", "++", "{", "h", ".", "AddASMGroupToDisplay", "(", "groupIDs", "[", "i", "]", ")", "\n", "}", "\n", "}" ]

[ "AddASMGroupsToDisplay", "adds", "multiple", "ASM", "group", "IDs", "to", "be", "displayed" ]

[ "func", "(", "h", "*", "SMTPAPIHeader", ")", "AddUniqueArg", "(", "arg", ",", "value", "string", ")", "{", "if", "h", ".", "UniqueArgs", "==", "nil", "{", "h", ".", "UniqueArgs", "=", "make", "(", "map", "[", "string", "]", "string", ")", "\n", "}", "\n", "h", ".", "UniqueArgs", "[", "arg", "]", "=", "value", "\n", "}" ]

[ "AddUniqueArg", "will", "set", "the", "value", "of", "a", "specific", "argument" ]

[ "func", "(", "h", "*", "SMTPAPIHeader", ")", "AddFilter", "(", "filter", ",", "setting", "string", ",", "value", "interface", "{", "}", ")", "{", "if", "h", ".", "Filters", "==", "nil", "{", "h", ".", "Filters", "=", "make", "(", "map", "[", "string", "]", "Filter", ")", "\n", "}", "\n", "if", "_", ",", "ok", ":=", "h", ".", "Filters", "[", "filter", "]", ";", "!", "ok", "{", "h", ".", "Filters", "[", "filter", "]", "=", "Filter", "{", "Settings", ":", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ")", ",", "}", "\n", "}", "\n", "h", ".", "Filters", "[", "filter", "]", ".", "Settings", "[", "setting", "]", "=", "value", "\n", "}" ]

[ "AddFilter", "will", "set", "the", "specific", "setting", "for", "a", "filter" ]

[ "func", "(", "h", "*", "SMTPAPIHeader", ")", "SetFilter", "(", "filter", "string", ",", "value", "*", "Filter", ")", "{", "if", "h", ".", "Filters", "==", "nil", "{", "h", ".", "Filters", "=", "make", "(", "map", "[", "string", "]", "Filter", ")", "\n", "}", "\n", "h", ".", "Filters", "[", "filter", "]", "=", "*", "value", "\n", "}" ]

[ "SetFilter", "takes", "in", "a", "Filter", "struct", "with", "predetermined", "settings", "and", "sets", "it", "for", "such", "Filter", "key" ]

[ "func", "(", "h", "*", "SMTPAPIHeader", ")", "AddSendEachAt", "(", "sendEachAt", "int64", ")", "{", "h", ".", "SendEachAt", "=", "append", "(", "h", ".", "SendEachAt", ",", "sendEachAt", ")", "\n", "}" ]

[ "AddSendEachAt", "takes", "in", "a", "timestamp", "and", "pushes", "it", "into", "a", "list", "Must", "match", "length", "of", "To", "emails" ]

[ "func", "(", "h", "*", "SMTPAPIHeader", ")", "JSONString", "(", ")", "(", "string", ",", "error", ")", "{", "headers", ",", "e", ":=", "json", ".", "Marshal", "(", "h", ")", "\n", "return", "escapeUnicode", "(", "string", "(", "headers", ")", ")", ",", "e", "\n", "}" ]

[ "JSONString", "returns", "the", "representation", "of", "the", "Header" ]

[ "func", "(", "h", "*", "SMTPAPIHeader", ")", "Load", "(", "b", "[", "]", "byte", ")", "error", "{", "return", "json", ".", "Unmarshal", "(", "b", ",", "h", ")", "\n", "}" ]

[ "Load", "allows", "you", "to", "load", "a", "pre", "-", "formed", "x", "-", "smtpapi", "header" ]

[ "func", "(", "c", "*", "Cors", ")", "handlePreflight", "(", "w", "http", ".", "ResponseWriter", ",", "r", "*", "http", ".", "Request", ")", "{", "headers", ":=", "w", ".", "Header", "(", ")", "\n", "origin", ":=", "r", ".", "Header", ".", "Get", "(", "\"", "\"", ")", "\n\n", "if", "r", ".", "Method", "!=", "\"", "\"", "{", "c", ".", "logf", "(", "\"", "\"", ",", "r", ".", "Method", ")", "\n", "return", "\n", "}", "\n", "// Always set Vary headers", "// see https://github.com/rs/cors/issues/10,", "// https://github.com/rs/cors/commit/dbdca4d95feaa7511a46e6f1efb3b3aa505bc43f#commitcomment-12352001", "headers", ".", "Add", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "headers", ".", "Add", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "headers", ".", "Add", "(", "\"", "\"", ",", "\"", "\"", ")", "\n\n", "if", "origin", "==", "\"", "\"", "{", "c", ".", "logf", "(", "\"", "\"", ")", "\n", "return", "\n", "}", "\n", "if", "!", "c", ".", "isOriginAllowed", "(", "r", ",", "origin", ")", "{", "c", ".", "logf", "(", "\"", "\"", ",", "origin", ")", "\n", "return", "\n", "}", "\n\n", "reqMethod", ":=", "r", ".", "Header", ".", "Get", "(", "\"", "\"", ")", "\n", "if", "!", "c", ".", "isMethodAllowed", "(", "reqMethod", ")", "{", "c", ".", "logf", "(", "\"", "\"", ",", "reqMethod", ")", "\n", "return", "\n", "}", "\n", "reqHeaders", ":=", "parseHeaderList", "(", "r", ".", "Header", ".", "Get", "(", "\"", "\"", ")", ")", "\n", "if", "!", "c", ".", "areHeadersAllowed", "(", "reqHeaders", ")", "{", "c", ".", "logf", "(", "\"", "\"", ",", "reqHeaders", ")", "\n", "return", "\n", "}", "\n", "headers", ".", "Set", "(", "\"", "\"", ",", "origin", ")", "\n", "// Spec says: Since the list of methods can be unbounded, simply returning the method indicated", "// by Access-Control-Request-Method (if supported) can be enough", "headers", ".", "Set", "(", "\"", "\"", ",", "strings", ".", "ToUpper", "(", "reqMethod", ")", ")", "\n", "if", "len", "(", "reqHeaders", ")", ">", "0", "{", "// Spec says: Since the list of headers can be unbounded, simply returning supported headers", "// from Access-Control-Request-Headers can be enough", "headers", ".", "Set", "(", "\"", "\"", ",", "strings", ".", "Join", "(", "reqHeaders", ",", "\"", "\"", ")", ")", "\n", "}", "\n", "if", "c", ".", "allowCredentials", "{", "headers", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "c", ".", "maxAge", ">", "0", "{", "headers", ".", "Set", "(", "\"", "\"", ",", "strconv", ".", "Itoa", "(", "c", ".", "maxAge", ")", ")", "\n", "}", "\n", "c", ".", "logf", "(", "\"", "\"", ",", "headers", ")", "\n", "}" ]

[ "handlePreflight", "handles", "pre", "-", "flight", "CORS", "requests" ]

[ "func", "(", "c", "*", "Cors", ")", "handleActualRequest", "(", "w", "http", ".", "ResponseWriter", ",", "r", "*", "http", ".", "Request", ")", "{", "headers", ":=", "w", ".", "Header", "(", ")", "\n", "origin", ":=", "r", ".", "Header", ".", "Get", "(", "\"", "\"", ")", "\n\n", "if", "r", ".", "Method", "==", "\"", "\"", "{", "c", ".", "logf", "(", "\"", "\"", ",", "r", ".", "Method", ")", "\n", "return", "\n", "}", "\n", "// Always set Vary, see https://github.com/rs/cors/issues/10", "headers", ".", "Add", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "if", "origin", "==", "\"", "\"", "{", "c", ".", "logf", "(", "\"", "\"", ")", "\n", "return", "\n", "}", "\n", "if", "!", "c", ".", "isOriginAllowed", "(", "r", ",", "origin", ")", "{", "c", ".", "logf", "(", "\"", "\"", ",", "origin", ")", "\n", "return", "\n", "}", "\n\n", "// Note that spec does define a way to specifically disallow a simple method like GET or", "// POST. Access-Control-Allow-Methods is only used for pre-flight requests and the", "// spec doesn't instruct to check the allowed methods for simple cross-origin requests.", "// We think it's a nice feature to be able to have control on those methods though.", "if", "!", "c", ".", "isMethodAllowed", "(", "r", ".", "Method", ")", "{", "if", "c", ".", "log", "!=", "nil", "{", "c", ".", "logf", "(", "\"", "\"", ",", "r", ".", "Method", ")", "\n", "}", "\n\n", "return", "\n", "}", "\n", "headers", ".", "Set", "(", "\"", "\"", ",", "origin", ")", "\n", "if", "len", "(", "c", ".", "exposedHeaders", ")", ">", "0", "{", "headers", ".", "Set", "(", "\"", "\"", ",", "strings", ".", "Join", "(", "c", ".", "exposedHeaders", ",", "\"", "\"", ")", ")", "\n", "}", "\n", "if", "c", ".", "allowCredentials", "{", "headers", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "}", "\n", "c", ".", "logf", "(", "\"", "\"", ",", "headers", ")", "\n", "}" ]

[ "handleActualRequest", "handles", "simple", "cross", "-", "origin", "requests", "actual", "request", "or", "redirects" ]

[ "func", "(", "c", "*", "Cors", ")", "isOriginAllowed", "(", "r", "*", "http", ".", "Request", ",", "origin", "string", ")", "bool", "{", "if", "c", ".", "allowOriginFunc", "!=", "nil", "{", "return", "c", ".", "allowOriginFunc", "(", "r", ",", "origin", ")", "\n", "}", "\n", "if", "c", ".", "allowedOriginsAll", "{", "return", "true", "\n", "}", "\n", "origin", "=", "strings", ".", "ToLower", "(", "origin", ")", "\n", "for", "_", ",", "o", ":=", "range", "c", ".", "allowedOrigins", "{", "if", "o", "==", "origin", "{", "return", "true", "\n", "}", "\n", "}", "\n", "for", "_", ",", "w", ":=", "range", "c", ".", "allowedWOrigins", "{", "if", "w", ".", "match", "(", "origin", ")", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "isOriginAllowed", "checks", "if", "a", "given", "origin", "is", "allowed", "to", "perform", "cross", "-", "domain", "requests", "on", "the", "endpoint" ]

[ "func", "(", "c", "*", "Cors", ")", "isMethodAllowed", "(", "method", "string", ")", "bool", "{", "if", "len", "(", "c", ".", "allowedMethods", ")", "==", "0", "{", "// If no method allowed, always return false, even for preflight request", "return", "false", "\n", "}", "\n", "method", "=", "strings", ".", "ToUpper", "(", "method", ")", "\n", "if", "method", "==", "\"", "\"", "{", "// Always allow preflight requests", "return", "true", "\n", "}", "\n", "for", "_", ",", "m", ":=", "range", "c", ".", "allowedMethods", "{", "if", "m", "==", "method", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "isMethodAllowed", "checks", "if", "a", "given", "method", "can", "be", "used", "as", "part", "of", "a", "cross", "-", "domain", "request", "on", "the", "endpoing" ]

[ "func", "loadAgentFile", "(", "filename", "string", ")", "(", "*", "redditproto", ".", "UserAgent", ",", "error", ")", "{", "buf", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "filename", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "agent", ":=", "&", "redditproto", ".", "UserAgent", "{", "}", "\n", "return", "agent", ",", "proto", ".", "UnmarshalText", "(", "bytes", ".", "NewBuffer", "(", "buf", ")", ".", "String", "(", ")", ",", "agent", ")", "\n", "}" ]

[ "loadAgentFile", "reads", "a", "user", "agent", "from", "a", "protobuffer", "file", "and", "returns", "it", "." ]

[ "func", "New", "(", "c", "Config", ")", "(", "Monitor", ",", "error", ")", "{", "m", ":=", "&", "monitor", "{", "tip", ":", "[", "]", "string", "{", "\"", "\"", "}", ",", "path", ":", "c", ".", "Path", ",", "scanner", ":", "c", ".", "Scanner", ",", "sorter", ":", "c", ".", "Sorter", ",", "}", "\n\n", "if", "err", ":=", "m", ".", "sync", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "m", ",", "nil", "\n", "}" ]

[ "New", "provides", "a", "monitor", "for", "the", "listing", "endpoint", "." ]

[ "func", "(", "m", "*", "monitor", ")", "Update", "(", ")", "(", "reddit", ".", "Harvest", ",", "error", ")", "{", "if", "m", ".", "blanks", ">", "blankThreshold", "{", "return", "reddit", ".", "Harvest", "{", "}", ",", "m", ".", "fixTip", "(", ")", "\n", "}", "\n\n", "names", ",", "harvest", ",", "err", ":=", "m", ".", "harvest", "(", "m", ".", "tip", "[", "0", "]", ")", "\n", "m", ".", "updateTip", "(", "names", ")", "\n", "return", "harvest", ",", "err", "\n", "}" ]

[ "Update", "checks", "for", "new", "content", "at", "the", "monitored", "listing", "endpoint", "and", "forwards", "new", "content", "to", "the", "bot", "for", "processing", "." ]

[ "func", "(", "m", "*", "monitor", ")", "harvest", "(", "ref", "string", ")", "(", "[", "]", "string", ",", "reddit", ".", "Harvest", ",", "error", ")", "{", "h", ",", "err", ":=", "m", ".", "scanner", ".", "Listing", "(", "m", ".", "path", ",", "ref", ")", "\n", "return", "m", ".", "sorter", ".", "Sort", "(", "h", ")", ",", "h", ",", "err", "\n", "}" ]

[ "harvest", "fetches", "from", "the", "listing", "any", "posts", "after", "the", "given", "reference", "post", "and", "returns", "those", "posts", "and", "a", "reverse", "chronologically", "sorted", "list", "of", "their", "names", "." ]

[ "func", "(", "m", "*", "monitor", ")", "sync", "(", ")", "error", "{", "names", ",", "_", ",", "err", ":=", "m", ".", "harvest", "(", "\"", "\"", ")", "\n", "if", "len", "(", "names", ")", ">", "0", "{", "m", ".", "tip", "=", "names", "\n", "}", "else", "{", "m", ".", "tip", "=", "defaultTip", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "sync", "fetches", "the", "current", "tip", "of", "a", "listing", "endpoint", "so", "that", "grawbots", "crawling", "forward", "in", "time", "don", "t", "treat", "it", "as", "a", "new", "post", "or", "reprocess", "it", "when", "restarted", "." ]

[ "func", "(", "m", "*", "monitor", ")", "updateTip", "(", "names", "[", "]", "string", ")", "{", "if", "len", "(", "names", ")", ">", "0", "{", "m", ".", "blanks", "=", "0", "\n", "}", "else", "{", "m", ".", "blanks", "++", "\n", "}", "\n\n", "m", ".", "tip", "=", "append", "(", "names", ",", "m", ".", "tip", "...", ")", "\n", "if", "len", "(", "m", ".", "tip", ")", ">", "maxTipSize", "{", "m", ".", "tip", "=", "m", ".", "tip", "[", "0", ":", "maxTipSize", "]", "\n", "}", "\n", "}" ]

[ "updateTip", "updates", "the", "monitor", "s", "list", "of", "names", "from", "the", "endpoint", "listing", "it", "uses", "to", "keep", "track", "of", "its", "position", "in", "the", "monitored", "listing", "." ]

[ "func", "(", "m", "*", "monitor", ")", "fixTip", "(", ")", "error", "{", "names", ",", "_", ",", "err", ":=", "m", ".", "harvest", "(", "m", ".", "tip", "[", "len", "(", "m", ".", "tip", ")", "-", "1", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// If none of our backup tips were returned, most likely the last backup", "// tip is dead and this check was meaningless.", "if", "len", "(", "names", ")", "==", "0", "{", "m", ".", "tip", "=", "m", ".", "tip", "[", ":", "len", "(", "m", ".", "tip", ")", "-", "1", "]", "\n", "if", "len", "(", "m", ".", "tip", ")", "==", "0", "{", "m", ".", "tip", "=", "defaultTip", "\n", "}", "\n", "return", "nil", "\n", "}", "\n\n", "// n^2 because your cycles don't matter to me & n <= maxTipSize", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "m", ".", "tip", ")", "-", "1", ";", "i", "++", "{", "alive", ":=", "false", "\n", "for", "_", ",", "n", ":=", "range", "names", "{", "if", "m", ".", "tip", "[", "i", "]", "==", "n", "{", "alive", "=", "true", "\n", "}", "\n", "}", "\n", "if", "!", "alive", "{", "m", ".", "tip", "=", "append", "(", "m", ".", "tip", "[", ":", "i", "]", ",", "m", ".", "tip", "[", "i", "+", "1", ":", "]", "...", ")", "\n", "}", "\n", "}", "\n\n", "m", ".", "blanks", "=", "0", "\n", "return", "nil", "\n", "}" ]

[ "fixTip", "checks", "all", "of", "the", "stored", "backup", "tips", "for", "health", ".", "If", "the", "post", "at", "the", "front", "has", "been", "deleted", "or", "caught", "in", "a", "spam", "filter", "the", "feed", "will", "die", "and", "we", "will", "stop", "getting", "posts", ".", "This", "will", "adjust", "backward", "if", "a", "tip", "is", "dead", "and", "remove", "any", "other", "dead", "tips", "in", "the", "list", ".", "Returns", "whether", "the", "tip", "was", "broken", "." ]

[ "func", "sortHarvest", "(", "h", "reddit", ".", "Harvest", ")", "[", "]", "string", "{", "things", ":=", "merge", "(", "postsAsThings", "(", "h", ".", "Posts", ")", ",", "commentsAsThings", "(", "h", ".", "Comments", ")", ",", "messagesAsThings", "(", "h", ".", "Messages", ")", ",", ")", "\n", "sort", ".", "Sort", "(", "byCreationTime", "{", "things", "}", ")", "\n\n", "names", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "things", ")", ")", "\n", "for", "i", ",", "t", ":=", "range", "things", "{", "names", "[", "i", "]", "=", "t", ".", "Name", "(", ")", "\n", "}", "\n\n", "return", "names", "\n", "}" ]

[ "sortHarvest", "returns", "the", "list", "of", "names", "of", "Reddit", "elements", "in", "a", "harvest", "sorted", "by", "creation", "time", "to", "the", "younger", "elements", "appear", "first", "in", "the", "slice", "." ]

[ "func", "(", "c", "*", "Comment", ")", "IsTopLevel", "(", ")", "bool", "{", "parentType", ":=", "strings", ".", "Split", "(", "c", ".", "ParentID", ",", "\"", "\"", ")", "[", "0", "]", "\n", "return", "parentType", "==", "postKind", "\n", "}" ]

[ "IsTopLevel", "is", "true", "when", "the", "comment", "is", "a", "top", "level", "comment", "." ]

[ "func", "connectScanStreams", "(", "handler", "interface", "{", "}", ",", "sc", "reddit", ".", "Scanner", ",", "c", "Config", ",", "kill", "<-", "chan", "bool", ",", "errs", "chan", "<-", "error", ",", ")", "error", "{", "if", "len", "(", "c", ".", "Subreddits", ")", ">", "0", "{", "ph", ",", "ok", ":=", "handler", ".", "(", "botfaces", ".", "PostHandler", ")", "\n", "if", "!", "ok", "{", "return", "postHandlerErr", "\n", "}", "\n\n", "if", "posts", ",", "err", ":=", "streams", ".", "Subreddits", "(", "sc", ",", "kill", ",", "errs", ",", "c", ".", "Subreddits", "...", ",", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "else", "{", "go", "func", "(", ")", "{", "for", "p", ":=", "range", "posts", "{", "errs", "<-", "ph", ".", "Post", "(", "p", ")", "\n", "}", "\n", "}", "(", ")", "\n", "}", "\n", "}", "\n\n", "if", "len", "(", "c", ".", "SubredditComments", ")", ">", "0", "{", "ch", ",", "ok", ":=", "handler", ".", "(", "botfaces", ".", "CommentHandler", ")", "\n", "if", "!", "ok", "{", "return", "commentHandlerErr", "\n", "}", "\n\n", "if", "comments", ",", "err", ":=", "streams", ".", "SubredditComments", "(", "sc", ",", "kill", ",", "errs", ",", "c", ".", "SubredditComments", "...", ",", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "else", "{", "go", "func", "(", ")", "{", "for", "c", ":=", "range", "comments", "{", "errs", "<-", "ch", ".", "Comment", "(", "c", ")", "\n", "}", "\n", "}", "(", ")", "\n", "}", "\n", "}", "\n\n", "if", "len", "(", "c", ".", "Users", ")", ">", "0", "{", "uh", ",", "ok", ":=", "handler", ".", "(", "botfaces", ".", "UserHandler", ")", "\n", "if", "!", "ok", "{", "return", "userHandlerErr", "\n", "}", "\n\n", "for", "_", ",", "user", ":=", "range", "c", ".", "Users", "{", "if", "posts", ",", "comments", ",", "err", ":=", "streams", ".", "User", "(", "sc", ",", "kill", ",", "errs", ",", "user", ",", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "else", "{", "go", "func", "(", ")", "{", "for", "p", ":=", "range", "posts", "{", "errs", "<-", "uh", ".", "UserPost", "(", "p", ")", "\n", "}", "\n", "}", "(", ")", "\n", "go", "func", "(", ")", "{", "for", "c", ":=", "range", "comments", "{", "errs", "<-", "uh", ".", "UserComment", "(", "c", ")", "\n", "}", "\n", "}", "(", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "connectScanStreams", "connects", "the", "streams", "a", "scanner", "can", "subscribe", "to", "to", "the", "handler", "." ]

[ "func", "NewScript", "(", "agent", "string", ",", "rate", "time", ".", "Duration", ")", "(", "Script", ",", "error", ")", "{", "c", ",", "err", ":=", "newClient", "(", "clientConfig", "{", "agent", ":", "agent", "}", ")", "\n", "r", ":=", "newReaper", "(", "reaperConfig", "{", "client", ":", "c", ",", "parser", ":", "newParser", "(", ")", ",", "hostname", ":", "\"", "\"", ",", "reapSuffix", ":", "\"", "\"", ",", "tls", ":", "true", ",", "rate", ":", "maxOf", "(", "rate", ",", "2", "*", "time", ".", "Second", ")", ",", "}", ",", ")", "\n", "return", "&", "script", "{", "Lurker", ":", "newLurker", "(", "r", ")", ",", "Scanner", ":", "newScanner", "(", "r", ")", ",", "}", ",", "err", "\n", "}" ]

[ "NewScript", "returns", "a", "Script", "handle", "to", "Reddit", "s", "API", "which", "always", "sends", "the", "given", "agent", "in", "the", "user", "-", "agent", "header", "of", "its", "requests", "and", "makes", "requests", "with", "no", "less", "time", "between", "them", "than", "rate", ".", "The", "minimum", "respected", "value", "of", "rate", "is", "2", "seconds", "because", "Reddit", "s", "API", "rules", "cap", "logged", "out", "non", "-", "OAuth", "clients", "at", "30", "requests", "per", "minute", "." ]