Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "(", "tx", "*", "Tx", ")", "forEachPage", "(", "pgid", "pgid", ",", "depth", "int", ",", "fn", "func", "(", "*", "page", ",", "int", ")", ")", "{", "p", ":=", "tx", ".", "page", "(", "pgid", ")", "\n\n", "// Execute function.", "fn", "(", "p", ",", "depth", ")", "\n\n", "// Recursively loop over children.", "if", "(", "p", ".", "flags", "&", "branchPageFlag", ")", "!=", "0", "{", "for", "i", ":=", "0", ";", "i", "<", "int", "(", "p", ".", "count", ")", ";", "i", "++", "{", "elem", ":=", "p", ".", "branchPageElement", "(", "uint16", "(", "i", ")", ")", "\n", "tx", ".", "forEachPage", "(", "elem", ".", "pgid", ",", "depth", "+", "1", ",", "fn", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "forEachPage", "iterates", "over", "every", "page", "within", "a", "given", "page", "and", "executes", "a", "function", "." ]

[ "func", "(", "tx", "*", "Tx", ")", "Page", "(", "id", "int", ")", "(", "*", "PageInfo", ",", "error", ")", "{", "if", "tx", ".", "db", "==", "nil", "{", "return", "nil", ",", "ErrTxClosed", "\n", "}", "else", "if", "pgid", "(", "id", ")", ">=", "tx", ".", "meta", ".", "pgid", "{", "return", "nil", ",", "nil", "\n", "}", "\n\n", "// Build the page info.", "p", ":=", "tx", ".", "db", ".", "page", "(", "pgid", "(", "id", ")", ")", "\n", "info", ":=", "&", "PageInfo", "{", "ID", ":", "id", ",", "Count", ":", "int", "(", "p", ".", "count", ")", ",", "OverflowCount", ":", "int", "(", "p", ".", "overflow", ")", ",", "}", "\n\n", "// Determine the type (or if it's free).", "if", "tx", ".", "db", ".", "freelist", ".", "freed", "(", "pgid", "(", "id", ")", ")", "{", "info", ".", "Type", "=", "\"", "\"", "\n", "}", "else", "{", "info", ".", "Type", "=", "p", ".", "typ", "(", ")", "\n", "}", "\n\n", "return", "info", ",", "nil", "\n", "}" ]

[ "Page", "returns", "page", "information", "for", "a", "given", "page", "number", ".", "This", "is", "only", "safe", "for", "concurrent", "use", "when", "used", "by", "a", "writable", "transaction", "." ]

[ "func", "(", "s", "*", "TxStats", ")", "Sub", "(", "other", "*", "TxStats", ")", "TxStats", "{", "var", "diff", "TxStats", "\n", "diff", ".", "PageCount", "=", "s", ".", "PageCount", "-", "other", ".", "PageCount", "\n", "diff", ".", "PageAlloc", "=", "s", ".", "PageAlloc", "-", "other", ".", "PageAlloc", "\n", "diff", ".", "CursorCount", "=", "s", ".", "CursorCount", "-", "other", ".", "CursorCount", "\n", "diff", ".", "NodeCount", "=", "s", ".", "NodeCount", "-", "other", ".", "NodeCount", "\n", "diff", ".", "NodeDeref", "=", "s", ".", "NodeDeref", "-", "other", ".", "NodeDeref", "\n", "diff", ".", "Rebalance", "=", "s", ".", "Rebalance", "-", "other", ".", "Rebalance", "\n", "diff", ".", "RebalanceTime", "=", "s", ".", "RebalanceTime", "-", "other", ".", "RebalanceTime", "\n", "diff", ".", "Split", "=", "s", ".", "Split", "-", "other", ".", "Split", "\n", "diff", ".", "Spill", "=", "s", ".", "Spill", "-", "other", ".", "Spill", "\n", "diff", ".", "SpillTime", "=", "s", ".", "SpillTime", "-", "other", ".", "SpillTime", "\n", "diff", ".", "Write", "=", "s", ".", "Write", "-", "other", ".", "Write", "\n", "diff", ".", "WriteTime", "=", "s", ".", "WriteTime", "-", "other", ".", "WriteTime", "\n", "return", "diff", "\n", "}" ]

[ "Sub", "calculates", "and", "returns", "the", "difference", "between", "two", "sets", "of", "transaction", "stats", ".", "This", "is", "useful", "when", "obtaining", "stats", "at", "two", "different", "points", "and", "time", "and", "you", "need", "the", "performance", "counters", "that", "occurred", "within", "that", "time", "span", "." ]

[ "func", "newCheckCommand", "(", "m", "*", "Main", ")", "*", "CheckCommand", "{", "return", "&", "CheckCommand", "{", "Stdin", ":", "m", ".", "Stdin", ",", "Stdout", ":", "m", ".", "Stdout", ",", "Stderr", ":", "m", ".", "Stderr", ",", "}", "\n", "}" ]

[ "NewCheckCommand", "returns", "a", "CheckCommand", "." ]

[ "func", "newInfoCommand", "(", "m", "*", "Main", ")", "*", "InfoCommand", "{", "return", "&", "InfoCommand", "{", "Stdin", ":", "m", ".", "Stdin", ",", "Stdout", ":", "m", ".", "Stdout", ",", "Stderr", ":", "m", ".", "Stderr", ",", "}", "\n", "}" ]

[ "NewInfoCommand", "returns", "a", "InfoCommand", "." ]

[ "func", "newDumpCommand", "(", "m", "*", "Main", ")", "*", "DumpCommand", "{", "return", "&", "DumpCommand", "{", "Stdin", ":", "m", ".", "Stdin", ",", "Stdout", ":", "m", ".", "Stdout", ",", "Stderr", ":", "m", ".", "Stderr", ",", "}", "\n", "}" ]

[ "newDumpCommand", "returns", "a", "DumpCommand", "." ]

[ "func", "(", "cmd", "*", "DumpCommand", ")", "PrintPage", "(", "w", "io", ".", "Writer", ",", "r", "io", ".", "ReaderAt", ",", "pageID", "int", ",", "pageSize", "int", ")", "error", "{", "const", "bytesPerLineN", "=", "16", "\n\n", "// Read page into buffer.", "buf", ":=", "make", "(", "[", "]", "byte", ",", "pageSize", ")", "\n", "addr", ":=", "pageID", "*", "pageSize", "\n", "if", "n", ",", "err", ":=", "r", ".", "ReadAt", "(", "buf", ",", "int64", "(", "addr", ")", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "else", "if", "n", "!=", "pageSize", "{", "return", "io", ".", "ErrUnexpectedEOF", "\n", "}", "\n\n", "// Write out to writer in 16-byte lines.", "var", "prev", "[", "]", "byte", "\n", "var", "skipped", "bool", "\n", "for", "offset", ":=", "0", ";", "offset", "<", "pageSize", ";", "offset", "+=", "bytesPerLineN", "{", "// Retrieve current 16-byte line.", "line", ":=", "buf", "[", "offset", ":", "offset", "+", "bytesPerLineN", "]", "\n", "isLastLine", ":=", "(", "offset", "==", "(", "pageSize", "-", "bytesPerLineN", ")", ")", "\n\n", "// If it's the same as the previous line then print a skip.", "if", "bytes", ".", "Equal", "(", "line", ",", "prev", ")", "&&", "!", "isLastLine", "{", "if", "!", "skipped", "{", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\"", ",", "addr", "+", "offset", ")", "\n", "skipped", "=", "true", "\n", "}", "\n", "}", "else", "{", "// Print line as hexadecimal in 2-byte groups.", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\"", ",", "addr", "+", "offset", ",", "line", "[", "0", ":", "2", "]", ",", "line", "[", "2", ":", "4", "]", ",", "line", "[", "4", ":", "6", "]", ",", "line", "[", "6", ":", "8", "]", ",", "line", "[", "8", ":", "10", "]", ",", "line", "[", "10", ":", "12", "]", ",", "line", "[", "12", ":", "14", "]", ",", "line", "[", "14", ":", "16", "]", ",", ")", "\n\n", "skipped", "=", "false", "\n", "}", "\n\n", "// Save the previous line.", "prev", "=", "line", "\n", "}", "\n", "fmt", ".", "Fprint", "(", "w", ",", "\"", "\\n", "\"", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "PrintPage", "prints", "a", "given", "page", "as", "hexadecimal", "." ]

[ "func", "newPageCommand", "(", "m", "*", "Main", ")", "*", "PageCommand", "{", "return", "&", "PageCommand", "{", "Stdin", ":", "m", ".", "Stdin", ",", "Stdout", ":", "m", ".", "Stdout", ",", "Stderr", ":", "m", ".", "Stderr", ",", "}", "\n", "}" ]

[ "newPageCommand", "returns", "a", "PageCommand", "." ]

[ "func", "(", "cmd", "*", "PageCommand", ")", "PrintMeta", "(", "w", "io", ".", "Writer", ",", "buf", "[", "]", "byte", ")", "error", "{", "m", ":=", "(", "*", "meta", ")", "(", "unsafe", ".", "Pointer", "(", "&", "buf", "[", "PageHeaderSize", "]", ")", ")", "\n", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\"", ",", "m", ".", "version", ")", "\n", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\"", ",", "m", ".", "pageSize", ")", "\n", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\"", ",", "m", ".", "flags", ")", "\n", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\"", ",", "m", ".", "root", ".", "root", ")", "\n", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\"", ",", "m", ".", "freelist", ")", "\n", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\"", ",", "m", ".", "pgid", ")", "\n", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\"", ",", "m", ".", "txid", ")", "\n", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\"", ",", "m", ".", "checksum", ")", "\n", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\"", ")", "\n", "return", "nil", "\n", "}" ]

[ "PrintMeta", "prints", "the", "data", "from", "the", "meta", "page", "." ]

[ "func", "(", "cmd", "*", "PageCommand", ")", "PrintLeaf", "(", "w", "io", ".", "Writer", ",", "buf", "[", "]", "byte", ")", "error", "{", "p", ":=", "(", "*", "page", ")", "(", "unsafe", ".", "Pointer", "(", "&", "buf", "[", "0", "]", ")", ")", "\n\n", "// Print number of items.", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\"", ",", "p", ".", "count", ")", "\n", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\"", ")", "\n\n", "// Print each key/value.", "for", "i", ":=", "uint16", "(", "0", ")", ";", "i", "<", "p", ".", "count", ";", "i", "++", "{", "e", ":=", "p", ".", "leafPageElement", "(", "i", ")", "\n\n", "// Format key as string.", "var", "k", "string", "\n", "if", "isPrintable", "(", "string", "(", "e", ".", "key", "(", ")", ")", ")", "{", "k", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "string", "(", "e", ".", "key", "(", ")", ")", ")", "\n", "}", "else", "{", "k", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "string", "(", "e", ".", "key", "(", ")", ")", ")", "\n", "}", "\n\n", "// Format value as string.", "var", "v", "string", "\n", "if", "(", "e", ".", "flags", "&", "uint32", "(", "bucketLeafFlag", ")", ")", "!=", "0", "{", "b", ":=", "(", "*", "bucket", ")", "(", "unsafe", ".", "Pointer", "(", "&", "e", ".", "value", "(", ")", "[", "0", "]", ")", ")", "\n", "v", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "b", ".", "root", ",", "b", ".", "sequence", ")", "\n", "}", "else", "if", "isPrintable", "(", "string", "(", "e", ".", "value", "(", ")", ")", ")", "{", "v", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "string", "(", "e", ".", "value", "(", ")", ")", ")", "\n", "}", "else", "{", "v", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "string", "(", "e", ".", "value", "(", ")", ")", ")", "\n", "}", "\n\n", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\"", ",", "k", ",", "v", ")", "\n", "}", "\n", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\"", ")", "\n", "return", "nil", "\n", "}" ]

[ "PrintLeaf", "prints", "the", "data", "for", "a", "leaf", "page", "." ]

[ "func", "(", "cmd", "*", "PageCommand", ")", "PrintBranch", "(", "w", "io", ".", "Writer", ",", "buf", "[", "]", "byte", ")", "error", "{", "p", ":=", "(", "*", "page", ")", "(", "unsafe", ".", "Pointer", "(", "&", "buf", "[", "0", "]", ")", ")", "\n\n", "// Print number of items.", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\"", ",", "p", ".", "count", ")", "\n", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\"", ")", "\n\n", "// Print each key/value.", "for", "i", ":=", "uint16", "(", "0", ")", ";", "i", "<", "p", ".", "count", ";", "i", "++", "{", "e", ":=", "p", ".", "branchPageElement", "(", "i", ")", "\n\n", "// Format key as string.", "var", "k", "string", "\n", "if", "isPrintable", "(", "string", "(", "e", ".", "key", "(", ")", ")", ")", "{", "k", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "string", "(", "e", ".", "key", "(", ")", ")", ")", "\n", "}", "else", "{", "k", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "string", "(", "e", ".", "key", "(", ")", ")", ")", "\n", "}", "\n\n", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\"", ",", "k", ",", "e", ".", "pgid", ")", "\n", "}", "\n", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\"", ")", "\n", "return", "nil", "\n", "}" ]

[ "PrintBranch", "prints", "the", "data", "for", "a", "leaf", "page", "." ]

[ "func", "(", "cmd", "*", "PageCommand", ")", "PrintFreelist", "(", "w", "io", ".", "Writer", ",", "buf", "[", "]", "byte", ")", "error", "{", "p", ":=", "(", "*", "page", ")", "(", "unsafe", ".", "Pointer", "(", "&", "buf", "[", "0", "]", ")", ")", "\n\n", "// Print number of items.", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\"", ",", "p", ".", "count", ")", "\n", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\"", ")", "\n\n", "// Print each page in the freelist.", "ids", ":=", "(", "*", "[", "maxAllocSize", "]", "pgid", ")", "(", "unsafe", ".", "Pointer", "(", "&", "p", ".", "ptr", ")", ")", "\n", "for", "i", ":=", "uint16", "(", "0", ")", ";", "i", "<", "p", ".", "count", ";", "i", "++", "{", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\"", ",", "ids", "[", "i", "]", ")", "\n", "}", "\n", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\"", ")", "\n", "return", "nil", "\n", "}" ]

[ "PrintFreelist", "prints", "the", "data", "for", "a", "freelist", "page", "." ]

[ "func", "newPagesCommand", "(", "m", "*", "Main", ")", "*", "PagesCommand", "{", "return", "&", "PagesCommand", "{", "Stdin", ":", "m", ".", "Stdin", ",", "Stdout", ":", "m", ".", "Stdout", ",", "Stderr", ":", "m", ".", "Stderr", ",", "}", "\n", "}" ]

[ "NewPagesCommand", "returns", "a", "PagesCommand", "." ]

[ "func", "newStatsCommand", "(", "m", "*", "Main", ")", "*", "StatsCommand", "{", "return", "&", "StatsCommand", "{", "Stdin", ":", "m", ".", "Stdin", ",", "Stdout", ":", "m", ".", "Stdout", ",", "Stderr", ":", "m", ".", "Stderr", ",", "}", "\n", "}" ]

[ "NewStatsCommand", "returns", "a", "StatsCommand", "." ]

[ "func", "newBenchCommand", "(", "m", "*", "Main", ")", "*", "BenchCommand", "{", "return", "&", "BenchCommand", "{", "Stdin", ":", "m", ".", "Stdin", ",", "Stdout", ":", "m", ".", "Stdout", ",", "Stderr", ":", "m", ".", "Stderr", ",", "}", "\n", "}" ]

[ "NewBenchCommand", "returns", "a", "BenchCommand", "using", "the" ]

[ "func", "(", "cmd", "*", "BenchCommand", ")", "Run", "(", "args", "...", "string", ")", "error", "{", "// Parse CLI arguments.", "options", ",", "err", ":=", "cmd", ".", "ParseFlags", "(", "args", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Remove path if \"-work\" is not set. Otherwise keep path.", "if", "options", ".", "Work", "{", "fmt", ".", "Fprintf", "(", "cmd", ".", "Stdout", ",", "\"", "\\n", "\"", ",", "options", ".", "Path", ")", "\n", "}", "else", "{", "defer", "os", ".", "Remove", "(", "options", ".", "Path", ")", "\n", "}", "\n\n", "// Create database.", "db", ",", "err", ":=", "bolt", ".", "Open", "(", "options", ".", "Path", ",", "0666", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "db", ".", "NoSync", "=", "options", ".", "NoSync", "\n", "defer", "db", ".", "Close", "(", ")", "\n\n", "// Write to the database.", "var", "results", "BenchResults", "\n", "if", "err", ":=", "cmd", ".", "runWrites", "(", "db", ",", "options", ",", "&", "results", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// Read from the database.", "if", "err", ":=", "cmd", ".", "runReads", "(", "db", ",", "options", ",", "&", "results", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// Print results.", "fmt", ".", "Fprintf", "(", "os", ".", "Stderr", ",", "\"", "\\t", "\\t", "\\t", "\\n", "\"", ",", "results", ".", "WriteDuration", ",", "results", ".", "WriteOpDuration", "(", ")", ",", "results", ".", "WriteOpsPerSecond", "(", ")", ")", "\n", "fmt", ".", "Fprintf", "(", "os", ".", "Stderr", ",", "\"", "\\t", "\\t", "\\t", "\\n", "\"", ",", "results", ".", "ReadDuration", ",", "results", ".", "ReadOpDuration", "(", ")", ",", "results", ".", "ReadOpsPerSecond", "(", ")", ")", "\n", "fmt", ".", "Fprintln", "(", "os", ".", "Stderr", ",", "\"", "\"", ")", "\n", "return", "nil", "\n", "}" ]

[ "Run", "executes", "the", "bench", "command", "." ]

[ "func", "(", "cmd", "*", "BenchCommand", ")", "runWrites", "(", "db", "*", "bolt", ".", "DB", ",", "options", "*", "BenchOptions", ",", "results", "*", "BenchResults", ")", "error", "{", "// Start profiling for writes.", "if", "options", ".", "ProfileMode", "==", "\"", "\"", "||", "options", ".", "ProfileMode", "==", "\"", "\"", "{", "cmd", ".", "startProfiling", "(", "options", ")", "\n", "}", "\n\n", "t", ":=", "time", ".", "Now", "(", ")", "\n\n", "var", "err", "error", "\n", "switch", "options", ".", "WriteMode", "{", "case", "\"", "\"", ":", "err", "=", "cmd", ".", "runWritesSequential", "(", "db", ",", "options", ",", "results", ")", "\n", "case", "\"", "\"", ":", "err", "=", "cmd", ".", "runWritesRandom", "(", "db", ",", "options", ",", "results", ")", "\n", "case", "\"", "\"", ":", "err", "=", "cmd", ".", "runWritesSequentialNested", "(", "db", ",", "options", ",", "results", ")", "\n", "case", "\"", "\"", ":", "err", "=", "cmd", ".", "runWritesRandomNested", "(", "db", ",", "options", ",", "results", ")", "\n", "default", ":", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "options", ".", "WriteMode", ")", "\n", "}", "\n\n", "// Save time to write.", "results", ".", "WriteDuration", "=", "time", ".", "Since", "(", "t", ")", "\n\n", "// Stop profiling for writes only.", "if", "options", ".", "ProfileMode", "==", "\"", "\"", "{", "cmd", ".", "stopProfiling", "(", ")", "\n", "}", "\n\n", "return", "err", "\n", "}" ]

[ "Writes", "to", "the", "database", "." ]

[ "func", "(", "cmd", "*", "BenchCommand", ")", "runReads", "(", "db", "*", "bolt", ".", "DB", ",", "options", "*", "BenchOptions", ",", "results", "*", "BenchResults", ")", "error", "{", "// Start profiling for reads.", "if", "options", ".", "ProfileMode", "==", "\"", "\"", "{", "cmd", ".", "startProfiling", "(", "options", ")", "\n", "}", "\n\n", "t", ":=", "time", ".", "Now", "(", ")", "\n\n", "var", "err", "error", "\n", "switch", "options", ".", "ReadMode", "{", "case", "\"", "\"", ":", "switch", "options", ".", "WriteMode", "{", "case", "\"", "\"", ",", "\"", "\"", ":", "err", "=", "cmd", ".", "runReadsSequentialNested", "(", "db", ",", "options", ",", "results", ")", "\n", "default", ":", "err", "=", "cmd", ".", "runReadsSequential", "(", "db", ",", "options", ",", "results", ")", "\n", "}", "\n", "default", ":", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "options", ".", "ReadMode", ")", "\n", "}", "\n\n", "// Save read time.", "results", ".", "ReadDuration", "=", "time", ".", "Since", "(", "t", ")", "\n\n", "// Stop profiling for reads.", "if", "options", ".", "ProfileMode", "==", "\"", "\"", "||", "options", ".", "ProfileMode", "==", "\"", "\"", "{", "cmd", ".", "stopProfiling", "(", ")", "\n", "}", "\n\n", "return", "err", "\n", "}" ]

[ "Reads", "from", "the", "database", "." ]

[ "func", "(", "cmd", "*", "BenchCommand", ")", "startProfiling", "(", "options", "*", "BenchOptions", ")", "{", "var", "err", "error", "\n\n", "// Start CPU profiling.", "if", "options", ".", "CPUProfile", "!=", "\"", "\"", "{", "cpuprofile", ",", "err", "=", "os", ".", "Create", "(", "options", ".", "CPUProfile", ")", "\n", "if", "err", "!=", "nil", "{", "fmt", ".", "Fprintf", "(", "cmd", ".", "Stderr", ",", "\"", "\\n", "\"", ",", "options", ".", "CPUProfile", ",", "err", ")", "\n", "os", ".", "Exit", "(", "1", ")", "\n", "}", "\n", "pprof", ".", "StartCPUProfile", "(", "cpuprofile", ")", "\n", "}", "\n\n", "// Start memory profiling.", "if", "options", ".", "MemProfile", "!=", "\"", "\"", "{", "memprofile", ",", "err", "=", "os", ".", "Create", "(", "options", ".", "MemProfile", ")", "\n", "if", "err", "!=", "nil", "{", "fmt", ".", "Fprintf", "(", "cmd", ".", "Stderr", ",", "\"", "\\n", "\"", ",", "options", ".", "MemProfile", ",", "err", ")", "\n", "os", ".", "Exit", "(", "1", ")", "\n", "}", "\n", "runtime", ".", "MemProfileRate", "=", "4096", "\n", "}", "\n\n", "// Start fatal profiling.", "if", "options", ".", "BlockProfile", "!=", "\"", "\"", "{", "blockprofile", ",", "err", "=", "os", ".", "Create", "(", "options", ".", "BlockProfile", ")", "\n", "if", "err", "!=", "nil", "{", "fmt", ".", "Fprintf", "(", "cmd", ".", "Stderr", ",", "\"", "\\n", "\"", ",", "options", ".", "BlockProfile", ",", "err", ")", "\n", "os", ".", "Exit", "(", "1", ")", "\n", "}", "\n", "runtime", ".", "SetBlockProfileRate", "(", "1", ")", "\n", "}", "\n", "}" ]

[ "Starts", "all", "profiles", "set", "on", "the", "options", "." ]

[ "func", "(", "cmd", "*", "BenchCommand", ")", "stopProfiling", "(", ")", "{", "if", "cpuprofile", "!=", "nil", "{", "pprof", ".", "StopCPUProfile", "(", ")", "\n", "cpuprofile", ".", "Close", "(", ")", "\n", "cpuprofile", "=", "nil", "\n", "}", "\n\n", "if", "memprofile", "!=", "nil", "{", "pprof", ".", "Lookup", "(", "\"", "\"", ")", ".", "WriteTo", "(", "memprofile", ",", "0", ")", "\n", "memprofile", ".", "Close", "(", ")", "\n", "memprofile", "=", "nil", "\n", "}", "\n\n", "if", "blockprofile", "!=", "nil", "{", "pprof", ".", "Lookup", "(", "\"", "\"", ")", ".", "WriteTo", "(", "blockprofile", ",", "0", ")", "\n", "blockprofile", ".", "Close", "(", ")", "\n", "blockprofile", "=", "nil", "\n", "runtime", ".", "SetBlockProfileRate", "(", "0", ")", "\n", "}", "\n", "}" ]

[ "Stops", "all", "profiles", "." ]

[ "func", "(", "r", "*", "BenchResults", ")", "WriteOpDuration", "(", ")", "time", ".", "Duration", "{", "if", "r", ".", "WriteOps", "==", "0", "{", "return", "0", "\n", "}", "\n", "return", "r", ".", "WriteDuration", "/", "time", ".", "Duration", "(", "r", ".", "WriteOps", ")", "\n", "}" ]

[ "Returns", "the", "duration", "for", "a", "single", "write", "operation", "." ]

[ "func", "(", "r", "*", "BenchResults", ")", "WriteOpsPerSecond", "(", ")", "int", "{", "var", "op", "=", "r", ".", "WriteOpDuration", "(", ")", "\n", "if", "op", "==", "0", "{", "return", "0", "\n", "}", "\n", "return", "int", "(", "time", ".", "Second", ")", "/", "int", "(", "op", ")", "\n", "}" ]

[ "Returns", "average", "number", "of", "write", "operations", "that", "can", "be", "performed", "per", "second", "." ]

[ "func", "(", "r", "*", "BenchResults", ")", "ReadOpDuration", "(", ")", "time", ".", "Duration", "{", "if", "r", ".", "ReadOps", "==", "0", "{", "return", "0", "\n", "}", "\n", "return", "r", ".", "ReadDuration", "/", "time", ".", "Duration", "(", "r", ".", "ReadOps", ")", "\n", "}" ]

[ "Returns", "the", "duration", "for", "a", "single", "read", "operation", "." ]

[ "func", "(", "r", "*", "BenchResults", ")", "ReadOpsPerSecond", "(", ")", "int", "{", "var", "op", "=", "r", ".", "ReadOpDuration", "(", ")", "\n", "if", "op", "==", "0", "{", "return", "0", "\n", "}", "\n", "return", "int", "(", "time", ".", "Second", ")", "/", "int", "(", "op", ")", "\n", "}" ]

[ "Returns", "average", "number", "of", "read", "operations", "that", "can", "be", "performed", "per", "second", "." ]

[ "func", "isPrintable", "(", "s", "string", ")", "bool", "{", "if", "!", "utf8", ".", "ValidString", "(", "s", ")", "{", "return", "false", "\n", "}", "\n", "for", "_", ",", "ch", ":=", "range", "s", "{", "if", "!", "unicode", ".", "IsPrint", "(", "ch", ")", "{", "return", "false", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "isPrintable", "returns", "true", "if", "the", "string", "is", "valid", "unicode", "and", "contains", "only", "printable", "runes", "." ]

[ "func", "ReadPage", "(", "path", "string", ",", "pageID", "int", ")", "(", "*", "page", ",", "[", "]", "byte", ",", "error", ")", "{", "// Find page size.", "pageSize", ",", "err", ":=", "ReadPageSize", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// Open database file.", "f", ",", "err", ":=", "os", ".", "Open", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "defer", "f", ".", "Close", "(", ")", "\n\n", "// Read one block into buffer.", "buf", ":=", "make", "(", "[", "]", "byte", ",", "pageSize", ")", "\n", "if", "n", ",", "err", ":=", "f", ".", "ReadAt", "(", "buf", ",", "int64", "(", "pageID", "*", "pageSize", ")", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "else", "if", "n", "!=", "len", "(", "buf", ")", "{", "return", "nil", ",", "nil", ",", "io", ".", "ErrUnexpectedEOF", "\n", "}", "\n\n", "// Determine total number of blocks.", "p", ":=", "(", "*", "page", ")", "(", "unsafe", ".", "Pointer", "(", "&", "buf", "[", "0", "]", ")", ")", "\n", "overflowN", ":=", "p", ".", "overflow", "\n\n", "// Re-read entire page (with overflow) into buffer.", "buf", "=", "make", "(", "[", "]", "byte", ",", "(", "int", "(", "overflowN", ")", "+", "1", ")", "*", "pageSize", ")", "\n", "if", "n", ",", "err", ":=", "f", ".", "ReadAt", "(", "buf", ",", "int64", "(", "pageID", "*", "pageSize", ")", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "else", "if", "n", "!=", "len", "(", "buf", ")", "{", "return", "nil", ",", "nil", ",", "io", ".", "ErrUnexpectedEOF", "\n", "}", "\n", "p", "=", "(", "*", "page", ")", "(", "unsafe", ".", "Pointer", "(", "&", "buf", "[", "0", "]", ")", ")", "\n\n", "return", "p", ",", "buf", ",", "nil", "\n", "}" ]

[ "ReadPage", "reads", "page", "info", "&", "full", "page", "data", "from", "a", "path", ".", "This", "is", "not", "transactionally", "safe", "." ]

[ "func", "ReadPageSize", "(", "path", "string", ")", "(", "int", ",", "error", ")", "{", "// Open database file.", "f", ",", "err", ":=", "os", ".", "Open", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "defer", "f", ".", "Close", "(", ")", "\n\n", "// Read 4KB chunk.", "buf", ":=", "make", "(", "[", "]", "byte", ",", "4096", ")", "\n", "if", "_", ",", "err", ":=", "io", ".", "ReadFull", "(", "f", ",", "buf", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n\n", "// Read page size from metadata.", "m", ":=", "(", "*", "meta", ")", "(", "unsafe", ".", "Pointer", "(", "&", "buf", "[", "PageHeaderSize", "]", ")", ")", "\n", "return", "int", "(", "m", ".", "pageSize", ")", ",", "nil", "\n", "}" ]

[ "ReadPageSize", "reads", "page", "size", "a", "path", ".", "This", "is", "not", "transactionally", "safe", "." ]

[ "func", "atois", "(", "strs", "[", "]", "string", ")", "(", "[", "]", "int", ",", "error", ")", "{", "var", "a", "[", "]", "int", "\n", "for", "_", ",", "str", ":=", "range", "strs", "{", "i", ",", "err", ":=", "strconv", ".", "Atoi", "(", "str", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "a", "=", "append", "(", "a", ",", "i", ")", "\n", "}", "\n", "return", "a", ",", "nil", "\n", "}" ]

[ "atois", "parses", "a", "slice", "of", "strings", "into", "integers", "." ]

[ "func", "newCompactCommand", "(", "m", "*", "Main", ")", "*", "CompactCommand", "{", "return", "&", "CompactCommand", "{", "Stdin", ":", "m", ".", "Stdin", ",", "Stdout", ":", "m", ".", "Stdout", ",", "Stderr", ":", "m", ".", "Stderr", ",", "}", "\n", "}" ]

[ "newCompactCommand", "returns", "a", "CompactCommand", "." ]

[ "func", "(", "cmd", "*", "CompactCommand", ")", "walk", "(", "db", "*", "bolt", ".", "DB", ",", "walkFn", "walkFunc", ")", "error", "{", "return", "db", ".", "View", "(", "func", "(", "tx", "*", "bolt", ".", "Tx", ")", "error", "{", "return", "tx", ".", "ForEach", "(", "func", "(", "name", "[", "]", "byte", ",", "b", "*", "bolt", ".", "Bucket", ")", "error", "{", "return", "cmd", ".", "walkBucket", "(", "b", ",", "nil", ",", "name", ",", "nil", ",", "b", ".", "Sequence", "(", ")", ",", "walkFn", ")", "\n", "}", ")", "\n", "}", ")", "\n", "}" ]

[ "walk", "walks", "recursively", "the", "bolt", "database", "db", "calling", "walkFn", "for", "each", "key", "it", "finds", "." ]

[ "func", "(", "n", "*", "node", ")", "size", "(", ")", "int", "{", "sz", ",", "elsz", ":=", "pageHeaderSize", ",", "n", ".", "pageElementSize", "(", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "n", ".", "inodes", ")", ";", "i", "++", "{", "item", ":=", "&", "n", ".", "inodes", "[", "i", "]", "\n", "sz", "+=", "elsz", "+", "len", "(", "item", ".", "key", ")", "+", "len", "(", "item", ".", "value", ")", "\n", "}", "\n", "return", "sz", "\n", "}" ]

[ "size", "returns", "the", "size", "of", "the", "node", "after", "serialization", "." ]

[ "func", "(", "n", "*", "node", ")", "sizeLessThan", "(", "v", "int", ")", "bool", "{", "sz", ",", "elsz", ":=", "pageHeaderSize", ",", "n", ".", "pageElementSize", "(", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "n", ".", "inodes", ")", ";", "i", "++", "{", "item", ":=", "&", "n", ".", "inodes", "[", "i", "]", "\n", "sz", "+=", "elsz", "+", "len", "(", "item", ".", "key", ")", "+", "len", "(", "item", ".", "value", ")", "\n", "if", "sz", ">=", "v", "{", "return", "false", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "sizeLessThan", "returns", "true", "if", "the", "node", "is", "less", "than", "a", "given", "size", ".", "This", "is", "an", "optimization", "to", "avoid", "calculating", "a", "large", "node", "when", "we", "only", "need", "to", "know", "if", "it", "fits", "inside", "a", "certain", "page", "size", "." ]

[ "func", "(", "n", "*", "node", ")", "childAt", "(", "index", "int", ")", "*", "node", "{", "if", "n", ".", "isLeaf", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "index", ")", ")", "\n", "}", "\n", "return", "n", ".", "bucket", ".", "node", "(", "n", ".", "inodes", "[", "index", "]", ".", "pgid", ",", "n", ")", "\n", "}" ]

[ "childAt", "returns", "the", "child", "node", "at", "a", "given", "index", "." ]

[ "func", "(", "n", "*", "node", ")", "childIndex", "(", "child", "*", "node", ")", "int", "{", "index", ":=", "sort", ".", "Search", "(", "len", "(", "n", ".", "inodes", ")", ",", "func", "(", "i", "int", ")", "bool", "{", "return", "bytes", ".", "Compare", "(", "n", ".", "inodes", "[", "i", "]", ".", "key", ",", "child", ".", "key", ")", "!=", "-", "1", "}", ")", "\n", "return", "index", "\n", "}" ]

[ "childIndex", "returns", "the", "index", "of", "a", "given", "child", "node", "." ]

[ "func", "(", "n", "*", "node", ")", "nextSibling", "(", ")", "*", "node", "{", "if", "n", ".", "parent", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "index", ":=", "n", ".", "parent", ".", "childIndex", "(", "n", ")", "\n", "if", "index", ">=", "n", ".", "parent", ".", "numChildren", "(", ")", "-", "1", "{", "return", "nil", "\n", "}", "\n", "return", "n", ".", "parent", ".", "childAt", "(", "index", "+", "1", ")", "\n", "}" ]

[ "nextSibling", "returns", "the", "next", "node", "with", "the", "same", "parent", "." ]

[ "func", "(", "n", "*", "node", ")", "prevSibling", "(", ")", "*", "node", "{", "if", "n", ".", "parent", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "index", ":=", "n", ".", "parent", ".", "childIndex", "(", "n", ")", "\n", "if", "index", "==", "0", "{", "return", "nil", "\n", "}", "\n", "return", "n", ".", "parent", ".", "childAt", "(", "index", "-", "1", ")", "\n", "}" ]

[ "prevSibling", "returns", "the", "previous", "node", "with", "the", "same", "parent", "." ]

[ "func", "(", "n", "*", "node", ")", "del", "(", "key", "[", "]", "byte", ")", "{", "// Find index of key.", "index", ":=", "sort", ".", "Search", "(", "len", "(", "n", ".", "inodes", ")", ",", "func", "(", "i", "int", ")", "bool", "{", "return", "bytes", ".", "Compare", "(", "n", ".", "inodes", "[", "i", "]", ".", "key", ",", "key", ")", "!=", "-", "1", "}", ")", "\n\n", "// Exit if the key isn't found.", "if", "index", ">=", "len", "(", "n", ".", "inodes", ")", "||", "!", "bytes", ".", "Equal", "(", "n", ".", "inodes", "[", "index", "]", ".", "key", ",", "key", ")", "{", "return", "\n", "}", "\n\n", "// Delete inode from the node.", "n", ".", "inodes", "=", "append", "(", "n", ".", "inodes", "[", ":", "index", "]", ",", "n", ".", "inodes", "[", "index", "+", "1", ":", "]", "...", ")", "\n\n", "// Mark the node as needing rebalancing.", "n", ".", "unbalanced", "=", "true", "\n", "}" ]

[ "del", "removes", "a", "key", "from", "the", "node", "." ]

[ "func", "(", "n", "*", "node", ")", "read", "(", "p", "*", "page", ")", "{", "n", ".", "pgid", "=", "p", ".", "id", "\n", "n", ".", "isLeaf", "=", "(", "(", "p", ".", "flags", "&", "leafPageFlag", ")", "!=", "0", ")", "\n", "n", ".", "inodes", "=", "make", "(", "inodes", ",", "int", "(", "p", ".", "count", ")", ")", "\n\n", "for", "i", ":=", "0", ";", "i", "<", "int", "(", "p", ".", "count", ")", ";", "i", "++", "{", "inode", ":=", "&", "n", ".", "inodes", "[", "i", "]", "\n", "if", "n", ".", "isLeaf", "{", "elem", ":=", "p", ".", "leafPageElement", "(", "uint16", "(", "i", ")", ")", "\n", "inode", ".", "flags", "=", "elem", ".", "flags", "\n", "inode", ".", "key", "=", "elem", ".", "key", "(", ")", "\n", "inode", ".", "value", "=", "elem", ".", "value", "(", ")", "\n", "}", "else", "{", "elem", ":=", "p", ".", "branchPageElement", "(", "uint16", "(", "i", ")", ")", "\n", "inode", ".", "pgid", "=", "elem", ".", "pgid", "\n", "inode", ".", "key", "=", "elem", ".", "key", "(", ")", "\n", "}", "\n", "_assert", "(", "len", "(", "inode", ".", "key", ")", ">", "0", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// Save first key so we can find the node in the parent when we spill.", "if", "len", "(", "n", ".", "inodes", ")", ">", "0", "{", "n", ".", "key", "=", "n", ".", "inodes", "[", "0", "]", ".", "key", "\n", "_assert", "(", "len", "(", "n", ".", "key", ")", ">", "0", ",", "\"", "\"", ")", "\n", "}", "else", "{", "n", ".", "key", "=", "nil", "\n", "}", "\n", "}" ]

[ "read", "initializes", "the", "node", "from", "a", "page", "." ]

[ "func", "(", "n", "*", "node", ")", "write", "(", "p", "*", "page", ")", "{", "// Initialize page.", "if", "n", ".", "isLeaf", "{", "p", ".", "flags", "|=", "leafPageFlag", "\n", "}", "else", "{", "p", ".", "flags", "|=", "branchPageFlag", "\n", "}", "\n\n", "if", "len", "(", "n", ".", "inodes", ")", ">=", "0xFFFF", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "len", "(", "n", ".", "inodes", ")", ",", "p", ".", "id", ")", ")", "\n", "}", "\n", "p", ".", "count", "=", "uint16", "(", "len", "(", "n", ".", "inodes", ")", ")", "\n\n", "// Stop here if there are no items to write.", "if", "p", ".", "count", "==", "0", "{", "return", "\n", "}", "\n\n", "// Loop over each item and write it to the page.", "b", ":=", "(", "*", "[", "maxAllocSize", "]", "byte", ")", "(", "unsafe", ".", "Pointer", "(", "&", "p", ".", "ptr", ")", ")", "[", "n", ".", "pageElementSize", "(", ")", "*", "len", "(", "n", ".", "inodes", ")", ":", "]", "\n", "for", "i", ",", "item", ":=", "range", "n", ".", "inodes", "{", "_assert", "(", "len", "(", "item", ".", "key", ")", ">", "0", ",", "\"", "\"", ")", "\n\n", "// Write the page element.", "if", "n", ".", "isLeaf", "{", "elem", ":=", "p", ".", "leafPageElement", "(", "uint16", "(", "i", ")", ")", "\n", "elem", ".", "pos", "=", "uint32", "(", "uintptr", "(", "unsafe", ".", "Pointer", "(", "&", "b", "[", "0", "]", ")", ")", "-", "uintptr", "(", "unsafe", ".", "Pointer", "(", "elem", ")", ")", ")", "\n", "elem", ".", "flags", "=", "item", ".", "flags", "\n", "elem", ".", "ksize", "=", "uint32", "(", "len", "(", "item", ".", "key", ")", ")", "\n", "elem", ".", "vsize", "=", "uint32", "(", "len", "(", "item", ".", "value", ")", ")", "\n", "}", "else", "{", "elem", ":=", "p", ".", "branchPageElement", "(", "uint16", "(", "i", ")", ")", "\n", "elem", ".", "pos", "=", "uint32", "(", "uintptr", "(", "unsafe", ".", "Pointer", "(", "&", "b", "[", "0", "]", ")", ")", "-", "uintptr", "(", "unsafe", ".", "Pointer", "(", "elem", ")", ")", ")", "\n", "elem", ".", "ksize", "=", "uint32", "(", "len", "(", "item", ".", "key", ")", ")", "\n", "elem", ".", "pgid", "=", "item", ".", "pgid", "\n", "_assert", "(", "elem", ".", "pgid", "!=", "p", ".", "id", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// If the length of key+value is larger than the max allocation size", "// then we need to reallocate the byte array pointer.", "//", "// See: https://github.com/boltdb/bolt/pull/335", "klen", ",", "vlen", ":=", "len", "(", "item", ".", "key", ")", ",", "len", "(", "item", ".", "value", ")", "\n", "if", "len", "(", "b", ")", "<", "klen", "+", "vlen", "{", "b", "=", "(", "*", "[", "maxAllocSize", "]", "byte", ")", "(", "unsafe", ".", "Pointer", "(", "&", "b", "[", "0", "]", ")", ")", "[", ":", "]", "\n", "}", "\n\n", "// Write data for the element to the end of the page.", "copy", "(", "b", "[", "0", ":", "]", ",", "item", ".", "key", ")", "\n", "b", "=", "b", "[", "klen", ":", "]", "\n", "copy", "(", "b", "[", "0", ":", "]", ",", "item", ".", "value", ")", "\n", "b", "=", "b", "[", "vlen", ":", "]", "\n", "}", "\n\n", "// DEBUG ONLY: n.dump()", "}" ]

[ "write", "writes", "the", "items", "onto", "one", "or", "more", "pages", "." ]

[ "func", "(", "n", "*", "node", ")", "spill", "(", ")", "error", "{", "var", "tx", "=", "n", ".", "bucket", ".", "tx", "\n", "if", "n", ".", "spilled", "{", "return", "nil", "\n", "}", "\n\n", "// Spill child nodes first. Child nodes can materialize sibling nodes in", "// the case of split-merge so we cannot use a range loop. We have to check", "// the children size on every loop iteration.", "sort", ".", "Sort", "(", "n", ".", "children", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "n", ".", "children", ")", ";", "i", "++", "{", "if", "err", ":=", "n", ".", "children", "[", "i", "]", ".", "spill", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "// We no longer need the child list because it's only used for spill tracking.", "n", ".", "children", "=", "nil", "\n\n", "// Split nodes into appropriate sizes. The first node will always be n.", "var", "nodes", "=", "n", ".", "split", "(", "tx", ".", "db", ".", "pageSize", ")", "\n", "for", "_", ",", "node", ":=", "range", "nodes", "{", "// Add node's page to the freelist if it's not new.", "if", "node", ".", "pgid", ">", "0", "{", "tx", ".", "db", ".", "freelist", ".", "free", "(", "tx", ".", "meta", ".", "txid", ",", "tx", ".", "page", "(", "node", ".", "pgid", ")", ")", "\n", "node", ".", "pgid", "=", "0", "\n", "}", "\n\n", "// Allocate contiguous space for the node.", "p", ",", "err", ":=", "tx", ".", "allocate", "(", "(", "node", ".", "size", "(", ")", "/", "tx", ".", "db", ".", "pageSize", ")", "+", "1", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Write the node.", "if", "p", ".", "id", ">=", "tx", ".", "meta", ".", "pgid", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "p", ".", "id", ",", "tx", ".", "meta", ".", "pgid", ")", ")", "\n", "}", "\n", "node", ".", "pgid", "=", "p", ".", "id", "\n", "node", ".", "write", "(", "p", ")", "\n", "node", ".", "spilled", "=", "true", "\n\n", "// Insert into parent inodes.", "if", "node", ".", "parent", "!=", "nil", "{", "var", "key", "=", "node", ".", "key", "\n", "if", "key", "==", "nil", "{", "key", "=", "node", ".", "inodes", "[", "0", "]", ".", "key", "\n", "}", "\n\n", "node", ".", "parent", ".", "put", "(", "key", ",", "node", ".", "inodes", "[", "0", "]", ".", "key", ",", "nil", ",", "node", ".", "pgid", ",", "0", ")", "\n", "node", ".", "key", "=", "node", ".", "inodes", "[", "0", "]", ".", "key", "\n", "_assert", "(", "len", "(", "node", ".", "key", ")", ">", "0", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// Update the statistics.", "tx", ".", "stats", ".", "Spill", "++", "\n", "}", "\n\n", "// If the root node split and created a new root then we need to spill that", "// as well. We'll clear out the children to make sure it doesn't try to respill.", "if", "n", ".", "parent", "!=", "nil", "&&", "n", ".", "parent", ".", "pgid", "==", "0", "{", "n", ".", "children", "=", "nil", "\n", "return", "n", ".", "parent", ".", "spill", "(", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "spill", "writes", "the", "nodes", "to", "dirty", "pages", "and", "splits", "nodes", "as", "it", "goes", ".", "Returns", "an", "error", "if", "dirty", "pages", "cannot", "be", "allocated", "." ]

[ "func", "(", "n", "*", "node", ")", "removeChild", "(", "target", "*", "node", ")", "{", "for", "i", ",", "child", ":=", "range", "n", ".", "children", "{", "if", "child", "==", "target", "{", "n", ".", "children", "=", "append", "(", "n", ".", "children", "[", ":", "i", "]", ",", "n", ".", "children", "[", "i", "+", "1", ":", "]", "...", ")", "\n", "return", "\n", "}", "\n", "}", "\n", "}" ]

[ "removes", "a", "node", "from", "the", "list", "of", "in", "-", "memory", "children", ".", "This", "does", "not", "affect", "the", "inodes", "." ]

[ "func", "(", "n", "*", "node", ")", "free", "(", ")", "{", "if", "n", ".", "pgid", "!=", "0", "{", "n", ".", "bucket", ".", "tx", ".", "db", ".", "freelist", ".", "free", "(", "n", ".", "bucket", ".", "tx", ".", "meta", ".", "txid", ",", "n", ".", "bucket", ".", "tx", ".", "page", "(", "n", ".", "pgid", ")", ")", "\n", "n", ".", "pgid", "=", "0", "\n", "}", "\n", "}" ]

[ "free", "adds", "the", "node", "s", "underlying", "page", "to", "the", "freelist", "." ]

[ "func", "newBucket", "(", "tx", "*", "Tx", ")", "Bucket", "{", "var", "b", "=", "Bucket", "{", "tx", ":", "tx", ",", "FillPercent", ":", "DefaultFillPercent", "}", "\n", "if", "tx", ".", "writable", "{", "b", ".", "buckets", "=", "make", "(", "map", "[", "string", "]", "*", "Bucket", ")", "\n", "b", ".", "nodes", "=", "make", "(", "map", "[", "pgid", "]", "*", "node", ")", "\n", "}", "\n", "return", "b", "\n", "}" ]

[ "newBucket", "returns", "a", "new", "bucket", "associated", "with", "a", "transaction", "." ]

[ "func", "(", "b", "*", "Bucket", ")", "Cursor", "(", ")", "*", "Cursor", "{", "// Update transaction statistics.", "b", ".", "tx", ".", "stats", ".", "CursorCount", "++", "\n\n", "// Allocate and return a cursor.", "return", "&", "Cursor", "{", "bucket", ":", "b", ",", "stack", ":", "make", "(", "[", "]", "elemRef", ",", "0", ")", ",", "}", "\n", "}" ]

[ "Cursor", "creates", "a", "cursor", "associated", "with", "the", "bucket", ".", "The", "cursor", "is", "only", "valid", "as", "long", "as", "the", "transaction", "is", "open", ".", "Do", "not", "use", "a", "cursor", "after", "the", "transaction", "is", "closed", "." ]

[ "func", "(", "b", "*", "Bucket", ")", "Bucket", "(", "name", "[", "]", "byte", ")", "*", "Bucket", "{", "if", "b", ".", "buckets", "!=", "nil", "{", "if", "child", ":=", "b", ".", "buckets", "[", "string", "(", "name", ")", "]", ";", "child", "!=", "nil", "{", "return", "child", "\n", "}", "\n", "}", "\n\n", "// Move cursor to key.", "c", ":=", "b", ".", "Cursor", "(", ")", "\n", "k", ",", "v", ",", "flags", ":=", "c", ".", "seek", "(", "name", ")", "\n\n", "// Return nil if the key doesn't exist or it is not a bucket.", "if", "!", "bytes", ".", "Equal", "(", "name", ",", "k", ")", "||", "(", "flags", "&", "bucketLeafFlag", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n\n", "// Otherwise create a bucket and cache it.", "var", "child", "=", "b", ".", "openBucket", "(", "v", ")", "\n", "if", "b", ".", "buckets", "!=", "nil", "{", "b", ".", "buckets", "[", "string", "(", "name", ")", "]", "=", "child", "\n", "}", "\n\n", "return", "child", "\n", "}" ]

[ "Bucket", "retrieves", "a", "nested", "bucket", "by", "name", ".", "Returns", "nil", "if", "the", "bucket", "does", "not", "exist", ".", "The", "bucket", "instance", "is", "only", "valid", "for", "the", "lifetime", "of", "the", "transaction", "." ]

[ "func", "(", "b", "*", "Bucket", ")", "openBucket", "(", "value", "[", "]", "byte", ")", "*", "Bucket", "{", "var", "child", "=", "newBucket", "(", "b", ".", "tx", ")", "\n\n", "// If unaligned load/stores are broken on this arch and value is", "// unaligned simply clone to an aligned byte array.", "unaligned", ":=", "brokenUnaligned", "&&", "uintptr", "(", "unsafe", ".", "Pointer", "(", "&", "value", "[", "0", "]", ")", ")", "&", "3", "!=", "0", "\n\n", "if", "unaligned", "{", "value", "=", "cloneBytes", "(", "value", ")", "\n", "}", "\n\n", "// If this is a writable transaction then we need to copy the bucket entry.", "// Read-only transactions can point directly at the mmap entry.", "if", "b", ".", "tx", ".", "writable", "&&", "!", "unaligned", "{", "child", ".", "bucket", "=", "&", "bucket", "{", "}", "\n", "*", "child", ".", "bucket", "=", "*", "(", "*", "bucket", ")", "(", "unsafe", ".", "Pointer", "(", "&", "value", "[", "0", "]", ")", ")", "\n", "}", "else", "{", "child", ".", "bucket", "=", "(", "*", "bucket", ")", "(", "unsafe", ".", "Pointer", "(", "&", "value", "[", "0", "]", ")", ")", "\n", "}", "\n\n", "// Save a reference to the inline page if the bucket is inline.", "if", "child", ".", "root", "==", "0", "{", "child", ".", "page", "=", "(", "*", "page", ")", "(", "unsafe", ".", "Pointer", "(", "&", "value", "[", "bucketHeaderSize", "]", ")", ")", "\n", "}", "\n\n", "return", "&", "child", "\n", "}" ]

[ "Helper", "method", "that", "re", "-", "interprets", "a", "sub", "-", "bucket", "value", "from", "a", "parent", "into", "a", "Bucket" ]

[ "func", "(", "b", "*", "Bucket", ")", "CreateBucketIfNotExists", "(", "key", "[", "]", "byte", ")", "(", "*", "Bucket", ",", "error", ")", "{", "child", ",", "err", ":=", "b", ".", "CreateBucket", "(", "key", ")", "\n", "if", "err", "==", "ErrBucketExists", "{", "return", "b", ".", "Bucket", "(", "key", ")", ",", "nil", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "child", ",", "nil", "\n", "}" ]

[ "CreateBucketIfNotExists", "creates", "a", "new", "bucket", "if", "it", "doesn", "t", "already", "exist", "and", "returns", "a", "reference", "to", "it", ".", "Returns", "an", "error", "if", "the", "bucket", "name", "is", "blank", "or", "if", "the", "bucket", "name", "is", "too", "long", ".", "The", "bucket", "instance", "is", "only", "valid", "for", "the", "lifetime", "of", "the", "transaction", "." ]

[ "func", "(", "b", "*", "Bucket", ")", "DeleteBucket", "(", "key", "[", "]", "byte", ")", "error", "{", "if", "b", ".", "tx", ".", "db", "==", "nil", "{", "return", "ErrTxClosed", "\n", "}", "else", "if", "!", "b", ".", "Writable", "(", ")", "{", "return", "ErrTxNotWritable", "\n", "}", "\n\n", "// Move cursor to correct position.", "c", ":=", "b", ".", "Cursor", "(", ")", "\n", "k", ",", "_", ",", "flags", ":=", "c", ".", "seek", "(", "key", ")", "\n\n", "// Return an error if bucket doesn't exist or is not a bucket.", "if", "!", "bytes", ".", "Equal", "(", "key", ",", "k", ")", "{", "return", "ErrBucketNotFound", "\n", "}", "else", "if", "(", "flags", "&", "bucketLeafFlag", ")", "==", "0", "{", "return", "ErrIncompatibleValue", "\n", "}", "\n\n", "// Recursively delete all child buckets.", "child", ":=", "b", ".", "Bucket", "(", "key", ")", "\n", "err", ":=", "child", ".", "ForEach", "(", "func", "(", "k", ",", "v", "[", "]", "byte", ")", "error", "{", "if", "v", "==", "nil", "{", "if", "err", ":=", "child", ".", "DeleteBucket", "(", "k", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Remove cached copy.", "delete", "(", "b", ".", "buckets", ",", "string", "(", "key", ")", ")", "\n\n", "// Release all bucket pages to freelist.", "child", ".", "nodes", "=", "nil", "\n", "child", ".", "rootNode", "=", "nil", "\n", "child", ".", "free", "(", ")", "\n\n", "// Delete the node if we have a matching key.", "c", ".", "node", "(", ")", ".", "del", "(", "key", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "DeleteBucket", "deletes", "a", "bucket", "at", "the", "given", "key", ".", "Returns", "an", "error", "if", "the", "bucket", "does", "not", "exists", "or", "if", "the", "key", "represents", "a", "non", "-", "bucket", "value", "." ]

[ "func", "(", "b", "*", "Bucket", ")", "Get", "(", "key", "[", "]", "byte", ")", "[", "]", "byte", "{", "k", ",", "v", ",", "flags", ":=", "b", ".", "Cursor", "(", ")", ".", "seek", "(", "key", ")", "\n\n", "// Return nil if this is a bucket.", "if", "(", "flags", "&", "bucketLeafFlag", ")", "!=", "0", "{", "return", "nil", "\n", "}", "\n\n", "// If our target node isn't the same key as what's passed in then return nil.", "if", "!", "bytes", ".", "Equal", "(", "key", ",", "k", ")", "{", "return", "nil", "\n", "}", "\n", "return", "v", "\n", "}" ]

[ "Get", "retrieves", "the", "value", "for", "a", "key", "in", "the", "bucket", ".", "Returns", "a", "nil", "value", "if", "the", "key", "does", "not", "exist", "or", "if", "the", "key", "is", "a", "nested", "bucket", ".", "The", "returned", "value", "is", "only", "valid", "for", "the", "life", "of", "the", "transaction", "." ]

[ "func", "(", "b", "*", "Bucket", ")", "Put", "(", "key", "[", "]", "byte", ",", "value", "[", "]", "byte", ")", "error", "{", "if", "b", ".", "tx", ".", "db", "==", "nil", "{", "return", "ErrTxClosed", "\n", "}", "else", "if", "!", "b", ".", "Writable", "(", ")", "{", "return", "ErrTxNotWritable", "\n", "}", "else", "if", "len", "(", "key", ")", "==", "0", "{", "return", "ErrKeyRequired", "\n", "}", "else", "if", "len", "(", "key", ")", ">", "MaxKeySize", "{", "return", "ErrKeyTooLarge", "\n", "}", "else", "if", "int64", "(", "len", "(", "value", ")", ")", ">", "MaxValueSize", "{", "return", "ErrValueTooLarge", "\n", "}", "\n\n", "// Move cursor to correct position.", "c", ":=", "b", ".", "Cursor", "(", ")", "\n", "k", ",", "_", ",", "flags", ":=", "c", ".", "seek", "(", "key", ")", "\n\n", "// Return an error if there is an existing key with a bucket value.", "if", "bytes", ".", "Equal", "(", "key", ",", "k", ")", "&&", "(", "flags", "&", "bucketLeafFlag", ")", "!=", "0", "{", "return", "ErrIncompatibleValue", "\n", "}", "\n\n", "// Insert into node.", "key", "=", "cloneBytes", "(", "key", ")", "\n", "c", ".", "node", "(", ")", ".", "put", "(", "key", ",", "key", ",", "value", ",", "0", ",", "0", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "Put", "sets", "the", "value", "for", "a", "key", "in", "the", "bucket", ".", "If", "the", "key", "exist", "then", "its", "previous", "value", "will", "be", "overwritten", ".", "Supplied", "value", "must", "remain", "valid", "for", "the", "life", "of", "the", "transaction", ".", "Returns", "an", "error", "if", "the", "bucket", "was", "created", "from", "a", "read", "-", "only", "transaction", "if", "the", "key", "is", "blank", "if", "the", "key", "is", "too", "large", "or", "if", "the", "value", "is", "too", "large", "." ]

[ "func", "(", "b", "*", "Bucket", ")", "SetSequence", "(", "v", "uint64", ")", "error", "{", "if", "b", ".", "tx", ".", "db", "==", "nil", "{", "return", "ErrTxClosed", "\n", "}", "else", "if", "!", "b", ".", "Writable", "(", ")", "{", "return", "ErrTxNotWritable", "\n", "}", "\n\n", "// Materialize the root node if it hasn't been already so that the", "// bucket will be saved during commit.", "if", "b", ".", "rootNode", "==", "nil", "{", "_", "=", "b", ".", "node", "(", "b", ".", "root", ",", "nil", ")", "\n", "}", "\n\n", "// Increment and return the sequence.", "b", ".", "bucket", ".", "sequence", "=", "v", "\n", "return", "nil", "\n", "}" ]

[ "SetSequence", "updates", "the", "sequence", "number", "for", "the", "bucket", "." ]

[ "func", "(", "b", "*", "Bucket", ")", "Stats", "(", ")", "BucketStats", "{", "var", "s", ",", "subStats", "BucketStats", "\n", "pageSize", ":=", "b", ".", "tx", ".", "db", ".", "pageSize", "\n", "s", ".", "BucketN", "+=", "1", "\n", "if", "b", ".", "root", "==", "0", "{", "s", ".", "InlineBucketN", "+=", "1", "\n", "}", "\n", "b", ".", "forEachPage", "(", "func", "(", "p", "*", "page", ",", "depth", "int", ")", "{", "if", "(", "p", ".", "flags", "&", "leafPageFlag", ")", "!=", "0", "{", "s", ".", "KeyN", "+=", "int", "(", "p", ".", "count", ")", "\n\n", "// used totals the used bytes for the page", "used", ":=", "pageHeaderSize", "\n\n", "if", "p", ".", "count", "!=", "0", "{", "// If page has any elements, add all element headers.", "used", "+=", "leafPageElementSize", "*", "int", "(", "p", ".", "count", "-", "1", ")", "\n\n", "// Add all element key, value sizes.", "// The computation takes advantage of the fact that the position", "// of the last element's key/value equals to the total of the sizes", "// of all previous elements' keys and values.", "// It also includes the last element's header.", "lastElement", ":=", "p", ".", "leafPageElement", "(", "p", ".", "count", "-", "1", ")", "\n", "used", "+=", "int", "(", "lastElement", ".", "pos", "+", "lastElement", ".", "ksize", "+", "lastElement", ".", "vsize", ")", "\n", "}", "\n\n", "if", "b", ".", "root", "==", "0", "{", "// For inlined bucket just update the inline stats", "s", ".", "InlineBucketInuse", "+=", "used", "\n", "}", "else", "{", "// For non-inlined bucket update all the leaf stats", "s", ".", "LeafPageN", "++", "\n", "s", ".", "LeafInuse", "+=", "used", "\n", "s", ".", "LeafOverflowN", "+=", "int", "(", "p", ".", "overflow", ")", "\n\n", "// Collect stats from sub-buckets.", "// Do that by iterating over all element headers", "// looking for the ones with the bucketLeafFlag.", "for", "i", ":=", "uint16", "(", "0", ")", ";", "i", "<", "p", ".", "count", ";", "i", "++", "{", "e", ":=", "p", ".", "leafPageElement", "(", "i", ")", "\n", "if", "(", "e", ".", "flags", "&", "bucketLeafFlag", ")", "!=", "0", "{", "// For any bucket element, open the element value", "// and recursively call Stats on the contained bucket.", "subStats", ".", "Add", "(", "b", ".", "openBucket", "(", "e", ".", "value", "(", ")", ")", ".", "Stats", "(", ")", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "else", "if", "(", "p", ".", "flags", "&", "branchPageFlag", ")", "!=", "0", "{", "s", ".", "BranchPageN", "++", "\n", "lastElement", ":=", "p", ".", "branchPageElement", "(", "p", ".", "count", "-", "1", ")", "\n\n", "// used totals the used bytes for the page", "// Add header and all element headers.", "used", ":=", "pageHeaderSize", "+", "(", "branchPageElementSize", "*", "int", "(", "p", ".", "count", "-", "1", ")", ")", "\n\n", "// Add size of all keys and values.", "// Again, use the fact that last element's position equals to", "// the total of key, value sizes of all previous elements.", "used", "+=", "int", "(", "lastElement", ".", "pos", "+", "lastElement", ".", "ksize", ")", "\n", "s", ".", "BranchInuse", "+=", "used", "\n", "s", ".", "BranchOverflowN", "+=", "int", "(", "p", ".", "overflow", ")", "\n", "}", "\n\n", "// Keep track of maximum page depth.", "if", "depth", "+", "1", ">", "s", ".", "Depth", "{", "s", ".", "Depth", "=", "(", "depth", "+", "1", ")", "\n", "}", "\n", "}", ")", "\n\n", "// Alloc stats can be computed from page counts and pageSize.", "s", ".", "BranchAlloc", "=", "(", "s", ".", "BranchPageN", "+", "s", ".", "BranchOverflowN", ")", "*", "pageSize", "\n", "s", ".", "LeafAlloc", "=", "(", "s", ".", "LeafPageN", "+", "s", ".", "LeafOverflowN", ")", "*", "pageSize", "\n\n", "// Add the max depth of sub-buckets to get total nested depth.", "s", ".", "Depth", "+=", "subStats", ".", "Depth", "\n", "// Add the stats for all sub-buckets", "s", ".", "Add", "(", "subStats", ")", "\n", "return", "s", "\n", "}" ]

[ "Stat", "returns", "stats", "on", "a", "bucket", "." ]

[ "func", "(", "b", "*", "Bucket", ")", "forEachPage", "(", "fn", "func", "(", "*", "page", ",", "int", ")", ")", "{", "// If we have an inline page then just use that.", "if", "b", ".", "page", "!=", "nil", "{", "fn", "(", "b", ".", "page", ",", "0", ")", "\n", "return", "\n", "}", "\n\n", "// Otherwise traverse the page hierarchy.", "b", ".", "tx", ".", "forEachPage", "(", "b", ".", "root", ",", "0", ",", "fn", ")", "\n", "}" ]

[ "forEachPage", "iterates", "over", "every", "page", "in", "a", "bucket", "including", "inline", "pages", "." ]

[ "func", "(", "b", "*", "Bucket", ")", "spill", "(", ")", "error", "{", "// Spill all child buckets first.", "for", "name", ",", "child", ":=", "range", "b", ".", "buckets", "{", "// If the child bucket is small enough and it has no child buckets then", "// write it inline into the parent bucket's page. Otherwise spill it", "// like a normal bucket and make the parent value a pointer to the page.", "var", "value", "[", "]", "byte", "\n", "if", "child", ".", "inlineable", "(", ")", "{", "child", ".", "free", "(", ")", "\n", "value", "=", "child", ".", "write", "(", ")", "\n", "}", "else", "{", "if", "err", ":=", "child", ".", "spill", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Update the child bucket header in this bucket.", "value", "=", "make", "(", "[", "]", "byte", ",", "unsafe", ".", "Sizeof", "(", "bucket", "{", "}", ")", ")", "\n", "var", "bucket", "=", "(", "*", "bucket", ")", "(", "unsafe", ".", "Pointer", "(", "&", "value", "[", "0", "]", ")", ")", "\n", "*", "bucket", "=", "*", "child", ".", "bucket", "\n", "}", "\n\n", "// Skip writing the bucket if there are no materialized nodes.", "if", "child", ".", "rootNode", "==", "nil", "{", "continue", "\n", "}", "\n\n", "// Update parent node.", "var", "c", "=", "b", ".", "Cursor", "(", ")", "\n", "k", ",", "_", ",", "flags", ":=", "c", ".", "seek", "(", "[", "]", "byte", "(", "name", ")", ")", "\n", "if", "!", "bytes", ".", "Equal", "(", "[", "]", "byte", "(", "name", ")", ",", "k", ")", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "[", "]", "byte", "(", "name", ")", ",", "k", ")", ")", "\n", "}", "\n", "if", "flags", "&", "bucketLeafFlag", "==", "0", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "flags", ")", ")", "\n", "}", "\n", "c", ".", "node", "(", ")", ".", "put", "(", "[", "]", "byte", "(", "name", ")", ",", "[", "]", "byte", "(", "name", ")", ",", "value", ",", "0", ",", "bucketLeafFlag", ")", "\n", "}", "\n\n", "// Ignore if there's not a materialized root node.", "if", "b", ".", "rootNode", "==", "nil", "{", "return", "nil", "\n", "}", "\n\n", "// Spill nodes.", "if", "err", ":=", "b", ".", "rootNode", ".", "spill", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "b", ".", "rootNode", "=", "b", ".", "rootNode", ".", "root", "(", ")", "\n\n", "// Update the root node for this bucket.", "if", "b", ".", "rootNode", ".", "pgid", ">=", "b", ".", "tx", ".", "meta", ".", "pgid", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "b", ".", "rootNode", ".", "pgid", ",", "b", ".", "tx", ".", "meta", ".", "pgid", ")", ")", "\n", "}", "\n", "b", ".", "root", "=", "b", ".", "rootNode", ".", "pgid", "\n\n", "return", "nil", "\n", "}" ]

[ "spill", "writes", "all", "the", "nodes", "for", "this", "bucket", "to", "dirty", "pages", "." ]

[ "func", "(", "b", "*", "Bucket", ")", "inlineable", "(", ")", "bool", "{", "var", "n", "=", "b", ".", "rootNode", "\n\n", "// Bucket must only contain a single leaf node.", "if", "n", "==", "nil", "||", "!", "n", ".", "isLeaf", "{", "return", "false", "\n", "}", "\n\n", "// Bucket is not inlineable if it contains subbuckets or if it goes beyond", "// our threshold for inline bucket size.", "var", "size", "=", "pageHeaderSize", "\n", "for", "_", ",", "inode", ":=", "range", "n", ".", "inodes", "{", "size", "+=", "leafPageElementSize", "+", "len", "(", "inode", ".", "key", ")", "+", "len", "(", "inode", ".", "value", ")", "\n\n", "if", "inode", ".", "flags", "&", "bucketLeafFlag", "!=", "0", "{", "return", "false", "\n", "}", "else", "if", "size", ">", "b", ".", "maxInlineBucketSize", "(", ")", "{", "return", "false", "\n", "}", "\n", "}", "\n\n", "return", "true", "\n", "}" ]

[ "inlineable", "returns", "true", "if", "a", "bucket", "is", "small", "enough", "to", "be", "written", "inline", "and", "if", "it", "contains", "no", "subbuckets", ".", "Otherwise", "returns", "false", "." ]

[ "func", "(", "b", "*", "Bucket", ")", "write", "(", ")", "[", "]", "byte", "{", "// Allocate the appropriate size.", "var", "n", "=", "b", ".", "rootNode", "\n", "var", "value", "=", "make", "(", "[", "]", "byte", ",", "bucketHeaderSize", "+", "n", ".", "size", "(", ")", ")", "\n\n", "// Write a bucket header.", "var", "bucket", "=", "(", "*", "bucket", ")", "(", "unsafe", ".", "Pointer", "(", "&", "value", "[", "0", "]", ")", ")", "\n", "*", "bucket", "=", "*", "b", ".", "bucket", "\n\n", "// Convert byte slice to a fake page and write the root node.", "var", "p", "=", "(", "*", "page", ")", "(", "unsafe", ".", "Pointer", "(", "&", "value", "[", "bucketHeaderSize", "]", ")", ")", "\n", "n", ".", "write", "(", "p", ")", "\n\n", "return", "value", "\n", "}" ]

[ "write", "allocates", "and", "writes", "a", "bucket", "to", "a", "byte", "slice", "." ]

[ "func", "(", "b", "*", "Bucket", ")", "rebalance", "(", ")", "{", "for", "_", ",", "n", ":=", "range", "b", ".", "nodes", "{", "n", ".", "rebalance", "(", ")", "\n", "}", "\n", "for", "_", ",", "child", ":=", "range", "b", ".", "buckets", "{", "child", ".", "rebalance", "(", ")", "\n", "}", "\n", "}" ]

[ "rebalance", "attempts", "to", "balance", "all", "nodes", "." ]

[ "func", "(", "b", "*", "Bucket", ")", "node", "(", "pgid", "pgid", ",", "parent", "*", "node", ")", "*", "node", "{", "_assert", "(", "b", ".", "nodes", "!=", "nil", ",", "\"", "\"", ")", "\n\n", "// Retrieve node if it's already been created.", "if", "n", ":=", "b", ".", "nodes", "[", "pgid", "]", ";", "n", "!=", "nil", "{", "return", "n", "\n", "}", "\n\n", "// Otherwise create a node and cache it.", "n", ":=", "&", "node", "{", "bucket", ":", "b", ",", "parent", ":", "parent", "}", "\n", "if", "parent", "==", "nil", "{", "b", ".", "rootNode", "=", "n", "\n", "}", "else", "{", "parent", ".", "children", "=", "append", "(", "parent", ".", "children", ",", "n", ")", "\n", "}", "\n\n", "// Use the inline page if this is an inline bucket.", "var", "p", "=", "b", ".", "page", "\n", "if", "p", "==", "nil", "{", "p", "=", "b", ".", "tx", ".", "page", "(", "pgid", ")", "\n", "}", "\n\n", "// Read the page into the node and cache it.", "n", ".", "read", "(", "p", ")", "\n", "b", ".", "nodes", "[", "pgid", "]", "=", "n", "\n\n", "// Update statistics.", "b", ".", "tx", ".", "stats", ".", "NodeCount", "++", "\n\n", "return", "n", "\n", "}" ]

[ "node", "creates", "a", "node", "from", "a", "page", "and", "associates", "it", "with", "a", "given", "parent", "." ]

[ "func", "(", "b", "*", "Bucket", ")", "free", "(", ")", "{", "if", "b", ".", "root", "==", "0", "{", "return", "\n", "}", "\n\n", "var", "tx", "=", "b", ".", "tx", "\n", "b", ".", "forEachPageNode", "(", "func", "(", "p", "*", "page", ",", "n", "*", "node", ",", "_", "int", ")", "{", "if", "p", "!=", "nil", "{", "tx", ".", "db", ".", "freelist", ".", "free", "(", "tx", ".", "meta", ".", "txid", ",", "p", ")", "\n", "}", "else", "{", "n", ".", "free", "(", ")", "\n", "}", "\n", "}", ")", "\n", "b", ".", "root", "=", "0", "\n", "}" ]

[ "free", "recursively", "frees", "all", "pages", "in", "the", "bucket", "." ]

[ "func", "(", "b", "*", "Bucket", ")", "dereference", "(", ")", "{", "if", "b", ".", "rootNode", "!=", "nil", "{", "b", ".", "rootNode", ".", "root", "(", ")", ".", "dereference", "(", ")", "\n", "}", "\n\n", "for", "_", ",", "child", ":=", "range", "b", ".", "buckets", "{", "child", ".", "dereference", "(", ")", "\n", "}", "\n", "}" ]

[ "dereference", "removes", "all", "references", "to", "the", "old", "mmap", "." ]

[ "func", "(", "b", "*", "Bucket", ")", "pageNode", "(", "id", "pgid", ")", "(", "*", "page", ",", "*", "node", ")", "{", "// Inline buckets have a fake page embedded in their value so treat them", "// differently. We'll return the rootNode (if available) or the fake page.", "if", "b", ".", "root", "==", "0", "{", "if", "id", "!=", "0", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "id", ")", ")", "\n", "}", "\n", "if", "b", ".", "rootNode", "!=", "nil", "{", "return", "nil", ",", "b", ".", "rootNode", "\n", "}", "\n", "return", "b", ".", "page", ",", "nil", "\n", "}", "\n\n", "// Check the node cache for non-inline buckets.", "if", "b", ".", "nodes", "!=", "nil", "{", "if", "n", ":=", "b", ".", "nodes", "[", "id", "]", ";", "n", "!=", "nil", "{", "return", "nil", ",", "n", "\n", "}", "\n", "}", "\n\n", "// Finally lookup the page from the transaction if no node is materialized.", "return", "b", ".", "tx", ".", "page", "(", "id", ")", ",", "nil", "\n", "}" ]

[ "pageNode", "returns", "the", "in", "-", "memory", "node", "if", "it", "exists", ".", "Otherwise", "returns", "the", "underlying", "page", "." ]

[ "func", "cloneBytes", "(", "v", "[", "]", "byte", ")", "[", "]", "byte", "{", "var", "clone", "=", "make", "(", "[", "]", "byte", ",", "len", "(", "v", ")", ")", "\n", "copy", "(", "clone", ",", "v", ")", "\n", "return", "clone", "\n", "}" ]

[ "cloneBytes", "returns", "a", "copy", "of", "a", "given", "slice", "." ]

[ "func", "mmap", "(", "db", "*", "DB", ",", "sz", "int", ")", "error", "{", "// Map the data file to memory.", "b", ",", "err", ":=", "unix", ".", "Mmap", "(", "int", "(", "db", ".", "file", ".", "Fd", "(", ")", ")", ",", "0", ",", "sz", ",", "syscall", ".", "PROT_READ", ",", "syscall", ".", "MAP_SHARED", "|", "db", ".", "MmapFlags", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Advise the kernel that the mmap is accessed randomly.", "if", "err", ":=", "unix", ".", "Madvise", "(", "b", ",", "syscall", ".", "MADV_RANDOM", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// Save the original byte slice and convert to a byte array pointer.", "db", ".", "dataref", "=", "b", "\n", "db", ".", "data", "=", "(", "*", "[", "maxMapSize", "]", "byte", ")", "(", "unsafe", ".", "Pointer", "(", "&", "b", "[", "0", "]", ")", ")", "\n", "db", ".", "datasz", "=", "sz", "\n", "return", "nil", "\n", "}" ]

[ "mmap", "memory", "maps", "a", "DB", "s", "data", "file", "." ]

[ "func", "munmap", "(", "db", "*", "DB", ")", "error", "{", "// Ignore the unmap if we have no mapped data.", "if", "db", ".", "dataref", "==", "nil", "{", "return", "nil", "\n", "}", "\n\n", "// Unmap using the original byte slice.", "err", ":=", "unix", ".", "Munmap", "(", "db", ".", "dataref", ")", "\n", "db", ".", "dataref", "=", "nil", "\n", "db", ".", "data", "=", "nil", "\n", "db", ".", "datasz", "=", "0", "\n", "return", "err", "\n", "}" ]

[ "munmap", "unmaps", "a", "DB", "s", "data", "file", "from", "memory", "." ]

[ "func", "(", "c", "*", "Cursor", ")", "First", "(", ")", "(", "key", "[", "]", "byte", ",", "value", "[", "]", "byte", ")", "{", "_assert", "(", "c", ".", "bucket", ".", "tx", ".", "db", "!=", "nil", ",", "\"", "\"", ")", "\n", "c", ".", "stack", "=", "c", ".", "stack", "[", ":", "0", "]", "\n", "p", ",", "n", ":=", "c", ".", "bucket", ".", "pageNode", "(", "c", ".", "bucket", ".", "root", ")", "\n", "c", ".", "stack", "=", "append", "(", "c", ".", "stack", ",", "elemRef", "{", "page", ":", "p", ",", "node", ":", "n", ",", "index", ":", "0", "}", ")", "\n", "c", ".", "first", "(", ")", "\n\n", "// If we land on an empty page then move to the next value.", "// https://github.com/boltdb/bolt/issues/450", "if", "c", ".", "stack", "[", "len", "(", "c", ".", "stack", ")", "-", "1", "]", ".", "count", "(", ")", "==", "0", "{", "c", ".", "next", "(", ")", "\n", "}", "\n\n", "k", ",", "v", ",", "flags", ":=", "c", ".", "keyValue", "(", ")", "\n", "if", "(", "flags", "&", "uint32", "(", "bucketLeafFlag", ")", ")", "!=", "0", "{", "return", "k", ",", "nil", "\n", "}", "\n", "return", "k", ",", "v", "\n\n", "}" ]

[ "First", "moves", "the", "cursor", "to", "the", "first", "item", "in", "the", "bucket", "and", "returns", "its", "key", "and", "value", ".", "If", "the", "bucket", "is", "empty", "then", "a", "nil", "key", "and", "value", "are", "returned", ".", "The", "returned", "key", "and", "value", "are", "only", "valid", "for", "the", "life", "of", "the", "transaction", "." ]

[ "func", "(", "c", "*", "Cursor", ")", "Last", "(", ")", "(", "key", "[", "]", "byte", ",", "value", "[", "]", "byte", ")", "{", "_assert", "(", "c", ".", "bucket", ".", "tx", ".", "db", "!=", "nil", ",", "\"", "\"", ")", "\n", "c", ".", "stack", "=", "c", ".", "stack", "[", ":", "0", "]", "\n", "p", ",", "n", ":=", "c", ".", "bucket", ".", "pageNode", "(", "c", ".", "bucket", ".", "root", ")", "\n", "ref", ":=", "elemRef", "{", "page", ":", "p", ",", "node", ":", "n", "}", "\n", "ref", ".", "index", "=", "ref", ".", "count", "(", ")", "-", "1", "\n", "c", ".", "stack", "=", "append", "(", "c", ".", "stack", ",", "ref", ")", "\n", "c", ".", "last", "(", ")", "\n", "k", ",", "v", ",", "flags", ":=", "c", ".", "keyValue", "(", ")", "\n", "if", "(", "flags", "&", "uint32", "(", "bucketLeafFlag", ")", ")", "!=", "0", "{", "return", "k", ",", "nil", "\n", "}", "\n", "return", "k", ",", "v", "\n", "}" ]

[ "Last", "moves", "the", "cursor", "to", "the", "last", "item", "in", "the", "bucket", "and", "returns", "its", "key", "and", "value", ".", "If", "the", "bucket", "is", "empty", "then", "a", "nil", "key", "and", "value", "are", "returned", ".", "The", "returned", "key", "and", "value", "are", "only", "valid", "for", "the", "life", "of", "the", "transaction", "." ]

[ "func", "(", "c", "*", "Cursor", ")", "Next", "(", ")", "(", "key", "[", "]", "byte", ",", "value", "[", "]", "byte", ")", "{", "_assert", "(", "c", ".", "bucket", ".", "tx", ".", "db", "!=", "nil", ",", "\"", "\"", ")", "\n", "k", ",", "v", ",", "flags", ":=", "c", ".", "next", "(", ")", "\n", "if", "(", "flags", "&", "uint32", "(", "bucketLeafFlag", ")", ")", "!=", "0", "{", "return", "k", ",", "nil", "\n", "}", "\n", "return", "k", ",", "v", "\n", "}" ]

[ "Next", "moves", "the", "cursor", "to", "the", "next", "item", "in", "the", "bucket", "and", "returns", "its", "key", "and", "value", ".", "If", "the", "cursor", "is", "at", "the", "end", "of", "the", "bucket", "then", "a", "nil", "key", "and", "value", "are", "returned", ".", "The", "returned", "key", "and", "value", "are", "only", "valid", "for", "the", "life", "of", "the", "transaction", "." ]

[ "func", "(", "c", "*", "Cursor", ")", "Prev", "(", ")", "(", "key", "[", "]", "byte", ",", "value", "[", "]", "byte", ")", "{", "_assert", "(", "c", ".", "bucket", ".", "tx", ".", "db", "!=", "nil", ",", "\"", "\"", ")", "\n\n", "// Attempt to move back one element until we're successful.", "// Move up the stack as we hit the beginning of each page in our stack.", "for", "i", ":=", "len", "(", "c", ".", "stack", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", "{", "elem", ":=", "&", "c", ".", "stack", "[", "i", "]", "\n", "if", "elem", ".", "index", ">", "0", "{", "elem", ".", "index", "--", "\n", "break", "\n", "}", "\n", "c", ".", "stack", "=", "c", ".", "stack", "[", ":", "i", "]", "\n", "}", "\n\n", "// If we've hit the end then return nil.", "if", "len", "(", "c", ".", "stack", ")", "==", "0", "{", "return", "nil", ",", "nil", "\n", "}", "\n\n", "// Move down the stack to find the last element of the last leaf under this branch.", "c", ".", "last", "(", ")", "\n", "k", ",", "v", ",", "flags", ":=", "c", ".", "keyValue", "(", ")", "\n", "if", "(", "flags", "&", "uint32", "(", "bucketLeafFlag", ")", ")", "!=", "0", "{", "return", "k", ",", "nil", "\n", "}", "\n", "return", "k", ",", "v", "\n", "}" ]

[ "Prev", "moves", "the", "cursor", "to", "the", "previous", "item", "in", "the", "bucket", "and", "returns", "its", "key", "and", "value", ".", "If", "the", "cursor", "is", "at", "the", "beginning", "of", "the", "bucket", "then", "a", "nil", "key", "and", "value", "are", "returned", ".", "The", "returned", "key", "and", "value", "are", "only", "valid", "for", "the", "life", "of", "the", "transaction", "." ]

[ "func", "(", "c", "*", "Cursor", ")", "Seek", "(", "seek", "[", "]", "byte", ")", "(", "key", "[", "]", "byte", ",", "value", "[", "]", "byte", ")", "{", "k", ",", "v", ",", "flags", ":=", "c", ".", "seek", "(", "seek", ")", "\n\n", "// If we ended up after the last element of a page then move to the next one.", "if", "ref", ":=", "&", "c", ".", "stack", "[", "len", "(", "c", ".", "stack", ")", "-", "1", "]", ";", "ref", ".", "index", ">=", "ref", ".", "count", "(", ")", "{", "k", ",", "v", ",", "flags", "=", "c", ".", "next", "(", ")", "\n", "}", "\n\n", "if", "k", "==", "nil", "{", "return", "nil", ",", "nil", "\n", "}", "else", "if", "(", "flags", "&", "uint32", "(", "bucketLeafFlag", ")", ")", "!=", "0", "{", "return", "k", ",", "nil", "\n", "}", "\n", "return", "k", ",", "v", "\n", "}" ]

[ "Seek", "moves", "the", "cursor", "to", "a", "given", "key", "and", "returns", "it", ".", "If", "the", "key", "does", "not", "exist", "then", "the", "next", "key", "is", "used", ".", "If", "no", "keys", "follow", "a", "nil", "key", "is", "returned", ".", "The", "returned", "key", "and", "value", "are", "only", "valid", "for", "the", "life", "of", "the", "transaction", "." ]

[ "func", "(", "c", "*", "Cursor", ")", "seek", "(", "seek", "[", "]", "byte", ")", "(", "key", "[", "]", "byte", ",", "value", "[", "]", "byte", ",", "flags", "uint32", ")", "{", "_assert", "(", "c", ".", "bucket", ".", "tx", ".", "db", "!=", "nil", ",", "\"", "\"", ")", "\n\n", "// Start from root page/node and traverse to correct page.", "c", ".", "stack", "=", "c", ".", "stack", "[", ":", "0", "]", "\n", "c", ".", "search", "(", "seek", ",", "c", ".", "bucket", ".", "root", ")", "\n", "ref", ":=", "&", "c", ".", "stack", "[", "len", "(", "c", ".", "stack", ")", "-", "1", "]", "\n\n", "// If the cursor is pointing to the end of page/node then return nil.", "if", "ref", ".", "index", ">=", "ref", ".", "count", "(", ")", "{", "return", "nil", ",", "nil", ",", "0", "\n", "}", "\n\n", "// If this is a bucket then return a nil value.", "return", "c", ".", "keyValue", "(", ")", "\n", "}" ]

[ "seek", "moves", "the", "cursor", "to", "a", "given", "key", "and", "returns", "it", ".", "If", "the", "key", "does", "not", "exist", "then", "the", "next", "key", "is", "used", "." ]

[ "func", "(", "c", "*", "Cursor", ")", "first", "(", ")", "{", "for", "{", "// Exit when we hit a leaf page.", "var", "ref", "=", "&", "c", ".", "stack", "[", "len", "(", "c", ".", "stack", ")", "-", "1", "]", "\n", "if", "ref", ".", "isLeaf", "(", ")", "{", "break", "\n", "}", "\n\n", "// Keep adding pages pointing to the first element to the stack.", "var", "pgid", "pgid", "\n", "if", "ref", ".", "node", "!=", "nil", "{", "pgid", "=", "ref", ".", "node", ".", "inodes", "[", "ref", ".", "index", "]", ".", "pgid", "\n", "}", "else", "{", "pgid", "=", "ref", ".", "page", ".", "branchPageElement", "(", "uint16", "(", "ref", ".", "index", ")", ")", ".", "pgid", "\n", "}", "\n", "p", ",", "n", ":=", "c", ".", "bucket", ".", "pageNode", "(", "pgid", ")", "\n", "c", ".", "stack", "=", "append", "(", "c", ".", "stack", ",", "elemRef", "{", "page", ":", "p", ",", "node", ":", "n", ",", "index", ":", "0", "}", ")", "\n", "}", "\n", "}" ]

[ "first", "moves", "the", "cursor", "to", "the", "first", "leaf", "element", "under", "the", "last", "page", "in", "the", "stack", "." ]

[ "func", "(", "c", "*", "Cursor", ")", "next", "(", ")", "(", "key", "[", "]", "byte", ",", "value", "[", "]", "byte", ",", "flags", "uint32", ")", "{", "for", "{", "// Attempt to move over one element until we're successful.", "// Move up the stack as we hit the end of each page in our stack.", "var", "i", "int", "\n", "for", "i", "=", "len", "(", "c", ".", "stack", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", "{", "elem", ":=", "&", "c", ".", "stack", "[", "i", "]", "\n", "if", "elem", ".", "index", "<", "elem", ".", "count", "(", ")", "-", "1", "{", "elem", ".", "index", "++", "\n", "break", "\n", "}", "\n", "}", "\n\n", "// If we've hit the root page then stop and return. This will leave the", "// cursor on the last element of the last page.", "if", "i", "==", "-", "1", "{", "return", "nil", ",", "nil", ",", "0", "\n", "}", "\n\n", "// Otherwise start from where we left off in the stack and find the", "// first element of the first leaf page.", "c", ".", "stack", "=", "c", ".", "stack", "[", ":", "i", "+", "1", "]", "\n", "c", ".", "first", "(", ")", "\n\n", "// If this is an empty page then restart and move back up the stack.", "// https://github.com/boltdb/bolt/issues/450", "if", "c", ".", "stack", "[", "len", "(", "c", ".", "stack", ")", "-", "1", "]", ".", "count", "(", ")", "==", "0", "{", "continue", "\n", "}", "\n\n", "return", "c", ".", "keyValue", "(", ")", "\n", "}", "\n", "}" ]

[ "next", "moves", "to", "the", "next", "leaf", "element", "and", "returns", "the", "key", "and", "value", ".", "If", "the", "cursor", "is", "at", "the", "last", "leaf", "element", "then", "it", "stays", "there", "and", "returns", "nil", "." ]

[ "func", "(", "c", "*", "Cursor", ")", "nsearch", "(", "key", "[", "]", "byte", ")", "{", "e", ":=", "&", "c", ".", "stack", "[", "len", "(", "c", ".", "stack", ")", "-", "1", "]", "\n", "p", ",", "n", ":=", "e", ".", "page", ",", "e", ".", "node", "\n\n", "// If we have a node then search its inodes.", "if", "n", "!=", "nil", "{", "index", ":=", "sort", ".", "Search", "(", "len", "(", "n", ".", "inodes", ")", ",", "func", "(", "i", "int", ")", "bool", "{", "return", "bytes", ".", "Compare", "(", "n", ".", "inodes", "[", "i", "]", ".", "key", ",", "key", ")", "!=", "-", "1", "\n", "}", ")", "\n", "e", ".", "index", "=", "index", "\n", "return", "\n", "}", "\n\n", "// If we have a page then search its leaf elements.", "inodes", ":=", "p", ".", "leafPageElements", "(", ")", "\n", "index", ":=", "sort", ".", "Search", "(", "int", "(", "p", ".", "count", ")", ",", "func", "(", "i", "int", ")", "bool", "{", "return", "bytes", ".", "Compare", "(", "inodes", "[", "i", "]", ".", "key", "(", ")", ",", "key", ")", "!=", "-", "1", "\n", "}", ")", "\n", "e", ".", "index", "=", "index", "\n", "}" ]

[ "nsearch", "searches", "the", "leaf", "node", "on", "the", "top", "of", "the", "stack", "for", "a", "key", "." ]

[ "func", "(", "c", "*", "Cursor", ")", "keyValue", "(", ")", "(", "[", "]", "byte", ",", "[", "]", "byte", ",", "uint32", ")", "{", "ref", ":=", "&", "c", ".", "stack", "[", "len", "(", "c", ".", "stack", ")", "-", "1", "]", "\n", "if", "ref", ".", "count", "(", ")", "==", "0", "||", "ref", ".", "index", ">=", "ref", ".", "count", "(", ")", "{", "return", "nil", ",", "nil", ",", "0", "\n", "}", "\n\n", "// Retrieve value from node.", "if", "ref", ".", "node", "!=", "nil", "{", "inode", ":=", "&", "ref", ".", "node", ".", "inodes", "[", "ref", ".", "index", "]", "\n", "return", "inode", ".", "key", ",", "inode", ".", "value", ",", "inode", ".", "flags", "\n", "}", "\n\n", "// Or retrieve value from page.", "elem", ":=", "ref", ".", "page", ".", "leafPageElement", "(", "uint16", "(", "ref", ".", "index", ")", ")", "\n", "return", "elem", ".", "key", "(", ")", ",", "elem", ".", "value", "(", ")", ",", "elem", ".", "flags", "\n", "}" ]

[ "keyValue", "returns", "the", "key", "and", "value", "of", "the", "current", "leaf", "element", "." ]

[ "func", "(", "c", "*", "Cursor", ")", "node", "(", ")", "*", "node", "{", "_assert", "(", "len", "(", "c", ".", "stack", ")", ">", "0", ",", "\"", "\"", ")", "\n\n", "// If the top of the stack is a leaf node then just return it.", "if", "ref", ":=", "&", "c", ".", "stack", "[", "len", "(", "c", ".", "stack", ")", "-", "1", "]", ";", "ref", ".", "node", "!=", "nil", "&&", "ref", ".", "isLeaf", "(", ")", "{", "return", "ref", ".", "node", "\n", "}", "\n\n", "// Start from root and traverse down the hierarchy.", "var", "n", "=", "c", ".", "stack", "[", "0", "]", ".", "node", "\n", "if", "n", "==", "nil", "{", "n", "=", "c", ".", "bucket", ".", "node", "(", "c", ".", "stack", "[", "0", "]", ".", "page", ".", "id", ",", "nil", ")", "\n", "}", "\n", "for", "_", ",", "ref", ":=", "range", "c", ".", "stack", "[", ":", "len", "(", "c", ".", "stack", ")", "-", "1", "]", "{", "_assert", "(", "!", "n", ".", "isLeaf", ",", "\"", "\"", ")", "\n", "n", "=", "n", ".", "childAt", "(", "int", "(", "ref", ".", "index", ")", ")", "\n", "}", "\n", "_assert", "(", "n", ".", "isLeaf", ",", "\"", "\"", ")", "\n", "return", "n", "\n", "}" ]

[ "node", "returns", "the", "node", "that", "the", "cursor", "is", "currently", "positioned", "on", "." ]

[ "func", "(", "r", "*", "elemRef", ")", "count", "(", ")", "int", "{", "if", "r", ".", "node", "!=", "nil", "{", "return", "len", "(", "r", ".", "node", ".", "inodes", ")", "\n", "}", "\n", "return", "int", "(", "r", ".", "page", ".", "count", ")", "\n", "}" ]

[ "count", "returns", "the", "number", "of", "inodes", "or", "page", "elements", "." ]

[ "func", "(", "p", "*", "page", ")", "leafPageElements", "(", ")", "[", "]", "leafPageElement", "{", "if", "p", ".", "count", "==", "0", "{", "return", "nil", "\n", "}", "\n", "return", "(", "(", "*", "[", "0x7FFFFFF", "]", "leafPageElement", ")", "(", "unsafe", ".", "Pointer", "(", "&", "p", ".", "ptr", ")", ")", ")", "[", ":", "]", "\n", "}" ]

[ "leafPageElements", "retrieves", "a", "list", "of", "leaf", "nodes", "." ]

[ "func", "(", "p", "*", "page", ")", "branchPageElements", "(", ")", "[", "]", "branchPageElement", "{", "if", "p", ".", "count", "==", "0", "{", "return", "nil", "\n", "}", "\n", "return", "(", "(", "*", "[", "0x7FFFFFF", "]", "branchPageElement", ")", "(", "unsafe", ".", "Pointer", "(", "&", "p", ".", "ptr", ")", ")", ")", "[", ":", "]", "\n", "}" ]

[ "branchPageElements", "retrieves", "a", "list", "of", "branch", "nodes", "." ]

[ "func", "(", "p", "*", "page", ")", "hexdump", "(", "n", "int", ")", "{", "buf", ":=", "(", "*", "[", "maxAllocSize", "]", "byte", ")", "(", "unsafe", ".", "Pointer", "(", "p", ")", ")", "[", ":", "n", "]", "\n", "fmt", ".", "Fprintf", "(", "os", ".", "Stderr", ",", "\"", "\\n", "\"", ",", "buf", ")", "\n", "}" ]

[ "dump", "writes", "n", "bytes", "of", "the", "page", "to", "STDERR", "as", "hex", "output", "." ]

[ "func", "(", "n", "*", "leafPageElement", ")", "value", "(", ")", "[", "]", "byte", "{", "buf", ":=", "(", "*", "[", "maxAllocSize", "]", "byte", ")", "(", "unsafe", ".", "Pointer", "(", "n", ")", ")", "\n", "return", "(", "*", "[", "maxAllocSize", "]", "byte", ")", "(", "unsafe", ".", "Pointer", "(", "&", "buf", "[", "n", ".", "pos", "+", "n", ".", "ksize", "]", ")", ")", "[", ":", "n", ".", "vsize", ":", "n", ".", "vsize", "]", "\n", "}" ]

[ "value", "returns", "a", "byte", "slice", "of", "the", "node", "value", "." ]

[ "func", "(", "a", "pgids", ")", "merge", "(", "b", "pgids", ")", "pgids", "{", "// Return the opposite slice if one is nil.", "if", "len", "(", "a", ")", "==", "0", "{", "return", "b", "\n", "}", "\n", "if", "len", "(", "b", ")", "==", "0", "{", "return", "a", "\n", "}", "\n", "merged", ":=", "make", "(", "pgids", ",", "len", "(", "a", ")", "+", "len", "(", "b", ")", ")", "\n", "mergepgids", "(", "merged", ",", "a", ",", "b", ")", "\n", "return", "merged", "\n", "}" ]

[ "merge", "returns", "the", "sorted", "union", "of", "a", "and", "b", "." ]

[ "func", "mergepgids", "(", "dst", ",", "a", ",", "b", "pgids", ")", "{", "if", "len", "(", "dst", ")", "<", "len", "(", "a", ")", "+", "len", "(", "b", ")", "{", "panic", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "len", "(", "dst", ")", ",", "len", "(", "a", ")", ",", "len", "(", "b", ")", ")", ")", "\n", "}", "\n", "// Copy in the opposite slice if one is nil.", "if", "len", "(", "a", ")", "==", "0", "{", "copy", "(", "dst", ",", "b", ")", "\n", "return", "\n", "}", "\n", "if", "len", "(", "b", ")", "==", "0", "{", "copy", "(", "dst", ",", "a", ")", "\n", "return", "\n", "}", "\n\n", "// Merged will hold all elements from both lists.", "merged", ":=", "dst", "[", ":", "0", "]", "\n\n", "// Assign lead to the slice with a lower starting value, follow to the higher value.", "lead", ",", "follow", ":=", "a", ",", "b", "\n", "if", "b", "[", "0", "]", "<", "a", "[", "0", "]", "{", "lead", ",", "follow", "=", "b", ",", "a", "\n", "}", "\n\n", "// Continue while there are elements in the lead.", "for", "len", "(", "lead", ")", ">", "0", "{", "// Merge largest prefix of lead that is ahead of follow[0].", "n", ":=", "sort", ".", "Search", "(", "len", "(", "lead", ")", ",", "func", "(", "i", "int", ")", "bool", "{", "return", "lead", "[", "i", "]", ">", "follow", "[", "0", "]", "}", ")", "\n", "merged", "=", "append", "(", "merged", ",", "lead", "[", ":", "n", "]", "...", ")", "\n", "if", "n", ">=", "len", "(", "lead", ")", "{", "break", "\n", "}", "\n\n", "// Swap lead and follow.", "lead", ",", "follow", "=", "follow", ",", "lead", "[", "n", ":", "]", "\n", "}", "\n\n", "// Append what's left in follow.", "_", "=", "append", "(", "merged", ",", "follow", "...", ")", "\n", "}" ]

[ "mergepgids", "copies", "the", "sorted", "union", "of", "a", "and", "b", "into", "dst", ".", "If", "dst", "is", "too", "small", "it", "panics", "." ]

[ "func", "PrintGoRushVersion", "(", ")", "{", "fmt", ".", "Printf", "(", "`GoRush %s, Compiler: %s %s, Copyright (C) 2019 Bo-Yi Wu, Inc.`", ",", "version", ",", "runtime", ".", "Compiler", ",", "runtime", ".", "Version", "(", ")", ")", "\n", "fmt", ".", "Println", "(", ")", "\n", "}" ]

[ "PrintGoRushVersion", "provide", "print", "server", "engine" ]

[ "func", "InitFCMClient", "(", "key", "string", ")", "(", "*", "fcm", ".", "Client", ",", "error", ")", "{", "var", "err", "error", "\n\n", "if", "key", "==", "\"", "\"", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "key", "!=", "PushConf", ".", "Android", ".", "APIKey", "{", "return", "fcm", ".", "NewClient", "(", "key", ")", "\n", "}", "\n\n", "if", "FCMClient", "==", "nil", "{", "FCMClient", ",", "err", "=", "fcm", ".", "NewClient", "(", "key", ")", "\n", "return", "FCMClient", ",", "err", "\n", "}", "\n\n", "return", "FCMClient", ",", "nil", "\n", "}" ]

[ "InitFCMClient", "use", "for", "initialize", "FCM", "Client", "." ]

[ "func", "pinger", "(", ")", "error", "{", "resp", ",", "err", ":=", "http", ".", "Get", "(", "\"", "\"", "+", "gorush", ".", "PushConf", ".", "Core", ".", "Port", "+", "gorush", ".", "PushConf", ".", "API", ".", "HealthURI", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "resp", ".", "Body", ".", "Close", "(", ")", "\n", "if", "resp", ".", "StatusCode", "!=", "200", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "handles", "pinging", "the", "endpoint", "and", "returns", "an", "error", "if", "the", "agent", "is", "in", "an", "unhealthy", "state", "." ]

[ "func", "(", "s", "*", "Server", ")", "Send", "(", "ctx", "context", ".", "Context", ",", "in", "*", "proto", ".", "NotificationRequest", ")", "(", "*", "proto", ".", "NotificationReply", ",", "error", ")", "{", "var", "badge", "=", "int", "(", "in", ".", "Badge", ")", "\n", "notification", ":=", "gorush", ".", "PushNotification", "{", "Platform", ":", "int", "(", "in", ".", "Platform", ")", ",", "Tokens", ":", "in", ".", "Tokens", ",", "Message", ":", "in", ".", "Message", ",", "Title", ":", "in", ".", "Title", ",", "Topic", ":", "in", ".", "Topic", ",", "APIKey", ":", "in", ".", "Key", ",", "Category", ":", "in", ".", "Category", ",", "Sound", ":", "in", ".", "Sound", ",", "ContentAvailable", ":", "in", ".", "ContentAvailable", ",", "ThreadID", ":", "in", ".", "ThreadID", ",", "MutableContent", ":", "in", ".", "MutableContent", ",", "}", "\n\n", "if", "badge", ">", "0", "{", "notification", ".", "Badge", "=", "&", "badge", "\n", "}", "\n\n", "if", "in", ".", "Alert", "!=", "nil", "{", "notification", ".", "Alert", "=", "gorush", ".", "Alert", "{", "Title", ":", "in", ".", "Alert", ".", "Title", ",", "Body", ":", "in", ".", "Alert", ".", "Body", ",", "Subtitle", ":", "in", ".", "Alert", ".", "Subtitle", ",", "Action", ":", "in", ".", "Alert", ".", "Action", ",", "ActionLocKey", ":", "in", ".", "Alert", ".", "Action", ",", "LaunchImage", ":", "in", ".", "Alert", ".", "LaunchImage", ",", "LocArgs", ":", "in", ".", "Alert", ".", "LocArgs", ",", "LocKey", ":", "in", ".", "Alert", ".", "LocKey", ",", "TitleLocArgs", ":", "in", ".", "Alert", ".", "TitleLocArgs", ",", "TitleLocKey", ":", "in", ".", "Alert", ".", "TitleLocKey", ",", "}", "\n", "}", "\n\n", "go", "gorush", ".", "SendNotification", "(", "notification", ")", "\n\n", "return", "&", "proto", ".", "NotificationReply", "{", "Success", ":", "true", ",", "Counts", ":", "int32", "(", "len", "(", "notification", ".", "Tokens", ")", ")", ",", "}", ",", "nil", "\n", "}" ]

[ "Send", "implements", "helloworld", ".", "GreeterServer" ]

[ "func", "RunGRPCServer", "(", ")", "error", "{", "if", "!", "gorush", ".", "PushConf", ".", "GRPC", ".", "Enabled", "{", "gorush", ".", "LogAccess", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "nil", "\n", "}", "\n\n", "lis", ",", "err", ":=", "net", ".", "Listen", "(", "\"", "\"", ",", "\"", "\"", "+", "gorush", ".", "PushConf", ".", "GRPC", ".", "Port", ")", "\n", "if", "err", "!=", "nil", "{", "gorush", ".", "LogError", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n", "s", ":=", "grpc", ".", "NewServer", "(", ")", "\n", "srv", ":=", "NewServer", "(", ")", "\n", "proto", ".", "RegisterGorushServer", "(", "s", ",", "srv", ")", "\n", "proto", ".", "RegisterHealthServer", "(", "s", ",", "srv", ")", "\n", "// Register reflection service on gRPC server.", "reflection", ".", "Register", "(", "s", ")", "\n", "gorush", ".", "LogAccess", ".", "Debug", "(", "\"", "\"", "+", "gorush", ".", "PushConf", ".", "GRPC", ".", "Port", "+", "\"", "\"", ")", "\n", "if", "err", ":=", "s", ".", "Serve", "(", "lis", ")", ";", "err", "!=", "nil", "{", "gorush", ".", "LogError", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "RunGRPCServer", "run", "gorush", "grpc", "server" ]

[ "func", "InitAPNSClient", "(", ")", "error", "{", "if", "PushConf", ".", "Ios", ".", "Enabled", "{", "var", "err", "error", "\n", "var", "authKey", "*", "ecdsa", ".", "PrivateKey", "\n", "var", "certificateKey", "tls", ".", "Certificate", "\n", "var", "ext", "string", "\n\n", "if", "PushConf", ".", "Ios", ".", "KeyPath", "!=", "\"", "\"", "{", "ext", "=", "filepath", ".", "Ext", "(", "PushConf", ".", "Ios", ".", "KeyPath", ")", "\n\n", "switch", "ext", "{", "case", "\"", "\"", ":", "certificateKey", ",", "err", "=", "certificate", ".", "FromP12File", "(", "PushConf", ".", "Ios", ".", "KeyPath", ",", "PushConf", ".", "Ios", ".", "Password", ")", "\n", "case", "\"", "\"", ":", "certificateKey", ",", "err", "=", "certificate", ".", "FromPemFile", "(", "PushConf", ".", "Ios", ".", "KeyPath", ",", "PushConf", ".", "Ios", ".", "Password", ")", "\n", "case", "\"", "\"", ":", "authKey", ",", "err", "=", "token", ".", "AuthKeyFromFile", "(", "PushConf", ".", "Ios", ".", "KeyPath", ")", "\n", "default", ":", "err", "=", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "err", "!=", "nil", "{", "LogError", ".", "Error", "(", "\"", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n\n", "return", "err", "\n", "}", "\n", "}", "else", "if", "PushConf", ".", "Ios", ".", "KeyBase64", "!=", "\"", "\"", "{", "ext", "=", "\"", "\"", "+", "PushConf", ".", "Ios", ".", "KeyType", "\n", "key", ",", "err", ":=", "base64", ".", "StdEncoding", ".", "DecodeString", "(", "PushConf", ".", "Ios", ".", "KeyBase64", ")", "\n", "if", "err", "!=", "nil", "{", "LogError", ".", "Error", "(", "\"", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n\n", "return", "err", "\n", "}", "\n", "switch", "ext", "{", "case", "\"", "\"", ":", "certificateKey", ",", "err", "=", "certificate", ".", "FromP12Bytes", "(", "key", ",", "PushConf", ".", "Ios", ".", "Password", ")", "\n", "case", "\"", "\"", ":", "certificateKey", ",", "err", "=", "certificate", ".", "FromPemBytes", "(", "key", ",", "PushConf", ".", "Ios", ".", "Password", ")", "\n", "case", "\"", "\"", ":", "authKey", ",", "err", "=", "token", ".", "AuthKeyFromBytes", "(", "key", ")", "\n", "default", ":", "err", "=", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "err", "!=", "nil", "{", "LogError", ".", "Error", "(", "\"", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n\n", "return", "err", "\n", "}", "\n", "}", "\n\n", "if", "ext", "==", "\"", "\"", "&&", "PushConf", ".", "Ios", ".", "KeyID", "!=", "\"", "\"", "&&", "PushConf", ".", "Ios", ".", "TeamID", "!=", "\"", "\"", "{", "token", ":=", "&", "token", ".", "Token", "{", "AuthKey", ":", "authKey", ",", "// KeyID from developer account (Certificates, Identifiers & Profiles -> Keys)", "KeyID", ":", "PushConf", ".", "Ios", ".", "KeyID", ",", "// TeamID from developer account (View Account -> Membership)", "TeamID", ":", "PushConf", ".", "Ios", ".", "TeamID", ",", "}", "\n", "if", "PushConf", ".", "Ios", ".", "Production", "{", "ApnsClient", "=", "apns2", ".", "NewTokenClient", "(", "token", ")", ".", "Production", "(", ")", "\n", "}", "else", "{", "ApnsClient", "=", "apns2", ".", "NewTokenClient", "(", "token", ")", ".", "Development", "(", ")", "\n", "}", "\n", "}", "else", "{", "if", "PushConf", ".", "Ios", ".", "Production", "{", "ApnsClient", "=", "apns2", ".", "NewClient", "(", "certificateKey", ")", ".", "Production", "(", ")", "\n", "}", "else", "{", "ApnsClient", "=", "apns2", ".", "NewClient", "(", "certificateKey", ")", ".", "Development", "(", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "InitAPNSClient", "use", "for", "initialize", "APNs", "Client", "." ]

[ "func", "PushToIOS", "(", "req", "PushNotification", ")", "bool", "{", "LogAccess", ".", "Debug", "(", "\"", "\"", ")", "\n", "if", "PushConf", ".", "Core", ".", "Sync", "{", "defer", "req", ".", "WaitDone", "(", ")", "\n", "}", "\n\n", "var", "(", "retryCount", "=", "0", "\n", "maxRetry", "=", "PushConf", ".", "Ios", ".", "MaxRetry", "\n", ")", "\n\n", "if", "req", ".", "Retry", ">", "0", "&&", "req", ".", "Retry", "<", "maxRetry", "{", "maxRetry", "=", "req", ".", "Retry", "\n", "}", "\n\n", "Retry", ":", "var", "(", "isError", "=", "false", "\n", "newTokens", "[", "]", "string", "\n", ")", "\n\n", "notification", ":=", "GetIOSNotification", "(", "req", ")", "\n", "client", ":=", "getApnsClient", "(", "req", ")", "\n\n", "for", "_", ",", "token", ":=", "range", "req", ".", "Tokens", "{", "notification", ".", "DeviceToken", "=", "token", "\n\n", "// send ios notification", "res", ",", "err", ":=", "client", ".", "Push", "(", "notification", ")", "\n\n", "if", "err", "!=", "nil", "{", "// apns server error", "LogPush", "(", "FailedPush", ",", "token", ",", "req", ",", "err", ")", "\n", "if", "PushConf", ".", "Core", ".", "Sync", "{", "req", ".", "AddLog", "(", "getLogPushEntry", "(", "FailedPush", ",", "token", ",", "req", ",", "err", ")", ")", "\n", "}", "\n", "StatStorage", ".", "AddIosError", "(", "1", ")", "\n", "newTokens", "=", "append", "(", "newTokens", ",", "token", ")", "\n", "isError", "=", "true", "\n", "continue", "\n", "}", "\n\n", "if", "res", ".", "StatusCode", "!=", "200", "{", "// error message:", "// ref: https://github.com/sideshow/apns2/blob/master/response.go#L14-L65", "LogPush", "(", "FailedPush", ",", "token", ",", "req", ",", "errors", ".", "New", "(", "res", ".", "Reason", ")", ")", "\n", "if", "PushConf", ".", "Core", ".", "Sync", "{", "req", ".", "AddLog", "(", "getLogPushEntry", "(", "FailedPush", ",", "token", ",", "req", ",", "errors", ".", "New", "(", "res", ".", "Reason", ")", ")", ")", "\n", "}", "\n", "StatStorage", ".", "AddIosError", "(", "1", ")", "\n", "newTokens", "=", "append", "(", "newTokens", ",", "token", ")", "\n", "isError", "=", "true", "\n", "continue", "\n", "}", "\n\n", "if", "res", ".", "Sent", "(", ")", "{", "LogPush", "(", "SucceededPush", ",", "token", ",", "req", ",", "nil", ")", "\n", "StatStorage", ".", "AddIosSuccess", "(", "1", ")", "\n", "}", "\n", "}", "\n\n", "if", "isError", "&&", "retryCount", "<", "maxRetry", "{", "retryCount", "++", "\n\n", "// resend fail token", "req", ".", "Tokens", "=", "newTokens", "\n", "goto", "Retry", "\n", "}", "\n\n", "return", "isError", "\n", "}" ]

[ "PushToIOS", "provide", "send", "notification", "to", "APNs", "server", "." ]

[ "func", "InitAppStatus", "(", ")", "error", "{", "LogAccess", ".", "Debug", "(", "\"", "\"", ",", "PushConf", ".", "Stat", ".", "Engine", ")", "\n", "switch", "PushConf", ".", "Stat", ".", "Engine", "{", "case", "\"", "\"", ":", "StatStorage", "=", "memory", ".", "New", "(", ")", "\n", "case", "\"", "\"", ":", "StatStorage", "=", "redis", ".", "New", "(", "PushConf", ")", "\n", "case", "\"", "\"", ":", "StatStorage", "=", "boltdb", ".", "New", "(", "PushConf", ")", "\n", "case", "\"", "\"", ":", "StatStorage", "=", "buntdb", ".", "New", "(", "PushConf", ")", "\n", "case", "\"", "\"", ":", "StatStorage", "=", "leveldb", ".", "New", "(", "PushConf", ")", "\n", "case", "\"", "\"", ":", "StatStorage", "=", "badger", ".", "New", "(", "PushConf", ")", "\n", "default", ":", "LogError", ".", "Error", "(", "\"", "\"", ")", "\n", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "err", ":=", "StatStorage", ".", "Init", "(", ")", ";", "err", "!=", "nil", "{", "LogError", ".", "Error", "(", "\"", "\"", "+", "err", ".", "Error", "(", ")", ")", "\n\n", "return", "err", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "InitAppStatus", "for", "initialize", "app", "status" ]

[ "func", "StatMiddleware", "(", ")", "gin", ".", "HandlerFunc", "{", "return", "func", "(", "c", "*", "gin", ".", "Context", ")", "{", "beginning", ",", "recorder", ":=", "Stats", ".", "Begin", "(", "c", ".", "Writer", ")", "\n", "c", ".", "Next", "(", ")", "\n", "Stats", ".", "End", "(", "beginning", ",", "stats", ".", "WithRecorder", "(", "recorder", ")", ")", "\n", "}", "\n", "}" ]

[ "StatMiddleware", "response", "time", "status", "code", "count", "etc", "." ]

[ "func", "NewGrpcHealthClient", "(", "conn", "*", "grpc", ".", "ClientConn", ")", "Health", "{", "client", ":=", "new", "(", "healthClient", ")", "\n", "client", ".", "client", "=", "proto", ".", "NewHealthClient", "(", "conn", ")", "\n", "client", ".", "conn", "=", "conn", "\n", "return", "client", "\n", "}" ]

[ "NewGrpcHealthClient", "returns", "a", "new", "grpc", "Client", "." ]

[ "func", "(", "p", "*", "PushNotification", ")", "AddLog", "(", "log", "LogPushEntry", ")", "{", "if", "p", ".", "log", "!=", "nil", "{", "*", "p", ".", "log", "=", "append", "(", "*", "p", ".", "log", ",", "log", ")", "\n", "}", "\n", "}" ]

[ "AddLog", "record", "fail", "log", "of", "notification" ]

[ "func", "CheckMessage", "(", "req", "PushNotification", ")", "error", "{", "var", "msg", "string", "\n\n", "// ignore send topic mesaage from FCM", "if", "!", "req", ".", "IsTopic", "(", ")", "&&", "len", "(", "req", ".", "Tokens", ")", "==", "0", "&&", "len", "(", "req", ".", "To", ")", "==", "0", "{", "msg", "=", "\"", "\"", "\n", "LogAccess", ".", "Debug", "(", "msg", ")", "\n", "return", "errors", ".", "New", "(", "msg", ")", "\n", "}", "\n\n", "if", "len", "(", "req", ".", "Tokens", ")", "==", "PlatFormIos", "&&", "len", "(", "req", ".", "Tokens", "[", "0", "]", ")", "==", "0", "{", "msg", "=", "\"", "\"", "\n", "LogAccess", ".", "Debug", "(", "msg", ")", "\n", "return", "errors", ".", "New", "(", "msg", ")", "\n", "}", "\n\n", "if", "req", ".", "Platform", "==", "PlatFormAndroid", "&&", "len", "(", "req", ".", "Tokens", ")", ">", "1000", "{", "msg", "=", "\"", "\"", "\n", "LogAccess", ".", "Debug", "(", "msg", ")", "\n", "return", "errors", ".", "New", "(", "msg", ")", "\n", "}", "\n\n", "// ref: https://firebase.google.com/docs/cloud-messaging/http-server-ref", "if", "req", ".", "Platform", "==", "PlatFormAndroid", "&&", "req", ".", "TimeToLive", "!=", "nil", "&&", "(", "*", "req", ".", "TimeToLive", "<", "uint", "(", "0", ")", "||", "uint", "(", "2419200", ")", "<", "*", "req", ".", "TimeToLive", ")", "{", "msg", "=", "\"", "\"", "+", "\"", "\"", "\n", "LogAccess", ".", "Debug", "(", "msg", ")", "\n", "return", "errors", ".", "New", "(", "msg", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "CheckMessage", "for", "check", "request", "message" ]

[ "func", "SetProxy", "(", "proxy", "string", ")", "error", "{", "proxyURL", ",", "err", ":=", "url", ".", "ParseRequestURI", "(", "proxy", ")", "\n\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "http", ".", "DefaultTransport", "=", "&", "http", ".", "Transport", "{", "Proxy", ":", "http", ".", "ProxyURL", "(", "proxyURL", ")", "}", "\n", "LogAccess", ".", "Debug", "(", "\"", "\"", "+", "proxy", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "SetProxy", "only", "working", "for", "FCM", "server", "." ]

[ "func", "CheckPushConf", "(", ")", "error", "{", "if", "!", "PushConf", ".", "Ios", ".", "Enabled", "&&", "!", "PushConf", ".", "Android", ".", "Enabled", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "PushConf", ".", "Ios", ".", "Enabled", "{", "if", "PushConf", ".", "Ios", ".", "KeyPath", "==", "\"", "\"", "&&", "PushConf", ".", "Ios", ".", "KeyBase64", "==", "\"", "\"", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// check certificate file exist", "if", "PushConf", ".", "Ios", ".", "KeyPath", "!=", "\"", "\"", "{", "if", "_", ",", "err", ":=", "os", ".", "Stat", "(", "PushConf", ".", "Ios", ".", "KeyPath", ")", ";", "os", ".", "IsNotExist", "(", "err", ")", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "if", "PushConf", ".", "Android", ".", "Enabled", "{", "if", "PushConf", ".", "Android", ".", "APIKey", "==", "\"", "\"", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "CheckPushConf", "provide", "check", "your", "yml", "config", "." ]

[ "func", "NewMetrics", "(", ")", "Metrics", "{", "return", "Metrics", "{", "TotalPushCount", ":", "prometheus", ".", "NewDesc", "(", "namespace", "+", "\"", "\"", ",", "\"", "\"", ",", "nil", ",", "nil", ",", ")", ",", "IosSuccess", ":", "prometheus", ".", "NewDesc", "(", "namespace", "+", "\"", "\"", ",", "\"", "\"", ",", "nil", ",", "nil", ",", ")", ",", "IosError", ":", "prometheus", ".", "NewDesc", "(", "namespace", "+", "\"", "\"", ",", "\"", "\"", ",", "nil", ",", "nil", ",", ")", ",", "AndroidSuccess", ":", "prometheus", ".", "NewDesc", "(", "namespace", "+", "\"", "\"", ",", "\"", "\"", ",", "nil", ",", "nil", ",", ")", ",", "AndroidError", ":", "prometheus", ".", "NewDesc", "(", "namespace", "+", "\"", "\"", ",", "\"", "\"", ",", "nil", ",", "nil", ",", ")", ",", "QueueUsage", ":", "prometheus", ".", "NewDesc", "(", "namespace", "+", "\"", "\"", ",", "\"", "\"", ",", "nil", ",", "nil", ",", ")", ",", "}", "\n", "}" ]

[ "NewMetrics", "returns", "a", "new", "Metrics", "with", "all", "prometheus", ".", "Desc", "initialized" ]

[ "func", "(", "c", "Metrics", ")", "Describe", "(", "ch", "chan", "<-", "*", "prometheus", ".", "Desc", ")", "{", "ch", "<-", "c", ".", "TotalPushCount", "\n", "ch", "<-", "c", ".", "IosSuccess", "\n", "ch", "<-", "c", ".", "IosError", "\n", "ch", "<-", "c", ".", "AndroidSuccess", "\n", "ch", "<-", "c", ".", "AndroidError", "\n", "ch", "<-", "c", ".", "QueueUsage", "\n", "}" ]

[ "Describe", "returns", "all", "possible", "prometheus", ".", "Desc" ]

[ "func", "(", "c", "Metrics", ")", "Collect", "(", "ch", "chan", "<-", "prometheus", ".", "Metric", ")", "{", "ch", "<-", "prometheus", ".", "MustNewConstMetric", "(", "c", ".", "TotalPushCount", ",", "prometheus", ".", "GaugeValue", ",", "float64", "(", "StatStorage", ".", "GetTotalCount", "(", ")", ")", ",", ")", "\n", "ch", "<-", "prometheus", ".", "MustNewConstMetric", "(", "c", ".", "IosSuccess", ",", "prometheus", ".", "GaugeValue", ",", "float64", "(", "StatStorage", ".", "GetIosSuccess", "(", ")", ")", ",", ")", "\n", "ch", "<-", "prometheus", ".", "MustNewConstMetric", "(", "c", ".", "IosError", ",", "prometheus", ".", "GaugeValue", ",", "float64", "(", "StatStorage", ".", "GetIosError", "(", ")", ")", ",", ")", "\n", "ch", "<-", "prometheus", ".", "MustNewConstMetric", "(", "c", ".", "AndroidSuccess", ",", "prometheus", ".", "GaugeValue", ",", "float64", "(", "StatStorage", ".", "GetAndroidSuccess", "(", ")", ")", ",", ")", "\n", "ch", "<-", "prometheus", ".", "MustNewConstMetric", "(", "c", ".", "AndroidError", ",", "prometheus", ".", "GaugeValue", ",", "float64", "(", "StatStorage", ".", "GetAndroidError", "(", ")", ")", ",", ")", "\n", "ch", "<-", "prometheus", ".", "MustNewConstMetric", "(", "c", ".", "QueueUsage", ",", "prometheus", ".", "GaugeValue", ",", "float64", "(", "len", "(", "QueueNotification", ")", ")", ",", ")", "\n", "}" ]

[ "Collect", "returns", "the", "metrics", "with", "values" ]

[ "func", "InitLog", "(", ")", "error", "{", "var", "err", "error", "\n\n", "// init logger", "LogAccess", "=", "logrus", ".", "New", "(", ")", "\n", "LogError", "=", "logrus", ".", "New", "(", ")", "\n\n", "LogAccess", ".", "Formatter", "=", "&", "logrus", ".", "TextFormatter", "{", "TimestampFormat", ":", "\"", "\"", ",", "FullTimestamp", ":", "true", ",", "}", "\n\n", "LogError", ".", "Formatter", "=", "&", "logrus", ".", "TextFormatter", "{", "TimestampFormat", ":", "\"", "\"", ",", "FullTimestamp", ":", "true", ",", "}", "\n\n", "// set logger", "if", "err", "=", "SetLogLevel", "(", "LogAccess", ",", "PushConf", ".", "Log", ".", "AccessLevel", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "New", "(", "\"", "\"", "+", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n\n", "if", "err", "=", "SetLogLevel", "(", "LogError", ",", "PushConf", ".", "Log", ".", "ErrorLevel", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "New", "(", "\"", "\"", "+", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n\n", "if", "err", "=", "SetLogOut", "(", "LogAccess", ",", "PushConf", ".", "Log", ".", "AccessLog", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "New", "(", "\"", "\"", "+", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n\n", "if", "err", "=", "SetLogOut", "(", "LogError", ",", "PushConf", ".", "Log", ".", "ErrorLog", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "New", "(", "\"", "\"", "+", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "InitLog", "use", "for", "initial", "log", "module" ]