Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "loadMessageFile", "(", "path", "string", ",", "info", "os", ".", "FileInfo", ",", "osError", "error", ")", "error", "{", "if", "osError", "!=", "nil", "{", "return", "osError", "\n", "}", "\n", "if", "info", ".", "IsDir", "(", ")", "{", "return", "nil", "\n", "}", "\n\n", "if", "matched", ",", "_", ":=", "regexp", ".", "MatchString", "(", "messageFilePattern", ",", "info", ".", "Name", "(", ")", ")", ";", "matched", "{", "messageConfig", ",", "err", ":=", "parseMessagesFile", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "locale", ":=", "parseLocaleFromFileName", "(", "info", ".", "Name", "(", ")", ")", "\n\n", "// If we have already parsed a message file for this locale, merge both", "if", "_", ",", "exists", ":=", "messages", "[", "locale", "]", ";", "exists", "{", "messages", "[", "locale", "]", ".", "Merge", "(", "messageConfig", ")", "\n", "i18nLog", ".", "Debugf", "(", "\"", "\"", ",", "locale", ")", "\n", "}", "else", "{", "messages", "[", "locale", "]", "=", "messageConfig", "\n", "}", "\n\n", "i18nLog", ".", "Debug", "(", "\"", "\"", ",", "\"", "\"", ",", "info", ".", "Name", "(", ")", ")", "\n", "}", "else", "{", "i18nLog", ".", "Warn", "(", "\"", "\"", ",", "\"", "\"", ",", "info", ".", "Name", "(", ")", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Load", "a", "single", "message", "file" ]

[ "func", "hasAcceptLanguageHeader", "(", "request", "*", "Request", ")", "(", "bool", ",", "string", ")", "{", "if", "request", ".", "AcceptLanguages", "!=", "nil", "&&", "len", "(", "request", ".", "AcceptLanguages", ")", ">", "0", "{", "return", "true", ",", "request", ".", "AcceptLanguages", "[", "0", "]", ".", "Language", "\n", "}", "\n\n", "return", "false", ",", "\"", "\"", "\n", "}" ]

[ "Determine", "whether", "the", "given", "request", "has", "valid", "Accept", "-", "Language", "value", ".", "Assumes", "that", "the", "accept", "languages", "stored", "in", "the", "request", "are", "sorted", "according", "to", "quality", "with", "top", "quality", "first", "in", "the", "slice", "." ]

[ "func", "hasLocaleCookie", "(", "request", "*", "Request", ")", "(", "bool", ",", "string", ")", "{", "if", "request", "!=", "nil", "{", "name", ":=", "Config", ".", "StringDefault", "(", "localeCookieConfigKey", ",", "CookiePrefix", "+", "\"", "\"", ")", "\n", "cookie", ",", "err", ":=", "request", ".", "Cookie", "(", "name", ")", "\n", "if", "err", "==", "nil", "{", "return", "true", ",", "cookie", ".", "GetValue", "(", ")", "\n", "}", "\n", "i18nLog", ".", "Debug", "(", "\"", "\"", ",", "\"", "\"", ",", "name", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "false", ",", "\"", "\"", "\n", "}" ]

[ "Determine", "whether", "the", "given", "request", "has", "a", "valid", "language", "cookie", "value", "." ]

[ "func", "JsonFormatEx", "(", "pretty", ",", "lineSeparated", "bool", ")", "LogFormat", "{", "jsonMarshal", ":=", "json", ".", "Marshal", "\n", "if", "pretty", "{", "jsonMarshal", "=", "func", "(", "v", "interface", "{", "}", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "return", "json", ".", "MarshalIndent", "(", "v", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n\n", "return", "FormatFunc", "(", "func", "(", "r", "*", "Record", ")", "[", "]", "byte", "{", "props", ":=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n\n", "props", "[", "\"", "\"", "]", "=", "r", ".", "Time", "\n", "props", "[", "\"", "\"", "]", "=", "levelString", "[", "r", ".", "Level", "]", "\n", "props", "[", "\"", "\"", "]", "=", "r", ".", "Message", "\n", "for", "k", ",", "v", ":=", "range", "r", ".", "Context", "{", "props", "[", "k", "]", "=", "formatJsonValue", "(", "v", ")", "\n", "}", "\n\n", "b", ",", "err", ":=", "jsonMarshal", "(", "props", ")", "\n", "if", "err", "!=", "nil", "{", "b", ",", "_", "=", "jsonMarshal", "(", "map", "[", "string", "]", "string", "{", "errorKey", ":", "err", ".", "Error", "(", ")", ",", "}", ")", "\n", "return", "b", "\n", "}", "\n\n", "if", "lineSeparated", "{", "b", "=", "append", "(", "b", ",", "'\\n'", ")", "\n", "}", "\n\n", "return", "b", "\n", "}", ")", "\n", "}" ]

[ "JsonFormatEx", "formats", "log", "records", "as", "JSON", "objects", ".", "If", "pretty", "is", "true", "records", "will", "be", "pretty", "-", "printed", ".", "If", "lineSeparated", "is", "true", "records", "will", "be", "logged", "with", "a", "new", "line", "between", "each", "record", "." ]

[ "func", "initSessionEngine", "(", ")", "{", "// Check for session engine to use and assign it", "sename", ":=", "Config", ".", "StringDefault", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "if", "se", ",", "found", ":=", "sessionEngineMap", "[", "sename", "]", ";", "found", "{", "CurrentSessionEngine", "=", "se", "(", ")", "\n", "}", "else", "{", "sessionLog", ".", "Warn", "(", "\"", "\"", ",", "sename", ")", "\n", "CurrentSessionEngine", "=", "sessionEngineMap", "[", "\"", "\"", "]", "(", ")", "\n", "}", "\n", "}" ]

[ "Called", "when", "application", "is", "starting", "up" ]

[ "func", "NewErrorFromPanic", "(", "err", "interface", "{", "}", ")", "*", "Error", "{", "// Parse the filename and line from the originating line of app code.", "// /Users/robfig/code/gocode/src/revel/examples/booking/app/controllers/hotels.go:191 (0x44735)", "stack", ":=", "string", "(", "debug", ".", "Stack", "(", ")", ")", "\n", "frame", ",", "basePath", ":=", "findRelevantStackFrame", "(", "stack", ")", "\n", "if", "frame", "==", "-", "1", "{", "return", "nil", "\n", "}", "\n\n", "stack", "=", "stack", "[", "frame", ":", "]", "\n", "stackElement", ":=", "stack", "[", ":", "strings", ".", "Index", "(", "stack", ",", "\"", "\\n", "\"", ")", "]", "\n", "colonIndex", ":=", "strings", ".", "LastIndex", "(", "stackElement", ",", "\"", "\"", ")", "\n", "filename", ":=", "stackElement", "[", ":", "colonIndex", "]", "\n", "var", "line", "int", "\n", "fmt", ".", "Sscan", "(", "stackElement", "[", "colonIndex", "+", "1", ":", "]", ",", "&", "line", ")", "\n\n", "// Show an error page.", "description", ":=", "\"", "\"", "\n", "if", "err", "!=", "nil", "{", "description", "=", "fmt", ".", "Sprint", "(", "err", ")", "\n", "}", "\n", "lines", ",", "readErr", ":=", "ReadLines", "(", "filename", ")", "\n", "if", "readErr", "!=", "nil", "{", "utilLog", ".", "Error", "(", "\"", "\"", ",", "\"", "\"", ",", "filename", ",", "\"", "\"", ",", "readErr", ")", "\n", "}", "\n", "return", "&", "Error", "{", "Title", ":", "\"", "\"", ",", "Path", ":", "filename", "[", "len", "(", "basePath", ")", ":", "]", ",", "Line", ":", "line", ",", "Description", ":", "description", ",", "SourceLines", ":", "lines", ",", "Stack", ":", "stack", ",", "}", "\n", "}" ]

[ "NewErrorFromPanic", "method", "finds", "the", "deepest", "stack", "from", "in", "user", "code", "and", "provide", "a", "code", "listing", "of", "that", "on", "the", "line", "that", "eventually", "triggered", "the", "panic", ".", "Returns", "nil", "if", "no", "relevant", "stack", "frame", "can", "be", "found", "." ]

[ "func", "(", "e", "*", "Error", ")", "ContextSource", "(", ")", "[", "]", "SourceLine", "{", "if", "e", ".", "SourceLines", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "start", ":=", "(", "e", ".", "Line", "-", "1", ")", "-", "5", "\n", "if", "start", "<", "0", "{", "start", "=", "0", "\n", "}", "\n", "end", ":=", "(", "e", ".", "Line", "-", "1", ")", "+", "5", "\n", "if", "end", ">", "len", "(", "e", ".", "SourceLines", ")", "{", "end", "=", "len", "(", "e", ".", "SourceLines", ")", "\n", "}", "\n\n", "lines", ":=", "make", "(", "[", "]", "SourceLine", ",", "end", "-", "start", ")", "\n", "for", "i", ",", "src", ":=", "range", "e", ".", "SourceLines", "[", "start", ":", "end", "]", "{", "fileLine", ":=", "start", "+", "i", "+", "1", "\n", "lines", "[", "i", "]", "=", "SourceLine", "{", "src", ",", "fileLine", ",", "fileLine", "==", "e", ".", "Line", "}", "\n", "}", "\n", "return", "lines", "\n", "}" ]

[ "ContextSource", "method", "returns", "a", "snippet", "of", "the", "source", "around", "where", "the", "error", "occurred", "." ]

[ "func", "(", "e", "*", "Error", ")", "SetLink", "(", "errorLink", "string", ")", "{", "errorLink", "=", "strings", ".", "Replace", "(", "errorLink", ",", "\"", "\"", ",", "e", ".", "Path", ",", "-", "1", ")", "\n", "errorLink", "=", "strings", ".", "Replace", "(", "errorLink", ",", "\"", "\"", ",", "strconv", ".", "Itoa", "(", "e", ".", "Line", ")", ",", "-", "1", ")", "\n\n", "e", ".", "Link", "=", "\"", "\"", "+", "errorLink", "+", "\"", "\"", "+", "e", ".", "Path", "+", "\"", "\"", "+", "strconv", ".", "Itoa", "(", "e", ".", "Line", ")", "+", "\"", "\"", "\n", "}" ]

[ "SetLink", "method", "prepares", "a", "link", "and", "assign", "to", "Error", ".", "Link", "attribute" ]

[ "func", "findRelevantStackFrame", "(", "stack", "string", ")", "(", "int", ",", "string", ")", "{", "// Find first item in SourcePath that isn't in RevelPath.", "// If first item is in RevelPath, keep track of position, trim and check again.", "partialStack", ":=", "stack", "\n", "sourcePath", ":=", "filepath", ".", "ToSlash", "(", "SourcePath", ")", "\n", "revelPath", ":=", "filepath", ".", "ToSlash", "(", "RevelPath", ")", "\n", "sumFrame", ":=", "0", "\n", "for", "{", "frame", ":=", "strings", ".", "Index", "(", "partialStack", ",", "sourcePath", ")", "\n", "revelFrame", ":=", "strings", ".", "Index", "(", "partialStack", ",", "revelPath", ")", "\n\n", "if", "frame", "==", "-", "1", "{", "break", "\n", "}", "else", "if", "frame", "!=", "revelFrame", "{", "return", "sumFrame", "+", "frame", ",", "SourcePath", "\n", "}", "else", "{", "// Need to at least trim off the first character so this frame isn't caught again.", "partialStack", "=", "partialStack", "[", "frame", "+", "1", ":", "]", "\n", "sumFrame", "+=", "frame", "+", "1", "\n", "}", "\n", "}", "\n", "for", "_", ",", "module", ":=", "range", "Modules", "{", "if", "frame", ":=", "strings", ".", "Index", "(", "stack", ",", "filepath", ".", "ToSlash", "(", "module", ".", "Path", ")", ")", ";", "frame", "!=", "-", "1", "{", "return", "frame", ",", "module", ".", "Path", "\n", "}", "\n", "}", "\n", "return", "-", "1", ",", "\"", "\"", "\n", "}" ]

[ "Return", "the", "character", "index", "of", "the", "first", "relevant", "stack", "frame", "or", "-", "1", "if", "none", "were", "found", ".", "Additionally", "it", "returns", "the", "base", "path", "of", "the", "tree", "in", "which", "the", "identified", "code", "resides", "." ]

[ "func", "HandlerFunc", "(", "log", "func", "(", "message", "string", ",", "time", "time", ".", "Time", ",", "level", "LogLevel", ",", "call", "CallStack", ",", "context", "ContextMap", ")", "error", ")", "LogHandler", "{", "return", "remoteHandler", "(", "log", ")", "\n", "}" ]

[ "This", "function", "allows", "you", "to", "do", "a", "full", "declaration", "for", "the", "log", "it", "is", "recommended", "you", "use", "FuncHandler", "instead" ]

[ "func", "(", "c", "remoteHandler", ")", "Log", "(", "record", "*", "Record", ")", "error", "{", "return", "c", "(", "record", ".", "Message", ",", "record", ".", "Time", ",", "record", ".", "Level", ",", "record", ".", "Call", ",", "record", ".", "Context", ")", "\n", "}" ]

[ "The", "Log", "implementation" ]

[ "func", "LazyHandler", "(", "h", "LogHandler", ")", "LogHandler", "{", "return", "FuncHandler", "(", "func", "(", "r", "*", "Record", ")", "error", "{", "for", "k", ",", "v", ":=", "range", "r", ".", "Context", "{", "if", "lz", ",", "ok", ":=", "v", ".", "(", "Lazy", ")", ";", "ok", "{", "value", ",", "err", ":=", "evaluateLazy", "(", "lz", ")", "\n", "if", "err", "!=", "nil", "{", "r", ".", "Context", "[", "errorKey", "]", "=", "\"", "\"", "+", "k", "\n", "}", "else", "{", "v", "=", "value", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "h", ".", "Log", "(", "r", ")", "\n", "}", ")", "\n", "}" ]

[ "LazyHandler", "writes", "all", "values", "to", "the", "wrapped", "handler", "after", "evaluating", "any", "lazy", "functions", "in", "the", "record", "s", "context", ".", "It", "is", "already", "wrapped", "around", "StreamHandler", "and", "SyslogHandler", "in", "this", "library", "you", "ll", "only", "need", "it", "if", "you", "write", "your", "own", "Handler", "." ]

[ "func", "GetLogger", "(", "name", "string", ",", "logger", "MultiLogger", ")", "(", "l", "*", "log", ".", "Logger", ")", "{", "switch", "name", "{", "case", "\"", "\"", ":", "// TODO trace is deprecated, replaced by debug", "l", "=", "log", ".", "New", "(", "loggerRewrite", "{", "Logger", ":", "logger", ",", "Level", ":", "log15", ".", "LvlDebug", "}", ",", "\"", "\"", ",", "0", ")", "\n", "case", "\"", "\"", ":", "l", "=", "log", ".", "New", "(", "loggerRewrite", "{", "Logger", ":", "logger", ",", "Level", ":", "log15", ".", "LvlDebug", "}", ",", "\"", "\"", ",", "0", ")", "\n", "case", "\"", "\"", ":", "l", "=", "log", ".", "New", "(", "loggerRewrite", "{", "Logger", ":", "logger", ",", "Level", ":", "log15", ".", "LvlInfo", "}", ",", "\"", "\"", ",", "0", ")", "\n", "case", "\"", "\"", ":", "l", "=", "log", ".", "New", "(", "loggerRewrite", "{", "Logger", ":", "logger", ",", "Level", ":", "log15", ".", "LvlWarn", "}", ",", "\"", "\"", ",", "0", ")", "\n", "case", "\"", "\"", ":", "l", "=", "log", ".", "New", "(", "loggerRewrite", "{", "Logger", ":", "logger", ",", "Level", ":", "log15", ".", "LvlError", "}", ",", "\"", "\"", ",", "0", ")", "\n", "case", "\"", "\"", ":", "l", "=", "log", ".", "New", "(", "loggerRewrite", "{", "Logger", ":", "logger", ",", "Level", ":", "log15", ".", "LvlInfo", "}", ",", "\"", "\"", ",", "0", ")", "\n", "}", "\n\n", "return", "l", "\n\n", "}" ]

[ "Returns", "the", "logger", "for", "the", "name" ]

[ "func", "(", "lr", "loggerRewrite", ")", "Write", "(", "p", "[", "]", "byte", ")", "(", "n", "int", ",", "err", "error", ")", "{", "if", "!", "lr", ".", "hideDeprecated", "{", "p", "=", "append", "(", "log_deprecated", ",", "p", "...", ")", "\n", "}", "\n", "n", "=", "len", "(", "p", ")", "\n", "if", "len", "(", "p", ")", ">", "0", "&&", "p", "[", "n", "-", "1", "]", "==", "'\\n'", "{", "p", "=", "p", "[", ":", "n", "-", "1", "]", "\n", "n", "--", "\n", "}", "\n\n", "switch", "lr", ".", "Level", "{", "case", "log15", ".", "LvlInfo", ":", "lr", ".", "Logger", ".", "Info", "(", "string", "(", "p", ")", ")", "\n", "case", "log15", ".", "LvlDebug", ":", "lr", ".", "Logger", ".", "Debug", "(", "string", "(", "p", ")", ")", "\n", "case", "log15", ".", "LvlWarn", ":", "lr", ".", "Logger", ".", "Warn", "(", "string", "(", "p", ")", ")", "\n", "case", "log15", ".", "LvlError", ":", "lr", ".", "Logger", ".", "Error", "(", "string", "(", "p", ")", ")", "\n", "case", "log15", ".", "LvlCrit", ":", "lr", ".", "Logger", ".", "Crit", "(", "string", "(", "p", ")", ")", "\n", "}", "\n\n", "return", "\n", "}" ]

[ "Implements", "the", "Write", "of", "the", "logger" ]

[ "func", "(", "h", "*", "CompositeMultiHandler", ")", "SetHandlers", "(", "handler", "LogHandler", ",", "options", "*", "LogOptions", ")", "{", "if", "len", "(", "options", ".", "Levels", ")", "==", "0", "{", "options", ".", "Levels", "=", "LvlAllList", "\n", "}", "\n\n", "// Set all levels", "for", "_", ",", "lvl", ":=", "range", "options", ".", "Levels", "{", "h", ".", "SetHandler", "(", "handler", ",", "options", ".", "ReplaceExistingHandler", ",", "lvl", ")", "\n", "}", "\n\n", "}" ]

[ "For", "the", "multi", "handler", "set", "the", "handler", "using", "the", "LogOptions", "defined" ]

[ "func", "(", "h", "*", "CompositeMultiHandler", ")", "SetJsonFile", "(", "filePath", "string", ",", "options", "*", "LogOptions", ")", "{", "writer", ":=", "&", "lumberjack", ".", "Logger", "{", "Filename", ":", "filePath", ",", "MaxSize", ":", "options", ".", "GetIntDefault", "(", "\"", "\"", ",", "1024", ")", ",", "// megabytes", "MaxAge", ":", "options", ".", "GetIntDefault", "(", "\"", "\"", ",", "7", ")", ",", "//days", "MaxBackups", ":", "options", ".", "GetIntDefault", "(", "\"", "\"", ",", "7", ")", ",", "Compress", ":", "options", ".", "GetBoolDefault", "(", "\"", "\"", ",", "true", ")", ",", "}", "\n", "h", ".", "SetJson", "(", "writer", ",", "options", ")", "\n", "}" ]

[ "Use", "built", "in", "rolling", "function" ]

[ "func", "(", "c", "CompressResponseWriter", ")", "CloseNotify", "(", ")", "<-", "chan", "bool", "{", "if", "c", ".", "parentNotify", "!=", "nil", "{", "return", "c", ".", "parentNotify", "\n", "}", "\n", "return", "c", ".", "closeNotify", "\n", "}" ]

[ "Called", "to", "notify", "the", "writer", "is", "closing" ]

[ "func", "(", "c", "*", "CompressResponseWriter", ")", "prepareHeaders", "(", ")", "{", "if", "c", ".", "compressionType", "!=", "\"", "\"", "{", "responseMime", ":=", "\"", "\"", "\n", "if", "t", ":=", "c", ".", "Header", ".", "Get", "(", "\"", "\"", ")", ";", "len", "(", "t", ")", ">", "0", "{", "responseMime", "=", "t", "[", "0", "]", "\n", "}", "\n", "responseMime", "=", "strings", ".", "TrimSpace", "(", "strings", ".", "SplitN", "(", "responseMime", ",", "\"", "\"", ",", "2", ")", "[", "0", "]", ")", "\n", "shouldEncode", ":=", "false", "\n\n", "if", "len", "(", "c", ".", "Header", ".", "Get", "(", "\"", "\"", ")", ")", "==", "0", "{", "for", "_", ",", "compressableMime", ":=", "range", "compressableMimes", "{", "if", "responseMime", "==", "compressableMime", "{", "shouldEncode", "=", "true", "\n", "c", ".", "Header", ".", "Set", "(", "\"", "\"", ",", "c", ".", "compressionType", ")", "\n", "c", ".", "Header", ".", "Del", "(", "\"", "\"", ")", "\n", "break", "\n", "}", "\n", "}", "\n", "}", "\n\n", "if", "!", "shouldEncode", "{", "c", ".", "compressWriter", "=", "nil", "\n", "c", ".", "compressionType", "=", "\"", "\"", "\n", "}", "\n", "}", "\n", "c", ".", "Header", ".", "Release", "(", ")", "\n", "}" ]

[ "Prepare", "the", "headers" ]

[ "func", "(", "c", "*", "CompressResponseWriter", ")", "WriteHeader", "(", "status", "int", ")", "{", "if", "c", ".", "closed", "{", "return", "\n", "}", "\n", "c", ".", "headersWritten", "=", "true", "\n", "c", ".", "prepareHeaders", "(", ")", "\n", "c", ".", "Header", ".", "SetStatus", "(", "status", ")", "\n", "}" ]

[ "Write", "the", "headers" ]

[ "func", "(", "c", "*", "CompressResponseWriter", ")", "Close", "(", ")", "error", "{", "if", "c", ".", "closed", "{", "return", "nil", "\n", "}", "\n", "if", "!", "c", ".", "headersWritten", "{", "c", ".", "prepareHeaders", "(", ")", "\n", "}", "\n", "if", "c", ".", "compressionType", "!=", "\"", "\"", "{", "c", ".", "Header", ".", "Del", "(", "\"", "\"", ")", "\n", "if", "err", ":=", "c", ".", "compressWriter", ".", "Close", "(", ")", ";", "err", "!=", "nil", "{", "// TODO When writing directly to stream, an error will be generated", "compressLog", ".", "Error", "(", "\"", "\"", ",", "\"", "\"", ",", "c", ".", "compressionType", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "}", "\n", "// Non-blocking write to the closenotifier, if we for some reason should", "// get called multiple times", "select", "{", "case", "c", ".", "closeNotify", "<-", "true", ":", "default", ":", "}", "\n", "c", ".", "closed", "=", "true", "\n", "return", "nil", "\n", "}" ]

[ "Close", "the", "writer" ]

[ "func", "(", "c", "*", "CompressResponseWriter", ")", "Write", "(", "b", "[", "]", "byte", ")", "(", "int", ",", "error", ")", "{", "if", "c", ".", "closed", "{", "return", "0", ",", "io", ".", "ErrClosedPipe", "\n", "}", "\n", "// Abort if parent has been closed", "if", "c", ".", "parentNotify", "!=", "nil", "{", "select", "{", "case", "<-", "c", ".", "parentNotify", ":", "return", "0", ",", "io", ".", "ErrClosedPipe", "\n", "default", ":", "}", "\n", "}", "\n", "// Abort if we ourselves have been closed", "if", "c", ".", "closed", "{", "return", "0", ",", "io", ".", "ErrClosedPipe", "\n", "}", "\n\n", "if", "!", "c", ".", "headersWritten", "{", "c", ".", "prepareHeaders", "(", ")", "\n", "c", ".", "headersWritten", "=", "true", "\n", "}", "\n", "if", "c", ".", "compressionType", "!=", "\"", "\"", "{", "return", "c", ".", "compressWriter", ".", "Write", "(", "b", ")", "\n", "}", "\n", "return", "c", ".", "OriginalWriter", ".", "Write", "(", "b", ")", "\n", "}" ]

[ "Write", "to", "the", "underling", "buffer" ]

[ "func", "detectCompressionType", "(", "req", "*", "Request", ",", "resp", "*", "Response", ")", "(", "found", "bool", ",", "compressionType", "string", ",", "compressionKind", "WriteFlusher", ")", "{", "if", "Config", ".", "BoolDefault", "(", "\"", "\"", ",", "false", ")", "{", "acceptedEncodings", ":=", "strings", ".", "Split", "(", "req", ".", "GetHttpHeader", "(", "\"", "\"", ")", ",", "\"", "\"", ")", "\n\n", "largestQ", ":=", "0.0", "\n", "chosenEncoding", ":=", "len", "(", "compressionTypes", ")", "\n\n", "// I have fixed one edge case for issue #914", "// But it's better to cover all possible edge cases or", "// Adapt to https://github.com/golang/gddo/blob/master/httputil/header/header.go#L172", "for", "_", ",", "encoding", ":=", "range", "acceptedEncodings", "{", "encoding", "=", "strings", ".", "TrimSpace", "(", "encoding", ")", "\n", "encodingParts", ":=", "strings", ".", "SplitN", "(", "encoding", ",", "\"", "\"", ",", "2", ")", "\n\n", "// If we are the format \"gzip;q=0.8\"", "if", "len", "(", "encodingParts", ")", ">", "1", "{", "q", ":=", "strings", ".", "TrimSpace", "(", "encodingParts", "[", "1", "]", ")", "\n", "if", "len", "(", "q", ")", "==", "0", "||", "!", "strings", ".", "HasPrefix", "(", "q", ",", "\"", "\"", ")", "{", "continue", "\n", "}", "\n\n", "// Strip off the q=", "num", ",", "err", ":=", "strconv", ".", "ParseFloat", "(", "q", "[", "2", ":", "]", ",", "32", ")", "\n", "if", "err", "!=", "nil", "{", "continue", "\n", "}", "\n\n", "if", "num", ">=", "largestQ", "&&", "num", ">", "0", "{", "if", "encodingParts", "[", "0", "]", "==", "\"", "\"", "{", "chosenEncoding", "=", "0", "\n", "largestQ", "=", "num", "\n", "continue", "\n", "}", "\n", "for", "i", ",", "encoding", ":=", "range", "compressionTypes", "{", "if", "encoding", "==", "encodingParts", "[", "0", "]", "{", "if", "i", "<", "chosenEncoding", "{", "largestQ", "=", "num", "\n", "chosenEncoding", "=", "i", "\n", "}", "\n", "break", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "else", "{", "// If we can accept anything, chose our preferred method.", "if", "encodingParts", "[", "0", "]", "==", "\"", "\"", "{", "chosenEncoding", "=", "0", "\n", "largestQ", "=", "1", "\n", "break", "\n", "}", "\n", "// This is for just plain \"gzip\"", "for", "i", ",", "encoding", ":=", "range", "compressionTypes", "{", "if", "encoding", "==", "encodingParts", "[", "0", "]", "{", "if", "i", "<", "chosenEncoding", "{", "largestQ", "=", "1.0", "\n", "chosenEncoding", "=", "i", "\n", "}", "\n", "break", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n\n", "if", "largestQ", "==", "0", "{", "return", "\n", "}", "\n\n", "compressionType", "=", "compressionTypes", "[", "chosenEncoding", "]", "\n\n", "switch", "compressionType", "{", "case", "\"", "\"", ":", "compressionKind", "=", "gzip", ".", "NewWriter", "(", "resp", ".", "GetWriter", "(", ")", ")", "\n", "found", "=", "true", "\n", "case", "\"", "\"", ":", "compressionKind", "=", "zlib", ".", "NewWriter", "(", "resp", ".", "GetWriter", "(", ")", ")", "\n", "found", "=", "true", "\n", "}", "\n", "}", "\n", "return", "\n", "}" ]

[ "DetectCompressionType", "method", "detects", "the", "compression", "type", "from", "header", "Accept", "-", "Encoding" ]

[ "func", "NewBufferedServerHeader", "(", "o", "ServerHeader", ")", "*", "BufferedServerHeader", "{", "return", "&", "BufferedServerHeader", "{", "original", ":", "o", ",", "headerMap", ":", "map", "[", "string", "]", "[", "]", "string", "{", "}", "}", "\n", "}" ]

[ "Creates", "a", "new", "instance", "based", "on", "the", "ServerHeader" ]

[ "func", "(", "bsh", "*", "BufferedServerHeader", ")", "Del", "(", "key", "string", ")", "{", "if", "bsh", ".", "released", "{", "bsh", ".", "original", ".", "Del", "(", "key", ")", "\n", "}", "else", "{", "delete", "(", "bsh", ".", "headerMap", ",", "key", ")", "\n", "}", "\n", "}" ]

[ "Delete", "this", "key" ]

[ "func", "(", "bsh", "*", "BufferedServerHeader", ")", "Get", "(", "key", "string", ")", "(", "value", "[", "]", "string", ")", "{", "if", "bsh", ".", "released", "{", "value", "=", "bsh", ".", "original", ".", "Get", "(", "key", ")", "\n", "}", "else", "{", "if", "v", ",", "found", ":=", "bsh", ".", "headerMap", "[", "key", "]", ";", "found", "&&", "len", "(", "v", ")", ">", "0", "{", "value", "=", "v", "\n", "}", "else", "{", "value", "=", "bsh", ".", "original", ".", "Get", "(", "key", ")", "\n", "}", "\n", "}", "\n", "return", "\n", "}" ]

[ "Get", "this", "key" ]

[ "func", "(", "bsh", "*", "BufferedServerHeader", ")", "GetKeys", "(", ")", "(", "value", "[", "]", "string", ")", "{", "if", "bsh", ".", "released", "{", "value", "=", "bsh", ".", "original", ".", "GetKeys", "(", ")", "\n", "}", "else", "{", "value", "=", "bsh", ".", "original", ".", "GetKeys", "(", ")", "\n", "for", "key", ":=", "range", "bsh", ".", "headerMap", "{", "found", ":=", "false", "\n", "for", "_", ",", "v", ":=", "range", "value", "{", "if", "v", "==", "key", "{", "found", "=", "true", "\n", "break", "\n", "}", "\n", "}", "\n", "if", "!", "found", "{", "value", "=", "append", "(", "value", ",", "key", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "\n", "}" ]

[ "Get", "all", "header", "keys" ]

[ "func", "(", "bsh", "*", "BufferedServerHeader", ")", "SetStatus", "(", "statusCode", "int", ")", "{", "if", "bsh", ".", "released", "{", "bsh", ".", "original", ".", "SetStatus", "(", "statusCode", ")", "\n", "}", "else", "{", "bsh", ".", "status", "=", "statusCode", "\n", "}", "\n", "}" ]

[ "Set", "the", "status" ]

[ "func", "(", "bsh", "*", "BufferedServerHeader", ")", "Release", "(", ")", "{", "bsh", ".", "released", "=", "true", "\n", "for", "k", ",", "v", ":=", "range", "bsh", ".", "headerMap", "{", "for", "_", ",", "r", ":=", "range", "v", "{", "bsh", ".", "original", ".", "Set", "(", "k", ",", "r", ")", "\n", "}", "\n", "}", "\n", "for", "_", ",", "c", ":=", "range", "bsh", ".", "cookieList", "{", "bsh", ".", "original", ".", "SetCookie", "(", "c", ")", "\n", "}", "\n", "if", "bsh", ".", "status", ">", "0", "{", "bsh", ".", "original", ".", "SetStatus", "(", "bsh", ".", "status", ")", "\n", "}", "\n", "}" ]

[ "Release", "the", "header", "and", "push", "the", "results", "to", "the", "original" ]

[ "func", "(", "w", "*", "Watcher", ")", "eagerRebuildEnabled", "(", ")", "bool", "{", "return", "Config", ".", "BoolDefault", "(", "\"", "\"", ",", "true", ")", "&&", "Config", ".", "BoolDefault", "(", "\"", "\"", ",", "true", ")", "&&", "Config", ".", "StringDefault", "(", "\"", "\"", ",", "\"", "\"", ")", "==", "\"", "\"", "\n", "}" ]

[ "If", "watch", ".", "mode", "is", "set", "to", "eager", "the", "application", "is", "rebuilt", "immediately", "when", "a", "source", "file", "is", "changed", ".", "This", "feature", "is", "available", "only", "in", "dev", "mode", "." ]

[ "func", "ExecuteTemplate", "(", "tmpl", "ExecutableTemplate", ",", "data", "interface", "{", "}", ")", "string", "{", "var", "b", "bytes", ".", "Buffer", "\n", "if", "err", ":=", "tmpl", ".", "Execute", "(", "&", "b", ",", "data", ")", ";", "err", "!=", "nil", "{", "utilLog", ".", "Error", "(", "\"", "\"", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "b", ".", "String", "(", ")", "\n", "}" ]

[ "ExecuteTemplate", "execute", "a", "template", "and", "returns", "the", "result", "as", "a", "string", "." ]

[ "func", "MustReadLines", "(", "filename", "string", ")", "[", "]", "string", "{", "r", ",", "err", ":=", "ReadLines", "(", "filename", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "return", "r", "\n", "}" ]

[ "MustReadLines", "reads", "the", "lines", "of", "the", "given", "file", ".", "Panics", "in", "the", "case", "of", "error", "." ]

[ "func", "ReadLines", "(", "filename", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "dataBytes", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "filename", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "strings", ".", "Split", "(", "string", "(", "dataBytes", ")", ",", "\"", "\\n", "\"", ")", ",", "nil", "\n", "}" ]

[ "ReadLines", "reads", "the", "lines", "of", "the", "given", "file", ".", "Panics", "in", "the", "case", "of", "error", "." ]

[ "func", "FindMethod", "(", "recvType", "reflect", ".", "Type", ",", "funcVal", "reflect", ".", "Value", ")", "*", "reflect", ".", "Method", "{", "// It is not possible to get the name of the method from the Func.", "// Instead, compare it to each method of the Controller.", "for", "i", ":=", "0", ";", "i", "<", "recvType", ".", "NumMethod", "(", ")", ";", "i", "++", "{", "method", ":=", "recvType", ".", "Method", "(", "i", ")", "\n", "if", "method", ".", "Func", ".", "Pointer", "(", ")", "==", "funcVal", ".", "Pointer", "(", ")", "{", "return", "&", "method", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "FindMethod", "returns", "the", "reflect", ".", "Method", "given", "a", "Receiver", "type", "and", "Func", "value", "." ]

[ "func", "DirExists", "(", "filename", "string", ")", "bool", "{", "fileInfo", ",", "err", ":=", "os", ".", "Stat", "(", "filename", ")", "\n", "return", "err", "==", "nil", "&&", "fileInfo", ".", "IsDir", "(", ")", "\n", "}" ]

[ "DirExists", "returns", "true", "if", "the", "given", "path", "exists", "and", "is", "a", "directory", "." ]

[ "func", "Walk", "(", "root", "string", ",", "walkFn", "filepath", ".", "WalkFunc", ")", "error", "{", "return", "fsWalk", "(", "root", ",", "root", ",", "walkFn", ")", "\n", "}" ]

[ "Walk", "method", "extends", "filepath", ".", "Walk", "to", "also", "follow", "symlinks", ".", "Always", "returns", "the", "path", "of", "the", "file", "or", "directory", "." ]

[ "func", "createDir", "(", "path", "string", ")", "error", "{", "if", "_", ",", "err", ":=", "os", ".", "Stat", "(", "path", ")", ";", "err", "!=", "nil", "{", "if", "os", ".", "IsNotExist", "(", "err", ")", "{", "if", "err", "=", "os", ".", "MkdirAll", "(", "path", ",", "0755", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "path", ",", "err", ")", "\n", "}", "\n", "}", "else", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "path", ",", "err", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "createDir", "method", "creates", "nested", "directories", "if", "not", "exists" ]

[ "func", "AddCommonFlags", "(", "c", "*", "cobra", ".", "Command", ",", "cfg", "*", "api", ".", "Config", ")", "{", "c", ".", "Flags", "(", ")", ".", "BoolVarP", "(", "&", "(", "cfg", ".", "Quiet", ")", ",", "\"", "\"", ",", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n", "c", ".", "Flags", "(", ")", ".", "BoolVar", "(", "&", "(", "cfg", ".", "Incremental", ")", ",", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n", "c", ".", "Flags", "(", ")", ".", "BoolVar", "(", "&", "(", "cfg", ".", "RemovePreviousImage", ")", ",", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n", "c", ".", "Flags", "(", ")", ".", "StringVar", "(", "&", "(", "cfg", ".", "CallbackURL", ")", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "c", ".", "Flags", "(", ")", ".", "VarP", "(", "&", "(", "cfg", ".", "BuilderPullPolicy", ")", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "c", ".", "Flags", "(", ")", ".", "Var", "(", "&", "(", "cfg", ".", "PreviousImagePullPolicy", ")", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "c", ".", "Flags", "(", ")", ".", "Var", "(", "&", "(", "cfg", ".", "RuntimeImagePullPolicy", ")", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "c", ".", "Flags", "(", ")", ".", "BoolVar", "(", "&", "(", "cfg", ".", "PreserveWorkingDir", ")", ",", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n", "c", ".", "Flags", "(", ")", ".", "StringVarP", "(", "&", "(", "cfg", ".", "DockerCfgPath", ")", ",", "\"", "\"", ",", "\"", "\"", ",", "filepath", ".", "Join", "(", "os", ".", "Getenv", "(", "\"", "\"", ")", ",", "\"", "\"", ")", ",", "\"", "\"", ")", "\n", "c", ".", "Flags", "(", ")", ".", "StringVarP", "(", "&", "(", "cfg", ".", "Destination", ")", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "}" ]

[ "AddCommonFlags", "adds", "the", "common", "flags", "for", "usage", "build", "and", "rebuild", "commands" ]

[ "func", "New", "(", "client", "dockerpkg", ".", "Client", ",", "config", "*", "api", ".", "Config", ",", "fs", "fs", ".", "FileSystem", ",", "overrides", "build", ".", "Overrides", ")", "(", "*", "STI", ",", "error", ")", "{", "excludePattern", ",", "err", ":=", "regexp", ".", "Compile", "(", "config", ".", "ExcludeRegExp", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "docker", ":=", "dockerpkg", ".", "New", "(", "client", ",", "config", ".", "PullAuthentication", ")", "\n", "var", "incrementalDocker", "dockerpkg", ".", "Docker", "\n", "if", "config", ".", "Incremental", "{", "incrementalDocker", "=", "dockerpkg", ".", "New", "(", "client", ",", "config", ".", "IncrementalAuthentication", ")", "\n", "}", "\n\n", "inst", ":=", "scripts", ".", "NewInstaller", "(", "config", ".", "BuilderImage", ",", "config", ".", "ScriptsURL", ",", "config", ".", "ScriptDownloadProxyConfig", ",", "docker", ",", "config", ".", "PullAuthentication", ",", "fs", ",", ")", "\n", "tarHandler", ":=", "tar", ".", "NewParanoid", "(", "fs", ")", "\n", "tarHandler", ".", "SetExclusionPattern", "(", "excludePattern", ")", "\n\n", "builder", ":=", "&", "STI", "{", "installer", ":", "inst", ",", "config", ":", "config", ",", "docker", ":", "docker", ",", "incrementalDocker", ":", "incrementalDocker", ",", "git", ":", "git", ".", "New", "(", "fs", ",", "cmd", ".", "NewCommandRunner", "(", ")", ")", ",", "fs", ":", "fs", ",", "tar", ":", "tarHandler", ",", "callbackInvoker", ":", "util", ".", "NewCallbackInvoker", "(", ")", ",", "requiredScripts", ":", "scripts", ".", "RequiredScripts", ",", "optionalScripts", ":", "scripts", ".", "OptionalScripts", ",", "optionalRuntimeScripts", ":", "[", "]", "string", "{", "constants", ".", "AssembleRuntime", "}", ",", "externalScripts", ":", "map", "[", "string", "]", "bool", "{", "}", ",", "installedScripts", ":", "map", "[", "string", "]", "bool", "{", "}", ",", "scriptsURL", ":", "map", "[", "string", "]", "string", "{", "}", ",", "newLabels", ":", "map", "[", "string", "]", "string", "{", "}", ",", "}", "\n\n", "if", "len", "(", "config", ".", "RuntimeImage", ")", ">", "0", "{", "builder", ".", "runtimeDocker", "=", "dockerpkg", ".", "New", "(", "client", ",", "config", ".", "RuntimeAuthentication", ")", "\n\n", "builder", ".", "runtimeInstaller", "=", "scripts", ".", "NewInstaller", "(", "config", ".", "RuntimeImage", ",", "config", ".", "ScriptsURL", ",", "config", ".", "ScriptDownloadProxyConfig", ",", "builder", ".", "runtimeDocker", ",", "config", ".", "RuntimeAuthentication", ",", "builder", ".", "fs", ",", ")", "\n", "}", "\n\n", "// The sources are downloaded using the Git downloader.", "// TODO: Add more SCM in future.", "// TODO: explicit decision made to customize processing for usage specifically vs.", "// leveraging overrides; also, we ultimately want to simplify s2i usage a good bit,", "// which would lead to replacing this quick short circuit (so this change is tactical)", "builder", ".", "source", "=", "overrides", ".", "Downloader", "\n", "if", "builder", ".", "source", "==", "nil", "&&", "!", "config", ".", "Usage", "{", "downloader", ",", "err", ":=", "scm", ".", "DownloaderForSource", "(", "builder", ".", "fs", ",", "config", ".", "Source", ",", "config", ".", "ForceCopy", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "builder", ".", "source", "=", "downloader", "\n", "}", "\n", "builder", ".", "garbage", "=", "build", ".", "NewDefaultCleaner", "(", "builder", ".", "fs", ",", "builder", ".", "docker", ")", "\n\n", "builder", ".", "layered", ",", "err", "=", "layered", ".", "New", "(", "client", ",", "config", ",", "builder", ".", "fs", ",", "builder", ",", "overrides", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Set interfaces", "builder", ".", "preparer", "=", "builder", "\n", "// later on, if we support say .gitignore func in addition to .dockerignore", "// func, setting ignorer will be based on config setting", "builder", ".", "ignorer", "=", "&", "ignore", ".", "DockerIgnorer", "{", "}", "\n", "builder", ".", "artifacts", "=", "builder", "\n", "builder", ".", "scripts", "=", "builder", "\n", "builder", ".", "postExecutor", "=", "builder", "\n", "builder", ".", "initPostExecutorSteps", "(", ")", "\n\n", "return", "builder", ",", "nil", "\n", "}" ]

[ "New", "returns", "the", "instance", "of", "STI", "builder", "strategy", "for", "the", "given", "config", ".", "If", "the", "layeredBuilder", "parameter", "is", "specified", "then", "the", "builder", "provided", "will", "be", "used", "for", "the", "case", "that", "the", "base", "Docker", "image", "does", "not", "have", "tar", "or", "bash", "installed", "." ]

[ "func", "(", "builder", "*", "STI", ")", "SetScripts", "(", "required", ",", "optional", "[", "]", "string", ")", "{", "builder", ".", "requiredScripts", "=", "required", "\n", "builder", ".", "optionalScripts", "=", "optional", "\n", "}" ]

[ "SetScripts", "allows", "to", "override", "default", "required", "and", "optional", "scripts" ]

[ "func", "(", "builder", "*", "STI", ")", "PostExecute", "(", "containerID", ",", "destination", "string", ")", "error", "{", "builder", ".", "postExecutorStepsContext", ".", "containerID", "=", "containerID", "\n", "builder", ".", "postExecutorStepsContext", ".", "destination", "=", "destination", "\n\n", "stageSteps", ":=", "builder", ".", "postExecutorFirstStageSteps", "\n", "if", "builder", ".", "postExecutorStage", ">", "0", "{", "stageSteps", "=", "builder", ".", "postExecutorSecondStageSteps", "\n", "}", "\n\n", "for", "_", ",", "step", ":=", "range", "stageSteps", "{", "if", "err", ":=", "step", ".", "execute", "(", "builder", ".", "postExecutorStepsContext", ")", ";", "err", "!=", "nil", "{", "glog", ".", "V", "(", "0", ")", ".", "Info", "(", "\"", "\"", ")", "\n", "return", "err", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "PostExecute", "allows", "to", "execute", "post", "-", "build", "actions", "after", "the", "Docker", "container", "execution", "finishes", "." ]

[ "func", "CreateBuildEnvironment", "(", "sourcePath", "string", ",", "cfgEnv", "api", ".", "EnvironmentList", ")", "[", "]", "string", "{", "s2iEnv", ",", "err", ":=", "scripts", ".", "GetEnvironment", "(", "filepath", ".", "Join", "(", "sourcePath", ",", "constants", ".", "Source", ")", ")", "\n", "if", "err", "!=", "nil", "{", "glog", ".", "V", "(", "3", ")", ".", "Infof", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "append", "(", "scripts", ".", "ConvertEnvironmentList", "(", "s2iEnv", ")", ",", "scripts", ".", "ConvertEnvironmentList", "(", "cfgEnv", ")", "...", ")", "\n", "}" ]

[ "CreateBuildEnvironment", "constructs", "the", "environment", "variables", "to", "be", "provided", "to", "the", "assemble", "script", "and", "committed", "in", "the", "new", "image", "." ]

[ "func", "(", "builder", "*", "STI", ")", "Exists", "(", "config", "*", "api", ".", "Config", ")", "bool", "{", "if", "!", "config", ".", "Incremental", "{", "return", "false", "\n", "}", "\n\n", "policy", ":=", "config", ".", "PreviousImagePullPolicy", "\n", "if", "len", "(", "policy", ")", "==", "0", "{", "policy", "=", "api", ".", "DefaultPreviousImagePullPolicy", "\n", "}", "\n\n", "tag", ":=", "util", ".", "FirstNonEmpty", "(", "config", ".", "IncrementalFromTag", ",", "config", ".", "Tag", ")", "\n\n", "startTime", ":=", "time", ".", "Now", "(", ")", "\n", "result", ",", "err", ":=", "dockerpkg", ".", "PullImage", "(", "tag", ",", "builder", ".", "incrementalDocker", ",", "policy", ")", "\n", "builder", ".", "result", ".", "BuildInfo", ".", "Stages", "=", "api", ".", "RecordStageAndStepInfo", "(", "builder", ".", "result", ".", "BuildInfo", ".", "Stages", ",", "api", ".", "StagePullImages", ",", "api", ".", "StepPullPreviousImage", ",", "startTime", ",", "time", ".", "Now", "(", ")", ")", "\n\n", "if", "err", "!=", "nil", "{", "builder", ".", "result", ".", "BuildInfo", ".", "FailureReason", "=", "utilstatus", ".", "NewFailureReason", "(", "utilstatus", ".", "ReasonPullPreviousImageFailed", ",", "utilstatus", ".", "ReasonMessagePullPreviousImageFailed", ",", ")", "\n", "glog", ".", "V", "(", "2", ")", ".", "Infof", "(", "\"", "\"", ",", "tag", ",", "err", ")", "\n", "return", "false", "\n", "}", "\n\n", "return", "result", ".", "Image", "!=", "nil", "&&", "builder", ".", "installedScripts", "[", "constants", ".", "SaveArtifacts", "]", "\n", "}" ]

[ "Exists", "determines", "if", "the", "current", "build", "supports", "incremental", "workflow", ".", "It", "checks", "if", "the", "previous", "image", "exists", "in", "the", "system", "and", "if", "so", "then", "it", "verifies", "that", "the", "save", "-", "artifacts", "script", "is", "present", "." ]

[ "func", "(", "builder", "*", "STI", ")", "uploadInjections", "(", "config", "*", "api", ".", "Config", ",", "rmScript", ",", "containerID", "string", ")", "error", "{", "glog", ".", "V", "(", "2", ")", ".", "Info", "(", "\"", "\"", ")", "\n", "for", "_", ",", "s", ":=", "range", "config", ".", "Injections", "{", "if", "err", ":=", "builder", ".", "docker", ".", "UploadToContainer", "(", "builder", ".", "fs", ",", "s", ".", "Source", ",", "s", ".", "Destination", ",", "containerID", ")", ";", "err", "!=", "nil", "{", "return", "util", ".", "HandleInjectionError", "(", "s", ",", "err", ")", "\n", "}", "\n", "}", "\n", "if", "err", ":=", "builder", ".", "docker", ".", "UploadToContainer", "(", "builder", ".", "fs", ",", "rmScript", ",", "rmInjectionsScript", ",", "containerID", ")", ";", "err", "!=", "nil", "{", "return", "util", ".", "HandleInjectionError", "(", "api", ".", "VolumeSpec", "{", "Source", ":", "rmScript", ",", "Destination", ":", "rmInjectionsScript", "}", ",", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "uploadInjections", "uploads", "the", "injected", "volumes", "to", "the", "s2i", "container", "along", "with", "the", "source", "removal", "script", "to", "truncate", "volumes", "that", "should", "not", "be", "kept", "." ]

[ "func", "(", "builder", "*", "STI", ")", "uploadInjectionResult", "(", "startErr", "error", ",", "containerID", "string", ")", "error", "{", "resultFile", ",", "err", ":=", "util", ".", "CreateInjectionResultFile", "(", "startErr", ")", "\n", "if", "len", "(", "resultFile", ")", ">", "0", "{", "defer", "os", ".", "Remove", "(", "resultFile", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "err", "=", "builder", ".", "docker", ".", "UploadToContainer", "(", "builder", ".", "fs", ",", "resultFile", ",", "injectionResultFile", ",", "containerID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "util", ".", "HandleInjectionError", "(", "api", ".", "VolumeSpec", "{", "Source", ":", "resultFile", ",", "Destination", ":", "injectionResultFile", "}", ",", "err", ")", "\n", "}", "\n", "return", "startErr", "\n", "}" ]

[ "uploadInjectionResult", "uploads", "a", "result", "file", "to", "the", "s2i", "container", "indicating", "that", "the", "injections", "have", "completed", ".", "If", "a", "non", "-", "nil", "error", "is", "passed", "in", "it", "is", "returned", "to", "ensure", "the", "error", "status", "of", "the", "injection", "upload", "is", "reported", "." ]

[ "func", "New", "(", "client", "docker", ".", "Client", ",", "config", "*", "api", ".", "Config", ",", "fs", "fs", ".", "FileSystem", ",", "scripts", "build", ".", "ScriptsHandler", ",", "overrides", "build", ".", "Overrides", ")", "(", "*", "Layered", ",", "error", ")", "{", "excludePattern", ",", "err", ":=", "regexp", ".", "Compile", "(", "config", ".", "ExcludeRegExp", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "d", ":=", "docker", ".", "New", "(", "client", ",", "config", ".", "PullAuthentication", ")", "\n", "tarHandler", ":=", "tar", ".", "New", "(", "fs", ")", "\n", "tarHandler", ".", "SetExclusionPattern", "(", "excludePattern", ")", "\n\n", "return", "&", "Layered", "{", "docker", ":", "d", ",", "config", ":", "config", ",", "fs", ":", "fs", ",", "tar", ":", "tarHandler", ",", "scripts", ":", "scripts", ",", "}", ",", "nil", "\n", "}" ]

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

[ "func", "getDestination", "(", "config", "*", "api", ".", "Config", ")", "string", "{", "destination", ":=", "config", ".", "Destination", "\n", "if", "len", "(", "destination", ")", "==", "0", "{", "destination", "=", "defaultDestination", "\n", "}", "\n", "return", "destination", "\n", "}" ]

[ "getDestination", "returns", "the", "destination", "directory", "from", "the", "config", "." ]

[ "func", "checkValidDirWithContents", "(", "name", "string", ")", "bool", "{", "items", ",", "err", ":=", "ioutil", ".", "ReadDir", "(", "name", ")", "\n", "if", "os", ".", "IsNotExist", "(", "err", ")", "{", "glog", ".", "Warningf", "(", "\"", "\"", ",", "name", ",", "err", ")", "\n", "}", "\n", "return", "!", "(", "err", "!=", "nil", "||", "len", "(", "items", ")", "==", "0", ")", "\n", "}" ]

[ "checkValidDirWithContents", "returns", "true", "if", "the", "parameter", "provided", "is", "a", "valid", "accessible", "and", "non", "-", "empty", "directory", "." ]

[ "func", "(", "s", "*", "URLScriptHandler", ")", "Get", "(", "script", "string", ")", "*", "api", ".", "InstallResult", "{", "if", "len", "(", "s", ".", "URL", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n", "scriptURL", ",", "err", ":=", "url", ".", "ParseRequestURI", "(", "s", ".", "URL", "+", "\"", "\"", "+", "script", ")", "\n", "if", "err", "!=", "nil", "{", "glog", ".", "Infof", "(", "\"", "\"", ",", "s", ".", "URL", ",", "err", ")", "\n", "return", "nil", "\n", "}", "\n", "return", "&", "api", ".", "InstallResult", "{", "Script", ":", "script", ",", "URL", ":", "scriptURL", ".", "String", "(", ")", ",", "}", "\n", "}" ]

[ "Get", "parses", "the", "provided", "URL", "and", "the", "script", "name", "." ]

[ "func", "(", "s", "*", "URLScriptHandler", ")", "Install", "(", "r", "*", "api", ".", "InstallResult", ")", "error", "{", "downloadURL", ",", "err", ":=", "url", ".", "Parse", "(", "r", ".", "URL", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "dst", ":=", "filepath", ".", "Join", "(", "s", ".", "DestinationDir", ",", "constants", ".", "UploadScripts", ",", "r", ".", "Script", ")", "\n", "if", "_", ",", "err", ":=", "s", ".", "Download", ".", "Download", "(", "downloadURL", ",", "dst", ")", ";", "err", "!=", "nil", "{", "if", "e", ",", "ok", ":=", "err", ".", "(", "s2ierr", ".", "Error", ")", ";", "ok", "{", "if", "e", ".", "ErrorCode", "==", "s2ierr", ".", "ScriptsInsideImageError", "{", "r", ".", "Installed", "=", "true", "\n", "return", "nil", "\n", "}", "\n", "}", "\n", "return", "err", "\n", "}", "\n", "if", "err", ":=", "s", ".", "FS", ".", "Chmod", "(", "dst", ",", "0755", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "r", ".", "Installed", "=", "true", "\n", "r", ".", "Downloaded", "=", "true", "\n", "return", "nil", "\n", "}" ]

[ "Install", "downloads", "the", "script", "and", "fix", "its", "permissions", "." ]

[ "func", "(", "s", "*", "SourceScriptHandler", ")", "Get", "(", "script", "string", ")", "*", "api", ".", "InstallResult", "{", "location", ":=", "filepath", ".", "Join", "(", "s", ".", "DestinationDir", ",", "constants", ".", "SourceScripts", ",", "script", ")", "\n", "if", "s", ".", "fs", ".", "Exists", "(", "location", ")", "{", "return", "&", "api", ".", "InstallResult", "{", "Script", ":", "script", ",", "URL", ":", "location", "}", "\n", "}", "\n", "// TODO: The '.sti/bin' path inside the source code directory is deprecated", "// and this should (and will) be removed soon.", "location", "=", "filepath", ".", "FromSlash", "(", "strings", ".", "Replace", "(", "filepath", ".", "ToSlash", "(", "location", ")", ",", "\"", "\"", ",", "\"", "\"", ",", "1", ")", ")", "\n", "if", "s", ".", "fs", ".", "Exists", "(", "location", ")", "{", "glog", ".", "Info", "(", "\"", "\"", ")", "\n", "return", "&", "api", ".", "InstallResult", "{", "Script", ":", "script", ",", "URL", ":", "location", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Get", "verifies", "if", "the", "script", "is", "present", "in", "the", "source", "directory", "and", "get", "the", "installation", "result", "." ]

[ "func", "(", "s", "*", "SourceScriptHandler", ")", "Install", "(", "r", "*", "api", ".", "InstallResult", ")", "error", "{", "dst", ":=", "filepath", ".", "Join", "(", "s", ".", "DestinationDir", ",", "constants", ".", "UploadScripts", ",", "r", ".", "Script", ")", "\n", "if", "err", ":=", "s", ".", "fs", ".", "Rename", "(", "r", ".", "URL", ",", "dst", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "err", ":=", "s", ".", "fs", ".", "Chmod", "(", "dst", ",", "0755", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "// Make the path to scripts nicer in logs", "parts", ":=", "strings", ".", "Split", "(", "filepath", ".", "ToSlash", "(", "r", ".", "URL", ")", ",", "\"", "\"", ")", "\n", "if", "len", "(", "parts", ")", ">", "3", "{", "r", ".", "URL", "=", "filepath", ".", "FromSlash", "(", "sourcesRootAbbrev", "+", "\"", "\"", "+", "strings", ".", "Join", "(", "parts", "[", "len", "(", "parts", ")", "-", "3", ":", "]", ",", "\"", "\"", ")", ")", "\n", "}", "\n", "r", ".", "Installed", "=", "true", "\n", "r", ".", "Downloaded", "=", "true", "\n", "return", "nil", "\n", "}" ]

[ "Install", "copies", "the", "script", "into", "upload", "directory", "and", "fix", "its", "permissions", "." ]

[ "func", "(", "m", "*", "DefaultScriptSourceManager", ")", "Add", "(", "s", "ScriptHandler", ")", "{", "if", "len", "(", "m", ".", "sources", ")", "==", "0", "{", "m", ".", "sources", "=", "[", "]", "ScriptHandler", "{", "}", "\n", "}", "\n", "m", ".", "sources", "=", "append", "(", "m", ".", "sources", ",", "s", ")", "\n", "}" ]

[ "Add", "registers", "a", "new", "script", "source", "handler", "." ]

[ "func", "NewInstaller", "(", "image", "string", ",", "scriptsURL", "string", ",", "proxyConfig", "*", "api", ".", "ProxyConfig", ",", "docker", "docker", ".", "Docker", ",", "auth", "api", ".", "AuthConfig", ",", "fs", "fs", ".", "FileSystem", ")", "Installer", "{", "m", ":=", "DefaultScriptSourceManager", "{", "Image", ":", "image", ",", "ScriptsURL", ":", "scriptsURL", ",", "dockerAuth", ":", "auth", ",", "docker", ":", "docker", ",", "fs", ":", "fs", ",", "download", ":", "NewDownloader", "(", "proxyConfig", ")", ",", "}", "\n", "// Order is important here, first we try to get the scripts from provided URL,", "// then we look into sources and check for .s2i/bin scripts.", "if", "len", "(", "m", ".", "ScriptsURL", ")", ">", "0", "{", "m", ".", "Add", "(", "&", "URLScriptHandler", "{", "URL", ":", "m", ".", "ScriptsURL", ",", "Download", ":", "m", ".", "download", ",", "FS", ":", "m", ".", "fs", ",", "Name", ":", "ScriptURLHandler", "}", ")", "\n", "}", "\n\n", "m", ".", "Add", "(", "&", "SourceScriptHandler", "{", "fs", ":", "m", ".", "fs", "}", ")", "\n\n", "if", "m", ".", "docker", "!=", "nil", "{", "// If the detection handlers above fail, try to get the script url from the", "// docker image itself.", "defaultURL", ",", "err", ":=", "m", ".", "docker", ".", "GetScriptsURL", "(", "m", ".", "Image", ")", "\n", "if", "err", "==", "nil", "&&", "defaultURL", "!=", "\"", "\"", "{", "m", ".", "Add", "(", "&", "URLScriptHandler", "{", "URL", ":", "defaultURL", ",", "Download", ":", "m", ".", "download", ",", "FS", ":", "m", ".", "fs", ",", "Name", ":", "ImageURLHandler", "}", ")", "\n", "}", "\n", "}", "\n", "return", "&", "m", "\n", "}" ]

[ "NewInstaller", "returns", "a", "new", "instance", "of", "the", "default", "Installer", "implementation" ]

[ "func", "(", "m", "*", "DefaultScriptSourceManager", ")", "InstallRequired", "(", "scripts", "[", "]", "string", ",", "dstDir", "string", ")", "(", "[", "]", "api", ".", "InstallResult", ",", "error", ")", "{", "result", ":=", "m", ".", "InstallOptional", "(", "scripts", ",", "dstDir", ")", "\n", "failedScripts", ":=", "[", "]", "string", "{", "}", "\n", "var", "err", "error", "\n", "for", "_", ",", "r", ":=", "range", "result", "{", "if", "r", ".", "Error", "!=", "nil", "{", "failedScripts", "=", "append", "(", "failedScripts", ",", "r", ".", "Script", ")", "\n", "}", "\n", "}", "\n", "if", "len", "(", "failedScripts", ")", ">", "0", "{", "err", "=", "s2ierr", ".", "NewInstallRequiredError", "(", "failedScripts", ",", "constants", ".", "ScriptsURLLabel", ")", "\n", "}", "\n", "return", "result", ",", "err", "\n", "}" ]

[ "InstallRequired", "Downloads", "and", "installs", "required", "scripts", "into", "dstDir", "the", "result", "is", "a", "map", "of", "scripts", "with", "detailed", "information", "about", "each", "of", "the", "scripts", "install", "process", "with", "error", "if", "installing", "some", "of", "them", "failed" ]

[ "func", "(", "m", "*", "DefaultScriptSourceManager", ")", "InstallOptional", "(", "scripts", "[", "]", "string", ",", "dstDir", "string", ")", "[", "]", "api", ".", "InstallResult", "{", "result", ":=", "[", "]", "api", ".", "InstallResult", "{", "}", "\n", "for", "_", ",", "script", ":=", "range", "scripts", "{", "installed", ":=", "false", "\n", "failedSources", ":=", "[", "]", "string", "{", "}", "\n", "for", "_", ",", "e", ":=", "range", "m", ".", "sources", "{", "detected", ":=", "false", "\n", "h", ":=", "e", ".", "(", "ScriptHandler", ")", "\n", "h", ".", "SetDestinationDir", "(", "dstDir", ")", "\n", "if", "r", ":=", "h", ".", "Get", "(", "script", ")", ";", "r", "!=", "nil", "{", "if", "err", ":=", "h", ".", "Install", "(", "r", ")", ";", "err", "!=", "nil", "{", "failedSources", "=", "append", "(", "failedSources", ",", "h", ".", "String", "(", ")", ")", "\n", "// all this means is this source didn't have this particular script", "glog", ".", "V", "(", "4", ")", ".", "Infof", "(", "\"", "\"", ",", "script", ",", "h", ",", "err", ")", "\n", "}", "else", "{", "r", ".", "FailedSources", "=", "failedSources", "\n", "result", "=", "append", "(", "result", ",", "*", "r", ")", "\n", "installed", "=", "true", "\n", "detected", "=", "true", "\n", "glog", ".", "V", "(", "4", ")", ".", "Infof", "(", "\"", "\"", ",", "script", ",", "r", ".", "URL", ")", "\n", "}", "\n", "}", "\n", "if", "detected", "{", "break", "\n", "}", "\n", "}", "\n", "if", "!", "installed", "{", "result", "=", "append", "(", "result", ",", "api", ".", "InstallResult", "{", "FailedSources", ":", "failedSources", ",", "Script", ":", "script", ",", "Error", ":", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "script", ")", ",", "}", ")", "\n", "}", "\n", "}", "\n", "return", "result", "\n", "}" ]

[ "InstallOptional", "downloads", "and", "installs", "a", "set", "of", "scripts", "into", "dstDir", "the", "result", "is", "a", "map", "of", "scripts", "with", "detailed", "information", "about", "each", "of", "the", "scripts", "install", "process" ]

[ "func", "(", "c", "*", "Clone", ")", "Download", "(", "config", "*", "api", ".", "Config", ")", "(", "*", "git", ".", "SourceInfo", ",", "error", ")", "{", "targetSourceDir", ":=", "filepath", ".", "Join", "(", "config", ".", "WorkingDir", ",", "constants", ".", "Source", ")", "\n", "config", ".", "WorkingSourceDir", "=", "targetSourceDir", "\n\n", "ref", ":=", "config", ".", "Source", ".", "URL", ".", "Fragment", "\n", "if", "ref", "==", "\"", "\"", "{", "ref", "=", "\"", "\"", "\n", "}", "\n\n", "if", "len", "(", "config", ".", "ContextDir", ")", ">", "0", "{", "targetSourceDir", "=", "filepath", ".", "Join", "(", "config", ".", "WorkingDir", ",", "constants", ".", "ContextTmp", ")", "\n", "glog", ".", "V", "(", "1", ")", ".", "Infof", "(", "\"", "\"", ",", "config", ".", "Source", ",", "config", ".", "ContextDir", ")", "\n", "}", "else", "{", "glog", ".", "V", "(", "1", ")", ".", "Infof", "(", "\"", "\"", ",", "config", ".", "Source", ")", "\n", "}", "\n\n", "if", "!", "config", ".", "IgnoreSubmodules", "{", "glog", ".", "V", "(", "2", ")", ".", "Infof", "(", "\"", "\"", ",", "targetSourceDir", ")", "\n", "}", "else", "{", "glog", ".", "V", "(", "2", ")", ".", "Infof", "(", "\"", "\"", ",", "targetSourceDir", ")", "\n", "}", "\n\n", "cloneConfig", ":=", "git", ".", "CloneConfig", "{", "Quiet", ":", "true", "}", "\n", "err", ":=", "c", ".", "Clone", "(", "config", ".", "Source", ",", "targetSourceDir", ",", "cloneConfig", ")", "\n", "if", "err", "!=", "nil", "{", "glog", ".", "V", "(", "0", ")", ".", "Infof", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "err", "=", "c", ".", "Checkout", "(", "targetSourceDir", ",", "ref", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "glog", ".", "V", "(", "1", ")", ".", "Infof", "(", "\"", "\"", ",", "ref", ")", "\n", "if", "!", "config", ".", "IgnoreSubmodules", "{", "err", "=", "c", ".", "SubmoduleUpdate", "(", "targetSourceDir", ",", "true", ",", "true", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "glog", ".", "V", "(", "1", ")", ".", "Infof", "(", "\"", "\"", ",", "ref", ")", "\n", "}", "\n\n", "// Record Git's knowledge about file permissions", "if", "runtime", ".", "GOOS", "==", "\"", "\"", "{", "filemodes", ",", "err", ":=", "c", ".", "LsTree", "(", "filepath", ".", "Join", "(", "targetSourceDir", ",", "config", ".", "ContextDir", ")", ",", "ref", ",", "true", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "for", "_", ",", "filemode", ":=", "range", "filemodes", "{", "c", ".", "Chmod", "(", "filepath", ".", "Join", "(", "targetSourceDir", ",", "config", ".", "ContextDir", ",", "filemode", ".", "Name", "(", ")", ")", ",", "os", ".", "FileMode", "(", "filemode", ".", "Mode", "(", ")", ")", "&", "os", ".", "ModePerm", ")", "\n", "}", "\n", "}", "\n\n", "info", ":=", "c", ".", "GetInfo", "(", "targetSourceDir", ")", "\n", "if", "len", "(", "config", ".", "ContextDir", ")", ">", "0", "{", "originalTargetDir", ":=", "filepath", ".", "Join", "(", "config", ".", "WorkingDir", ",", "constants", ".", "Source", ")", "\n", "c", ".", "RemoveDirectory", "(", "originalTargetDir", ")", "\n", "path", ":=", "filepath", ".", "Join", "(", "targetSourceDir", ",", "config", ".", "ContextDir", ")", "\n", "err", ":=", "c", ".", "CopyContents", "(", "path", ",", "originalTargetDir", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "c", ".", "RemoveDirectory", "(", "targetSourceDir", ")", "\n", "}", "\n\n", "if", "len", "(", "config", ".", "ContextDir", ")", ">", "0", "{", "info", ".", "ContextDir", "=", "config", ".", "ContextDir", "\n", "}", "\n\n", "return", "info", ",", "nil", "\n", "}" ]

[ "Download", "downloads", "the", "application", "source", "code", "from", "the", "Git", "repository", "and", "checkout", "the", "Ref", "specified", "in", "the", "config", "." ]

[ "func", "Strategy", "(", "client", "docker", ".", "Client", ",", "config", "*", "api", ".", "Config", ",", "overrides", "build", ".", "Overrides", ")", "(", "build", ".", "Builder", ",", "api", ".", "BuildInfo", ",", "error", ")", "{", "var", "builder", "build", ".", "Builder", "\n", "var", "buildInfo", "api", ".", "BuildInfo", "\n", "var", "err", "error", "\n\n", "fileSystem", ":=", "fs", ".", "NewFileSystem", "(", ")", "\n\n", "startTime", ":=", "time", ".", "Now", "(", ")", "\n\n", "if", "len", "(", "config", ".", "AsDockerfile", ")", "!=", "0", "{", "builder", ",", "err", "=", "dockerfile", ".", "New", "(", "config", ",", "fileSystem", ")", "\n", "if", "err", "!=", "nil", "{", "buildInfo", ".", "FailureReason", "=", "utilstatus", ".", "NewFailureReason", "(", "utilstatus", ".", "ReasonGenericS2IBuildFailed", ",", "utilstatus", ".", "ReasonMessageGenericS2iBuildFailed", ",", ")", "\n", "return", "nil", ",", "buildInfo", ",", "err", "\n", "}", "\n", "return", "builder", ",", "buildInfo", ",", "nil", "\n", "}", "\n\n", "dkr", ":=", "docker", ".", "New", "(", "client", ",", "config", ".", "PullAuthentication", ")", "\n", "image", ",", "err", ":=", "docker", ".", "GetBuilderImage", "(", "dkr", ",", "config", ")", "\n", "buildInfo", ".", "Stages", "=", "api", ".", "RecordStageAndStepInfo", "(", "buildInfo", ".", "Stages", ",", "api", ".", "StagePullImages", ",", "api", ".", "StepPullBuilderImage", ",", "startTime", ",", "time", ".", "Now", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "buildInfo", ".", "FailureReason", "=", "utilstatus", ".", "NewFailureReason", "(", "utilstatus", ".", "ReasonPullBuilderImageFailed", ",", "utilstatus", ".", "ReasonMessagePullBuilderImageFailed", ",", ")", "\n", "return", "nil", ",", "buildInfo", ",", "err", "\n", "}", "\n", "config", ".", "HasOnBuild", "=", "image", ".", "OnBuild", "\n\n", "if", "config", ".", "AssembleUser", ",", "err", "=", "docker", ".", "GetAssembleUser", "(", "dkr", ",", "config", ")", ";", "err", "!=", "nil", "{", "buildInfo", ".", "FailureReason", "=", "utilstatus", ".", "NewFailureReason", "(", "utilstatus", ".", "ReasonPullBuilderImageFailed", ",", "utilstatus", ".", "ReasonMessagePullBuilderImageFailed", ",", ")", "\n", "return", "nil", ",", "buildInfo", ",", "err", "\n", "}", "\n\n", "// if we're blocking onbuild, just do a normal s2i build flow", "// which won't do a docker build and invoke the onbuild commands", "if", "image", ".", "OnBuild", "&&", "!", "config", ".", "BlockOnBuild", "{", "builder", ",", "err", "=", "onbuild", ".", "New", "(", "client", ",", "config", ",", "fileSystem", ",", "overrides", ")", "\n", "if", "err", "!=", "nil", "{", "buildInfo", ".", "FailureReason", "=", "utilstatus", ".", "NewFailureReason", "(", "utilstatus", ".", "ReasonGenericS2IBuildFailed", ",", "utilstatus", ".", "ReasonMessageGenericS2iBuildFailed", ",", ")", "\n", "return", "nil", ",", "buildInfo", ",", "err", "\n", "}", "\n", "return", "builder", ",", "buildInfo", ",", "nil", "\n", "}", "\n\n", "builder", ",", "err", "=", "sti", ".", "New", "(", "client", ",", "config", ",", "fileSystem", ",", "overrides", ")", "\n", "if", "err", "!=", "nil", "{", "buildInfo", ".", "FailureReason", "=", "utilstatus", ".", "NewFailureReason", "(", "utilstatus", ".", "ReasonGenericS2IBuildFailed", ",", "utilstatus", ".", "ReasonMessageGenericS2iBuildFailed", ",", ")", "\n", "return", "nil", ",", "buildInfo", ",", "err", "\n", "}", "\n", "return", "builder", ",", "buildInfo", ",", "err", "\n", "}" ]

[ "Strategy", "creates", "the", "appropriate", "build", "strategy", "for", "the", "provided", "config", "using", "the", "overrides", "provided", ".", "Not", "all", "strategies", "support", "all", "overrides", "." ]

[ "func", "New", "(", "client", "docker", ".", "Client", ",", "config", "*", "api", ".", "Config", ")", "*", "DockerRunner", "{", "d", ":=", "docker", ".", "New", "(", "client", ",", "config", ".", "PullAuthentication", ")", "\n", "return", "&", "DockerRunner", "{", "d", "}", "\n", "}" ]

[ "New", "creates", "a", "DockerRunner", "for", "executing", "the", "methods", "associated", "with", "running", "the", "produced", "image", "in", "a", "docker", "container", "for", "verification", "purposes", "." ]

[ "func", "(", "b", "*", "DockerRunner", ")", "Run", "(", "config", "*", "api", ".", "Config", ")", "error", "{", "glog", ".", "V", "(", "4", ")", ".", "Infof", "(", "\"", "\\n", "\"", ",", "config", ".", "Tag", ")", "\n\n", "outReader", ",", "outWriter", ":=", "io", ".", "Pipe", "(", ")", "\n", "errReader", ",", "errWriter", ":=", "io", ".", "Pipe", "(", ")", "\n\n", "opts", ":=", "docker", ".", "RunContainerOptions", "{", "Image", ":", "config", ".", "Tag", ",", "Stdout", ":", "outWriter", ",", "Stderr", ":", "errWriter", ",", "TargetImage", ":", "true", ",", "CGroupLimits", ":", "config", ".", "CGroupLimits", ",", "CapDrop", ":", "config", ".", "DropCapabilities", ",", "}", "\n\n", "docker", ".", "StreamContainerIO", "(", "errReader", ",", "nil", ",", "func", "(", "s", "string", ")", "{", "glog", ".", "Error", "(", "s", ")", "}", ")", "\n", "docker", ".", "StreamContainerIO", "(", "outReader", ",", "nil", ",", "func", "(", "s", "string", ")", "{", "glog", ".", "Info", "(", "s", ")", "}", ")", "\n\n", "err", ":=", "b", ".", "ContainerClient", ".", "RunContainer", "(", "opts", ")", "\n", "// If we get a ContainerError, the original message reports the", "// container name. The container is temporary and its name is", "// meaningless, therefore we make the error message more helpful by", "// replacing the container name with the image tag.", "if", "e", ",", "ok", ":=", "err", ".", "(", "s2ierr", ".", "ContainerError", ")", ";", "ok", "{", "return", "s2ierr", ".", "NewContainerError", "(", "config", ".", "Tag", ",", "e", ".", "ErrorCode", ",", "e", ".", "Output", ")", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "Run", "invokes", "the", "Docker", "API", "to", "run", "the", "image", "defined", "in", "config", "as", "a", "new", "container", ".", "The", "container", "s", "stdout", "and", "stderr", "will", "be", "logged", "with", "glog", "." ]

[ "func", "NewUsage", "(", "client", "docker", ".", "Client", ",", "config", "*", "api", ".", "Config", ")", "(", "*", "Usage", ",", "error", ")", "{", "b", ",", "err", ":=", "New", "(", "client", ",", "config", ",", "fs", ".", "NewFileSystem", "(", ")", ",", "build", ".", "Overrides", "{", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "usage", ":=", "Usage", "{", "handler", ":", "b", ",", "config", ":", "config", ",", "garbage", ":", "b", ".", "garbage", ",", "}", "\n", "return", "&", "usage", ",", "nil", "\n", "}" ]

[ "NewUsage", "creates", "a", "new", "instance", "of", "the", "default", "Usage", "implementation" ]

[ "func", "(", "u", "*", "Usage", ")", "Show", "(", ")", "error", "{", "b", ":=", "u", ".", "handler", "\n", "defer", "u", ".", "garbage", ".", "Cleanup", "(", "u", ".", "config", ")", "\n\n", "b", ".", "SetScripts", "(", "[", "]", "string", "{", "constants", ".", "Usage", "}", ",", "[", "]", "string", "{", "}", ")", "\n\n", "if", "err", ":=", "b", ".", "Prepare", "(", "u", ".", "config", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "b", ".", "Execute", "(", "constants", ".", "Usage", ",", "\"", "\"", ",", "u", ".", "config", ")", "\n", "}" ]

[ "Show", "starts", "the", "builder", "container", "and", "invokes", "the", "usage", "script", "on", "it", "to", "print", "usage", "information", "for", "the", "script", "." ]

[ "func", "New", "(", "client", "docker", ".", "Client", ",", "config", "*", "api", ".", "Config", ",", "fs", "fs", ".", "FileSystem", ",", "overrides", "build", ".", "Overrides", ")", "(", "*", "OnBuild", ",", "error", ")", "{", "dockerHandler", ":=", "docker", ".", "New", "(", "client", ",", "config", ".", "PullAuthentication", ")", "\n", "builder", ":=", "&", "OnBuild", "{", "docker", ":", "dockerHandler", ",", "git", ":", "git", ".", "New", "(", "fs", ",", "cmd", ".", "NewCommandRunner", "(", ")", ")", ",", "fs", ":", "fs", ",", "tar", ":", "tar", ".", "New", "(", "fs", ")", ",", "}", "\n", "// Use STI Prepare() and download the 'run' script optionally.", "s", ",", "err", ":=", "sti", ".", "New", "(", "client", ",", "config", ",", "fs", ",", "overrides", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "s", ".", "SetScripts", "(", "[", "]", "string", "{", "}", ",", "[", "]", "string", "{", "constants", ".", "Assemble", ",", "constants", ".", "Run", "}", ")", "\n\n", "downloader", ":=", "overrides", ".", "Downloader", "\n", "if", "downloader", "==", "nil", "{", "downloader", ",", "err", "=", "scm", ".", "DownloaderForSource", "(", "builder", ".", "fs", ",", "config", ".", "Source", ",", "config", ".", "ForceCopy", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "builder", ".", "source", "=", "onBuildSourceHandler", "{", "Downloader", ":", "downloader", ",", "Preparer", ":", "s", ",", "Ignorer", ":", "&", "ignore", ".", "DockerIgnorer", "{", "}", ",", "}", "\n\n", "builder", ".", "garbage", "=", "build", ".", "NewDefaultCleaner", "(", "builder", ".", "fs", ",", "builder", ".", "docker", ")", "\n", "return", "builder", ",", "nil", "\n", "}" ]

[ "New", "returns", "a", "new", "instance", "of", "OnBuild", "builder" ]

[ "func", "(", "builder", "*", "OnBuild", ")", "Build", "(", "config", "*", "api", ".", "Config", ")", "(", "*", "api", ".", "Result", ",", "error", ")", "{", "buildResult", ":=", "&", "api", ".", "Result", "{", "}", "\n\n", "if", "config", ".", "BlockOnBuild", "{", "buildResult", ".", "BuildInfo", ".", "FailureReason", "=", "utilstatus", ".", "NewFailureReason", "(", "utilstatus", ".", "ReasonOnBuildForbidden", ",", "utilstatus", ".", "ReasonMessageOnBuildForbidden", ",", ")", "\n", "return", "buildResult", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "glog", ".", "V", "(", "2", ")", ".", "Info", "(", "\"", "\"", ")", "\n", "// Change the installation directory for this config to store scripts inside", "// the application root directory.", "if", "err", ":=", "builder", ".", "source", ".", "Prepare", "(", "config", ")", ";", "err", "!=", "nil", "{", "return", "buildResult", ",", "err", "\n", "}", "\n\n", "// If necessary, copy the STI scripts into application root directory", "builder", ".", "copySTIScripts", "(", "config", ")", "\n\n", "glog", ".", "V", "(", "2", ")", ".", "Info", "(", "\"", "\"", ")", "\n", "if", "err", ":=", "builder", ".", "CreateDockerfile", "(", "config", ")", ";", "err", "!=", "nil", "{", "buildResult", ".", "BuildInfo", ".", "FailureReason", "=", "utilstatus", ".", "NewFailureReason", "(", "utilstatus", ".", "ReasonDockerfileCreateFailed", ",", "utilstatus", ".", "ReasonMessageDockerfileCreateFailed", ",", ")", "\n", "return", "buildResult", ",", "err", "\n", "}", "\n\n", "glog", ".", "V", "(", "2", ")", ".", "Info", "(", "\"", "\"", ")", "\n", "tarStream", ":=", "builder", ".", "tar", ".", "CreateTarStreamReader", "(", "filepath", ".", "Join", "(", "config", ".", "WorkingDir", ",", "\"", "\"", ",", "\"", "\"", ")", ",", "false", ")", "\n", "defer", "tarStream", ".", "Close", "(", ")", "\n\n", "outReader", ",", "outWriter", ":=", "io", ".", "Pipe", "(", ")", "\n", "go", "io", ".", "Copy", "(", "os", ".", "Stdout", ",", "outReader", ")", "\n\n", "opts", ":=", "docker", ".", "BuildImageOptions", "{", "Name", ":", "config", ".", "Tag", ",", "Stdin", ":", "tarStream", ",", "Stdout", ":", "outWriter", ",", "CGroupLimits", ":", "config", ".", "CGroupLimits", ",", "}", "\n\n", "glog", ".", "V", "(", "2", ")", ".", "Info", "(", "\"", "\"", ")", "\n", "if", "err", ":=", "builder", ".", "docker", ".", "BuildImage", "(", "opts", ")", ";", "err", "!=", "nil", "{", "buildResult", ".", "BuildInfo", ".", "FailureReason", "=", "utilstatus", ".", "NewFailureReason", "(", "utilstatus", ".", "ReasonDockerImageBuildFailed", ",", "utilstatus", ".", "ReasonMessageDockerImageBuildFailed", ",", ")", "\n", "return", "buildResult", ",", "err", "\n", "}", "\n\n", "glog", ".", "V", "(", "2", ")", ".", "Info", "(", "\"", "\"", ")", "\n", "builder", ".", "garbage", ".", "Cleanup", "(", "config", ")", "\n\n", "var", "imageID", "string", "\n", "var", "err", "error", "\n", "if", "len", "(", "opts", ".", "Name", ")", ">", "0", "{", "if", "imageID", ",", "err", "=", "builder", ".", "docker", ".", "GetImageID", "(", "opts", ".", "Name", ")", ";", "err", "!=", "nil", "{", "buildResult", ".", "BuildInfo", ".", "FailureReason", "=", "utilstatus", ".", "NewFailureReason", "(", "utilstatus", ".", "ReasonGenericS2IBuildFailed", ",", "utilstatus", ".", "ReasonMessageGenericS2iBuildFailed", ",", ")", "\n", "return", "buildResult", ",", "err", "\n", "}", "\n", "}", "\n\n", "return", "&", "api", ".", "Result", "{", "Success", ":", "true", ",", "WorkingDir", ":", "config", ".", "WorkingDir", ",", "ImageID", ":", "imageID", ",", "}", ",", "nil", "\n", "}" ]

[ "Build", "executes", "the", "ONBUILD", "kind", "of", "build" ]

[ "func", "(", "builder", "*", "OnBuild", ")", "CreateDockerfile", "(", "config", "*", "api", ".", "Config", ")", "error", "{", "buffer", ":=", "bytes", ".", "Buffer", "{", "}", "\n", "uploadDir", ":=", "filepath", ".", "Join", "(", "config", ".", "WorkingDir", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "buffer", ".", "WriteString", "(", "fmt", ".", "Sprintf", "(", "\"", "\\n", "\"", ",", "config", ".", "BuilderImage", ")", ")", "\n", "entrypoint", ",", "err", ":=", "GuessEntrypoint", "(", "builder", ".", "fs", ",", "uploadDir", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "env", ",", "err", ":=", "scripts", ".", "GetEnvironment", "(", "filepath", ".", "Join", "(", "config", ".", "WorkingDir", ",", "constants", ".", "Source", ")", ")", "\n", "if", "err", "!=", "nil", "{", "glog", ".", "V", "(", "1", ")", ".", "Infof", "(", "\"", "\"", ",", "err", ")", "\n", "}", "else", "{", "buffer", ".", "WriteString", "(", "scripts", ".", "ConvertEnvironmentToDocker", "(", "env", ")", ")", "\n", "}", "\n", "// If there is an assemble script present, run it as part of the build process", "// as the last thing.", "if", "builder", ".", "hasAssembleScript", "(", "config", ")", "{", "buffer", ".", "WriteString", "(", "\"", "\\n", "\"", ")", "\n", "}", "\n", "// FIXME: This assumes that the WORKDIR is set to the application source root", "// directory.", "buffer", ".", "WriteString", "(", "fmt", ".", "Sprintf", "(", "`ENTRYPOINT [\"./%s\"]`", "+", "\"", "\\n", "\"", ",", "entrypoint", ")", ")", "\n", "return", "builder", ".", "fs", ".", "WriteFile", "(", "filepath", ".", "Join", "(", "uploadDir", ",", "\"", "\"", ")", ",", "buffer", ".", "Bytes", "(", ")", ")", "\n", "}" ]

[ "CreateDockerfile", "creates", "the", "ONBUILD", "Dockerfile" ]

[ "func", "(", "builder", "*", "OnBuild", ")", "hasAssembleScript", "(", "config", "*", "api", ".", "Config", ")", "bool", "{", "assemblePath", ":=", "filepath", ".", "Join", "(", "config", ".", "WorkingDir", ",", "\"", "\"", ",", "\"", "\"", ",", "constants", ".", "Assemble", ")", "\n", "_", ",", "err", ":=", "builder", ".", "fs", ".", "Stat", "(", "assemblePath", ")", "\n", "return", "err", "==", "nil", "\n", "}" ]

[ "hasAssembleScript", "checks", "if", "the", "the", "assemble", "script", "is", "available" ]

[ "func", "NewCmdUsage", "(", "cfg", "*", "api", ".", "Config", ")", "*", "cobra", ".", "Command", "{", "oldScriptsFlag", ":=", "\"", "\"", "\n", "oldDestination", ":=", "\"", "\"", "\n\n", "usageCmd", ":=", "&", "cobra", ".", "Command", "{", "Use", ":", "\"", "\"", ",", "Short", ":", "\"", "\"", ",", "Long", ":", "\"", "\"", ",", "Run", ":", "func", "(", "cmd", "*", "cobra", ".", "Command", ",", "args", "[", "]", "string", ")", "{", "if", "len", "(", "args", ")", "==", "0", "{", "cmd", ".", "Help", "(", ")", "\n", "return", "\n", "}", "\n\n", "cfg", ".", "Usage", "=", "true", "\n", "cfg", ".", "BuilderImage", "=", "args", "[", "0", "]", "\n\n", "if", "len", "(", "oldScriptsFlag", ")", "!=", "0", "{", "glog", ".", "Warning", "(", "\"", "\"", ")", "\n", "cfg", ".", "ScriptsURL", "=", "oldScriptsFlag", "\n", "}", "\n\n", "if", "len", "(", "cfg", ".", "BuilderPullPolicy", ")", "==", "0", "{", "cfg", ".", "BuilderPullPolicy", "=", "api", ".", "DefaultBuilderPullPolicy", "\n", "}", "\n", "if", "len", "(", "cfg", ".", "PreviousImagePullPolicy", ")", "==", "0", "{", "cfg", ".", "PreviousImagePullPolicy", "=", "api", ".", "DefaultPreviousImagePullPolicy", "\n", "}", "\n\n", "client", ",", "err", ":=", "docker", ".", "NewEngineAPIClient", "(", "cfg", ".", "DockerConfig", ")", "\n", "s2ierr", ".", "CheckError", "(", "err", ")", "\n", "uh", ",", "err", ":=", "sti", ".", "NewUsage", "(", "client", ",", "cfg", ")", "\n", "s2ierr", ".", "CheckError", "(", "err", ")", "\n", "err", "=", "uh", ".", "Show", "(", ")", "\n", "s2ierr", ".", "CheckError", "(", "err", ")", "\n", "}", ",", "}", "\n", "usageCmd", ".", "Flags", "(", ")", ".", "StringVarP", "(", "&", "(", "oldDestination", ")", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "cmdutil", ".", "AddCommonFlags", "(", "usageCmd", ",", "cfg", ")", "\n", "return", "usageCmd", "\n", "}" ]

[ "NewCmdUsage", "implements", "the", "S2I", "cli", "usage", "command", "." ]

[ "func", "(", "d", "stiDocker", ")", "InspectImage", "(", "name", "string", ")", "(", "*", "dockertypes", ".", "ImageInspect", ",", "error", ")", "{", "ctx", ",", "cancel", ":=", "getDefaultContext", "(", ")", "\n", "defer", "cancel", "(", ")", "\n", "resp", ",", "_", ",", "err", ":=", "d", ".", "client", ".", "ImageInspectWithRaw", "(", "ctx", ",", "name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "resp", ",", "nil", "\n", "}" ]

[ "InspectImage", "returns", "the", "image", "information", "and", "its", "raw", "representation", "." ]

[ "func", "(", "rco", "RunContainerOptions", ")", "asDockerConfig", "(", ")", "dockercontainer", ".", "Config", "{", "return", "dockercontainer", ".", "Config", "{", "Image", ":", "getImageName", "(", "rco", ".", "Image", ")", ",", "User", ":", "rco", ".", "User", ",", "Env", ":", "rco", ".", "Env", ",", "Entrypoint", ":", "rco", ".", "Entrypoint", ",", "OpenStdin", ":", "rco", ".", "Stdin", "!=", "nil", ",", "StdinOnce", ":", "rco", ".", "Stdin", "!=", "nil", ",", "AttachStdout", ":", "rco", ".", "Stdout", "!=", "nil", ",", "}", "\n", "}" ]

[ "asDockerConfig", "converts", "a", "RunContainerOptions", "into", "a", "Config", "understood", "by", "the", "docker", "client" ]

[ "func", "(", "rco", "RunContainerOptions", ")", "asDockerHostConfig", "(", ")", "dockercontainer", ".", "HostConfig", "{", "hostConfig", ":=", "dockercontainer", ".", "HostConfig", "{", "CapDrop", ":", "rco", ".", "CapDrop", ",", "PublishAllPorts", ":", "rco", ".", "TargetImage", ",", "NetworkMode", ":", "dockercontainer", ".", "NetworkMode", "(", "rco", ".", "NetworkMode", ")", ",", "Binds", ":", "rco", ".", "Binds", ",", "ExtraHosts", ":", "rco", ".", "AddHost", ",", "SecurityOpt", ":", "rco", ".", "SecurityOpt", ",", "}", "\n", "if", "rco", ".", "CGroupLimits", "!=", "nil", "{", "hostConfig", ".", "Resources", ".", "Memory", "=", "rco", ".", "CGroupLimits", ".", "MemoryLimitBytes", "\n", "hostConfig", ".", "Resources", ".", "MemorySwap", "=", "rco", ".", "CGroupLimits", ".", "MemorySwap", "\n", "hostConfig", ".", "Resources", ".", "CgroupParent", "=", "rco", ".", "CGroupLimits", ".", "Parent", "\n", "}", "\n", "return", "hostConfig", "\n", "}" ]

[ "asDockerHostConfig", "converts", "a", "RunContainerOptions", "into", "a", "HostConfig", "understood", "by", "the", "docker", "client" ]

[ "func", "(", "rco", "RunContainerOptions", ")", "asDockerCreateContainerOptions", "(", ")", "dockertypes", ".", "ContainerCreateConfig", "{", "config", ":=", "rco", ".", "asDockerConfig", "(", ")", "\n", "hostConfig", ":=", "rco", ".", "asDockerHostConfig", "(", ")", "\n", "return", "dockertypes", ".", "ContainerCreateConfig", "{", "Name", ":", "containerName", "(", "rco", ".", "Image", ")", ",", "Config", ":", "&", "config", ",", "HostConfig", ":", "&", "hostConfig", ",", "}", "\n", "}" ]

[ "asDockerCreateContainerOptions", "converts", "a", "RunContainerOptions", "into", "a", "ContainerCreateConfig", "understood", "by", "the", "docker", "client" ]

[ "func", "(", "rco", "RunContainerOptions", ")", "asDockerAttachToContainerOptions", "(", ")", "dockertypes", ".", "ContainerAttachOptions", "{", "return", "dockertypes", ".", "ContainerAttachOptions", "{", "Stdin", ":", "rco", ".", "Stdin", "!=", "nil", ",", "Stdout", ":", "rco", ".", "Stdout", "!=", "nil", ",", "Stderr", ":", "rco", ".", "Stderr", "!=", "nil", ",", "Stream", ":", "rco", ".", "Stdout", "!=", "nil", ",", "}", "\n", "}" ]

[ "asDockerAttachToContainerOptions", "converts", "a", "RunContainerOptions", "into", "a", "ContainerAttachOptions", "understood", "by", "the", "docker", "client" ]

[ "func", "NewEngineAPIClient", "(", "config", "*", "api", ".", "DockerConfig", ")", "(", "*", "dockerapi", ".", "Client", ",", "error", ")", "{", "var", "httpClient", "*", "http", ".", "Client", "\n\n", "if", "config", ".", "UseTLS", "||", "config", ".", "TLSVerify", "{", "tlscOptions", ":=", "tlsconfig", ".", "Options", "{", "InsecureSkipVerify", ":", "!", "config", ".", "TLSVerify", ",", "}", "\n\n", "if", "_", ",", "err", ":=", "os", ".", "Stat", "(", "config", ".", "CAFile", ")", ";", "!", "os", ".", "IsNotExist", "(", "err", ")", "{", "tlscOptions", ".", "CAFile", "=", "config", ".", "CAFile", "\n", "}", "\n", "if", "_", ",", "err", ":=", "os", ".", "Stat", "(", "config", ".", "CertFile", ")", ";", "!", "os", ".", "IsNotExist", "(", "err", ")", "{", "tlscOptions", ".", "CertFile", "=", "config", ".", "CertFile", "\n", "}", "\n", "if", "_", ",", "err", ":=", "os", ".", "Stat", "(", "config", ".", "KeyFile", ")", ";", "!", "os", ".", "IsNotExist", "(", "err", ")", "{", "tlscOptions", ".", "KeyFile", "=", "config", ".", "KeyFile", "\n", "}", "\n\n", "tlsc", ",", "err", ":=", "tlsconfig", ".", "Client", "(", "tlscOptions", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "httpClient", "=", "&", "http", ".", "Client", "{", "Transport", ":", "&", "http", ".", "Transport", "{", "TLSClientConfig", ":", "tlsc", ",", "}", ",", "}", "\n", "}", "\n", "return", "dockerapi", ".", "NewClient", "(", "config", ".", "Endpoint", ",", "os", ".", "Getenv", "(", "\"", "\"", ")", ",", "httpClient", ",", "nil", ")", "\n", "}" ]

[ "NewEngineAPIClient", "creates", "a", "new", "Docker", "engine", "API", "client" ]

[ "func", "New", "(", "client", "Client", ",", "auth", "api", ".", "AuthConfig", ")", "Docker", "{", "return", "&", "stiDocker", "{", "client", ":", "client", ",", "pullAuth", ":", "dockertypes", ".", "AuthConfig", "{", "Username", ":", "auth", ".", "Username", ",", "Password", ":", "auth", ".", "Password", ",", "Email", ":", "auth", ".", "Email", ",", "ServerAddress", ":", "auth", ".", "ServerAddress", ",", "}", ",", "}", "\n", "}" ]

[ "New", "creates", "a", "new", "implementation", "of", "the", "STI", "Docker", "interface" ]

[ "func", "(", "d", "*", "stiDocker", ")", "GetImageEntrypoint", "(", "name", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "image", ",", "err", ":=", "d", ".", "InspectImage", "(", "name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "image", ".", "Config", ".", "Entrypoint", ",", "nil", "\n", "}" ]

[ "GetImageEntrypoint", "returns", "the", "ENTRYPOINT", "property", "for", "the", "given", "image", "name", "." ]

[ "func", "(", "d", "*", "stiDocker", ")", "IsImageInLocalRegistry", "(", "name", "string", ")", "(", "bool", ",", "error", ")", "{", "name", "=", "getImageName", "(", "name", ")", "\n", "resp", ",", "err", ":=", "d", ".", "InspectImage", "(", "name", ")", "\n", "if", "resp", "!=", "nil", "{", "return", "true", ",", "nil", "\n", "}", "\n", "if", "err", "!=", "nil", "&&", "!", "dockerapi", ".", "IsErrNotFound", "(", "err", ")", "{", "return", "false", ",", "s2ierr", ".", "NewInspectImageError", "(", "name", ",", "err", ")", "\n", "}", "\n", "return", "false", ",", "nil", "\n", "}" ]

[ "IsImageInLocalRegistry", "determines", "whether", "the", "supplied", "image", "is", "in", "the", "local", "registry", "." ]

[ "func", "(", "d", "*", "stiDocker", ")", "GetImageUser", "(", "name", "string", ")", "(", "string", ",", "error", ")", "{", "name", "=", "getImageName", "(", "name", ")", "\n", "resp", ",", "err", ":=", "d", ".", "InspectImage", "(", "name", ")", "\n", "if", "err", "!=", "nil", "{", "glog", ".", "V", "(", "4", ")", ".", "Infof", "(", "\"", "\"", ",", "name", ",", "err", ")", "\n", "return", "\"", "\"", ",", "s2ierr", ".", "NewInspectImageError", "(", "name", ",", "err", ")", "\n", "}", "\n", "user", ":=", "resp", ".", "Config", ".", "User", "\n", "return", "user", ",", "nil", "\n", "}" ]

[ "GetImageUser", "finds", "and", "retrieves", "the", "user", "associated", "with", "an", "image", "if", "one", "has", "been", "specified" ]

[ "func", "(", "d", "*", "stiDocker", ")", "Version", "(", ")", "(", "dockertypes", ".", "Version", ",", "error", ")", "{", "ctx", ",", "cancel", ":=", "getDefaultContext", "(", ")", "\n", "defer", "cancel", "(", ")", "\n", "return", "d", ".", "client", ".", "ServerVersion", "(", "ctx", ")", "\n", "}" ]

[ "Version", "returns", "information", "of", "the", "docker", "client", "and", "server", "host" ]

[ "func", "(", "d", "*", "stiDocker", ")", "IsImageOnBuild", "(", "name", "string", ")", "bool", "{", "onbuild", ",", "err", ":=", "d", ".", "GetOnBuild", "(", "name", ")", "\n", "return", "err", "==", "nil", "&&", "len", "(", "onbuild", ")", ">", "0", "\n", "}" ]

[ "IsImageOnBuild", "provides", "information", "about", "whether", "the", "Docker", "image", "has", "OnBuild", "instruction", "recorded", "in", "the", "Image", "Config", "." ]

[ "func", "(", "d", "*", "stiDocker", ")", "CheckAndPullImage", "(", "name", "string", ")", "(", "*", "api", ".", "Image", ",", "error", ")", "{", "name", "=", "getImageName", "(", "name", ")", "\n", "displayName", ":=", "name", "\n\n", "if", "!", "glog", ".", "Is", "(", "3", ")", "{", "// For less verbose log levels (less than 3), shorten long iamge names like:", "// \"centos/php-56-centos7@sha256:51c3e2b08bd9fadefccd6ec42288680d6d7f861bdbfbd2d8d24960621e4e27f5\"", "// to include just enough characters to differentiate the build from others in the docker repository:", "// \"centos/php-56-centos7@sha256:51c3e2b08bd...\"", "// 18 characters is somewhat arbitrary, but should be enough to avoid a name collision.", "split", ":=", "strings", ".", "Split", "(", "name", ",", "\"", "\"", ")", "\n", "if", "len", "(", "split", ")", ">", "1", "&&", "len", "(", "split", "[", "1", "]", ")", ">", "18", "{", "displayName", "=", "split", "[", "0", "]", "+", "\"", "\"", "+", "split", "[", "1", "]", "[", ":", "18", "]", "+", "\"", "\"", "\n", "}", "\n", "}", "\n\n", "image", ",", "err", ":=", "d", ".", "CheckImage", "(", "name", ")", "\n", "if", "err", "!=", "nil", "&&", "!", "strings", ".", "Contains", "(", "err", ".", "(", "s2ierr", ".", "Error", ")", ".", "Details", ".", "Error", "(", ")", ",", "\"", "\"", ")", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "image", "==", "nil", "{", "glog", ".", "V", "(", "1", ")", ".", "Infof", "(", "\"", "\"", ",", "displayName", ")", "\n", "return", "d", ".", "PullImage", "(", "name", ")", "\n", "}", "\n\n", "glog", ".", "V", "(", "3", ")", ".", "Infof", "(", "\"", "\"", ",", "displayName", ")", "\n", "return", "image", ",", "nil", "\n", "}" ]

[ "CheckAndPullImage", "pulls", "an", "image", "into", "the", "local", "registry", "if", "not", "present", "and", "returns", "the", "image", "metadata" ]

[ "func", "(", "d", "*", "stiDocker", ")", "CheckImage", "(", "name", "string", ")", "(", "*", "api", ".", "Image", ",", "error", ")", "{", "name", "=", "getImageName", "(", "name", ")", "\n", "inspect", ",", "err", ":=", "d", ".", "InspectImage", "(", "name", ")", "\n", "if", "err", "!=", "nil", "{", "glog", ".", "V", "(", "4", ")", ".", "Infof", "(", "\"", "\"", ",", "name", ",", "err", ")", "\n", "return", "nil", ",", "s2ierr", ".", "NewInspectImageError", "(", "name", ",", "err", ")", "\n", "}", "\n", "if", "inspect", "!=", "nil", "{", "image", ":=", "&", "api", ".", "Image", "{", "}", "\n", "updateImageWithInspect", "(", "image", ",", "inspect", ")", "\n", "return", "image", ",", "nil", "\n", "}", "\n\n", "return", "nil", ",", "nil", "\n", "}" ]

[ "CheckImage", "checks", "image", "from", "the", "local", "registry", "." ]

[ "func", "(", "d", "*", "stiDocker", ")", "PullImage", "(", "name", "string", ")", "(", "*", "api", ".", "Image", ",", "error", ")", "{", "name", "=", "getImageName", "(", "name", ")", "\n\n", "// RegistryAuth is the base64 encoded credentials for the registry", "base64Auth", ",", "err", ":=", "base64EncodeAuth", "(", "d", ".", "pullAuth", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "s2ierr", ".", "NewPullImageError", "(", "name", ",", "err", ")", "\n", "}", "\n", "var", "retriableError", "=", "false", "\n\n", "for", "retries", ":=", "0", ";", "retries", "<=", "DefaultPullRetryCount", ";", "retries", "++", "{", "err", "=", "util", ".", "TimeoutAfter", "(", "DefaultDockerTimeout", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "name", ")", ",", "func", "(", "timer", "*", "time", ".", "Timer", ")", "error", "{", "resp", ",", "pullErr", ":=", "d", ".", "client", ".", "ImagePull", "(", "context", ".", "Background", "(", ")", ",", "name", ",", "dockertypes", ".", "ImagePullOptions", "{", "RegistryAuth", ":", "base64Auth", "}", ")", "\n", "if", "pullErr", "!=", "nil", "{", "return", "pullErr", "\n", "}", "\n", "defer", "resp", ".", "Close", "(", ")", "\n\n", "decoder", ":=", "json", ".", "NewDecoder", "(", "resp", ")", "\n", "for", "{", "if", "!", "timer", ".", "Stop", "(", ")", "{", "return", "&", "util", ".", "TimeoutError", "{", "}", "\n", "}", "\n", "timer", ".", "Reset", "(", "DefaultDockerTimeout", ")", "\n\n", "var", "msg", "dockermessage", ".", "JSONMessage", "\n", "pullErr", "=", "decoder", ".", "Decode", "(", "&", "msg", ")", "\n", "if", "pullErr", "==", "io", ".", "EOF", "{", "return", "nil", "\n", "}", "\n", "if", "pullErr", "!=", "nil", "{", "return", "pullErr", "\n", "}", "\n\n", "if", "msg", ".", "Error", "!=", "nil", "{", "return", "msg", ".", "Error", "\n", "}", "\n", "if", "msg", ".", "Progress", "!=", "nil", "{", "glog", ".", "V", "(", "4", ")", ".", "Infof", "(", "\"", "\"", ",", "name", ",", "msg", ".", "Progress", ".", "String", "(", ")", ")", "\n", "}", "\n", "}", "\n", "}", ")", "\n", "if", "err", "==", "nil", "{", "break", "\n", "}", "\n", "glog", ".", "V", "(", "0", ")", ".", "Infof", "(", "\"", "\"", ",", "err", ")", "\n", "errMsg", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "err", ")", "\n", "for", "_", ",", "errorString", ":=", "range", "RetriableErrors", "{", "if", "strings", ".", "Contains", "(", "errMsg", ",", "errorString", ")", "{", "retriableError", "=", "true", "\n", "break", "\n", "}", "\n", "}", "\n\n", "if", "!", "retriableError", "{", "return", "nil", ",", "s2ierr", ".", "NewPullImageError", "(", "name", ",", "err", ")", "\n", "}", "\n\n", "glog", ".", "V", "(", "0", ")", ".", "Infof", "(", "\"", "\"", ",", "DefaultPullRetryDelay", ")", "\n", "time", ".", "Sleep", "(", "DefaultPullRetryDelay", ")", "\n", "}", "\n\n", "inspectResp", ",", "err", ":=", "d", ".", "InspectImage", "(", "name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "s2ierr", ".", "NewPullImageError", "(", "name", ",", "err", ")", "\n", "}", "\n", "if", "inspectResp", "!=", "nil", "{", "image", ":=", "&", "api", ".", "Image", "{", "}", "\n", "updateImageWithInspect", "(", "image", ",", "inspectResp", ")", "\n", "return", "image", ",", "nil", "\n", "}", "\n", "return", "nil", ",", "nil", "\n", "}" ]

[ "PullImage", "pulls", "an", "image", "into", "the", "local", "registry" ]

[ "func", "(", "d", "*", "stiDocker", ")", "RemoveContainer", "(", "id", "string", ")", "error", "{", "ctx", ",", "cancel", ":=", "getDefaultContext", "(", ")", "\n", "defer", "cancel", "(", ")", "\n", "opts", ":=", "dockertypes", ".", "ContainerRemoveOptions", "{", "RemoveVolumes", ":", "true", ",", "}", "\n", "return", "d", ".", "client", ".", "ContainerRemove", "(", "ctx", ",", "id", ",", "opts", ")", "\n", "}" ]

[ "RemoveContainer", "removes", "a", "container", "and", "its", "associated", "volumes", "." ]

[ "func", "(", "d", "*", "stiDocker", ")", "KillContainer", "(", "id", "string", ")", "error", "{", "ctx", ",", "cancel", ":=", "getDefaultContext", "(", ")", "\n", "defer", "cancel", "(", ")", "\n", "return", "d", ".", "client", ".", "ContainerKill", "(", "ctx", ",", "id", ",", "\"", "\"", ")", "\n", "}" ]

[ "KillContainer", "kills", "a", "container", "." ]

[ "func", "(", "d", "*", "stiDocker", ")", "GetLabels", "(", "name", "string", ")", "(", "map", "[", "string", "]", "string", ",", "error", ")", "{", "name", "=", "getImageName", "(", "name", ")", "\n", "resp", ",", "err", ":=", "d", ".", "InspectImage", "(", "name", ")", "\n", "if", "err", "!=", "nil", "{", "glog", ".", "V", "(", "4", ")", ".", "Infof", "(", "\"", "\"", ",", "name", ",", "err", ")", "\n", "return", "nil", ",", "s2ierr", ".", "NewInspectImageError", "(", "name", ",", "err", ")", "\n", "}", "\n", "return", "resp", ".", "Config", ".", "Labels", ",", "nil", "\n", "}" ]

[ "GetLabels", "retrieves", "the", "labels", "of", "the", "given", "image", "." ]

[ "func", "getImageName", "(", "name", "string", ")", "string", "{", "_", ",", "tag", ",", "id", ":=", "parseRepositoryTag", "(", "name", ")", "\n", "if", "len", "(", "tag", ")", "==", "0", "&&", "len", "(", "id", ")", "==", "0", "{", "//_, tag, _ := parseRepositoryTag(name)", "//if len(tag) == 0 {", "return", "strings", ".", "Join", "(", "[", "]", "string", "{", "name", ",", "DefaultTag", "}", ",", "\"", "\"", ")", "\n", "}", "\n\n", "return", "name", "\n", "}" ]

[ "getImageName", "checks", "the", "image", "name", "and", "adds", "DefaultTag", "if", "none", "is", "specified" ]

[ "func", "getLabel", "(", "image", "*", "api", ".", "Image", ",", "name", "string", ")", "string", "{", "if", "value", ",", "ok", ":=", "image", ".", "Config", ".", "Labels", "[", "name", "]", ";", "ok", "{", "return", "value", "\n", "}", "\n", "return", "\"", "\"", "\n", "}" ]

[ "getLabel", "gets", "label", "s", "value", "from", "the", "image", "metadata" ]

[ "func", "getVariable", "(", "image", "*", "api", ".", "Image", ",", "name", "string", ")", "string", "{", "envName", ":=", "name", "+", "\"", "\"", "\n", "for", "_", ",", "v", ":=", "range", "image", ".", "Config", ".", "Env", "{", "if", "strings", ".", "HasPrefix", "(", "v", ",", "envName", ")", "{", "return", "strings", ".", "TrimSpace", "(", "v", "[", "len", "(", "envName", ")", ":", "]", ")", "\n", "}", "\n", "}", "\n\n", "return", "\"", "\"", "\n", "}" ]

[ "getVariable", "gets", "environment", "variable", "s", "value", "from", "the", "image", "metadata" ]

[ "func", "(", "d", "*", "stiDocker", ")", "GetScriptsURL", "(", "image", "string", ")", "(", "string", ",", "error", ")", "{", "imageMetadata", ",", "err", ":=", "d", ".", "CheckAndPullImage", "(", "image", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "return", "getScriptsURL", "(", "imageMetadata", ")", ",", "nil", "\n", "}" ]

[ "GetScriptsURL", "finds", "a", "scripts", "-", "url", "label", "on", "the", "given", "image", "." ]

[ "func", "getScriptsURL", "(", "image", "*", "api", ".", "Image", ")", "string", "{", "if", "image", "==", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "scriptsURL", ":=", "getLabel", "(", "image", ",", "constants", ".", "ScriptsURLLabel", ")", "\n\n", "// For backward compatibility, support the old label schema", "if", "len", "(", "scriptsURL", ")", "==", "0", "{", "scriptsURL", "=", "getLabel", "(", "image", ",", "constants", ".", "DeprecatedScriptsURLLabel", ")", "\n", "if", "len", "(", "scriptsURL", ")", ">", "0", "{", "glog", ".", "V", "(", "0", ")", ".", "Infof", "(", "\"", "\"", ",", "image", ".", "ID", ",", "constants", ".", "DeprecatedScriptsURLLabel", ",", "constants", ".", "ScriptsURLLabel", ")", "\n", "}", "\n", "}", "\n", "if", "len", "(", "scriptsURL", ")", "==", "0", "{", "scriptsURL", "=", "getVariable", "(", "image", ",", "constants", ".", "ScriptsURLEnvironment", ")", "\n", "if", "len", "(", "scriptsURL", ")", "!=", "0", "{", "glog", ".", "V", "(", "0", ")", ".", "Infof", "(", "\"", "\"", ",", "image", ".", "ID", ",", "constants", ".", "ScriptsURLEnvironment", ",", "constants", ".", "ScriptsURLLabel", ")", "\n", "}", "\n", "}", "\n", "if", "len", "(", "scriptsURL", ")", "==", "0", "{", "glog", ".", "V", "(", "0", ")", ".", "Infof", "(", "\"", "\"", ",", "image", ".", "ID", ",", "constants", ".", "ScriptsURLLabel", ")", "\n", "}", "else", "{", "glog", ".", "V", "(", "2", ")", ".", "Infof", "(", "\"", "\"", ",", "image", ".", "ID", ",", "constants", ".", "ScriptsURLLabel", ",", "scriptsURL", ")", "\n", "}", "\n\n", "return", "scriptsURL", "\n", "}" ]

[ "getScriptsURL", "finds", "a", "scripts", "url", "label", "in", "the", "image", "metadata" ]

[ "func", "getDestination", "(", "image", "*", "api", ".", "Image", ")", "string", "{", "if", "val", ":=", "getLabel", "(", "image", ",", "constants", ".", "DestinationLabel", ")", ";", "len", "(", "val", ")", "!=", "0", "{", "return", "val", "\n", "}", "\n", "// For backward compatibility, support the old label schema", "if", "val", ":=", "getLabel", "(", "image", ",", "constants", ".", "DeprecatedDestinationLabel", ")", ";", "len", "(", "val", ")", "!=", "0", "{", "glog", ".", "V", "(", "0", ")", ".", "Infof", "(", "\"", "\"", ",", "image", ".", "ID", ",", "constants", ".", "DeprecatedDestinationLabel", ",", "constants", ".", "DestinationLabel", ")", "\n", "return", "val", "\n", "}", "\n", "if", "val", ":=", "getVariable", "(", "image", ",", "constants", ".", "LocationEnvironment", ")", ";", "len", "(", "val", ")", "!=", "0", "{", "glog", ".", "V", "(", "0", ")", ".", "Infof", "(", "\"", "\"", ",", "image", ".", "ID", ",", "constants", ".", "LocationEnvironment", ",", "constants", ".", "DestinationLabel", ")", "\n", "return", "val", "\n", "}", "\n\n", "// default directory if none is specified", "return", "DefaultDestination", "\n", "}" ]

[ "getDestination", "finds", "a", "destination", "label", "in", "the", "image", "metadata" ]

[ "func", "(", "d", "*", "stiDocker", ")", "holdHijackedConnection", "(", "tty", "bool", ",", "opts", "*", "RunContainerOptions", ",", "resp", "dockertypes", ".", "HijackedResponse", ")", "error", "{", "receiveStdout", ":=", "make", "(", "chan", "error", ",", "1", ")", "\n", "if", "opts", ".", "Stdout", "!=", "nil", "||", "opts", ".", "Stderr", "!=", "nil", "{", "go", "func", "(", ")", "{", "err", ":=", "d", ".", "redirectResponseToOutputStream", "(", "tty", ",", "opts", ".", "Stdout", ",", "opts", ".", "Stderr", ",", "resp", ".", "Reader", ")", "\n", "if", "opts", ".", "Stdout", "!=", "nil", "{", "opts", ".", "Stdout", ".", "Close", "(", ")", "\n", "opts", ".", "Stdout", "=", "nil", "\n", "}", "\n", "if", "opts", ".", "Stderr", "!=", "nil", "{", "opts", ".", "Stderr", ".", "Close", "(", ")", "\n", "opts", ".", "Stderr", "=", "nil", "\n", "}", "\n", "receiveStdout", "<-", "err", "\n", "}", "(", ")", "\n", "}", "else", "{", "receiveStdout", "<-", "nil", "\n", "}", "\n\n", "if", "opts", ".", "Stdin", "!=", "nil", "{", "_", ",", "err", ":=", "io", ".", "Copy", "(", "resp", ".", "Conn", ",", "opts", ".", "Stdin", ")", "\n", "opts", ".", "Stdin", ".", "Close", "(", ")", "\n", "opts", ".", "Stdin", "=", "nil", "\n", "if", "err", "!=", "nil", "{", "<-", "receiveStdout", "\n", "return", "err", "\n", "}", "\n", "}", "\n", "err", ":=", "resp", ".", "CloseWrite", "(", ")", "\n", "if", "err", "!=", "nil", "{", "<-", "receiveStdout", "\n", "return", "err", "\n", "}", "\n\n", "// Hang around until the streaming is over - either when the server closes", "// the connection, or someone locally closes resp.", "return", "<-", "receiveStdout", "\n", "}" ]

[ "holdHijackedConnection", "pumps", "data", "up", "to", "the", "container", "s", "stdin", "and", "runs", "a", "goroutine", "to", "pump", "data", "down", "from", "the", "container", "s", "stdout", "and", "stderr", ".", "it", "holds", "open", "the", "HijackedResponse", "until", "all", "of", "this", "is", "done", ".", "Caller", "s", "responsibility", "to", "close", "resp", "as", "well", "as", "outputStream", "and", "errorStream", "if", "appropriate", "." ]

[ "func", "(", "d", "*", "stiDocker", ")", "GetImageID", "(", "name", "string", ")", "(", "string", ",", "error", ")", "{", "name", "=", "getImageName", "(", "name", ")", "\n", "image", ",", "err", ":=", "d", ".", "InspectImage", "(", "name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "return", "image", ".", "ID", ",", "nil", "\n", "}" ]

[ "GetImageID", "retrieves", "the", "ID", "of", "the", "image", "identified", "by", "name" ]

[ "func", "(", "d", "*", "stiDocker", ")", "CommitContainer", "(", "opts", "CommitContainerOptions", ")", "(", "string", ",", "error", ")", "{", "dockerOpts", ":=", "dockertypes", ".", "ContainerCommitOptions", "{", "Reference", ":", "opts", ".", "Repository", ",", "}", "\n", "if", "opts", ".", "Command", "!=", "nil", "||", "opts", ".", "Entrypoint", "!=", "nil", "{", "config", ":=", "dockercontainer", ".", "Config", "{", "Cmd", ":", "opts", ".", "Command", ",", "Entrypoint", ":", "opts", ".", "Entrypoint", ",", "Env", ":", "opts", ".", "Env", ",", "Labels", ":", "opts", ".", "Labels", ",", "User", ":", "opts", ".", "User", ",", "}", "\n", "dockerOpts", ".", "Config", "=", "&", "config", "\n", "glog", ".", "V", "(", "2", ")", ".", "Infof", "(", "\"", "\"", ",", "dockerOpts", ",", "*", "util", ".", "SafeForLoggingContainerConfig", "(", "&", "config", ")", ")", "\n", "}", "\n\n", "resp", ",", "err", ":=", "d", ".", "client", ".", "ContainerCommit", "(", "context", ".", "Background", "(", ")", ",", "opts", ".", "ContainerID", ",", "dockerOpts", ")", "\n", "if", "err", "==", "nil", "{", "return", "resp", ".", "ID", ",", "nil", "\n", "}", "\n", "return", "\"", "\"", ",", "err", "\n", "}" ]

[ "CommitContainer", "commits", "a", "container", "to", "an", "image", "with", "a", "specific", "tag", ".", "The", "new", "image", "ID", "is", "returned" ]

[ "func", "(", "d", "*", "stiDocker", ")", "RemoveImage", "(", "imageID", "string", ")", "error", "{", "ctx", ",", "cancel", ":=", "getDefaultContext", "(", ")", "\n", "defer", "cancel", "(", ")", "\n", "_", ",", "err", ":=", "d", ".", "client", ".", "ImageRemove", "(", "ctx", ",", "imageID", ",", "dockertypes", ".", "ImageRemoveOptions", "{", "}", ")", "\n", "return", "err", "\n", "}" ]

[ "RemoveImage", "removes", "the", "image", "with", "specified", "ID" ]

[ "func", "(", "d", "*", "stiDocker", ")", "BuildImage", "(", "opts", "BuildImageOptions", ")", "error", "{", "dockerOpts", ":=", "dockertypes", ".", "ImageBuildOptions", "{", "Tags", ":", "[", "]", "string", "{", "opts", ".", "Name", "}", ",", "NoCache", ":", "true", ",", "SuppressOutput", ":", "false", ",", "Remove", ":", "true", ",", "ForceRemove", ":", "true", ",", "}", "\n", "if", "opts", ".", "CGroupLimits", "!=", "nil", "{", "dockerOpts", ".", "Memory", "=", "opts", ".", "CGroupLimits", ".", "MemoryLimitBytes", "\n", "dockerOpts", ".", "MemorySwap", "=", "opts", ".", "CGroupLimits", ".", "MemorySwap", "\n", "dockerOpts", ".", "CgroupParent", "=", "opts", ".", "CGroupLimits", ".", "Parent", "\n", "}", "\n", "glog", ".", "V", "(", "2", ")", ".", "Infof", "(", "\"", "\"", ",", "dockerOpts", ")", "\n", "resp", ",", "err", ":=", "d", ".", "client", ".", "ImageBuild", "(", "context", ".", "Background", "(", ")", ",", "opts", ".", "Stdin", ",", "dockerOpts", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "resp", ".", "Body", ".", "Close", "(", ")", "\n", "// since can't pass in output stream to engine-api, need to copy contents of", "// the output stream they create into our output stream", "_", ",", "err", "=", "io", ".", "Copy", "(", "opts", ".", "Stdout", ",", "resp", ".", "Body", ")", "\n", "if", "opts", ".", "Stdout", "!=", "nil", "{", "opts", ".", "Stdout", ".", "Close", "(", ")", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "BuildImage", "builds", "the", "image", "according", "to", "specified", "options" ]

[ "func", "isValidEntrypoint", "(", "fs", "fs", ".", "FileSystem", ",", "path", "string", ")", "bool", "{", "stat", ",", "err", ":=", "fs", ".", "Stat", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", "\n", "}", "\n", "found", ":=", "false", "\n", "for", "_", ",", "pattern", ":=", "range", "validEntrypoints", "{", "if", "pattern", ".", "MatchString", "(", "stat", ".", "Name", "(", ")", ")", "{", "found", "=", "true", "\n", "break", "\n", "}", "\n", "}", "\n", "if", "!", "found", "{", "return", "false", "\n", "}", "\n", "mode", ":=", "stat", ".", "Mode", "(", ")", "\n", "return", "mode", "&", "0111", "!=", "0", "\n", "}" ]

[ "isValidEntrypoint", "checks", "if", "the", "given", "file", "exists", "and", "if", "it", "is", "a", "regular", "file", ".", "Valid", "ENTRYPOINT", "must", "be", "an", "executable", "file", "so", "the", "executable", "bit", "must", "be", "set", "." ]

[ "func", "NewCmdVersion", "(", ")", "*", "cobra", ".", "Command", "{", "return", "&", "cobra", ".", "Command", "{", "Use", ":", "\"", "\"", ",", "Short", ":", "\"", "\"", ",", "Long", ":", "\"", "\"", ",", "Run", ":", "func", "(", "cmd", "*", "cobra", ".", "Command", ",", "args", "[", "]", "string", ")", "{", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "version", ".", "Get", "(", ")", ")", "\n", "}", ",", "}", "\n", "}" ]

[ "NewCmdVersion", "implements", "the", "S2i", "cli", "version", "command", "." ]

[ "func", "(", "b", "*", "DockerIgnorer", ")", "Ignore", "(", "config", "*", "api", ".", "Config", ")", "error", "{", "/*\n\t\t so, to duplicate the .dockerignore capabilities (https://docs.docker.com/reference/builder/#dockerignore-file)\n\t\t we have a flow that follows:\n\t\t0) First note, .dockerignore rules are NOT recursive (unlike .gitignore) .. you have to list subdir explicitly\n\t\t1) Read in the exclusion patterns\n\t\t2) Skip over comments (noted by #)\n\t\t3) note overrides (via exclamation sign i.e. !) and reinstate files (don't remove) as needed\n\t\t4) leverage Glob matching to build list, as .dockerignore is documented as following filepath.Match / filepath.Glob\n\t\t5) del files\n\t\t 1 to 4 is in getListOfFilesToIgnore\n\t*/", "filesToDel", ",", "lerr", ":=", "getListOfFilesToIgnore", "(", "config", ".", "WorkingSourceDir", ")", "\n", "if", "lerr", "!=", "nil", "{", "return", "lerr", "\n", "}", "\n\n", "if", "filesToDel", "==", "nil", "{", "return", "nil", "\n", "}", "\n\n", "// delete compiled list of files", "for", "_", ",", "fileToDel", ":=", "range", "filesToDel", "{", "glog", ".", "V", "(", "5", ")", ".", "Infof", "(", "\"", "\\n", "\"", ",", "fileToDel", ")", "\n", "rerr", ":=", "os", ".", "RemoveAll", "(", "fileToDel", ")", "\n", "if", "rerr", "!=", "nil", "{", "glog", ".", "Errorf", "(", "\"", "\\n", "\"", ",", "fileToDel", ",", "rerr", ")", "\n", "return", "rerr", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Ignore", "removes", "files", "from", "the", "workspace", "based", "on", "the", "contents", "of", "the", ".", "s2iignore", "file" ]

[ "func", "Config", "(", "client", "docker", ".", "Client", ",", "config", "*", "api", ".", "Config", ")", "string", "{", "out", ",", "err", ":=", "tabbedString", "(", "func", "(", "out", "io", ".", "Writer", ")", "error", "{", "if", "len", "(", "config", ".", "DisplayName", ")", ">", "0", "{", "fmt", ".", "Fprintf", "(", "out", ",", "\"", "\\t", "\\n", "\"", ",", "config", ".", "DisplayName", ")", "\n", "}", "\n", "if", "len", "(", "config", ".", "Description", ")", ">", "0", "{", "fmt", ".", "Fprintf", "(", "out", ",", "\"", "\\t", "\\n", "\"", ",", "config", ".", "Description", ")", "\n", "}", "\n", "if", "len", "(", "config", ".", "AsDockerfile", ")", "==", "0", "{", "describeBuilderImage", "(", "client", ",", "config", ",", "out", ")", "\n", "describeRuntimeImage", "(", "config", ",", "out", ")", "\n", "}", "\n", "fmt", ".", "Fprintf", "(", "out", ",", "\"", "\\t", "\\n", "\"", ",", "config", ".", "Source", ")", "\n", "if", "len", "(", "config", ".", "ContextDir", ")", ">", "0", "{", "fmt", ".", "Fprintf", "(", "out", ",", "\"", "\\t", "\\n", "\"", ",", "config", ".", "ContextDir", ")", "\n", "}", "\n", "fmt", ".", "Fprintf", "(", "out", ",", "\"", "\\t", "\\n", "\"", ",", "config", ".", "Tag", ")", "\n", "printEnv", "(", "out", ",", "config", ".", "Environment", ")", "\n", "if", "len", "(", "config", ".", "EnvironmentFile", ")", ">", "0", "{", "fmt", ".", "Fprintf", "(", "out", ",", "\"", "\\t", "\\n", "\"", ",", "config", ".", "EnvironmentFile", ")", "\n", "}", "\n", "printLabels", "(", "out", ",", "config", ".", "Labels", ")", "\n", "fmt", ".", "Fprintf", "(", "out", ",", "\"", "\\t", "\\n", "\"", ",", "printBool", "(", "config", ".", "Incremental", ")", ")", "\n", "if", "config", ".", "Incremental", "{", "fmt", ".", "Fprintf", "(", "out", ",", "\"", "\\t", "\\n", "\"", ",", "config", ".", "IncrementalAuthentication", ".", "Username", ")", "\n", "}", "\n", "fmt", ".", "Fprintf", "(", "out", ",", "\"", "\\t", "\\n", "\"", ",", "printBool", "(", "config", ".", "RemovePreviousImage", ")", ")", "\n", "fmt", ".", "Fprintf", "(", "out", ",", "\"", "\\t", "\\n", "\"", ",", "config", ".", "BuilderPullPolicy", ")", "\n", "fmt", ".", "Fprintf", "(", "out", ",", "\"", "\\t", "\\n", "\"", ",", "config", ".", "PreviousImagePullPolicy", ")", "\n", "fmt", ".", "Fprintf", "(", "out", ",", "\"", "\\t", "\\n", "\"", ",", "printBool", "(", "config", ".", "Quiet", ")", ")", "\n", "fmt", ".", "Fprintf", "(", "out", ",", "\"", "\\t", "\\n", "\"", ",", "printBool", "(", "config", ".", "LayeredBuild", ")", ")", "\n", "if", "len", "(", "config", ".", "Destination", ")", ">", "0", "{", "fmt", ".", "Fprintf", "(", "out", ",", "\"", "\\t", "\\n", "\"", ",", "config", ".", "Destination", ")", "\n", "}", "\n", "if", "len", "(", "config", ".", "CallbackURL", ")", ">", "0", "{", "fmt", ".", "Fprintf", "(", "out", ",", "\"", "\\t", "\\n", "\"", ",", "config", ".", "CallbackURL", ")", "\n", "}", "\n", "if", "len", "(", "config", ".", "ScriptsURL", ")", ">", "0", "{", "fmt", ".", "Fprintf", "(", "out", ",", "\"", "\\t", "\\n", "\"", ",", "config", ".", "ScriptsURL", ")", "\n", "}", "\n", "if", "len", "(", "config", ".", "WorkingDir", ")", ">", "0", "{", "fmt", ".", "Fprintf", "(", "out", ",", "\"", "\\t", "\\n", "\"", ",", "config", ".", "WorkingDir", ")", "\n", "}", "\n", "if", "config", ".", "DockerNetworkMode", "!=", "\"", "\"", "{", "fmt", ".", "Fprintf", "(", "out", ",", "\"", "\\t", "\\n", "\"", ",", "config", ".", "DockerNetworkMode", ")", "\n", "}", "\n", "fmt", ".", "Fprintf", "(", "out", ",", "\"", "\\t", "\\n", "\"", ",", "config", ".", "DockerConfig", ".", "Endpoint", ")", "\n\n", "if", "_", ",", "err", ":=", "os", ".", "Open", "(", "config", ".", "DockerCfgPath", ")", ";", "err", "==", "nil", "{", "fmt", ".", "Fprintf", "(", "out", ",", "\"", "\\t", "\\n", "\"", ",", "config", ".", "DockerCfgPath", ")", "\n", "fmt", ".", "Fprintf", "(", "out", ",", "\"", "\\t", "\\n", "\"", ",", "config", ".", "PullAuthentication", ".", "Username", ")", "\n", "}", "\n\n", "if", "len", "(", "config", ".", "Injections", ")", ">", "0", "{", "result", ":=", "[", "]", "string", "{", "}", "\n", "for", "_", ",", "i", ":=", "range", "config", ".", "Injections", "{", "result", "=", "append", "(", "result", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "i", ".", "Source", ",", "i", ".", "Destination", ")", ")", "\n", "}", "\n", "fmt", ".", "Fprintf", "(", "out", ",", "\"", "\\t", "\\n", "\"", ",", "strings", ".", "Join", "(", "result", ",", "\"", "\"", ")", ")", "\n", "}", "\n", "if", "len", "(", "config", ".", "BuildVolumes", ")", ">", "0", "{", "result", ":=", "[", "]", "string", "{", "}", "\n", "for", "_", ",", "i", ":=", "range", "config", ".", "BuildVolumes", "{", "if", "runtime", ".", "GOOS", "==", "\"", "\"", "{", "// We need to avoid the colon in the Windows drive letter", "result", "=", "append", "(", "result", ",", "i", "[", "0", ":", "2", "]", "+", "strings", ".", "Replace", "(", "i", "[", "3", ":", "]", ",", "\"", "\"", ",", "\"", "\"", ",", "1", ")", ")", "\n", "}", "else", "{", "result", "=", "append", "(", "result", ",", "strings", ".", "Replace", "(", "i", ",", "\"", "\"", ",", "\"", "\"", ",", "1", ")", ")", "\n", "}", "\n", "}", "\n", "fmt", ".", "Fprintf", "(", "out", ",", "\"", "\\t", "\\n", "\"", ",", "strings", ".", "Join", "(", "result", ",", "\"", "\"", ")", ")", "\n", "}", "\n", "return", "nil", "\n", "}", ")", "\n\n", "if", "err", "!=", "nil", "{", "fmt", ".", "Printf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "out", "\n", "}" ]

[ "Config", "returns", "the", "Config", "object", "in", "nice", "readable", "tabbed", "format", "." ]

[ "func", "checkAndGetNewLabels", "(", "builder", "*", "STI", ",", "docker", "dockerpkg", ".", "Docker", ",", "tar", "s2itar", ".", "Tar", ",", "containerID", "string", ")", "error", "{", "glog", ".", "V", "(", "3", ")", ".", "Infof", "(", "\"", "\"", ")", "\n\n", "// metadata filename and its path inside the container", "metadataFilename", ":=", "\"", "\"", "\n", "sourceFilepath", ":=", "filepath", ".", "Join", "(", "\"", "\"", ",", "metadataFilename", ")", "\n\n", "// create the 'downloadPath' folder if it doesn't exist", "downloadPath", ":=", "filepath", ".", "Join", "(", "builder", ".", "config", ".", "WorkingDir", ",", "\"", "\"", ")", "\n", "glog", ".", "V", "(", "3", ")", ".", "Infof", "(", "\"", "\"", ",", "downloadPath", ")", "\n", "if", "err", ":=", "os", ".", "MkdirAll", "(", "downloadPath", ",", "0700", ")", ";", "err", "!=", "nil", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "downloadPath", ",", "metadataFilename", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n\n", "// download & extract the file from container", "if", "_", ",", "err", ":=", "downloadAndExtractFileFromContainer", "(", "docker", ",", "tar", ",", "sourceFilepath", ",", "downloadPath", ",", "containerID", ")", ";", "err", "!=", "nil", "{", "glog", ".", "V", "(", "3", ")", ".", "Infof", "(", "\"", "\"", ",", "metadataFilename", ")", "\n", "return", "nil", "\n", "}", "\n\n", "// open the file", "filePath", ":=", "filepath", ".", "Join", "(", "downloadPath", ",", "metadataFilename", ")", "\n", "fd", ",", "err", ":=", "os", ".", "Open", "(", "filePath", ")", "\n", "if", "fd", "==", "nil", "||", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "downloadPath", ",", "err", ")", "\n", "}", "\n", "defer", "fd", ".", "Close", "(", ")", "\n\n", "// read the file to a string", "str", ",", "err", ":=", "ioutil", ".", "ReadAll", "(", "fd", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "filePath", ",", "err", ")", "\n", "}", "\n", "glog", ".", "V", "(", "3", ")", ".", "Infof", "(", "\"", "\\n", "\\n", "\"", ",", "str", ")", "\n\n", "// string into a map", "var", "data", "map", "[", "string", "]", "interface", "{", "}", "\n\n", "if", "err", "=", "json", ".", "Unmarshal", "(", "[", "]", "byte", "(", "str", ")", ",", "&", "data", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "metadataFilename", ",", "err", ")", "\n", "}", "\n\n", "// update newLabels[]", "labels", ":=", "data", "[", "\"", "\"", "]", "\n", "for", "_", ",", "l", ":=", "range", "labels", ".", "(", "[", "]", "interface", "{", "}", ")", "{", "for", "k", ",", "v", ":=", "range", "l", ".", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "{", "builder", ".", "newLabels", "[", "k", "]", "=", "v", ".", "(", "string", ")", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "check", "for", "new", "labels", "and", "apply", "to", "the", "output", "image", "." ]