Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "(", "h", "*", "Handler", ")", "close", "(", ")", "{", "h", ".", "once", ".", "Do", "(", "func", "(", ")", "{", "for", "_", ",", "fn", ":=", "range", "h", ".", "notify", "{", "fn", "(", ")", "\n", "}", "\n", "}", ")", "\n", "}" ]

[ "close", "calls", "the", "notify", "functions", "used", "when", "no", "signal", "was", "caught", "and", "the", "Run", "method", "returned", "." ]

[ "func", "(", "h", "*", "Handler", ")", "signal", "(", "s", "os", ".", "Signal", ")", "{", "h", ".", "once", ".", "Do", "(", "func", "(", ")", "{", "for", "_", ",", "fn", ":=", "range", "h", ".", "notify", "{", "fn", "(", ")", "\n", "}", "\n", "if", "h", ".", "final", "==", "nil", "{", "os", ".", "Exit", "(", "2", ")", "\n", "}", "\n", "h", ".", "final", "(", "s", ")", "\n", "}", ")", "\n", "}" ]

[ "signal", "calls", "the", "notify", "functions", "and", "final", "used", "when", "a", "signal", "was", "caught", "while", "the", "Run", "method", "was", "running", ".", "If", "final", "is", "nil", "os", ".", "Exit", "will", "be", "called", "as", "a", "default", "." ]

[ "func", "(", "n", "*", "Noop", ")", "Download", "(", "config", "*", "api", ".", "Config", ")", "(", "*", "git", ".", "SourceInfo", ",", "error", ")", "{", "glog", ".", "V", "(", "1", ")", ".", "Info", "(", "\"", "\"", ")", "\n\n", "return", "&", "git", ".", "SourceInfo", "{", "}", ",", "nil", "\n", "}" ]

[ "Download", "is", "a", "no", "-", "op", "downloader", "so", "that", "Noop", "satisfies", "build", ".", "Downloader" ]

[ "func", "(", "c", "*", "runner", ")", "RunWithOptions", "(", "opts", "CommandOpts", ",", "name", "string", ",", "arg", "...", "string", ")", "error", "{", "cmd", ":=", "exec", ".", "Command", "(", "name", ",", "arg", "...", ")", "\n", "if", "opts", ".", "Stdout", "!=", "nil", "{", "cmd", ".", "Stdout", "=", "opts", ".", "Stdout", "\n", "}", "\n", "if", "opts", ".", "Stderr", "!=", "nil", "{", "cmd", ".", "Stderr", "=", "opts", ".", "Stderr", "\n", "}", "\n", "if", "opts", ".", "Dir", "!=", "\"", "\"", "{", "cmd", ".", "Dir", "=", "opts", ".", "Dir", "\n", "}", "\n", "if", "len", "(", "opts", ".", "EnvAppend", ")", ">", "0", "{", "cmd", ".", "Env", "=", "os", ".", "Environ", "(", ")", "\n", "cmd", ".", "Env", "=", "append", "(", "cmd", ".", "Env", ",", "opts", ".", "EnvAppend", "...", ")", "\n", "}", "\n", "return", "cmd", ".", "Run", "(", ")", "\n", "}" ]

[ "RunWithOptions", "runs", "a", "command", "with", "the", "provided", "options" ]

[ "func", "(", "c", "*", "runner", ")", "Run", "(", "name", "string", ",", "arg", "...", "string", ")", "error", "{", "return", "c", ".", "RunWithOptions", "(", "CommandOpts", "{", "}", ",", "name", ",", "arg", "...", ")", "\n", "}" ]

[ "Run", "executes", "a", "command", "with", "default", "options" ]

[ "func", "(", "c", "*", "runner", ")", "StartWithStdoutPipe", "(", "opts", "CommandOpts", ",", "name", "string", ",", "arg", "...", "string", ")", "(", "io", ".", "ReadCloser", ",", "error", ")", "{", "c", ".", "cmd", "=", "exec", ".", "Command", "(", "name", ",", "arg", "...", ")", "\n", "if", "opts", ".", "Stderr", "!=", "nil", "{", "c", ".", "cmd", ".", "Stderr", "=", "opts", ".", "Stderr", "\n", "}", "\n", "if", "opts", ".", "Dir", "!=", "\"", "\"", "{", "c", ".", "cmd", ".", "Dir", "=", "opts", ".", "Dir", "\n", "}", "\n", "if", "len", "(", "opts", ".", "EnvAppend", ")", ">", "0", "{", "c", ".", "cmd", ".", "Env", "=", "os", ".", "Environ", "(", ")", "\n", "c", ".", "cmd", ".", "Env", "=", "append", "(", "c", ".", "cmd", ".", "Env", ",", "opts", ".", "EnvAppend", "...", ")", "\n", "}", "\n", "r", ",", "err", ":=", "c", ".", "cmd", ".", "StdoutPipe", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "r", ",", "c", ".", "cmd", ".", "Start", "(", ")", "\n", "}" ]

[ "StartWithStdoutPipe", "executes", "a", "command", "returning", "a", "ReadCloser", "connected", "to", "the", "command", "s", "stdout", "." ]

[ "func", "GenerateConfigFromLabels", "(", "config", "*", "api", ".", "Config", ",", "metadata", "*", "docker", ".", "PullResult", ")", "error", "{", "if", "config", "==", "nil", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "metadata", "==", "nil", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "labels", ":=", "metadata", ".", "Image", ".", "Config", ".", "Labels", "\n\n", "if", "builderVersion", ",", "ok", ":=", "labels", "[", "constants", ".", "BuilderVersionLabel", "]", ";", "ok", "{", "config", ".", "BuilderImageVersion", "=", "builderVersion", "\n", "config", ".", "BuilderBaseImageVersion", "=", "labels", "[", "constants", ".", "BuilderBaseVersionLabel", "]", "\n", "}", "\n\n", "config", ".", "ScriptsURL", "=", "labels", "[", "constants", ".", "ScriptsURLLabel", "]", "\n", "if", "len", "(", "config", ".", "ScriptsURL", ")", "==", "0", "{", "// FIXME: Backward compatibility", "config", ".", "ScriptsURL", "=", "labels", "[", "constants", ".", "DeprecatedScriptsURLLabel", "]", "\n", "}", "\n\n", "config", ".", "Description", "=", "labels", "[", "constants", ".", "KubernetesDescriptionLabel", "]", "\n", "config", ".", "DisplayName", "=", "labels", "[", "constants", ".", "KubernetesDisplayNameLabel", "]", "\n\n", "if", "builder", ",", "ok", ":=", "labels", "[", "constants", ".", "BuildImageLabel", "]", ";", "ok", "{", "config", ".", "BuilderImage", "=", "builder", "\n", "}", "else", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "constants", ".", "BuildImageLabel", ")", "\n", "}", "\n\n", "if", "repo", ",", "ok", ":=", "labels", "[", "constants", ".", "BuildSourceLocationLabel", "]", ";", "ok", "{", "source", ",", "err", ":=", "git", ".", "Parse", "(", "repo", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "constants", ".", "BuildSourceLocationLabel", ",", "repo", ",", "err", ")", "\n", "}", "\n", "config", ".", "Source", "=", "source", "\n", "}", "else", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "constants", ".", "BuildSourceLocationLabel", ")", "\n", "}", "\n\n", "config", ".", "ContextDir", "=", "labels", "[", "constants", ".", "BuildSourceContextDirLabel", "]", "\n", "config", ".", "Source", ".", "URL", ".", "Fragment", "=", "labels", "[", "constants", ".", "BuildCommitRefLabel", "]", "\n\n", "return", "nil", "\n", "}" ]

[ "GenerateConfigFromLabels", "generates", "the", "S2I", "Config", "struct", "from", "the", "Docker", "image", "labels", "." ]

[ "func", "ConvertEnvironmentList", "(", "env", "api", ".", "EnvironmentList", ")", "(", "result", "[", "]", "string", ")", "{", "for", "_", ",", "e", ":=", "range", "env", "{", "result", "=", "append", "(", "result", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "e", ".", "Name", ",", "e", ".", "Value", ")", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "ConvertEnvironmentList", "converts", "the", "EnvironmentList", "to", "key", "=", "val", "strings", "." ]

[ "func", "ConvertEnvironmentToDocker", "(", "env", "api", ".", "EnvironmentList", ")", "(", "result", "string", ")", "{", "for", "i", ",", "e", ":=", "range", "env", "{", "if", "i", "==", "0", "{", "result", "+=", "fmt", ".", "Sprintf", "(", "\"", "\\\"", "\\\"", "\"", ",", "e", ".", "Name", ",", "e", ".", "Value", ")", "\n", "}", "else", "{", "result", "+=", "fmt", ".", "Sprintf", "(", "\"", "\\\\", "\\n", "\\\"", "\\\"", "\"", ",", "e", ".", "Name", ",", "e", ".", "Value", ")", "\n", "}", "\n", "}", "\n", "result", "+=", "\"", "\\n", "\"", "\n", "return", "\n", "}" ]

[ "ConvertEnvironmentToDocker", "converts", "the", "EnvironmentList", "into", "Dockerfile", "format", "." ]

[ "func", "ValidateConfig", "(", "config", "*", "api", ".", "Config", ")", "[", "]", "Error", "{", "allErrs", ":=", "[", "]", "Error", "{", "}", "\n", "if", "len", "(", "config", ".", "BuilderImage", ")", "==", "0", "{", "allErrs", "=", "append", "(", "allErrs", ",", "NewFieldRequired", "(", "\"", "\"", ")", ")", "\n", "}", "\n", "switch", "config", ".", "BuilderPullPolicy", "{", "case", "api", ".", "PullNever", ",", "api", ".", "PullAlways", ",", "api", ".", "PullIfNotPresent", ":", "default", ":", "allErrs", "=", "append", "(", "allErrs", ",", "NewFieldInvalidValue", "(", "\"", "\"", ")", ")", "\n", "}", "\n", "if", "config", ".", "DockerConfig", "==", "nil", "||", "len", "(", "config", ".", "DockerConfig", ".", "Endpoint", ")", "==", "0", "{", "allErrs", "=", "append", "(", "allErrs", ",", "NewFieldRequired", "(", "\"", "\"", ")", ")", "\n", "}", "\n", "if", "config", ".", "DockerNetworkMode", "!=", "\"", "\"", "&&", "!", "validateDockerNetworkMode", "(", "config", ".", "DockerNetworkMode", ")", "{", "allErrs", "=", "append", "(", "allErrs", ",", "NewFieldInvalidValue", "(", "\"", "\"", ")", ")", "\n", "}", "\n", "if", "config", ".", "Labels", "!=", "nil", "{", "for", "k", ":=", "range", "config", ".", "Labels", "{", "if", "len", "(", "k", ")", "==", "0", "{", "allErrs", "=", "append", "(", "allErrs", ",", "NewFieldInvalidValue", "(", "\"", "\"", ")", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "if", "config", ".", "Tag", "!=", "\"", "\"", "{", "if", "err", ":=", "validateDockerReference", "(", "config", ".", "Tag", ")", ";", "err", "!=", "nil", "{", "allErrs", "=", "append", "(", "allErrs", ",", "NewFieldInvalidValueWithReason", "(", "\"", "\"", ",", "err", ".", "Error", "(", ")", ")", ")", "\n", "}", "\n", "}", "\n", "return", "allErrs", "\n", "}" ]

[ "ValidateConfig", "returns", "a", "list", "of", "error", "from", "validation", "." ]

[ "func", "NewFieldInvalidValueWithReason", "(", "field", ",", "reason", "string", ")", "Error", "{", "return", "Error", "{", "Type", ":", "ErrorInvalidValue", ",", "Field", ":", "field", ",", "Reason", ":", "reason", "}", "\n", "}" ]

[ "NewFieldInvalidValueWithReason", "returns", "a", "ValidationError", "indicating", "invalid", "value", "and", "a", "reason", "for", "the", "error" ]

[ "func", "NewCmdCompletion", "(", "root", "*", "cobra", ".", "Command", ")", "*", "cobra", ".", "Command", "{", "shells", ":=", "[", "]", "string", "{", "}", "\n", "for", "s", ":=", "range", "completionShells", "{", "shells", "=", "append", "(", "shells", ",", "s", ")", "\n", "}", "\n\n", "return", "&", "cobra", ".", "Command", "{", "Use", ":", "\"", "\"", ",", "Short", ":", "\"", "\"", ",", "Long", ":", "\"", "\"", ",", "Run", ":", "func", "(", "cmd", "*", "cobra", ".", "Command", ",", "args", "[", "]", "string", ")", "{", "// TODO: The version of cobra we vendor takes a", "// *bytes.Buffer, while newer versions take an", "// io.Writer. The code below could be simplified to a", "// single line `root.GenBashCompletion(os.Stdout)` when", "// we update cobra.", "var", "out", "bytes", ".", "Buffer", "\n", "err", ":=", "RunCompletion", "(", "&", "out", ",", "cmd", ",", "root", ",", "args", ")", "\n", "if", "err", "!=", "nil", "{", "s2ierr", ".", "CheckError", "(", "err", ")", "\n", "}", "else", "{", "fmt", ".", "Print", "(", "out", ".", "String", "(", ")", ")", "\n", "}", "\n", "}", ",", "ValidArgs", ":", "shells", ",", "}", "\n", "}" ]

[ "NewCmdCompletion", "implements", "the", "S2I", "cli", "completion", "command", "." ]

[ "func", "NewInspectImageError", "(", "name", "string", ",", "err", "error", ")", "error", "{", "return", "Error", "{", "Message", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "name", ")", ",", "Details", ":", "err", ",", "ErrorCode", ":", "InspectImageError", ",", "Suggestion", ":", "\"", "\"", ",", "}", "\n", "}" ]

[ "NewInspectImageError", "returns", "a", "new", "error", "which", "indicates", "there", "was", "a", "problem", "inspecting", "the", "image" ]

[ "func", "NewPullImageError", "(", "name", "string", ",", "err", "error", ")", "error", "{", "return", "Error", "{", "Message", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "name", ")", ",", "Details", ":", "err", ",", "ErrorCode", ":", "PullImageError", ",", "Suggestion", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "\"", "\"", ")", ",", "}", "\n", "}" ]

[ "NewPullImageError", "returns", "a", "new", "error", "which", "indicates", "there", "was", "a", "problem", "pulling", "the", "image" ]

[ "func", "NewSaveArtifactsError", "(", "name", ",", "output", "string", ",", "err", "error", ")", "error", "{", "return", "Error", "{", "Message", ":", "fmt", ".", "Sprintf", "(", "\"", "\\n", "\"", ",", "name", ",", "output", ")", ",", "Details", ":", "err", ",", "ErrorCode", ":", "SaveArtifactsError", ",", "Suggestion", ":", "\"", "\"", ",", "}", "\n", "}" ]

[ "NewSaveArtifactsError", "returns", "a", "new", "error", "which", "indicates", "there", "was", "a", "problem", "calling", "save", "-", "artifacts", "script" ]

[ "func", "NewAssembleError", "(", "name", ",", "output", "string", ",", "err", "error", ")", "error", "{", "return", "Error", "{", "Message", ":", "fmt", ".", "Sprintf", "(", "\"", "\\n", "\"", ",", "name", ",", "output", ")", ",", "Details", ":", "err", ",", "ErrorCode", ":", "AssembleError", ",", "Suggestion", ":", "\"", "\"", ",", "}", "\n", "}" ]

[ "NewAssembleError", "returns", "a", "new", "error", "which", "indicates", "there", "was", "a", "problem", "running", "assemble", "script" ]

[ "func", "NewWorkDirError", "(", "dir", "string", ",", "err", "error", ")", "error", "{", "return", "Error", "{", "Message", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "dir", ")", ",", "Details", ":", "err", ",", "ErrorCode", ":", "WorkdirError", ",", "Suggestion", ":", "\"", "\"", ",", "}", "\n", "}" ]

[ "NewWorkDirError", "returns", "a", "new", "error", "which", "indicates", "there", "was", "a", "problem", "when", "creating", "working", "directory" ]

[ "func", "NewBuildError", "(", "name", "string", ",", "err", "error", ")", "error", "{", "return", "Error", "{", "Message", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "name", ")", ",", "Details", ":", "err", ",", "ErrorCode", ":", "BuildError", ",", "Suggestion", ":", "\"", "\"", ",", "}", "\n", "}" ]

[ "NewBuildError", "returns", "a", "new", "error", "which", "indicates", "there", "was", "a", "problem", "building", "the", "image" ]

[ "func", "NewTarTimeoutError", "(", ")", "error", "{", "return", "Error", "{", "Message", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ")", ",", "Details", ":", "nil", ",", "ErrorCode", ":", "TarTimeoutError", ",", "Suggestion", ":", "\"", "\"", ",", "}", "\n", "}" ]

[ "NewTarTimeoutError", "returns", "a", "new", "error", "which", "indicates", "there", "was", "a", "problem", "when", "sending", "or", "receiving", "tar", "stream" ]

[ "func", "NewDownloadError", "(", "url", "string", ",", "code", "int", ")", "error", "{", "return", "Error", "{", "Message", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "url", ",", "code", ")", ",", "Details", ":", "nil", ",", "ErrorCode", ":", "DownloadError", ",", "Suggestion", ":", "\"", "\"", ",", "}", "\n", "}" ]

[ "NewDownloadError", "returns", "a", "new", "error", "which", "indicates", "there", "was", "a", "problem", "when", "downloading", "a", "file" ]

[ "func", "NewScriptsInsideImageError", "(", "url", "string", ")", "error", "{", "return", "Error", "{", "Message", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "url", ")", ",", "Details", ":", "nil", ",", "ErrorCode", ":", "ScriptsInsideImageError", ",", "Suggestion", ":", "\"", "\"", ",", "}", "\n", "}" ]

[ "NewScriptsInsideImageError", "returns", "a", "new", "error", "which", "informs", "of", "scripts", "being", "placed", "inside", "the", "image" ]

[ "func", "NewInstallError", "(", "script", "string", ")", "error", "{", "return", "Error", "{", "Message", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "script", ")", ",", "Details", ":", "nil", ",", "ErrorCode", ":", "InstallError", ",", "Suggestion", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "constants", ".", "ScriptsURLLabel", ")", ",", "}", "\n", "}" ]

[ "NewInstallError", "returns", "a", "new", "error", "which", "indicates", "there", "was", "a", "problem", "when", "downloading", "a", "script" ]

[ "func", "NewInstallRequiredError", "(", "scripts", "[", "]", "string", ",", "label", "string", ")", "error", "{", "return", "Error", "{", "Message", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "scripts", ")", ",", "Details", ":", "nil", ",", "ErrorCode", ":", "InstallErrorRequired", ",", "Suggestion", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "constants", ".", "ScriptsURLLabel", ")", ",", "}", "\n", "}" ]

[ "NewInstallRequiredError", "returns", "a", "new", "error", "which", "indicates", "there", "was", "a", "problem", "when", "downloading", "a", "required", "script" ]

[ "func", "NewURLHandlerError", "(", "url", "string", ")", "error", "{", "return", "Error", "{", "Message", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "url", ")", ",", "Details", ":", "nil", ",", "ErrorCode", ":", "URLHandlerError", ",", "Suggestion", ":", "\"", "\"", ",", "}", "\n", "}" ]

[ "NewURLHandlerError", "returns", "a", "new", "error", "which", "indicates", "there", "was", "a", "problem", "when", "trying", "to", "read", "scripts", "URL" ]

[ "func", "NewContainerError", "(", "name", "string", ",", "code", "int", ",", "output", "string", ")", "error", "{", "return", "ContainerError", "{", "Message", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "code", ",", "name", ")", ",", "Output", ":", "output", ",", "ErrorCode", ":", "STIContainerError", ",", "Suggestion", ":", "\"", "\"", ",", "ExitCode", ":", "code", ",", "}", "\n", "}" ]

[ "NewContainerError", "return", "a", "new", "error", "which", "indicates", "there", "was", "a", "problem", "invoking", "command", "inside", "container" ]

[ "func", "NewSourcePathError", "(", "path", "string", ")", "error", "{", "return", "Error", "{", "Message", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "path", ")", ",", "Details", ":", "nil", ",", "ErrorCode", ":", "SourcePathError", ",", "Suggestion", ":", "\"", "\"", ",", "}", "\n", "}" ]

[ "NewSourcePathError", "returns", "a", "new", "error", "which", "indicates", "there", "was", "a", "problem", "when", "accessing", "the", "source", "code", "from", "the", "local", "filesystem" ]

[ "func", "NewUserNotAllowedError", "(", "image", "string", ",", "onbuild", "bool", ")", "error", "{", "var", "msg", "string", "\n", "if", "onbuild", "{", "msg", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "image", ")", "\n", "}", "else", "{", "msg", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "image", ")", "\n", "}", "\n", "return", "Error", "{", "Message", ":", "msg", ",", "ErrorCode", ":", "UserNotAllowedError", ",", "Suggestion", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "image", ")", ",", "}", "\n", "}" ]

[ "NewUserNotAllowedError", "returns", "a", "new", "error", "that", "indicates", "that", "the", "build", "could", "not", "run", "because", "the", "image", "uses", "a", "user", "outside", "of", "the", "range", "of", "allowed", "users" ]

[ "func", "NewAssembleUserNotAllowedError", "(", "image", "string", ",", "usesConfig", "bool", ")", "error", "{", "var", "msg", ",", "suggestion", "string", "\n", "if", "usesConfig", "{", "msg", "=", "\"", "\"", "\n", "suggestion", "=", "\"", "\"", "\n", "}", "else", "{", "msg", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "image", ",", "constants", ".", "AssembleUserLabel", ")", "\n", "suggestion", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "constants", ".", "AssembleUserLabel", ",", "image", ")", "\n", "}", "\n", "return", "Error", "{", "Message", ":", "msg", ",", "ErrorCode", ":", "UserNotAllowedError", ",", "Suggestion", ":", "suggestion", ",", "}", "\n", "}" ]

[ "NewAssembleUserNotAllowedError", "returns", "a", "new", "error", "that", "indicates", "that", "the", "build", "could", "not", "run", "because", "the", "build", "or", "image", "uses", "an", "assemble", "user", "outside", "of", "the", "range", "of", "allowed", "users", "." ]

[ "func", "CheckError", "(", "err", "error", ")", "{", "if", "err", "==", "nil", "{", "return", "\n", "}", "\n\n", "if", "e", ",", "ok", ":=", "err", ".", "(", "Error", ")", ";", "ok", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "e", ")", "\n", "glog", ".", "Errorf", "(", "\"", "\"", ",", "e", ".", "Suggestion", ")", "\n", "if", "e", ".", "Details", "!=", "nil", "{", "glog", ".", "V", "(", "1", ")", ".", "Infof", "(", "\"", "\"", ",", "e", ".", "Details", ")", "\n", "}", "\n", "glog", ".", "Error", "(", "\"", "\"", "+", "\"", "\"", "+", "\"", "\"", ")", "\n", "os", ".", "Exit", "(", "e", ".", "ErrorCode", ")", "\n", "}", "else", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "os", ".", "Exit", "(", "1", ")", "\n", "}", "\n", "}" ]

[ "CheckError", "checks", "input", "error", ".", "1", ".", "if", "the", "input", "error", "is", "nil", "the", "function", "does", "nothing", "but", "return", ".", "2", ".", "if", "the", "input", "error", "is", "a", "kind", "of", "Error", "which", "is", "thrown", "during", "S2I", "execution", "the", "function", "handle", "it", "with", "Suggestion", "and", "Details", ".", "3", ".", "if", "the", "input", "error", "is", "a", "kind", "of", "system", "Error", "which", "is", "unknown", "the", "function", "exit", "with", "1", "." ]

[ "func", "(", "info", "Info", ")", "String", "(", ")", "string", "{", "version", ":=", "info", ".", "GitVersion", "\n", "if", "version", "==", "\"", "\"", "{", "version", "=", "\"", "\"", "\n", "}", "\n", "return", "version", "\n", "}" ]

[ "String", "returns", "info", "as", "a", "human", "-", "friendly", "version", "string", "." ]

[ "func", "NewDownloader", "(", "proxyConfig", "*", "api", ".", "ProxyConfig", ")", "Downloader", "{", "httpReader", ":=", "NewHTTPURLReader", "(", "proxyConfig", ")", "\n", "return", "&", "downloader", "{", "schemeReaders", ":", "map", "[", "string", "]", "schemeReader", "{", "\"", "\"", ":", "httpReader", ",", "\"", "\"", ":", "httpReader", ",", "\"", "\"", ":", "&", "FileURLReader", "{", "}", ",", "\"", "\"", ":", "&", "ImageReader", "{", "}", ",", "}", ",", "}", "\n", "}" ]

[ "NewDownloader", "creates", "an", "instance", "of", "the", "default", "Downloader", "implementation" ]

[ "func", "NewHTTPURLReader", "(", "proxyConfig", "*", "api", ".", "ProxyConfig", ")", "*", "HTTPURLReader", "{", "getFunc", ":=", "http", ".", "Get", "\n", "if", "proxyConfig", "!=", "nil", "{", "transportMapMutex", ".", "Lock", "(", ")", "\n", "transport", ",", "ok", ":=", "transportMap", "[", "*", "proxyConfig", "]", "\n", "if", "!", "ok", "{", "transport", "=", "&", "http", ".", "Transport", "{", "Proxy", ":", "func", "(", "req", "*", "http", ".", "Request", ")", "(", "*", "url", ".", "URL", ",", "error", ")", "{", "if", "proxyConfig", ".", "HTTPSProxy", "!=", "nil", "&&", "req", ".", "URL", ".", "Scheme", "==", "\"", "\"", "{", "return", "proxyConfig", ".", "HTTPSProxy", ",", "nil", "\n", "}", "\n", "return", "proxyConfig", ".", "HTTPProxy", ",", "nil", "\n", "}", ",", "}", "\n", "transportMap", "[", "*", "proxyConfig", "]", "=", "transport", "\n", "}", "\n", "transportMapMutex", ".", "Unlock", "(", ")", "\n", "client", ":=", "&", "http", ".", "Client", "{", "Transport", ":", "transport", ",", "}", "\n", "getFunc", "=", "client", ".", "Get", "\n", "}", "\n", "return", "&", "HTTPURLReader", "{", "Get", ":", "getFunc", "}", "\n", "}" ]

[ "NewHTTPURLReader", "returns", "a", "new", "HTTPURLReader", "." ]

[ "func", "(", "*", "FileURLReader", ")", "Read", "(", "url", "*", "url", ".", "URL", ")", "(", "io", ".", "ReadCloser", ",", "error", ")", "{", "// for some reason url.Host may contain information about the ./ or ../ when", "// specifying relative path, thus using that value as well", "return", "os", ".", "Open", "(", "filepath", ".", "Join", "(", "url", ".", "Host", ",", "url", ".", "Path", ")", ")", "\n", "}" ]

[ "Read", "produces", "an", "io", ".", "Reader", "from", "a", "file", "URL" ]

[ "func", "(", "*", "ImageReader", ")", "Read", "(", "url", "*", "url", ".", "URL", ")", "(", "io", ".", "ReadCloser", ",", "error", ")", "{", "return", "nil", ",", "s2ierr", ".", "NewScriptsInsideImageError", "(", "url", ".", "String", "(", ")", ")", "\n", "}" ]

[ "Read", "throws", "Not", "implemented", "error" ]

[ "func", "New", "(", "config", "*", "api", ".", "Config", ",", "fs", "fs", ".", "FileSystem", ")", "(", "*", "Dockerfile", ",", "error", ")", "{", "return", "&", "Dockerfile", "{", "fs", ":", "fs", ",", "// where we will get the assemble/run scripts from on the host machine,", "// if any are provided.", "uploadScriptsDir", ":", "constants", ".", "UploadScripts", ",", "uploadSrcDir", ":", "constants", ".", "Source", ",", "result", ":", "&", "api", ".", "Result", "{", "}", ",", "ignorer", ":", "&", "ignore", ".", "DockerIgnorer", "{", "}", ",", "}", ",", "nil", "\n", "}" ]

[ "New", "creates", "a", "Dockerfile", "builder", "." ]

[ "func", "(", "builder", "*", "Dockerfile", ")", "Build", "(", "config", "*", "api", ".", "Config", ")", "(", "*", "api", ".", "Result", ",", "error", ")", "{", "// Handle defaulting of the configuration that is unique to the dockerfile strategy", "if", "strings", ".", "HasSuffix", "(", "config", ".", "AsDockerfile", ",", "string", "(", "os", ".", "PathSeparator", ")", ")", "{", "config", ".", "AsDockerfile", "=", "config", ".", "AsDockerfile", "+", "\"", "\"", "\n", "}", "\n", "if", "len", "(", "config", ".", "AssembleUser", ")", "==", "0", "{", "config", ".", "AssembleUser", "=", "\"", "\"", "\n", "}", "\n", "if", "!", "user", ".", "IsUserAllowed", "(", "config", ".", "AssembleUser", ",", "&", "config", ".", "AllowedUIDs", ")", "{", "builder", ".", "setFailureReason", "(", "utilstatus", ".", "ReasonAssembleUserForbidden", ",", "utilstatus", ".", "ReasonMessageAssembleUserForbidden", ")", "\n", "return", "builder", ".", "result", ",", "s2ierr", ".", "NewUserNotAllowedError", "(", "config", ".", "AssembleUser", ",", "false", ")", "\n", "}", "\n\n", "dir", ",", "_", ":=", "filepath", ".", "Split", "(", "config", ".", "AsDockerfile", ")", "\n", "if", "len", "(", "dir", ")", "==", "0", "{", "dir", "=", "\"", "\"", "\n", "}", "\n", "config", ".", "PreserveWorkingDir", "=", "true", "\n", "config", ".", "WorkingDir", "=", "dir", "\n\n", "if", "config", ".", "BuilderImage", "==", "\"", "\"", "{", "builder", ".", "setFailureReason", "(", "utilstatus", ".", "ReasonGenericS2IBuildFailed", ",", "utilstatus", ".", "ReasonMessageGenericS2iBuildFailed", ")", "\n", "return", "builder", ".", "result", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "err", ":=", "builder", ".", "Prepare", "(", "config", ")", ";", "err", "!=", "nil", "{", "return", "builder", ".", "result", ",", "err", "\n", "}", "\n\n", "if", "err", ":=", "builder", ".", "CreateDockerfile", "(", "config", ")", ";", "err", "!=", "nil", "{", "builder", ".", "setFailureReason", "(", "utilstatus", ".", "ReasonDockerfileCreateFailed", ",", "utilstatus", ".", "ReasonMessageDockerfileCreateFailed", ")", "\n", "return", "builder", ".", "result", ",", "err", "\n", "}", "\n\n", "builder", ".", "result", ".", "Success", "=", "true", "\n\n", "return", "builder", ".", "result", ",", "nil", "\n", "}" ]

[ "Build", "produces", "a", "Dockerfile", "that", "when", "run", "with", "the", "correct", "filesystem", "context", "will", "produce", "the", "application", "image", "." ]

[ "func", "(", "builder", "*", "Dockerfile", ")", "installScripts", "(", "scriptsURL", "string", ",", "config", "*", "api", ".", "Config", ")", "[", "]", "api", ".", "InstallResult", "{", "scriptInstaller", ":=", "scripts", ".", "NewInstaller", "(", "\"", "\"", ",", "scriptsURL", ",", "config", ".", "ScriptDownloadProxyConfig", ",", "nil", ",", "api", ".", "AuthConfig", "{", "}", ",", "builder", ".", "fs", ",", ")", "\n\n", "// all scripts are optional, we trust the image contains scripts if we don't find them", "// in the source repo.", "return", "scriptInstaller", ".", "InstallOptional", "(", "append", "(", "scripts", ".", "RequiredScripts", ",", "scripts", ".", "OptionalScripts", "...", ")", ",", "config", ".", "WorkingDir", ")", "\n", "}" ]

[ "installScripts", "installs", "scripts", "at", "the", "provided", "URL", "to", "the", "Dockerfile", "context" ]

[ "func", "(", "builder", "*", "Dockerfile", ")", "setFailureReason", "(", "reason", "api", ".", "StepFailureReason", ",", "message", "api", ".", "StepFailureMessage", ")", "{", "builder", ".", "result", ".", "BuildInfo", ".", "FailureReason", "=", "utilstatus", ".", "NewFailureReason", "(", "reason", ",", "message", ")", "\n", "}" ]

[ "setFailureReason", "sets", "the", "builder", "s", "failure", "reason", "with", "the", "given", "reason", "and", "message", "." ]

[ "func", "getImageScriptsDir", "(", "config", "*", "api", ".", "Config", ")", "(", "string", ",", "bool", ")", "{", "if", "strings", ".", "HasPrefix", "(", "config", ".", "ScriptsURL", ",", "\"", "\"", ")", "{", "return", "strings", ".", "TrimPrefix", "(", "config", ".", "ScriptsURL", ",", "\"", "\"", ")", ",", "true", "\n", "}", "\n", "if", "strings", ".", "HasPrefix", "(", "config", ".", "ImageScriptsURL", ",", "\"", "\"", ")", "{", "return", "strings", ".", "TrimPrefix", "(", "config", ".", "ImageScriptsURL", ",", "\"", "\"", ")", ",", "false", "\n", "}", "\n", "return", "defaultScriptsDir", ",", "false", "\n", "}" ]

[ "getImageScriptsDir", "returns", "the", "directory", "containing", "the", "builder", "image", "scripts", "and", "a", "bool", "indicating", "that", "the", "directory", "is", "expected", "to", "contain", "all", "s2i", "scripts" ]

[ "func", "scanScripts", "(", "name", "string", ")", "map", "[", "string", "]", "bool", "{", "scriptsMap", ":=", "make", "(", "map", "[", "string", "]", "bool", ")", "\n", "items", ",", "err", ":=", "ioutil", ".", "ReadDir", "(", "name", ")", "\n", "if", "os", ".", "IsNotExist", "(", "err", ")", "{", "glog", ".", "Warningf", "(", "\"", "\"", ",", "name", ",", "err", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "||", "len", "(", "items", ")", "==", "0", "{", "return", "scriptsMap", "\n", "}", "\n\n", "assembleProvided", ":=", "false", "\n", "runProvided", ":=", "false", "\n", "saveArtifactsProvided", ":=", "false", "\n", "for", "_", ",", "f", ":=", "range", "items", "{", "glog", ".", "V", "(", "2", ")", ".", "Infof", "(", "\"", "\"", ",", "f", ".", "Name", "(", ")", ")", "\n", "if", "f", ".", "Name", "(", ")", "==", "constants", ".", "Run", "{", "runProvided", "=", "true", "\n", "scriptsMap", "[", "constants", ".", "Run", "]", "=", "true", "\n", "}", "else", "if", "f", ".", "Name", "(", ")", "==", "constants", ".", "Assemble", "{", "assembleProvided", "=", "true", "\n", "scriptsMap", "[", "constants", ".", "Assemble", "]", "=", "true", "\n", "}", "else", "if", "f", ".", "Name", "(", ")", "==", "constants", ".", "SaveArtifacts", "{", "saveArtifactsProvided", "=", "true", "\n", "scriptsMap", "[", "constants", ".", "SaveArtifacts", "]", "=", "true", "\n", "}", "\n", "if", "runProvided", "&&", "assembleProvided", "&&", "saveArtifactsProvided", "{", "break", "\n", "}", "\n", "}", "\n", "return", "scriptsMap", "\n", "}" ]

[ "scanScripts", "returns", "a", "map", "of", "provided", "s2i", "scripts" ]

[ "func", "GenerateOutputImageLabels", "(", "info", "*", "git", ".", "SourceInfo", ",", "config", "*", "api", ".", "Config", ")", "map", "[", "string", "]", "string", "{", "labels", ":=", "map", "[", "string", "]", "string", "{", "}", "\n", "namespace", ":=", "constants", ".", "DefaultNamespace", "\n", "if", "len", "(", "config", ".", "LabelNamespace", ")", ">", "0", "{", "namespace", "=", "config", ".", "LabelNamespace", "\n", "}", "\n\n", "labels", "=", "GenerateLabelsFromConfig", "(", "labels", ",", "config", ",", "namespace", ")", "\n", "labels", "=", "GenerateLabelsFromSourceInfo", "(", "labels", ",", "info", ",", "namespace", ")", "\n", "return", "labels", "\n", "}" ]

[ "GenerateOutputImageLabels", "generate", "the", "labels", "based", "on", "the", "s2i", "Config", "and", "source", "repository", "informations", "." ]

[ "func", "GenerateLabelsFromConfig", "(", "labels", "map", "[", "string", "]", "string", ",", "config", "*", "api", ".", "Config", ",", "namespace", "string", ")", "map", "[", "string", "]", "string", "{", "if", "len", "(", "config", ".", "Description", ")", ">", "0", "{", "labels", "[", "constants", ".", "KubernetesDescriptionLabel", "]", "=", "config", ".", "Description", "\n", "}", "\n\n", "if", "len", "(", "config", ".", "DisplayName", ")", ">", "0", "{", "labels", "[", "constants", ".", "KubernetesDisplayNameLabel", "]", "=", "config", ".", "DisplayName", "\n", "}", "else", "if", "len", "(", "config", ".", "Tag", ")", ">", "0", "{", "labels", "[", "constants", ".", "KubernetesDisplayNameLabel", "]", "=", "config", ".", "Tag", "\n", "}", "\n\n", "addBuildLabel", "(", "labels", ",", "\"", "\"", ",", "config", ".", "BuilderImage", ",", "namespace", ")", "\n", "return", "labels", "\n", "}" ]

[ "GenerateLabelsFromConfig", "generate", "the", "labels", "based", "on", "build", "s2i", "Config" ]

[ "func", "GenerateLabelsFromSourceInfo", "(", "labels", "map", "[", "string", "]", "string", ",", "info", "*", "git", ".", "SourceInfo", ",", "namespace", "string", ")", "map", "[", "string", "]", "string", "{", "if", "info", "==", "nil", "{", "glog", ".", "V", "(", "3", ")", ".", "Info", "(", "\"", "\"", ")", "\n", "return", "labels", "\n", "}", "\n\n", "if", "len", "(", "info", ".", "AuthorName", ")", ">", "0", "{", "author", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "info", ".", "AuthorName", ",", "info", ".", "AuthorEmail", ")", "\n", "addBuildLabel", "(", "labels", ",", "\"", "\"", ",", "author", ",", "namespace", ")", "\n", "}", "\n\n", "addBuildLabel", "(", "labels", ",", "\"", "\"", ",", "info", ".", "Date", ",", "namespace", ")", "\n", "addBuildLabel", "(", "labels", ",", "\"", "\"", ",", "info", ".", "CommitID", ",", "namespace", ")", "\n", "addBuildLabel", "(", "labels", ",", "\"", "\"", ",", "info", ".", "Ref", ",", "namespace", ")", "\n", "addBuildLabel", "(", "labels", ",", "\"", "\"", ",", "info", ".", "Message", ",", "namespace", ")", "\n", "addBuildLabel", "(", "labels", ",", "\"", "\"", ",", "info", ".", "Location", ",", "namespace", ")", "\n", "addBuildLabel", "(", "labels", ",", "\"", "\"", ",", "info", ".", "ContextDir", ",", "namespace", ")", "\n", "return", "labels", "\n", "}" ]

[ "GenerateLabelsFromSourceInfo", "generate", "the", "labels", "based", "on", "the", "source", "repository", "informations", "." ]

[ "func", "(", "a", "ChmodAdapter", ")", "WriteHeader", "(", "hdr", "*", "tar", ".", "Header", ")", "error", "{", "if", "hdr", ".", "FileInfo", "(", ")", ".", "Mode", "(", ")", "&", "os", ".", "ModeSymlink", "==", "0", "{", "newMode", ":=", "hdr", ".", "Mode", "&^", "0777", "\n", "if", "hdr", ".", "FileInfo", "(", ")", ".", "IsDir", "(", ")", "{", "newMode", "|=", "a", ".", "NewDirMode", "\n", "}", "else", "if", "hdr", ".", "FileInfo", "(", ")", ".", "Mode", "(", ")", "&", "0010", "!=", "0", "{", "// S_IXUSR", "newMode", "|=", "a", ".", "NewExecFileMode", "\n", "}", "else", "{", "newMode", "|=", "a", ".", "NewFileMode", "\n", "}", "\n", "hdr", ".", "Mode", "=", "newMode", "\n", "}", "\n", "return", "a", ".", "Writer", ".", "WriteHeader", "(", "hdr", ")", "\n", "}" ]

[ "WriteHeader", "changes", "the", "mode", "of", "files", "and", "directories", "inline", "as", "a", "tarfile", "is", "being", "written" ]

[ "func", "(", "a", "RenameAdapter", ")", "WriteHeader", "(", "hdr", "*", "tar", ".", "Header", ")", "error", "{", "if", "hdr", ".", "Name", "==", "a", ".", "Old", "{", "hdr", ".", "Name", "=", "a", ".", "New", "\n", "}", "else", "if", "strings", ".", "HasPrefix", "(", "hdr", ".", "Name", ",", "a", ".", "Old", "+", "\"", "\"", ")", "{", "hdr", ".", "Name", "=", "a", ".", "New", "+", "hdr", ".", "Name", "[", "len", "(", "a", ".", "Old", ")", ":", "]", "\n", "}", "\n\n", "return", "a", ".", "Writer", ".", "WriteHeader", "(", "hdr", ")", "\n", "}" ]

[ "WriteHeader", "renames", "files", "and", "directories", "inline", "as", "a", "tarfile", "is", "being", "written" ]

[ "func", "New", "(", "fs", "fs", ".", "FileSystem", ")", "Tar", "{", "return", "&", "stiTar", "{", "FileSystem", ":", "fs", ",", "exclude", ":", "DefaultExclusionPattern", ",", "timeout", ":", "defaultTimeout", ",", "}", "\n", "}" ]

[ "New", "creates", "a", "new", "Tar" ]

[ "func", "NewWithTimeout", "(", "fs", "fs", ".", "FileSystem", ",", "timeout", "time", ".", "Duration", ")", "Tar", "{", "return", "&", "stiTar", "{", "FileSystem", ":", "fs", ",", "exclude", ":", "DefaultExclusionPattern", ",", "timeout", ":", "timeout", ",", "}", "\n", "}" ]

[ "NewWithTimeout", "creates", "a", "new", "Tar", "with", "the", "provided", "timeout", "extracting", "files", "." ]

[ "func", "NewParanoid", "(", "fs", "fs", ".", "FileSystem", ")", "Tar", "{", "return", "&", "stiTar", "{", "FileSystem", ":", "fs", ",", "exclude", ":", "DefaultExclusionPattern", ",", "timeout", ":", "defaultTimeout", ",", "disallowOverwrite", ":", "true", ",", "disallowOutsidePaths", ":", "true", ",", "disallowSpecialFiles", ":", "true", ",", "}", "\n", "}" ]

[ "NewParanoid", "creates", "a", "new", "Tar", "that", "has", "restrictions", "on", "what", "it", "can", "do", "while", "extracting", "files", "." ]

[ "func", "NewParanoidWithTimeout", "(", "fs", "fs", ".", "FileSystem", ",", "timeout", "time", ".", "Duration", ")", "Tar", "{", "return", "&", "stiTar", "{", "FileSystem", ":", "fs", ",", "exclude", ":", "DefaultExclusionPattern", ",", "timeout", ":", "timeout", ",", "disallowOverwrite", ":", "true", ",", "disallowOutsidePaths", ":", "true", ",", "disallowSpecialFiles", ":", "true", ",", "}", "\n", "}" ]

[ "NewParanoidWithTimeout", "creates", "a", "new", "Tar", "with", "the", "provided", "timeout", "extracting", "files", ".", "It", "has", "restrictions", "on", "what", "it", "can", "do", "while", "extracting", "files", "." ]

[ "func", "(", "t", "*", "stiTar", ")", "CreateTarFile", "(", "base", ",", "dir", "string", ")", "(", "string", ",", "error", ")", "{", "tarFile", ",", "err", ":=", "ioutil", ".", "TempFile", "(", "base", ",", "\"", "\"", ")", "\n", "defer", "tarFile", ".", "Close", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "if", "err", "=", "t", ".", "CreateTarStream", "(", "dir", ",", "false", ",", "tarFile", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "return", "tarFile", ".", "Name", "(", ")", ",", "nil", "\n", "}" ]

[ "CreateTarFile", "creates", "a", "tar", "file", "from", "the", "given", "directory", "while", "excluding", "files", "that", "match", "the", "given", "exclusion", "pattern", "It", "returns", "the", "name", "of", "the", "created", "file" ]

[ "func", "(", "t", "*", "stiTar", ")", "CreateTarStream", "(", "dir", "string", ",", "includeDirInPath", "bool", ",", "writer", "io", ".", "Writer", ")", "error", "{", "tarWriter", ":=", "tar", ".", "NewWriter", "(", "writer", ")", "\n", "defer", "tarWriter", ".", "Close", "(", ")", "\n\n", "return", "t", ".", "CreateTarStreamToTarWriter", "(", "dir", ",", "includeDirInPath", ",", "tarWriter", ",", "nil", ")", "\n", "}" ]

[ "CreateTarStream", "calls", "CreateTarStreamToTarWriter", "with", "a", "nil", "logger" ]

[ "func", "(", "t", "*", "stiTar", ")", "CreateTarStreamReader", "(", "dir", "string", ",", "includeDirInPath", "bool", ")", "io", ".", "ReadCloser", "{", "r", ",", "w", ":=", "io", ".", "Pipe", "(", ")", "\n", "go", "func", "(", ")", "{", "w", ".", "CloseWithError", "(", "t", ".", "CreateTarStream", "(", "dir", ",", "includeDirInPath", ",", "w", ")", ")", "\n", "}", "(", ")", "\n", "return", "r", "\n", "}" ]

[ "CreateTarStreamReader", "returns", "an", "io", ".", "ReadCloser", "from", "which", "a", "tar", "stream", "can", "be", "read", ".", "The", "tar", "stream", "is", "created", "using", "CreateTarStream", "." ]

[ "func", "(", "t", "*", "stiTar", ")", "CreateTarStreamToTarWriter", "(", "dir", "string", ",", "includeDirInPath", "bool", ",", "tarWriter", "Writer", ",", "logger", "io", ".", "Writer", ")", "error", "{", "dir", "=", "filepath", ".", "Clean", "(", "dir", ")", "// remove relative paths and extraneous slashes", "\n", "glog", ".", "V", "(", "5", ")", ".", "Infof", "(", "\"", "\"", ",", "dir", ")", "\n", "err", ":=", "t", ".", "Walk", "(", "dir", ",", "func", "(", "path", "string", ",", "info", "os", ".", "FileInfo", ",", "err", "error", ")", "error", "{", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "// on Windows, directory symlinks report as a directory and as a symlink.", "// They should be treated as symlinks.", "if", "!", "t", ".", "shouldExclude", "(", "path", ")", "{", "// if file is a link just writing header info is enough", "if", "info", ".", "Mode", "(", ")", "&", "os", ".", "ModeSymlink", "!=", "0", "{", "if", "dir", "==", "path", "{", "return", "nil", "\n", "}", "\n", "if", "err", "=", "t", ".", "writeTarHeader", "(", "tarWriter", ",", "dir", ",", "path", ",", "info", ",", "includeDirInPath", ",", "logger", ")", ";", "err", "!=", "nil", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "info", ".", "Name", "(", ")", ",", "err", ")", "\n", "}", "\n", "// on Windows, filepath.Walk recurses into directory symlinks when it", "// shouldn't. https://github.com/golang/go/issues/17540", "if", "err", "==", "nil", "&&", "info", ".", "Mode", "(", ")", "&", "os", ".", "ModeDir", "!=", "0", "{", "return", "filepath", ".", "SkipDir", "\n", "}", "\n", "return", "err", "\n", "}", "\n", "if", "info", ".", "IsDir", "(", ")", "{", "if", "dir", "==", "path", "{", "return", "nil", "\n", "}", "\n", "if", "err", "=", "t", ".", "writeTarHeader", "(", "tarWriter", ",", "dir", ",", "path", ",", "info", ",", "includeDirInPath", ",", "logger", ")", ";", "err", "!=", "nil", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "info", ".", "Name", "(", ")", ",", "err", ")", "\n", "}", "\n", "return", "err", "\n", "}", "\n\n", "// regular files are copied into tar, if accessible", "file", ",", "err", ":=", "os", ".", "Open", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "path", ",", "err", ")", "\n", "return", "nil", "\n", "}", "\n", "defer", "file", ".", "Close", "(", ")", "\n", "if", "err", "=", "t", ".", "writeTarHeader", "(", "tarWriter", ",", "dir", ",", "path", ",", "info", ",", "includeDirInPath", ",", "logger", ")", ";", "err", "!=", "nil", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "info", ".", "Name", "(", ")", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n", "if", "_", ",", "err", "=", "io", ".", "Copy", "(", "tarWriter", ",", "file", ")", ";", "err", "!=", "nil", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "path", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", ")", "\n\n", "if", "err", "!=", "nil", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "CreateTarStreamToTarWriter", "creates", "a", "tar", "stream", "on", "the", "given", "writer", "from", "the", "given", "directory", "while", "excluding", "files", "that", "match", "the", "given", "exclusion", "pattern", "." ]

[ "func", "(", "t", "*", "stiTar", ")", "writeTarHeader", "(", "tarWriter", "Writer", ",", "dir", "string", ",", "path", "string", ",", "info", "os", ".", "FileInfo", ",", "includeDirInPath", "bool", ",", "logger", "io", ".", "Writer", ")", "error", "{", "var", "(", "link", "string", "\n", "err", "error", "\n", ")", "\n", "if", "info", ".", "Mode", "(", ")", "&", "os", ".", "ModeSymlink", "!=", "0", "{", "link", ",", "err", "=", "os", ".", "Readlink", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "header", ",", "err", ":=", "tar", ".", "FileInfoHeader", "(", "info", ",", "link", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "// on Windows, tar.FileInfoHeader incorrectly interprets directory symlinks", "// as directories. https://github.com/golang/go/issues/17541", "if", "info", ".", "Mode", "(", ")", "&", "os", ".", "ModeSymlink", "!=", "0", "&&", "info", ".", "Mode", "(", ")", "&", "os", ".", "ModeDir", "!=", "0", "{", "header", ".", "Typeflag", "=", "tar", ".", "TypeSymlink", "\n", "header", ".", "Mode", "&^=", "040000", "// c_ISDIR", "\n", "header", ".", "Mode", "|=", "0120000", "// c_ISLNK", "\n", "header", ".", "Linkname", "=", "link", "\n", "}", "\n", "prefix", ":=", "dir", "\n", "if", "includeDirInPath", "{", "prefix", "=", "filepath", ".", "Dir", "(", "prefix", ")", "\n", "}", "\n", "fileName", ":=", "path", "\n", "if", "prefix", "!=", "\"", "\"", "{", "fileName", "=", "path", "[", "1", "+", "len", "(", "prefix", ")", ":", "]", "\n", "}", "\n", "header", ".", "Name", "=", "filepath", ".", "ToSlash", "(", "fileName", ")", "\n", "header", ".", "Linkname", "=", "filepath", ".", "ToSlash", "(", "header", ".", "Linkname", ")", "\n", "// Force the header format to PAX to support UTF-8 filenames", "// and use the same format throughout the entire tar file.", "header", ".", "Format", "=", "tar", ".", "FormatPAX", "\n", "logFile", "(", "logger", ",", "header", ".", "Name", ")", "\n", "glog", ".", "V", "(", "5", ")", ".", "Infof", "(", "\"", "\"", ",", "path", ",", "header", ".", "Name", ")", "\n", "return", "tarWriter", ".", "WriteHeader", "(", "header", ")", "\n", "}" ]

[ "writeTarHeader", "writes", "tar", "header", "for", "given", "file", "returns", "error", "if", "operation", "fails" ]

[ "func", "(", "t", "*", "stiTar", ")", "ExtractTarStream", "(", "dir", "string", ",", "reader", "io", ".", "Reader", ")", "error", "{", "tarReader", ":=", "tar", ".", "NewReader", "(", "reader", ")", "\n", "return", "t", ".", "ExtractTarStreamFromTarReader", "(", "dir", ",", "tarReader", ",", "nil", ")", "\n", "}" ]

[ "ExtractTarStream", "calls", "ExtractTarStreamFromTarReader", "with", "a", "default", "reader", "and", "nil", "logger" ]

[ "func", "(", "t", "*", "stiTar", ")", "ExtractTarStreamWithLogging", "(", "dir", "string", ",", "reader", "io", ".", "Reader", ",", "logger", "io", ".", "Writer", ")", "error", "{", "tarReader", ":=", "tar", ".", "NewReader", "(", "reader", ")", "\n", "return", "t", ".", "ExtractTarStreamFromTarReader", "(", "dir", ",", "tarReader", ",", "logger", ")", "\n", "}" ]

[ "ExtractTarStreamWithLogging", "calls", "ExtractTarStreamFromTarReader", "with", "a", "default", "reader" ]

[ "func", "fdatasync", "(", "db", "*", "DB", ")", "error", "{", "return", "syscall", ".", "Fdatasync", "(", "int", "(", "db", ".", "file", ".", "Fd", "(", ")", ")", ")", "\n", "}" ]

[ "fdatasync", "flushes", "written", "data", "to", "a", "file", "descriptor", "." ]

[ "func", "newFreelist", "(", ")", "*", "freelist", "{", "return", "&", "freelist", "{", "pending", ":", "make", "(", "map", "[", "txid", "]", "[", "]", "pgid", ")", ",", "cache", ":", "make", "(", "map", "[", "pgid", "]", "bool", ")", ",", "}", "\n", "}" ]

[ "newFreelist", "returns", "an", "empty", "initialized", "freelist", "." ]

[ "func", "(", "f", "*", "freelist", ")", "size", "(", ")", "int", "{", "n", ":=", "f", ".", "count", "(", ")", "\n", "if", "n", ">=", "0xFFFF", "{", "// The first element will be used to store the count. See freelist.write.", "n", "++", "\n", "}", "\n", "return", "pageHeaderSize", "+", "(", "int", "(", "unsafe", ".", "Sizeof", "(", "pgid", "(", "0", ")", ")", ")", "*", "n", ")", "\n", "}" ]

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

[ "func", "(", "f", "*", "freelist", ")", "pending_count", "(", ")", "int", "{", "var", "count", "int", "\n", "for", "_", ",", "list", ":=", "range", "f", ".", "pending", "{", "count", "+=", "len", "(", "list", ")", "\n", "}", "\n", "return", "count", "\n", "}" ]

[ "pending_count", "returns", "count", "of", "pending", "pages" ]

[ "func", "(", "f", "*", "freelist", ")", "copyall", "(", "dst", "[", "]", "pgid", ")", "{", "m", ":=", "make", "(", "pgids", ",", "0", ",", "f", ".", "pending_count", "(", ")", ")", "\n", "for", "_", ",", "list", ":=", "range", "f", ".", "pending", "{", "m", "=", "append", "(", "m", ",", "list", "...", ")", "\n", "}", "\n", "sort", ".", "Sort", "(", "m", ")", "\n", "mergepgids", "(", "dst", ",", "f", ".", "ids", ",", "m", ")", "\n", "}" ]

[ "copyall", "copies", "into", "dst", "a", "list", "of", "all", "free", "ids", "and", "all", "pending", "ids", "in", "one", "sorted", "list", ".", "f", ".", "count", "returns", "the", "minimum", "length", "required", "for", "dst", "." ]

[ "func", "(", "f", "*", "freelist", ")", "allocate", "(", "n", "int", ")", "pgid", "{", "if", "len", "(", "f", ".", "ids", ")", "==", "0", "{", "return", "0", "\n", "}", "\n\n", "var", "initial", ",", "previd", "pgid", "\n", "for", "i", ",", "id", ":=", "range", "f", ".", "ids", "{", "if", "id", "<=", "1", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "id", ")", ")", "\n", "}", "\n\n", "// Reset initial page if this is not contiguous.", "if", "previd", "==", "0", "||", "id", "-", "previd", "!=", "1", "{", "initial", "=", "id", "\n", "}", "\n\n", "// If we found a contiguous block then remove it and return it.", "if", "(", "id", "-", "initial", ")", "+", "1", "==", "pgid", "(", "n", ")", "{", "// If we're allocating off the beginning then take the fast path", "// and just adjust the existing slice. This will use extra memory", "// temporarily but the append() in free() will realloc the slice", "// as is necessary.", "if", "(", "i", "+", "1", ")", "==", "n", "{", "f", ".", "ids", "=", "f", ".", "ids", "[", "i", "+", "1", ":", "]", "\n", "}", "else", "{", "copy", "(", "f", ".", "ids", "[", "i", "-", "n", "+", "1", ":", "]", ",", "f", ".", "ids", "[", "i", "+", "1", ":", "]", ")", "\n", "f", ".", "ids", "=", "f", ".", "ids", "[", ":", "len", "(", "f", ".", "ids", ")", "-", "n", "]", "\n", "}", "\n\n", "// Remove from the free cache.", "for", "i", ":=", "pgid", "(", "0", ")", ";", "i", "<", "pgid", "(", "n", ")", ";", "i", "++", "{", "delete", "(", "f", ".", "cache", ",", "initial", "+", "i", ")", "\n", "}", "\n\n", "return", "initial", "\n", "}", "\n\n", "previd", "=", "id", "\n", "}", "\n", "return", "0", "\n", "}" ]

[ "allocate", "returns", "the", "starting", "page", "id", "of", "a", "contiguous", "list", "of", "pages", "of", "a", "given", "size", ".", "If", "a", "contiguous", "block", "cannot", "be", "found", "then", "0", "is", "returned", "." ]

[ "func", "(", "f", "*", "freelist", ")", "free", "(", "txid", "txid", ",", "p", "*", "page", ")", "{", "if", "p", ".", "id", "<=", "1", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "p", ".", "id", ")", ")", "\n", "}", "\n\n", "// Free page and all its overflow pages.", "var", "ids", "=", "f", ".", "pending", "[", "txid", "]", "\n", "for", "id", ":=", "p", ".", "id", ";", "id", "<=", "p", ".", "id", "+", "pgid", "(", "p", ".", "overflow", ")", ";", "id", "++", "{", "// Verify that page is not already free.", "if", "f", ".", "cache", "[", "id", "]", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "id", ")", ")", "\n", "}", "\n\n", "// Add to the freelist and cache.", "ids", "=", "append", "(", "ids", ",", "id", ")", "\n", "f", ".", "cache", "[", "id", "]", "=", "true", "\n", "}", "\n", "f", ".", "pending", "[", "txid", "]", "=", "ids", "\n", "}" ]

[ "free", "releases", "a", "page", "and", "its", "overflow", "for", "a", "given", "transaction", "id", ".", "If", "the", "page", "is", "already", "free", "then", "a", "panic", "will", "occur", "." ]

[ "func", "(", "f", "*", "freelist", ")", "rollback", "(", "txid", "txid", ")", "{", "// Remove page ids from cache.", "for", "_", ",", "id", ":=", "range", "f", ".", "pending", "[", "txid", "]", "{", "delete", "(", "f", ".", "cache", ",", "id", ")", "\n", "}", "\n\n", "// Remove pages from pending list.", "delete", "(", "f", ".", "pending", ",", "txid", ")", "\n", "}" ]

[ "rollback", "removes", "the", "pages", "from", "a", "given", "pending", "tx", "." ]

[ "func", "(", "f", "*", "freelist", ")", "read", "(", "p", "*", "page", ")", "{", "// If the page.count is at the max uint16 value (64k) then it's considered", "// an overflow and the size of the freelist is stored as the first element.", "idx", ",", "count", ":=", "0", ",", "int", "(", "p", ".", "count", ")", "\n", "if", "count", "==", "0xFFFF", "{", "idx", "=", "1", "\n", "count", "=", "int", "(", "(", "(", "*", "[", "maxAllocSize", "]", "pgid", ")", "(", "unsafe", ".", "Pointer", "(", "&", "p", ".", "ptr", ")", ")", ")", "[", "0", "]", ")", "\n", "}", "\n\n", "// Copy the list of page ids from the freelist.", "if", "count", "==", "0", "{", "f", ".", "ids", "=", "nil", "\n", "}", "else", "{", "ids", ":=", "(", "(", "*", "[", "maxAllocSize", "]", "pgid", ")", "(", "unsafe", ".", "Pointer", "(", "&", "p", ".", "ptr", ")", ")", ")", "[", "idx", ":", "count", "]", "\n", "f", ".", "ids", "=", "make", "(", "[", "]", "pgid", ",", "len", "(", "ids", ")", ")", "\n", "copy", "(", "f", ".", "ids", ",", "ids", ")", "\n\n", "// Make sure they're sorted.", "sort", ".", "Sort", "(", "pgids", "(", "f", ".", "ids", ")", ")", "\n", "}", "\n\n", "// Rebuild the page cache.", "f", ".", "reindex", "(", ")", "\n", "}" ]

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

[ "func", "(", "f", "*", "freelist", ")", "write", "(", "p", "*", "page", ")", "error", "{", "// Combine the old free pgids and pgids waiting on an open transaction.", "// Update the header flag.", "p", ".", "flags", "|=", "freelistPageFlag", "\n\n", "// The page.count can only hold up to 64k elements so if we overflow that", "// number then we handle it by putting the size in the first element.", "lenids", ":=", "f", ".", "count", "(", ")", "\n", "if", "lenids", "==", "0", "{", "p", ".", "count", "=", "uint16", "(", "lenids", ")", "\n", "}", "else", "if", "lenids", "<", "0xFFFF", "{", "p", ".", "count", "=", "uint16", "(", "lenids", ")", "\n", "f", ".", "copyall", "(", "(", "(", "*", "[", "maxAllocSize", "]", "pgid", ")", "(", "unsafe", ".", "Pointer", "(", "&", "p", ".", "ptr", ")", ")", ")", "[", ":", "]", ")", "\n", "}", "else", "{", "p", ".", "count", "=", "0xFFFF", "\n", "(", "(", "*", "[", "maxAllocSize", "]", "pgid", ")", "(", "unsafe", ".", "Pointer", "(", "&", "p", ".", "ptr", ")", ")", ")", "[", "0", "]", "=", "pgid", "(", "lenids", ")", "\n", "f", ".", "copyall", "(", "(", "(", "*", "[", "maxAllocSize", "]", "pgid", ")", "(", "unsafe", ".", "Pointer", "(", "&", "p", ".", "ptr", ")", ")", ")", "[", "1", ":", "]", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "write", "writes", "the", "page", "ids", "onto", "a", "freelist", "page", ".", "All", "free", "and", "pending", "ids", "are", "saved", "to", "disk", "since", "in", "the", "event", "of", "a", "program", "crash", "all", "pending", "ids", "will", "become", "free", "." ]

[ "func", "(", "f", "*", "freelist", ")", "reload", "(", "p", "*", "page", ")", "{", "f", ".", "read", "(", "p", ")", "\n\n", "// Build a cache of only pending pages.", "pcache", ":=", "make", "(", "map", "[", "pgid", "]", "bool", ")", "\n", "for", "_", ",", "pendingIDs", ":=", "range", "f", ".", "pending", "{", "for", "_", ",", "pendingID", ":=", "range", "pendingIDs", "{", "pcache", "[", "pendingID", "]", "=", "true", "\n", "}", "\n", "}", "\n\n", "// Check each page in the freelist and build a new available freelist", "// with any pages not in the pending lists.", "var", "a", "[", "]", "pgid", "\n", "for", "_", ",", "id", ":=", "range", "f", ".", "ids", "{", "if", "!", "pcache", "[", "id", "]", "{", "a", "=", "append", "(", "a", ",", "id", ")", "\n", "}", "\n", "}", "\n", "f", ".", "ids", "=", "a", "\n\n", "// Once the available list is rebuilt then rebuild the free cache so that", "// it includes the available and pending free pages.", "f", ".", "reindex", "(", ")", "\n", "}" ]

[ "reload", "reads", "the", "freelist", "from", "a", "page", "and", "filters", "out", "pending", "items", "." ]

[ "func", "(", "f", "*", "freelist", ")", "reindex", "(", ")", "{", "f", ".", "cache", "=", "make", "(", "map", "[", "pgid", "]", "bool", ",", "len", "(", "f", ".", "ids", ")", ")", "\n", "for", "_", ",", "id", ":=", "range", "f", ".", "ids", "{", "f", ".", "cache", "[", "id", "]", "=", "true", "\n", "}", "\n", "for", "_", ",", "pendingIDs", ":=", "range", "f", ".", "pending", "{", "for", "_", ",", "pendingID", ":=", "range", "pendingIDs", "{", "f", ".", "cache", "[", "pendingID", "]", "=", "true", "\n", "}", "\n", "}", "\n", "}" ]

[ "reindex", "rebuilds", "the", "free", "cache", "based", "on", "available", "and", "pending", "free", "lists", "." ]

[ "func", "Open", "(", "path", "string", ",", "mode", "os", ".", "FileMode", ",", "options", "*", "Options", ")", "(", "*", "DB", ",", "error", ")", "{", "var", "db", "=", "&", "DB", "{", "opened", ":", "true", "}", "\n\n", "// Set default options if no options are provided.", "if", "options", "==", "nil", "{", "options", "=", "DefaultOptions", "\n", "}", "\n", "db", ".", "NoGrowSync", "=", "options", ".", "NoGrowSync", "\n", "db", ".", "MmapFlags", "=", "options", ".", "MmapFlags", "\n\n", "// Set default values for later DB operations.", "db", ".", "MaxBatchSize", "=", "DefaultMaxBatchSize", "\n", "db", ".", "MaxBatchDelay", "=", "DefaultMaxBatchDelay", "\n", "db", ".", "AllocSize", "=", "DefaultAllocSize", "\n\n", "flag", ":=", "os", ".", "O_RDWR", "\n", "if", "options", ".", "ReadOnly", "{", "flag", "=", "os", ".", "O_RDONLY", "\n", "db", ".", "readOnly", "=", "true", "\n", "}", "\n\n", "// Open data file and separate sync handler for metadata writes.", "db", ".", "path", "=", "path", "\n", "var", "err", "error", "\n", "if", "db", ".", "file", ",", "err", "=", "os", ".", "OpenFile", "(", "db", ".", "path", ",", "flag", "|", "os", ".", "O_CREATE", ",", "mode", ")", ";", "err", "!=", "nil", "{", "_", "=", "db", ".", "close", "(", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Lock file so that other processes using Bolt in read-write mode cannot", "// use the database at the same time. This would cause corruption since", "// the two processes would write meta pages and free pages separately.", "// The database file is locked exclusively (only one process can grab the lock)", "// if !options.ReadOnly.", "// The database file is locked using the shared lock (more than one process may", "// hold a lock at the same time) otherwise (options.ReadOnly is set).", "if", "err", ":=", "flock", "(", "db", ",", "mode", ",", "!", "db", ".", "readOnly", ",", "options", ".", "Timeout", ")", ";", "err", "!=", "nil", "{", "_", "=", "db", ".", "close", "(", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Default values for test hooks", "db", ".", "ops", ".", "writeAt", "=", "db", ".", "file", ".", "WriteAt", "\n\n", "// Initialize the database if it doesn't exist.", "if", "info", ",", "err", ":=", "db", ".", "file", ".", "Stat", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "else", "if", "info", ".", "Size", "(", ")", "==", "0", "{", "// Initialize new files with meta pages.", "if", "err", ":=", "db", ".", "init", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "else", "{", "// Read the first meta page to determine the page size.", "var", "buf", "[", "0x1000", "]", "byte", "\n", "if", "_", ",", "err", ":=", "db", ".", "file", ".", "ReadAt", "(", "buf", "[", ":", "]", ",", "0", ")", ";", "err", "==", "nil", "{", "m", ":=", "db", ".", "pageInBuffer", "(", "buf", "[", ":", "]", ",", "0", ")", ".", "meta", "(", ")", "\n", "if", "err", ":=", "m", ".", "validate", "(", ")", ";", "err", "!=", "nil", "{", "// If we can't read the page size, we can assume it's the same", "// as the OS -- since that's how the page size was chosen in the", "// first place.", "//", "// If the first page is invalid and this OS uses a different", "// page size than what the database was created with then we", "// are out of luck and cannot access the database.", "db", ".", "pageSize", "=", "os", ".", "Getpagesize", "(", ")", "\n", "}", "else", "{", "db", ".", "pageSize", "=", "int", "(", "m", ".", "pageSize", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "// Initialize page pool.", "db", ".", "pagePool", "=", "sync", ".", "Pool", "{", "New", ":", "func", "(", ")", "interface", "{", "}", "{", "return", "make", "(", "[", "]", "byte", ",", "db", ".", "pageSize", ")", "\n", "}", ",", "}", "\n\n", "// Memory map the data file.", "if", "err", ":=", "db", ".", "mmap", "(", "options", ".", "InitialMmapSize", ")", ";", "err", "!=", "nil", "{", "_", "=", "db", ".", "close", "(", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Read in the freelist.", "db", ".", "freelist", "=", "newFreelist", "(", ")", "\n", "db", ".", "freelist", ".", "read", "(", "db", ".", "page", "(", "db", ".", "meta", "(", ")", ".", "freelist", ")", ")", "\n\n", "// Mark the database as opened and return.", "return", "db", ",", "nil", "\n", "}" ]

[ "Open", "creates", "and", "opens", "a", "database", "at", "the", "given", "path", ".", "If", "the", "file", "does", "not", "exist", "then", "it", "will", "be", "created", "automatically", ".", "Passing", "in", "nil", "options", "will", "cause", "Bolt", "to", "open", "the", "database", "with", "the", "default", "options", "." ]

[ "func", "(", "db", "*", "DB", ")", "mmap", "(", "minsz", "int", ")", "error", "{", "db", ".", "mmaplock", ".", "Lock", "(", ")", "\n", "defer", "db", ".", "mmaplock", ".", "Unlock", "(", ")", "\n\n", "info", ",", "err", ":=", "db", ".", "file", ".", "Stat", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "else", "if", "int", "(", "info", ".", "Size", "(", ")", ")", "<", "db", ".", "pageSize", "*", "2", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// Ensure the size is at least the minimum size.", "var", "size", "=", "int", "(", "info", ".", "Size", "(", ")", ")", "\n", "if", "size", "<", "minsz", "{", "size", "=", "minsz", "\n", "}", "\n", "size", ",", "err", "=", "db", ".", "mmapSize", "(", "size", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Dereference all mmap references before unmapping.", "if", "db", ".", "rwtx", "!=", "nil", "{", "db", ".", "rwtx", ".", "root", ".", "dereference", "(", ")", "\n", "}", "\n\n", "// Unmap existing data before continuing.", "if", "err", ":=", "db", ".", "munmap", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Memory-map the data file as a byte slice.", "if", "err", ":=", "mmap", "(", "db", ",", "size", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Save references to the meta pages.", "db", ".", "meta0", "=", "db", ".", "page", "(", "0", ")", ".", "meta", "(", ")", "\n", "db", ".", "meta1", "=", "db", ".", "page", "(", "1", ")", ".", "meta", "(", ")", "\n\n", "// Validate the meta pages. We only return an error if both meta pages fail", "// validation, since meta0 failing validation means that it wasn't saved", "// properly -- but we can recover using meta1. And vice-versa.", "err0", ":=", "db", ".", "meta0", ".", "validate", "(", ")", "\n", "err1", ":=", "db", ".", "meta1", ".", "validate", "(", ")", "\n", "if", "err0", "!=", "nil", "&&", "err1", "!=", "nil", "{", "return", "err0", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "mmap", "opens", "the", "underlying", "memory", "-", "mapped", "file", "and", "initializes", "the", "meta", "references", ".", "minsz", "is", "the", "minimum", "size", "that", "the", "new", "mmap", "can", "be", "." ]

[ "func", "(", "db", "*", "DB", ")", "munmap", "(", ")", "error", "{", "if", "err", ":=", "munmap", "(", "db", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", "+", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "munmap", "unmaps", "the", "data", "file", "from", "memory", "." ]

[ "func", "(", "db", "*", "DB", ")", "mmapSize", "(", "size", "int", ")", "(", "int", ",", "error", ")", "{", "// Double the size from 32KB until 1GB.", "for", "i", ":=", "uint", "(", "15", ")", ";", "i", "<=", "30", ";", "i", "++", "{", "if", "size", "<=", "1", "<<", "i", "{", "return", "1", "<<", "i", ",", "nil", "\n", "}", "\n", "}", "\n\n", "// Verify the requested size is not above the maximum allowed.", "if", "size", ">", "maxMapSize", "{", "return", "0", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// If larger than 1GB then grow by 1GB at a time.", "sz", ":=", "int64", "(", "size", ")", "\n", "if", "remainder", ":=", "sz", "%", "int64", "(", "maxMmapStep", ")", ";", "remainder", ">", "0", "{", "sz", "+=", "int64", "(", "maxMmapStep", ")", "-", "remainder", "\n", "}", "\n\n", "// Ensure that the mmap size is a multiple of the page size.", "// This should always be true since we're incrementing in MBs.", "pageSize", ":=", "int64", "(", "db", ".", "pageSize", ")", "\n", "if", "(", "sz", "%", "pageSize", ")", "!=", "0", "{", "sz", "=", "(", "(", "sz", "/", "pageSize", ")", "+", "1", ")", "*", "pageSize", "\n", "}", "\n\n", "// If we've exceeded the max size then only grow up to the max size.", "if", "sz", ">", "maxMapSize", "{", "sz", "=", "maxMapSize", "\n", "}", "\n\n", "return", "int", "(", "sz", ")", ",", "nil", "\n", "}" ]

[ "mmapSize", "determines", "the", "appropriate", "size", "for", "the", "mmap", "given", "the", "current", "size", "of", "the", "database", ".", "The", "minimum", "size", "is", "32KB", "and", "doubles", "until", "it", "reaches", "1GB", ".", "Returns", "an", "error", "if", "the", "new", "mmap", "size", "is", "greater", "than", "the", "max", "allowed", "." ]

[ "func", "(", "db", "*", "DB", ")", "init", "(", ")", "error", "{", "// Set the page size to the OS page size.", "db", ".", "pageSize", "=", "os", ".", "Getpagesize", "(", ")", "\n\n", "// Create two meta pages on a buffer.", "buf", ":=", "make", "(", "[", "]", "byte", ",", "db", ".", "pageSize", "*", "4", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "2", ";", "i", "++", "{", "p", ":=", "db", ".", "pageInBuffer", "(", "buf", "[", ":", "]", ",", "pgid", "(", "i", ")", ")", "\n", "p", ".", "id", "=", "pgid", "(", "i", ")", "\n", "p", ".", "flags", "=", "metaPageFlag", "\n\n", "// Initialize the meta page.", "m", ":=", "p", ".", "meta", "(", ")", "\n", "m", ".", "magic", "=", "magic", "\n", "m", ".", "version", "=", "version", "\n", "m", ".", "pageSize", "=", "uint32", "(", "db", ".", "pageSize", ")", "\n", "m", ".", "freelist", "=", "2", "\n", "m", ".", "root", "=", "bucket", "{", "root", ":", "3", "}", "\n", "m", ".", "pgid", "=", "4", "\n", "m", ".", "txid", "=", "txid", "(", "i", ")", "\n", "m", ".", "checksum", "=", "m", ".", "sum64", "(", ")", "\n", "}", "\n\n", "// Write an empty freelist at page 3.", "p", ":=", "db", ".", "pageInBuffer", "(", "buf", "[", ":", "]", ",", "pgid", "(", "2", ")", ")", "\n", "p", ".", "id", "=", "pgid", "(", "2", ")", "\n", "p", ".", "flags", "=", "freelistPageFlag", "\n", "p", ".", "count", "=", "0", "\n\n", "// Write an empty leaf page at page 4.", "p", "=", "db", ".", "pageInBuffer", "(", "buf", "[", ":", "]", ",", "pgid", "(", "3", ")", ")", "\n", "p", ".", "id", "=", "pgid", "(", "3", ")", "\n", "p", ".", "flags", "=", "leafPageFlag", "\n", "p", ".", "count", "=", "0", "\n\n", "// Write the buffer to our data file.", "if", "_", ",", "err", ":=", "db", ".", "ops", ".", "writeAt", "(", "buf", ",", "0", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "err", ":=", "fdatasync", "(", "db", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "init", "creates", "a", "new", "database", "file", "and", "initializes", "its", "meta", "pages", "." ]

[ "func", "(", "db", "*", "DB", ")", "removeTx", "(", "tx", "*", "Tx", ")", "{", "// Release the read lock on the mmap.", "db", ".", "mmaplock", ".", "RUnlock", "(", ")", "\n\n", "// Use the meta lock to restrict access to the DB object.", "db", ".", "metalock", ".", "Lock", "(", ")", "\n\n", "// Remove the transaction.", "for", "i", ",", "t", ":=", "range", "db", ".", "txs", "{", "if", "t", "==", "tx", "{", "last", ":=", "len", "(", "db", ".", "txs", ")", "-", "1", "\n", "db", ".", "txs", "[", "i", "]", "=", "db", ".", "txs", "[", "last", "]", "\n", "db", ".", "txs", "[", "last", "]", "=", "nil", "\n", "db", ".", "txs", "=", "db", ".", "txs", "[", ":", "last", "]", "\n", "break", "\n", "}", "\n", "}", "\n", "n", ":=", "len", "(", "db", ".", "txs", ")", "\n\n", "// Unlock the meta pages.", "db", ".", "metalock", ".", "Unlock", "(", ")", "\n\n", "// Merge statistics.", "db", ".", "statlock", ".", "Lock", "(", ")", "\n", "db", ".", "stats", ".", "OpenTxN", "=", "n", "\n", "db", ".", "stats", ".", "TxStats", ".", "add", "(", "&", "tx", ".", "stats", ")", "\n", "db", ".", "statlock", ".", "Unlock", "(", ")", "\n", "}" ]

[ "removeTx", "removes", "a", "transaction", "from", "the", "database", "." ]

[ "func", "(", "b", "*", "batch", ")", "run", "(", ")", "{", "b", ".", "db", ".", "batchMu", ".", "Lock", "(", ")", "\n", "b", ".", "timer", ".", "Stop", "(", ")", "\n", "// Make sure no new work is added to this batch, but don't break", "// other batches.", "if", "b", ".", "db", ".", "batch", "==", "b", "{", "b", ".", "db", ".", "batch", "=", "nil", "\n", "}", "\n", "b", ".", "db", ".", "batchMu", ".", "Unlock", "(", ")", "\n\n", "retry", ":", "for", "len", "(", "b", ".", "calls", ")", ">", "0", "{", "var", "failIdx", "=", "-", "1", "\n", "err", ":=", "b", ".", "db", ".", "Update", "(", "func", "(", "tx", "*", "Tx", ")", "error", "{", "for", "i", ",", "c", ":=", "range", "b", ".", "calls", "{", "if", "err", ":=", "safelyCall", "(", "c", ".", "fn", ",", "tx", ")", ";", "err", "!=", "nil", "{", "failIdx", "=", "i", "\n", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", ")", "\n\n", "if", "failIdx", ">=", "0", "{", "// take the failing transaction out of the batch. it's", "// safe to shorten b.calls here because db.batch no longer", "// points to us, and we hold the mutex anyway.", "c", ":=", "b", ".", "calls", "[", "failIdx", "]", "\n", "b", ".", "calls", "[", "failIdx", "]", ",", "b", ".", "calls", "=", "b", ".", "calls", "[", "len", "(", "b", ".", "calls", ")", "-", "1", "]", ",", "b", ".", "calls", "[", ":", "len", "(", "b", ".", "calls", ")", "-", "1", "]", "\n", "// tell the submitter re-run it solo, continue with the rest of the batch", "c", ".", "err", "<-", "trySolo", "\n", "continue", "retry", "\n", "}", "\n\n", "// pass success, or bolt internal errors, to all callers", "for", "_", ",", "c", ":=", "range", "b", ".", "calls", "{", "c", ".", "err", "<-", "err", "\n", "}", "\n", "break", "retry", "\n", "}", "\n", "}" ]

[ "run", "performs", "the", "transactions", "in", "the", "batch", "and", "communicates", "results", "back", "to", "DB", ".", "Batch", "." ]

[ "func", "(", "db", "*", "DB", ")", "Stats", "(", ")", "Stats", "{", "db", ".", "statlock", ".", "RLock", "(", ")", "\n", "defer", "db", ".", "statlock", ".", "RUnlock", "(", ")", "\n", "return", "db", ".", "stats", "\n", "}" ]

[ "Stats", "retrieves", "ongoing", "performance", "stats", "for", "the", "database", ".", "This", "is", "only", "updated", "when", "a", "transaction", "closes", "." ]

[ "func", "(", "db", "*", "DB", ")", "Info", "(", ")", "*", "Info", "{", "return", "&", "Info", "{", "uintptr", "(", "unsafe", ".", "Pointer", "(", "&", "db", ".", "data", "[", "0", "]", ")", ")", ",", "db", ".", "pageSize", "}", "\n", "}" ]

[ "This", "is", "for", "internal", "access", "to", "the", "raw", "data", "bytes", "from", "the", "C", "cursor", "use", "carefully", "or", "not", "at", "all", "." ]

[ "func", "(", "db", "*", "DB", ")", "page", "(", "id", "pgid", ")", "*", "page", "{", "pos", ":=", "id", "*", "pgid", "(", "db", ".", "pageSize", ")", "\n", "return", "(", "*", "page", ")", "(", "unsafe", ".", "Pointer", "(", "&", "db", ".", "data", "[", "pos", "]", ")", ")", "\n", "}" ]

[ "page", "retrieves", "a", "page", "reference", "from", "the", "mmap", "based", "on", "the", "current", "page", "size", "." ]

[ "func", "(", "db", "*", "DB", ")", "pageInBuffer", "(", "b", "[", "]", "byte", ",", "id", "pgid", ")", "*", "page", "{", "return", "(", "*", "page", ")", "(", "unsafe", ".", "Pointer", "(", "&", "b", "[", "id", "*", "pgid", "(", "db", ".", "pageSize", ")", "]", ")", ")", "\n", "}" ]

[ "pageInBuffer", "retrieves", "a", "page", "reference", "from", "a", "given", "byte", "array", "based", "on", "the", "current", "page", "size", "." ]

[ "func", "(", "db", "*", "DB", ")", "meta", "(", ")", "*", "meta", "{", "// We have to return the meta with the highest txid which doesn't fail", "// validation. Otherwise, we can cause errors when in fact the database is", "// in a consistent state. metaA is the one with the higher txid.", "metaA", ":=", "db", ".", "meta0", "\n", "metaB", ":=", "db", ".", "meta1", "\n", "if", "db", ".", "meta1", ".", "txid", ">", "db", ".", "meta0", ".", "txid", "{", "metaA", "=", "db", ".", "meta1", "\n", "metaB", "=", "db", ".", "meta0", "\n", "}", "\n\n", "// Use higher meta page if valid. Otherwise fallback to previous, if valid.", "if", "err", ":=", "metaA", ".", "validate", "(", ")", ";", "err", "==", "nil", "{", "return", "metaA", "\n", "}", "else", "if", "err", ":=", "metaB", ".", "validate", "(", ")", ";", "err", "==", "nil", "{", "return", "metaB", "\n", "}", "\n\n", "// This should never be reached, because both meta1 and meta0 were validated", "// on mmap() and we do fsync() on every write.", "panic", "(", "\"", "\"", ")", "\n", "}" ]

[ "meta", "retrieves", "the", "current", "meta", "page", "reference", "." ]

[ "func", "(", "db", "*", "DB", ")", "grow", "(", "sz", "int", ")", "error", "{", "// Ignore if the new size is less than available file size.", "if", "sz", "<=", "db", ".", "filesz", "{", "return", "nil", "\n", "}", "\n\n", "// If the data is smaller than the alloc size then only allocate what's needed.", "// Once it goes over the allocation size then allocate in chunks.", "if", "db", ".", "datasz", "<", "db", ".", "AllocSize", "{", "sz", "=", "db", ".", "datasz", "\n", "}", "else", "{", "sz", "+=", "db", ".", "AllocSize", "\n", "}", "\n\n", "// Truncate and fsync to ensure file size metadata is flushed.", "// https://github.com/boltdb/bolt/issues/284", "if", "!", "db", ".", "NoGrowSync", "&&", "!", "db", ".", "readOnly", "{", "if", "runtime", ".", "GOOS", "!=", "\"", "\"", "{", "if", "err", ":=", "db", ".", "file", ".", "Truncate", "(", "int64", "(", "sz", ")", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n", "if", "err", ":=", "db", ".", "file", ".", "Sync", "(", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n\n", "db", ".", "filesz", "=", "sz", "\n", "return", "nil", "\n", "}" ]

[ "grow", "grows", "the", "size", "of", "the", "database", "to", "the", "given", "sz", "." ]

[ "func", "(", "s", "*", "Stats", ")", "Sub", "(", "other", "*", "Stats", ")", "Stats", "{", "if", "other", "==", "nil", "{", "return", "*", "s", "\n", "}", "\n", "var", "diff", "Stats", "\n", "diff", ".", "FreePageN", "=", "s", ".", "FreePageN", "\n", "diff", ".", "PendingPageN", "=", "s", ".", "PendingPageN", "\n", "diff", ".", "FreeAlloc", "=", "s", ".", "FreeAlloc", "\n", "diff", ".", "FreelistInuse", "=", "s", ".", "FreelistInuse", "\n", "diff", ".", "TxN", "=", "s", ".", "TxN", "-", "other", ".", "TxN", "\n", "diff", ".", "TxStats", "=", "s", ".", "TxStats", ".", "Sub", "(", "&", "other", ".", "TxStats", ")", "\n", "return", "diff", "\n", "}" ]

[ "Sub", "calculates", "and", "returns", "the", "difference", "between", "two", "sets", "of", "database", "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", "(", "m", "*", "meta", ")", "validate", "(", ")", "error", "{", "if", "m", ".", "magic", "!=", "magic", "{", "return", "ErrInvalid", "\n", "}", "else", "if", "m", ".", "version", "!=", "version", "{", "return", "ErrVersionMismatch", "\n", "}", "else", "if", "m", ".", "checksum", "!=", "0", "&&", "m", ".", "checksum", "!=", "m", ".", "sum64", "(", ")", "{", "return", "ErrChecksum", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "validate", "checks", "the", "marker", "bytes", "and", "version", "of", "the", "meta", "page", "to", "ensure", "it", "matches", "this", "binary", "." ]

[ "func", "(", "m", "*", "meta", ")", "write", "(", "p", "*", "page", ")", "{", "if", "m", ".", "root", ".", "root", ">=", "m", ".", "pgid", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "m", ".", "root", ".", "root", ",", "m", ".", "pgid", ")", ")", "\n", "}", "else", "if", "m", ".", "freelist", ">=", "m", ".", "pgid", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "m", ".", "freelist", ",", "m", ".", "pgid", ")", ")", "\n", "}", "\n\n", "// Page id is either going to be 0 or 1 which we can determine by the transaction ID.", "p", ".", "id", "=", "pgid", "(", "m", ".", "txid", "%", "2", ")", "\n", "p", ".", "flags", "|=", "metaPageFlag", "\n\n", "// Calculate the checksum.", "m", ".", "checksum", "=", "m", ".", "sum64", "(", ")", "\n\n", "m", ".", "copy", "(", "p", ".", "meta", "(", ")", ")", "\n", "}" ]

[ "write", "writes", "the", "meta", "onto", "a", "page", "." ]

[ "func", "(", "m", "*", "meta", ")", "sum64", "(", ")", "uint64", "{", "var", "h", "=", "fnv", ".", "New64a", "(", ")", "\n", "_", ",", "_", "=", "h", ".", "Write", "(", "(", "*", "[", "unsafe", ".", "Offsetof", "(", "meta", "{", "}", ".", "checksum", ")", "]", "byte", ")", "(", "unsafe", ".", "Pointer", "(", "m", ")", ")", "[", ":", "]", ")", "\n", "return", "h", ".", "Sum64", "(", ")", "\n", "}" ]

[ "generates", "the", "checksum", "for", "the", "meta", "." ]

[ "func", "(", "tx", "*", "Tx", ")", "init", "(", "db", "*", "DB", ")", "{", "tx", ".", "db", "=", "db", "\n", "tx", ".", "pages", "=", "nil", "\n\n", "// Copy the meta page since it can be changed by the writer.", "tx", ".", "meta", "=", "&", "meta", "{", "}", "\n", "db", ".", "meta", "(", ")", ".", "copy", "(", "tx", ".", "meta", ")", "\n\n", "// Copy over the root bucket.", "tx", ".", "root", "=", "newBucket", "(", "tx", ")", "\n", "tx", ".", "root", ".", "bucket", "=", "&", "bucket", "{", "}", "\n", "*", "tx", ".", "root", ".", "bucket", "=", "tx", ".", "meta", ".", "root", "\n\n", "// Increment the transaction id and add a page cache for writable transactions.", "if", "tx", ".", "writable", "{", "tx", ".", "pages", "=", "make", "(", "map", "[", "pgid", "]", "*", "page", ")", "\n", "tx", ".", "meta", ".", "txid", "+=", "txid", "(", "1", ")", "\n", "}", "\n", "}" ]

[ "init", "initializes", "the", "transaction", "." ]

[ "func", "(", "tx", "*", "Tx", ")", "Size", "(", ")", "int64", "{", "return", "int64", "(", "tx", ".", "meta", ".", "pgid", ")", "*", "int64", "(", "tx", ".", "db", ".", "pageSize", ")", "\n", "}" ]

[ "Size", "returns", "current", "database", "size", "in", "bytes", "as", "seen", "by", "this", "transaction", "." ]

[ "func", "(", "tx", "*", "Tx", ")", "Bucket", "(", "name", "[", "]", "byte", ")", "*", "Bucket", "{", "return", "tx", ".", "root", ".", "Bucket", "(", "name", ")", "\n", "}" ]

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

[ "func", "(", "tx", "*", "Tx", ")", "CreateBucket", "(", "name", "[", "]", "byte", ")", "(", "*", "Bucket", ",", "error", ")", "{", "return", "tx", ".", "root", ".", "CreateBucket", "(", "name", ")", "\n", "}" ]

[ "CreateBucket", "creates", "a", "new", "bucket", ".", "Returns", "an", "error", "if", "the", "bucket", "already", "exists", "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", "(", "tx", "*", "Tx", ")", "CreateBucketIfNotExists", "(", "name", "[", "]", "byte", ")", "(", "*", "Bucket", ",", "error", ")", "{", "return", "tx", ".", "root", ".", "CreateBucketIfNotExists", "(", "name", ")", "\n", "}" ]

[ "CreateBucketIfNotExists", "creates", "a", "new", "bucket", "if", "it", "doesn", "t", "already", "exist", ".", "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", "(", "tx", "*", "Tx", ")", "DeleteBucket", "(", "name", "[", "]", "byte", ")", "error", "{", "return", "tx", ".", "root", ".", "DeleteBucket", "(", "name", ")", "\n", "}" ]

[ "DeleteBucket", "deletes", "a", "bucket", ".", "Returns", "an", "error", "if", "the", "bucket", "cannot", "be", "found", "or", "if", "the", "key", "represents", "a", "non", "-", "bucket", "value", "." ]

[ "func", "(", "tx", "*", "Tx", ")", "ForEach", "(", "fn", "func", "(", "name", "[", "]", "byte", ",", "b", "*", "Bucket", ")", "error", ")", "error", "{", "return", "tx", ".", "root", ".", "ForEach", "(", "func", "(", "k", ",", "v", "[", "]", "byte", ")", "error", "{", "if", "err", ":=", "fn", "(", "k", ",", "tx", ".", "root", ".", "Bucket", "(", "k", ")", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "nil", "\n", "}", ")", "\n", "}" ]

[ "ForEach", "executes", "a", "function", "for", "each", "bucket", "in", "the", "root", ".", "If", "the", "provided", "function", "returns", "an", "error", "then", "the", "iteration", "is", "stopped", "and", "the", "error", "is", "returned", "to", "the", "caller", "." ]

[ "func", "(", "tx", "*", "Tx", ")", "OnCommit", "(", "fn", "func", "(", ")", ")", "{", "tx", ".", "commitHandlers", "=", "append", "(", "tx", ".", "commitHandlers", ",", "fn", ")", "\n", "}" ]

[ "OnCommit", "adds", "a", "handler", "function", "to", "be", "executed", "after", "the", "transaction", "successfully", "commits", "." ]

[ "func", "(", "tx", "*", "Tx", ")", "Commit", "(", ")", "error", "{", "_assert", "(", "!", "tx", ".", "managed", ",", "\"", "\"", ")", "\n", "if", "tx", ".", "db", "==", "nil", "{", "return", "ErrTxClosed", "\n", "}", "else", "if", "!", "tx", ".", "writable", "{", "return", "ErrTxNotWritable", "\n", "}", "\n\n", "// TODO(benbjohnson): Use vectorized I/O to write out dirty pages.", "// Rebalance nodes which have had deletions.", "var", "startTime", "=", "time", ".", "Now", "(", ")", "\n", "tx", ".", "root", ".", "rebalance", "(", ")", "\n", "if", "tx", ".", "stats", ".", "Rebalance", ">", "0", "{", "tx", ".", "stats", ".", "RebalanceTime", "+=", "time", ".", "Since", "(", "startTime", ")", "\n", "}", "\n\n", "// spill data onto dirty pages.", "startTime", "=", "time", ".", "Now", "(", ")", "\n", "if", "err", ":=", "tx", ".", "root", ".", "spill", "(", ")", ";", "err", "!=", "nil", "{", "tx", ".", "rollback", "(", ")", "\n", "return", "err", "\n", "}", "\n", "tx", ".", "stats", ".", "SpillTime", "+=", "time", ".", "Since", "(", "startTime", ")", "\n\n", "// Free the old root bucket.", "tx", ".", "meta", ".", "root", ".", "root", "=", "tx", ".", "root", ".", "root", "\n\n", "opgid", ":=", "tx", ".", "meta", ".", "pgid", "\n\n", "// Free the freelist and allocate new pages for it. This will overestimate", "// the size of the freelist but not underestimate the size (which would be bad).", "tx", ".", "db", ".", "freelist", ".", "free", "(", "tx", ".", "meta", ".", "txid", ",", "tx", ".", "db", ".", "page", "(", "tx", ".", "meta", ".", "freelist", ")", ")", "\n", "p", ",", "err", ":=", "tx", ".", "allocate", "(", "(", "tx", ".", "db", ".", "freelist", ".", "size", "(", ")", "/", "tx", ".", "db", ".", "pageSize", ")", "+", "1", ")", "\n", "if", "err", "!=", "nil", "{", "tx", ".", "rollback", "(", ")", "\n", "return", "err", "\n", "}", "\n", "if", "err", ":=", "tx", ".", "db", ".", "freelist", ".", "write", "(", "p", ")", ";", "err", "!=", "nil", "{", "tx", ".", "rollback", "(", ")", "\n", "return", "err", "\n", "}", "\n", "tx", ".", "meta", ".", "freelist", "=", "p", ".", "id", "\n\n", "// If the high water mark has moved up then attempt to grow the database.", "if", "tx", ".", "meta", ".", "pgid", ">", "opgid", "{", "if", "err", ":=", "tx", ".", "db", ".", "grow", "(", "int", "(", "tx", ".", "meta", ".", "pgid", "+", "1", ")", "*", "tx", ".", "db", ".", "pageSize", ")", ";", "err", "!=", "nil", "{", "tx", ".", "rollback", "(", ")", "\n", "return", "err", "\n", "}", "\n", "}", "\n\n", "// Write dirty pages to disk.", "startTime", "=", "time", ".", "Now", "(", ")", "\n", "if", "err", ":=", "tx", ".", "write", "(", ")", ";", "err", "!=", "nil", "{", "tx", ".", "rollback", "(", ")", "\n", "return", "err", "\n", "}", "\n\n", "// If strict mode is enabled then perform a consistency check.", "// Only the first consistency error is reported in the panic.", "if", "tx", ".", "db", ".", "StrictMode", "{", "ch", ":=", "tx", ".", "Check", "(", ")", "\n", "var", "errs", "[", "]", "string", "\n", "for", "{", "err", ",", "ok", ":=", "<-", "ch", "\n", "if", "!", "ok", "{", "break", "\n", "}", "\n", "errs", "=", "append", "(", "errs", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "if", "len", "(", "errs", ")", ">", "0", "{", "panic", "(", "\"", "\"", "+", "strings", ".", "Join", "(", "errs", ",", "\"", "\\n", "\"", ")", ")", "\n", "}", "\n", "}", "\n\n", "// Write meta to disk.", "if", "err", ":=", "tx", ".", "writeMeta", "(", ")", ";", "err", "!=", "nil", "{", "tx", ".", "rollback", "(", ")", "\n", "return", "err", "\n", "}", "\n", "tx", ".", "stats", ".", "WriteTime", "+=", "time", ".", "Since", "(", "startTime", ")", "\n\n", "// Finalize the transaction.", "tx", ".", "close", "(", ")", "\n\n", "// Execute commit handlers now that the locks have been removed.", "for", "_", ",", "fn", ":=", "range", "tx", ".", "commitHandlers", "{", "fn", "(", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Commit", "writes", "all", "changes", "to", "disk", "and", "updates", "the", "meta", "page", ".", "Returns", "an", "error", "if", "a", "disk", "write", "error", "occurs", "or", "if", "Commit", "is", "called", "on", "a", "read", "-", "only", "transaction", "." ]

[ "func", "(", "tx", "*", "Tx", ")", "Rollback", "(", ")", "error", "{", "_assert", "(", "!", "tx", ".", "managed", ",", "\"", "\"", ")", "\n", "if", "tx", ".", "db", "==", "nil", "{", "return", "ErrTxClosed", "\n", "}", "\n", "tx", ".", "rollback", "(", ")", "\n", "return", "nil", "\n", "}" ]

[ "Rollback", "closes", "the", "transaction", "and", "ignores", "all", "previous", "updates", ".", "Read", "-", "only", "transactions", "must", "be", "rolled", "back", "and", "not", "committed", "." ]

[ "func", "(", "tx", "*", "Tx", ")", "CopyFile", "(", "path", "string", ",", "mode", "os", ".", "FileMode", ")", "error", "{", "f", ",", "err", ":=", "os", ".", "OpenFile", "(", "path", ",", "os", ".", "O_RDWR", "|", "os", ".", "O_CREATE", "|", "os", ".", "O_TRUNC", ",", "mode", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "err", "=", "tx", ".", "Copy", "(", "f", ")", "\n", "if", "err", "!=", "nil", "{", "_", "=", "f", ".", "Close", "(", ")", "\n", "return", "err", "\n", "}", "\n", "return", "f", ".", "Close", "(", ")", "\n", "}" ]

[ "CopyFile", "copies", "the", "entire", "database", "to", "file", "at", "the", "given", "path", ".", "A", "reader", "transaction", "is", "maintained", "during", "the", "copy", "so", "it", "is", "safe", "to", "continue", "using", "the", "database", "while", "a", "copy", "is", "in", "progress", "." ]

[ "func", "(", "tx", "*", "Tx", ")", "Check", "(", ")", "<-", "chan", "error", "{", "ch", ":=", "make", "(", "chan", "error", ")", "\n", "go", "tx", ".", "check", "(", "ch", ")", "\n", "return", "ch", "\n", "}" ]

[ "Check", "performs", "several", "consistency", "checks", "on", "the", "database", "for", "this", "transaction", ".", "An", "error", "is", "returned", "if", "any", "inconsistency", "is", "found", ".", "It", "can", "be", "safely", "run", "concurrently", "on", "a", "writable", "transaction", ".", "However", "this", "incurs", "a", "high", "cost", "for", "large", "databases", "and", "databases", "with", "a", "lot", "of", "subbuckets", "because", "of", "caching", ".", "This", "overhead", "can", "be", "removed", "if", "running", "on", "a", "read", "-", "only", "transaction", "however", "it", "is", "not", "safe", "to", "execute", "other", "writer", "transactions", "at", "the", "same", "time", "." ]

[ "func", "(", "tx", "*", "Tx", ")", "write", "(", ")", "error", "{", "// Sort pages by id.", "pages", ":=", "make", "(", "pages", ",", "0", ",", "len", "(", "tx", ".", "pages", ")", ")", "\n", "for", "_", ",", "p", ":=", "range", "tx", ".", "pages", "{", "pages", "=", "append", "(", "pages", ",", "p", ")", "\n", "}", "\n", "// Clear out page cache early.", "tx", ".", "pages", "=", "make", "(", "map", "[", "pgid", "]", "*", "page", ")", "\n", "sort", ".", "Sort", "(", "pages", ")", "\n\n", "// Write pages to disk in order.", "for", "_", ",", "p", ":=", "range", "pages", "{", "size", ":=", "(", "int", "(", "p", ".", "overflow", ")", "+", "1", ")", "*", "tx", ".", "db", ".", "pageSize", "\n", "offset", ":=", "int64", "(", "p", ".", "id", ")", "*", "int64", "(", "tx", ".", "db", ".", "pageSize", ")", "\n\n", "// Write out page in \"max allocation\" sized chunks.", "ptr", ":=", "(", "*", "[", "maxAllocSize", "]", "byte", ")", "(", "unsafe", ".", "Pointer", "(", "p", ")", ")", "\n", "for", "{", "// Limit our write to our max allocation size.", "sz", ":=", "size", "\n", "if", "sz", ">", "maxAllocSize", "-", "1", "{", "sz", "=", "maxAllocSize", "-", "1", "\n", "}", "\n\n", "// Write chunk to disk.", "buf", ":=", "ptr", "[", ":", "sz", "]", "\n", "if", "_", ",", "err", ":=", "tx", ".", "db", ".", "ops", ".", "writeAt", "(", "buf", ",", "offset", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Update statistics.", "tx", ".", "stats", ".", "Write", "++", "\n\n", "// Exit inner for loop if we've written all the chunks.", "size", "-=", "sz", "\n", "if", "size", "==", "0", "{", "break", "\n", "}", "\n\n", "// Otherwise move offset forward and move pointer to next chunk.", "offset", "+=", "int64", "(", "sz", ")", "\n", "ptr", "=", "(", "*", "[", "maxAllocSize", "]", "byte", ")", "(", "unsafe", ".", "Pointer", "(", "&", "ptr", "[", "sz", "]", ")", ")", "\n", "}", "\n", "}", "\n\n", "// Ignore file sync if flag is set on DB.", "if", "!", "tx", ".", "db", ".", "NoSync", "||", "IgnoreNoSync", "{", "if", "err", ":=", "fdatasync", "(", "tx", ".", "db", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "// Put small pages back to page pool.", "for", "_", ",", "p", ":=", "range", "pages", "{", "// Ignore page sizes over 1 page.", "// These are allocated using make() instead of the page pool.", "if", "int", "(", "p", ".", "overflow", ")", "!=", "0", "{", "continue", "\n", "}", "\n\n", "buf", ":=", "(", "*", "[", "maxAllocSize", "]", "byte", ")", "(", "unsafe", ".", "Pointer", "(", "p", ")", ")", "[", ":", "tx", ".", "db", ".", "pageSize", "]", "\n\n", "// See https://go.googlesource.com/go/+/f03c9202c43e0abb130669852082117ca50aa9b1", "for", "i", ":=", "range", "buf", "{", "buf", "[", "i", "]", "=", "0", "\n", "}", "\n", "tx", ".", "db", ".", "pagePool", ".", "Put", "(", "buf", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "write", "writes", "any", "dirty", "pages", "to", "disk", "." ]

[ "func", "(", "tx", "*", "Tx", ")", "writeMeta", "(", ")", "error", "{", "// Create a temporary buffer for the meta page.", "buf", ":=", "make", "(", "[", "]", "byte", ",", "tx", ".", "db", ".", "pageSize", ")", "\n", "p", ":=", "tx", ".", "db", ".", "pageInBuffer", "(", "buf", ",", "0", ")", "\n", "tx", ".", "meta", ".", "write", "(", "p", ")", "\n\n", "// Write the meta page to file.", "if", "_", ",", "err", ":=", "tx", ".", "db", ".", "ops", ".", "writeAt", "(", "buf", ",", "int64", "(", "p", ".", "id", ")", "*", "int64", "(", "tx", ".", "db", ".", "pageSize", ")", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "!", "tx", ".", "db", ".", "NoSync", "||", "IgnoreNoSync", "{", "if", "err", ":=", "fdatasync", "(", "tx", ".", "db", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "// Update statistics.", "tx", ".", "stats", ".", "Write", "++", "\n\n", "return", "nil", "\n", "}" ]

[ "writeMeta", "writes", "the", "meta", "to", "the", "disk", "." ]

[ "func", "(", "tx", "*", "Tx", ")", "page", "(", "id", "pgid", ")", "*", "page", "{", "// Check the dirty pages first.", "if", "tx", ".", "pages", "!=", "nil", "{", "if", "p", ",", "ok", ":=", "tx", ".", "pages", "[", "id", "]", ";", "ok", "{", "return", "p", "\n", "}", "\n", "}", "\n\n", "// Otherwise return directly from the mmap.", "return", "tx", ".", "db", ".", "page", "(", "id", ")", "\n", "}" ]

[ "page", "returns", "a", "reference", "to", "the", "page", "with", "a", "given", "id", ".", "If", "page", "has", "been", "written", "to", "then", "a", "temporary", "buffered", "page", "is", "returned", "." ]