repo
stringlengths
5
54
path
stringlengths
4
155
func_name
stringlengths
1
118
original_string
stringlengths
52
85.5k
language
stringclasses
1 value
code
stringlengths
52
85.5k
code_tokens
sequence
docstring
stringlengths
6
2.61k
docstring_tokens
sequence
sha
stringlengths
40
40
url
stringlengths
85
252
partition
stringclasses
1 value
gobwas/ws
http.go
httpParseVersion
func httpParseVersion(bts []byte) (major, minor int, ok bool) { switch { case bytes.Equal(bts, httpVersion1_0): return 1, 0, true case bytes.Equal(bts, httpVersion1_1): return 1, 1, true case len(bts) < 8: return case !bytes.Equal(bts[:5], httpVersionPrefix): return } bts = bts[5:] dot := bytes.IndexByte(bts, '.') if dot == -1 { return } var err error major, err = asciiToInt(bts[:dot]) if err != nil { return } minor, err = asciiToInt(bts[dot+1:]) if err != nil { return } return major, minor, true }
go
func httpParseVersion(bts []byte) (major, minor int, ok bool) { switch { case bytes.Equal(bts, httpVersion1_0): return 1, 0, true case bytes.Equal(bts, httpVersion1_1): return 1, 1, true case len(bts) < 8: return case !bytes.Equal(bts[:5], httpVersionPrefix): return } bts = bts[5:] dot := bytes.IndexByte(bts, '.') if dot == -1 { return } var err error major, err = asciiToInt(bts[:dot]) if err != nil { return } minor, err = asciiToInt(bts[dot+1:]) if err != nil { return } return major, minor, true }
[ "func", "httpParseVersion", "(", "bts", "[", "]", "byte", ")", "(", "major", ",", "minor", "int", ",", "ok", "bool", ")", "{", "switch", "{", "case", "bytes", ".", "Equal", "(", "bts", ",", "httpVersion1_0", ")", ":", "return", "1", ",", "0", ",", "true", "\n", "case", "bytes", ".", "Equal", "(", "bts", ",", "httpVersion1_1", ")", ":", "return", "1", ",", "1", ",", "true", "\n", "case", "len", "(", "bts", ")", "<", "8", ":", "return", "\n", "case", "!", "bytes", ".", "Equal", "(", "bts", "[", ":", "5", "]", ",", "httpVersionPrefix", ")", ":", "return", "\n", "}", "\n\n", "bts", "=", "bts", "[", "5", ":", "]", "\n\n", "dot", ":=", "bytes", ".", "IndexByte", "(", "bts", ",", "'.'", ")", "\n", "if", "dot", "==", "-", "1", "{", "return", "\n", "}", "\n", "var", "err", "error", "\n", "major", ",", "err", "=", "asciiToInt", "(", "bts", "[", ":", "dot", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "minor", ",", "err", "=", "asciiToInt", "(", "bts", "[", "dot", "+", "1", ":", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "return", "major", ",", "minor", ",", "true", "\n", "}" ]
// httpParseVersion parses major and minor version of HTTP protocol. It returns // parsed values and true if parse is ok.
[ "httpParseVersion", "parses", "major", "and", "minor", "version", "of", "HTTP", "protocol", ".", "It", "returns", "parsed", "values", "and", "true", "if", "parse", "is", "ok", "." ]
7338e265e1ab4ea2403da5ce80d934ef5f976923
https://github.com/gobwas/ws/blob/7338e265e1ab4ea2403da5ce80d934ef5f976923/http.go#L124-L153
train
gobwas/ws
http.go
httpParseHeaderLine
func httpParseHeaderLine(line []byte) (k, v []byte, ok bool) { colon := bytes.IndexByte(line, ':') if colon == -1 { return } k = btrim(line[:colon]) // TODO(gobwas): maybe use just lower here? canonicalizeHeaderKey(k) v = btrim(line[colon+1:]) return k, v, true }
go
func httpParseHeaderLine(line []byte) (k, v []byte, ok bool) { colon := bytes.IndexByte(line, ':') if colon == -1 { return } k = btrim(line[:colon]) // TODO(gobwas): maybe use just lower here? canonicalizeHeaderKey(k) v = btrim(line[colon+1:]) return k, v, true }
[ "func", "httpParseHeaderLine", "(", "line", "[", "]", "byte", ")", "(", "k", ",", "v", "[", "]", "byte", ",", "ok", "bool", ")", "{", "colon", ":=", "bytes", ".", "IndexByte", "(", "line", ",", "':'", ")", "\n", "if", "colon", "==", "-", "1", "{", "return", "\n", "}", "\n\n", "k", "=", "btrim", "(", "line", "[", ":", "colon", "]", ")", "\n", "// TODO(gobwas): maybe use just lower here?", "canonicalizeHeaderKey", "(", "k", ")", "\n\n", "v", "=", "btrim", "(", "line", "[", "colon", "+", "1", ":", "]", ")", "\n\n", "return", "k", ",", "v", ",", "true", "\n", "}" ]
// httpParseHeaderLine parses HTTP header as key-value pair. It returns parsed // values and true if parse is ok.
[ "httpParseHeaderLine", "parses", "HTTP", "header", "as", "key", "-", "value", "pair", ".", "It", "returns", "parsed", "values", "and", "true", "if", "parse", "is", "ok", "." ]
7338e265e1ab4ea2403da5ce80d934ef5f976923
https://github.com/gobwas/ws/blob/7338e265e1ab4ea2403da5ce80d934ef5f976923/http.go#L157-L170
train
gobwas/ws
http.go
httpGetHeader
func httpGetHeader(h http.Header, key string) string { if h == nil { return "" } v := h[key] if len(v) == 0 { return "" } return v[0] }
go
func httpGetHeader(h http.Header, key string) string { if h == nil { return "" } v := h[key] if len(v) == 0 { return "" } return v[0] }
[ "func", "httpGetHeader", "(", "h", "http", ".", "Header", ",", "key", "string", ")", "string", "{", "if", "h", "==", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "v", ":=", "h", "[", "key", "]", "\n", "if", "len", "(", "v", ")", "==", "0", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "v", "[", "0", "]", "\n", "}" ]
// httpGetHeader is the same as textproto.MIMEHeader.Get, except the thing, // that key is already canonical. This helps to increase performance.
[ "httpGetHeader", "is", "the", "same", "as", "textproto", ".", "MIMEHeader", ".", "Get", "except", "the", "thing", "that", "key", "is", "already", "canonical", ".", "This", "helps", "to", "increase", "performance", "." ]
7338e265e1ab4ea2403da5ce80d934ef5f976923
https://github.com/gobwas/ws/blob/7338e265e1ab4ea2403da5ce80d934ef5f976923/http.go#L174-L183
train
gobwas/ws
http.go
httpError
func httpError(w http.ResponseWriter, body string, code int) { w.Header().Set("Content-Type", "text/plain; charset=utf-8") w.Header().Set("Content-Length", strconv.Itoa(len(body))) w.WriteHeader(code) w.Write([]byte(body)) }
go
func httpError(w http.ResponseWriter, body string, code int) { w.Header().Set("Content-Type", "text/plain; charset=utf-8") w.Header().Set("Content-Length", strconv.Itoa(len(body))) w.WriteHeader(code) w.Write([]byte(body)) }
[ "func", "httpError", "(", "w", "http", ".", "ResponseWriter", ",", "body", "string", ",", "code", "int", ")", "{", "w", ".", "Header", "(", ")", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "w", ".", "Header", "(", ")", ".", "Set", "(", "\"", "\"", ",", "strconv", ".", "Itoa", "(", "len", "(", "body", ")", ")", ")", "\n", "w", ".", "WriteHeader", "(", "code", ")", "\n", "w", ".", "Write", "(", "[", "]", "byte", "(", "body", ")", ")", "\n", "}" ]
// httpError is like the http.Error with WebSocket context exception.
[ "httpError", "is", "like", "the", "http", ".", "Error", "with", "WebSocket", "context", "exception", "." ]
7338e265e1ab4ea2403da5ce80d934ef5f976923
https://github.com/gobwas/ws/blob/7338e265e1ab4ea2403da5ce80d934ef5f976923/http.go#L375-L380
train
gobwas/ws
check.go
Is
func (s State) Is(v State) bool { return uint8(s)&uint8(v) != 0 }
go
func (s State) Is(v State) bool { return uint8(s)&uint8(v) != 0 }
[ "func", "(", "s", "State", ")", "Is", "(", "v", "State", ")", "bool", "{", "return", "uint8", "(", "s", ")", "&", "uint8", "(", "v", ")", "!=", "0", "\n", "}" ]
// Is checks whether the s has v enabled.
[ "Is", "checks", "whether", "the", "s", "has", "v", "enabled", "." ]
7338e265e1ab4ea2403da5ce80d934ef5f976923
https://github.com/gobwas/ws/blob/7338e265e1ab4ea2403da5ce80d934ef5f976923/check.go#L22-L24
train
gobwas/ws
wsutil/reader.go
NewReader
func NewReader(r io.Reader, s ws.State) *Reader { return &Reader{ Source: r, State: s, } }
go
func NewReader(r io.Reader, s ws.State) *Reader { return &Reader{ Source: r, State: s, } }
[ "func", "NewReader", "(", "r", "io", ".", "Reader", ",", "s", "ws", ".", "State", ")", "*", "Reader", "{", "return", "&", "Reader", "{", "Source", ":", "r", ",", "State", ":", "s", ",", "}", "\n", "}" ]
// NewReader creates new frame reader that reads from r keeping given state to // make some protocol validity checks when it needed.
[ "NewReader", "creates", "new", "frame", "reader", "that", "reads", "from", "r", "keeping", "given", "state", "to", "make", "some", "protocol", "validity", "checks", "when", "it", "needed", "." ]
7338e265e1ab4ea2403da5ce80d934ef5f976923
https://github.com/gobwas/ws/blob/7338e265e1ab4ea2403da5ce80d934ef5f976923/wsutil/reader.go#L53-L58
train
gobwas/ws
wsutil/reader.go
Discard
func (r *Reader) Discard() (err error) { for { _, err = io.Copy(ioutil.Discard, &r.raw) if err != nil { break } if !r.fragmented() { break } if _, err = r.NextFrame(); err != nil { break } } r.reset() return err }
go
func (r *Reader) Discard() (err error) { for { _, err = io.Copy(ioutil.Discard, &r.raw) if err != nil { break } if !r.fragmented() { break } if _, err = r.NextFrame(); err != nil { break } } r.reset() return err }
[ "func", "(", "r", "*", "Reader", ")", "Discard", "(", ")", "(", "err", "error", ")", "{", "for", "{", "_", ",", "err", "=", "io", ".", "Copy", "(", "ioutil", ".", "Discard", ",", "&", "r", ".", "raw", ")", "\n", "if", "err", "!=", "nil", "{", "break", "\n", "}", "\n", "if", "!", "r", ".", "fragmented", "(", ")", "{", "break", "\n", "}", "\n", "if", "_", ",", "err", "=", "r", ".", "NextFrame", "(", ")", ";", "err", "!=", "nil", "{", "break", "\n", "}", "\n", "}", "\n", "r", ".", "reset", "(", ")", "\n", "return", "err", "\n", "}" ]
// Discard discards current message unread bytes. // It discards all frames of fragmeneted message.
[ "Discard", "discards", "current", "message", "unread", "bytes", ".", "It", "discards", "all", "frames", "of", "fragmeneted", "message", "." ]
7338e265e1ab4ea2403da5ce80d934ef5f976923
https://github.com/gobwas/ws/blob/7338e265e1ab4ea2403da5ce80d934ef5f976923/wsutil/reader.go#L128-L143
train
gobwas/ws
wsutil/cipher.go
NewCipherReader
func NewCipherReader(r io.Reader, mask [4]byte) *CipherReader { return &CipherReader{r, mask, 0} }
go
func NewCipherReader(r io.Reader, mask [4]byte) *CipherReader { return &CipherReader{r, mask, 0} }
[ "func", "NewCipherReader", "(", "r", "io", ".", "Reader", ",", "mask", "[", "4", "]", "byte", ")", "*", "CipherReader", "{", "return", "&", "CipherReader", "{", "r", ",", "mask", ",", "0", "}", "\n", "}" ]
// NewCipherReader creates xor-cipher reader from r with given mask.
[ "NewCipherReader", "creates", "xor", "-", "cipher", "reader", "from", "r", "with", "given", "mask", "." ]
7338e265e1ab4ea2403da5ce80d934ef5f976923
https://github.com/gobwas/ws/blob/7338e265e1ab4ea2403da5ce80d934ef5f976923/wsutil/cipher.go#L20-L22
train
gobwas/ws
wsutil/cipher.go
Reset
func (c *CipherReader) Reset(r io.Reader, mask [4]byte) { c.r = r c.mask = mask c.pos = 0 }
go
func (c *CipherReader) Reset(r io.Reader, mask [4]byte) { c.r = r c.mask = mask c.pos = 0 }
[ "func", "(", "c", "*", "CipherReader", ")", "Reset", "(", "r", "io", ".", "Reader", ",", "mask", "[", "4", "]", "byte", ")", "{", "c", ".", "r", "=", "r", "\n", "c", ".", "mask", "=", "mask", "\n", "c", ".", "pos", "=", "0", "\n", "}" ]
// Reset resets CipherReader to read from r with given mask.
[ "Reset", "resets", "CipherReader", "to", "read", "from", "r", "with", "given", "mask", "." ]
7338e265e1ab4ea2403da5ce80d934ef5f976923
https://github.com/gobwas/ws/blob/7338e265e1ab4ea2403da5ce80d934ef5f976923/wsutil/cipher.go#L25-L29
train
gobwas/ws
wsutil/cipher.go
Read
func (c *CipherReader) Read(p []byte) (n int, err error) { n, err = c.r.Read(p) ws.Cipher(p[:n], c.mask, c.pos) c.pos += n return }
go
func (c *CipherReader) Read(p []byte) (n int, err error) { n, err = c.r.Read(p) ws.Cipher(p[:n], c.mask, c.pos) c.pos += n return }
[ "func", "(", "c", "*", "CipherReader", ")", "Read", "(", "p", "[", "]", "byte", ")", "(", "n", "int", ",", "err", "error", ")", "{", "n", ",", "err", "=", "c", ".", "r", ".", "Read", "(", "p", ")", "\n", "ws", ".", "Cipher", "(", "p", "[", ":", "n", "]", ",", "c", ".", "mask", ",", "c", ".", "pos", ")", "\n", "c", ".", "pos", "+=", "n", "\n", "return", "\n", "}" ]
// Read implements io.Reader interface. It applies mask given during // initialization to every read byte.
[ "Read", "implements", "io", ".", "Reader", "interface", ".", "It", "applies", "mask", "given", "during", "initialization", "to", "every", "read", "byte", "." ]
7338e265e1ab4ea2403da5ce80d934ef5f976923
https://github.com/gobwas/ws/blob/7338e265e1ab4ea2403da5ce80d934ef5f976923/wsutil/cipher.go#L33-L38
train
gobwas/ws
wsutil/cipher.go
NewCipherWriter
func NewCipherWriter(w io.Writer, mask [4]byte) *CipherWriter { return &CipherWriter{w, mask, 0} }
go
func NewCipherWriter(w io.Writer, mask [4]byte) *CipherWriter { return &CipherWriter{w, mask, 0} }
[ "func", "NewCipherWriter", "(", "w", "io", ".", "Writer", ",", "mask", "[", "4", "]", "byte", ")", "*", "CipherWriter", "{", "return", "&", "CipherWriter", "{", "w", ",", "mask", ",", "0", "}", "\n", "}" ]
// NewCipherWriter creates xor-cipher writer to w with given mask.
[ "NewCipherWriter", "creates", "xor", "-", "cipher", "writer", "to", "w", "with", "given", "mask", "." ]
7338e265e1ab4ea2403da5ce80d934ef5f976923
https://github.com/gobwas/ws/blob/7338e265e1ab4ea2403da5ce80d934ef5f976923/wsutil/cipher.go#L49-L51
train
gobwas/ws
wsutil/cipher.go
Reset
func (c *CipherWriter) Reset(w io.Writer, mask [4]byte) { c.w = w c.mask = mask c.pos = 0 }
go
func (c *CipherWriter) Reset(w io.Writer, mask [4]byte) { c.w = w c.mask = mask c.pos = 0 }
[ "func", "(", "c", "*", "CipherWriter", ")", "Reset", "(", "w", "io", ".", "Writer", ",", "mask", "[", "4", "]", "byte", ")", "{", "c", ".", "w", "=", "w", "\n", "c", ".", "mask", "=", "mask", "\n", "c", ".", "pos", "=", "0", "\n", "}" ]
// Reset reset CipherWriter to write to w with given mask.
[ "Reset", "reset", "CipherWriter", "to", "write", "to", "w", "with", "given", "mask", "." ]
7338e265e1ab4ea2403da5ce80d934ef5f976923
https://github.com/gobwas/ws/blob/7338e265e1ab4ea2403da5ce80d934ef5f976923/wsutil/cipher.go#L54-L58
train
gobwas/ws
wsutil/cipher.go
Write
func (c *CipherWriter) Write(p []byte) (n int, err error) { cp := pbytes.GetLen(len(p)) defer pbytes.Put(cp) copy(cp, p) ws.Cipher(cp, c.mask, c.pos) n, err = c.w.Write(cp) c.pos += n return }
go
func (c *CipherWriter) Write(p []byte) (n int, err error) { cp := pbytes.GetLen(len(p)) defer pbytes.Put(cp) copy(cp, p) ws.Cipher(cp, c.mask, c.pos) n, err = c.w.Write(cp) c.pos += n return }
[ "func", "(", "c", "*", "CipherWriter", ")", "Write", "(", "p", "[", "]", "byte", ")", "(", "n", "int", ",", "err", "error", ")", "{", "cp", ":=", "pbytes", ".", "GetLen", "(", "len", "(", "p", ")", ")", "\n", "defer", "pbytes", ".", "Put", "(", "cp", ")", "\n\n", "copy", "(", "cp", ",", "p", ")", "\n", "ws", ".", "Cipher", "(", "cp", ",", "c", ".", "mask", ",", "c", ".", "pos", ")", "\n", "n", ",", "err", "=", "c", ".", "w", ".", "Write", "(", "cp", ")", "\n", "c", ".", "pos", "+=", "n", "\n\n", "return", "\n", "}" ]
// Write implements io.Writer interface. It applies mask vien during // initialization to every sent byte. It does not modify original slice.
[ "Write", "implements", "io", ".", "Writer", "interface", ".", "It", "applies", "mask", "vien", "during", "initialization", "to", "every", "sent", "byte", ".", "It", "does", "not", "modify", "original", "slice", "." ]
7338e265e1ab4ea2403da5ce80d934ef5f976923
https://github.com/gobwas/ws/blob/7338e265e1ab4ea2403da5ce80d934ef5f976923/wsutil/cipher.go#L62-L72
train
rkt/rkt
store/imagestore/remote.go
GetRemote
func GetRemote(tx *sql.Tx, aciURL string) (*Remote, error) { rows, err := tx.Query("SELECT * FROM remote WHERE aciurl == $1", aciURL) if err != nil { return nil, err } defer rows.Close() if ok := rows.Next(); !ok { return nil, ErrRemoteNotFound } remote := &Remote{} if err := remoteRowScan(rows, remote); err != nil { return nil, err } if err := rows.Err(); err != nil { return nil, err } return remote, nil }
go
func GetRemote(tx *sql.Tx, aciURL string) (*Remote, error) { rows, err := tx.Query("SELECT * FROM remote WHERE aciurl == $1", aciURL) if err != nil { return nil, err } defer rows.Close() if ok := rows.Next(); !ok { return nil, ErrRemoteNotFound } remote := &Remote{} if err := remoteRowScan(rows, remote); err != nil { return nil, err } if err := rows.Err(); err != nil { return nil, err } return remote, nil }
[ "func", "GetRemote", "(", "tx", "*", "sql", ".", "Tx", ",", "aciURL", "string", ")", "(", "*", "Remote", ",", "error", ")", "{", "rows", ",", "err", ":=", "tx", ".", "Query", "(", "\"", "\"", ",", "aciURL", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "rows", ".", "Close", "(", ")", "\n\n", "if", "ok", ":=", "rows", ".", "Next", "(", ")", ";", "!", "ok", "{", "return", "nil", ",", "ErrRemoteNotFound", "\n", "}", "\n\n", "remote", ":=", "&", "Remote", "{", "}", "\n", "if", "err", ":=", "remoteRowScan", "(", "rows", ",", "remote", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "err", ":=", "rows", ".", "Err", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "remote", ",", "nil", "\n", "}" ]
// GetRemote tries to retrieve a remote with the given aciURL. // If remote doesn't exist, it returns ErrRemoteNotFound error.
[ "GetRemote", "tries", "to", "retrieve", "a", "remote", "with", "the", "given", "aciURL", ".", "If", "remote", "doesn", "t", "exist", "it", "returns", "ErrRemoteNotFound", "error", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/store/imagestore/remote.go#L56-L77
train
rkt/rkt
store/imagestore/remote.go
GetAllRemotes
func GetAllRemotes(tx *sql.Tx) ([]*Remote, error) { var remotes []*Remote query := "SELECT * from remote" rows, err := tx.Query(query) if err != nil { return nil, err } defer rows.Close() for rows.Next() { r := &Remote{} if err := remoteRowScan(rows, r); err != nil { return nil, err } remotes = append(remotes, r) } if err := rows.Err(); err != nil { return nil, err } return remotes, nil }
go
func GetAllRemotes(tx *sql.Tx) ([]*Remote, error) { var remotes []*Remote query := "SELECT * from remote" rows, err := tx.Query(query) if err != nil { return nil, err } defer rows.Close() for rows.Next() { r := &Remote{} if err := remoteRowScan(rows, r); err != nil { return nil, err } remotes = append(remotes, r) } if err := rows.Err(); err != nil { return nil, err } return remotes, nil }
[ "func", "GetAllRemotes", "(", "tx", "*", "sql", ".", "Tx", ")", "(", "[", "]", "*", "Remote", ",", "error", ")", "{", "var", "remotes", "[", "]", "*", "Remote", "\n", "query", ":=", "\"", "\"", "\n\n", "rows", ",", "err", ":=", "tx", ".", "Query", "(", "query", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n\n", "}", "\n", "defer", "rows", ".", "Close", "(", ")", "\n\n", "for", "rows", ".", "Next", "(", ")", "{", "r", ":=", "&", "Remote", "{", "}", "\n", "if", "err", ":=", "remoteRowScan", "(", "rows", ",", "r", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n\n", "}", "\n\n", "remotes", "=", "append", "(", "remotes", ",", "r", ")", "\n\n", "}", "\n\n", "if", "err", ":=", "rows", ".", "Err", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n\n", "}", "\n\n", "return", "remotes", ",", "nil", "\n\n", "}" ]
// GetAllRemotes returns all the ACIInfos sorted by optional sortfields and // with ascending or descending order.
[ "GetAllRemotes", "returns", "all", "the", "ACIInfos", "sorted", "by", "optional", "sortfields", "and", "with", "ascending", "or", "descending", "order", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/store/imagestore/remote.go#L81-L110
train
rkt/rkt
store/imagestore/remote.go
RemoveRemote
func RemoveRemote(tx *sql.Tx, blobKey string) error { _, err := tx.Exec("DELETE FROM remote WHERE blobkey == $1", blobKey) if err != nil { return err } return nil }
go
func RemoveRemote(tx *sql.Tx, blobKey string) error { _, err := tx.Exec("DELETE FROM remote WHERE blobkey == $1", blobKey) if err != nil { return err } return nil }
[ "func", "RemoveRemote", "(", "tx", "*", "sql", ".", "Tx", ",", "blobKey", "string", ")", "error", "{", "_", ",", "err", ":=", "tx", ".", "Exec", "(", "\"", "\"", ",", "blobKey", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "nil", "\n", "}" ]
// RemoveRemote removes the remote with the given blobKey.
[ "RemoveRemote", "removes", "the", "remote", "with", "the", "given", "blobKey", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/store/imagestore/remote.go#L128-L134
train
rkt/rkt
stage1/init/init.go
machinedRegister
func machinedRegister() bool { // machined has a D-Bus interface following versioning guidelines, see: // http://www.freedesktop.org/wiki/Software/systemd/machined/ // Therefore we can just check if the D-Bus method we need exists and we // don't need to check the signature. var found int conn, err := dbus.SystemBus() if err != nil { return false } node, err := introspect.Call(conn.Object("org.freedesktop.machine1", "/org/freedesktop/machine1")) if err != nil { return false } for _, iface := range node.Interfaces { if iface.Name != "org.freedesktop.machine1.Manager" { continue } // machined v215 supports methods "RegisterMachine" and "CreateMachine" called by nspawn v215. // machined v216+ (since commit 5aa4bb) additionally supports methods "CreateMachineWithNetwork" // and "RegisterMachineWithNetwork", called by nspawn v216+. for _, method := range iface.Methods { if method.Name == "CreateMachineWithNetwork" || method.Name == "RegisterMachineWithNetwork" { found++ } } break } return found == 2 }
go
func machinedRegister() bool { // machined has a D-Bus interface following versioning guidelines, see: // http://www.freedesktop.org/wiki/Software/systemd/machined/ // Therefore we can just check if the D-Bus method we need exists and we // don't need to check the signature. var found int conn, err := dbus.SystemBus() if err != nil { return false } node, err := introspect.Call(conn.Object("org.freedesktop.machine1", "/org/freedesktop/machine1")) if err != nil { return false } for _, iface := range node.Interfaces { if iface.Name != "org.freedesktop.machine1.Manager" { continue } // machined v215 supports methods "RegisterMachine" and "CreateMachine" called by nspawn v215. // machined v216+ (since commit 5aa4bb) additionally supports methods "CreateMachineWithNetwork" // and "RegisterMachineWithNetwork", called by nspawn v216+. for _, method := range iface.Methods { if method.Name == "CreateMachineWithNetwork" || method.Name == "RegisterMachineWithNetwork" { found++ } } break } return found == 2 }
[ "func", "machinedRegister", "(", ")", "bool", "{", "// machined has a D-Bus interface following versioning guidelines, see:", "// http://www.freedesktop.org/wiki/Software/systemd/machined/", "// Therefore we can just check if the D-Bus method we need exists and we", "// don't need to check the signature.", "var", "found", "int", "\n\n", "conn", ",", "err", ":=", "dbus", ".", "SystemBus", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", "\n", "}", "\n", "node", ",", "err", ":=", "introspect", ".", "Call", "(", "conn", ".", "Object", "(", "\"", "\"", ",", "\"", "\"", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", "\n", "}", "\n", "for", "_", ",", "iface", ":=", "range", "node", ".", "Interfaces", "{", "if", "iface", ".", "Name", "!=", "\"", "\"", "{", "continue", "\n", "}", "\n", "// machined v215 supports methods \"RegisterMachine\" and \"CreateMachine\" called by nspawn v215.", "// machined v216+ (since commit 5aa4bb) additionally supports methods \"CreateMachineWithNetwork\"", "// and \"RegisterMachineWithNetwork\", called by nspawn v216+.", "for", "_", ",", "method", ":=", "range", "iface", ".", "Methods", "{", "if", "method", ".", "Name", "==", "\"", "\"", "||", "method", ".", "Name", "==", "\"", "\"", "{", "found", "++", "\n", "}", "\n", "}", "\n", "break", "\n", "}", "\n", "return", "found", "==", "2", "\n", "}" ]
// machinedRegister checks if nspawn should register the pod to machined
[ "machinedRegister", "checks", "if", "nspawn", "should", "register", "the", "pod", "to", "machined" ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage1/init/init.go#L162-L192
train
rkt/rkt
stage1/init/init.go
mountContainerV1Cgroups
func mountContainerV1Cgroups(m fs.Mounter, p *stage1commontypes.Pod, enabledCgroups map[int][]string, subcgroup string, serviceNames []string) error { mountContext := os.Getenv(common.EnvSELinuxMountContext) stage1Root := common.Stage1RootfsPath(p.Root) if err := v1.CreateCgroups(m, stage1Root, enabledCgroups, mountContext); err != nil { return errwrap.Wrap(errors.New("error creating container cgroups"), err) } if err := v1.RemountCgroups(m, stage1Root, enabledCgroups, subcgroup, p.InsecureOptions.DisablePaths); err != nil { return errwrap.Wrap(errors.New("error restricting container cgroups"), err) } return nil }
go
func mountContainerV1Cgroups(m fs.Mounter, p *stage1commontypes.Pod, enabledCgroups map[int][]string, subcgroup string, serviceNames []string) error { mountContext := os.Getenv(common.EnvSELinuxMountContext) stage1Root := common.Stage1RootfsPath(p.Root) if err := v1.CreateCgroups(m, stage1Root, enabledCgroups, mountContext); err != nil { return errwrap.Wrap(errors.New("error creating container cgroups"), err) } if err := v1.RemountCgroups(m, stage1Root, enabledCgroups, subcgroup, p.InsecureOptions.DisablePaths); err != nil { return errwrap.Wrap(errors.New("error restricting container cgroups"), err) } return nil }
[ "func", "mountContainerV1Cgroups", "(", "m", "fs", ".", "Mounter", ",", "p", "*", "stage1commontypes", ".", "Pod", ",", "enabledCgroups", "map", "[", "int", "]", "[", "]", "string", ",", "subcgroup", "string", ",", "serviceNames", "[", "]", "string", ")", "error", "{", "mountContext", ":=", "os", ".", "Getenv", "(", "common", ".", "EnvSELinuxMountContext", ")", "\n", "stage1Root", ":=", "common", ".", "Stage1RootfsPath", "(", "p", ".", "Root", ")", "\n", "if", "err", ":=", "v1", ".", "CreateCgroups", "(", "m", ",", "stage1Root", ",", "enabledCgroups", ",", "mountContext", ")", ";", "err", "!=", "nil", "{", "return", "errwrap", ".", "Wrap", "(", "errors", ".", "New", "(", "\"", "\"", ")", ",", "err", ")", "\n", "}", "\n\n", "if", "err", ":=", "v1", ".", "RemountCgroups", "(", "m", ",", "stage1Root", ",", "enabledCgroups", ",", "subcgroup", ",", "p", ".", "InsecureOptions", ".", "DisablePaths", ")", ";", "err", "!=", "nil", "{", "return", "errwrap", ".", "Wrap", "(", "errors", ".", "New", "(", "\"", "\"", ")", ",", "err", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]
// mountContainerV1Cgroups mounts the cgroup controllers hierarchy in the container's // namespace read-only, leaving the needed knobs in the subcgroup for each-app // read-write so systemd inside stage1 can apply isolators to them
[ "mountContainerV1Cgroups", "mounts", "the", "cgroup", "controllers", "hierarchy", "in", "the", "container", "s", "namespace", "read", "-", "only", "leaving", "the", "needed", "knobs", "in", "the", "subcgroup", "for", "each", "-", "app", "read", "-", "write", "so", "systemd", "inside", "stage1", "can", "apply", "isolators", "to", "them" ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage1/init/init.go#L843-L855
train
rkt/rkt
common/networking/ports.go
findAppPort
func findAppPort(manifest *schema.PodManifest, portName types.ACName) (*types.Port, error) { var foundPort *types.Port for _, app := range manifest.Apps { for _, port := range app.App.Ports { if portName == port.Name { if foundPort != nil { // error: ambiguous return nil, fmt.Errorf("port name %q defined multiple apps", portName) } p := port // duplicate b/c port gets overwritten foundPort = &p } } } return foundPort, nil }
go
func findAppPort(manifest *schema.PodManifest, portName types.ACName) (*types.Port, error) { var foundPort *types.Port for _, app := range manifest.Apps { for _, port := range app.App.Ports { if portName == port.Name { if foundPort != nil { // error: ambiguous return nil, fmt.Errorf("port name %q defined multiple apps", portName) } p := port // duplicate b/c port gets overwritten foundPort = &p } } } return foundPort, nil }
[ "func", "findAppPort", "(", "manifest", "*", "schema", ".", "PodManifest", ",", "portName", "types", ".", "ACName", ")", "(", "*", "types", ".", "Port", ",", "error", ")", "{", "var", "foundPort", "*", "types", ".", "Port", "\n\n", "for", "_", ",", "app", ":=", "range", "manifest", ".", "Apps", "{", "for", "_", ",", "port", ":=", "range", "app", ".", "App", ".", "Ports", "{", "if", "portName", "==", "port", ".", "Name", "{", "if", "foundPort", "!=", "nil", "{", "// error: ambiguous", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "portName", ")", "\n", "}", "\n", "p", ":=", "port", "// duplicate b/c port gets overwritten", "\n", "foundPort", "=", "&", "p", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "foundPort", ",", "nil", "\n", "}" ]
// findAppPort looks through the manifest to find a port with a given name. // If multiple apps expose the same port name, it will fail
[ "findAppPort", "looks", "through", "the", "manifest", "to", "find", "a", "port", "with", "a", "given", "name", ".", "If", "multiple", "apps", "expose", "the", "same", "port", "name", "it", "will", "fail" ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/common/networking/ports.go#L34-L49
train
rkt/rkt
common/networking/ports.go
conflicts
func (fp *ForwardedPort) conflicts(fp1 *ForwardedPort) bool { if fp.PodPort.Protocol != fp1.PodPort.Protocol { return false } if fp.HostPort.HostPort != fp1.HostPort.HostPort { return false } // If either port has the 0.0.0.0 address, they conflict zeroAddr := net.IPv4(0, 0, 0, 0) if fp.HostPort.HostIP.Equal(zeroAddr) || fp1.HostPort.HostIP.Equal(zeroAddr) { return true } if fp.HostPort.HostIP.Equal(fp1.HostPort.HostIP) { return true } return false }
go
func (fp *ForwardedPort) conflicts(fp1 *ForwardedPort) bool { if fp.PodPort.Protocol != fp1.PodPort.Protocol { return false } if fp.HostPort.HostPort != fp1.HostPort.HostPort { return false } // If either port has the 0.0.0.0 address, they conflict zeroAddr := net.IPv4(0, 0, 0, 0) if fp.HostPort.HostIP.Equal(zeroAddr) || fp1.HostPort.HostIP.Equal(zeroAddr) { return true } if fp.HostPort.HostIP.Equal(fp1.HostPort.HostIP) { return true } return false }
[ "func", "(", "fp", "*", "ForwardedPort", ")", "conflicts", "(", "fp1", "*", "ForwardedPort", ")", "bool", "{", "if", "fp", ".", "PodPort", ".", "Protocol", "!=", "fp1", ".", "PodPort", ".", "Protocol", "{", "return", "false", "\n", "}", "\n\n", "if", "fp", ".", "HostPort", ".", "HostPort", "!=", "fp1", ".", "HostPort", ".", "HostPort", "{", "return", "false", "\n", "}", "\n\n", "// If either port has the 0.0.0.0 address, they conflict", "zeroAddr", ":=", "net", ".", "IPv4", "(", "0", ",", "0", ",", "0", ",", "0", ")", "\n", "if", "fp", ".", "HostPort", ".", "HostIP", ".", "Equal", "(", "zeroAddr", ")", "||", "fp1", ".", "HostPort", ".", "HostIP", ".", "Equal", "(", "zeroAddr", ")", "{", "return", "true", "\n", "}", "\n\n", "if", "fp", ".", "HostPort", ".", "HostIP", ".", "Equal", "(", "fp1", ".", "HostPort", ".", "HostIP", ")", "{", "return", "true", "\n", "}", "\n\n", "return", "false", "\n", "}" ]
// conflicts checks if two ports conflict with each other
[ "conflicts", "checks", "if", "two", "ports", "conflict", "with", "each", "other" ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/common/networking/ports.go#L99-L119
train
rkt/rkt
pkg/flag/pairlist.go
SetOne
func (pl *PairList) SetOne(key, val string) error { // Check that key is allowed if len(pl.permissible) > 0 { permVals, ok := pl.permissible[key] if !ok { return fmt.Errorf("key %v is not allowed", key) } // Check that value is allowed if len(permVals) > 0 { _, ok = permVals[val] if !ok { return fmt.Errorf("key %v does not allow value %v", key, val) } } } pl.Pairs[key] = val return nil }
go
func (pl *PairList) SetOne(key, val string) error { // Check that key is allowed if len(pl.permissible) > 0 { permVals, ok := pl.permissible[key] if !ok { return fmt.Errorf("key %v is not allowed", key) } // Check that value is allowed if len(permVals) > 0 { _, ok = permVals[val] if !ok { return fmt.Errorf("key %v does not allow value %v", key, val) } } } pl.Pairs[key] = val return nil }
[ "func", "(", "pl", "*", "PairList", ")", "SetOne", "(", "key", ",", "val", "string", ")", "error", "{", "// Check that key is allowed", "if", "len", "(", "pl", ".", "permissible", ")", ">", "0", "{", "permVals", ",", "ok", ":=", "pl", ".", "permissible", "[", "key", "]", "\n", "if", "!", "ok", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "key", ")", "\n", "}", "\n\n", "// Check that value is allowed", "if", "len", "(", "permVals", ")", ">", "0", "{", "_", ",", "ok", "=", "permVals", "[", "val", "]", "\n", "if", "!", "ok", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "key", ",", "val", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "pl", ".", "Pairs", "[", "key", "]", "=", "val", "\n", "return", "nil", "\n", "}" ]
// SetOne validates and sets an individual key-value pair // It will overwrite an existing value
[ "SetOne", "validates", "and", "sets", "an", "individual", "key", "-", "value", "pair", "It", "will", "overwrite", "an", "existing", "value" ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/flag/pairlist.go#L97-L116
train
rkt/rkt
pkg/flag/pairlist.go
Keys
func (pl *PairList) Keys() []string { keys := make([]string, 0, len(pl.Pairs)) for k := range pl.Pairs { keys = append(keys, k) } sort.Strings(keys) return keys }
go
func (pl *PairList) Keys() []string { keys := make([]string, 0, len(pl.Pairs)) for k := range pl.Pairs { keys = append(keys, k) } sort.Strings(keys) return keys }
[ "func", "(", "pl", "*", "PairList", ")", "Keys", "(", ")", "[", "]", "string", "{", "keys", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "pl", ".", "Pairs", ")", ")", "\n", "for", "k", ":=", "range", "pl", ".", "Pairs", "{", "keys", "=", "append", "(", "keys", ",", "k", ")", "\n", "}", "\n", "sort", ".", "Strings", "(", "keys", ")", "\n", "return", "keys", "\n", "}" ]
// Keys returns a sorted list of all present keys
[ "Keys", "returns", "a", "sorted", "list", "of", "all", "present", "keys" ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/flag/pairlist.go#L119-L126
train
rkt/rkt
pkg/flag/pairlist.go
String
func (pl *PairList) String() string { ps := make([]string, 0, len(pl.Pairs)) for _, k := range pl.Keys() { ps = append(ps, fmt.Sprintf("%v=%v", k, pl.Pairs[k])) } return strings.Join(ps, " ") }
go
func (pl *PairList) String() string { ps := make([]string, 0, len(pl.Pairs)) for _, k := range pl.Keys() { ps = append(ps, fmt.Sprintf("%v=%v", k, pl.Pairs[k])) } return strings.Join(ps, " ") }
[ "func", "(", "pl", "*", "PairList", ")", "String", "(", ")", "string", "{", "ps", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "pl", ".", "Pairs", ")", ")", "\n", "for", "_", ",", "k", ":=", "range", "pl", ".", "Keys", "(", ")", "{", "ps", "=", "append", "(", "ps", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "k", ",", "pl", ".", "Pairs", "[", "k", "]", ")", ")", "\n", "}", "\n", "return", "strings", ".", "Join", "(", "ps", ",", "\"", "\"", ")", "\n", "}" ]
// String presents a k=v list in key=sorted order
[ "String", "presents", "a", "k", "=", "v", "list", "in", "key", "=", "sorted", "order" ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/flag/pairlist.go#L129-L135
train
rkt/rkt
pkg/flag/pairlist.go
SerializePairs
func SerializePairs(pairs map[string]string) string { tmp := make([]string, 0, len(pairs)) for k, v := range pairs { tmp = append(tmp, fmt.Sprintf("%s=%s", k, v)) } return strings.Join(tmp, ",") }
go
func SerializePairs(pairs map[string]string) string { tmp := make([]string, 0, len(pairs)) for k, v := range pairs { tmp = append(tmp, fmt.Sprintf("%s=%s", k, v)) } return strings.Join(tmp, ",") }
[ "func", "SerializePairs", "(", "pairs", "map", "[", "string", "]", "string", ")", "string", "{", "tmp", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "pairs", ")", ")", "\n\n", "for", "k", ",", "v", ":=", "range", "pairs", "{", "tmp", "=", "append", "(", "tmp", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "k", ",", "v", ")", ")", "\n", "}", "\n", "return", "strings", ".", "Join", "(", "tmp", ",", "\"", "\"", ")", "\n", "}" ]
// Serialize takes a map and generates a string that can be parsed by Set
[ "Serialize", "takes", "a", "map", "and", "generates", "a", "string", "that", "can", "be", "parsed", "by", "Set" ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/flag/pairlist.go#L172-L179
train
rkt/rkt
pkg/tar/chroot.go
extractTarCommand
func extractTarCommand() error { if len(os.Args) != 5 { return fmt.Errorf("incorrect number of arguments. Usage: %s DIR {true|false} uidShift uidCount", multicallName) } if !sys.HasChrootCapability() { return fmt.Errorf("chroot capability not available.") } dir := os.Args[1] if !filepath.IsAbs(dir) { return fmt.Errorf("dir %s must be an absolute path", dir) } overwrite, err := strconv.ParseBool(os.Args[2]) if err != nil { return fmt.Errorf("error parsing overwrite argument: %v", err) } us, err := strconv.ParseUint(os.Args[3], 10, 32) if err != nil { return fmt.Errorf("error parsing uidShift argument: %v", err) } uc, err := strconv.ParseUint(os.Args[4], 10, 32) if err != nil { return fmt.Errorf("error parsing uidCount argument: %v", err) } uidRange := &user.UidRange{Shift: uint32(us), Count: uint32(uc)} if err := syscall.Chroot(dir); err != nil { return fmt.Errorf("failed to chroot in %s: %v", dir, err) } if err := syscall.Chdir("/"); err != nil { return fmt.Errorf("failed to chdir: %v", err) } fileMapFile := os.NewFile(uintptr(fileMapFdNum), "fileMap") fileMap := map[string]struct{}{} if err := json.NewDecoder(fileMapFile).Decode(&fileMap); err != nil { return fmt.Errorf("error decoding fileMap: %v", err) } editor, err := NewUidShiftingFilePermEditor(uidRange) if err != nil { return fmt.Errorf("error determining current user: %v", err) } if err := ExtractTarInsecure(tar.NewReader(os.Stdin), "/", overwrite, fileMap, editor); err != nil { return fmt.Errorf("error extracting tar: %v", err) } // flush remaining bytes io.Copy(ioutil.Discard, os.Stdin) return nil }
go
func extractTarCommand() error { if len(os.Args) != 5 { return fmt.Errorf("incorrect number of arguments. Usage: %s DIR {true|false} uidShift uidCount", multicallName) } if !sys.HasChrootCapability() { return fmt.Errorf("chroot capability not available.") } dir := os.Args[1] if !filepath.IsAbs(dir) { return fmt.Errorf("dir %s must be an absolute path", dir) } overwrite, err := strconv.ParseBool(os.Args[2]) if err != nil { return fmt.Errorf("error parsing overwrite argument: %v", err) } us, err := strconv.ParseUint(os.Args[3], 10, 32) if err != nil { return fmt.Errorf("error parsing uidShift argument: %v", err) } uc, err := strconv.ParseUint(os.Args[4], 10, 32) if err != nil { return fmt.Errorf("error parsing uidCount argument: %v", err) } uidRange := &user.UidRange{Shift: uint32(us), Count: uint32(uc)} if err := syscall.Chroot(dir); err != nil { return fmt.Errorf("failed to chroot in %s: %v", dir, err) } if err := syscall.Chdir("/"); err != nil { return fmt.Errorf("failed to chdir: %v", err) } fileMapFile := os.NewFile(uintptr(fileMapFdNum), "fileMap") fileMap := map[string]struct{}{} if err := json.NewDecoder(fileMapFile).Decode(&fileMap); err != nil { return fmt.Errorf("error decoding fileMap: %v", err) } editor, err := NewUidShiftingFilePermEditor(uidRange) if err != nil { return fmt.Errorf("error determining current user: %v", err) } if err := ExtractTarInsecure(tar.NewReader(os.Stdin), "/", overwrite, fileMap, editor); err != nil { return fmt.Errorf("error extracting tar: %v", err) } // flush remaining bytes io.Copy(ioutil.Discard, os.Stdin) return nil }
[ "func", "extractTarCommand", "(", ")", "error", "{", "if", "len", "(", "os", ".", "Args", ")", "!=", "5", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "multicallName", ")", "\n", "}", "\n", "if", "!", "sys", ".", "HasChrootCapability", "(", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "dir", ":=", "os", ".", "Args", "[", "1", "]", "\n", "if", "!", "filepath", ".", "IsAbs", "(", "dir", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "dir", ")", "\n", "}", "\n", "overwrite", ",", "err", ":=", "strconv", ".", "ParseBool", "(", "os", ".", "Args", "[", "2", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "us", ",", "err", ":=", "strconv", ".", "ParseUint", "(", "os", ".", "Args", "[", "3", "]", ",", "10", ",", "32", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "uc", ",", "err", ":=", "strconv", ".", "ParseUint", "(", "os", ".", "Args", "[", "4", "]", ",", "10", ",", "32", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "uidRange", ":=", "&", "user", ".", "UidRange", "{", "Shift", ":", "uint32", "(", "us", ")", ",", "Count", ":", "uint32", "(", "uc", ")", "}", "\n\n", "if", "err", ":=", "syscall", ".", "Chroot", "(", "dir", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "dir", ",", "err", ")", "\n", "}", "\n", "if", "err", ":=", "syscall", ".", "Chdir", "(", "\"", "\"", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "fileMapFile", ":=", "os", ".", "NewFile", "(", "uintptr", "(", "fileMapFdNum", ")", ",", "\"", "\"", ")", "\n\n", "fileMap", ":=", "map", "[", "string", "]", "struct", "{", "}", "{", "}", "\n", "if", "err", ":=", "json", ".", "NewDecoder", "(", "fileMapFile", ")", ".", "Decode", "(", "&", "fileMap", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "editor", ",", "err", ":=", "NewUidShiftingFilePermEditor", "(", "uidRange", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "if", "err", ":=", "ExtractTarInsecure", "(", "tar", ".", "NewReader", "(", "os", ".", "Stdin", ")", ",", "\"", "\"", ",", "overwrite", ",", "fileMap", ",", "editor", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// flush remaining bytes", "io", ".", "Copy", "(", "ioutil", ".", "Discard", ",", "os", ".", "Stdin", ")", "\n\n", "return", "nil", "\n", "}" ]
// Because this function is executed by multicall in a different process, it is not possible to use errwrap to return errors
[ "Because", "this", "function", "is", "executed", "by", "multicall", "in", "a", "different", "process", "it", "is", "not", "possible", "to", "use", "errwrap", "to", "return", "errors" ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/tar/chroot.go#L47-L98
train
rkt/rkt
pkg/distribution/docker.go
NewDocker
func NewDocker(u *url.URL) (Distribution, error) { dp, err := parseCIMD(u) if err != nil { return nil, fmt.Errorf("cannot parse URI: %q: %v", u.String(), err) } if dp.Type != TypeDocker { return nil, fmt.Errorf("wrong distribution type: %q", dp.Type) } parsed, err := d2acommon.ParseDockerURL(dp.Data) if err != nil { return nil, fmt.Errorf("bad docker URL %q: %v", dp.Data, err) } return &Docker{ url: dp.Data, parsedURL: parsed, simple: SimpleDockerRef(parsed), full: FullDockerRef(parsed), }, nil }
go
func NewDocker(u *url.URL) (Distribution, error) { dp, err := parseCIMD(u) if err != nil { return nil, fmt.Errorf("cannot parse URI: %q: %v", u.String(), err) } if dp.Type != TypeDocker { return nil, fmt.Errorf("wrong distribution type: %q", dp.Type) } parsed, err := d2acommon.ParseDockerURL(dp.Data) if err != nil { return nil, fmt.Errorf("bad docker URL %q: %v", dp.Data, err) } return &Docker{ url: dp.Data, parsedURL: parsed, simple: SimpleDockerRef(parsed), full: FullDockerRef(parsed), }, nil }
[ "func", "NewDocker", "(", "u", "*", "url", ".", "URL", ")", "(", "Distribution", ",", "error", ")", "{", "dp", ",", "err", ":=", "parseCIMD", "(", "u", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "u", ".", "String", "(", ")", ",", "err", ")", "\n", "}", "\n", "if", "dp", ".", "Type", "!=", "TypeDocker", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "dp", ".", "Type", ")", "\n", "}", "\n\n", "parsed", ",", "err", ":=", "d2acommon", ".", "ParseDockerURL", "(", "dp", ".", "Data", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "dp", ".", "Data", ",", "err", ")", "\n", "}", "\n\n", "return", "&", "Docker", "{", "url", ":", "dp", ".", "Data", ",", "parsedURL", ":", "parsed", ",", "simple", ":", "SimpleDockerRef", "(", "parsed", ")", ",", "full", ":", "FullDockerRef", "(", "parsed", ")", ",", "}", ",", "nil", "\n", "}" ]
// NewDocker creates a new docker distribution from the provided distribution uri string
[ "NewDocker", "creates", "a", "new", "docker", "distribution", "from", "the", "provided", "distribution", "uri", "string" ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/distribution/docker.go#L58-L78
train
rkt/rkt
stage1/init/common/pod.go
execEscape
func execEscape(i int, str string) string { escapeMap := map[string]string{ `'`: `\`, } if i > 0 { // These are escaped only after the first argument escapeMap[`$`] = `$` escapeMap[`%`] = `%` } escArg := fmt.Sprintf("%q", str) for k := range escapeMap { reStr := `([` + regexp.QuoteMeta(k) + `])` re := regexp.MustCompile(reStr) escArg = re.ReplaceAllStringFunc(escArg, func(s string) string { escaped := escapeMap[s] + s return escaped }) } return escArg }
go
func execEscape(i int, str string) string { escapeMap := map[string]string{ `'`: `\`, } if i > 0 { // These are escaped only after the first argument escapeMap[`$`] = `$` escapeMap[`%`] = `%` } escArg := fmt.Sprintf("%q", str) for k := range escapeMap { reStr := `([` + regexp.QuoteMeta(k) + `])` re := regexp.MustCompile(reStr) escArg = re.ReplaceAllStringFunc(escArg, func(s string) string { escaped := escapeMap[s] + s return escaped }) } return escArg }
[ "func", "execEscape", "(", "i", "int", ",", "str", "string", ")", "string", "{", "escapeMap", ":=", "map", "[", "string", "]", "string", "{", "`'`", ":", "`\\`", ",", "}", "\n\n", "if", "i", ">", "0", "{", "// These are escaped only after the first argument", "escapeMap", "[", "`$`", "]", "=", "`$`", "\n", "escapeMap", "[", "`%`", "]", "=", "`%`", "\n", "}", "\n\n", "escArg", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "str", ")", "\n", "for", "k", ":=", "range", "escapeMap", "{", "reStr", ":=", "`([`", "+", "regexp", ".", "QuoteMeta", "(", "k", ")", "+", "`])`", "\n", "re", ":=", "regexp", ".", "MustCompile", "(", "reStr", ")", "\n", "escArg", "=", "re", ".", "ReplaceAllStringFunc", "(", "escArg", ",", "func", "(", "s", "string", ")", "string", "{", "escaped", ":=", "escapeMap", "[", "s", "]", "+", "s", "\n", "return", "escaped", "\n", "}", ")", "\n", "}", "\n", "return", "escArg", "\n", "}" ]
// execEscape uses Golang's string quoting for ", \, \n, and regex for special cases
[ "execEscape", "uses", "Golang", "s", "string", "quoting", "for", "\\", "\\", "n", "and", "regex", "for", "special", "cases" ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage1/init/common/pod.go#L51-L71
train
rkt/rkt
stage1/init/common/pod.go
quoteExec
func quoteExec(exec []string) string { if len(exec) == 0 { // existing callers always include at least the binary so this shouldn't occur. panic("empty exec") } var qexec []string for i, arg := range exec { escArg := execEscape(i, arg) qexec = append(qexec, escArg) } return strings.Join(qexec, " ") }
go
func quoteExec(exec []string) string { if len(exec) == 0 { // existing callers always include at least the binary so this shouldn't occur. panic("empty exec") } var qexec []string for i, arg := range exec { escArg := execEscape(i, arg) qexec = append(qexec, escArg) } return strings.Join(qexec, " ") }
[ "func", "quoteExec", "(", "exec", "[", "]", "string", ")", "string", "{", "if", "len", "(", "exec", ")", "==", "0", "{", "// existing callers always include at least the binary so this shouldn't occur.", "panic", "(", "\"", "\"", ")", "\n", "}", "\n\n", "var", "qexec", "[", "]", "string", "\n", "for", "i", ",", "arg", ":=", "range", "exec", "{", "escArg", ":=", "execEscape", "(", "i", ",", "arg", ")", "\n", "qexec", "=", "append", "(", "qexec", ",", "escArg", ")", "\n", "}", "\n", "return", "strings", ".", "Join", "(", "qexec", ",", "\"", "\"", ")", "\n", "}" ]
// quoteExec returns an array of quoted strings appropriate for systemd execStart usage
[ "quoteExec", "returns", "an", "array", "of", "quoted", "strings", "appropriate", "for", "systemd", "execStart", "usage" ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage1/init/common/pod.go#L74-L86
train
rkt/rkt
stage1/init/common/pod.go
SetJournalPermissions
func SetJournalPermissions(p *stage1commontypes.Pod) error { s1 := common.Stage1ImagePath(p.Root) rktgid, err := common.LookupGid(common.RktGroup) if err != nil { return fmt.Errorf("group %q not found", common.RktGroup) } journalPath := filepath.Join(s1, "rootfs", "var", "log", "journal") if err := os.MkdirAll(journalPath, os.FileMode(0755)); err != nil { return errwrap.Wrap(errors.New("error creating journal dir"), err) } a, err := acl.InitACL() if err != nil { return err } defer a.Free() if err := a.ParseACL(fmt.Sprintf("g:%d:r-x,m:r-x", rktgid)); err != nil { return errwrap.Wrap(errors.New("error parsing ACL string"), err) } if err := a.AddBaseEntries(journalPath); err != nil { return errwrap.Wrap(errors.New("error adding base ACL entries"), err) } if err := a.Valid(); err != nil { return err } if err := a.SetFileACLDefault(journalPath); err != nil { return errwrap.Wrap(fmt.Errorf("error setting default ACLs on %q", journalPath), err) } return nil }
go
func SetJournalPermissions(p *stage1commontypes.Pod) error { s1 := common.Stage1ImagePath(p.Root) rktgid, err := common.LookupGid(common.RktGroup) if err != nil { return fmt.Errorf("group %q not found", common.RktGroup) } journalPath := filepath.Join(s1, "rootfs", "var", "log", "journal") if err := os.MkdirAll(journalPath, os.FileMode(0755)); err != nil { return errwrap.Wrap(errors.New("error creating journal dir"), err) } a, err := acl.InitACL() if err != nil { return err } defer a.Free() if err := a.ParseACL(fmt.Sprintf("g:%d:r-x,m:r-x", rktgid)); err != nil { return errwrap.Wrap(errors.New("error parsing ACL string"), err) } if err := a.AddBaseEntries(journalPath); err != nil { return errwrap.Wrap(errors.New("error adding base ACL entries"), err) } if err := a.Valid(); err != nil { return err } if err := a.SetFileACLDefault(journalPath); err != nil { return errwrap.Wrap(fmt.Errorf("error setting default ACLs on %q", journalPath), err) } return nil }
[ "func", "SetJournalPermissions", "(", "p", "*", "stage1commontypes", ".", "Pod", ")", "error", "{", "s1", ":=", "common", ".", "Stage1ImagePath", "(", "p", ".", "Root", ")", "\n\n", "rktgid", ",", "err", ":=", "common", ".", "LookupGid", "(", "common", ".", "RktGroup", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "common", ".", "RktGroup", ")", "\n", "}", "\n\n", "journalPath", ":=", "filepath", ".", "Join", "(", "s1", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "if", "err", ":=", "os", ".", "MkdirAll", "(", "journalPath", ",", "os", ".", "FileMode", "(", "0755", ")", ")", ";", "err", "!=", "nil", "{", "return", "errwrap", ".", "Wrap", "(", "errors", ".", "New", "(", "\"", "\"", ")", ",", "err", ")", "\n", "}", "\n\n", "a", ",", "err", ":=", "acl", ".", "InitACL", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "a", ".", "Free", "(", ")", "\n\n", "if", "err", ":=", "a", ".", "ParseACL", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "rktgid", ")", ")", ";", "err", "!=", "nil", "{", "return", "errwrap", ".", "Wrap", "(", "errors", ".", "New", "(", "\"", "\"", ")", ",", "err", ")", "\n", "}", "\n\n", "if", "err", ":=", "a", ".", "AddBaseEntries", "(", "journalPath", ")", ";", "err", "!=", "nil", "{", "return", "errwrap", ".", "Wrap", "(", "errors", ".", "New", "(", "\"", "\"", ")", ",", "err", ")", "\n", "}", "\n\n", "if", "err", ":=", "a", ".", "Valid", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "err", ":=", "a", ".", "SetFileACLDefault", "(", "journalPath", ")", ";", "err", "!=", "nil", "{", "return", "errwrap", ".", "Wrap", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "journalPath", ")", ",", "err", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]
// SetJournalPermissions sets ACLs and permissions so the rkt group can access // the pod's logs
[ "SetJournalPermissions", "sets", "ACLs", "and", "permissions", "so", "the", "rkt", "group", "can", "access", "the", "pod", "s", "logs" ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage1/init/common/pod.go#L118-L154
train
rkt/rkt
stage1/init/common/pod.go
findHostPort
func findHostPort(pm schema.PodManifest, name types.ACName) uint { var port uint for _, p := range pm.Ports { if p.Name == name { port = p.HostPort } } return port }
go
func findHostPort(pm schema.PodManifest, name types.ACName) uint { var port uint for _, p := range pm.Ports { if p.Name == name { port = p.HostPort } } return port }
[ "func", "findHostPort", "(", "pm", "schema", ".", "PodManifest", ",", "name", "types", ".", "ACName", ")", "uint", "{", "var", "port", "uint", "\n", "for", "_", ",", "p", ":=", "range", "pm", ".", "Ports", "{", "if", "p", ".", "Name", "==", "name", "{", "port", "=", "p", ".", "HostPort", "\n", "}", "\n", "}", "\n", "return", "port", "\n", "}" ]
// findHostPort returns the port number on the host that corresponds to an // image manifest port identified by name
[ "findHostPort", "returns", "the", "port", "number", "on", "the", "host", "that", "corresponds", "to", "an", "image", "manifest", "port", "identified", "by", "name" ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage1/init/common/pod.go#L166-L174
train
rkt/rkt
stage1/init/common/pod.go
appSearchPaths
func appSearchPaths(p *stage1commontypes.Pod, workDir string, app types.App) []string { appEnv := app.Environment if imgPath, ok := appEnv.Get("PATH"); ok { return strings.Split(imgPath, ":") } // emulate exec(3) behavior, first check working directory and then the // list of directories returned by confstr(_CS_PATH). That's typically // "/bin:/usr/bin" so let's use that. return []string{workDir, "/bin", "/usr/bin"} }
go
func appSearchPaths(p *stage1commontypes.Pod, workDir string, app types.App) []string { appEnv := app.Environment if imgPath, ok := appEnv.Get("PATH"); ok { return strings.Split(imgPath, ":") } // emulate exec(3) behavior, first check working directory and then the // list of directories returned by confstr(_CS_PATH). That's typically // "/bin:/usr/bin" so let's use that. return []string{workDir, "/bin", "/usr/bin"} }
[ "func", "appSearchPaths", "(", "p", "*", "stage1commontypes", ".", "Pod", ",", "workDir", "string", ",", "app", "types", ".", "App", ")", "[", "]", "string", "{", "appEnv", ":=", "app", ".", "Environment", "\n\n", "if", "imgPath", ",", "ok", ":=", "appEnv", ".", "Get", "(", "\"", "\"", ")", ";", "ok", "{", "return", "strings", ".", "Split", "(", "imgPath", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// emulate exec(3) behavior, first check working directory and then the", "// list of directories returned by confstr(_CS_PATH). That's typically", "// \"/bin:/usr/bin\" so let's use that.", "return", "[", "]", "string", "{", "workDir", ",", "\"", "\"", ",", "\"", "\"", "}", "\n", "}" ]
// appSearchPaths returns a list of paths where we should search for // non-absolute exec binaries
[ "appSearchPaths", "returns", "a", "list", "of", "paths", "where", "we", "should", "search", "for", "non", "-", "absolute", "exec", "binaries" ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage1/init/common/pod.go#L251-L262
train
rkt/rkt
stage1/init/common/pod.go
FindBinPath
func FindBinPath(p *stage1commontypes.Pod, ra *schema.RuntimeApp) (string, error) { if len(ra.App.Exec) == 0 { return "", errors.New("app has no executable") } bin := ra.App.Exec[0] var binPath string switch { // absolute path, just use it case filepath.IsAbs(bin): binPath = bin // non-absolute path containing a slash, look in the working dir case strings.Contains(bin, "/"): binPath = filepath.Join(ra.App.WorkingDirectory, bin) // filename, search in the app's $PATH default: absRoot, err := filepath.Abs(p.Root) if err != nil { return "", errwrap.Wrap(errors.New("could not get pod's root absolute path"), err) } appRootfs := common.AppRootfsPath(absRoot, ra.Name) appPathDirs := appSearchPaths(p, ra.App.WorkingDirectory, *ra.App) appPath := strings.Join(appPathDirs, ":") binPath, err = lookupPathInsideApp(bin, appPath, appRootfs, ra.App.WorkingDirectory) if err != nil { return "", errwrap.Wrap(fmt.Errorf("error looking up %q", bin), err) } } return binPath, nil }
go
func FindBinPath(p *stage1commontypes.Pod, ra *schema.RuntimeApp) (string, error) { if len(ra.App.Exec) == 0 { return "", errors.New("app has no executable") } bin := ra.App.Exec[0] var binPath string switch { // absolute path, just use it case filepath.IsAbs(bin): binPath = bin // non-absolute path containing a slash, look in the working dir case strings.Contains(bin, "/"): binPath = filepath.Join(ra.App.WorkingDirectory, bin) // filename, search in the app's $PATH default: absRoot, err := filepath.Abs(p.Root) if err != nil { return "", errwrap.Wrap(errors.New("could not get pod's root absolute path"), err) } appRootfs := common.AppRootfsPath(absRoot, ra.Name) appPathDirs := appSearchPaths(p, ra.App.WorkingDirectory, *ra.App) appPath := strings.Join(appPathDirs, ":") binPath, err = lookupPathInsideApp(bin, appPath, appRootfs, ra.App.WorkingDirectory) if err != nil { return "", errwrap.Wrap(fmt.Errorf("error looking up %q", bin), err) } } return binPath, nil }
[ "func", "FindBinPath", "(", "p", "*", "stage1commontypes", ".", "Pod", ",", "ra", "*", "schema", ".", "RuntimeApp", ")", "(", "string", ",", "error", ")", "{", "if", "len", "(", "ra", ".", "App", ".", "Exec", ")", "==", "0", "{", "return", "\"", "\"", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "bin", ":=", "ra", ".", "App", ".", "Exec", "[", "0", "]", "\n\n", "var", "binPath", "string", "\n", "switch", "{", "// absolute path, just use it", "case", "filepath", ".", "IsAbs", "(", "bin", ")", ":", "binPath", "=", "bin", "\n", "// non-absolute path containing a slash, look in the working dir", "case", "strings", ".", "Contains", "(", "bin", ",", "\"", "\"", ")", ":", "binPath", "=", "filepath", ".", "Join", "(", "ra", ".", "App", ".", "WorkingDirectory", ",", "bin", ")", "\n", "// filename, search in the app's $PATH", "default", ":", "absRoot", ",", "err", ":=", "filepath", ".", "Abs", "(", "p", ".", "Root", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errwrap", ".", "Wrap", "(", "errors", ".", "New", "(", "\"", "\"", ")", ",", "err", ")", "\n", "}", "\n", "appRootfs", ":=", "common", ".", "AppRootfsPath", "(", "absRoot", ",", "ra", ".", "Name", ")", "\n", "appPathDirs", ":=", "appSearchPaths", "(", "p", ",", "ra", ".", "App", ".", "WorkingDirectory", ",", "*", "ra", ".", "App", ")", "\n", "appPath", ":=", "strings", ".", "Join", "(", "appPathDirs", ",", "\"", "\"", ")", "\n\n", "binPath", ",", "err", "=", "lookupPathInsideApp", "(", "bin", ",", "appPath", ",", "appRootfs", ",", "ra", ".", "App", ".", "WorkingDirectory", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errwrap", ".", "Wrap", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "bin", ")", ",", "err", ")", "\n", "}", "\n", "}", "\n\n", "return", "binPath", ",", "nil", "\n", "}" ]
// FindBinPath takes a binary path and returns a the absolute path of the // binary relative to the app rootfs. This can be passed to ExecStart on the // app's systemd service file directly.
[ "FindBinPath", "takes", "a", "binary", "path", "and", "returns", "a", "the", "absolute", "path", "of", "the", "binary", "relative", "to", "the", "app", "rootfs", ".", "This", "can", "be", "passed", "to", "ExecStart", "on", "the", "app", "s", "systemd", "service", "file", "directly", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage1/init/common/pod.go#L267-L299
train
rkt/rkt
stage1/init/common/pod.go
EvaluateSymlinksInsideApp
func EvaluateSymlinksInsideApp(appRootfs, path string) (string, error) { chroot, err := newChroot(appRootfs) if err != nil { return "", errwrap.Wrapf(fmt.Sprintf("chroot to %q failed", appRootfs), err) } target, err := fileutil.EvalSymlinksAlways(path) if err != nil { return "", errwrap.Wrapf(fmt.Sprintf("evaluating symlinks of %q failed", path), err) } // EvalSymlinksAlways might return a relative path abs, err := filepath.Abs(target) if err != nil { return "", errwrap.Wrapf(fmt.Sprintf("failed to get absolute representation of %q", target), err) } if err := chroot.escape(); err != nil { return "", errwrap.Wrapf(fmt.Sprintf("escaping chroot %q failed", appRootfs), err) } return abs, nil }
go
func EvaluateSymlinksInsideApp(appRootfs, path string) (string, error) { chroot, err := newChroot(appRootfs) if err != nil { return "", errwrap.Wrapf(fmt.Sprintf("chroot to %q failed", appRootfs), err) } target, err := fileutil.EvalSymlinksAlways(path) if err != nil { return "", errwrap.Wrapf(fmt.Sprintf("evaluating symlinks of %q failed", path), err) } // EvalSymlinksAlways might return a relative path abs, err := filepath.Abs(target) if err != nil { return "", errwrap.Wrapf(fmt.Sprintf("failed to get absolute representation of %q", target), err) } if err := chroot.escape(); err != nil { return "", errwrap.Wrapf(fmt.Sprintf("escaping chroot %q failed", appRootfs), err) } return abs, nil }
[ "func", "EvaluateSymlinksInsideApp", "(", "appRootfs", ",", "path", "string", ")", "(", "string", ",", "error", ")", "{", "chroot", ",", "err", ":=", "newChroot", "(", "appRootfs", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errwrap", ".", "Wrapf", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "appRootfs", ")", ",", "err", ")", "\n", "}", "\n\n", "target", ",", "err", ":=", "fileutil", ".", "EvalSymlinksAlways", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errwrap", ".", "Wrapf", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "path", ")", ",", "err", ")", "\n", "}", "\n\n", "// EvalSymlinksAlways might return a relative path", "abs", ",", "err", ":=", "filepath", ".", "Abs", "(", "target", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errwrap", ".", "Wrapf", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "target", ")", ",", "err", ")", "\n", "}", "\n\n", "if", "err", ":=", "chroot", ".", "escape", "(", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errwrap", ".", "Wrapf", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "appRootfs", ")", ",", "err", ")", "\n", "}", "\n\n", "return", "abs", ",", "nil", "\n", "}" ]
// EvaluateSymlinksInsideApp tries to resolve symlinks within the path. // It returns the actual path relative to the app rootfs for the given path. // This is needed for absolute symlinks - we are in a different rootfs.
[ "EvaluateSymlinksInsideApp", "tries", "to", "resolve", "symlinks", "within", "the", "path", ".", "It", "returns", "the", "actual", "path", "relative", "to", "the", "app", "rootfs", "for", "the", "given", "path", ".", "This", "is", "needed", "for", "absolute", "symlinks", "-", "we", "are", "in", "a", "different", "rootfs", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage1/init/common/pod.go#L434-L456
train
rkt/rkt
stage1/init/common/pod.go
PodToNspawnArgs
func PodToNspawnArgs(p *stage1commontypes.Pod) ([]string, error) { args := []string{ "--uuid=" + p.UUID.String(), "--machine=" + GetMachineID(p), "--directory=" + common.Stage1RootfsPath(p.Root), } for i := range p.Manifest.Apps { aa, err := appToNspawnArgs(p, &p.Manifest.Apps[i]) if err != nil { return nil, err } args = append(args, aa...) } if p.InsecureOptions.DisableCapabilities { args = append(args, "--capability=all") } return args, nil }
go
func PodToNspawnArgs(p *stage1commontypes.Pod) ([]string, error) { args := []string{ "--uuid=" + p.UUID.String(), "--machine=" + GetMachineID(p), "--directory=" + common.Stage1RootfsPath(p.Root), } for i := range p.Manifest.Apps { aa, err := appToNspawnArgs(p, &p.Manifest.Apps[i]) if err != nil { return nil, err } args = append(args, aa...) } if p.InsecureOptions.DisableCapabilities { args = append(args, "--capability=all") } return args, nil }
[ "func", "PodToNspawnArgs", "(", "p", "*", "stage1commontypes", ".", "Pod", ")", "(", "[", "]", "string", ",", "error", ")", "{", "args", ":=", "[", "]", "string", "{", "\"", "\"", "+", "p", ".", "UUID", ".", "String", "(", ")", ",", "\"", "\"", "+", "GetMachineID", "(", "p", ")", ",", "\"", "\"", "+", "common", ".", "Stage1RootfsPath", "(", "p", ".", "Root", ")", ",", "}", "\n\n", "for", "i", ":=", "range", "p", ".", "Manifest", ".", "Apps", "{", "aa", ",", "err", ":=", "appToNspawnArgs", "(", "p", ",", "&", "p", ".", "Manifest", ".", "Apps", "[", "i", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "args", "=", "append", "(", "args", ",", "aa", "...", ")", "\n", "}", "\n\n", "if", "p", ".", "InsecureOptions", ".", "DisableCapabilities", "{", "args", "=", "append", "(", "args", ",", "\"", "\"", ")", "\n", "}", "\n\n", "return", "args", ",", "nil", "\n", "}" ]
// PodToNspawnArgs renders a prepared Pod as a systemd-nspawn // argument list ready to be executed
[ "PodToNspawnArgs", "renders", "a", "prepared", "Pod", "as", "a", "systemd", "-", "nspawn", "argument", "list", "ready", "to", "be", "executed" ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage1/init/common/pod.go#L546-L566
train
rkt/rkt
stage1/init/common/pod.go
GetFlavor
func GetFlavor(p *stage1commontypes.Pod) (flavor string, systemdVersion int, err error) { flavor, err = os.Readlink(filepath.Join(common.Stage1RootfsPath(p.Root), "flavor")) if err != nil { return "", -1, errwrap.Wrap(errors.New("unable to determine stage1 flavor"), err) } if flavor == "host" { // This flavor does not contain systemd, parse "systemctl --version" systemctlBin, err := common.LookupPath("systemctl", os.Getenv("PATH")) if err != nil { return "", -1, err } systemdVersion, err := common.SystemdVersion(systemctlBin) if err != nil { return "", -1, errwrap.Wrap(errors.New("error finding systemctl version"), err) } return flavor, systemdVersion, nil } systemdVersionBytes, err := ioutil.ReadFile(filepath.Join(common.Stage1RootfsPath(p.Root), "systemd-version")) if err != nil { return "", -1, errwrap.Wrap(errors.New("unable to determine stage1's systemd version"), err) } systemdVersionString := strings.Trim(string(systemdVersionBytes), " \n") // systemdVersionString is either a tag name or a branch name. If it's a // tag name it's of the form "v229", remove the first character to get the // number. systemdVersion, err = strconv.Atoi(systemdVersionString[1:]) if err != nil { // If we get a syntax error, it means the parsing of the version string // of the form "v229" failed, set it to 0 to indicate we couldn't guess // it. if e, ok := err.(*strconv.NumError); ok && e.Err == strconv.ErrSyntax { systemdVersion = 0 } else { return "", -1, errwrap.Wrap(errors.New("error parsing stage1's systemd version"), err) } } return flavor, systemdVersion, nil }
go
func GetFlavor(p *stage1commontypes.Pod) (flavor string, systemdVersion int, err error) { flavor, err = os.Readlink(filepath.Join(common.Stage1RootfsPath(p.Root), "flavor")) if err != nil { return "", -1, errwrap.Wrap(errors.New("unable to determine stage1 flavor"), err) } if flavor == "host" { // This flavor does not contain systemd, parse "systemctl --version" systemctlBin, err := common.LookupPath("systemctl", os.Getenv("PATH")) if err != nil { return "", -1, err } systemdVersion, err := common.SystemdVersion(systemctlBin) if err != nil { return "", -1, errwrap.Wrap(errors.New("error finding systemctl version"), err) } return flavor, systemdVersion, nil } systemdVersionBytes, err := ioutil.ReadFile(filepath.Join(common.Stage1RootfsPath(p.Root), "systemd-version")) if err != nil { return "", -1, errwrap.Wrap(errors.New("unable to determine stage1's systemd version"), err) } systemdVersionString := strings.Trim(string(systemdVersionBytes), " \n") // systemdVersionString is either a tag name or a branch name. If it's a // tag name it's of the form "v229", remove the first character to get the // number. systemdVersion, err = strconv.Atoi(systemdVersionString[1:]) if err != nil { // If we get a syntax error, it means the parsing of the version string // of the form "v229" failed, set it to 0 to indicate we couldn't guess // it. if e, ok := err.(*strconv.NumError); ok && e.Err == strconv.ErrSyntax { systemdVersion = 0 } else { return "", -1, errwrap.Wrap(errors.New("error parsing stage1's systemd version"), err) } } return flavor, systemdVersion, nil }
[ "func", "GetFlavor", "(", "p", "*", "stage1commontypes", ".", "Pod", ")", "(", "flavor", "string", ",", "systemdVersion", "int", ",", "err", "error", ")", "{", "flavor", ",", "err", "=", "os", ".", "Readlink", "(", "filepath", ".", "Join", "(", "common", ".", "Stage1RootfsPath", "(", "p", ".", "Root", ")", ",", "\"", "\"", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "-", "1", ",", "errwrap", ".", "Wrap", "(", "errors", ".", "New", "(", "\"", "\"", ")", ",", "err", ")", "\n", "}", "\n\n", "if", "flavor", "==", "\"", "\"", "{", "// This flavor does not contain systemd, parse \"systemctl --version\"", "systemctlBin", ",", "err", ":=", "common", ".", "LookupPath", "(", "\"", "\"", ",", "os", ".", "Getenv", "(", "\"", "\"", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "-", "1", ",", "err", "\n", "}", "\n\n", "systemdVersion", ",", "err", ":=", "common", ".", "SystemdVersion", "(", "systemctlBin", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "-", "1", ",", "errwrap", ".", "Wrap", "(", "errors", ".", "New", "(", "\"", "\"", ")", ",", "err", ")", "\n", "}", "\n\n", "return", "flavor", ",", "systemdVersion", ",", "nil", "\n", "}", "\n\n", "systemdVersionBytes", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "filepath", ".", "Join", "(", "common", ".", "Stage1RootfsPath", "(", "p", ".", "Root", ")", ",", "\"", "\"", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "-", "1", ",", "errwrap", ".", "Wrap", "(", "errors", ".", "New", "(", "\"", "\"", ")", ",", "err", ")", "\n", "}", "\n", "systemdVersionString", ":=", "strings", ".", "Trim", "(", "string", "(", "systemdVersionBytes", ")", ",", "\"", "\\n", "\"", ")", "\n\n", "// systemdVersionString is either a tag name or a branch name. If it's a", "// tag name it's of the form \"v229\", remove the first character to get the", "// number.", "systemdVersion", ",", "err", "=", "strconv", ".", "Atoi", "(", "systemdVersionString", "[", "1", ":", "]", ")", "\n", "if", "err", "!=", "nil", "{", "// If we get a syntax error, it means the parsing of the version string", "// of the form \"v229\" failed, set it to 0 to indicate we couldn't guess", "// it.", "if", "e", ",", "ok", ":=", "err", ".", "(", "*", "strconv", ".", "NumError", ")", ";", "ok", "&&", "e", ".", "Err", "==", "strconv", ".", "ErrSyntax", "{", "systemdVersion", "=", "0", "\n", "}", "else", "{", "return", "\"", "\"", ",", "-", "1", ",", "errwrap", ".", "Wrap", "(", "errors", ".", "New", "(", "\"", "\"", ")", ",", "err", ")", "\n", "}", "\n", "}", "\n", "return", "flavor", ",", "systemdVersion", ",", "nil", "\n", "}" ]
// GetFlavor populates a flavor string based on the flavor itself and respectively the systemd version // If the systemd version couldn't be guessed, it will be set to 0.
[ "GetFlavor", "populates", "a", "flavor", "string", "based", "on", "the", "flavor", "itself", "and", "respectively", "the", "systemd", "version", "If", "the", "systemd", "version", "couldn", "t", "be", "guessed", "it", "will", "be", "set", "to", "0", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage1/init/common/pod.go#L570-L612
train
rkt/rkt
stage1/init/common/pod.go
GetAppHashes
func GetAppHashes(p *stage1commontypes.Pod) []types.Hash { var names []types.Hash for _, a := range p.Manifest.Apps { names = append(names, a.Image.ID) } return names }
go
func GetAppHashes(p *stage1commontypes.Pod) []types.Hash { var names []types.Hash for _, a := range p.Manifest.Apps { names = append(names, a.Image.ID) } return names }
[ "func", "GetAppHashes", "(", "p", "*", "stage1commontypes", ".", "Pod", ")", "[", "]", "types", ".", "Hash", "{", "var", "names", "[", "]", "types", ".", "Hash", "\n", "for", "_", ",", "a", ":=", "range", "p", ".", "Manifest", ".", "Apps", "{", "names", "=", "append", "(", "names", ",", "a", ".", "Image", ".", "ID", ")", "\n", "}", "\n\n", "return", "names", "\n", "}" ]
// GetAppHashes returns a list of hashes of the apps in this pod
[ "GetAppHashes", "returns", "a", "list", "of", "hashes", "of", "the", "apps", "in", "this", "pod" ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage1/init/common/pod.go#L615-L622
train
rkt/rkt
stage1/init/common/pod.go
parseLinuxCapabilitiesSet
func parseLinuxCapabilitiesSet(capSet types.LinuxCapabilitiesSet) []string { var capsStr []string for _, cap := range capSet.Set() { capsStr = append(capsStr, string(cap)) } return capsStr }
go
func parseLinuxCapabilitiesSet(capSet types.LinuxCapabilitiesSet) []string { var capsStr []string for _, cap := range capSet.Set() { capsStr = append(capsStr, string(cap)) } return capsStr }
[ "func", "parseLinuxCapabilitiesSet", "(", "capSet", "types", ".", "LinuxCapabilitiesSet", ")", "[", "]", "string", "{", "var", "capsStr", "[", "]", "string", "\n", "for", "_", ",", "cap", ":=", "range", "capSet", ".", "Set", "(", ")", "{", "capsStr", "=", "append", "(", "capsStr", ",", "string", "(", "cap", ")", ")", "\n", "}", "\n", "return", "capsStr", "\n", "}" ]
// parseLinuxCapabilitySet parses a LinuxCapabilitiesSet into string slice
[ "parseLinuxCapabilitySet", "parses", "a", "LinuxCapabilitiesSet", "into", "string", "slice" ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage1/init/common/pod.go#L708-L714
train
rkt/rkt
stage1/init/common/pod.go
escape
func (c *chroot) escape() error { // change directory to outer root and close it if err := syscall.Fchdir(int(c.root.Fd())); err != nil { return errwrap.Wrapf("changing directory to outer root failed", err) } if err := c.root.Close(); err != nil { return errwrap.Wrapf("closing outer root failed", err) } // chroot to current directory aka "." being the outer root if err := syscall.Chroot("."); err != nil { return errwrap.Wrapf("chroot to current directory failed", err) } // chdir into previous working directory if err := os.Chdir(c.wd); err != nil { return errwrap.Wrapf("chdir to working directory failed", err) } return nil }
go
func (c *chroot) escape() error { // change directory to outer root and close it if err := syscall.Fchdir(int(c.root.Fd())); err != nil { return errwrap.Wrapf("changing directory to outer root failed", err) } if err := c.root.Close(); err != nil { return errwrap.Wrapf("closing outer root failed", err) } // chroot to current directory aka "." being the outer root if err := syscall.Chroot("."); err != nil { return errwrap.Wrapf("chroot to current directory failed", err) } // chdir into previous working directory if err := os.Chdir(c.wd); err != nil { return errwrap.Wrapf("chdir to working directory failed", err) } return nil }
[ "func", "(", "c", "*", "chroot", ")", "escape", "(", ")", "error", "{", "// change directory to outer root and close it", "if", "err", ":=", "syscall", ".", "Fchdir", "(", "int", "(", "c", ".", "root", ".", "Fd", "(", ")", ")", ")", ";", "err", "!=", "nil", "{", "return", "errwrap", ".", "Wrapf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "if", "err", ":=", "c", ".", "root", ".", "Close", "(", ")", ";", "err", "!=", "nil", "{", "return", "errwrap", ".", "Wrapf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// chroot to current directory aka \".\" being the outer root", "if", "err", ":=", "syscall", ".", "Chroot", "(", "\"", "\"", ")", ";", "err", "!=", "nil", "{", "return", "errwrap", ".", "Wrapf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// chdir into previous working directory", "if", "err", ":=", "os", ".", "Chdir", "(", "c", ".", "wd", ")", ";", "err", "!=", "nil", "{", "return", "errwrap", ".", "Wrapf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]
// Escape escapes the chroot environment changing back to the original working directory where newChroot was invoked.
[ "Escape", "escapes", "the", "chroot", "environment", "changing", "back", "to", "the", "original", "working", "directory", "where", "newChroot", "was", "invoked", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage1/init/common/pod.go#L763-L784
train
rkt/rkt
common/apps/apps.go
SeccompOverride
func (a *App) SeccompOverride() (mode string, errno string, set []string, e error) { if a.SeccompFilter == "" { return } for _, i := range strings.Split(a.SeccompFilter, ",") { kv := strings.Split(i, "=") if len(kv) == 2 { switch kv[0] { case "mode": if kv[1] != "remove" && kv[1] != "retain" { e = ErrInvalidSeccompMode } mode = kv[1] case "errno": errno = kv[1] default: e = ErrInvalidSeccompOverride } } else { set = append(set, i) } } return }
go
func (a *App) SeccompOverride() (mode string, errno string, set []string, e error) { if a.SeccompFilter == "" { return } for _, i := range strings.Split(a.SeccompFilter, ",") { kv := strings.Split(i, "=") if len(kv) == 2 { switch kv[0] { case "mode": if kv[1] != "remove" && kv[1] != "retain" { e = ErrInvalidSeccompMode } mode = kv[1] case "errno": errno = kv[1] default: e = ErrInvalidSeccompOverride } } else { set = append(set, i) } } return }
[ "func", "(", "a", "*", "App", ")", "SeccompOverride", "(", ")", "(", "mode", "string", ",", "errno", "string", ",", "set", "[", "]", "string", ",", "e", "error", ")", "{", "if", "a", ".", "SeccompFilter", "==", "\"", "\"", "{", "return", "\n", "}", "\n", "for", "_", ",", "i", ":=", "range", "strings", ".", "Split", "(", "a", ".", "SeccompFilter", ",", "\"", "\"", ")", "{", "kv", ":=", "strings", ".", "Split", "(", "i", ",", "\"", "\"", ")", "\n", "if", "len", "(", "kv", ")", "==", "2", "{", "switch", "kv", "[", "0", "]", "{", "case", "\"", "\"", ":", "if", "kv", "[", "1", "]", "!=", "\"", "\"", "&&", "kv", "[", "1", "]", "!=", "\"", "\"", "{", "e", "=", "ErrInvalidSeccompMode", "\n", "}", "\n", "mode", "=", "kv", "[", "1", "]", "\n", "case", "\"", "\"", ":", "errno", "=", "kv", "[", "1", "]", "\n", "default", ":", "e", "=", "ErrInvalidSeccompOverride", "\n", "}", "\n", "}", "else", "{", "set", "=", "append", "(", "set", ",", "i", ")", "\n", "}", "\n", "}", "\n", "return", "\n", "}" ]
// SeccompFilter returns type, filter set and optional errno // for a seccomp filter override specified via CLI
[ "SeccompFilter", "returns", "type", "filter", "set", "and", "optional", "errno", "for", "a", "seccomp", "filter", "override", "specified", "via", "CLI" ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/common/apps/apps.go#L86-L109
train
rkt/rkt
common/apps/apps.go
Create
func (al *Apps) Create(img string) { al.apps = append(al.apps, App{Image: img}) }
go
func (al *Apps) Create(img string) { al.apps = append(al.apps, App{Image: img}) }
[ "func", "(", "al", "*", "Apps", ")", "Create", "(", "img", "string", ")", "{", "al", ".", "apps", "=", "append", "(", "al", ".", "apps", ",", "App", "{", "Image", ":", "img", "}", ")", "\n", "}" ]
// Create creates a new app in al and returns a pointer to it
[ "Create", "creates", "a", "new", "app", "in", "al", "and", "returns", "a", "pointer", "to", "it" ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/common/apps/apps.go#L122-L124
train
rkt/rkt
common/apps/apps.go
Last
func (al *Apps) Last() *App { if len(al.apps) == 0 { return nil } return &al.apps[len(al.apps)-1] }
go
func (al *Apps) Last() *App { if len(al.apps) == 0 { return nil } return &al.apps[len(al.apps)-1] }
[ "func", "(", "al", "*", "Apps", ")", "Last", "(", ")", "*", "App", "{", "if", "len", "(", "al", ".", "apps", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n", "return", "&", "al", ".", "apps", "[", "len", "(", "al", ".", "apps", ")", "-", "1", "]", "\n", "}" ]
// Last returns a pointer to the top app in al
[ "Last", "returns", "a", "pointer", "to", "the", "top", "app", "in", "al" ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/common/apps/apps.go#L127-L132
train
rkt/rkt
common/apps/apps.go
Walk
func (al *Apps) Walk(f func(*App) error) error { for i := range al.apps { // XXX(vc): note we supply f() with a pointer to the app instance in al.apps to enable modification by f() if err := f(&al.apps[i]); err != nil { return err } } return nil }
go
func (al *Apps) Walk(f func(*App) error) error { for i := range al.apps { // XXX(vc): note we supply f() with a pointer to the app instance in al.apps to enable modification by f() if err := f(&al.apps[i]); err != nil { return err } } return nil }
[ "func", "(", "al", "*", "Apps", ")", "Walk", "(", "f", "func", "(", "*", "App", ")", "error", ")", "error", "{", "for", "i", ":=", "range", "al", ".", "apps", "{", "// XXX(vc): note we supply f() with a pointer to the app instance in al.apps to enable modification by f()", "if", "err", ":=", "f", "(", "&", "al", ".", "apps", "[", "i", "]", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]
// Walk iterates on al.apps calling f for each app // walking stops if f returns an error, the error is simply returned
[ "Walk", "iterates", "on", "al", ".", "apps", "calling", "f", "for", "each", "app", "walking", "stops", "if", "f", "returns", "an", "error", "the", "error", "is", "simply", "returned" ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/common/apps/apps.go#L167-L175
train
rkt/rkt
common/apps/apps.go
GetArgs
func (al *Apps) GetArgs() [][]string { var aal [][]string for _, a := range al.apps { aal = append(aal, a.Args) } return aal }
go
func (al *Apps) GetArgs() [][]string { var aal [][]string for _, a := range al.apps { aal = append(aal, a.Args) } return aal }
[ "func", "(", "al", "*", "Apps", ")", "GetArgs", "(", ")", "[", "]", "[", "]", "string", "{", "var", "aal", "[", "]", "[", "]", "string", "\n", "for", "_", ",", "a", ":=", "range", "al", ".", "apps", "{", "aal", "=", "append", "(", "aal", ",", "a", ".", "Args", ")", "\n", "}", "\n", "return", "aal", "\n", "}" ]
// GetArgs returns a list of lists of arguments in al, one list of args per app. // The order reflects the app order in al.
[ "GetArgs", "returns", "a", "list", "of", "lists", "of", "arguments", "in", "al", "one", "list", "of", "args", "per", "app", ".", "The", "order", "reflects", "the", "app", "order", "in", "al", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/common/apps/apps.go#L192-L198
train
rkt/rkt
stage1/common/run.go
WithClearedCloExec
func WithClearedCloExec(lfd int, f func() error) error { err := sys.CloseOnExec(lfd, false) if err != nil { return err } defer sys.CloseOnExec(lfd, true) return f() }
go
func WithClearedCloExec(lfd int, f func() error) error { err := sys.CloseOnExec(lfd, false) if err != nil { return err } defer sys.CloseOnExec(lfd, true) return f() }
[ "func", "WithClearedCloExec", "(", "lfd", "int", ",", "f", "func", "(", ")", "error", ")", "error", "{", "err", ":=", "sys", ".", "CloseOnExec", "(", "lfd", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "sys", ".", "CloseOnExec", "(", "lfd", ",", "true", ")", "\n\n", "return", "f", "(", ")", "\n", "}" ]
// WithClearedCloExec executes a given function in between setting and unsetting the close-on-exit flag // on the given file descriptor
[ "WithClearedCloExec", "executes", "a", "given", "function", "in", "between", "setting", "and", "unsetting", "the", "close", "-", "on", "-", "exit", "flag", "on", "the", "given", "file", "descriptor" ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage1/common/run.go#L31-L39
train
rkt/rkt
stage1/common/run.go
PrepareEnterCmd
func PrepareEnterCmd(enterStage2 bool) []string { var args []string enterCmd := os.Getenv(common.CrossingEnterCmd) enterPID := os.Getenv(common.CrossingEnterPID) if enterCmd != "" && enterPID != "" { args = append(args, []string{enterCmd, fmt.Sprintf("--pid=%s", enterPID)}...) enterApp := os.Getenv(common.CrossingEnterApp) if enterApp != "" && enterStage2 { args = append(args, fmt.Sprintf("--app=%s", enterApp)) } args = append(args, "--") } return args }
go
func PrepareEnterCmd(enterStage2 bool) []string { var args []string enterCmd := os.Getenv(common.CrossingEnterCmd) enterPID := os.Getenv(common.CrossingEnterPID) if enterCmd != "" && enterPID != "" { args = append(args, []string{enterCmd, fmt.Sprintf("--pid=%s", enterPID)}...) enterApp := os.Getenv(common.CrossingEnterApp) if enterApp != "" && enterStage2 { args = append(args, fmt.Sprintf("--app=%s", enterApp)) } args = append(args, "--") } return args }
[ "func", "PrepareEnterCmd", "(", "enterStage2", "bool", ")", "[", "]", "string", "{", "var", "args", "[", "]", "string", "\n", "enterCmd", ":=", "os", ".", "Getenv", "(", "common", ".", "CrossingEnterCmd", ")", "\n", "enterPID", ":=", "os", ".", "Getenv", "(", "common", ".", "CrossingEnterPID", ")", "\n", "if", "enterCmd", "!=", "\"", "\"", "&&", "enterPID", "!=", "\"", "\"", "{", "args", "=", "append", "(", "args", ",", "[", "]", "string", "{", "enterCmd", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "enterPID", ")", "}", "...", ")", "\n", "enterApp", ":=", "os", ".", "Getenv", "(", "common", ".", "CrossingEnterApp", ")", "\n", "if", "enterApp", "!=", "\"", "\"", "&&", "enterStage2", "{", "args", "=", "append", "(", "args", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "enterApp", ")", ")", "\n", "}", "\n", "args", "=", "append", "(", "args", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "args", "\n", "}" ]
// PrepareEnterCmd retrieves enter argument and prepare a command list // to further run a command in stage1 context
[ "PrepareEnterCmd", "retrieves", "enter", "argument", "and", "prepare", "a", "command", "list", "to", "further", "run", "a", "command", "in", "stage1", "context" ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage1/common/run.go#L59-L72
train
rkt/rkt
pkg/passwd/passwd.go
LookupUidFromFile
func LookupUidFromFile(userName, passwdFile string) (uid int, err error) { users, err := parsePasswdFile(passwdFile) if err != nil { return -1, errwrap.Wrap(fmt.Errorf("error parsing %q file", passwdFile), err) } user, ok := users[userName] if !ok { return -1, fmt.Errorf("%q user not found", userName) } return user.Uid, nil }
go
func LookupUidFromFile(userName, passwdFile string) (uid int, err error) { users, err := parsePasswdFile(passwdFile) if err != nil { return -1, errwrap.Wrap(fmt.Errorf("error parsing %q file", passwdFile), err) } user, ok := users[userName] if !ok { return -1, fmt.Errorf("%q user not found", userName) } return user.Uid, nil }
[ "func", "LookupUidFromFile", "(", "userName", ",", "passwdFile", "string", ")", "(", "uid", "int", ",", "err", "error", ")", "{", "users", ",", "err", ":=", "parsePasswdFile", "(", "passwdFile", ")", "\n", "if", "err", "!=", "nil", "{", "return", "-", "1", ",", "errwrap", ".", "Wrap", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "passwdFile", ")", ",", "err", ")", "\n", "}", "\n\n", "user", ",", "ok", ":=", "users", "[", "userName", "]", "\n", "if", "!", "ok", "{", "return", "-", "1", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "userName", ")", "\n", "}", "\n\n", "return", "user", ".", "Uid", ",", "nil", "\n", "}" ]
// LookupUidFromFile reads the passwd file specified by passwdFile, and returns the // uid of the user specified by userName.
[ "LookupUidFromFile", "reads", "the", "passwd", "file", "specified", "by", "passwdFile", "and", "returns", "the", "uid", "of", "the", "user", "specified", "by", "userName", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/passwd/passwd.go#L46-L58
train
rkt/rkt
pkg/passwd/passwd.go
LookupUid
func LookupUid(userName string) (uid int, err error) { return LookupUidFromFile(userName, passwdFilePath) }
go
func LookupUid(userName string) (uid int, err error) { return LookupUidFromFile(userName, passwdFilePath) }
[ "func", "LookupUid", "(", "userName", "string", ")", "(", "uid", "int", ",", "err", "error", ")", "{", "return", "LookupUidFromFile", "(", "userName", ",", "passwdFilePath", ")", "\n", "}" ]
// LookupUid reads the passwd file and returns the uid of the user // specified by userName.
[ "LookupUid", "reads", "the", "passwd", "file", "and", "returns", "the", "uid", "of", "the", "user", "specified", "by", "userName", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/passwd/passwd.go#L62-L64
train
rkt/rkt
pkg/aci/render.go
RenderACIWithImageID
func RenderACIWithImageID(imageID types.Hash, dir string, ap acirenderer.ACIRegistry, uidRange *user.UidRange) error { renderedACI, err := acirenderer.GetRenderedACIWithImageID(imageID, ap) if err != nil { return err } return renderImage(renderedACI, dir, ap, uidRange) }
go
func RenderACIWithImageID(imageID types.Hash, dir string, ap acirenderer.ACIRegistry, uidRange *user.UidRange) error { renderedACI, err := acirenderer.GetRenderedACIWithImageID(imageID, ap) if err != nil { return err } return renderImage(renderedACI, dir, ap, uidRange) }
[ "func", "RenderACIWithImageID", "(", "imageID", "types", ".", "Hash", ",", "dir", "string", ",", "ap", "acirenderer", ".", "ACIRegistry", ",", "uidRange", "*", "user", ".", "UidRange", ")", "error", "{", "renderedACI", ",", "err", ":=", "acirenderer", ".", "GetRenderedACIWithImageID", "(", "imageID", ",", "ap", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "renderImage", "(", "renderedACI", ",", "dir", ",", "ap", ",", "uidRange", ")", "\n", "}" ]
// Given an imageID, start with the matching image available in the store, // build its dependency list and render it inside dir
[ "Given", "an", "imageID", "start", "with", "the", "matching", "image", "available", "in", "the", "store", "build", "its", "dependency", "list", "and", "render", "it", "inside", "dir" ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/aci/render.go#L31-L37
train
rkt/rkt
pkg/aci/render.go
RenderACI
func RenderACI(name types.ACIdentifier, labels types.Labels, dir string, ap acirenderer.ACIRegistry, uidRange *user.UidRange) error { renderedACI, err := acirenderer.GetRenderedACI(name, labels, ap) if err != nil { return err } return renderImage(renderedACI, dir, ap, uidRange) }
go
func RenderACI(name types.ACIdentifier, labels types.Labels, dir string, ap acirenderer.ACIRegistry, uidRange *user.UidRange) error { renderedACI, err := acirenderer.GetRenderedACI(name, labels, ap) if err != nil { return err } return renderImage(renderedACI, dir, ap, uidRange) }
[ "func", "RenderACI", "(", "name", "types", ".", "ACIdentifier", ",", "labels", "types", ".", "Labels", ",", "dir", "string", ",", "ap", "acirenderer", ".", "ACIRegistry", ",", "uidRange", "*", "user", ".", "UidRange", ")", "error", "{", "renderedACI", ",", "err", ":=", "acirenderer", ".", "GetRenderedACI", "(", "name", ",", "labels", ",", "ap", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "renderImage", "(", "renderedACI", ",", "dir", ",", "ap", ",", "uidRange", ")", "\n", "}" ]
// Given an image app name and optional labels, get the best matching image // available in the store, build its dependency list and render it inside dir
[ "Given", "an", "image", "app", "name", "and", "optional", "labels", "get", "the", "best", "matching", "image", "available", "in", "the", "store", "build", "its", "dependency", "list", "and", "render", "it", "inside", "dir" ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/aci/render.go#L41-L47
train
rkt/rkt
pkg/aci/render.go
RenderACIFromList
func RenderACIFromList(imgs acirenderer.Images, dir string, ap acirenderer.ACIProvider, uidRange *user.UidRange) error { renderedACI, err := acirenderer.GetRenderedACIFromList(imgs, ap) if err != nil { return err } return renderImage(renderedACI, dir, ap, uidRange) }
go
func RenderACIFromList(imgs acirenderer.Images, dir string, ap acirenderer.ACIProvider, uidRange *user.UidRange) error { renderedACI, err := acirenderer.GetRenderedACIFromList(imgs, ap) if err != nil { return err } return renderImage(renderedACI, dir, ap, uidRange) }
[ "func", "RenderACIFromList", "(", "imgs", "acirenderer", ".", "Images", ",", "dir", "string", ",", "ap", "acirenderer", ".", "ACIProvider", ",", "uidRange", "*", "user", ".", "UidRange", ")", "error", "{", "renderedACI", ",", "err", ":=", "acirenderer", ".", "GetRenderedACIFromList", "(", "imgs", ",", "ap", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "renderImage", "(", "renderedACI", ",", "dir", ",", "ap", ",", "uidRange", ")", "\n", "}" ]
// Given an already populated dependency list, it will extract, under the provided // directory, the rendered ACI
[ "Given", "an", "already", "populated", "dependency", "list", "it", "will", "extract", "under", "the", "provided", "directory", "the", "rendered", "ACI" ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/aci/render.go#L51-L57
train
rkt/rkt
pkg/aci/render.go
renderImage
func renderImage(renderedACI acirenderer.RenderedACI, dir string, ap acirenderer.ACIProvider, uidRange *user.UidRange) error { for _, ra := range renderedACI { rs, err := ap.ReadStream(ra.Key) if err != nil { return err } // Overwrite is not needed. If a file needs to be overwritten then the renderedACI builder has a bug if err := ptar.ExtractTar(rs, dir, false, uidRange, ra.FileMap); err != nil { rs.Close() return errwrap.Wrap(errors.New("error extracting ACI"), err) } rs.Close() } return nil }
go
func renderImage(renderedACI acirenderer.RenderedACI, dir string, ap acirenderer.ACIProvider, uidRange *user.UidRange) error { for _, ra := range renderedACI { rs, err := ap.ReadStream(ra.Key) if err != nil { return err } // Overwrite is not needed. If a file needs to be overwritten then the renderedACI builder has a bug if err := ptar.ExtractTar(rs, dir, false, uidRange, ra.FileMap); err != nil { rs.Close() return errwrap.Wrap(errors.New("error extracting ACI"), err) } rs.Close() } return nil }
[ "func", "renderImage", "(", "renderedACI", "acirenderer", ".", "RenderedACI", ",", "dir", "string", ",", "ap", "acirenderer", ".", "ACIProvider", ",", "uidRange", "*", "user", ".", "UidRange", ")", "error", "{", "for", "_", ",", "ra", ":=", "range", "renderedACI", "{", "rs", ",", "err", ":=", "ap", ".", "ReadStream", "(", "ra", ".", "Key", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Overwrite is not needed. If a file needs to be overwritten then the renderedACI builder has a bug", "if", "err", ":=", "ptar", ".", "ExtractTar", "(", "rs", ",", "dir", ",", "false", ",", "uidRange", ",", "ra", ".", "FileMap", ")", ";", "err", "!=", "nil", "{", "rs", ".", "Close", "(", ")", "\n", "return", "errwrap", ".", "Wrap", "(", "errors", ".", "New", "(", "\"", "\"", ")", ",", "err", ")", "\n", "}", "\n", "rs", ".", "Close", "(", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]
// Given a RenderedACI, it will extract, under the provided directory, the // needed files from the right source ACI. // The manifest will be extracted from the upper ACI. // No file overwriting is done as it should usually be called // providing an empty directory.
[ "Given", "a", "RenderedACI", "it", "will", "extract", "under", "the", "provided", "directory", "the", "needed", "files", "from", "the", "right", "source", "ACI", ".", "The", "manifest", "will", "be", "extracted", "from", "the", "upper", "ACI", ".", "No", "file", "overwriting", "is", "done", "as", "it", "should", "usually", "be", "called", "providing", "an", "empty", "directory", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/aci/render.go#L64-L80
train
rkt/rkt
rkt/image/httpfetcher.go
Hash
func (f *httpFetcher) Hash(u *url.URL, a *asc) (string, error) { ensureLogger(f.Debug) urlStr := u.String() if !f.NoCache && f.Rem != nil { if useCached(f.Rem.DownloadTime, f.Rem.CacheMaxAge) { diag.Printf("image for %s isn't expired, not fetching.", urlStr) return f.Rem.BlobKey, nil } } diag.Printf("fetching image from %s", urlStr) aciFile, cd, err := f.fetchURL(u, a, eTag(f.Rem)) if err != nil { return "", err } defer aciFile.Close() if key := maybeUseCached(f.Rem, cd); key != "" { // TODO(krnowak): that does not update the store with // the new CacheMaxAge and Download Time, so it will // query the server every time after initial // CacheMaxAge is exceeded return key, nil } key, err := f.S.WriteACI(aciFile, imagestore.ACIFetchInfo{ Latest: false, }) if err != nil { return "", err } // TODO(krnowak): What's the point of the second parameter? // The SigURL field in imagestore.Remote seems to be completely // unused. newRem := imagestore.NewRemote(urlStr, a.Location) newRem.BlobKey = key newRem.DownloadTime = time.Now() if cd != nil { newRem.ETag = cd.ETag newRem.CacheMaxAge = cd.MaxAge } err = f.S.WriteRemote(newRem) if err != nil { return "", err } return key, nil }
go
func (f *httpFetcher) Hash(u *url.URL, a *asc) (string, error) { ensureLogger(f.Debug) urlStr := u.String() if !f.NoCache && f.Rem != nil { if useCached(f.Rem.DownloadTime, f.Rem.CacheMaxAge) { diag.Printf("image for %s isn't expired, not fetching.", urlStr) return f.Rem.BlobKey, nil } } diag.Printf("fetching image from %s", urlStr) aciFile, cd, err := f.fetchURL(u, a, eTag(f.Rem)) if err != nil { return "", err } defer aciFile.Close() if key := maybeUseCached(f.Rem, cd); key != "" { // TODO(krnowak): that does not update the store with // the new CacheMaxAge and Download Time, so it will // query the server every time after initial // CacheMaxAge is exceeded return key, nil } key, err := f.S.WriteACI(aciFile, imagestore.ACIFetchInfo{ Latest: false, }) if err != nil { return "", err } // TODO(krnowak): What's the point of the second parameter? // The SigURL field in imagestore.Remote seems to be completely // unused. newRem := imagestore.NewRemote(urlStr, a.Location) newRem.BlobKey = key newRem.DownloadTime = time.Now() if cd != nil { newRem.ETag = cd.ETag newRem.CacheMaxAge = cd.MaxAge } err = f.S.WriteRemote(newRem) if err != nil { return "", err } return key, nil }
[ "func", "(", "f", "*", "httpFetcher", ")", "Hash", "(", "u", "*", "url", ".", "URL", ",", "a", "*", "asc", ")", "(", "string", ",", "error", ")", "{", "ensureLogger", "(", "f", ".", "Debug", ")", "\n", "urlStr", ":=", "u", ".", "String", "(", ")", "\n\n", "if", "!", "f", ".", "NoCache", "&&", "f", ".", "Rem", "!=", "nil", "{", "if", "useCached", "(", "f", ".", "Rem", ".", "DownloadTime", ",", "f", ".", "Rem", ".", "CacheMaxAge", ")", "{", "diag", ".", "Printf", "(", "\"", "\"", ",", "urlStr", ")", "\n", "return", "f", ".", "Rem", ".", "BlobKey", ",", "nil", "\n", "}", "\n", "}", "\n\n", "diag", ".", "Printf", "(", "\"", "\"", ",", "urlStr", ")", "\n\n", "aciFile", ",", "cd", ",", "err", ":=", "f", ".", "fetchURL", "(", "u", ",", "a", ",", "eTag", "(", "f", ".", "Rem", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "defer", "aciFile", ".", "Close", "(", ")", "\n\n", "if", "key", ":=", "maybeUseCached", "(", "f", ".", "Rem", ",", "cd", ")", ";", "key", "!=", "\"", "\"", "{", "// TODO(krnowak): that does not update the store with", "// the new CacheMaxAge and Download Time, so it will", "// query the server every time after initial", "// CacheMaxAge is exceeded", "return", "key", ",", "nil", "\n", "}", "\n", "key", ",", "err", ":=", "f", ".", "S", ".", "WriteACI", "(", "aciFile", ",", "imagestore", ".", "ACIFetchInfo", "{", "Latest", ":", "false", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "// TODO(krnowak): What's the point of the second parameter?", "// The SigURL field in imagestore.Remote seems to be completely", "// unused.", "newRem", ":=", "imagestore", ".", "NewRemote", "(", "urlStr", ",", "a", ".", "Location", ")", "\n", "newRem", ".", "BlobKey", "=", "key", "\n", "newRem", ".", "DownloadTime", "=", "time", ".", "Now", "(", ")", "\n", "if", "cd", "!=", "nil", "{", "newRem", ".", "ETag", "=", "cd", ".", "ETag", "\n", "newRem", ".", "CacheMaxAge", "=", "cd", ".", "MaxAge", "\n", "}", "\n", "err", "=", "f", ".", "S", ".", "WriteRemote", "(", "newRem", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "return", "key", ",", "nil", "\n", "}" ]
// Hash fetches the URL, optionally verifies it against passed asc, // stores it in the store and returns the hash.
[ "Hash", "fetches", "the", "URL", "optionally", "verifies", "it", "against", "passed", "asc", "stores", "it", "in", "the", "store", "and", "returns", "the", "hash", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/rkt/image/httpfetcher.go#L44-L93
train
rkt/rkt
stage1/app_add/app_add.go
addMountsStage0
func addMountsStage0(p *stage1types.Pod, ra *schema.RuntimeApp, enterCmd []string) error { sharedVolPath, err := common.CreateSharedVolumesPath(p.Root) if err != nil { return err } vols := make(map[types.ACName]types.Volume) for _, v := range p.Manifest.Volumes { vols[v.Name] = v } imageManifest := p.Images[ra.Name.String()] mounts, err := stage1init.GenerateMounts(ra, p.Manifest.Volumes, stage1init.ConvertedFromDocker(imageManifest)) if err != nil { return errwrap.Wrapf("could not generate mounts", err) } absRoot, err := filepath.Abs(p.Root) if err != nil { return errwrap.Wrapf("could not determine pod's absolute path", err) } appRootfs := common.AppRootfsPath(absRoot, ra.Name) // This logic is mostly copied from appToNspawnArgs // TODO(cdc): deduplicate for _, m := range mounts { shPath := filepath.Join(sharedVolPath, m.Volume.Name.String()) // Evaluate symlinks within the app's rootfs - otherwise absolute // symlinks will be wrong. mntPath, err := stage1init.EvaluateSymlinksInsideApp(appRootfs, m.Mount.Path) if err != nil { return errwrap.Wrap(fmt.Errorf("could not evaluate path %v", m.Mount.Path), err) } // Create the stage1 destination if err := stage1init.PrepareMountpoints(shPath, filepath.Join(appRootfs, mntPath), &m.Volume, m.DockerImplicit); err != nil { return errwrap.Wrapf("could not prepare mountpoint", err) } err = addMountStage0(p, ra, &m, mntPath, enterCmd) if err != nil { return errwrap.Wrap(fmt.Errorf("error adding mount volume %v path %v", m.Mount.Volume, m.Mount.Path), err) } } return nil }
go
func addMountsStage0(p *stage1types.Pod, ra *schema.RuntimeApp, enterCmd []string) error { sharedVolPath, err := common.CreateSharedVolumesPath(p.Root) if err != nil { return err } vols := make(map[types.ACName]types.Volume) for _, v := range p.Manifest.Volumes { vols[v.Name] = v } imageManifest := p.Images[ra.Name.String()] mounts, err := stage1init.GenerateMounts(ra, p.Manifest.Volumes, stage1init.ConvertedFromDocker(imageManifest)) if err != nil { return errwrap.Wrapf("could not generate mounts", err) } absRoot, err := filepath.Abs(p.Root) if err != nil { return errwrap.Wrapf("could not determine pod's absolute path", err) } appRootfs := common.AppRootfsPath(absRoot, ra.Name) // This logic is mostly copied from appToNspawnArgs // TODO(cdc): deduplicate for _, m := range mounts { shPath := filepath.Join(sharedVolPath, m.Volume.Name.String()) // Evaluate symlinks within the app's rootfs - otherwise absolute // symlinks will be wrong. mntPath, err := stage1init.EvaluateSymlinksInsideApp(appRootfs, m.Mount.Path) if err != nil { return errwrap.Wrap(fmt.Errorf("could not evaluate path %v", m.Mount.Path), err) } // Create the stage1 destination if err := stage1init.PrepareMountpoints(shPath, filepath.Join(appRootfs, mntPath), &m.Volume, m.DockerImplicit); err != nil { return errwrap.Wrapf("could not prepare mountpoint", err) } err = addMountStage0(p, ra, &m, mntPath, enterCmd) if err != nil { return errwrap.Wrap(fmt.Errorf("error adding mount volume %v path %v", m.Mount.Volume, m.Mount.Path), err) } } return nil }
[ "func", "addMountsStage0", "(", "p", "*", "stage1types", ".", "Pod", ",", "ra", "*", "schema", ".", "RuntimeApp", ",", "enterCmd", "[", "]", "string", ")", "error", "{", "sharedVolPath", ",", "err", ":=", "common", ".", "CreateSharedVolumesPath", "(", "p", ".", "Root", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "vols", ":=", "make", "(", "map", "[", "types", ".", "ACName", "]", "types", ".", "Volume", ")", "\n", "for", "_", ",", "v", ":=", "range", "p", ".", "Manifest", ".", "Volumes", "{", "vols", "[", "v", ".", "Name", "]", "=", "v", "\n", "}", "\n\n", "imageManifest", ":=", "p", ".", "Images", "[", "ra", ".", "Name", ".", "String", "(", ")", "]", "\n\n", "mounts", ",", "err", ":=", "stage1init", ".", "GenerateMounts", "(", "ra", ",", "p", ".", "Manifest", ".", "Volumes", ",", "stage1init", ".", "ConvertedFromDocker", "(", "imageManifest", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errwrap", ".", "Wrapf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "absRoot", ",", "err", ":=", "filepath", ".", "Abs", "(", "p", ".", "Root", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errwrap", ".", "Wrapf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "appRootfs", ":=", "common", ".", "AppRootfsPath", "(", "absRoot", ",", "ra", ".", "Name", ")", "\n\n", "// This logic is mostly copied from appToNspawnArgs", "// TODO(cdc): deduplicate", "for", "_", ",", "m", ":=", "range", "mounts", "{", "shPath", ":=", "filepath", ".", "Join", "(", "sharedVolPath", ",", "m", ".", "Volume", ".", "Name", ".", "String", "(", ")", ")", "\n\n", "// Evaluate symlinks within the app's rootfs - otherwise absolute", "// symlinks will be wrong.", "mntPath", ",", "err", ":=", "stage1init", ".", "EvaluateSymlinksInsideApp", "(", "appRootfs", ",", "m", ".", "Mount", ".", "Path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errwrap", ".", "Wrap", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "m", ".", "Mount", ".", "Path", ")", ",", "err", ")", "\n", "}", "\n\n", "// Create the stage1 destination", "if", "err", ":=", "stage1init", ".", "PrepareMountpoints", "(", "shPath", ",", "filepath", ".", "Join", "(", "appRootfs", ",", "mntPath", ")", ",", "&", "m", ".", "Volume", ",", "m", ".", "DockerImplicit", ")", ";", "err", "!=", "nil", "{", "return", "errwrap", ".", "Wrapf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "err", "=", "addMountStage0", "(", "p", ",", "ra", ",", "&", "m", ",", "mntPath", ",", "enterCmd", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errwrap", ".", "Wrap", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "m", ".", "Mount", ".", "Volume", ",", "m", ".", "Mount", ".", "Path", ")", ",", "err", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]
// addMountStage0 iterates over all requested mounts and bind mounts them to the stage2 rootfs.
[ "addMountStage0", "iterates", "over", "all", "requested", "mounts", "and", "bind", "mounts", "them", "to", "the", "stage2", "rootfs", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage1/app_add/app_add.go#L163-L211
train
rkt/rkt
stage1/app_add/app_add.go
Cleanup
func (p *playground) Cleanup() error { if err := os.Remove(p.playground); err != nil { return err } if err := p.mnt.Unmount(p.tmpDir, 0); err != nil { return err } return os.Remove(p.tmpDir) }
go
func (p *playground) Cleanup() error { if err := os.Remove(p.playground); err != nil { return err } if err := p.mnt.Unmount(p.tmpDir, 0); err != nil { return err } return os.Remove(p.tmpDir) }
[ "func", "(", "p", "*", "playground", ")", "Cleanup", "(", ")", "error", "{", "if", "err", ":=", "os", ".", "Remove", "(", "p", ".", "playground", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "err", ":=", "p", ".", "mnt", ".", "Unmount", "(", "p", ".", "tmpDir", ",", "0", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "os", ".", "Remove", "(", "p", ".", "tmpDir", ")", "\n", "}" ]
// Cleanup cleans up the playground. // It removes it, unmounts the parent directory, and removes the unmounted directory.
[ "Cleanup", "cleans", "up", "the", "playground", ".", "It", "removes", "it", "unmounts", "the", "parent", "directory", "and", "removes", "the", "unmounted", "directory", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage1/app_add/app_add.go#L426-L436
train
rkt/rkt
pkg/user/util.go
ShiftFiles
func ShiftFiles(filesToShift []string, uidRange *UidRange) error { if uidRange.Shift != 0 && uidRange.Count != 0 { for _, f := range filesToShift { if err := os.Chown(f, int(uidRange.Shift), int(uidRange.Shift)); err != nil { return err } } } return nil }
go
func ShiftFiles(filesToShift []string, uidRange *UidRange) error { if uidRange.Shift != 0 && uidRange.Count != 0 { for _, f := range filesToShift { if err := os.Chown(f, int(uidRange.Shift), int(uidRange.Shift)); err != nil { return err } } } return nil }
[ "func", "ShiftFiles", "(", "filesToShift", "[", "]", "string", ",", "uidRange", "*", "UidRange", ")", "error", "{", "if", "uidRange", ".", "Shift", "!=", "0", "&&", "uidRange", ".", "Count", "!=", "0", "{", "for", "_", ",", "f", ":=", "range", "filesToShift", "{", "if", "err", ":=", "os", ".", "Chown", "(", "f", ",", "int", "(", "uidRange", ".", "Shift", ")", ",", "int", "(", "uidRange", ".", "Shift", ")", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]
// ShiftFiles shifts filesToshift by the amounts specified in uidRange
[ "ShiftFiles", "shifts", "filesToshift", "by", "the", "amounts", "specified", "in", "uidRange" ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/user/util.go#L20-L29
train
rkt/rkt
rkt/image/namefetcher.go
Hash
func (f *nameFetcher) Hash(app *discovery.App, a *asc) (string, error) { ensureLogger(f.Debug) name := app.Name.String() diag.Printf("searching for app image %s", name) ep, err := f.discoverApp(app) if err != nil { return "", errwrap.Wrap(fmt.Errorf("discovery failed for %q", name), err) } latest := false // No specified version label, mark it as latest if _, ok := app.Labels["version"]; !ok { latest = true } return f.fetchImageFromEndpoints(app, ep, a, latest) }
go
func (f *nameFetcher) Hash(app *discovery.App, a *asc) (string, error) { ensureLogger(f.Debug) name := app.Name.String() diag.Printf("searching for app image %s", name) ep, err := f.discoverApp(app) if err != nil { return "", errwrap.Wrap(fmt.Errorf("discovery failed for %q", name), err) } latest := false // No specified version label, mark it as latest if _, ok := app.Labels["version"]; !ok { latest = true } return f.fetchImageFromEndpoints(app, ep, a, latest) }
[ "func", "(", "f", "*", "nameFetcher", ")", "Hash", "(", "app", "*", "discovery", ".", "App", ",", "a", "*", "asc", ")", "(", "string", ",", "error", ")", "{", "ensureLogger", "(", "f", ".", "Debug", ")", "\n", "name", ":=", "app", ".", "Name", ".", "String", "(", ")", "\n", "diag", ".", "Printf", "(", "\"", "\"", ",", "name", ")", "\n", "ep", ",", "err", ":=", "f", ".", "discoverApp", "(", "app", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errwrap", ".", "Wrap", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "name", ")", ",", "err", ")", "\n", "}", "\n", "latest", ":=", "false", "\n", "// No specified version label, mark it as latest", "if", "_", ",", "ok", ":=", "app", ".", "Labels", "[", "\"", "\"", "]", ";", "!", "ok", "{", "latest", "=", "true", "\n", "}", "\n", "return", "f", ".", "fetchImageFromEndpoints", "(", "app", ",", "ep", ",", "a", ",", "latest", ")", "\n", "}" ]
// Hash runs the discovery, fetches the image, optionally verifies // it against passed asc, stores it in the store and returns the hash.
[ "Hash", "runs", "the", "discovery", "fetches", "the", "image", "optionally", "verifies", "it", "against", "passed", "asc", "stores", "it", "in", "the", "store", "and", "returns", "the", "hash", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/rkt/image/namefetcher.go#L50-L64
train
rkt/rkt
common/overlay/overlay.go
Opts
func (cfg *MountCfg) Opts() string { opts := fmt.Sprintf( "lowerdir=%s,upperdir=%s,workdir=%s", sanitize(cfg.Lower), sanitize(cfg.Upper), sanitize(cfg.Work), ) return label.FormatMountLabel(opts, cfg.Lbl) }
go
func (cfg *MountCfg) Opts() string { opts := fmt.Sprintf( "lowerdir=%s,upperdir=%s,workdir=%s", sanitize(cfg.Lower), sanitize(cfg.Upper), sanitize(cfg.Work), ) return label.FormatMountLabel(opts, cfg.Lbl) }
[ "func", "(", "cfg", "*", "MountCfg", ")", "Opts", "(", ")", "string", "{", "opts", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "sanitize", "(", "cfg", ".", "Lower", ")", ",", "sanitize", "(", "cfg", ".", "Upper", ")", ",", "sanitize", "(", "cfg", ".", "Work", ")", ",", ")", "\n\n", "return", "label", ".", "FormatMountLabel", "(", "opts", ",", "cfg", ".", "Lbl", ")", "\n", "}" ]
// Opts returns options for mount system call.
[ "Opts", "returns", "options", "for", "mount", "system", "call", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/common/overlay/overlay.go#L50-L57
train
rkt/rkt
common/overlay/overlay.go
Mount
func Mount(cfg *MountCfg) error { err := syscall.Mount("overlay", cfg.Dest, "overlay", 0, cfg.Opts()) if err != nil { const text = "error mounting overlay with options '%s' and dest '%s'" return errwrap.Wrap(fmt.Errorf(text, cfg.Opts(), cfg.Dest), err) } return nil }
go
func Mount(cfg *MountCfg) error { err := syscall.Mount("overlay", cfg.Dest, "overlay", 0, cfg.Opts()) if err != nil { const text = "error mounting overlay with options '%s' and dest '%s'" return errwrap.Wrap(fmt.Errorf(text, cfg.Opts(), cfg.Dest), err) } return nil }
[ "func", "Mount", "(", "cfg", "*", "MountCfg", ")", "error", "{", "err", ":=", "syscall", ".", "Mount", "(", "\"", "\"", ",", "cfg", ".", "Dest", ",", "\"", "\"", ",", "0", ",", "cfg", ".", "Opts", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "const", "text", "=", "\"", "\"", "\n", "return", "errwrap", ".", "Wrap", "(", "fmt", ".", "Errorf", "(", "text", ",", "cfg", ".", "Opts", "(", ")", ",", "cfg", ".", "Dest", ")", ",", "err", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]
// Mount mounts the upper and lower directories to the destination directory. // The MountCfg struct supplies information required to build the mount system // call.
[ "Mount", "mounts", "the", "upper", "and", "lower", "directories", "to", "the", "destination", "directory", ".", "The", "MountCfg", "struct", "supplies", "information", "required", "to", "build", "the", "mount", "system", "call", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/common/overlay/overlay.go#L62-L70
train
rkt/rkt
pkg/lock/file.go
TryExclusiveLock
func (l *FileLock) TryExclusiveLock() error { err := syscall.Flock(l.fd, syscall.LOCK_EX|syscall.LOCK_NB) if err == syscall.EWOULDBLOCK { err = ErrLocked } return err }
go
func (l *FileLock) TryExclusiveLock() error { err := syscall.Flock(l.fd, syscall.LOCK_EX|syscall.LOCK_NB) if err == syscall.EWOULDBLOCK { err = ErrLocked } return err }
[ "func", "(", "l", "*", "FileLock", ")", "TryExclusiveLock", "(", ")", "error", "{", "err", ":=", "syscall", ".", "Flock", "(", "l", ".", "fd", ",", "syscall", ".", "LOCK_EX", "|", "syscall", ".", "LOCK_NB", ")", "\n", "if", "err", "==", "syscall", ".", "EWOULDBLOCK", "{", "err", "=", "ErrLocked", "\n", "}", "\n", "return", "err", "\n", "}" ]
// TryExclusiveLock takes an exclusive lock without blocking. // This is idempotent when the Lock already represents an exclusive lock, // and tries promote a shared lock to exclusive atomically. // It will return ErrLocked if any lock is already held.
[ "TryExclusiveLock", "takes", "an", "exclusive", "lock", "without", "blocking", ".", "This", "is", "idempotent", "when", "the", "Lock", "already", "represents", "an", "exclusive", "lock", "and", "tries", "promote", "a", "shared", "lock", "to", "exclusive", "atomically", ".", "It", "will", "return", "ErrLocked", "if", "any", "lock", "is", "already", "held", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/lock/file.go#L48-L54
train
rkt/rkt
pkg/lock/file.go
ExclusiveLock
func (l *FileLock) ExclusiveLock() error { return syscall.Flock(l.fd, syscall.LOCK_EX) }
go
func (l *FileLock) ExclusiveLock() error { return syscall.Flock(l.fd, syscall.LOCK_EX) }
[ "func", "(", "l", "*", "FileLock", ")", "ExclusiveLock", "(", ")", "error", "{", "return", "syscall", ".", "Flock", "(", "l", ".", "fd", ",", "syscall", ".", "LOCK_EX", ")", "\n", "}" ]
// ExclusiveLock takes an exclusive lock. // This is idempotent when the Lock already represents an exclusive lock, // and promotes a shared lock to exclusive atomically. // It will block if an exclusive lock is already held.
[ "ExclusiveLock", "takes", "an", "exclusive", "lock", ".", "This", "is", "idempotent", "when", "the", "Lock", "already", "represents", "an", "exclusive", "lock", "and", "promotes", "a", "shared", "lock", "to", "exclusive", "atomically", ".", "It", "will", "block", "if", "an", "exclusive", "lock", "is", "already", "held", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/lock/file.go#L74-L76
train
rkt/rkt
pkg/lock/file.go
Unlock
func (l *FileLock) Unlock() error { return syscall.Flock(l.fd, syscall.LOCK_UN) }
go
func (l *FileLock) Unlock() error { return syscall.Flock(l.fd, syscall.LOCK_UN) }
[ "func", "(", "l", "*", "FileLock", ")", "Unlock", "(", ")", "error", "{", "return", "syscall", ".", "Flock", "(", "l", ".", "fd", ",", "syscall", ".", "LOCK_UN", ")", "\n", "}" ]
// Unlock unlocks the lock
[ "Unlock", "unlocks", "the", "lock" ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/lock/file.go#L140-L142
train
rkt/rkt
pkg/lock/file.go
Fd
func (l *FileLock) Fd() (int, error) { var err error if l.fd == -1 { err = errors.New("lock closed") } return l.fd, err }
go
func (l *FileLock) Fd() (int, error) { var err error if l.fd == -1 { err = errors.New("lock closed") } return l.fd, err }
[ "func", "(", "l", "*", "FileLock", ")", "Fd", "(", ")", "(", "int", ",", "error", ")", "{", "var", "err", "error", "\n", "if", "l", ".", "fd", "==", "-", "1", "{", "err", "=", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "l", ".", "fd", ",", "err", "\n", "}" ]
// Fd returns the lock's file descriptor, or an error if the lock is closed
[ "Fd", "returns", "the", "lock", "s", "file", "descriptor", "or", "an", "error", "if", "the", "lock", "is", "closed" ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/lock/file.go#L145-L151
train
rkt/rkt
pkg/lock/file.go
Close
func (l *FileLock) Close() error { fd := l.fd l.fd = -1 return syscall.Close(fd) }
go
func (l *FileLock) Close() error { fd := l.fd l.fd = -1 return syscall.Close(fd) }
[ "func", "(", "l", "*", "FileLock", ")", "Close", "(", ")", "error", "{", "fd", ":=", "l", ".", "fd", "\n", "l", ".", "fd", "=", "-", "1", "\n", "return", "syscall", ".", "Close", "(", "fd", ")", "\n", "}" ]
// Close closes the lock which implicitly unlocks it as well
[ "Close", "closes", "the", "lock", "which", "implicitly", "unlocks", "it", "as", "well" ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/lock/file.go#L154-L158
train
rkt/rkt
pkg/lock/file.go
NewLock
func NewLock(path string, lockType LockType) (*FileLock, error) { l := &FileLock{path: path, fd: -1} mode := syscall.O_RDONLY | syscall.O_CLOEXEC if lockType == Dir { mode |= syscall.O_DIRECTORY } lfd, err := syscall.Open(l.path, mode, 0) if err != nil { if err == syscall.ENOENT { err = ErrNotExist } else if err == syscall.EACCES { err = ErrPermission } return nil, err } l.fd = lfd var stat syscall.Stat_t err = syscall.Fstat(lfd, &stat) if err != nil { return nil, err } // Check if the file is a regular file if lockType == RegFile && !(stat.Mode&syscall.S_IFMT == syscall.S_IFREG) { return nil, ErrNotRegular } return l, nil }
go
func NewLock(path string, lockType LockType) (*FileLock, error) { l := &FileLock{path: path, fd: -1} mode := syscall.O_RDONLY | syscall.O_CLOEXEC if lockType == Dir { mode |= syscall.O_DIRECTORY } lfd, err := syscall.Open(l.path, mode, 0) if err != nil { if err == syscall.ENOENT { err = ErrNotExist } else if err == syscall.EACCES { err = ErrPermission } return nil, err } l.fd = lfd var stat syscall.Stat_t err = syscall.Fstat(lfd, &stat) if err != nil { return nil, err } // Check if the file is a regular file if lockType == RegFile && !(stat.Mode&syscall.S_IFMT == syscall.S_IFREG) { return nil, ErrNotRegular } return l, nil }
[ "func", "NewLock", "(", "path", "string", ",", "lockType", "LockType", ")", "(", "*", "FileLock", ",", "error", ")", "{", "l", ":=", "&", "FileLock", "{", "path", ":", "path", ",", "fd", ":", "-", "1", "}", "\n\n", "mode", ":=", "syscall", ".", "O_RDONLY", "|", "syscall", ".", "O_CLOEXEC", "\n", "if", "lockType", "==", "Dir", "{", "mode", "|=", "syscall", ".", "O_DIRECTORY", "\n", "}", "\n", "lfd", ",", "err", ":=", "syscall", ".", "Open", "(", "l", ".", "path", ",", "mode", ",", "0", ")", "\n", "if", "err", "!=", "nil", "{", "if", "err", "==", "syscall", ".", "ENOENT", "{", "err", "=", "ErrNotExist", "\n", "}", "else", "if", "err", "==", "syscall", ".", "EACCES", "{", "err", "=", "ErrPermission", "\n", "}", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "l", ".", "fd", "=", "lfd", "\n\n", "var", "stat", "syscall", ".", "Stat_t", "\n", "err", "=", "syscall", ".", "Fstat", "(", "lfd", ",", "&", "stat", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "// Check if the file is a regular file", "if", "lockType", "==", "RegFile", "&&", "!", "(", "stat", ".", "Mode", "&", "syscall", ".", "S_IFMT", "==", "syscall", ".", "S_IFREG", ")", "{", "return", "nil", ",", "ErrNotRegular", "\n", "}", "\n\n", "return", "l", ",", "nil", "\n", "}" ]
// NewLock opens a new lock on a file without acquisition
[ "NewLock", "opens", "a", "new", "lock", "on", "a", "file", "without", "acquisition" ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/lock/file.go#L161-L190
train
rkt/rkt
tools/depsgen/gocmd.go
goGetArgs
func goGetArgs(args []string) (string, string, string, goDepsMode) { f, target := standardFlags(goCmd) repo := f.String("repo", "", "Go repo (example: github.com/rkt/rkt)") module := f.String("module", "", "Module inside Go repo (example: stage1)") mode := f.String("mode", "make", "Mode to use (make - print deps as makefile [default], files - print a list of files)") f.Parse(args) if *repo == "" { common.Die("--repo parameter must be specified and cannot be empty") } if *module == "" { common.Die("--module parameter must be specified and cannot be empty") } var dMode goDepsMode switch *mode { case "make": dMode = goMakeMode if *target == "" { common.Die("--target parameter must be specified and cannot be empty when using 'make' mode") } case "files": dMode = goFilesMode default: common.Die("unknown --mode parameter %q - expected either 'make' or 'files'", *mode) } return *target, *repo, *module, dMode }
go
func goGetArgs(args []string) (string, string, string, goDepsMode) { f, target := standardFlags(goCmd) repo := f.String("repo", "", "Go repo (example: github.com/rkt/rkt)") module := f.String("module", "", "Module inside Go repo (example: stage1)") mode := f.String("mode", "make", "Mode to use (make - print deps as makefile [default], files - print a list of files)") f.Parse(args) if *repo == "" { common.Die("--repo parameter must be specified and cannot be empty") } if *module == "" { common.Die("--module parameter must be specified and cannot be empty") } var dMode goDepsMode switch *mode { case "make": dMode = goMakeMode if *target == "" { common.Die("--target parameter must be specified and cannot be empty when using 'make' mode") } case "files": dMode = goFilesMode default: common.Die("unknown --mode parameter %q - expected either 'make' or 'files'", *mode) } return *target, *repo, *module, dMode }
[ "func", "goGetArgs", "(", "args", "[", "]", "string", ")", "(", "string", ",", "string", ",", "string", ",", "goDepsMode", ")", "{", "f", ",", "target", ":=", "standardFlags", "(", "goCmd", ")", "\n", "repo", ":=", "f", ".", "String", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "module", ":=", "f", ".", "String", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "mode", ":=", "f", ".", "String", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n\n", "f", ".", "Parse", "(", "args", ")", "\n", "if", "*", "repo", "==", "\"", "\"", "{", "common", ".", "Die", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "*", "module", "==", "\"", "\"", "{", "common", ".", "Die", "(", "\"", "\"", ")", "\n", "}", "\n\n", "var", "dMode", "goDepsMode", "\n\n", "switch", "*", "mode", "{", "case", "\"", "\"", ":", "dMode", "=", "goMakeMode", "\n", "if", "*", "target", "==", "\"", "\"", "{", "common", ".", "Die", "(", "\"", "\"", ")", "\n", "}", "\n", "case", "\"", "\"", ":", "dMode", "=", "goFilesMode", "\n", "default", ":", "common", ".", "Die", "(", "\"", "\"", ",", "*", "mode", ")", "\n", "}", "\n", "return", "*", "target", ",", "*", "repo", ",", "*", "module", ",", "dMode", "\n", "}" ]
// getArgs parses given parameters and returns target, repo, module and // mode. If mode is "files", then target is optional.
[ "getArgs", "parses", "given", "parameters", "and", "returns", "target", "repo", "module", "and", "mode", ".", "If", "mode", "is", "files", "then", "target", "is", "optional", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/tools/depsgen/gocmd.go#L69-L97
train
rkt/rkt
tools/depsgen/gocmd.go
goGetPackageDeps
func goGetPackageDeps(repo, module string) []string { dir, deps := goGetDeps(repo, module) return goGetFiles(dir, deps) }
go
func goGetPackageDeps(repo, module string) []string { dir, deps := goGetDeps(repo, module) return goGetFiles(dir, deps) }
[ "func", "goGetPackageDeps", "(", "repo", ",", "module", "string", ")", "[", "]", "string", "{", "dir", ",", "deps", ":=", "goGetDeps", "(", "repo", ",", "module", ")", "\n", "return", "goGetFiles", "(", "dir", ",", "deps", ")", "\n", "}" ]
// goGetPackageDeps returns a list of files that are used to build a // module in a given repo.
[ "goGetPackageDeps", "returns", "a", "list", "of", "files", "that", "are", "used", "to", "build", "a", "module", "in", "a", "given", "repo", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/tools/depsgen/gocmd.go#L101-L104
train
rkt/rkt
tools/depsgen/gocmd.go
goGetDeps
func goGetDeps(repo, module string) (string, []string) { pkg := path.Join(repo, module) rawTuples := goRun(goList([]string{"Dir", "Deps"}, []string{pkg})) if len(rawTuples) != 1 { common.Die("Expected to get only one line from go list for a single package") } tuple := goSliceRawTuple(rawTuples[0]) dir := tuple[0] if module != "." { dirsToStrip := 1 + strings.Count(module, "/") for i := 0; i < dirsToStrip; i++ { dir = filepath.Dir(dir) } } dir = filepath.Clean(dir) deps := goSliceRawSlice(tuple[1]) return dir, append([]string{pkg}, deps...) }
go
func goGetDeps(repo, module string) (string, []string) { pkg := path.Join(repo, module) rawTuples := goRun(goList([]string{"Dir", "Deps"}, []string{pkg})) if len(rawTuples) != 1 { common.Die("Expected to get only one line from go list for a single package") } tuple := goSliceRawTuple(rawTuples[0]) dir := tuple[0] if module != "." { dirsToStrip := 1 + strings.Count(module, "/") for i := 0; i < dirsToStrip; i++ { dir = filepath.Dir(dir) } } dir = filepath.Clean(dir) deps := goSliceRawSlice(tuple[1]) return dir, append([]string{pkg}, deps...) }
[ "func", "goGetDeps", "(", "repo", ",", "module", "string", ")", "(", "string", ",", "[", "]", "string", ")", "{", "pkg", ":=", "path", ".", "Join", "(", "repo", ",", "module", ")", "\n", "rawTuples", ":=", "goRun", "(", "goList", "(", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", "}", ",", "[", "]", "string", "{", "pkg", "}", ")", ")", "\n", "if", "len", "(", "rawTuples", ")", "!=", "1", "{", "common", ".", "Die", "(", "\"", "\"", ")", "\n", "}", "\n", "tuple", ":=", "goSliceRawTuple", "(", "rawTuples", "[", "0", "]", ")", "\n", "dir", ":=", "tuple", "[", "0", "]", "\n", "if", "module", "!=", "\"", "\"", "{", "dirsToStrip", ":=", "1", "+", "strings", ".", "Count", "(", "module", ",", "\"", "\"", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "dirsToStrip", ";", "i", "++", "{", "dir", "=", "filepath", ".", "Dir", "(", "dir", ")", "\n", "}", "\n", "}", "\n", "dir", "=", "filepath", ".", "Clean", "(", "dir", ")", "\n", "deps", ":=", "goSliceRawSlice", "(", "tuple", "[", "1", "]", ")", "\n", "return", "dir", ",", "append", "(", "[", "]", "string", "{", "pkg", "}", ",", "deps", "...", ")", "\n", "}" ]
// goGetDeps gets the directory of a given repo and the all // dependencies, direct or indirect, of a given module in the repo.
[ "goGetDeps", "gets", "the", "directory", "of", "a", "given", "repo", "and", "the", "all", "dependencies", "direct", "or", "indirect", "of", "a", "given", "module", "in", "the", "repo", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/tools/depsgen/gocmd.go#L108-L125
train
rkt/rkt
tools/depsgen/gocmd.go
goGetFiles
func goGetFiles(dir string, pkgs []string) []string { params := []string{ "Dir", "GoFiles", "CgoFiles", } var allFiles []string rawTuples := goRun(goList(params, pkgs)) for _, raw := range rawTuples { tuple := goSliceRawTuple(raw) moduleDir := filepath.Clean(tuple[0]) dirSep := fmt.Sprintf("%s%c", dir, filepath.Separator) moduleDirSep := fmt.Sprintf("%s%c", moduleDir, filepath.Separator) if !strings.HasPrefix(moduleDirSep, dirSep) { continue } relModuleDir, err := filepath.Rel(dir, moduleDir) if err != nil { common.Die("Could not make a relative path from %q to %q, even if they have the same prefix", moduleDir, dir) } files := append(goSliceRawSlice(tuple[1]), goSliceRawSlice(tuple[2])...) for i := 0; i < len(files); i++ { files[i] = filepath.Join(relModuleDir, files[i]) } allFiles = append(allFiles, files...) } return allFiles }
go
func goGetFiles(dir string, pkgs []string) []string { params := []string{ "Dir", "GoFiles", "CgoFiles", } var allFiles []string rawTuples := goRun(goList(params, pkgs)) for _, raw := range rawTuples { tuple := goSliceRawTuple(raw) moduleDir := filepath.Clean(tuple[0]) dirSep := fmt.Sprintf("%s%c", dir, filepath.Separator) moduleDirSep := fmt.Sprintf("%s%c", moduleDir, filepath.Separator) if !strings.HasPrefix(moduleDirSep, dirSep) { continue } relModuleDir, err := filepath.Rel(dir, moduleDir) if err != nil { common.Die("Could not make a relative path from %q to %q, even if they have the same prefix", moduleDir, dir) } files := append(goSliceRawSlice(tuple[1]), goSliceRawSlice(tuple[2])...) for i := 0; i < len(files); i++ { files[i] = filepath.Join(relModuleDir, files[i]) } allFiles = append(allFiles, files...) } return allFiles }
[ "func", "goGetFiles", "(", "dir", "string", ",", "pkgs", "[", "]", "string", ")", "[", "]", "string", "{", "params", ":=", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "}", "\n", "var", "allFiles", "[", "]", "string", "\n", "rawTuples", ":=", "goRun", "(", "goList", "(", "params", ",", "pkgs", ")", ")", "\n", "for", "_", ",", "raw", ":=", "range", "rawTuples", "{", "tuple", ":=", "goSliceRawTuple", "(", "raw", ")", "\n", "moduleDir", ":=", "filepath", ".", "Clean", "(", "tuple", "[", "0", "]", ")", "\n", "dirSep", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "dir", ",", "filepath", ".", "Separator", ")", "\n", "moduleDirSep", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "moduleDir", ",", "filepath", ".", "Separator", ")", "\n", "if", "!", "strings", ".", "HasPrefix", "(", "moduleDirSep", ",", "dirSep", ")", "{", "continue", "\n", "}", "\n", "relModuleDir", ",", "err", ":=", "filepath", ".", "Rel", "(", "dir", ",", "moduleDir", ")", "\n", "if", "err", "!=", "nil", "{", "common", ".", "Die", "(", "\"", "\"", ",", "moduleDir", ",", "dir", ")", "\n", "}", "\n", "files", ":=", "append", "(", "goSliceRawSlice", "(", "tuple", "[", "1", "]", ")", ",", "goSliceRawSlice", "(", "tuple", "[", "2", "]", ")", "...", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "files", ")", ";", "i", "++", "{", "files", "[", "i", "]", "=", "filepath", ".", "Join", "(", "relModuleDir", ",", "files", "[", "i", "]", ")", "\n", "}", "\n", "allFiles", "=", "append", "(", "allFiles", ",", "files", "...", ")", "\n", "}", "\n", "return", "allFiles", "\n", "}" ]
// goGetFiles returns a list of files that are in given packages. File // paths are relative to a given directory.
[ "goGetFiles", "returns", "a", "list", "of", "files", "that", "are", "in", "given", "packages", ".", "File", "paths", "are", "relative", "to", "a", "given", "directory", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/tools/depsgen/gocmd.go#L129-L156
train
rkt/rkt
tools/depsgen/gocmd.go
goRun
func goRun(argv []string) []string { cmd := exec.Command(argv[0], argv[1:]...) stdout := new(bytes.Buffer) stderr := new(bytes.Buffer) cmd.Stdout = stdout cmd.Stderr = stderr if err := cmd.Run(); err != nil { common.Die("Error running %s: %v: %s", strings.Join(argv, " "), err, stderr.String()) } rawLines := strings.Split(stdout.String(), "\n") lines := make([]string, 0, len(rawLines)) for _, line := range rawLines { if trimmed := strings.TrimSpace(line); trimmed != "" { lines = append(lines, trimmed) } } return lines }
go
func goRun(argv []string) []string { cmd := exec.Command(argv[0], argv[1:]...) stdout := new(bytes.Buffer) stderr := new(bytes.Buffer) cmd.Stdout = stdout cmd.Stderr = stderr if err := cmd.Run(); err != nil { common.Die("Error running %s: %v: %s", strings.Join(argv, " "), err, stderr.String()) } rawLines := strings.Split(stdout.String(), "\n") lines := make([]string, 0, len(rawLines)) for _, line := range rawLines { if trimmed := strings.TrimSpace(line); trimmed != "" { lines = append(lines, trimmed) } } return lines }
[ "func", "goRun", "(", "argv", "[", "]", "string", ")", "[", "]", "string", "{", "cmd", ":=", "exec", ".", "Command", "(", "argv", "[", "0", "]", ",", "argv", "[", "1", ":", "]", "...", ")", "\n", "stdout", ":=", "new", "(", "bytes", ".", "Buffer", ")", "\n", "stderr", ":=", "new", "(", "bytes", ".", "Buffer", ")", "\n", "cmd", ".", "Stdout", "=", "stdout", "\n", "cmd", ".", "Stderr", "=", "stderr", "\n", "if", "err", ":=", "cmd", ".", "Run", "(", ")", ";", "err", "!=", "nil", "{", "common", ".", "Die", "(", "\"", "\"", ",", "strings", ".", "Join", "(", "argv", ",", "\"", "\"", ")", ",", "err", ",", "stderr", ".", "String", "(", ")", ")", "\n", "}", "\n", "rawLines", ":=", "strings", ".", "Split", "(", "stdout", ".", "String", "(", ")", ",", "\"", "\\n", "\"", ")", "\n", "lines", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "rawLines", ")", ")", "\n", "for", "_", ",", "line", ":=", "range", "rawLines", "{", "if", "trimmed", ":=", "strings", ".", "TrimSpace", "(", "line", ")", ";", "trimmed", "!=", "\"", "\"", "{", "lines", "=", "append", "(", "lines", ",", "trimmed", ")", "\n", "}", "\n", "}", "\n", "return", "lines", "\n", "}" ]
// goRun executes given argument list and captures its output. The // output is sliced into lines with empty lines being discarded.
[ "goRun", "executes", "given", "argument", "list", "and", "captures", "its", "output", ".", "The", "output", "is", "sliced", "into", "lines", "with", "empty", "lines", "being", "discarded", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/tools/depsgen/gocmd.go#L175-L192
train
rkt/rkt
tools/depsgen/gocmd.go
goSliceRawSlice
func goSliceRawSlice(s string) []string { s = strings.TrimPrefix(s, "[") s = strings.TrimSuffix(s, "]") s = strings.TrimSpace(s) if s == "" { return nil } a := strings.Split(s, " ") return a }
go
func goSliceRawSlice(s string) []string { s = strings.TrimPrefix(s, "[") s = strings.TrimSuffix(s, "]") s = strings.TrimSpace(s) if s == "" { return nil } a := strings.Split(s, " ") return a }
[ "func", "goSliceRawSlice", "(", "s", "string", ")", "[", "]", "string", "{", "s", "=", "strings", ".", "TrimPrefix", "(", "s", ",", "\"", "\"", ")", "\n", "s", "=", "strings", ".", "TrimSuffix", "(", "s", ",", "\"", "\"", ")", "\n", "s", "=", "strings", ".", "TrimSpace", "(", "s", ")", "\n", "if", "s", "==", "\"", "\"", "{", "return", "nil", "\n", "}", "\n", "a", ":=", "strings", ".", "Split", "(", "s", ",", "\"", "\"", ")", "\n", "return", "a", "\n", "}" ]
// goSliceRawSlice slices given string representation of a slice into // slice of strings.
[ "goSliceRawSlice", "slices", "given", "string", "representation", "of", "a", "slice", "into", "slice", "of", "strings", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/tools/depsgen/gocmd.go#L196-L205
train
rkt/rkt
stage1/init/common/mount.go
ConvertedFromDocker
func ConvertedFromDocker(im *schema.ImageManifest) bool { if im == nil { // nil sometimes sneaks in here due to unit tests return false } ann := im.Annotations _, ok := ann.Get("appc.io/docker/repository") return ok }
go
func ConvertedFromDocker(im *schema.ImageManifest) bool { if im == nil { // nil sometimes sneaks in here due to unit tests return false } ann := im.Annotations _, ok := ann.Get("appc.io/docker/repository") return ok }
[ "func", "ConvertedFromDocker", "(", "im", "*", "schema", ".", "ImageManifest", ")", "bool", "{", "if", "im", "==", "nil", "{", "// nil sometimes sneaks in here due to unit tests", "return", "false", "\n", "}", "\n", "ann", ":=", "im", ".", "Annotations", "\n", "_", ",", "ok", ":=", "ann", ".", "Get", "(", "\"", "\"", ")", "\n", "return", "ok", "\n", "}" ]
// ConvertedFromDocker determines if an app's image has been converted // from docker. This is needed because implicit docker empty volumes have // different behavior from AppC
[ "ConvertedFromDocker", "determines", "if", "an", "app", "s", "image", "has", "been", "converted", "from", "docker", ".", "This", "is", "needed", "because", "implicit", "docker", "empty", "volumes", "have", "different", "behavior", "from", "AppC" ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage1/init/common/mount.go#L53-L60
train
rkt/rkt
stage1/init/common/mount.go
Source
func (m *Mount) Source(podRoot string) string { switch m.Volume.Kind { case "host": return m.Volume.Source case "empty": return filepath.Join(common.SharedVolumesPath(podRoot), m.Volume.Name.String()) } return "" // We validate in GenerateMounts that it's valid }
go
func (m *Mount) Source(podRoot string) string { switch m.Volume.Kind { case "host": return m.Volume.Source case "empty": return filepath.Join(common.SharedVolumesPath(podRoot), m.Volume.Name.String()) } return "" // We validate in GenerateMounts that it's valid }
[ "func", "(", "m", "*", "Mount", ")", "Source", "(", "podRoot", "string", ")", "string", "{", "switch", "m", ".", "Volume", ".", "Kind", "{", "case", "\"", "\"", ":", "return", "m", ".", "Volume", ".", "Source", "\n", "case", "\"", "\"", ":", "return", "filepath", ".", "Join", "(", "common", ".", "SharedVolumesPath", "(", "podRoot", ")", ",", "m", ".", "Volume", ".", "Name", ".", "String", "(", ")", ")", "\n", "}", "\n", "return", "\"", "\"", "// We validate in GenerateMounts that it's valid", "\n", "}" ]
// Source computes the real volume source for a volume. // Volumes of type 'empty' use a workdir relative to podRoot
[ "Source", "computes", "the", "real", "volume", "source", "for", "a", "volume", ".", "Volumes", "of", "type", "empty", "use", "a", "workdir", "relative", "to", "podRoot" ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage1/init/common/mount.go#L64-L72
train
rkt/rkt
stage1/init/common/mount.go
GenerateMounts
func GenerateMounts(ra *schema.RuntimeApp, podVolumes []types.Volume, convertedFromDocker bool) ([]Mount, error) { app := ra.App var genMnts []Mount vols := make(map[types.ACName]types.Volume) for _, v := range podVolumes { vols[v.Name] = v } // RuntimeApps have mounts, whereas Apps have mountPoints. mountPoints are partially for // Docker compat; since apps can declare mountpoints. However, if we just run with rkt run, // then we'll only have a Mount and no corresponding MountPoint. // Furthermore, Mounts can have embedded volumes in the case of the CRI. // So, we generate a pile of Mounts and their corresponding Volume // Map of hostpath -> Mount mnts := make(map[string]schema.Mount) // Check runtimeApp's Mounts for _, m := range ra.Mounts { mnts[m.Path] = m vol := m.AppVolume // Mounts can supply a volume if vol == nil { vv, ok := vols[m.Volume] if !ok { return nil, fmt.Errorf("could not find volume %s", m.Volume) } vol = &vv } // Find a corresponding MountPoint, which is optional ro := false for _, mp := range ra.App.MountPoints { if mp.Name == m.Volume { ro = mp.ReadOnly break } } if vol.ReadOnly != nil { ro = *vol.ReadOnly } switch vol.Kind { case "host": case "empty": default: return nil, fmt.Errorf("Volume %s has invalid kind %s", vol.Name, vol.Kind) } genMnts = append(genMnts, Mount{ Mount: m, DockerImplicit: false, ReadOnly: ro, Volume: *vol, }) } // Now, match up MountPoints with Mounts or Volumes // If there's no Mount and no Volume, generate an empty volume for _, mp := range app.MountPoints { // there's already a Mount for this MountPoint, stop if _, ok := mnts[mp.Path]; ok { continue } // No Mount, try to match based on volume name vol, ok := vols[mp.Name] // there is no volume for this mount point, creating an "empty" volume // implicitly if !ok { defaultMode := "0755" defaultUID := 0 defaultGID := 0 uniqName := ra.Name + "-" + mp.Name emptyVol := types.Volume{ Name: uniqName, Kind: "empty", Mode: &defaultMode, UID: &defaultUID, GID: &defaultGID, } log.Printf("warning: no volume specified for mount point %q, implicitly creating an \"empty\" volume. This volume will be removed when the pod is garbage-collected.", mp.Name) if convertedFromDocker { log.Printf("Docker converted image, initializing implicit volume with data contained at the mount point %q.", mp.Name) } vols[uniqName] = emptyVol genMnts = append(genMnts, Mount{ Mount: schema.Mount{ Volume: uniqName, Path: mp.Path, }, Volume: emptyVol, ReadOnly: mp.ReadOnly, DockerImplicit: convertedFromDocker, }) } else { ro := mp.ReadOnly if vol.ReadOnly != nil { ro = *vol.ReadOnly } genMnts = append(genMnts, Mount{ Mount: schema.Mount{ Volume: vol.Name, Path: mp.Path, }, Volume: vol, ReadOnly: ro, DockerImplicit: false, }) } } return genMnts, nil }
go
func GenerateMounts(ra *schema.RuntimeApp, podVolumes []types.Volume, convertedFromDocker bool) ([]Mount, error) { app := ra.App var genMnts []Mount vols := make(map[types.ACName]types.Volume) for _, v := range podVolumes { vols[v.Name] = v } // RuntimeApps have mounts, whereas Apps have mountPoints. mountPoints are partially for // Docker compat; since apps can declare mountpoints. However, if we just run with rkt run, // then we'll only have a Mount and no corresponding MountPoint. // Furthermore, Mounts can have embedded volumes in the case of the CRI. // So, we generate a pile of Mounts and their corresponding Volume // Map of hostpath -> Mount mnts := make(map[string]schema.Mount) // Check runtimeApp's Mounts for _, m := range ra.Mounts { mnts[m.Path] = m vol := m.AppVolume // Mounts can supply a volume if vol == nil { vv, ok := vols[m.Volume] if !ok { return nil, fmt.Errorf("could not find volume %s", m.Volume) } vol = &vv } // Find a corresponding MountPoint, which is optional ro := false for _, mp := range ra.App.MountPoints { if mp.Name == m.Volume { ro = mp.ReadOnly break } } if vol.ReadOnly != nil { ro = *vol.ReadOnly } switch vol.Kind { case "host": case "empty": default: return nil, fmt.Errorf("Volume %s has invalid kind %s", vol.Name, vol.Kind) } genMnts = append(genMnts, Mount{ Mount: m, DockerImplicit: false, ReadOnly: ro, Volume: *vol, }) } // Now, match up MountPoints with Mounts or Volumes // If there's no Mount and no Volume, generate an empty volume for _, mp := range app.MountPoints { // there's already a Mount for this MountPoint, stop if _, ok := mnts[mp.Path]; ok { continue } // No Mount, try to match based on volume name vol, ok := vols[mp.Name] // there is no volume for this mount point, creating an "empty" volume // implicitly if !ok { defaultMode := "0755" defaultUID := 0 defaultGID := 0 uniqName := ra.Name + "-" + mp.Name emptyVol := types.Volume{ Name: uniqName, Kind: "empty", Mode: &defaultMode, UID: &defaultUID, GID: &defaultGID, } log.Printf("warning: no volume specified for mount point %q, implicitly creating an \"empty\" volume. This volume will be removed when the pod is garbage-collected.", mp.Name) if convertedFromDocker { log.Printf("Docker converted image, initializing implicit volume with data contained at the mount point %q.", mp.Name) } vols[uniqName] = emptyVol genMnts = append(genMnts, Mount{ Mount: schema.Mount{ Volume: uniqName, Path: mp.Path, }, Volume: emptyVol, ReadOnly: mp.ReadOnly, DockerImplicit: convertedFromDocker, }) } else { ro := mp.ReadOnly if vol.ReadOnly != nil { ro = *vol.ReadOnly } genMnts = append(genMnts, Mount{ Mount: schema.Mount{ Volume: vol.Name, Path: mp.Path, }, Volume: vol, ReadOnly: ro, DockerImplicit: false, }) } } return genMnts, nil }
[ "func", "GenerateMounts", "(", "ra", "*", "schema", ".", "RuntimeApp", ",", "podVolumes", "[", "]", "types", ".", "Volume", ",", "convertedFromDocker", "bool", ")", "(", "[", "]", "Mount", ",", "error", ")", "{", "app", ":=", "ra", ".", "App", "\n\n", "var", "genMnts", "[", "]", "Mount", "\n\n", "vols", ":=", "make", "(", "map", "[", "types", ".", "ACName", "]", "types", ".", "Volume", ")", "\n", "for", "_", ",", "v", ":=", "range", "podVolumes", "{", "vols", "[", "v", ".", "Name", "]", "=", "v", "\n", "}", "\n\n", "// RuntimeApps have mounts, whereas Apps have mountPoints. mountPoints are partially for", "// Docker compat; since apps can declare mountpoints. However, if we just run with rkt run,", "// then we'll only have a Mount and no corresponding MountPoint.", "// Furthermore, Mounts can have embedded volumes in the case of the CRI.", "// So, we generate a pile of Mounts and their corresponding Volume", "// Map of hostpath -> Mount", "mnts", ":=", "make", "(", "map", "[", "string", "]", "schema", ".", "Mount", ")", "\n\n", "// Check runtimeApp's Mounts", "for", "_", ",", "m", ":=", "range", "ra", ".", "Mounts", "{", "mnts", "[", "m", ".", "Path", "]", "=", "m", "\n\n", "vol", ":=", "m", ".", "AppVolume", "// Mounts can supply a volume", "\n", "if", "vol", "==", "nil", "{", "vv", ",", "ok", ":=", "vols", "[", "m", ".", "Volume", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "m", ".", "Volume", ")", "\n", "}", "\n", "vol", "=", "&", "vv", "\n", "}", "\n\n", "// Find a corresponding MountPoint, which is optional", "ro", ":=", "false", "\n", "for", "_", ",", "mp", ":=", "range", "ra", ".", "App", ".", "MountPoints", "{", "if", "mp", ".", "Name", "==", "m", ".", "Volume", "{", "ro", "=", "mp", ".", "ReadOnly", "\n", "break", "\n", "}", "\n", "}", "\n", "if", "vol", ".", "ReadOnly", "!=", "nil", "{", "ro", "=", "*", "vol", ".", "ReadOnly", "\n", "}", "\n\n", "switch", "vol", ".", "Kind", "{", "case", "\"", "\"", ":", "case", "\"", "\"", ":", "default", ":", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "vol", ".", "Name", ",", "vol", ".", "Kind", ")", "\n", "}", "\n", "genMnts", "=", "append", "(", "genMnts", ",", "Mount", "{", "Mount", ":", "m", ",", "DockerImplicit", ":", "false", ",", "ReadOnly", ":", "ro", ",", "Volume", ":", "*", "vol", ",", "}", ")", "\n", "}", "\n\n", "// Now, match up MountPoints with Mounts or Volumes", "// If there's no Mount and no Volume, generate an empty volume", "for", "_", ",", "mp", ":=", "range", "app", ".", "MountPoints", "{", "// there's already a Mount for this MountPoint, stop", "if", "_", ",", "ok", ":=", "mnts", "[", "mp", ".", "Path", "]", ";", "ok", "{", "continue", "\n", "}", "\n\n", "// No Mount, try to match based on volume name", "vol", ",", "ok", ":=", "vols", "[", "mp", ".", "Name", "]", "\n", "// there is no volume for this mount point, creating an \"empty\" volume", "// implicitly", "if", "!", "ok", "{", "defaultMode", ":=", "\"", "\"", "\n", "defaultUID", ":=", "0", "\n", "defaultGID", ":=", "0", "\n", "uniqName", ":=", "ra", ".", "Name", "+", "\"", "\"", "+", "mp", ".", "Name", "\n", "emptyVol", ":=", "types", ".", "Volume", "{", "Name", ":", "uniqName", ",", "Kind", ":", "\"", "\"", ",", "Mode", ":", "&", "defaultMode", ",", "UID", ":", "&", "defaultUID", ",", "GID", ":", "&", "defaultGID", ",", "}", "\n\n", "log", ".", "Printf", "(", "\"", "\\\"", "\\\"", "\"", ",", "mp", ".", "Name", ")", "\n", "if", "convertedFromDocker", "{", "log", ".", "Printf", "(", "\"", "\"", ",", "mp", ".", "Name", ")", "\n", "}", "\n\n", "vols", "[", "uniqName", "]", "=", "emptyVol", "\n", "genMnts", "=", "append", "(", "genMnts", ",", "Mount", "{", "Mount", ":", "schema", ".", "Mount", "{", "Volume", ":", "uniqName", ",", "Path", ":", "mp", ".", "Path", ",", "}", ",", "Volume", ":", "emptyVol", ",", "ReadOnly", ":", "mp", ".", "ReadOnly", ",", "DockerImplicit", ":", "convertedFromDocker", ",", "}", ")", "\n", "}", "else", "{", "ro", ":=", "mp", ".", "ReadOnly", "\n", "if", "vol", ".", "ReadOnly", "!=", "nil", "{", "ro", "=", "*", "vol", ".", "ReadOnly", "\n", "}", "\n", "genMnts", "=", "append", "(", "genMnts", ",", "Mount", "{", "Mount", ":", "schema", ".", "Mount", "{", "Volume", ":", "vol", ".", "Name", ",", "Path", ":", "mp", ".", "Path", ",", "}", ",", "Volume", ":", "vol", ",", "ReadOnly", ":", "ro", ",", "DockerImplicit", ":", "false", ",", "}", ")", "\n", "}", "\n", "}", "\n\n", "return", "genMnts", ",", "nil", "\n", "}" ]
// GenerateMounts maps MountPoint paths to volumes, returning a list of mounts, // each with a parameter indicating if it's an implicit empty volume from a // Docker image.
[ "GenerateMounts", "maps", "MountPoint", "paths", "to", "volumes", "returning", "a", "list", "of", "mounts", "each", "with", "a", "parameter", "indicating", "if", "it", "s", "an", "implicit", "empty", "volume", "from", "a", "Docker", "image", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage1/init/common/mount.go#L77-L196
train
rkt/rkt
stage1/init/common/mount.go
EnsureTargetExists
func EnsureTargetExists(source, destination string) error { fileInfo, err := os.Stat(source) if err != nil { return errwrap.Wrap(fmt.Errorf("could not stat source location: %v", source), err) } targetPathParent, _ := filepath.Split(destination) if err := os.MkdirAll(targetPathParent, common.SharedVolumePerm); err != nil { return errwrap.Wrap(fmt.Errorf("could not create parent directory: %v", targetPathParent), err) } if fileInfo.IsDir() { if err := os.Mkdir(destination, common.SharedVolumePerm); err != nil && !os.IsExist(err) { return errwrap.Wrap(errors.New("could not create destination directory "+destination), err) } } else { if file, err := os.OpenFile(destination, os.O_CREATE, common.SharedVolumePerm); err != nil { return errwrap.Wrap(errors.New("could not create destination file"), err) } else { file.Close() } } return nil }
go
func EnsureTargetExists(source, destination string) error { fileInfo, err := os.Stat(source) if err != nil { return errwrap.Wrap(fmt.Errorf("could not stat source location: %v", source), err) } targetPathParent, _ := filepath.Split(destination) if err := os.MkdirAll(targetPathParent, common.SharedVolumePerm); err != nil { return errwrap.Wrap(fmt.Errorf("could not create parent directory: %v", targetPathParent), err) } if fileInfo.IsDir() { if err := os.Mkdir(destination, common.SharedVolumePerm); err != nil && !os.IsExist(err) { return errwrap.Wrap(errors.New("could not create destination directory "+destination), err) } } else { if file, err := os.OpenFile(destination, os.O_CREATE, common.SharedVolumePerm); err != nil { return errwrap.Wrap(errors.New("could not create destination file"), err) } else { file.Close() } } return nil }
[ "func", "EnsureTargetExists", "(", "source", ",", "destination", "string", ")", "error", "{", "fileInfo", ",", "err", ":=", "os", ".", "Stat", "(", "source", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errwrap", ".", "Wrap", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "source", ")", ",", "err", ")", "\n", "}", "\n\n", "targetPathParent", ",", "_", ":=", "filepath", ".", "Split", "(", "destination", ")", "\n", "if", "err", ":=", "os", ".", "MkdirAll", "(", "targetPathParent", ",", "common", ".", "SharedVolumePerm", ")", ";", "err", "!=", "nil", "{", "return", "errwrap", ".", "Wrap", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "targetPathParent", ")", ",", "err", ")", "\n", "}", "\n\n", "if", "fileInfo", ".", "IsDir", "(", ")", "{", "if", "err", ":=", "os", ".", "Mkdir", "(", "destination", ",", "common", ".", "SharedVolumePerm", ")", ";", "err", "!=", "nil", "&&", "!", "os", ".", "IsExist", "(", "err", ")", "{", "return", "errwrap", ".", "Wrap", "(", "errors", ".", "New", "(", "\"", "\"", "+", "destination", ")", ",", "err", ")", "\n", "}", "\n", "}", "else", "{", "if", "file", ",", "err", ":=", "os", ".", "OpenFile", "(", "destination", ",", "os", ".", "O_CREATE", ",", "common", ".", "SharedVolumePerm", ")", ";", "err", "!=", "nil", "{", "return", "errwrap", ".", "Wrap", "(", "errors", ".", "New", "(", "\"", "\"", ")", ",", "err", ")", "\n", "}", "else", "{", "file", ".", "Close", "(", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]
// EnsureTargetExists will recursively create a given mountpoint. If directories // are created, their permissions are initialized to common.SharedVolumePerm
[ "EnsureTargetExists", "will", "recursively", "create", "a", "given", "mountpoint", ".", "If", "directories", "are", "created", "their", "permissions", "are", "initialized", "to", "common", ".", "SharedVolumePerm" ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage1/init/common/mount.go#L274-L297
train
rkt/rkt
rkt/image/httpops.go
DownloadSignature
func (o *httpOps) DownloadSignature(a *asc) (readSeekCloser, bool, error) { ensureLogger(o.Debug) diag.Printf("downloading signature from %v", a.Location) ascFile, err := a.Get() if err == nil { return ascFile, false, nil } if _, ok := err.(*statusAcceptedError); ok { log.Printf("server requested deferring the signature download") return NopReadSeekCloser(nil), true, nil } return nil, false, errwrap.Wrap(errors.New("error downloading the signature file"), err) }
go
func (o *httpOps) DownloadSignature(a *asc) (readSeekCloser, bool, error) { ensureLogger(o.Debug) diag.Printf("downloading signature from %v", a.Location) ascFile, err := a.Get() if err == nil { return ascFile, false, nil } if _, ok := err.(*statusAcceptedError); ok { log.Printf("server requested deferring the signature download") return NopReadSeekCloser(nil), true, nil } return nil, false, errwrap.Wrap(errors.New("error downloading the signature file"), err) }
[ "func", "(", "o", "*", "httpOps", ")", "DownloadSignature", "(", "a", "*", "asc", ")", "(", "readSeekCloser", ",", "bool", ",", "error", ")", "{", "ensureLogger", "(", "o", ".", "Debug", ")", "\n", "diag", ".", "Printf", "(", "\"", "\"", ",", "a", ".", "Location", ")", "\n", "ascFile", ",", "err", ":=", "a", ".", "Get", "(", ")", "\n", "if", "err", "==", "nil", "{", "return", "ascFile", ",", "false", ",", "nil", "\n", "}", "\n", "if", "_", ",", "ok", ":=", "err", ".", "(", "*", "statusAcceptedError", ")", ";", "ok", "{", "log", ".", "Printf", "(", "\"", "\"", ")", "\n", "return", "NopReadSeekCloser", "(", "nil", ")", ",", "true", ",", "nil", "\n", "}", "\n", "return", "nil", ",", "false", ",", "errwrap", ".", "Wrap", "(", "errors", ".", "New", "(", "\"", "\"", ")", ",", "err", ")", "\n", "}" ]
// DownloadSignature takes an asc instance and tries to get the // signature. If the remote server asked to to defer the download, // this function will return true and no error and no file.
[ "DownloadSignature", "takes", "an", "asc", "instance", "and", "tries", "to", "get", "the", "signature", ".", "If", "the", "remote", "server", "asked", "to", "to", "defer", "the", "download", "this", "function", "will", "return", "true", "and", "no", "error", "and", "no", "file", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/rkt/image/httpops.go#L43-L55
train
rkt/rkt
rkt/image/httpops.go
DownloadSignatureAgain
func (o *httpOps) DownloadSignatureAgain(a *asc) (readSeekCloser, error) { ensureLogger(o.Debug) ascFile, retry, err := o.DownloadSignature(a) if err != nil { return nil, err } if retry { return nil, fmt.Errorf("error downloading the signature file: server asked to defer the download again") } return ascFile, nil }
go
func (o *httpOps) DownloadSignatureAgain(a *asc) (readSeekCloser, error) { ensureLogger(o.Debug) ascFile, retry, err := o.DownloadSignature(a) if err != nil { return nil, err } if retry { return nil, fmt.Errorf("error downloading the signature file: server asked to defer the download again") } return ascFile, nil }
[ "func", "(", "o", "*", "httpOps", ")", "DownloadSignatureAgain", "(", "a", "*", "asc", ")", "(", "readSeekCloser", ",", "error", ")", "{", "ensureLogger", "(", "o", ".", "Debug", ")", "\n", "ascFile", ",", "retry", ",", "err", ":=", "o", ".", "DownloadSignature", "(", "a", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "retry", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "ascFile", ",", "nil", "\n", "}" ]
// DownloadSignatureAgain does a similar thing to DownloadSignature, // but it expects the signature to be actually provided, that is - no // deferring this time.
[ "DownloadSignatureAgain", "does", "a", "similar", "thing", "to", "DownloadSignature", "but", "it", "expects", "the", "signature", "to", "be", "actually", "provided", "that", "is", "-", "no", "deferring", "this", "time", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/rkt/image/httpops.go#L60-L70
train
rkt/rkt
rkt/image/httpops.go
DownloadImage
func (o *httpOps) DownloadImage(u *url.URL) (readSeekCloser, *cacheData, error) { ensureLogger(o.Debug) image, cd, err := o.DownloadImageWithETag(u, "") if err != nil { return nil, nil, err } if cd.UseCached { return nil, nil, fmt.Errorf("asked to use cached image even if not asked for that") } return image, cd, nil }
go
func (o *httpOps) DownloadImage(u *url.URL) (readSeekCloser, *cacheData, error) { ensureLogger(o.Debug) image, cd, err := o.DownloadImageWithETag(u, "") if err != nil { return nil, nil, err } if cd.UseCached { return nil, nil, fmt.Errorf("asked to use cached image even if not asked for that") } return image, cd, nil }
[ "func", "(", "o", "*", "httpOps", ")", "DownloadImage", "(", "u", "*", "url", ".", "URL", ")", "(", "readSeekCloser", ",", "*", "cacheData", ",", "error", ")", "{", "ensureLogger", "(", "o", ".", "Debug", ")", "\n", "image", ",", "cd", ",", "err", ":=", "o", ".", "DownloadImageWithETag", "(", "u", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "if", "cd", ".", "UseCached", "{", "return", "nil", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "image", ",", "cd", ",", "nil", "\n", "}" ]
// DownloadImage download the image, duh. It expects to actually // receive the file, instead of being asked to use the cached version.
[ "DownloadImage", "download", "the", "image", "duh", ".", "It", "expects", "to", "actually", "receive", "the", "file", "instead", "of", "being", "asked", "to", "use", "the", "cached", "version", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/rkt/image/httpops.go#L74-L84
train
rkt/rkt
rkt/image/httpops.go
DownloadImageWithETag
func (o *httpOps) DownloadImageWithETag(u *url.URL, etag string) (readSeekCloser, *cacheData, error) { var aciFile *removeOnClose // closed on error var errClose error // error signaling to close aciFile ensureLogger(o.Debug) aciFile, err := getTmpROC(o.S, u.String()) if err != nil { return nil, nil, err } defer func() { if errClose != nil { aciFile.Close() } }() session := o.getSession(u, aciFile.File, "ACI", etag) dl := o.getDownloader(session) errClose = dl.Download(u, aciFile.File) if errClose != nil { return nil, nil, errwrap.Wrap(errors.New("error downloading ACI"), errClose) } if session.Cd.UseCached { aciFile.Close() return NopReadSeekCloser(nil), session.Cd, nil } return aciFile, session.Cd, nil }
go
func (o *httpOps) DownloadImageWithETag(u *url.URL, etag string) (readSeekCloser, *cacheData, error) { var aciFile *removeOnClose // closed on error var errClose error // error signaling to close aciFile ensureLogger(o.Debug) aciFile, err := getTmpROC(o.S, u.String()) if err != nil { return nil, nil, err } defer func() { if errClose != nil { aciFile.Close() } }() session := o.getSession(u, aciFile.File, "ACI", etag) dl := o.getDownloader(session) errClose = dl.Download(u, aciFile.File) if errClose != nil { return nil, nil, errwrap.Wrap(errors.New("error downloading ACI"), errClose) } if session.Cd.UseCached { aciFile.Close() return NopReadSeekCloser(nil), session.Cd, nil } return aciFile, session.Cd, nil }
[ "func", "(", "o", "*", "httpOps", ")", "DownloadImageWithETag", "(", "u", "*", "url", ".", "URL", ",", "etag", "string", ")", "(", "readSeekCloser", ",", "*", "cacheData", ",", "error", ")", "{", "var", "aciFile", "*", "removeOnClose", "// closed on error", "\n", "var", "errClose", "error", "// error signaling to close aciFile", "\n\n", "ensureLogger", "(", "o", ".", "Debug", ")", "\n", "aciFile", ",", "err", ":=", "getTmpROC", "(", "o", ".", "S", ",", "u", ".", "String", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n\n", "defer", "func", "(", ")", "{", "if", "errClose", "!=", "nil", "{", "aciFile", ".", "Close", "(", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "session", ":=", "o", ".", "getSession", "(", "u", ",", "aciFile", ".", "File", ",", "\"", "\"", ",", "etag", ")", "\n", "dl", ":=", "o", ".", "getDownloader", "(", "session", ")", "\n", "errClose", "=", "dl", ".", "Download", "(", "u", ",", "aciFile", ".", "File", ")", "\n", "if", "errClose", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "errwrap", ".", "Wrap", "(", "errors", ".", "New", "(", "\"", "\"", ")", ",", "errClose", ")", "\n", "}", "\n\n", "if", "session", ".", "Cd", ".", "UseCached", "{", "aciFile", ".", "Close", "(", ")", "\n", "return", "NopReadSeekCloser", "(", "nil", ")", ",", "session", ".", "Cd", ",", "nil", "\n", "}", "\n\n", "return", "aciFile", ",", "session", ".", "Cd", ",", "nil", "\n", "}" ]
// DownloadImageWithETag might download an image or tell you to use // the cached image. In the latter case the returned file will be nil.
[ "DownloadImageWithETag", "might", "download", "an", "image", "or", "tell", "you", "to", "use", "the", "cached", "image", ".", "In", "the", "latter", "case", "the", "returned", "file", "will", "be", "nil", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/rkt/image/httpops.go#L88-L117
train
rkt/rkt
rkt/image/httpops.go
AscRemoteFetcher
func (o *httpOps) AscRemoteFetcher() *remoteAscFetcher { ensureLogger(o.Debug) f := func(u *url.URL, file *os.File) error { switch u.Scheme { case "http", "https": default: return fmt.Errorf("invalid signature location: expected %q scheme, got %q", "http(s)", u.Scheme) } session := o.getSession(u, file, "signature", "") dl := o.getDownloader(session) err := dl.Download(u, file) if err != nil { return err } if session.Cd.UseCached { return fmt.Errorf("unexpected cache reuse request for signature %q", u.String()) } return nil } return &remoteAscFetcher{ F: f, S: o.S, } }
go
func (o *httpOps) AscRemoteFetcher() *remoteAscFetcher { ensureLogger(o.Debug) f := func(u *url.URL, file *os.File) error { switch u.Scheme { case "http", "https": default: return fmt.Errorf("invalid signature location: expected %q scheme, got %q", "http(s)", u.Scheme) } session := o.getSession(u, file, "signature", "") dl := o.getDownloader(session) err := dl.Download(u, file) if err != nil { return err } if session.Cd.UseCached { return fmt.Errorf("unexpected cache reuse request for signature %q", u.String()) } return nil } return &remoteAscFetcher{ F: f, S: o.S, } }
[ "func", "(", "o", "*", "httpOps", ")", "AscRemoteFetcher", "(", ")", "*", "remoteAscFetcher", "{", "ensureLogger", "(", "o", ".", "Debug", ")", "\n", "f", ":=", "func", "(", "u", "*", "url", ".", "URL", ",", "file", "*", "os", ".", "File", ")", "error", "{", "switch", "u", ".", "Scheme", "{", "case", "\"", "\"", ",", "\"", "\"", ":", "default", ":", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "\"", "\"", ",", "u", ".", "Scheme", ")", "\n", "}", "\n", "session", ":=", "o", ".", "getSession", "(", "u", ",", "file", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "dl", ":=", "o", ".", "getDownloader", "(", "session", ")", "\n", "err", ":=", "dl", ".", "Download", "(", "u", ",", "file", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "session", ".", "Cd", ".", "UseCached", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "u", ".", "String", "(", ")", ")", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "return", "&", "remoteAscFetcher", "{", "F", ":", "f", ",", "S", ":", "o", ".", "S", ",", "}", "\n", "}" ]
// AscRemoteFetcher provides a remoteAscFetcher for asc.
[ "AscRemoteFetcher", "provides", "a", "remoteAscFetcher", "for", "asc", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/rkt/image/httpops.go#L120-L143
train
rkt/rkt
stage1/iottymux/iottymux.go
actionAttach
func actionAttach(statusPath string, autoMode bool) error { var endpoints Targets dialTimeout := 15 * time.Second // retrieve available endpoints statusFile, err := os.OpenFile(statusPath, os.O_RDONLY, os.ModePerm) if err != nil { return err } err = json.NewDecoder(statusFile).Decode(&endpoints) _ = statusFile.Close() if err != nil { return err } // retrieve custom attaching modes customTargets := struct { ttyIn bool ttyOut bool stdin bool stdout bool stderr bool }{} if !autoMode { customTargets.ttyIn, _ = strconv.ParseBool(os.Getenv("STAGE2_ATTACH_TTYIN")) customTargets.ttyOut, _ = strconv.ParseBool(os.Getenv("STAGE2_ATTACH_TTYOUT")) customTargets.stdin, _ = strconv.ParseBool(os.Getenv("STAGE2_ATTACH_STDIN")) customTargets.stdout, _ = strconv.ParseBool(os.Getenv("STAGE2_ATTACH_STDOUT")) customTargets.stderr, _ = strconv.ParseBool(os.Getenv("STAGE2_ATTACH_STDERR")) } // Proxy I/O between this process and the iottymux service: // - input (stdin, tty-in) copying routines can only be canceled by process killing (ie. user detaching) // - output (stdout, stderr, tty-out) copying routines are canceled by errors when reading from remote service c := make(chan error) copyOut := func(w io.Writer, conn net.Conn) { _, err := io.Copy(w, conn) c <- err } for _, ep := range endpoints.Targets { d := net.Dialer{Timeout: dialTimeout} conn, err := d.Dial(ep.Domain, ep.Address) if err != nil { return err } defer conn.Close() switch ep.Name { case "stdin": if autoMode || customTargets.stdin { go io.Copy(conn, os.Stdin) } case "stdout": if autoMode || customTargets.stdout { go copyOut(os.Stdout, conn) } case "stderr": if autoMode || customTargets.stderr { go copyOut(os.Stderr, conn) } case "tty": if autoMode || customTargets.ttyIn { go io.Copy(conn, os.Stdin) } if autoMode || customTargets.ttyOut { go copyOut(os.Stdout, conn) } else { go copyOut(ioutil.Discard, conn) } } } // as soon as one output copying routine fails, this unblocks and the whole process exits return <-c }
go
func actionAttach(statusPath string, autoMode bool) error { var endpoints Targets dialTimeout := 15 * time.Second // retrieve available endpoints statusFile, err := os.OpenFile(statusPath, os.O_RDONLY, os.ModePerm) if err != nil { return err } err = json.NewDecoder(statusFile).Decode(&endpoints) _ = statusFile.Close() if err != nil { return err } // retrieve custom attaching modes customTargets := struct { ttyIn bool ttyOut bool stdin bool stdout bool stderr bool }{} if !autoMode { customTargets.ttyIn, _ = strconv.ParseBool(os.Getenv("STAGE2_ATTACH_TTYIN")) customTargets.ttyOut, _ = strconv.ParseBool(os.Getenv("STAGE2_ATTACH_TTYOUT")) customTargets.stdin, _ = strconv.ParseBool(os.Getenv("STAGE2_ATTACH_STDIN")) customTargets.stdout, _ = strconv.ParseBool(os.Getenv("STAGE2_ATTACH_STDOUT")) customTargets.stderr, _ = strconv.ParseBool(os.Getenv("STAGE2_ATTACH_STDERR")) } // Proxy I/O between this process and the iottymux service: // - input (stdin, tty-in) copying routines can only be canceled by process killing (ie. user detaching) // - output (stdout, stderr, tty-out) copying routines are canceled by errors when reading from remote service c := make(chan error) copyOut := func(w io.Writer, conn net.Conn) { _, err := io.Copy(w, conn) c <- err } for _, ep := range endpoints.Targets { d := net.Dialer{Timeout: dialTimeout} conn, err := d.Dial(ep.Domain, ep.Address) if err != nil { return err } defer conn.Close() switch ep.Name { case "stdin": if autoMode || customTargets.stdin { go io.Copy(conn, os.Stdin) } case "stdout": if autoMode || customTargets.stdout { go copyOut(os.Stdout, conn) } case "stderr": if autoMode || customTargets.stderr { go copyOut(os.Stderr, conn) } case "tty": if autoMode || customTargets.ttyIn { go io.Copy(conn, os.Stdin) } if autoMode || customTargets.ttyOut { go copyOut(os.Stdout, conn) } else { go copyOut(ioutil.Discard, conn) } } } // as soon as one output copying routine fails, this unblocks and the whole process exits return <-c }
[ "func", "actionAttach", "(", "statusPath", "string", ",", "autoMode", "bool", ")", "error", "{", "var", "endpoints", "Targets", "\n", "dialTimeout", ":=", "15", "*", "time", ".", "Second", "\n\n", "// retrieve available endpoints", "statusFile", ",", "err", ":=", "os", ".", "OpenFile", "(", "statusPath", ",", "os", ".", "O_RDONLY", ",", "os", ".", "ModePerm", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "err", "=", "json", ".", "NewDecoder", "(", "statusFile", ")", ".", "Decode", "(", "&", "endpoints", ")", "\n", "_", "=", "statusFile", ".", "Close", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// retrieve custom attaching modes", "customTargets", ":=", "struct", "{", "ttyIn", "bool", "\n", "ttyOut", "bool", "\n", "stdin", "bool", "\n", "stdout", "bool", "\n", "stderr", "bool", "\n", "}", "{", "}", "\n", "if", "!", "autoMode", "{", "customTargets", ".", "ttyIn", ",", "_", "=", "strconv", ".", "ParseBool", "(", "os", ".", "Getenv", "(", "\"", "\"", ")", ")", "\n", "customTargets", ".", "ttyOut", ",", "_", "=", "strconv", ".", "ParseBool", "(", "os", ".", "Getenv", "(", "\"", "\"", ")", ")", "\n", "customTargets", ".", "stdin", ",", "_", "=", "strconv", ".", "ParseBool", "(", "os", ".", "Getenv", "(", "\"", "\"", ")", ")", "\n", "customTargets", ".", "stdout", ",", "_", "=", "strconv", ".", "ParseBool", "(", "os", ".", "Getenv", "(", "\"", "\"", ")", ")", "\n", "customTargets", ".", "stderr", ",", "_", "=", "strconv", ".", "ParseBool", "(", "os", ".", "Getenv", "(", "\"", "\"", ")", ")", "\n", "}", "\n\n", "// Proxy I/O between this process and the iottymux service:", "// - input (stdin, tty-in) copying routines can only be canceled by process killing (ie. user detaching)", "// - output (stdout, stderr, tty-out) copying routines are canceled by errors when reading from remote service", "c", ":=", "make", "(", "chan", "error", ")", "\n", "copyOut", ":=", "func", "(", "w", "io", ".", "Writer", ",", "conn", "net", ".", "Conn", ")", "{", "_", ",", "err", ":=", "io", ".", "Copy", "(", "w", ",", "conn", ")", "\n", "c", "<-", "err", "\n", "}", "\n\n", "for", "_", ",", "ep", ":=", "range", "endpoints", ".", "Targets", "{", "d", ":=", "net", ".", "Dialer", "{", "Timeout", ":", "dialTimeout", "}", "\n", "conn", ",", "err", ":=", "d", ".", "Dial", "(", "ep", ".", "Domain", ",", "ep", ".", "Address", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "conn", ".", "Close", "(", ")", "\n", "switch", "ep", ".", "Name", "{", "case", "\"", "\"", ":", "if", "autoMode", "||", "customTargets", ".", "stdin", "{", "go", "io", ".", "Copy", "(", "conn", ",", "os", ".", "Stdin", ")", "\n", "}", "\n", "case", "\"", "\"", ":", "if", "autoMode", "||", "customTargets", ".", "stdout", "{", "go", "copyOut", "(", "os", ".", "Stdout", ",", "conn", ")", "\n", "}", "\n", "case", "\"", "\"", ":", "if", "autoMode", "||", "customTargets", ".", "stderr", "{", "go", "copyOut", "(", "os", ".", "Stderr", ",", "conn", ")", "\n", "}", "\n", "case", "\"", "\"", ":", "if", "autoMode", "||", "customTargets", ".", "ttyIn", "{", "go", "io", ".", "Copy", "(", "conn", ",", "os", ".", "Stdin", ")", "\n", "}", "\n\n", "if", "autoMode", "||", "customTargets", ".", "ttyOut", "{", "go", "copyOut", "(", "os", ".", "Stdout", ",", "conn", ")", "\n", "}", "else", "{", "go", "copyOut", "(", "ioutil", ".", "Discard", ",", "conn", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "// as soon as one output copying routine fails, this unblocks and the whole process exits", "return", "<-", "c", "\n", "}" ]
// actionAttach handles the attach action, either in "automatic" or "custom endpoints" mode.
[ "actionAttach", "handles", "the", "attach", "action", "either", "in", "automatic", "or", "custom", "endpoints", "mode", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage1/iottymux/iottymux.go#L137-L212
train
rkt/rkt
stage1/iottymux/iottymux.go
dispatchSig
func dispatchSig(stop chan<- error) { sigChan := make(chan os.Signal) signal.Notify( sigChan, syscall.SIGTERM, syscall.SIGHUP, syscall.SIGINT, ) go func() { diag.Println("Waiting for signal") sig := <-sigChan diag.Printf("Received signal %v\n", sig) close(stop) }() }
go
func dispatchSig(stop chan<- error) { sigChan := make(chan os.Signal) signal.Notify( sigChan, syscall.SIGTERM, syscall.SIGHUP, syscall.SIGINT, ) go func() { diag.Println("Waiting for signal") sig := <-sigChan diag.Printf("Received signal %v\n", sig) close(stop) }() }
[ "func", "dispatchSig", "(", "stop", "chan", "<-", "error", ")", "{", "sigChan", ":=", "make", "(", "chan", "os", ".", "Signal", ")", "\n", "signal", ".", "Notify", "(", "sigChan", ",", "syscall", ".", "SIGTERM", ",", "syscall", ".", "SIGHUP", ",", "syscall", ".", "SIGINT", ",", ")", "\n\n", "go", "func", "(", ")", "{", "diag", ".", "Println", "(", "\"", "\"", ")", "\n", "sig", ":=", "<-", "sigChan", "\n", "diag", ".", "Printf", "(", "\"", "\\n", "\"", ",", "sig", ")", "\n", "close", "(", "stop", ")", "\n", "}", "(", ")", "\n", "}" ]
// dispatchSig launches a goroutine and closes the given stop channel // when SIGTERM, SIGHUP, or SIGINT is received.
[ "dispatchSig", "launches", "a", "goroutine", "and", "closes", "the", "given", "stop", "channel", "when", "SIGTERM", "SIGHUP", "or", "SIGINT", "is", "received", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage1/iottymux/iottymux.go#L475-L490
train
rkt/rkt
stage1/iottymux/iottymux.go
bufferLine
func bufferLine(src io.Reader, c chan<- []byte, ec chan<- error) { rd := bufio.NewReader(src) for { lineOut, err := rd.ReadBytes('\n') if len(lineOut) > 0 { c <- lineOut } if err != nil { ec <- err } } }
go
func bufferLine(src io.Reader, c chan<- []byte, ec chan<- error) { rd := bufio.NewReader(src) for { lineOut, err := rd.ReadBytes('\n') if len(lineOut) > 0 { c <- lineOut } if err != nil { ec <- err } } }
[ "func", "bufferLine", "(", "src", "io", ".", "Reader", ",", "c", "chan", "<-", "[", "]", "byte", ",", "ec", "chan", "<-", "error", ")", "{", "rd", ":=", "bufio", ".", "NewReader", "(", "src", ")", "\n", "for", "{", "lineOut", ",", "err", ":=", "rd", ".", "ReadBytes", "(", "'\\n'", ")", "\n", "if", "len", "(", "lineOut", ")", ">", "0", "{", "c", "<-", "lineOut", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "ec", "<-", "err", "\n", "}", "\n", "}", "\n", "}" ]
// bufferLine buffers and queues a single line from a Reader to a multiplexer // If reading from src fails, it hard-fails and propagates the error back.
[ "bufferLine", "buffers", "and", "queues", "a", "single", "line", "from", "a", "Reader", "to", "a", "multiplexer", "If", "reading", "from", "src", "fails", "it", "hard", "-", "fails", "and", "propagates", "the", "error", "back", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage1/iottymux/iottymux.go#L494-L505
train
rkt/rkt
stage1/iottymux/iottymux.go
acceptConn
func acceptConn(socket net.Listener, c chan<- net.Conn, stream string) { for { conn, err := socket.Accept() if err == nil { diag.Printf("Accepted new connection for %s\n", stream) c <- conn } } }
go
func acceptConn(socket net.Listener, c chan<- net.Conn, stream string) { for { conn, err := socket.Accept() if err == nil { diag.Printf("Accepted new connection for %s\n", stream) c <- conn } } }
[ "func", "acceptConn", "(", "socket", "net", ".", "Listener", ",", "c", "chan", "<-", "net", ".", "Conn", ",", "stream", "string", ")", "{", "for", "{", "conn", ",", "err", ":=", "socket", ".", "Accept", "(", ")", "\n", "if", "err", "==", "nil", "{", "diag", ".", "Printf", "(", "\"", "\\n", "\"", ",", "stream", ")", "\n", "c", "<-", "conn", "\n", "}", "\n", "}", "\n", "}" ]
// acceptConn accepts a single client and queues it for further proxying // It is never canceled explicitly, as it is bound to the lifetime of the main process.
[ "acceptConn", "accepts", "a", "single", "client", "and", "queues", "it", "for", "further", "proxying", "It", "is", "never", "canceled", "explicitly", "as", "it", "is", "bound", "to", "the", "lifetime", "of", "the", "main", "process", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage1/iottymux/iottymux.go#L509-L517
train
rkt/rkt
stage1/iottymux/iottymux.go
muxInput
func muxInput(clients <-chan net.Conn, stdin *os.File) { for { select { case c := <-clients: go bufferInput(c, stdin) } } }
go
func muxInput(clients <-chan net.Conn, stdin *os.File) { for { select { case c := <-clients: go bufferInput(c, stdin) } } }
[ "func", "muxInput", "(", "clients", "<-", "chan", "net", ".", "Conn", ",", "stdin", "*", "os", ".", "File", ")", "{", "for", "{", "select", "{", "case", "c", ":=", "<-", "clients", ":", "go", "bufferInput", "(", "c", ",", "stdin", ")", "\n", "}", "\n", "}", "\n", "}" ]
// muxInput accepts remote clients and multiplex input line from them
[ "muxInput", "accepts", "remote", "clients", "and", "multiplex", "input", "line", "from", "them" ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage1/iottymux/iottymux.go#L558-L565
train
rkt/rkt
stage1/iottymux/iottymux.go
bufferInput
func bufferInput(conn net.Conn, stdin *os.File) { rd := bufio.NewReader(conn) defer conn.Close() for { lineIn, err := rd.ReadBytes('\n') if len(lineIn) == 0 && err != nil { return } _, err = stdin.Write(lineIn) if err != nil { return } } }
go
func bufferInput(conn net.Conn, stdin *os.File) { rd := bufio.NewReader(conn) defer conn.Close() for { lineIn, err := rd.ReadBytes('\n') if len(lineIn) == 0 && err != nil { return } _, err = stdin.Write(lineIn) if err != nil { return } } }
[ "func", "bufferInput", "(", "conn", "net", ".", "Conn", ",", "stdin", "*", "os", ".", "File", ")", "{", "rd", ":=", "bufio", ".", "NewReader", "(", "conn", ")", "\n", "defer", "conn", ".", "Close", "(", ")", "\n", "for", "{", "lineIn", ",", "err", ":=", "rd", ".", "ReadBytes", "(", "'\\n'", ")", "\n", "if", "len", "(", "lineIn", ")", "==", "0", "&&", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "_", ",", "err", "=", "stdin", ".", "Write", "(", "lineIn", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "}", "\n", "}" ]
// bufferInput buffers and write a single line from a remote client to the local app
[ "bufferInput", "buffers", "and", "write", "a", "single", "line", "from", "a", "remote", "client", "to", "the", "local", "app" ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage1/iottymux/iottymux.go#L568-L581
train
rkt/rkt
stage1/iottymux/iottymux.go
muxOutput
func muxOutput(streamLabel string, lines chan []byte, clients <-chan net.Conn, targets <-chan io.WriteCloser) { var logs []io.WriteCloser var conns []io.WriteCloser writeAndFilter := func(wc io.WriteCloser, line []byte) bool { _, err := wc.Write(line) if err != nil { wc.Close() } return err != nil } logsWriteAndFilter := func(wc io.WriteCloser, line []byte) bool { out := []byte(fmt.Sprintf("%s %s %s", time.Now().Format(time.RFC3339Nano), streamLabel, line)) return writeAndFilter(wc, out) } for { select { // an incoming output line to multiplex // TODO(lucab): ordered non-blocking writes case l := <-lines: conns = filterTargets(conns, l, writeAndFilter) logs = filterTargets(logs, l, logsWriteAndFilter) // a new remote client case c := <-clients: conns = append(conns, c) // a new local log target case t := <-targets: logs = append(logs, t) } } }
go
func muxOutput(streamLabel string, lines chan []byte, clients <-chan net.Conn, targets <-chan io.WriteCloser) { var logs []io.WriteCloser var conns []io.WriteCloser writeAndFilter := func(wc io.WriteCloser, line []byte) bool { _, err := wc.Write(line) if err != nil { wc.Close() } return err != nil } logsWriteAndFilter := func(wc io.WriteCloser, line []byte) bool { out := []byte(fmt.Sprintf("%s %s %s", time.Now().Format(time.RFC3339Nano), streamLabel, line)) return writeAndFilter(wc, out) } for { select { // an incoming output line to multiplex // TODO(lucab): ordered non-blocking writes case l := <-lines: conns = filterTargets(conns, l, writeAndFilter) logs = filterTargets(logs, l, logsWriteAndFilter) // a new remote client case c := <-clients: conns = append(conns, c) // a new local log target case t := <-targets: logs = append(logs, t) } } }
[ "func", "muxOutput", "(", "streamLabel", "string", ",", "lines", "chan", "[", "]", "byte", ",", "clients", "<-", "chan", "net", ".", "Conn", ",", "targets", "<-", "chan", "io", ".", "WriteCloser", ")", "{", "var", "logs", "[", "]", "io", ".", "WriteCloser", "\n", "var", "conns", "[", "]", "io", ".", "WriteCloser", "\n\n", "writeAndFilter", ":=", "func", "(", "wc", "io", ".", "WriteCloser", ",", "line", "[", "]", "byte", ")", "bool", "{", "_", ",", "err", ":=", "wc", ".", "Write", "(", "line", ")", "\n", "if", "err", "!=", "nil", "{", "wc", ".", "Close", "(", ")", "\n", "}", "\n", "return", "err", "!=", "nil", "\n", "}", "\n\n", "logsWriteAndFilter", ":=", "func", "(", "wc", "io", ".", "WriteCloser", ",", "line", "[", "]", "byte", ")", "bool", "{", "out", ":=", "[", "]", "byte", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "time", ".", "Now", "(", ")", ".", "Format", "(", "time", ".", "RFC3339Nano", ")", ",", "streamLabel", ",", "line", ")", ")", "\n", "return", "writeAndFilter", "(", "wc", ",", "out", ")", "\n", "}", "\n\n", "for", "{", "select", "{", "// an incoming output line to multiplex", "// TODO(lucab): ordered non-blocking writes", "case", "l", ":=", "<-", "lines", ":", "conns", "=", "filterTargets", "(", "conns", ",", "l", ",", "writeAndFilter", ")", "\n", "logs", "=", "filterTargets", "(", "logs", ",", "l", ",", "logsWriteAndFilter", ")", "\n\n", "// a new remote client", "case", "c", ":=", "<-", "clients", ":", "conns", "=", "append", "(", "conns", ",", "c", ")", "\n\n", "// a new local log target", "case", "t", ":=", "<-", "targets", ":", "logs", "=", "append", "(", "logs", ",", "t", ")", "\n", "}", "\n", "}", "\n", "}" ]
// muxOutput receives remote clients and local log targets, // multiplexing output lines to them
[ "muxOutput", "receives", "remote", "clients", "and", "local", "log", "targets", "multiplexing", "output", "lines", "to", "them" ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage1/iottymux/iottymux.go#L585-L619
train
rkt/rkt
stage1/iottymux/iottymux.go
filterTargets
func filterTargets( wcs []io.WriteCloser, line []byte, filter func(io.WriteCloser, []byte) bool, ) []io.WriteCloser { var filteredTargets []io.WriteCloser for _, c := range wcs { if !filter(c, line) { filteredTargets = append(filteredTargets, c) } } return filteredTargets }
go
func filterTargets( wcs []io.WriteCloser, line []byte, filter func(io.WriteCloser, []byte) bool, ) []io.WriteCloser { var filteredTargets []io.WriteCloser for _, c := range wcs { if !filter(c, line) { filteredTargets = append(filteredTargets, c) } } return filteredTargets }
[ "func", "filterTargets", "(", "wcs", "[", "]", "io", ".", "WriteCloser", ",", "line", "[", "]", "byte", ",", "filter", "func", "(", "io", ".", "WriteCloser", ",", "[", "]", "byte", ")", "bool", ",", ")", "[", "]", "io", ".", "WriteCloser", "{", "var", "filteredTargets", "[", "]", "io", ".", "WriteCloser", "\n\n", "for", "_", ",", "c", ":=", "range", "wcs", "{", "if", "!", "filter", "(", "c", ",", "line", ")", "{", "filteredTargets", "=", "append", "(", "filteredTargets", ",", "c", ")", "\n", "}", "\n", "}", "\n", "return", "filteredTargets", "\n", "}" ]
// filterTargets passes line to each writer in wcs, // filtering out single writers if filter returns true.
[ "filterTargets", "passes", "line", "to", "each", "writer", "in", "wcs", "filtering", "out", "single", "writers", "if", "filter", "returns", "true", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage1/iottymux/iottymux.go#L623-L636
train
rkt/rkt
pkg/keystore/keystore.go
New
func New(config *Config) *Keystore { if config == nil { config = defaultConfig } return &Keystore{config} }
go
func New(config *Config) *Keystore { if config == nil { config = defaultConfig } return &Keystore{config} }
[ "func", "New", "(", "config", "*", "Config", ")", "*", "Keystore", "{", "if", "config", "==", "nil", "{", "config", "=", "defaultConfig", "\n", "}", "\n", "return", "&", "Keystore", "{", "config", "}", "\n", "}" ]
// New returns a new Keystore based on config.
[ "New", "returns", "a", "new", "Keystore", "based", "on", "config", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/keystore/keystore.go#L50-L55
train
rkt/rkt
pkg/keystore/keystore.go
CheckSignature
func CheckSignature(prefix string, signed, signature io.ReadSeeker) (*openpgp.Entity, error) { ks := New(defaultConfig) return checkSignature(ks, prefix, signed, signature) }
go
func CheckSignature(prefix string, signed, signature io.ReadSeeker) (*openpgp.Entity, error) { ks := New(defaultConfig) return checkSignature(ks, prefix, signed, signature) }
[ "func", "CheckSignature", "(", "prefix", "string", ",", "signed", ",", "signature", "io", ".", "ReadSeeker", ")", "(", "*", "openpgp", ".", "Entity", ",", "error", ")", "{", "ks", ":=", "New", "(", "defaultConfig", ")", "\n", "return", "checkSignature", "(", "ks", ",", "prefix", ",", "signed", ",", "signature", ")", "\n", "}" ]
// CheckSignature is a convenience method for creating a Keystore with a default // configuration and invoking CheckSignature.
[ "CheckSignature", "is", "a", "convenience", "method", "for", "creating", "a", "Keystore", "with", "a", "default", "configuration", "and", "invoking", "CheckSignature", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/keystore/keystore.go#L70-L73
train
rkt/rkt
pkg/keystore/keystore.go
DeleteTrustedKeyPrefix
func (ks *Keystore) DeleteTrustedKeyPrefix(prefix, fingerprint string) error { acidentifier, err := types.NewACIdentifier(prefix) if err != nil { return err } return os.Remove(path.Join(ks.LocalPrefixPath, acidentifier.String(), fingerprint)) }
go
func (ks *Keystore) DeleteTrustedKeyPrefix(prefix, fingerprint string) error { acidentifier, err := types.NewACIdentifier(prefix) if err != nil { return err } return os.Remove(path.Join(ks.LocalPrefixPath, acidentifier.String(), fingerprint)) }
[ "func", "(", "ks", "*", "Keystore", ")", "DeleteTrustedKeyPrefix", "(", "prefix", ",", "fingerprint", "string", ")", "error", "{", "acidentifier", ",", "err", ":=", "types", ".", "NewACIdentifier", "(", "prefix", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "os", ".", "Remove", "(", "path", ".", "Join", "(", "ks", ".", "LocalPrefixPath", ",", "acidentifier", ".", "String", "(", ")", ",", "fingerprint", ")", ")", "\n", "}" ]
// DeleteTrustedKeyPrefix deletes the prefix trusted key identified by fingerprint.
[ "DeleteTrustedKeyPrefix", "deletes", "the", "prefix", "trusted", "key", "identified", "by", "fingerprint", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/keystore/keystore.go#L111-L117
train
rkt/rkt
pkg/keystore/keystore.go
MaskTrustedKeySystemPrefix
func (ks *Keystore) MaskTrustedKeySystemPrefix(prefix, fingerprint string) (string, error) { acidentifier, err := types.NewACIdentifier(prefix) if err != nil { return "", err } dst := path.Join(ks.LocalPrefixPath, acidentifier.String(), fingerprint) if err := ioutil.WriteFile(dst, []byte(""), 0644); err != nil { return "", err } if err := os.Chmod(dst, 0644); err != nil { return "", err } return dst, nil }
go
func (ks *Keystore) MaskTrustedKeySystemPrefix(prefix, fingerprint string) (string, error) { acidentifier, err := types.NewACIdentifier(prefix) if err != nil { return "", err } dst := path.Join(ks.LocalPrefixPath, acidentifier.String(), fingerprint) if err := ioutil.WriteFile(dst, []byte(""), 0644); err != nil { return "", err } if err := os.Chmod(dst, 0644); err != nil { return "", err } return dst, nil }
[ "func", "(", "ks", "*", "Keystore", ")", "MaskTrustedKeySystemPrefix", "(", "prefix", ",", "fingerprint", "string", ")", "(", "string", ",", "error", ")", "{", "acidentifier", ",", "err", ":=", "types", ".", "NewACIdentifier", "(", "prefix", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "dst", ":=", "path", ".", "Join", "(", "ks", ".", "LocalPrefixPath", ",", "acidentifier", ".", "String", "(", ")", ",", "fingerprint", ")", "\n", "if", "err", ":=", "ioutil", ".", "WriteFile", "(", "dst", ",", "[", "]", "byte", "(", "\"", "\"", ")", ",", "0644", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "if", "err", ":=", "os", ".", "Chmod", "(", "dst", ",", "0644", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "return", "dst", ",", "nil", "\n", "}" ]
// MaskTrustedKeySystemPrefix masks the system prefix trusted key identified by fingerprint.
[ "MaskTrustedKeySystemPrefix", "masks", "the", "system", "prefix", "trusted", "key", "identified", "by", "fingerprint", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/keystore/keystore.go#L120-L133
train
rkt/rkt
pkg/keystore/keystore.go
DeleteTrustedKeyRoot
func (ks *Keystore) DeleteTrustedKeyRoot(fingerprint string) error { return os.Remove(path.Join(ks.LocalRootPath, fingerprint)) }
go
func (ks *Keystore) DeleteTrustedKeyRoot(fingerprint string) error { return os.Remove(path.Join(ks.LocalRootPath, fingerprint)) }
[ "func", "(", "ks", "*", "Keystore", ")", "DeleteTrustedKeyRoot", "(", "fingerprint", "string", ")", "error", "{", "return", "os", ".", "Remove", "(", "path", ".", "Join", "(", "ks", ".", "LocalRootPath", ",", "fingerprint", ")", ")", "\n", "}" ]
// DeleteTrustedKeyRoot deletes the root trusted key identified by fingerprint.
[ "DeleteTrustedKeyRoot", "deletes", "the", "root", "trusted", "key", "identified", "by", "fingerprint", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/keystore/keystore.go#L136-L138
train
rkt/rkt
pkg/keystore/keystore.go
MaskTrustedKeySystemRoot
func (ks *Keystore) MaskTrustedKeySystemRoot(fingerprint string) (string, error) { dst := path.Join(ks.LocalRootPath, fingerprint) if err := ioutil.WriteFile(dst, []byte(""), 0644); err != nil { return "", err } if err := os.Chmod(dst, 0644); err != nil { return "", err } return dst, nil }
go
func (ks *Keystore) MaskTrustedKeySystemRoot(fingerprint string) (string, error) { dst := path.Join(ks.LocalRootPath, fingerprint) if err := ioutil.WriteFile(dst, []byte(""), 0644); err != nil { return "", err } if err := os.Chmod(dst, 0644); err != nil { return "", err } return dst, nil }
[ "func", "(", "ks", "*", "Keystore", ")", "MaskTrustedKeySystemRoot", "(", "fingerprint", "string", ")", "(", "string", ",", "error", ")", "{", "dst", ":=", "path", ".", "Join", "(", "ks", ".", "LocalRootPath", ",", "fingerprint", ")", "\n", "if", "err", ":=", "ioutil", ".", "WriteFile", "(", "dst", ",", "[", "]", "byte", "(", "\"", "\"", ")", ",", "0644", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "if", "err", ":=", "os", ".", "Chmod", "(", "dst", ",", "0644", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "return", "dst", ",", "nil", "\n", "}" ]
// MaskTrustedKeySystemRoot masks the system root trusted key identified by fingerprint.
[ "MaskTrustedKeySystemRoot", "masks", "the", "system", "root", "trusted", "key", "identified", "by", "fingerprint", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/keystore/keystore.go#L141-L150
train
rkt/rkt
pkg/keystore/keystore.go
TrustedKeyPrefixExists
func (ks *Keystore) TrustedKeyPrefixExists(prefix string) (bool, error) { acidentifier, err := types.NewACIdentifier(prefix) if err != nil { return false, err } pathNamesPrefix := []string{ // example: /etc/rkt/trustedkeys/prefix.d/coreos.com/etcd path.Join(ks.LocalPrefixPath, acidentifier.String()), // example: /usr/lib/rkt/trustedkeys/prefix.d/coreos.com/etcd path.Join(ks.SystemPrefixPath, acidentifier.String()), } for _, p := range pathNamesPrefix { _, err := os.Stat(p) if os.IsNotExist(err) { continue } if err != nil { return false, errwrap.Wrap(fmt.Errorf("cannot check dir %q", p), err) } files, err := ioutil.ReadDir(p) if err != nil { return false, errwrap.Wrap(fmt.Errorf("cannot list files in dir %q", p), err) } for _, f := range files { if !f.IsDir() && f.Size() > 0 { return true, nil } } } parentPrefix, _ := path.Split(prefix) parentPrefix = strings.Trim(parentPrefix, "/") if parentPrefix != "" { return ks.TrustedKeyPrefixExists(parentPrefix) } return false, nil }
go
func (ks *Keystore) TrustedKeyPrefixExists(prefix string) (bool, error) { acidentifier, err := types.NewACIdentifier(prefix) if err != nil { return false, err } pathNamesPrefix := []string{ // example: /etc/rkt/trustedkeys/prefix.d/coreos.com/etcd path.Join(ks.LocalPrefixPath, acidentifier.String()), // example: /usr/lib/rkt/trustedkeys/prefix.d/coreos.com/etcd path.Join(ks.SystemPrefixPath, acidentifier.String()), } for _, p := range pathNamesPrefix { _, err := os.Stat(p) if os.IsNotExist(err) { continue } if err != nil { return false, errwrap.Wrap(fmt.Errorf("cannot check dir %q", p), err) } files, err := ioutil.ReadDir(p) if err != nil { return false, errwrap.Wrap(fmt.Errorf("cannot list files in dir %q", p), err) } for _, f := range files { if !f.IsDir() && f.Size() > 0 { return true, nil } } } parentPrefix, _ := path.Split(prefix) parentPrefix = strings.Trim(parentPrefix, "/") if parentPrefix != "" { return ks.TrustedKeyPrefixExists(parentPrefix) } return false, nil }
[ "func", "(", "ks", "*", "Keystore", ")", "TrustedKeyPrefixExists", "(", "prefix", "string", ")", "(", "bool", ",", "error", ")", "{", "acidentifier", ",", "err", ":=", "types", ".", "NewACIdentifier", "(", "prefix", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n\n", "pathNamesPrefix", ":=", "[", "]", "string", "{", "// example: /etc/rkt/trustedkeys/prefix.d/coreos.com/etcd", "path", ".", "Join", "(", "ks", ".", "LocalPrefixPath", ",", "acidentifier", ".", "String", "(", ")", ")", ",", "// example: /usr/lib/rkt/trustedkeys/prefix.d/coreos.com/etcd", "path", ".", "Join", "(", "ks", ".", "SystemPrefixPath", ",", "acidentifier", ".", "String", "(", ")", ")", ",", "}", "\n\n", "for", "_", ",", "p", ":=", "range", "pathNamesPrefix", "{", "_", ",", "err", ":=", "os", ".", "Stat", "(", "p", ")", "\n", "if", "os", ".", "IsNotExist", "(", "err", ")", "{", "continue", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "errwrap", ".", "Wrap", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "p", ")", ",", "err", ")", "\n", "}", "\n", "files", ",", "err", ":=", "ioutil", ".", "ReadDir", "(", "p", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "errwrap", ".", "Wrap", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "p", ")", ",", "err", ")", "\n", "}", "\n", "for", "_", ",", "f", ":=", "range", "files", "{", "if", "!", "f", ".", "IsDir", "(", ")", "&&", "f", ".", "Size", "(", ")", ">", "0", "{", "return", "true", ",", "nil", "\n", "}", "\n", "}", "\n", "}", "\n\n", "parentPrefix", ",", "_", ":=", "path", ".", "Split", "(", "prefix", ")", "\n", "parentPrefix", "=", "strings", ".", "Trim", "(", "parentPrefix", ",", "\"", "\"", ")", "\n\n", "if", "parentPrefix", "!=", "\"", "\"", "{", "return", "ks", ".", "TrustedKeyPrefixExists", "(", "parentPrefix", ")", "\n", "}", "\n\n", "return", "false", ",", "nil", "\n", "}" ]
// TrustKeyPrefixExists returns whether or not there exists 1 or more trusted // keys for a given prefix, or for any parent prefix.
[ "TrustKeyPrefixExists", "returns", "whether", "or", "not", "there", "exists", "1", "or", "more", "trusted", "keys", "for", "a", "given", "prefix", "or", "for", "any", "parent", "prefix", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/keystore/keystore.go#L154-L194
train
rkt/rkt
pkg/keystore/keystore.go
TrustedKeyPrefixWithFingerprintExists
func (ks *Keystore) TrustedKeyPrefixWithFingerprintExists(prefix string, r io.ReadSeeker) (bool, error) { defer r.Seek(0, os.SEEK_SET) entityList, err := openpgp.ReadArmoredKeyRing(r) if err != nil { return false, err } if len(entityList) < 1 { return false, errors.New("missing opengpg entity") } pubKey := entityList[0].PrimaryKey fileName := fingerprintToFilename(pubKey.Fingerprint) pathNamesRoot := []string{ // example: /etc/rkt/trustedkeys/root.d/8b86de38890ddb7291867b025210bd8888182190 path.Join(ks.LocalRootPath, fileName), // example: /usr/lib/rkt/trustedkeys/root.d/8b86de38890ddb7291867b025210bd8888182190 path.Join(ks.SystemRootPath, fileName), } var pathNamesPrefix []string if prefix != "" { acidentifier, err := types.NewACIdentifier(prefix) if err != nil { return false, err } pathNamesPrefix = []string{ // example: /etc/rkt/trustedkeys/prefix.d/coreos.com/etcd/8b86de38890ddb7291867b025210bd8888182190 path.Join(ks.LocalPrefixPath, acidentifier.String(), fileName), // example: /usr/lib/rkt/trustedkeys/prefix.d/coreos.com/etcd/8b86de38890ddb7291867b025210bd8888182190 path.Join(ks.SystemPrefixPath, acidentifier.String(), fileName), } } pathNames := append(pathNamesRoot, pathNamesPrefix...) for _, p := range pathNames { _, err := os.Stat(p) if err == nil { return true, nil } else if !os.IsNotExist(err) { return false, errwrap.Wrap(fmt.Errorf("cannot check file %q", p), err) } } return false, nil }
go
func (ks *Keystore) TrustedKeyPrefixWithFingerprintExists(prefix string, r io.ReadSeeker) (bool, error) { defer r.Seek(0, os.SEEK_SET) entityList, err := openpgp.ReadArmoredKeyRing(r) if err != nil { return false, err } if len(entityList) < 1 { return false, errors.New("missing opengpg entity") } pubKey := entityList[0].PrimaryKey fileName := fingerprintToFilename(pubKey.Fingerprint) pathNamesRoot := []string{ // example: /etc/rkt/trustedkeys/root.d/8b86de38890ddb7291867b025210bd8888182190 path.Join(ks.LocalRootPath, fileName), // example: /usr/lib/rkt/trustedkeys/root.d/8b86de38890ddb7291867b025210bd8888182190 path.Join(ks.SystemRootPath, fileName), } var pathNamesPrefix []string if prefix != "" { acidentifier, err := types.NewACIdentifier(prefix) if err != nil { return false, err } pathNamesPrefix = []string{ // example: /etc/rkt/trustedkeys/prefix.d/coreos.com/etcd/8b86de38890ddb7291867b025210bd8888182190 path.Join(ks.LocalPrefixPath, acidentifier.String(), fileName), // example: /usr/lib/rkt/trustedkeys/prefix.d/coreos.com/etcd/8b86de38890ddb7291867b025210bd8888182190 path.Join(ks.SystemPrefixPath, acidentifier.String(), fileName), } } pathNames := append(pathNamesRoot, pathNamesPrefix...) for _, p := range pathNames { _, err := os.Stat(p) if err == nil { return true, nil } else if !os.IsNotExist(err) { return false, errwrap.Wrap(fmt.Errorf("cannot check file %q", p), err) } } return false, nil }
[ "func", "(", "ks", "*", "Keystore", ")", "TrustedKeyPrefixWithFingerprintExists", "(", "prefix", "string", ",", "r", "io", ".", "ReadSeeker", ")", "(", "bool", ",", "error", ")", "{", "defer", "r", ".", "Seek", "(", "0", ",", "os", ".", "SEEK_SET", ")", "\n\n", "entityList", ",", "err", ":=", "openpgp", ".", "ReadArmoredKeyRing", "(", "r", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "if", "len", "(", "entityList", ")", "<", "1", "{", "return", "false", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "pubKey", ":=", "entityList", "[", "0", "]", ".", "PrimaryKey", "\n", "fileName", ":=", "fingerprintToFilename", "(", "pubKey", ".", "Fingerprint", ")", "\n\n", "pathNamesRoot", ":=", "[", "]", "string", "{", "// example: /etc/rkt/trustedkeys/root.d/8b86de38890ddb7291867b025210bd8888182190", "path", ".", "Join", "(", "ks", ".", "LocalRootPath", ",", "fileName", ")", ",", "// example: /usr/lib/rkt/trustedkeys/root.d/8b86de38890ddb7291867b025210bd8888182190", "path", ".", "Join", "(", "ks", ".", "SystemRootPath", ",", "fileName", ")", ",", "}", "\n\n", "var", "pathNamesPrefix", "[", "]", "string", "\n", "if", "prefix", "!=", "\"", "\"", "{", "acidentifier", ",", "err", ":=", "types", ".", "NewACIdentifier", "(", "prefix", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "pathNamesPrefix", "=", "[", "]", "string", "{", "// example: /etc/rkt/trustedkeys/prefix.d/coreos.com/etcd/8b86de38890ddb7291867b025210bd8888182190", "path", ".", "Join", "(", "ks", ".", "LocalPrefixPath", ",", "acidentifier", ".", "String", "(", ")", ",", "fileName", ")", ",", "// example: /usr/lib/rkt/trustedkeys/prefix.d/coreos.com/etcd/8b86de38890ddb7291867b025210bd8888182190", "path", ".", "Join", "(", "ks", ".", "SystemPrefixPath", ",", "acidentifier", ".", "String", "(", ")", ",", "fileName", ")", ",", "}", "\n", "}", "\n\n", "pathNames", ":=", "append", "(", "pathNamesRoot", ",", "pathNamesPrefix", "...", ")", "\n", "for", "_", ",", "p", ":=", "range", "pathNames", "{", "_", ",", "err", ":=", "os", ".", "Stat", "(", "p", ")", "\n", "if", "err", "==", "nil", "{", "return", "true", ",", "nil", "\n", "}", "else", "if", "!", "os", ".", "IsNotExist", "(", "err", ")", "{", "return", "false", ",", "errwrap", ".", "Wrap", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "p", ")", ",", "err", ")", "\n", "}", "\n", "}", "\n\n", "return", "false", ",", "nil", "\n", "}" ]
// TrustedKeyPrefixWithFingerprintExists returns whether or not a trusted key with the fingerprint of the key accessible through r exists for the given prefix.
[ "TrustedKeyPrefixWithFingerprintExists", "returns", "whether", "or", "not", "a", "trusted", "key", "with", "the", "fingerprint", "of", "the", "key", "accessible", "through", "r", "exists", "for", "the", "given", "prefix", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/keystore/keystore.go#L197-L242
train
rkt/rkt
pkg/keystore/keystore.go
StoreTrustedKeyPrefix
func (ks *Keystore) StoreTrustedKeyPrefix(prefix string, r io.Reader) (string, error) { acidentifier, err := types.NewACIdentifier(prefix) if err != nil { return "", err } return storeTrustedKey(path.Join(ks.LocalPrefixPath, acidentifier.String()), r) }
go
func (ks *Keystore) StoreTrustedKeyPrefix(prefix string, r io.Reader) (string, error) { acidentifier, err := types.NewACIdentifier(prefix) if err != nil { return "", err } return storeTrustedKey(path.Join(ks.LocalPrefixPath, acidentifier.String()), r) }
[ "func", "(", "ks", "*", "Keystore", ")", "StoreTrustedKeyPrefix", "(", "prefix", "string", ",", "r", "io", ".", "Reader", ")", "(", "string", ",", "error", ")", "{", "acidentifier", ",", "err", ":=", "types", ".", "NewACIdentifier", "(", "prefix", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "return", "storeTrustedKey", "(", "path", ".", "Join", "(", "ks", ".", "LocalPrefixPath", ",", "acidentifier", ".", "String", "(", ")", ")", ",", "r", ")", "\n", "}" ]
// StoreTrustedKeyPrefix stores the contents of public key r as a prefix trusted key.
[ "StoreTrustedKeyPrefix", "stores", "the", "contents", "of", "public", "key", "r", "as", "a", "prefix", "trusted", "key", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/keystore/keystore.go#L245-L251
train
rkt/rkt
pkg/keystore/keystore.go
StoreTrustedKeyRoot
func (ks *Keystore) StoreTrustedKeyRoot(r io.Reader) (string, error) { return storeTrustedKey(ks.LocalRootPath, r) }
go
func (ks *Keystore) StoreTrustedKeyRoot(r io.Reader) (string, error) { return storeTrustedKey(ks.LocalRootPath, r) }
[ "func", "(", "ks", "*", "Keystore", ")", "StoreTrustedKeyRoot", "(", "r", "io", ".", "Reader", ")", "(", "string", ",", "error", ")", "{", "return", "storeTrustedKey", "(", "ks", ".", "LocalRootPath", ",", "r", ")", "\n", "}" ]
// StoreTrustedKeyRoot stores the contents of public key r as a root trusted key.
[ "StoreTrustedKeyRoot", "stores", "the", "contents", "of", "public", "key", "r", "as", "a", "root", "trusted", "key", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/keystore/keystore.go#L254-L256
train
rkt/rkt
pkg/set/string.go
ConditionalHas
func (s String) ConditionalHas(conditionFunc func(source, item string) bool, item string) bool { for source := range s { if conditionFunc(source, item) { return true } } return false }
go
func (s String) ConditionalHas(conditionFunc func(source, item string) bool, item string) bool { for source := range s { if conditionFunc(source, item) { return true } } return false }
[ "func", "(", "s", "String", ")", "ConditionalHas", "(", "conditionFunc", "func", "(", "source", ",", "item", "string", ")", "bool", ",", "item", "string", ")", "bool", "{", "for", "source", ":=", "range", "s", "{", "if", "conditionFunc", "(", "source", ",", "item", ")", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]
// ConditionalHas returns true if and only if there is any item 'source' // in the set that satisfies the conditionFunc wrt 'item'.
[ "ConditionalHas", "returns", "true", "if", "and", "only", "if", "there", "is", "any", "item", "source", "in", "the", "set", "that", "satisfies", "the", "conditionFunc", "wrt", "item", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/set/string.go#L60-L67
train
rkt/rkt
stage1/init/common/path.go
RelEnvFilePath
func RelEnvFilePath(appName types.ACName) string { return filepath.Join(envDir, appName.String()) }
go
func RelEnvFilePath(appName types.ACName) string { return filepath.Join(envDir, appName.String()) }
[ "func", "RelEnvFilePath", "(", "appName", "types", ".", "ACName", ")", "string", "{", "return", "filepath", ".", "Join", "(", "envDir", ",", "appName", ".", "String", "(", ")", ")", "\n", "}" ]
// RelEnvFilePath returns the path to the environment file for the given // app name relative to the pod's root.
[ "RelEnvFilePath", "returns", "the", "path", "to", "the", "environment", "file", "for", "the", "given", "app", "name", "relative", "to", "the", "pod", "s", "root", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage1/init/common/path.go#L56-L58
train
rkt/rkt
stage1/init/common/path.go
EnvFilePath
func EnvFilePath(root string, appName types.ACName) string { return filepath.Join(common.Stage1RootfsPath(root), RelEnvFilePath(appName)) }
go
func EnvFilePath(root string, appName types.ACName) string { return filepath.Join(common.Stage1RootfsPath(root), RelEnvFilePath(appName)) }
[ "func", "EnvFilePath", "(", "root", "string", ",", "appName", "types", ".", "ACName", ")", "string", "{", "return", "filepath", ".", "Join", "(", "common", ".", "Stage1RootfsPath", "(", "root", ")", ",", "RelEnvFilePath", "(", "appName", ")", ")", "\n", "}" ]
// EnvFilePath returns the path to the environment file for the given app name.
[ "EnvFilePath", "returns", "the", "path", "to", "the", "environment", "file", "for", "the", "given", "app", "name", "." ]
0c8765619cae3391a9ffa12c8dbd12ba7a475eb8
https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage1/init/common/path.go#L61-L63
train