id int32 0 167k | 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 listlengths 21 1.41k | docstring stringlengths 6 2.61k | docstring_tokens listlengths 3 215 | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
21,000 | rkt/rkt | rkt/gc.go | renameExpired | func renameExpired(preparedExpiration time.Duration) error {
if err := pkgPod.WalkPods(getDataDir(), pkgPod.IncludePreparedDir, func(p *pkgPod.Pod) {
st := &syscall.Stat_t{}
pp := p.Path()
if err := syscall.Lstat(pp, st); err != nil {
if err != syscall.ENOENT {
stderr.PrintE(fmt.Sprintf("unable to stat %q... | go | func renameExpired(preparedExpiration time.Duration) error {
if err := pkgPod.WalkPods(getDataDir(), pkgPod.IncludePreparedDir, func(p *pkgPod.Pod) {
st := &syscall.Stat_t{}
pp := p.Path()
if err := syscall.Lstat(pp, st); err != nil {
if err != syscall.ENOENT {
stderr.PrintE(fmt.Sprintf("unable to stat %q... | [
"func",
"renameExpired",
"(",
"preparedExpiration",
"time",
".",
"Duration",
")",
"error",
"{",
"if",
"err",
":=",
"pkgPod",
".",
"WalkPods",
"(",
"getDataDir",
"(",
")",
",",
"pkgPod",
".",
"IncludePreparedDir",
",",
"func",
"(",
"p",
"*",
"pkgPod",
".",
... | // renameExpired renames expired prepared pods to the garbage directory | [
"renameExpired",
"renames",
"expired",
"prepared",
"pods",
"to",
"the",
"garbage",
"directory"
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/rkt/gc.go#L162-L183 |
21,001 | rkt/rkt | rkt/gc.go | deletePod | func deletePod(p *pkgPod.Pod) bool {
podState := p.State()
if podState != pkgPod.ExitedGarbage && podState != pkgPod.Garbage && podState != pkgPod.ExitedDeleting {
stderr.Errorf("non-garbage pod %q (status %q), skipped", p.UUID, p.State())
return false
}
if podState == pkgPod.ExitedGarbage {
s, err := images... | go | func deletePod(p *pkgPod.Pod) bool {
podState := p.State()
if podState != pkgPod.ExitedGarbage && podState != pkgPod.Garbage && podState != pkgPod.ExitedDeleting {
stderr.Errorf("non-garbage pod %q (status %q), skipped", p.UUID, p.State())
return false
}
if podState == pkgPod.ExitedGarbage {
s, err := images... | [
"func",
"deletePod",
"(",
"p",
"*",
"pkgPod",
".",
"Pod",
")",
"bool",
"{",
"podState",
":=",
"p",
".",
"State",
"(",
")",
"\n",
"if",
"podState",
"!=",
"pkgPod",
".",
"ExitedGarbage",
"&&",
"podState",
"!=",
"pkgPod",
".",
"Garbage",
"&&",
"podState",... | // deletePod cleans up files and resource associated with the pod
// pod must be under exclusive lock and be in either ExitedGarbage
// or Garbage state | [
"deletePod",
"cleans",
"up",
"files",
"and",
"resource",
"associated",
"with",
"the",
"pod",
"pod",
"must",
"be",
"under",
"exclusive",
"lock",
"and",
"be",
"in",
"either",
"ExitedGarbage",
"or",
"Garbage",
"state"
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/rkt/gc.go#L251-L316 |
21,002 | rkt/rkt | store/imagestore/store.go | backupDB | func (s *Store) backupDB() error {
if os.Geteuid() != 0 {
return ErrDBUpdateNeedsRoot
}
backupsDir := filepath.Join(s.dir, "db-backups")
return backup.CreateBackup(s.dbDir(), backupsDir, backupsNumber)
} | go | func (s *Store) backupDB() error {
if os.Geteuid() != 0 {
return ErrDBUpdateNeedsRoot
}
backupsDir := filepath.Join(s.dir, "db-backups")
return backup.CreateBackup(s.dbDir(), backupsDir, backupsNumber)
} | [
"func",
"(",
"s",
"*",
"Store",
")",
"backupDB",
"(",
")",
"error",
"{",
"if",
"os",
".",
"Geteuid",
"(",
")",
"!=",
"0",
"{",
"return",
"ErrDBUpdateNeedsRoot",
"\n",
"}",
"\n",
"backupsDir",
":=",
"filepath",
".",
"Join",
"(",
"s",
".",
"dir",
","... | // backupDB backs up current database. | [
"backupDB",
"backs",
"up",
"current",
"database",
"."
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/store/imagestore/store.go#L283-L289 |
21,003 | rkt/rkt | store/imagestore/store.go | ResolveName | func (s *Store) ResolveName(name string) ([]string, bool, error) {
var (
aciInfos []*ACIInfo
found bool
)
err := s.db.Do(func(tx *sql.Tx) error {
var err error
aciInfos, found, err = GetACIInfosWithName(tx, name)
return err
})
if err != nil {
return nil, found, errwrap.Wrap(errors.New("error retriev... | go | func (s *Store) ResolveName(name string) ([]string, bool, error) {
var (
aciInfos []*ACIInfo
found bool
)
err := s.db.Do(func(tx *sql.Tx) error {
var err error
aciInfos, found, err = GetACIInfosWithName(tx, name)
return err
})
if err != nil {
return nil, found, errwrap.Wrap(errors.New("error retriev... | [
"func",
"(",
"s",
"*",
"Store",
")",
"ResolveName",
"(",
"name",
"string",
")",
"(",
"[",
"]",
"string",
",",
"bool",
",",
"error",
")",
"{",
"var",
"(",
"aciInfos",
"[",
"]",
"*",
"ACIInfo",
"\n",
"found",
"bool",
"\n",
")",
"\n",
"err",
":=",
... | // ResolveName resolves an image name to a list of full keys and using the
// store for resolution. | [
"ResolveName",
"resolves",
"an",
"image",
"name",
"to",
"a",
"list",
"of",
"full",
"keys",
"and",
"using",
"the",
"store",
"for",
"resolution",
"."
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/store/imagestore/store.go#L374-L394 |
21,004 | rkt/rkt | store/imagestore/store.go | RemoveACI | func (s *Store) RemoveACI(key string) error {
imageKeyLock, err := lock.ExclusiveKeyLock(s.imageLockDir, key)
if err != nil {
return errwrap.Wrap(errors.New("error locking image"), err)
}
defer imageKeyLock.Close()
// Firstly remove aciinfo and remote from the db in an unique transaction.
// remote needs to be... | go | func (s *Store) RemoveACI(key string) error {
imageKeyLock, err := lock.ExclusiveKeyLock(s.imageLockDir, key)
if err != nil {
return errwrap.Wrap(errors.New("error locking image"), err)
}
defer imageKeyLock.Close()
// Firstly remove aciinfo and remote from the db in an unique transaction.
// remote needs to be... | [
"func",
"(",
"s",
"*",
"Store",
")",
"RemoveACI",
"(",
"key",
"string",
")",
"error",
"{",
"imageKeyLock",
",",
"err",
":=",
"lock",
".",
"ExclusiveKeyLock",
"(",
"s",
".",
"imageLockDir",
",",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return... | // RemoveACI removes the ACI with the given key. It firstly removes the aci
// infos inside the db, then it tries to remove the non transactional data.
// If some error occurs removing some non transactional data a
// StoreRemovalError is returned. | [
"RemoveACI",
"removes",
"the",
"ACI",
"with",
"the",
"given",
"key",
".",
"It",
"firstly",
"removes",
"the",
"aci",
"infos",
"inside",
"the",
"db",
"then",
"it",
"tries",
"to",
"remove",
"the",
"non",
"transactional",
"data",
".",
"If",
"some",
"error",
... | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/store/imagestore/store.go#L506-L551 |
21,005 | rkt/rkt | store/imagestore/store.go | GetRemote | func (s *Store) GetRemote(aciURL string) (*Remote, error) {
var remote *Remote
err := s.db.Do(func(tx *sql.Tx) error {
var err error
remote, err = GetRemote(tx, aciURL)
return err
})
if err != nil {
return nil, err
}
return remote, nil
} | go | func (s *Store) GetRemote(aciURL string) (*Remote, error) {
var remote *Remote
err := s.db.Do(func(tx *sql.Tx) error {
var err error
remote, err = GetRemote(tx, aciURL)
return err
})
if err != nil {
return nil, err
}
return remote, nil
} | [
"func",
"(",
"s",
"*",
"Store",
")",
"GetRemote",
"(",
"aciURL",
"string",
")",
"(",
"*",
"Remote",
",",
"error",
")",
"{",
"var",
"remote",
"*",
"Remote",
"\n\n",
"err",
":=",
"s",
".",
"db",
".",
"Do",
"(",
"func",
"(",
"tx",
"*",
"sql",
".",... | // 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/store.go#L555-L570 |
21,006 | rkt/rkt | store/imagestore/store.go | GetImageManifestJSON | func (s *Store) GetImageManifestJSON(key string) ([]byte, error) {
key, err := s.ResolveKey(key)
if err != nil {
return nil, errwrap.Wrap(errors.New("error resolving image ID"), err)
}
keyLock, err := lock.SharedKeyLock(s.imageLockDir, key)
if err != nil {
return nil, errwrap.Wrap(errors.New("error locking ima... | go | func (s *Store) GetImageManifestJSON(key string) ([]byte, error) {
key, err := s.ResolveKey(key)
if err != nil {
return nil, errwrap.Wrap(errors.New("error resolving image ID"), err)
}
keyLock, err := lock.SharedKeyLock(s.imageLockDir, key)
if err != nil {
return nil, errwrap.Wrap(errors.New("error locking ima... | [
"func",
"(",
"s",
"*",
"Store",
")",
"GetImageManifestJSON",
"(",
"key",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"key",
",",
"err",
":=",
"s",
".",
"ResolveKey",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return"... | // GetImageManifestJSON gets the ImageManifest JSON bytes with the
// specified key. | [
"GetImageManifestJSON",
"gets",
"the",
"ImageManifest",
"JSON",
"bytes",
"with",
"the",
"specified",
"key",
"."
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/store/imagestore/store.go#L582-L598 |
21,007 | rkt/rkt | store/imagestore/store.go | GetImageManifest | func (s *Store) GetImageManifest(key string) (*schema.ImageManifest, error) {
imj, err := s.GetImageManifestJSON(key)
if err != nil {
return nil, err
}
var im *schema.ImageManifest
if err = json.Unmarshal(imj, &im); err != nil {
return nil, errwrap.Wrap(errors.New("error unmarshalling image manifest"), err)
}... | go | func (s *Store) GetImageManifest(key string) (*schema.ImageManifest, error) {
imj, err := s.GetImageManifestJSON(key)
if err != nil {
return nil, err
}
var im *schema.ImageManifest
if err = json.Unmarshal(imj, &im); err != nil {
return nil, errwrap.Wrap(errors.New("error unmarshalling image manifest"), err)
}... | [
"func",
"(",
"s",
"*",
"Store",
")",
"GetImageManifest",
"(",
"key",
"string",
")",
"(",
"*",
"schema",
".",
"ImageManifest",
",",
"error",
")",
"{",
"imj",
",",
"err",
":=",
"s",
".",
"GetImageManifestJSON",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",... | // GetImageManifest gets the ImageManifest with the specified key. | [
"GetImageManifest",
"gets",
"the",
"ImageManifest",
"with",
"the",
"specified",
"key",
"."
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/store/imagestore/store.go#L601-L611 |
21,008 | rkt/rkt | store/imagestore/store.go | HasFullKey | func (s *Store) HasFullKey(key string) bool {
return s.stores[imageManifestType].Has(key)
} | go | func (s *Store) HasFullKey(key string) bool {
return s.stores[imageManifestType].Has(key)
} | [
"func",
"(",
"s",
"*",
"Store",
")",
"HasFullKey",
"(",
"key",
"string",
")",
"bool",
"{",
"return",
"s",
".",
"stores",
"[",
"imageManifestType",
"]",
".",
"Has",
"(",
"key",
")",
"\n",
"}"
] | // HasFullKey returns whether the image with the given key exists on the disk by
// checking if the image manifest kv store contains the key. | [
"HasFullKey",
"returns",
"whether",
"the",
"image",
"with",
"the",
"given",
"key",
"exists",
"on",
"the",
"disk",
"by",
"checking",
"if",
"the",
"image",
"manifest",
"kv",
"store",
"contains",
"the",
"key",
"."
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/store/imagestore/store.go#L756-L758 |
21,009 | rkt/rkt | store/imagestore/store.go | keyToString | func keyToString(k []byte) string {
if len(k) != lenHash {
panic(fmt.Sprintf("bad hash passed to hashToKey: %x", k))
}
return fmt.Sprintf("%s%x", hashPrefix, k)[0:lenKey]
} | go | func keyToString(k []byte) string {
if len(k) != lenHash {
panic(fmt.Sprintf("bad hash passed to hashToKey: %x", k))
}
return fmt.Sprintf("%s%x", hashPrefix, k)[0:lenKey]
} | [
"func",
"keyToString",
"(",
"k",
"[",
"]",
"byte",
")",
"string",
"{",
"if",
"len",
"(",
"k",
")",
"!=",
"lenHash",
"{",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"k",
")",
")",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Sprintf",... | // keyToString takes a key and returns a shortened and prefixed hexadecimal string version | [
"keyToString",
"takes",
"a",
"key",
"and",
"returns",
"a",
"shortened",
"and",
"prefixed",
"hexadecimal",
"string",
"version"
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/store/imagestore/store.go#L766-L771 |
21,010 | rkt/rkt | rkt/image/downloader.go | Download | func (d *downloader) Download(u *url.URL, out writeSyncer) error {
client, err := d.Session.Client()
if err != nil {
return err
}
req, err := d.Session.Request(u)
if err != nil {
return err
}
res, err := client.Do(req)
if err != nil {
return err
}
defer res.Body.Close()
if stopNow, err := d.Session.Ha... | go | func (d *downloader) Download(u *url.URL, out writeSyncer) error {
client, err := d.Session.Client()
if err != nil {
return err
}
req, err := d.Session.Request(u)
if err != nil {
return err
}
res, err := client.Do(req)
if err != nil {
return err
}
defer res.Body.Close()
if stopNow, err := d.Session.Ha... | [
"func",
"(",
"d",
"*",
"downloader",
")",
"Download",
"(",
"u",
"*",
"url",
".",
"URL",
",",
"out",
"writeSyncer",
")",
"error",
"{",
"client",
",",
"err",
":=",
"d",
".",
"Session",
".",
"Client",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
... | // Download tries to fetch the passed URL and write the contents into
// a given writeSyncer instance. | [
"Download",
"tries",
"to",
"fetch",
"the",
"passed",
"URL",
"and",
"write",
"the",
"contents",
"into",
"a",
"given",
"writeSyncer",
"instance",
"."
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/rkt/image/downloader.go#L54-L86 |
21,011 | rkt/rkt | rkt/enter.go | getAppName | func getAppName(p *pkgPod.Pod) (*types.ACName, error) {
if flagAppName != "" {
return types.NewACName(flagAppName)
}
// figure out the app name, or show a list if multiple are present
_, m, err := p.PodManifest()
if err != nil {
return nil, errwrap.Wrap(errors.New("error reading pod manifest"), err)
}
swit... | go | func getAppName(p *pkgPod.Pod) (*types.ACName, error) {
if flagAppName != "" {
return types.NewACName(flagAppName)
}
// figure out the app name, or show a list if multiple are present
_, m, err := p.PodManifest()
if err != nil {
return nil, errwrap.Wrap(errors.New("error reading pod manifest"), err)
}
swit... | [
"func",
"getAppName",
"(",
"p",
"*",
"pkgPod",
".",
"Pod",
")",
"(",
"*",
"types",
".",
"ACName",
",",
"error",
")",
"{",
"if",
"flagAppName",
"!=",
"\"",
"\"",
"{",
"return",
"types",
".",
"NewACName",
"(",
"flagAppName",
")",
"\n",
"}",
"\n\n",
"... | // getAppName returns the app name to enter
// If one was supplied in the flags then it's simply returned
// If the PM contains a single app, that app's name is returned
// If the PM has multiple apps, the names are printed and an error is returned | [
"getAppName",
"returns",
"the",
"app",
"name",
"to",
"enter",
"If",
"one",
"was",
"supplied",
"in",
"the",
"flags",
"then",
"it",
"s",
"simply",
"returned",
"If",
"the",
"PM",
"contains",
"a",
"single",
"app",
"that",
"app",
"s",
"name",
"is",
"returned"... | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/rkt/enter.go#L128-L153 |
21,012 | rkt/rkt | rkt/enter.go | getEnterArgv | func getEnterArgv(p *pkgPod.Pod, cmdArgs []string) ([]string, error) {
var argv []string
if len(cmdArgs) < 2 {
stderr.Printf("no command specified, assuming %q", defaultCmd)
argv = []string{defaultCmd}
} else {
argv = cmdArgs[1:]
}
return argv, nil
} | go | func getEnterArgv(p *pkgPod.Pod, cmdArgs []string) ([]string, error) {
var argv []string
if len(cmdArgs) < 2 {
stderr.Printf("no command specified, assuming %q", defaultCmd)
argv = []string{defaultCmd}
} else {
argv = cmdArgs[1:]
}
return argv, nil
} | [
"func",
"getEnterArgv",
"(",
"p",
"*",
"pkgPod",
".",
"Pod",
",",
"cmdArgs",
"[",
"]",
"string",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"var",
"argv",
"[",
"]",
"string",
"\n",
"if",
"len",
"(",
"cmdArgs",
")",
"<",
"2",
"{",
"st... | // getEnterArgv returns the argv to use for entering the pod | [
"getEnterArgv",
"returns",
"the",
"argv",
"to",
"use",
"for",
"entering",
"the",
"pod"
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/rkt/enter.go#L156-L166 |
21,013 | rkt/rkt | common/cgroup/v1/cgroup.go | mountFsRO | func mountFsRO(m fs.Mounter, mountPoint string, flags uintptr) error {
flags = flags |
syscall.MS_BIND |
syscall.MS_REMOUNT |
syscall.MS_RDONLY
if err := m.Mount(mountPoint, mountPoint, "", flags, ""); err != nil {
return errwrap.Wrap(fmt.Errorf("error remounting read-only %q", mountPoint), err)
}
return ... | go | func mountFsRO(m fs.Mounter, mountPoint string, flags uintptr) error {
flags = flags |
syscall.MS_BIND |
syscall.MS_REMOUNT |
syscall.MS_RDONLY
if err := m.Mount(mountPoint, mountPoint, "", flags, ""); err != nil {
return errwrap.Wrap(fmt.Errorf("error remounting read-only %q", mountPoint), err)
}
return ... | [
"func",
"mountFsRO",
"(",
"m",
"fs",
".",
"Mounter",
",",
"mountPoint",
"string",
",",
"flags",
"uintptr",
")",
"error",
"{",
"flags",
"=",
"flags",
"|",
"syscall",
".",
"MS_BIND",
"|",
"syscall",
".",
"MS_REMOUNT",
"|",
"syscall",
".",
"MS_RDONLY",
"\n\... | // mountFsRO remounts the given mountPoint using the given flags read-only. | [
"mountFsRO",
"remounts",
"the",
"given",
"mountPoint",
"using",
"the",
"given",
"flags",
"read",
"-",
"only",
"."
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/common/cgroup/v1/cgroup.go#L36-L47 |
21,014 | rkt/rkt | common/cgroup/v1/cgroup.go | GetEnabledCgroups | func GetEnabledCgroups() (map[int][]string, error) {
cgroupsFile, err := os.Open("/proc/cgroups")
if err != nil {
return nil, err
}
defer cgroupsFile.Close()
cgroups, err := parseCgroups(cgroupsFile)
if err != nil {
return nil, errwrap.Wrap(errors.New("error parsing /proc/cgroups"), err)
}
return cgroups,... | go | func GetEnabledCgroups() (map[int][]string, error) {
cgroupsFile, err := os.Open("/proc/cgroups")
if err != nil {
return nil, err
}
defer cgroupsFile.Close()
cgroups, err := parseCgroups(cgroupsFile)
if err != nil {
return nil, errwrap.Wrap(errors.New("error parsing /proc/cgroups"), err)
}
return cgroups,... | [
"func",
"GetEnabledCgroups",
"(",
")",
"(",
"map",
"[",
"int",
"]",
"[",
"]",
"string",
",",
"error",
")",
"{",
"cgroupsFile",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
... | // GetEnabledCgroups returns a map with the enabled cgroup controllers grouped by
// hierarchy | [
"GetEnabledCgroups",
"returns",
"a",
"map",
"with",
"the",
"enabled",
"cgroup",
"controllers",
"grouped",
"by",
"hierarchy"
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/common/cgroup/v1/cgroup.go#L81-L94 |
21,015 | rkt/rkt | common/cgroup/v1/cgroup.go | GetOwnCgroupPath | func GetOwnCgroupPath(controller string) (string, error) {
parts, err := parseCgroupController("/proc/self/cgroup", controller)
if err != nil {
return "", err
}
return parts[2], nil
} | go | func GetOwnCgroupPath(controller string) (string, error) {
parts, err := parseCgroupController("/proc/self/cgroup", controller)
if err != nil {
return "", err
}
return parts[2], nil
} | [
"func",
"GetOwnCgroupPath",
"(",
"controller",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"parts",
",",
"err",
":=",
"parseCgroupController",
"(",
"\"",
"\"",
",",
"controller",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
... | // GetOwnCgroupPath returns the cgroup path of this process in controller
// hierarchy | [
"GetOwnCgroupPath",
"returns",
"the",
"cgroup",
"path",
"of",
"this",
"process",
"in",
"controller",
"hierarchy"
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/common/cgroup/v1/cgroup.go#L149-L155 |
21,016 | rkt/rkt | common/cgroup/v1/cgroup.go | GetCgroupPathByPid | func GetCgroupPathByPid(pid int, controller string) (string, error) {
parts, err := parseCgroupController(fmt.Sprintf("/proc/%d/cgroup", pid), controller)
if err != nil {
return "", err
}
return parts[2], nil
} | go | func GetCgroupPathByPid(pid int, controller string) (string, error) {
parts, err := parseCgroupController(fmt.Sprintf("/proc/%d/cgroup", pid), controller)
if err != nil {
return "", err
}
return parts[2], nil
} | [
"func",
"GetCgroupPathByPid",
"(",
"pid",
"int",
",",
"controller",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"parts",
",",
"err",
":=",
"parseCgroupController",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"pid",
")",
",",
"controller",... | // GetCgroupPathByPid returns the cgroup path of the process with the given pid
// and given controller. | [
"GetCgroupPathByPid",
"returns",
"the",
"cgroup",
"path",
"of",
"the",
"process",
"with",
"the",
"given",
"pid",
"and",
"given",
"controller",
"."
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/common/cgroup/v1/cgroup.go#L159-L165 |
21,017 | rkt/rkt | common/cgroup/v1/cgroup.go | JoinSubcgroup | func JoinSubcgroup(controller string, subcgroup string) error {
subcgroupPath := filepath.Join("/sys/fs/cgroup", controller, subcgroup)
if err := os.MkdirAll(subcgroupPath, 0600); err != nil {
return errwrap.Wrap(fmt.Errorf("error creating %q subcgroup", subcgroup), err)
}
pidBytes := []byte(strconv.Itoa(os.Getpi... | go | func JoinSubcgroup(controller string, subcgroup string) error {
subcgroupPath := filepath.Join("/sys/fs/cgroup", controller, subcgroup)
if err := os.MkdirAll(subcgroupPath, 0600); err != nil {
return errwrap.Wrap(fmt.Errorf("error creating %q subcgroup", subcgroup), err)
}
pidBytes := []byte(strconv.Itoa(os.Getpi... | [
"func",
"JoinSubcgroup",
"(",
"controller",
"string",
",",
"subcgroup",
"string",
")",
"error",
"{",
"subcgroupPath",
":=",
"filepath",
".",
"Join",
"(",
"\"",
"\"",
",",
"controller",
",",
"subcgroup",
")",
"\n",
"if",
"err",
":=",
"os",
".",
"MkdirAll",
... | // JoinSubcgroup makes the calling process join the subcgroup hierarchy on a
// particular controller | [
"JoinSubcgroup",
"makes",
"the",
"calling",
"process",
"join",
"the",
"subcgroup",
"hierarchy",
"on",
"a",
"particular",
"controller"
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/common/cgroup/v1/cgroup.go#L169-L180 |
21,018 | rkt/rkt | common/cgroup/v1/cgroup.go | IsControllerMounted | func IsControllerMounted(c string) (bool, error) {
cgroupProcsPath := filepath.Join("/sys/fs/cgroup", c, "cgroup.procs")
if _, err := os.Stat(cgroupProcsPath); err != nil {
if !os.IsNotExist(err) {
return false, err
}
return false, nil
}
return true, nil
} | go | func IsControllerMounted(c string) (bool, error) {
cgroupProcsPath := filepath.Join("/sys/fs/cgroup", c, "cgroup.procs")
if _, err := os.Stat(cgroupProcsPath); err != nil {
if !os.IsNotExist(err) {
return false, err
}
return false, nil
}
return true, nil
} | [
"func",
"IsControllerMounted",
"(",
"c",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"cgroupProcsPath",
":=",
"filepath",
".",
"Join",
"(",
"\"",
"\"",
",",
"c",
",",
"\"",
"\"",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
... | // IsControllerMounted returns whether a controller is mounted by checking that
// cgroup.procs is accessible | [
"IsControllerMounted",
"returns",
"whether",
"a",
"controller",
"is",
"mounted",
"by",
"checking",
"that",
"cgroup",
".",
"procs",
"is",
"accessible"
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/common/cgroup/v1/cgroup.go#L238-L248 |
21,019 | rkt/rkt | pkg/fileutil/fileutil_linux.go | Lgetxattr | func Lgetxattr(path string, attr string) ([]byte, error) {
pathBytes, err := syscall.BytePtrFromString(path)
if err != nil {
return nil, err
}
attrBytes, err := syscall.BytePtrFromString(attr)
if err != nil {
return nil, err
}
dest := make([]byte, 128)
destBytes := unsafe.Pointer(&dest[0])
sz, _, errno :=... | go | func Lgetxattr(path string, attr string) ([]byte, error) {
pathBytes, err := syscall.BytePtrFromString(path)
if err != nil {
return nil, err
}
attrBytes, err := syscall.BytePtrFromString(attr)
if err != nil {
return nil, err
}
dest := make([]byte, 128)
destBytes := unsafe.Pointer(&dest[0])
sz, _, errno :=... | [
"func",
"Lgetxattr",
"(",
"path",
"string",
",",
"attr",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"pathBytes",
",",
"err",
":=",
"syscall",
".",
"BytePtrFromString",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return"... | // Returns a nil slice and nil error if the xattr is not set | [
"Returns",
"a",
"nil",
"slice",
"and",
"nil",
"error",
"if",
"the",
"xattr",
"is",
"not",
"set"
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/fileutil/fileutil_linux.go#L58-L84 |
21,020 | rkt/rkt | pkg/fileutil/fileutil_linux.go | GetDeviceInfo | func GetDeviceInfo(path string) (kind rune, major uint64, minor uint64, err error) {
d, err := os.Lstat(path)
if err != nil {
return
}
mode := d.Mode()
if mode&os.ModeDevice == 0 {
err = fmt.Errorf("not a device: %s", path)
return
}
stat_t, ok := d.Sys().(*syscall.Stat_t)
if !ok {
err = fmt.Errorf("can... | go | func GetDeviceInfo(path string) (kind rune, major uint64, minor uint64, err error) {
d, err := os.Lstat(path)
if err != nil {
return
}
mode := d.Mode()
if mode&os.ModeDevice == 0 {
err = fmt.Errorf("not a device: %s", path)
return
}
stat_t, ok := d.Sys().(*syscall.Stat_t)
if !ok {
err = fmt.Errorf("can... | [
"func",
"GetDeviceInfo",
"(",
"path",
"string",
")",
"(",
"kind",
"rune",
",",
"major",
"uint64",
",",
"minor",
"uint64",
",",
"err",
"error",
")",
"{",
"d",
",",
"err",
":=",
"os",
".",
"Lstat",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
... | // GetDeviceInfo returns the type, major, and minor numbers of a device.
// Kind is 'b' or 'c' for block and character devices, respectively.
// This does not follow symlinks. | [
"GetDeviceInfo",
"returns",
"the",
"type",
"major",
"and",
"minor",
"numbers",
"of",
"a",
"device",
".",
"Kind",
"is",
"b",
"or",
"c",
"for",
"block",
"and",
"character",
"devices",
"respectively",
".",
"This",
"does",
"not",
"follow",
"symlinks",
"."
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/fileutil/fileutil_linux.go#L113-L130 |
21,021 | rkt/rkt | pkg/fileutil/fileutil_linux.go | getDeviceInfo | func getDeviceInfo(mode os.FileMode, rdev uint64) (kind rune, major uint64, minor uint64, err error) {
kind = 'b'
if mode&os.ModeCharDevice != 0 {
kind = 'c'
}
major = (rdev >> 8) & 0xfff
minor = (rdev & 0xff) | ((rdev >> 12) & 0xfff00)
return
} | go | func getDeviceInfo(mode os.FileMode, rdev uint64) (kind rune, major uint64, minor uint64, err error) {
kind = 'b'
if mode&os.ModeCharDevice != 0 {
kind = 'c'
}
major = (rdev >> 8) & 0xfff
minor = (rdev & 0xff) | ((rdev >> 12) & 0xfff00)
return
} | [
"func",
"getDeviceInfo",
"(",
"mode",
"os",
".",
"FileMode",
",",
"rdev",
"uint64",
")",
"(",
"kind",
"rune",
",",
"major",
"uint64",
",",
"minor",
"uint64",
",",
"err",
"error",
")",
"{",
"kind",
"=",
"'b'",
"\n\n",
"if",
"mode",
"&",
"os",
".",
"... | // Parse the device info out of the mode bits. Separate for testability. | [
"Parse",
"the",
"device",
"info",
"out",
"of",
"the",
"mode",
"bits",
".",
"Separate",
"for",
"testability",
"."
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/fileutil/fileutil_linux.go#L133-L144 |
21,022 | rkt/rkt | common/cgroup/cgroup.go | IsIsolatorSupported | func IsIsolatorSupported(isolator string) (bool, error) {
isUnified, err := IsCgroupUnified("/")
if err != nil {
return false, errwrap.Wrap(errors.New("error determining cgroup version"), err)
}
if isUnified {
controllers, err := v2.GetEnabledControllers()
if err != nil {
return false, errwrap.Wrap(errors... | go | func IsIsolatorSupported(isolator string) (bool, error) {
isUnified, err := IsCgroupUnified("/")
if err != nil {
return false, errwrap.Wrap(errors.New("error determining cgroup version"), err)
}
if isUnified {
controllers, err := v2.GetEnabledControllers()
if err != nil {
return false, errwrap.Wrap(errors... | [
"func",
"IsIsolatorSupported",
"(",
"isolator",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"isUnified",
",",
"err",
":=",
"IsCgroupUnified",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"errwrap",
".",
"Wr... | // IsIsolatorSupported returns whether an isolator is supported in the kernel | [
"IsIsolatorSupported",
"returns",
"whether",
"an",
"isolator",
"is",
"supported",
"in",
"the",
"kernel"
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/common/cgroup/cgroup.go#L37-L56 |
21,023 | rkt/rkt | pkg/backup/backup.go | CreateBackup | func CreateBackup(dir, backupsDir string, limit int) error {
tmpBackupDir := filepath.Join(backupsDir, "tmp")
if err := os.MkdirAll(backupsDir, 0750); err != nil {
return err
}
if err := fileutil.CopyTree(dir, tmpBackupDir, user.NewBlankUidRange()); err != nil {
return err
}
defer os.RemoveAll(tmpBackupDir)
... | go | func CreateBackup(dir, backupsDir string, limit int) error {
tmpBackupDir := filepath.Join(backupsDir, "tmp")
if err := os.MkdirAll(backupsDir, 0750); err != nil {
return err
}
if err := fileutil.CopyTree(dir, tmpBackupDir, user.NewBlankUidRange()); err != nil {
return err
}
defer os.RemoveAll(tmpBackupDir)
... | [
"func",
"CreateBackup",
"(",
"dir",
",",
"backupsDir",
"string",
",",
"limit",
"int",
")",
"error",
"{",
"tmpBackupDir",
":=",
"filepath",
".",
"Join",
"(",
"backupsDir",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
":=",
"os",
".",
"MkdirAll",
"(",
"backu... | // CreateBackup backs a directory up in a given directory. It basically
// copies this directory into a given backups directory. The backups
// directory has a simple structure - a directory inside named "0" is
// the most recent backup. A directory name for oldest backup is
// deduced from a given limit. For instance,... | [
"CreateBackup",
"backs",
"a",
"directory",
"up",
"in",
"a",
"given",
"directory",
".",
"It",
"basically",
"copies",
"this",
"directory",
"into",
"a",
"given",
"backups",
"directory",
".",
"The",
"backups",
"directory",
"has",
"a",
"simple",
"structure",
"-",
... | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/backup/backup.go#L35-L55 |
21,024 | rkt/rkt | pkg/backup/backup.go | pruneOldBackups | func pruneOldBackups(dir string, limit int) error {
if list, err := ioutil.ReadDir(dir); err != nil {
return err
} else {
for _, fi := range list {
if num, err := strconv.Atoi(fi.Name()); err != nil {
// directory name is not a number,
// leave it alone
continue
} else if num < limit {
// di... | go | func pruneOldBackups(dir string, limit int) error {
if list, err := ioutil.ReadDir(dir); err != nil {
return err
} else {
for _, fi := range list {
if num, err := strconv.Atoi(fi.Name()); err != nil {
// directory name is not a number,
// leave it alone
continue
} else if num < limit {
// di... | [
"func",
"pruneOldBackups",
"(",
"dir",
"string",
",",
"limit",
"int",
")",
"error",
"{",
"if",
"list",
",",
"err",
":=",
"ioutil",
".",
"ReadDir",
"(",
"dir",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"else",
"{",
"for",
"_",
... | // pruneOldBackups removes old backups, that is - directories with
// names greater or equal than given limit. | [
"pruneOldBackups",
"removes",
"old",
"backups",
"that",
"is",
"-",
"directories",
"with",
"names",
"greater",
"or",
"equal",
"than",
"given",
"limit",
"."
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/backup/backup.go#L59-L80 |
21,025 | rkt/rkt | pkg/backup/backup.go | shiftBackups | func shiftBackups(dir string, oldest int) error {
if oldest < 0 {
return nil
}
for i := oldest; i >= 0; i-- {
current := filepath.Join(dir, strconv.Itoa(i))
inc := filepath.Join(dir, strconv.Itoa(i+1))
if err := os.Rename(current, inc); err != nil && !os.IsNotExist(err) {
return err
}
}
return nil
} | go | func shiftBackups(dir string, oldest int) error {
if oldest < 0 {
return nil
}
for i := oldest; i >= 0; i-- {
current := filepath.Join(dir, strconv.Itoa(i))
inc := filepath.Join(dir, strconv.Itoa(i+1))
if err := os.Rename(current, inc); err != nil && !os.IsNotExist(err) {
return err
}
}
return nil
} | [
"func",
"shiftBackups",
"(",
"dir",
"string",
",",
"oldest",
"int",
")",
"error",
"{",
"if",
"oldest",
"<",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"for",
"i",
":=",
"oldest",
";",
"i",
">=",
"0",
";",
"i",
"--",
"{",
"current",
":=",
"filepa... | // shiftBackups renames all directories with names being numbers up to
// oldest to names with numbers greater by one. | [
"shiftBackups",
"renames",
"all",
"directories",
"with",
"names",
"being",
"numbers",
"up",
"to",
"oldest",
"to",
"names",
"with",
"numbers",
"greater",
"by",
"one",
"."
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/backup/backup.go#L84-L96 |
21,026 | rkt/rkt | pkg/aci/aci.go | NewBasicACI | func NewBasicACI(dir string, name string) (*os.File, error) {
manifest := schema.ImageManifest{
ACKind: schema.ImageManifestKind,
ACVersion: schema.AppContainerVersion,
Name: types.ACIdentifier(name),
}
b, err := manifest.MarshalJSON()
if err != nil {
return nil, err
}
return NewACI(dir, string(... | go | func NewBasicACI(dir string, name string) (*os.File, error) {
manifest := schema.ImageManifest{
ACKind: schema.ImageManifestKind,
ACVersion: schema.AppContainerVersion,
Name: types.ACIdentifier(name),
}
b, err := manifest.MarshalJSON()
if err != nil {
return nil, err
}
return NewACI(dir, string(... | [
"func",
"NewBasicACI",
"(",
"dir",
"string",
",",
"name",
"string",
")",
"(",
"*",
"os",
".",
"File",
",",
"error",
")",
"{",
"manifest",
":=",
"schema",
".",
"ImageManifest",
"{",
"ACKind",
":",
"schema",
".",
"ImageManifestKind",
",",
"ACVersion",
":",... | // NewBasicACI creates a new ACI in the given directory with the given name.
// Used for testing. | [
"NewBasicACI",
"creates",
"a",
"new",
"ACI",
"in",
"the",
"given",
"directory",
"with",
"the",
"given",
"name",
".",
"Used",
"for",
"testing",
"."
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/aci/aci.go#L109-L122 |
21,027 | rkt/rkt | pkg/aci/aci.go | NewACI | func NewACI(dir string, manifest string, entries []*ACIEntry) (*os.File, error) {
var im schema.ImageManifest
if err := im.UnmarshalJSON([]byte(manifest)); err != nil {
return nil, errwrap.Wrap(errors.New("invalid image manifest"), err)
}
tf, err := ioutil.TempFile(dir, "")
if err != nil {
return nil, err
}
... | go | func NewACI(dir string, manifest string, entries []*ACIEntry) (*os.File, error) {
var im schema.ImageManifest
if err := im.UnmarshalJSON([]byte(manifest)); err != nil {
return nil, errwrap.Wrap(errors.New("invalid image manifest"), err)
}
tf, err := ioutil.TempFile(dir, "")
if err != nil {
return nil, err
}
... | [
"func",
"NewACI",
"(",
"dir",
"string",
",",
"manifest",
"string",
",",
"entries",
"[",
"]",
"*",
"ACIEntry",
")",
"(",
"*",
"os",
".",
"File",
",",
"error",
")",
"{",
"var",
"im",
"schema",
".",
"ImageManifest",
"\n",
"if",
"err",
":=",
"im",
".",... | // NewACI creates a new ACI in the given directory with the given image
// manifest and entries.
// Used for testing. | [
"NewACI",
"creates",
"a",
"new",
"ACI",
"in",
"the",
"given",
"directory",
"with",
"the",
"given",
"image",
"manifest",
"and",
"entries",
".",
"Used",
"for",
"testing",
"."
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/aci/aci.go#L127-L164 |
21,028 | rkt/rkt | pkg/aci/aci.go | NewDetachedSignature | func NewDetachedSignature(armoredPrivateKey string, aci io.Reader) (io.Reader, error) {
entityList, err := openpgp.ReadArmoredKeyRing(bytes.NewBufferString(armoredPrivateKey))
if err != nil {
return nil, err
}
if len(entityList) < 1 {
return nil, errors.New("empty entity list")
}
signature := &bytes.Buffer{}
... | go | func NewDetachedSignature(armoredPrivateKey string, aci io.Reader) (io.Reader, error) {
entityList, err := openpgp.ReadArmoredKeyRing(bytes.NewBufferString(armoredPrivateKey))
if err != nil {
return nil, err
}
if len(entityList) < 1 {
return nil, errors.New("empty entity list")
}
signature := &bytes.Buffer{}
... | [
"func",
"NewDetachedSignature",
"(",
"armoredPrivateKey",
"string",
",",
"aci",
"io",
".",
"Reader",
")",
"(",
"io",
".",
"Reader",
",",
"error",
")",
"{",
"entityList",
",",
"err",
":=",
"openpgp",
".",
"ReadArmoredKeyRing",
"(",
"bytes",
".",
"NewBufferStr... | // NewDetachedSignature creates a new openpgp armored detached signature for the given ACI
// signed with armoredPrivateKey. | [
"NewDetachedSignature",
"creates",
"a",
"new",
"openpgp",
"armored",
"detached",
"signature",
"for",
"the",
"given",
"ACI",
"signed",
"with",
"armoredPrivateKey",
"."
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/aci/aci.go#L168-L181 |
21,029 | rkt/rkt | pkg/pod/sandbox.go | SandboxManifest | func (p *Pod) SandboxManifest() (*schema.PodManifest, error) {
_, pm, err := p.PodManifest() // this takes the lock fd to load the manifest, hence path is not needed here
if err != nil {
return nil, errwrap.Wrap(errors.New("error loading pod manifest"), err)
}
ms, ok := pm.Annotations.Get("coreos.com/rkt/stage1/... | go | func (p *Pod) SandboxManifest() (*schema.PodManifest, error) {
_, pm, err := p.PodManifest() // this takes the lock fd to load the manifest, hence path is not needed here
if err != nil {
return nil, errwrap.Wrap(errors.New("error loading pod manifest"), err)
}
ms, ok := pm.Annotations.Get("coreos.com/rkt/stage1/... | [
"func",
"(",
"p",
"*",
"Pod",
")",
"SandboxManifest",
"(",
")",
"(",
"*",
"schema",
".",
"PodManifest",
",",
"error",
")",
"{",
"_",
",",
"pm",
",",
"err",
":=",
"p",
".",
"PodManifest",
"(",
")",
"// this takes the lock fd to load the manifest, hence path i... | // SandboxManifest loads the underlying pod manifest and checks whether mutable operations are allowed.
// It returns ErrImmutable if the pod does not allow mutable operations or any other error if the operation failed.
// Upon success a reference to the pod manifest is returned and mutable operations are possible. | [
"SandboxManifest",
"loads",
"the",
"underlying",
"pod",
"manifest",
"and",
"checks",
"whether",
"mutable",
"operations",
"are",
"allowed",
".",
"It",
"returns",
"ErrImmutable",
"if",
"the",
"pod",
"does",
"not",
"allow",
"mutable",
"operations",
"or",
"any",
"ot... | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/pod/sandbox.go#L37-L56 |
21,030 | rkt/rkt | pkg/pod/sandbox.go | UpdateManifest | func (p *Pod) UpdateManifest(m *schema.PodManifest, path string) error {
if !p.mutable {
return ErrImmutable
}
mpath := common.PodManifestPath(path)
mstat, err := os.Stat(mpath)
if err != nil {
return err
}
tmpf, err := ioutil.TempFile(path, "")
if err != nil {
return err
}
defer func() {
tmpf.Clos... | go | func (p *Pod) UpdateManifest(m *schema.PodManifest, path string) error {
if !p.mutable {
return ErrImmutable
}
mpath := common.PodManifestPath(path)
mstat, err := os.Stat(mpath)
if err != nil {
return err
}
tmpf, err := ioutil.TempFile(path, "")
if err != nil {
return err
}
defer func() {
tmpf.Clos... | [
"func",
"(",
"p",
"*",
"Pod",
")",
"UpdateManifest",
"(",
"m",
"*",
"schema",
".",
"PodManifest",
",",
"path",
"string",
")",
"error",
"{",
"if",
"!",
"p",
".",
"mutable",
"{",
"return",
"ErrImmutable",
"\n",
"}",
"\n\n",
"mpath",
":=",
"common",
"."... | // UpdateManifest updates the given pod manifest in the given path atomically on the file system.
// The pod manifest has to be locked using LockManifest first to avoid races in case of concurrent writes. | [
"UpdateManifest",
"updates",
"the",
"given",
"pod",
"manifest",
"in",
"the",
"given",
"path",
"atomically",
"on",
"the",
"file",
"system",
".",
"The",
"pod",
"manifest",
"has",
"to",
"be",
"locked",
"using",
"LockManifest",
"first",
"to",
"avoid",
"races",
"... | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/pod/sandbox.go#L60-L94 |
21,031 | rkt/rkt | pkg/pod/sandbox.go | ExclusiveLockManifest | func (p *Pod) ExclusiveLockManifest() error {
if p.manifestLock != nil {
return p.manifestLock.ExclusiveLock() // This is idempotent
}
l, err := lock.ExclusiveLock(common.PodManifestLockPath(p.Path()), lock.RegFile)
if err != nil {
return err
}
p.manifestLock = l
return nil
} | go | func (p *Pod) ExclusiveLockManifest() error {
if p.manifestLock != nil {
return p.manifestLock.ExclusiveLock() // This is idempotent
}
l, err := lock.ExclusiveLock(common.PodManifestLockPath(p.Path()), lock.RegFile)
if err != nil {
return err
}
p.manifestLock = l
return nil
} | [
"func",
"(",
"p",
"*",
"Pod",
")",
"ExclusiveLockManifest",
"(",
")",
"error",
"{",
"if",
"p",
".",
"manifestLock",
"!=",
"nil",
"{",
"return",
"p",
".",
"manifestLock",
".",
"ExclusiveLock",
"(",
")",
"// This is idempotent",
"\n",
"}",
"\n\n",
"l",
","... | // ExclusiveLockManifest gets an exclusive lock on only the pod manifest in the app sandbox.
// Since the pod might already be running, we can't just get an exclusive lock on the pod itself. | [
"ExclusiveLockManifest",
"gets",
"an",
"exclusive",
"lock",
"on",
"only",
"the",
"pod",
"manifest",
"in",
"the",
"app",
"sandbox",
".",
"Since",
"the",
"pod",
"might",
"already",
"be",
"running",
"we",
"can",
"t",
"just",
"get",
"an",
"exclusive",
"lock",
... | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/pod/sandbox.go#L98-L110 |
21,032 | rkt/rkt | pkg/pod/sandbox.go | UnlockManifest | func (p *Pod) UnlockManifest() error {
if p.manifestLock == nil {
return nil
}
if err := p.manifestLock.Close(); err != nil {
return err
}
p.manifestLock = nil
return nil
} | go | func (p *Pod) UnlockManifest() error {
if p.manifestLock == nil {
return nil
}
if err := p.manifestLock.Close(); err != nil {
return err
}
p.manifestLock = nil
return nil
} | [
"func",
"(",
"p",
"*",
"Pod",
")",
"UnlockManifest",
"(",
")",
"error",
"{",
"if",
"p",
".",
"manifestLock",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"p",
".",
"manifestLock",
".",
"Close",
"(",
")",
";",
"err",
"!... | // UnlockManifest unlocks the pod manifest lock. | [
"UnlockManifest",
"unlocks",
"the",
"pod",
"manifest",
"lock",
"."
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/pod/sandbox.go#L113-L123 |
21,033 | rkt/rkt | store/imagestore/schema.go | getDBVersion | func getDBVersion(tx *sql.Tx) (int, error) {
var version int
rows, err := tx.Query("SELECT version FROM version")
if err != nil {
return -1, err
}
defer rows.Close()
found := false
for rows.Next() {
if err := rows.Scan(&version); err != nil {
return -1, err
}
found = true
break
}
if err := rows.Er... | go | func getDBVersion(tx *sql.Tx) (int, error) {
var version int
rows, err := tx.Query("SELECT version FROM version")
if err != nil {
return -1, err
}
defer rows.Close()
found := false
for rows.Next() {
if err := rows.Scan(&version); err != nil {
return -1, err
}
found = true
break
}
if err := rows.Er... | [
"func",
"getDBVersion",
"(",
"tx",
"*",
"sql",
".",
"Tx",
")",
"(",
"int",
",",
"error",
")",
"{",
"var",
"version",
"int",
"\n",
"rows",
",",
"err",
":=",
"tx",
".",
"Query",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",... | // getDBVersion retrieves the current db version | [
"getDBVersion",
"retrieves",
"the",
"current",
"db",
"version"
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/store/imagestore/schema.go#L66-L88 |
21,034 | rkt/rkt | store/imagestore/schema.go | updateDBVersion | func updateDBVersion(tx *sql.Tx, version int) error {
// ql doesn't have an INSERT OR UPDATE function so
// it's faster to remove and reinsert the row
_, err := tx.Exec("DELETE FROM version")
if err != nil {
return err
}
_, err = tx.Exec("INSERT INTO version VALUES ($1)", version)
if err != nil {
return err
... | go | func updateDBVersion(tx *sql.Tx, version int) error {
// ql doesn't have an INSERT OR UPDATE function so
// it's faster to remove and reinsert the row
_, err := tx.Exec("DELETE FROM version")
if err != nil {
return err
}
_, err = tx.Exec("INSERT INTO version VALUES ($1)", version)
if err != nil {
return err
... | [
"func",
"updateDBVersion",
"(",
"tx",
"*",
"sql",
".",
"Tx",
",",
"version",
"int",
")",
"error",
"{",
"// ql doesn't have an INSERT OR UPDATE function so",
"// it's faster to remove and reinsert the row",
"_",
",",
"err",
":=",
"tx",
".",
"Exec",
"(",
"\"",
"\"",
... | // updateDBVersion updates the db version | [
"updateDBVersion",
"updates",
"the",
"db",
"version"
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/store/imagestore/schema.go#L91-L103 |
21,035 | rkt/rkt | pkg/acl/acl.go | InitACL | func InitACL() (*ACL, error) {
h, err := getHandle()
if err != nil {
return nil, err
}
return &ACL{lib: h}, nil
} | go | func InitACL() (*ACL, error) {
h, err := getHandle()
if err != nil {
return nil, err
}
return &ACL{lib: h}, nil
} | [
"func",
"InitACL",
"(",
")",
"(",
"*",
"ACL",
",",
"error",
")",
"{",
"h",
",",
"err",
":=",
"getHandle",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"ACL",
"{",
"lib",
":",
"h... | // InitACL dlopens libacl and returns an ACL object if successful. | [
"InitACL",
"dlopens",
"libacl",
"and",
"returns",
"an",
"ACL",
"object",
"if",
"successful",
"."
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/acl/acl.go#L220-L227 |
21,036 | rkt/rkt | pkg/acl/acl.go | ParseACL | func (a *ACL) ParseACL(acl string) error {
acl_from_text, err := getSymbolPointer(a.lib.handle, "acl_from_text")
if err != nil {
return err
}
cacl := C.CString(acl)
defer C.free(unsafe.Pointer(cacl))
retACL, err := C.my_acl_from_text(acl_from_text, cacl)
if retACL == nil {
return errwrap.Wrap(errors.New("er... | go | func (a *ACL) ParseACL(acl string) error {
acl_from_text, err := getSymbolPointer(a.lib.handle, "acl_from_text")
if err != nil {
return err
}
cacl := C.CString(acl)
defer C.free(unsafe.Pointer(cacl))
retACL, err := C.my_acl_from_text(acl_from_text, cacl)
if retACL == nil {
return errwrap.Wrap(errors.New("er... | [
"func",
"(",
"a",
"*",
"ACL",
")",
"ParseACL",
"(",
"acl",
"string",
")",
"error",
"{",
"acl_from_text",
",",
"err",
":=",
"getSymbolPointer",
"(",
"a",
".",
"lib",
".",
"handle",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",... | // ParseACL parses a string representation of an ACL. | [
"ParseACL",
"parses",
"a",
"string",
"representation",
"of",
"an",
"ACL",
"."
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/acl/acl.go#L230-L246 |
21,037 | rkt/rkt | pkg/acl/acl.go | Free | func (a *ACL) Free() error {
acl_free, err := getSymbolPointer(a.lib.handle, "acl_free")
if err != nil {
return err
}
ret, err := C.my_acl_free(acl_free, a.a)
if ret < 0 {
return errwrap.Wrap(errors.New("error calling acl_free"), err)
}
return a.lib.close()
} | go | func (a *ACL) Free() error {
acl_free, err := getSymbolPointer(a.lib.handle, "acl_free")
if err != nil {
return err
}
ret, err := C.my_acl_free(acl_free, a.a)
if ret < 0 {
return errwrap.Wrap(errors.New("error calling acl_free"), err)
}
return a.lib.close()
} | [
"func",
"(",
"a",
"*",
"ACL",
")",
"Free",
"(",
")",
"error",
"{",
"acl_free",
",",
"err",
":=",
"getSymbolPointer",
"(",
"a",
".",
"lib",
".",
"handle",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n... | // Free frees libacl's internal structures and closes libacl. | [
"Free",
"frees",
"libacl",
"s",
"internal",
"structures",
"and",
"closes",
"libacl",
"."
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/acl/acl.go#L249-L261 |
21,038 | rkt/rkt | pkg/acl/acl.go | SetFileACLDefault | func (a *ACL) SetFileACLDefault(path string) error {
acl_set_file, err := getSymbolPointer(a.lib.handle, "acl_set_file")
if err != nil {
return err
}
cpath := C.CString(path)
defer C.free(unsafe.Pointer(cpath))
ret, err := C.my_acl_set_file(acl_set_file, cpath, C.ACL_TYPE_DEFAULT, a.a)
if ret < 0 {
return ... | go | func (a *ACL) SetFileACLDefault(path string) error {
acl_set_file, err := getSymbolPointer(a.lib.handle, "acl_set_file")
if err != nil {
return err
}
cpath := C.CString(path)
defer C.free(unsafe.Pointer(cpath))
ret, err := C.my_acl_set_file(acl_set_file, cpath, C.ACL_TYPE_DEFAULT, a.a)
if ret < 0 {
return ... | [
"func",
"(",
"a",
"*",
"ACL",
")",
"SetFileACLDefault",
"(",
"path",
"string",
")",
"error",
"{",
"acl_set_file",
",",
"err",
":=",
"getSymbolPointer",
"(",
"a",
".",
"lib",
".",
"handle",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
... | // SetFileACLDefault sets the "default" ACL for path. | [
"SetFileACLDefault",
"sets",
"the",
"default",
"ACL",
"for",
"path",
"."
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/acl/acl.go#L264-L279 |
21,039 | rkt/rkt | pkg/acl/acl.go | Valid | func (a *ACL) Valid() error {
acl_valid, err := getSymbolPointer(a.lib.handle, "acl_valid")
if err != nil {
return err
}
ret, err := C.my_acl_valid(acl_valid, a.a)
if ret < 0 {
return errwrap.Wrap(errors.New("invalid acl"), err)
}
return nil
} | go | func (a *ACL) Valid() error {
acl_valid, err := getSymbolPointer(a.lib.handle, "acl_valid")
if err != nil {
return err
}
ret, err := C.my_acl_valid(acl_valid, a.a)
if ret < 0 {
return errwrap.Wrap(errors.New("invalid acl"), err)
}
return nil
} | [
"func",
"(",
"a",
"*",
"ACL",
")",
"Valid",
"(",
")",
"error",
"{",
"acl_valid",
",",
"err",
":=",
"getSymbolPointer",
"(",
"a",
".",
"lib",
".",
"handle",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"... | // Valid checks whether the ACL is valid. | [
"Valid",
"checks",
"whether",
"the",
"ACL",
"is",
"valid",
"."
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/acl/acl.go#L282-L293 |
21,040 | rkt/rkt | pkg/acl/acl.go | AddBaseEntries | func (a *ACL) AddBaseEntries(path string) error {
fi, err := os.Lstat(path)
if err != nil {
return err
}
mode := fi.Mode().Perm()
var r, w, x bool
// set USER_OBJ entry
r = mode&userRead == userRead
w = mode&userWrite == userWrite
x = mode&userExec == userExec
if err := a.addBaseEntryFromMode(TagUserObj, r... | go | func (a *ACL) AddBaseEntries(path string) error {
fi, err := os.Lstat(path)
if err != nil {
return err
}
mode := fi.Mode().Perm()
var r, w, x bool
// set USER_OBJ entry
r = mode&userRead == userRead
w = mode&userWrite == userWrite
x = mode&userExec == userExec
if err := a.addBaseEntryFromMode(TagUserObj, r... | [
"func",
"(",
"a",
"*",
"ACL",
")",
"AddBaseEntries",
"(",
"path",
"string",
")",
"error",
"{",
"fi",
",",
"err",
":=",
"os",
".",
"Lstat",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"mode",
":=",
"f... | // AddBaseEntries adds the base ACL entries from the file permissions. | [
"AddBaseEntries",
"adds",
"the",
"base",
"ACL",
"entries",
"from",
"the",
"file",
"permissions",
"."
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/acl/acl.go#L296-L329 |
21,041 | rkt/rkt | pkg/distribution/appc.go | NewAppc | func NewAppc(u *url.URL) (Distribution, error) {
c, err := parseCIMD(u)
if err != nil {
return nil, fmt.Errorf("cannot parse URI: %q: %v", u.String(), err)
}
if c.Type != TypeAppc {
return nil, fmt.Errorf("wrong distribution type: %q", c.Type)
}
appcStr := c.Data
for n, v := range u.Query() {
appcStr += f... | go | func NewAppc(u *url.URL) (Distribution, error) {
c, err := parseCIMD(u)
if err != nil {
return nil, fmt.Errorf("cannot parse URI: %q: %v", u.String(), err)
}
if c.Type != TypeAppc {
return nil, fmt.Errorf("wrong distribution type: %q", c.Type)
}
appcStr := c.Data
for n, v := range u.Query() {
appcStr += f... | [
"func",
"NewAppc",
"(",
"u",
"*",
"url",
".",
"URL",
")",
"(",
"Distribution",
",",
"error",
")",
"{",
"c",
",",
"err",
":=",
"parseCIMD",
"(",
"u",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\""... | // NewAppc returns an Appc distribution from an Appc distribution URI | [
"NewAppc",
"returns",
"an",
"Appc",
"distribution",
"from",
"an",
"Appc",
"distribution",
"URI"
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/distribution/appc.go#L52-L71 |
21,042 | rkt/rkt | pkg/distribution/appc.go | NewAppcFromApp | func NewAppcFromApp(app *discovery.App) Distribution {
rawuri := NewCIMDString(TypeAppc, distAppcVersion, url.QueryEscape(app.Name.String()))
var version string
labels := types.Labels{}
for n, v := range app.Labels {
if n == "version" {
version = v
}
labels = append(labels, types.Label{Name: n, Value: v}... | go | func NewAppcFromApp(app *discovery.App) Distribution {
rawuri := NewCIMDString(TypeAppc, distAppcVersion, url.QueryEscape(app.Name.String()))
var version string
labels := types.Labels{}
for n, v := range app.Labels {
if n == "version" {
version = v
}
labels = append(labels, types.Label{Name: n, Value: v}... | [
"func",
"NewAppcFromApp",
"(",
"app",
"*",
"discovery",
".",
"App",
")",
"Distribution",
"{",
"rawuri",
":=",
"NewCIMDString",
"(",
"TypeAppc",
",",
"distAppcVersion",
",",
"url",
".",
"QueryEscape",
"(",
"app",
".",
"Name",
".",
"String",
"(",
")",
")",
... | // NewAppcFromApp returns an Appc distribution from an appc App discovery string | [
"NewAppcFromApp",
"returns",
"an",
"Appc",
"distribution",
"from",
"an",
"appc",
"App",
"discovery",
"string"
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/distribution/appc.go#L74-L121 |
21,043 | rkt/rkt | pkg/sys/sys.go | CloseOnExec | func CloseOnExec(fd int, set bool) error {
flag := uintptr(0)
if set {
flag = syscall.FD_CLOEXEC
}
_, _, err := syscall.RawSyscall(syscall.SYS_FCNTL, uintptr(fd), syscall.F_SETFD, flag)
if err != 0 {
return syscall.Errno(err)
}
return nil
} | go | func CloseOnExec(fd int, set bool) error {
flag := uintptr(0)
if set {
flag = syscall.FD_CLOEXEC
}
_, _, err := syscall.RawSyscall(syscall.SYS_FCNTL, uintptr(fd), syscall.F_SETFD, flag)
if err != 0 {
return syscall.Errno(err)
}
return nil
} | [
"func",
"CloseOnExec",
"(",
"fd",
"int",
",",
"set",
"bool",
")",
"error",
"{",
"flag",
":=",
"uintptr",
"(",
"0",
")",
"\n",
"if",
"set",
"{",
"flag",
"=",
"syscall",
".",
"FD_CLOEXEC",
"\n",
"}",
"\n",
"_",
",",
"_",
",",
"err",
":=",
"syscall"... | // CloseOnExec sets or clears FD_CLOEXEC flag on a file descriptor | [
"CloseOnExec",
"sets",
"or",
"clears",
"FD_CLOEXEC",
"flag",
"on",
"a",
"file",
"descriptor"
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/sys/sys.go#L22-L32 |
21,044 | rkt/rkt | common/cgroup/v2/cgroup.go | GetEnabledControllers | func GetEnabledControllers() ([]string, error) {
controllersFile, err := os.Open("/sys/fs/cgroup/cgroup.controllers")
if err != nil {
return nil, err
}
defer controllersFile.Close()
sc := bufio.NewScanner(controllersFile)
sc.Scan()
if err := sc.Err(); err != nil {
return nil, err
}
return strings.Split(... | go | func GetEnabledControllers() ([]string, error) {
controllersFile, err := os.Open("/sys/fs/cgroup/cgroup.controllers")
if err != nil {
return nil, err
}
defer controllersFile.Close()
sc := bufio.NewScanner(controllersFile)
sc.Scan()
if err := sc.Err(); err != nil {
return nil, err
}
return strings.Split(... | [
"func",
"GetEnabledControllers",
"(",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"controllersFile",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
... | // GetEnabledControllers returns a list of enabled cgroup controllers | [
"GetEnabledControllers",
"returns",
"a",
"list",
"of",
"enabled",
"cgroup",
"controllers"
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/common/cgroup/v2/cgroup.go#L30-L45 |
21,045 | rkt/rkt | tools/depsgen/globcmd.go | globGetArgs | func globGetArgs(args []string) globArgs {
f, target := standardFlags(globCmd)
suffix := f.String("suffix", "", "File suffix (example: .go)")
globbingMode := f.String("glob-mode", "all", "Which files to glob (normal, dot-files, all [default])")
filelist := f.String("filelist", "", "Read all the files from this file... | go | func globGetArgs(args []string) globArgs {
f, target := standardFlags(globCmd)
suffix := f.String("suffix", "", "File suffix (example: .go)")
globbingMode := f.String("glob-mode", "all", "Which files to glob (normal, dot-files, all [default])")
filelist := f.String("filelist", "", "Read all the files from this file... | [
"func",
"globGetArgs",
"(",
"args",
"[",
"]",
"string",
")",
"globArgs",
"{",
"f",
",",
"target",
":=",
"standardFlags",
"(",
"globCmd",
")",
"\n",
"suffix",
":=",
"f",
".",
"String",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
... | // globGetArgs parses given parameters and returns a target, a suffix
// and a list of files. | [
"globGetArgs",
"parses",
"given",
"parameters",
"and",
"returns",
"a",
"target",
"a",
"suffix",
"and",
"a",
"list",
"of",
"files",
"."
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/tools/depsgen/globcmd.go#L76-L103 |
21,046 | rkt/rkt | tools/depsgen/globcmd.go | globGetMakeFunction | func globGetMakeFunction(files []string, suffix string, mode globMode) string {
dirs := map[string]struct{}{}
for _, file := range files {
dirs[filepath.Dir(file)] = struct{}{}
}
makeWildcards := make([]string, 0, len(dirs))
wildcard := globGetMakeSnippet(mode)
for dir := range dirs {
str := replacePlaceholde... | go | func globGetMakeFunction(files []string, suffix string, mode globMode) string {
dirs := map[string]struct{}{}
for _, file := range files {
dirs[filepath.Dir(file)] = struct{}{}
}
makeWildcards := make([]string, 0, len(dirs))
wildcard := globGetMakeSnippet(mode)
for dir := range dirs {
str := replacePlaceholde... | [
"func",
"globGetMakeFunction",
"(",
"files",
"[",
"]",
"string",
",",
"suffix",
"string",
",",
"mode",
"globMode",
")",
"string",
"{",
"dirs",
":=",
"map",
"[",
"string",
"]",
"struct",
"{",
"}",
"{",
"}",
"\n",
"for",
"_",
",",
"file",
":=",
"range"... | // globGetMakeFunction returns a make snippet which calls wildcard
// function in all directories where given files are and with a given
// suffix. | [
"globGetMakeFunction",
"returns",
"a",
"make",
"snippet",
"which",
"calls",
"wildcard",
"function",
"in",
"all",
"directories",
"where",
"given",
"files",
"are",
"and",
"with",
"a",
"given",
"suffix",
"."
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/tools/depsgen/globcmd.go#L143-L155 |
21,047 | rkt/rkt | pkg/pod/wait.go | WaitFinished | func (p *Pod) WaitFinished(ctx context.Context) error {
f := func() bool {
switch err := p.TrySharedLock(); err {
case nil:
// the pod is now locked successfully, hence one of the running phases passed.
// continue with unlocking the pod immediately below.
case lock.ErrLocked:
// pod is still locked, he... | go | func (p *Pod) WaitFinished(ctx context.Context) error {
f := func() bool {
switch err := p.TrySharedLock(); err {
case nil:
// the pod is now locked successfully, hence one of the running phases passed.
// continue with unlocking the pod immediately below.
case lock.ErrLocked:
// pod is still locked, he... | [
"func",
"(",
"p",
"*",
"Pod",
")",
"WaitFinished",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"f",
":=",
"func",
"(",
")",
"bool",
"{",
"switch",
"err",
":=",
"p",
".",
"TrySharedLock",
"(",
")",
";",
"err",
"{",
"case",
"nil",
":"... | // WaitFinished waits for a pod to finish by polling every 100 milliseconds
// or until the given context is cancelled. This method refreshes the pod state.
// It is the caller's responsibility to determine the actual terminal state. | [
"WaitFinished",
"waits",
"for",
"a",
"pod",
"to",
"finish",
"by",
"polling",
"every",
"100",
"milliseconds",
"or",
"until",
"the",
"given",
"context",
"is",
"cancelled",
".",
"This",
"method",
"refreshes",
"the",
"pod",
"state",
".",
"It",
"is",
"the",
"ca... | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/pod/wait.go#L28-L61 |
21,048 | rkt/rkt | pkg/pod/wait.go | WaitReady | func (p *Pod) WaitReady(ctx context.Context) error {
f := func() bool {
if err := p.refreshState(); err != nil {
return false
}
return p.IsSupervisorReady()
}
return retry(ctx, f, 100*time.Millisecond)
} | go | func (p *Pod) WaitReady(ctx context.Context) error {
f := func() bool {
if err := p.refreshState(); err != nil {
return false
}
return p.IsSupervisorReady()
}
return retry(ctx, f, 100*time.Millisecond)
} | [
"func",
"(",
"p",
"*",
"Pod",
")",
"WaitReady",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"f",
":=",
"func",
"(",
")",
"bool",
"{",
"if",
"err",
":=",
"p",
".",
"refreshState",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"... | // WaitReady blocks until the pod is ready by polling the readiness state every 100 milliseconds
// or until the given context is cancelled. This method refreshes the pod state. | [
"WaitReady",
"blocks",
"until",
"the",
"pod",
"is",
"ready",
"by",
"polling",
"the",
"readiness",
"state",
"every",
"100",
"milliseconds",
"or",
"until",
"the",
"given",
"context",
"is",
"cancelled",
".",
"This",
"method",
"refreshes",
"the",
"pod",
"state",
... | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/pod/wait.go#L65-L75 |
21,049 | rkt/rkt | pkg/pod/wait.go | retry | func retry(ctx context.Context, f func() bool, delay time.Duration) error {
if f() {
return nil
}
ticker := time.NewTicker(delay)
errChan := make(chan error)
go func() {
defer close(errChan)
for {
select {
case <-ctx.Done():
errChan <- ctx.Err()
return
case <-ticker.C:
if f() {
r... | go | func retry(ctx context.Context, f func() bool, delay time.Duration) error {
if f() {
return nil
}
ticker := time.NewTicker(delay)
errChan := make(chan error)
go func() {
defer close(errChan)
for {
select {
case <-ctx.Done():
errChan <- ctx.Err()
return
case <-ticker.C:
if f() {
r... | [
"func",
"retry",
"(",
"ctx",
"context",
".",
"Context",
",",
"f",
"func",
"(",
")",
"bool",
",",
"delay",
"time",
".",
"Duration",
")",
"error",
"{",
"if",
"f",
"(",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"ticker",
":=",
"time",
".",
"NewT... | // retry calls function f indefinitely with the given delay between invocations
// until f returns true or the given context is cancelled.
// It returns immediately without delay in case function f immediately returns true. | [
"retry",
"calls",
"function",
"f",
"indefinitely",
"with",
"the",
"given",
"delay",
"between",
"invocations",
"until",
"f",
"returns",
"true",
"or",
"the",
"given",
"context",
"is",
"cancelled",
".",
"It",
"returns",
"immediately",
"without",
"delay",
"in",
"c... | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/pod/wait.go#L80-L105 |
21,050 | rkt/rkt | pkg/fileutil/fileutil.go | DirSize | func DirSize(path string) (int64, error) {
seenInode := make(map[uint64]struct{})
if _, err := os.Stat(path); err == nil {
var sz int64
err := filepath.Walk(path, func(path string, info os.FileInfo, err error) error {
if hasHardLinks(info) {
ino := getInode(info)
if _, ok := seenInode[ino]; !ok {
... | go | func DirSize(path string) (int64, error) {
seenInode := make(map[uint64]struct{})
if _, err := os.Stat(path); err == nil {
var sz int64
err := filepath.Walk(path, func(path string, info os.FileInfo, err error) error {
if hasHardLinks(info) {
ino := getInode(info)
if _, ok := seenInode[ino]; !ok {
... | [
"func",
"DirSize",
"(",
"path",
"string",
")",
"(",
"int64",
",",
"error",
")",
"{",
"seenInode",
":=",
"make",
"(",
"map",
"[",
"uint64",
"]",
"struct",
"{",
"}",
")",
"\n\n",
"if",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"path",
")",
"... | // DirSize takes a path and returns its size in bytes | [
"DirSize",
"takes",
"a",
"path",
"and",
"returns",
"its",
"size",
"in",
"bytes"
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/fileutil/fileutil.go#L208-L229 |
21,051 | rkt/rkt | pkg/fileutil/fileutil.go | IsDeviceNode | func IsDeviceNode(path string) bool {
d, err := os.Lstat(path)
if err == nil {
m := d.Mode()
return m&os.ModeDevice == os.ModeDevice
}
return false
} | go | func IsDeviceNode(path string) bool {
d, err := os.Lstat(path)
if err == nil {
m := d.Mode()
return m&os.ModeDevice == os.ModeDevice
}
return false
} | [
"func",
"IsDeviceNode",
"(",
"path",
"string",
")",
"bool",
"{",
"d",
",",
"err",
":=",
"os",
".",
"Lstat",
"(",
"path",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"m",
":=",
"d",
".",
"Mode",
"(",
")",
"\n",
"return",
"m",
"&",
"os",
".",
"Mo... | // IsDeviceNode checks if the given path points to a block or char device.
// It doesn't follow symlinks. | [
"IsDeviceNode",
"checks",
"if",
"the",
"given",
"path",
"points",
"to",
"a",
"block",
"or",
"char",
"device",
".",
"It",
"doesn",
"t",
"follow",
"symlinks",
"."
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/fileutil/fileutil.go#L244-L251 |
21,052 | rkt/rkt | stage1/init/kvm/hypervisor/hvlkvm/lkvm_driver.go | StartCmd | func StartCmd(wdPath, uuid, kernelPath string, nds []kvm.NetDescriber, cpu, mem int64, debug bool) []string {
machineID := strings.Replace(uuid, "-", "", -1)
driverConfiguration := hypervisor.KvmHypervisor{
Bin: "./lkvm",
KernelParams: []string{
"systemd.default_standard_error=journal+console",
"systemd.def... | go | func StartCmd(wdPath, uuid, kernelPath string, nds []kvm.NetDescriber, cpu, mem int64, debug bool) []string {
machineID := strings.Replace(uuid, "-", "", -1)
driverConfiguration := hypervisor.KvmHypervisor{
Bin: "./lkvm",
KernelParams: []string{
"systemd.default_standard_error=journal+console",
"systemd.def... | [
"func",
"StartCmd",
"(",
"wdPath",
",",
"uuid",
",",
"kernelPath",
"string",
",",
"nds",
"[",
"]",
"kvm",
".",
"NetDescriber",
",",
"cpu",
",",
"mem",
"int64",
",",
"debug",
"bool",
")",
"[",
"]",
"string",
"{",
"machineID",
":=",
"strings",
".",
"Re... | // StartCmd takes path to stage1, UUID of the pod, path to kernel, network
// describers, memory in megabytes and quantity of cpus and prepares command
// line to run LKVM process | [
"StartCmd",
"takes",
"path",
"to",
"stage1",
"UUID",
"of",
"the",
"pod",
"path",
"to",
"kernel",
"network",
"describers",
"memory",
"in",
"megabytes",
"and",
"quantity",
"of",
"cpus",
"and",
"prepares",
"command",
"line",
"to",
"run",
"LKVM",
"process"
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage1/init/kvm/hypervisor/hvlkvm/lkvm_driver.go#L30-L56 |
21,053 | rkt/rkt | stage1/init/kvm/hypervisor/hvlkvm/lkvm_driver.go | kvmNetArgs | func kvmNetArgs(nds []kvm.NetDescriber) []string {
var lkvmArgs []string
for _, nd := range nds {
lkvmArgs = append(lkvmArgs, "--network")
lkvmArgs = append(
lkvmArgs,
fmt.Sprintf("mode=tap,tapif=%s,host_ip=%s,guest_ip=%s", nd.IfName(), nd.Gateway(), nd.GuestIP()),
)
}
return lkvmArgs
} | go | func kvmNetArgs(nds []kvm.NetDescriber) []string {
var lkvmArgs []string
for _, nd := range nds {
lkvmArgs = append(lkvmArgs, "--network")
lkvmArgs = append(
lkvmArgs,
fmt.Sprintf("mode=tap,tapif=%s,host_ip=%s,guest_ip=%s", nd.IfName(), nd.Gateway(), nd.GuestIP()),
)
}
return lkvmArgs
} | [
"func",
"kvmNetArgs",
"(",
"nds",
"[",
"]",
"kvm",
".",
"NetDescriber",
")",
"[",
"]",
"string",
"{",
"var",
"lkvmArgs",
"[",
"]",
"string",
"\n\n",
"for",
"_",
",",
"nd",
":=",
"range",
"nds",
"{",
"lkvmArgs",
"=",
"append",
"(",
"lkvmArgs",
",",
... | // kvmNetArgs returns additional arguments that need to be passed
// to lkvm tool to configure networks properly. Logic is based on
// network configuration extracted from Networking struct
// and essentially from activeNets that expose NetDescriber behavior | [
"kvmNetArgs",
"returns",
"additional",
"arguments",
"that",
"need",
"to",
"be",
"passed",
"to",
"lkvm",
"tool",
"to",
"configure",
"networks",
"properly",
".",
"Logic",
"is",
"based",
"on",
"network",
"configuration",
"extracted",
"from",
"Networking",
"struct",
... | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage1/init/kvm/hypervisor/hvlkvm/lkvm_driver.go#L62-L74 |
21,054 | rkt/rkt | pkg/flag/optionlist.go | NewOptionList | func NewOptionList(permissibleOptions []string, defaultOptions string) (*OptionList, error) {
permissible := make(map[string]struct{})
ol := &OptionList{
allOptions: permissibleOptions,
permissible: permissible,
typeName: "OptionList",
}
for _, o := range permissibleOptions {
ol.permissible[o] = struct... | go | func NewOptionList(permissibleOptions []string, defaultOptions string) (*OptionList, error) {
permissible := make(map[string]struct{})
ol := &OptionList{
allOptions: permissibleOptions,
permissible: permissible,
typeName: "OptionList",
}
for _, o := range permissibleOptions {
ol.permissible[o] = struct... | [
"func",
"NewOptionList",
"(",
"permissibleOptions",
"[",
"]",
"string",
",",
"defaultOptions",
"string",
")",
"(",
"*",
"OptionList",
",",
"error",
")",
"{",
"permissible",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"struct",
"{",
"}",
")",
"\n",
"ol"... | // NewOptionList initializes an OptionList. PermissibleOptions is the complete
// set of allowable options. It will set all options specified in defaultOptions
// as provided; they will all be cleared if this flag is passed in the CLI | [
"NewOptionList",
"initializes",
"an",
"OptionList",
".",
"PermissibleOptions",
"is",
"the",
"complete",
"set",
"of",
"allowable",
"options",
".",
"It",
"will",
"set",
"all",
"options",
"specified",
"in",
"defaultOptions",
"as",
"provided",
";",
"they",
"will",
"... | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/flag/optionlist.go#L38-L55 |
21,055 | rkt/rkt | rkt/image_gc.go | gcTreeStore | func gcTreeStore(ts *treestore.Store) error {
// Take an exclusive lock to block other pods being created.
// This is needed to avoid races between the below steps (getting the
// list of referenced treeStoreIDs, getting the list of treeStoreIDs
// from the store, removal of unreferenced treeStoreIDs) and new
// p... | go | func gcTreeStore(ts *treestore.Store) error {
// Take an exclusive lock to block other pods being created.
// This is needed to avoid races between the below steps (getting the
// list of referenced treeStoreIDs, getting the list of treeStoreIDs
// from the store, removal of unreferenced treeStoreIDs) and new
// p... | [
"func",
"gcTreeStore",
"(",
"ts",
"*",
"treestore",
".",
"Store",
")",
"error",
"{",
"// Take an exclusive lock to block other pods being created.",
"// This is needed to avoid races between the below steps (getting the",
"// list of referenced treeStoreIDs, getting the list of treeStoreID... | // gcTreeStore removes all treeStoreIDs not referenced by any non garbage
// collected pod from the store. | [
"gcTreeStore",
"removes",
"all",
"treeStoreIDs",
"not",
"referenced",
"by",
"any",
"non",
"garbage",
"collected",
"pod",
"from",
"the",
"store",
"."
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/rkt/image_gc.go#L82-L111 |
21,056 | rkt/rkt | rkt/image_gc.go | getRunningImages | func getRunningImages() ([]string, error) {
var runningImages []string
var errors []error
err := pkgPod.WalkPods(getDataDir(), pkgPod.IncludeMostDirs, func(p *pkgPod.Pod) {
var pm schema.PodManifest
if p.State() != pkgPod.Running {
return
}
if !p.PodManifestAvailable() {
return
}
_, manifest, err :... | go | func getRunningImages() ([]string, error) {
var runningImages []string
var errors []error
err := pkgPod.WalkPods(getDataDir(), pkgPod.IncludeMostDirs, func(p *pkgPod.Pod) {
var pm schema.PodManifest
if p.State() != pkgPod.Running {
return
}
if !p.PodManifestAvailable() {
return
}
_, manifest, err :... | [
"func",
"getRunningImages",
"(",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"var",
"runningImages",
"[",
"]",
"string",
"\n",
"var",
"errors",
"[",
"]",
"error",
"\n",
"err",
":=",
"pkgPod",
".",
"WalkPods",
"(",
"getDataDir",
"(",
")",
",... | // getRunningImages will return the image IDs used to create any of the
// currently running pods | [
"getRunningImages",
"will",
"return",
"the",
"image",
"IDs",
"used",
"to",
"create",
"any",
"of",
"the",
"currently",
"running",
"pods"
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/rkt/image_gc.go#L167-L195 |
21,057 | rkt/rkt | stage0/run.go | deduplicateMPs | func deduplicateMPs(mounts []schema.Mount) []schema.Mount {
var res []schema.Mount
seen := make(map[string]struct{})
for _, m := range mounts {
cleanPath := path.Clean(m.Path)
if _, ok := seen[cleanPath]; !ok {
res = append(res, m)
seen[cleanPath] = struct{}{}
}
}
return res
} | go | func deduplicateMPs(mounts []schema.Mount) []schema.Mount {
var res []schema.Mount
seen := make(map[string]struct{})
for _, m := range mounts {
cleanPath := path.Clean(m.Path)
if _, ok := seen[cleanPath]; !ok {
res = append(res, m)
seen[cleanPath] = struct{}{}
}
}
return res
} | [
"func",
"deduplicateMPs",
"(",
"mounts",
"[",
"]",
"schema",
".",
"Mount",
")",
"[",
"]",
"schema",
".",
"Mount",
"{",
"var",
"res",
"[",
"]",
"schema",
".",
"Mount",
"\n",
"seen",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"struct",
"{",
"}",
... | // deduplicateMPs removes Mounts with duplicated paths. If there's more than
// one Mount with the same path, it keeps the first one encountered. | [
"deduplicateMPs",
"removes",
"Mounts",
"with",
"duplicated",
"paths",
".",
"If",
"there",
"s",
"more",
"than",
"one",
"Mount",
"with",
"the",
"same",
"path",
"it",
"keeps",
"the",
"first",
"one",
"encountered",
"."
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage0/run.go#L161-L172 |
21,058 | rkt/rkt | stage0/run.go | MergeMounts | func MergeMounts(mounts []schema.Mount, appMounts []schema.Mount) []schema.Mount {
ml := append(appMounts, mounts...)
return deduplicateMPs(ml)
} | go | func MergeMounts(mounts []schema.Mount, appMounts []schema.Mount) []schema.Mount {
ml := append(appMounts, mounts...)
return deduplicateMPs(ml)
} | [
"func",
"MergeMounts",
"(",
"mounts",
"[",
"]",
"schema",
".",
"Mount",
",",
"appMounts",
"[",
"]",
"schema",
".",
"Mount",
")",
"[",
"]",
"schema",
".",
"Mount",
"{",
"ml",
":=",
"append",
"(",
"appMounts",
",",
"mounts",
"...",
")",
"\n",
"return",... | // MergeMounts combines the global and per-app mount slices | [
"MergeMounts",
"combines",
"the",
"global",
"and",
"per",
"-",
"app",
"mount",
"slices"
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage0/run.go#L175-L178 |
21,059 | rkt/rkt | stage0/run.go | Prepare | func Prepare(cfg PrepareConfig, dir string, uuid *types.UUID) error {
if err := os.MkdirAll(common.AppsInfoPath(dir), common.DefaultRegularDirPerm); err != nil {
return errwrap.Wrap(errors.New("error creating apps info directory"), err)
}
debug("Preparing stage1")
if err := prepareStage1Image(cfg, dir); err != ni... | go | func Prepare(cfg PrepareConfig, dir string, uuid *types.UUID) error {
if err := os.MkdirAll(common.AppsInfoPath(dir), common.DefaultRegularDirPerm); err != nil {
return errwrap.Wrap(errors.New("error creating apps info directory"), err)
}
debug("Preparing stage1")
if err := prepareStage1Image(cfg, dir); err != ni... | [
"func",
"Prepare",
"(",
"cfg",
"PrepareConfig",
",",
"dir",
"string",
",",
"uuid",
"*",
"types",
".",
"UUID",
")",
"error",
"{",
"if",
"err",
":=",
"os",
".",
"MkdirAll",
"(",
"common",
".",
"AppsInfoPath",
"(",
"dir",
")",
",",
"common",
".",
"Defau... | // Prepare sets up a pod based on the given config. | [
"Prepare",
"sets",
"up",
"a",
"pod",
"based",
"on",
"the",
"given",
"config",
"."
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage0/run.go#L408-L468 |
21,060 | rkt/rkt | stage0/run.go | setupAppImage | func setupAppImage(cfg RunConfig, appName types.ACName, img types.Hash, cdir string, useOverlay bool) error {
ad := common.AppPath(cdir, appName)
if useOverlay {
err := os.MkdirAll(ad, common.DefaultRegularDirPerm)
if err != nil {
return errwrap.Wrap(errors.New("error creating image directory"), err)
}
tre... | go | func setupAppImage(cfg RunConfig, appName types.ACName, img types.Hash, cdir string, useOverlay bool) error {
ad := common.AppPath(cdir, appName)
if useOverlay {
err := os.MkdirAll(ad, common.DefaultRegularDirPerm)
if err != nil {
return errwrap.Wrap(errors.New("error creating image directory"), err)
}
tre... | [
"func",
"setupAppImage",
"(",
"cfg",
"RunConfig",
",",
"appName",
"types",
".",
"ACName",
",",
"img",
"types",
".",
"Hash",
",",
"cdir",
"string",
",",
"useOverlay",
"bool",
")",
"error",
"{",
"ad",
":=",
"common",
".",
"AppPath",
"(",
"cdir",
",",
"ap... | // setupAppImage mounts the overlay filesystem for the app image that
// corresponds to the given hash if useOverlay is true.
// It also creates an mtab file in the application's rootfs if one is not
// present. | [
"setupAppImage",
"mounts",
"the",
"overlay",
"filesystem",
"for",
"the",
"app",
"image",
"that",
"corresponds",
"to",
"the",
"given",
"hash",
"if",
"useOverlay",
"is",
"true",
".",
"It",
"also",
"creates",
"an",
"mtab",
"file",
"in",
"the",
"application",
"s... | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage0/run.go#L773-L792 |
21,061 | rkt/rkt | stage0/run.go | prepareStage1Image | func prepareStage1Image(cfg PrepareConfig, cdir string) error {
s1 := common.Stage1ImagePath(cdir)
if err := os.MkdirAll(s1, common.DefaultRegularDirPerm); err != nil {
return errwrap.Wrap(errors.New("error creating stage1 directory"), err)
}
treeStoreID, _, err := cfg.TreeStore.Render(cfg.Stage1Image.String(), ... | go | func prepareStage1Image(cfg PrepareConfig, cdir string) error {
s1 := common.Stage1ImagePath(cdir)
if err := os.MkdirAll(s1, common.DefaultRegularDirPerm); err != nil {
return errwrap.Wrap(errors.New("error creating stage1 directory"), err)
}
treeStoreID, _, err := cfg.TreeStore.Render(cfg.Stage1Image.String(), ... | [
"func",
"prepareStage1Image",
"(",
"cfg",
"PrepareConfig",
",",
"cdir",
"string",
")",
"error",
"{",
"s1",
":=",
"common",
".",
"Stage1ImagePath",
"(",
"cdir",
")",
"\n",
"if",
"err",
":=",
"os",
".",
"MkdirAll",
"(",
"s1",
",",
"common",
".",
"DefaultRe... | // prepareStage1Image renders and verifies tree cache of the given hash
// when using overlay.
// When useOverlay is false, it attempts to render and expand the stage1. | [
"prepareStage1Image",
"renders",
"and",
"verifies",
"tree",
"cache",
"of",
"the",
"given",
"hash",
"when",
"using",
"overlay",
".",
"When",
"useOverlay",
"is",
"false",
"it",
"attempts",
"to",
"render",
"and",
"expand",
"the",
"stage1",
"."
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage0/run.go#L830-L858 |
21,062 | rkt/rkt | stage0/run.go | setupStage1Image | func setupStage1Image(cfg RunConfig, cdir string, useOverlay bool) error {
s1 := common.Stage1ImagePath(cdir)
if useOverlay {
treeStoreID, err := ioutil.ReadFile(filepath.Join(cdir, common.Stage1TreeStoreIDFilename))
if err != nil {
return err
}
// pass an empty appName
if err := overlayRender(cfg, stri... | go | func setupStage1Image(cfg RunConfig, cdir string, useOverlay bool) error {
s1 := common.Stage1ImagePath(cdir)
if useOverlay {
treeStoreID, err := ioutil.ReadFile(filepath.Join(cdir, common.Stage1TreeStoreIDFilename))
if err != nil {
return err
}
// pass an empty appName
if err := overlayRender(cfg, stri... | [
"func",
"setupStage1Image",
"(",
"cfg",
"RunConfig",
",",
"cdir",
"string",
",",
"useOverlay",
"bool",
")",
"error",
"{",
"s1",
":=",
"common",
".",
"Stage1ImagePath",
"(",
"cdir",
")",
"\n",
"if",
"useOverlay",
"{",
"treeStoreID",
",",
"err",
":=",
"iouti... | // setupStage1Image mounts the overlay filesystem for stage1.
// When useOverlay is false it is a noop | [
"setupStage1Image",
"mounts",
"the",
"overlay",
"filesystem",
"for",
"stage1",
".",
"When",
"useOverlay",
"is",
"false",
"it",
"is",
"a",
"noop"
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage0/run.go#L862-L884 |
21,063 | rkt/rkt | stage0/run.go | writeManifest | func writeManifest(cfg CommonConfig, img types.Hash, dest string) error {
mb, err := cfg.Store.GetImageManifestJSON(img.String())
if err != nil {
return err
}
debug("Writing image manifest")
if err := ioutil.WriteFile(filepath.Join(dest, "manifest"), mb, common.DefaultRegularFilePerm); err != nil {
return err... | go | func writeManifest(cfg CommonConfig, img types.Hash, dest string) error {
mb, err := cfg.Store.GetImageManifestJSON(img.String())
if err != nil {
return err
}
debug("Writing image manifest")
if err := ioutil.WriteFile(filepath.Join(dest, "manifest"), mb, common.DefaultRegularFilePerm); err != nil {
return err... | [
"func",
"writeManifest",
"(",
"cfg",
"CommonConfig",
",",
"img",
"types",
".",
"Hash",
",",
"dest",
"string",
")",
"error",
"{",
"mb",
",",
"err",
":=",
"cfg",
".",
"Store",
".",
"GetImageManifestJSON",
"(",
"img",
".",
"String",
"(",
")",
")",
"\n",
... | // writeManifest takes an img ID and writes the corresponding manifest in dest | [
"writeManifest",
"takes",
"an",
"img",
"ID",
"and",
"writes",
"the",
"corresponding",
"manifest",
"in",
"dest"
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage0/run.go#L887-L899 |
21,064 | rkt/rkt | stage0/run.go | copyAppManifest | func copyAppManifest(cdir string, appName types.ACName, dest string) error {
appInfoDir := common.AppInfoPath(cdir, appName)
sourceFn := filepath.Join(appInfoDir, "manifest")
destFn := filepath.Join(dest, "manifest")
if err := fileutil.CopyRegularFile(sourceFn, destFn); err != nil {
return errwrap.Wrap(errors.New... | go | func copyAppManifest(cdir string, appName types.ACName, dest string) error {
appInfoDir := common.AppInfoPath(cdir, appName)
sourceFn := filepath.Join(appInfoDir, "manifest")
destFn := filepath.Join(dest, "manifest")
if err := fileutil.CopyRegularFile(sourceFn, destFn); err != nil {
return errwrap.Wrap(errors.New... | [
"func",
"copyAppManifest",
"(",
"cdir",
"string",
",",
"appName",
"types",
".",
"ACName",
",",
"dest",
"string",
")",
"error",
"{",
"appInfoDir",
":=",
"common",
".",
"AppInfoPath",
"(",
"cdir",
",",
"appName",
")",
"\n",
"sourceFn",
":=",
"filepath",
".",... | // copyAppManifest copies to saved image manifest for the given appName and
// writes it in the dest directory. | [
"copyAppManifest",
"copies",
"to",
"saved",
"image",
"manifest",
"for",
"the",
"given",
"appName",
"and",
"writes",
"it",
"in",
"the",
"dest",
"directory",
"."
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage0/run.go#L903-L911 |
21,065 | rkt/rkt | stage0/run.go | overlayRender | func overlayRender(cfg RunConfig, treeStoreID string, cdir string, dest string, appName string) error {
cachedTreePath := cfg.TreeStore.GetRootFS(treeStoreID)
mc, err := prepareOverlay(cachedTreePath, treeStoreID, cdir, dest, appName, cfg.MountLabel,
cfg.RktGid, common.DefaultRegularDirPerm)
if err != nil {
retu... | go | func overlayRender(cfg RunConfig, treeStoreID string, cdir string, dest string, appName string) error {
cachedTreePath := cfg.TreeStore.GetRootFS(treeStoreID)
mc, err := prepareOverlay(cachedTreePath, treeStoreID, cdir, dest, appName, cfg.MountLabel,
cfg.RktGid, common.DefaultRegularDirPerm)
if err != nil {
retu... | [
"func",
"overlayRender",
"(",
"cfg",
"RunConfig",
",",
"treeStoreID",
"string",
",",
"cdir",
"string",
",",
"dest",
"string",
",",
"appName",
"string",
")",
"error",
"{",
"cachedTreePath",
":=",
"cfg",
".",
"TreeStore",
".",
"GetRootFS",
"(",
"treeStoreID",
... | // overlayRender renders the image that corresponds to the given hash using the
// overlay filesystem. It mounts an overlay filesystem from the cached tree of
// the image as rootfs. | [
"overlayRender",
"renders",
"the",
"image",
"that",
"corresponds",
"to",
"the",
"given",
"hash",
"using",
"the",
"overlay",
"filesystem",
".",
"It",
"mounts",
"an",
"overlay",
"filesystem",
"from",
"the",
"cached",
"tree",
"of",
"the",
"image",
"as",
"rootfs",... | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage0/run.go#L916-L928 |
21,066 | rkt/rkt | stage0/run.go | prepareOverlay | func prepareOverlay(lower, treeStoreID, cdir, dest, appName, lbl string,
gid int, fm os.FileMode) (*overlay.MountCfg, error) {
fi, err := os.Stat(lower)
if err != nil {
return nil, err
}
imgMode := fi.Mode()
dst := path.Join(dest, "rootfs")
if err := os.MkdirAll(dst, imgMode); err != nil {
return nil, err
... | go | func prepareOverlay(lower, treeStoreID, cdir, dest, appName, lbl string,
gid int, fm os.FileMode) (*overlay.MountCfg, error) {
fi, err := os.Stat(lower)
if err != nil {
return nil, err
}
imgMode := fi.Mode()
dst := path.Join(dest, "rootfs")
if err := os.MkdirAll(dst, imgMode); err != nil {
return nil, err
... | [
"func",
"prepareOverlay",
"(",
"lower",
",",
"treeStoreID",
",",
"cdir",
",",
"dest",
",",
"appName",
",",
"lbl",
"string",
",",
"gid",
"int",
",",
"fm",
"os",
".",
"FileMode",
")",
"(",
"*",
"overlay",
".",
"MountCfg",
",",
"error",
")",
"{",
"fi",
... | // prepateOverlay sets up the needed directories, files and permissions for the
// overlay-rendered pods | [
"prepateOverlay",
"sets",
"up",
"the",
"needed",
"directories",
"files",
"and",
"permissions",
"for",
"the",
"overlay",
"-",
"rendered",
"pods"
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage0/run.go#L932-L987 |
21,067 | rkt/rkt | store/treestore/tree.go | NewStore | func NewStore(dir string, store *imagestore.Store) (*Store, error) {
// TODO(sgotti) backward compatibility with the current tree store paths. Needs a migration path to better paths.
ts := &Store{dir: filepath.Join(dir, "tree"), store: store}
ts.lockDir = filepath.Join(dir, "treestorelocks")
if err := os.MkdirAll(... | go | func NewStore(dir string, store *imagestore.Store) (*Store, error) {
// TODO(sgotti) backward compatibility with the current tree store paths. Needs a migration path to better paths.
ts := &Store{dir: filepath.Join(dir, "tree"), store: store}
ts.lockDir = filepath.Join(dir, "treestorelocks")
if err := os.MkdirAll(... | [
"func",
"NewStore",
"(",
"dir",
"string",
",",
"store",
"*",
"imagestore",
".",
"Store",
")",
"(",
"*",
"Store",
",",
"error",
")",
"{",
"// TODO(sgotti) backward compatibility with the current tree store paths. Needs a migration path to better paths.",
"ts",
":=",
"&",
... | // NewStore creates a Store for managing filesystem trees, including the dependency graph resolution of the underlying image layers. | [
"NewStore",
"creates",
"a",
"Store",
"for",
"managing",
"filesystem",
"trees",
"including",
"the",
"dependency",
"graph",
"resolution",
"of",
"the",
"underlying",
"image",
"layers",
"."
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/store/treestore/tree.go#L73-L82 |
21,068 | rkt/rkt | store/treestore/tree.go | GetID | func (ts *Store) GetID(key string) (string, error) {
hash, err := types.NewHash(key)
if err != nil {
return "", err
}
images, err := acirenderer.CreateDepListFromImageID(*hash, ts.store)
if err != nil {
return "", err
}
var keys []string
for _, image := range images {
keys = append(keys, image.Key)
}
i... | go | func (ts *Store) GetID(key string) (string, error) {
hash, err := types.NewHash(key)
if err != nil {
return "", err
}
images, err := acirenderer.CreateDepListFromImageID(*hash, ts.store)
if err != nil {
return "", err
}
var keys []string
for _, image := range images {
keys = append(keys, image.Key)
}
i... | [
"func",
"(",
"ts",
"*",
"Store",
")",
"GetID",
"(",
"key",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"hash",
",",
"err",
":=",
"types",
".",
"NewHash",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",... | // GetID calculates the treestore ID for the given image key.
// The treeStoreID is computed as an hash of the flattened dependency tree
// image keys. In this way the ID may change for the same key if the image's
// dependencies change. | [
"GetID",
"calculates",
"the",
"treestore",
"ID",
"for",
"the",
"given",
"image",
"key",
".",
"The",
"treeStoreID",
"is",
"computed",
"as",
"an",
"hash",
"of",
"the",
"flattened",
"dependency",
"tree",
"image",
"keys",
".",
"In",
"this",
"way",
"the",
"ID",... | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/store/treestore/tree.go#L88-L106 |
21,069 | rkt/rkt | store/treestore/tree.go | Render | func (ts *Store) Render(key string, rebuild bool) (id string, hash string, err error) {
id, err = ts.GetID(key)
if err != nil {
return "", "", errwrap.Wrap(errors.New("cannot calculate treestore id"), err)
}
// this lock references the treestore dir for the specified id.
treeStoreKeyLock, err := lock.ExclusiveK... | go | func (ts *Store) Render(key string, rebuild bool) (id string, hash string, err error) {
id, err = ts.GetID(key)
if err != nil {
return "", "", errwrap.Wrap(errors.New("cannot calculate treestore id"), err)
}
// this lock references the treestore dir for the specified id.
treeStoreKeyLock, err := lock.ExclusiveK... | [
"func",
"(",
"ts",
"*",
"Store",
")",
"Render",
"(",
"key",
"string",
",",
"rebuild",
"bool",
")",
"(",
"id",
"string",
",",
"hash",
"string",
",",
"err",
"error",
")",
"{",
"id",
",",
"err",
"=",
"ts",
".",
"GetID",
"(",
"key",
")",
"\n",
"if"... | // Render renders a treestore for the given image key if it's not
// already fully rendered.
// Users of treestore should call s.Render before using it to ensure
// that the treestore is completely rendered.
// Returns the id and hash of the rendered treestore if it is newly rendered,
// and only the id if it is alread... | [
"Render",
"renders",
"a",
"treestore",
"for",
"the",
"given",
"image",
"key",
"if",
"it",
"s",
"not",
"already",
"fully",
"rendered",
".",
"Users",
"of",
"treestore",
"should",
"call",
"s",
".",
"Render",
"before",
"using",
"it",
"to",
"ensure",
"that",
... | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/store/treestore/tree.go#L114-L147 |
21,070 | rkt/rkt | store/treestore/tree.go | Check | func (ts *Store) Check(id string) (string, error) {
treeStoreKeyLock, err := lock.SharedKeyLock(ts.lockDir, id)
if err != nil {
return "", errwrap.Wrap(errors.New("error locking tree store"), err)
}
defer treeStoreKeyLock.Close()
return ts.check(id)
} | go | func (ts *Store) Check(id string) (string, error) {
treeStoreKeyLock, err := lock.SharedKeyLock(ts.lockDir, id)
if err != nil {
return "", errwrap.Wrap(errors.New("error locking tree store"), err)
}
defer treeStoreKeyLock.Close()
return ts.check(id)
} | [
"func",
"(",
"ts",
"*",
"Store",
")",
"Check",
"(",
"id",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"treeStoreKeyLock",
",",
"err",
":=",
"lock",
".",
"SharedKeyLock",
"(",
"ts",
".",
"lockDir",
",",
"id",
")",
"\n",
"if",
"err",
"!=",
... | // Check verifies the treestore consistency for the specified id. | [
"Check",
"verifies",
"the",
"treestore",
"consistency",
"for",
"the",
"specified",
"id",
"."
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/store/treestore/tree.go#L150-L158 |
21,071 | rkt/rkt | store/treestore/tree.go | Remove | func (ts *Store) Remove(id string) error {
treeStoreKeyLock, err := lock.ExclusiveKeyLock(ts.lockDir, id)
if err != nil {
return errwrap.Wrap(errors.New("error locking tree store"), err)
}
defer treeStoreKeyLock.Close()
if err := ts.remove(id); err != nil {
return errwrap.Wrap(errors.New("error removing the t... | go | func (ts *Store) Remove(id string) error {
treeStoreKeyLock, err := lock.ExclusiveKeyLock(ts.lockDir, id)
if err != nil {
return errwrap.Wrap(errors.New("error locking tree store"), err)
}
defer treeStoreKeyLock.Close()
if err := ts.remove(id); err != nil {
return errwrap.Wrap(errors.New("error removing the t... | [
"func",
"(",
"ts",
"*",
"Store",
")",
"Remove",
"(",
"id",
"string",
")",
"error",
"{",
"treeStoreKeyLock",
",",
"err",
":=",
"lock",
".",
"ExclusiveKeyLock",
"(",
"ts",
".",
"lockDir",
",",
"id",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
... | // Remove removes the rendered image in tree store with the given id. | [
"Remove",
"removes",
"the",
"rendered",
"image",
"in",
"tree",
"store",
"with",
"the",
"given",
"id",
"."
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/store/treestore/tree.go#L161-L173 |
21,072 | rkt/rkt | store/treestore/tree.go | remove | func (ts *Store) remove(id string) error {
treepath := ts.GetPath(id)
// If tree path doesn't exist we're done
_, err := os.Stat(treepath)
if err != nil && os.IsNotExist(err) {
return nil
}
if err != nil {
return errwrap.Wrap(errors.New("failed to open tree store directory"), err)
}
renderedFilePath := fil... | go | func (ts *Store) remove(id string) error {
treepath := ts.GetPath(id)
// If tree path doesn't exist we're done
_, err := os.Stat(treepath)
if err != nil && os.IsNotExist(err) {
return nil
}
if err != nil {
return errwrap.Wrap(errors.New("failed to open tree store directory"), err)
}
renderedFilePath := fil... | [
"func",
"(",
"ts",
"*",
"Store",
")",
"remove",
"(",
"id",
"string",
")",
"error",
"{",
"treepath",
":=",
"ts",
".",
"GetPath",
"(",
"id",
")",
"\n",
"// If tree path doesn't exist we're done",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"treepath",
... | // remove cleans the directory for the provided id | [
"remove",
"cleans",
"the",
"directory",
"for",
"the",
"provided",
"id"
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/store/treestore/tree.go#L270-L316 |
21,073 | rkt/rkt | store/treestore/tree.go | IsRendered | func (ts *Store) IsRendered(id string) (bool, error) {
// if the "rendered" flag file exists, assume that the store is already
// fully rendered.
treepath := ts.GetPath(id)
_, err := os.Stat(filepath.Join(treepath, renderedfilename))
if os.IsNotExist(err) {
return false, nil
}
if err != nil {
return false, e... | go | func (ts *Store) IsRendered(id string) (bool, error) {
// if the "rendered" flag file exists, assume that the store is already
// fully rendered.
treepath := ts.GetPath(id)
_, err := os.Stat(filepath.Join(treepath, renderedfilename))
if os.IsNotExist(err) {
return false, nil
}
if err != nil {
return false, e... | [
"func",
"(",
"ts",
"*",
"Store",
")",
"IsRendered",
"(",
"id",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"// if the \"rendered\" flag file exists, assume that the store is already",
"// fully rendered.",
"treepath",
":=",
"ts",
".",
"GetPath",
"(",
"id",
... | // IsRendered checks if the tree store with the provided id is fully rendered | [
"IsRendered",
"checks",
"if",
"the",
"tree",
"store",
"with",
"the",
"provided",
"id",
"is",
"fully",
"rendered"
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/store/treestore/tree.go#L319-L331 |
21,074 | rkt/rkt | store/treestore/tree.go | Hash | func (ts *Store) Hash(id string) (string, error) {
treepath := ts.GetPath(id)
hash := sha512.New()
iw := newHashWriter(hash)
err := filepath.Walk(treepath, buildWalker(treepath, iw))
if err != nil {
return "", errwrap.Wrap(errors.New("error walking rootfs"), err)
}
hashstring := hashToKey(hash)
return hash... | go | func (ts *Store) Hash(id string) (string, error) {
treepath := ts.GetPath(id)
hash := sha512.New()
iw := newHashWriter(hash)
err := filepath.Walk(treepath, buildWalker(treepath, iw))
if err != nil {
return "", errwrap.Wrap(errors.New("error walking rootfs"), err)
}
hashstring := hashToKey(hash)
return hash... | [
"func",
"(",
"ts",
"*",
"Store",
")",
"Hash",
"(",
"id",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"treepath",
":=",
"ts",
".",
"GetPath",
"(",
"id",
")",
"\n\n",
"hash",
":=",
"sha512",
".",
"New",
"(",
")",
"\n",
"iw",
":=",
"newH... | // Hash calculates an hash of the rendered ACI. It uses the same functions
// used to create a tar but instead of writing the full archive is just
// computes the sha512 sum of the file infos and contents. | [
"Hash",
"calculates",
"an",
"hash",
"of",
"the",
"rendered",
"ACI",
".",
"It",
"uses",
"the",
"same",
"functions",
"used",
"to",
"create",
"a",
"tar",
"but",
"instead",
"of",
"writing",
"the",
"full",
"archive",
"is",
"just",
"computes",
"the",
"sha512",
... | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/store/treestore/tree.go#L350-L363 |
21,075 | rkt/rkt | store/treestore/tree.go | check | func (ts *Store) check(id string) (string, error) {
treepath := ts.GetPath(id)
hash, err := ioutil.ReadFile(filepath.Join(treepath, hashfilename))
if err != nil {
return "", errwrap.Wrap(ErrReadHashfile, err)
}
curhash, err := ts.Hash(id)
if err != nil {
return "", errwrap.Wrap(errors.New("cannot calculate tr... | go | func (ts *Store) check(id string) (string, error) {
treepath := ts.GetPath(id)
hash, err := ioutil.ReadFile(filepath.Join(treepath, hashfilename))
if err != nil {
return "", errwrap.Wrap(ErrReadHashfile, err)
}
curhash, err := ts.Hash(id)
if err != nil {
return "", errwrap.Wrap(errors.New("cannot calculate tr... | [
"func",
"(",
"ts",
"*",
"Store",
")",
"check",
"(",
"id",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"treepath",
":=",
"ts",
".",
"GetPath",
"(",
"id",
")",
"\n",
"hash",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"filepath",
".... | // check calculates the actual rendered ACI's hash and verifies that it matches
// the saved value. Returns the calculated hash. | [
"check",
"calculates",
"the",
"actual",
"rendered",
"ACI",
"s",
"hash",
"and",
"verifies",
"that",
"it",
"matches",
"the",
"saved",
"value",
".",
"Returns",
"the",
"calculated",
"hash",
"."
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/store/treestore/tree.go#L367-L381 |
21,076 | rkt/rkt | store/treestore/tree.go | Size | func (ts *Store) Size(id string) (int64, error) {
sz, err := fileutil.DirSize(ts.GetPath(id))
if err != nil {
return -1, errwrap.Wrap(errors.New("error calculating size"), err)
}
return sz, nil
} | go | func (ts *Store) Size(id string) (int64, error) {
sz, err := fileutil.DirSize(ts.GetPath(id))
if err != nil {
return -1, errwrap.Wrap(errors.New("error calculating size"), err)
}
return sz, nil
} | [
"func",
"(",
"ts",
"*",
"Store",
")",
"Size",
"(",
"id",
"string",
")",
"(",
"int64",
",",
"error",
")",
"{",
"sz",
",",
"err",
":=",
"fileutil",
".",
"DirSize",
"(",
"ts",
".",
"GetPath",
"(",
"id",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
... | // Size returns the size of the rootfs for the provided id. It is a relatively
// expensive operation, it goes through all the files and adds up their size. | [
"Size",
"returns",
"the",
"size",
"of",
"the",
"rootfs",
"for",
"the",
"provided",
"id",
".",
"It",
"is",
"a",
"relatively",
"expensive",
"operation",
"it",
"goes",
"through",
"all",
"the",
"files",
"and",
"adds",
"up",
"their",
"size",
"."
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/store/treestore/tree.go#L385-L391 |
21,077 | rkt/rkt | store/treestore/tree.go | GetImageHash | func (ts *Store) GetImageHash(id string) (string, error) {
treepath := ts.GetPath(id)
imgHash, err := ioutil.ReadFile(filepath.Join(treepath, imagefilename))
if err != nil {
return "", errwrap.Wrap(errors.New("cannot read image file"), err)
}
return string(imgHash), nil
} | go | func (ts *Store) GetImageHash(id string) (string, error) {
treepath := ts.GetPath(id)
imgHash, err := ioutil.ReadFile(filepath.Join(treepath, imagefilename))
if err != nil {
return "", errwrap.Wrap(errors.New("cannot read image file"), err)
}
return string(imgHash), nil
} | [
"func",
"(",
"ts",
"*",
"Store",
")",
"GetImageHash",
"(",
"id",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"treepath",
":=",
"ts",
".",
"GetPath",
"(",
"id",
")",
"\n\n",
"imgHash",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"fil... | // GetImageHash returns the hash of the image that uses the tree store
// identified by id. | [
"GetImageHash",
"returns",
"the",
"hash",
"of",
"the",
"image",
"that",
"uses",
"the",
"tree",
"store",
"identified",
"by",
"id",
"."
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/store/treestore/tree.go#L395-L404 |
21,078 | rkt/rkt | pkg/mountinfo/mountinfo.go | HasPrefix | func HasPrefix(p string) FilterFunc {
return FilterFunc(func(m *Mount) bool {
return strings.HasPrefix(m.MountPoint, p)
})
} | go | func HasPrefix(p string) FilterFunc {
return FilterFunc(func(m *Mount) bool {
return strings.HasPrefix(m.MountPoint, p)
})
} | [
"func",
"HasPrefix",
"(",
"p",
"string",
")",
"FilterFunc",
"{",
"return",
"FilterFunc",
"(",
"func",
"(",
"m",
"*",
"Mount",
")",
"bool",
"{",
"return",
"strings",
".",
"HasPrefix",
"(",
"m",
".",
"MountPoint",
",",
"p",
")",
"\n",
"}",
")",
"\n",
... | // HasPrefix returns a FilterFunc which returns true if
// the mountpoint of a given mount has prefix p, else false. | [
"HasPrefix",
"returns",
"a",
"FilterFunc",
"which",
"returns",
"true",
"if",
"the",
"mountpoint",
"of",
"a",
"given",
"mount",
"has",
"prefix",
"p",
"else",
"false",
"."
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/mountinfo/mountinfo.go#L32-L36 |
21,079 | rkt/rkt | pkg/mountinfo/mountinfo.go | ParseMounts | func ParseMounts(pid uint) (Mounts, error) {
var procPath string
if pid == 0 {
procPath = "/proc/self/mountinfo"
} else {
procPath = fmt.Sprintf("/proc/%d/mountinfo", pid)
}
mi, err := os.Open(procPath)
if err != nil {
return nil, err
}
defer mi.Close()
return parseMountinfo(mi)
} | go | func ParseMounts(pid uint) (Mounts, error) {
var procPath string
if pid == 0 {
procPath = "/proc/self/mountinfo"
} else {
procPath = fmt.Sprintf("/proc/%d/mountinfo", pid)
}
mi, err := os.Open(procPath)
if err != nil {
return nil, err
}
defer mi.Close()
return parseMountinfo(mi)
} | [
"func",
"ParseMounts",
"(",
"pid",
"uint",
")",
"(",
"Mounts",
",",
"error",
")",
"{",
"var",
"procPath",
"string",
"\n",
"if",
"pid",
"==",
"0",
"{",
"procPath",
"=",
"\"",
"\"",
"\n",
"}",
"else",
"{",
"procPath",
"=",
"fmt",
".",
"Sprintf",
"(",... | // ParseMounts returns all mountpoints associated with a process mount namespace.
// The special value 0 as pid argument is used to specify the current process. | [
"ParseMounts",
"returns",
"all",
"mountpoints",
"associated",
"with",
"a",
"process",
"mount",
"namespace",
".",
"The",
"special",
"value",
"0",
"as",
"pid",
"argument",
"is",
"used",
"to",
"specify",
"the",
"current",
"process",
"."
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/pkg/mountinfo/mountinfo.go#L40-L55 |
21,080 | rkt/rkt | stage1/init/kvm/resources.go | findResources | func findResources(isolators types.Isolators) (mem, cpus int64) {
for _, i := range isolators {
switch v := i.Value().(type) {
case *types.ResourceMemory:
mem = v.Limit().Value()
// Convert bytes into megabytes
mem /= 1024 * 1024
case *types.ResourceCPU:
cpus = v.Limit().Value()
}
}
return mem, c... | go | func findResources(isolators types.Isolators) (mem, cpus int64) {
for _, i := range isolators {
switch v := i.Value().(type) {
case *types.ResourceMemory:
mem = v.Limit().Value()
// Convert bytes into megabytes
mem /= 1024 * 1024
case *types.ResourceCPU:
cpus = v.Limit().Value()
}
}
return mem, c... | [
"func",
"findResources",
"(",
"isolators",
"types",
".",
"Isolators",
")",
"(",
"mem",
",",
"cpus",
"int64",
")",
"{",
"for",
"_",
",",
"i",
":=",
"range",
"isolators",
"{",
"switch",
"v",
":=",
"i",
".",
"Value",
"(",
")",
".",
"(",
"type",
")",
... | // findResources finds value of last isolator for particular type. | [
"findResources",
"finds",
"value",
"of",
"last",
"isolator",
"for",
"particular",
"type",
"."
] | 0c8765619cae3391a9ffa12c8dbd12ba7a475eb8 | https://github.com/rkt/rkt/blob/0c8765619cae3391a9ffa12c8dbd12ba7a475eb8/stage1/init/kvm/resources.go#L42-L54 |
21,081 | go-playground/validator | struct_level.go | wrapStructLevelFunc | func wrapStructLevelFunc(fn StructLevelFunc) StructLevelFuncCtx {
return func(ctx context.Context, sl StructLevel) {
fn(sl)
}
} | go | func wrapStructLevelFunc(fn StructLevelFunc) StructLevelFuncCtx {
return func(ctx context.Context, sl StructLevel) {
fn(sl)
}
} | [
"func",
"wrapStructLevelFunc",
"(",
"fn",
"StructLevelFunc",
")",
"StructLevelFuncCtx",
"{",
"return",
"func",
"(",
"ctx",
"context",
".",
"Context",
",",
"sl",
"StructLevel",
")",
"{",
"fn",
"(",
"sl",
")",
"\n",
"}",
"\n",
"}"
] | // wrapStructLevelFunc wraps normal StructLevelFunc makes it compatible with StructLevelFuncCtx | [
"wrapStructLevelFunc",
"wraps",
"normal",
"StructLevelFunc",
"makes",
"it",
"compatible",
"with",
"StructLevelFuncCtx"
] | e25e66164b537d7b3161dfede38466880534e783 | https://github.com/go-playground/validator/blob/e25e66164b537d7b3161dfede38466880534e783/struct_level.go#L16-L20 |
21,082 | go-playground/validator | struct_level.go | ExtractType | func (v *validate) ExtractType(field reflect.Value) (reflect.Value, reflect.Kind, bool) {
return v.extractTypeInternal(field, false)
} | go | func (v *validate) ExtractType(field reflect.Value) (reflect.Value, reflect.Kind, bool) {
return v.extractTypeInternal(field, false)
} | [
"func",
"(",
"v",
"*",
"validate",
")",
"ExtractType",
"(",
"field",
"reflect",
".",
"Value",
")",
"(",
"reflect",
".",
"Value",
",",
"reflect",
".",
"Kind",
",",
"bool",
")",
"{",
"return",
"v",
".",
"extractTypeInternal",
"(",
"field",
",",
"false",
... | // ExtractType gets the actual underlying type of field value. | [
"ExtractType",
"gets",
"the",
"actual",
"underlying",
"type",
"of",
"field",
"value",
"."
] | e25e66164b537d7b3161dfede38466880534e783 | https://github.com/go-playground/validator/blob/e25e66164b537d7b3161dfede38466880534e783/struct_level.go#L104-L106 |
21,083 | go-playground/validator | struct_level.go | ReportError | func (v *validate) ReportError(field interface{}, fieldName, structFieldName, tag, param string) {
fv, kind, _ := v.extractTypeInternal(reflect.ValueOf(field), false)
if len(structFieldName) == 0 {
structFieldName = fieldName
}
v.str1 = string(append(v.ns, fieldName...))
if v.v.hasTagNameFunc || fieldName !=... | go | func (v *validate) ReportError(field interface{}, fieldName, structFieldName, tag, param string) {
fv, kind, _ := v.extractTypeInternal(reflect.ValueOf(field), false)
if len(structFieldName) == 0 {
structFieldName = fieldName
}
v.str1 = string(append(v.ns, fieldName...))
if v.v.hasTagNameFunc || fieldName !=... | [
"func",
"(",
"v",
"*",
"validate",
")",
"ReportError",
"(",
"field",
"interface",
"{",
"}",
",",
"fieldName",
",",
"structFieldName",
",",
"tag",
",",
"param",
"string",
")",
"{",
"fv",
",",
"kind",
",",
"_",
":=",
"v",
".",
"extractTypeInternal",
"(",... | // ReportError reports an error just by passing the field and tag information | [
"ReportError",
"reports",
"an",
"error",
"just",
"by",
"passing",
"the",
"field",
"and",
"tag",
"information"
] | e25e66164b537d7b3161dfede38466880534e783 | https://github.com/go-playground/validator/blob/e25e66164b537d7b3161dfede38466880534e783/struct_level.go#L109-L158 |
21,084 | go-playground/validator | _examples/custom/main.go | ValidateValuer | func ValidateValuer(field reflect.Value) interface{} {
if valuer, ok := field.Interface().(driver.Valuer); ok {
val, err := valuer.Value()
if err == nil {
return val
}
// handle the error how you want
}
return nil
} | go | func ValidateValuer(field reflect.Value) interface{} {
if valuer, ok := field.Interface().(driver.Valuer); ok {
val, err := valuer.Value()
if err == nil {
return val
}
// handle the error how you want
}
return nil
} | [
"func",
"ValidateValuer",
"(",
"field",
"reflect",
".",
"Value",
")",
"interface",
"{",
"}",
"{",
"if",
"valuer",
",",
"ok",
":=",
"field",
".",
"Interface",
"(",
")",
".",
"(",
"driver",
".",
"Valuer",
")",
";",
"ok",
"{",
"val",
",",
"err",
":=",... | // ValidateValuer implements validator.CustomTypeFunc | [
"ValidateValuer",
"implements",
"validator",
".",
"CustomTypeFunc"
] | e25e66164b537d7b3161dfede38466880534e783 | https://github.com/go-playground/validator/blob/e25e66164b537d7b3161dfede38466880534e783/_examples/custom/main.go#L39-L51 |
21,085 | go-playground/validator | errors.go | Error | func (e *InvalidValidationError) Error() string {
if e.Type == nil {
return "validator: (nil)"
}
return "validator: (nil " + e.Type.String() + ")"
} | go | func (e *InvalidValidationError) Error() string {
if e.Type == nil {
return "validator: (nil)"
}
return "validator: (nil " + e.Type.String() + ")"
} | [
"func",
"(",
"e",
"*",
"InvalidValidationError",
")",
"Error",
"(",
")",
"string",
"{",
"if",
"e",
".",
"Type",
"==",
"nil",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n\n",
"return",
"\"",
"\"",
"+",
"e",
".",
"Type",
".",
"String",
"(",
")",
"+",
... | // Error returns InvalidValidationError message | [
"Error",
"returns",
"InvalidValidationError",
"message"
] | e25e66164b537d7b3161dfede38466880534e783 | https://github.com/go-playground/validator/blob/e25e66164b537d7b3161dfede38466880534e783/errors.go#L26-L33 |
21,086 | go-playground/validator | errors.go | Error | func (ve ValidationErrors) Error() string {
buff := bytes.NewBufferString("")
var fe *fieldError
for i := 0; i < len(ve); i++ {
fe = ve[i].(*fieldError)
buff.WriteString(fe.Error())
buff.WriteString("\n")
}
return strings.TrimSpace(buff.String())
} | go | func (ve ValidationErrors) Error() string {
buff := bytes.NewBufferString("")
var fe *fieldError
for i := 0; i < len(ve); i++ {
fe = ve[i].(*fieldError)
buff.WriteString(fe.Error())
buff.WriteString("\n")
}
return strings.TrimSpace(buff.String())
} | [
"func",
"(",
"ve",
"ValidationErrors",
")",
"Error",
"(",
")",
"string",
"{",
"buff",
":=",
"bytes",
".",
"NewBufferString",
"(",
"\"",
"\"",
")",
"\n\n",
"var",
"fe",
"*",
"fieldError",
"\n\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"ve... | // Error is intended for use in development + debugging and not intended to be a production error message.
// It allows ValidationErrors to subscribe to the Error interface.
// All information to create an error message specific to your application is contained within
// the FieldError found within the ValidationErrors... | [
"Error",
"is",
"intended",
"for",
"use",
"in",
"development",
"+",
"debugging",
"and",
"not",
"intended",
"to",
"be",
"a",
"production",
"error",
"message",
".",
"It",
"allows",
"ValidationErrors",
"to",
"subscribe",
"to",
"the",
"Error",
"interface",
".",
"... | e25e66164b537d7b3161dfede38466880534e783 | https://github.com/go-playground/validator/blob/e25e66164b537d7b3161dfede38466880534e783/errors.go#L43-L57 |
21,087 | go-playground/validator | errors.go | Translate | func (ve ValidationErrors) Translate(ut ut.Translator) ValidationErrorsTranslations {
trans := make(ValidationErrorsTranslations)
var fe *fieldError
for i := 0; i < len(ve); i++ {
fe = ve[i].(*fieldError)
// // in case an Anonymous struct was used, ensure that the key
// // would be 'Username' instead of "... | go | func (ve ValidationErrors) Translate(ut ut.Translator) ValidationErrorsTranslations {
trans := make(ValidationErrorsTranslations)
var fe *fieldError
for i := 0; i < len(ve); i++ {
fe = ve[i].(*fieldError)
// // in case an Anonymous struct was used, ensure that the key
// // would be 'Username' instead of "... | [
"func",
"(",
"ve",
"ValidationErrors",
")",
"Translate",
"(",
"ut",
"ut",
".",
"Translator",
")",
"ValidationErrorsTranslations",
"{",
"trans",
":=",
"make",
"(",
"ValidationErrorsTranslations",
")",
"\n\n",
"var",
"fe",
"*",
"fieldError",
"\n\n",
"for",
"i",
... | // Translate translates all of the ValidationErrors | [
"Translate",
"translates",
"all",
"of",
"the",
"ValidationErrors"
] | e25e66164b537d7b3161dfede38466880534e783 | https://github.com/go-playground/validator/blob/e25e66164b537d7b3161dfede38466880534e783/errors.go#L60-L80 |
21,088 | go-playground/validator | errors.go | Field | func (fe *fieldError) Field() string {
return fe.ns[len(fe.ns)-int(fe.fieldLen):]
// // return fe.field
// fld := fe.ns[len(fe.ns)-int(fe.fieldLen):]
// log.Println("FLD:", fld)
// if len(fld) > 0 && fld[:1] == "." {
// return fld[1:]
// }
// return fld
} | go | func (fe *fieldError) Field() string {
return fe.ns[len(fe.ns)-int(fe.fieldLen):]
// // return fe.field
// fld := fe.ns[len(fe.ns)-int(fe.fieldLen):]
// log.Println("FLD:", fld)
// if len(fld) > 0 && fld[:1] == "." {
// return fld[1:]
// }
// return fld
} | [
"func",
"(",
"fe",
"*",
"fieldError",
")",
"Field",
"(",
")",
"string",
"{",
"return",
"fe",
".",
"ns",
"[",
"len",
"(",
"fe",
".",
"ns",
")",
"-",
"int",
"(",
"fe",
".",
"fieldLen",
")",
":",
"]",
"\n",
"// // return fe.field",
"// fld := fe.ns[len(... | // Field returns the fields name with the tag name taking precedence over the
// fields actual name. | [
"Field",
"returns",
"the",
"fields",
"name",
"with",
"the",
"tag",
"name",
"taking",
"precedence",
"over",
"the",
"fields",
"actual",
"name",
"."
] | e25e66164b537d7b3161dfede38466880534e783 | https://github.com/go-playground/validator/blob/e25e66164b537d7b3161dfede38466880534e783/errors.go#L206-L219 |
21,089 | go-playground/validator | errors.go | StructField | func (fe *fieldError) StructField() string {
// return fe.structField
return fe.structNs[len(fe.structNs)-int(fe.structfieldLen):]
} | go | func (fe *fieldError) StructField() string {
// return fe.structField
return fe.structNs[len(fe.structNs)-int(fe.structfieldLen):]
} | [
"func",
"(",
"fe",
"*",
"fieldError",
")",
"StructField",
"(",
")",
"string",
"{",
"// return fe.structField",
"return",
"fe",
".",
"structNs",
"[",
"len",
"(",
"fe",
".",
"structNs",
")",
"-",
"int",
"(",
"fe",
".",
"structfieldLen",
")",
":",
"]",
"\... | // returns the fields actual name from the struct, when able to determine. | [
"returns",
"the",
"fields",
"actual",
"name",
"from",
"the",
"struct",
"when",
"able",
"to",
"determine",
"."
] | e25e66164b537d7b3161dfede38466880534e783 | https://github.com/go-playground/validator/blob/e25e66164b537d7b3161dfede38466880534e783/errors.go#L222-L225 |
21,090 | go-playground/validator | errors.go | Error | func (fe *fieldError) Error() string {
return fmt.Sprintf(fieldErrMsg, fe.ns, fe.Field(), fe.tag)
} | go | func (fe *fieldError) Error() string {
return fmt.Sprintf(fieldErrMsg, fe.ns, fe.Field(), fe.tag)
} | [
"func",
"(",
"fe",
"*",
"fieldError",
")",
"Error",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"fieldErrMsg",
",",
"fe",
".",
"ns",
",",
"fe",
".",
"Field",
"(",
")",
",",
"fe",
".",
"tag",
")",
"\n",
"}"
] | // Error returns the fieldError's error message | [
"Error",
"returns",
"the",
"fieldError",
"s",
"error",
"message"
] | e25e66164b537d7b3161dfede38466880534e783 | https://github.com/go-playground/validator/blob/e25e66164b537d7b3161dfede38466880534e783/errors.go#L250-L252 |
21,091 | go-playground/validator | non-standard/validators/notblank.go | NotBlank | func NotBlank(fl validator.FieldLevel) bool {
field := fl.Field()
switch field.Kind() {
case reflect.String:
return len(strings.TrimSpace(field.String())) > 0
case reflect.Chan, reflect.Map, reflect.Slice, reflect.Array:
return field.Len() > 0
case reflect.Ptr, reflect.Interface, reflect.Func:
return !field... | go | func NotBlank(fl validator.FieldLevel) bool {
field := fl.Field()
switch field.Kind() {
case reflect.String:
return len(strings.TrimSpace(field.String())) > 0
case reflect.Chan, reflect.Map, reflect.Slice, reflect.Array:
return field.Len() > 0
case reflect.Ptr, reflect.Interface, reflect.Func:
return !field... | [
"func",
"NotBlank",
"(",
"fl",
"validator",
".",
"FieldLevel",
")",
"bool",
"{",
"field",
":=",
"fl",
".",
"Field",
"(",
")",
"\n\n",
"switch",
"field",
".",
"Kind",
"(",
")",
"{",
"case",
"reflect",
".",
"String",
":",
"return",
"len",
"(",
"strings... | // NotBlank is the validation function for validating if the current field
// has a value or length greater than zero, or is not a space only string. | [
"NotBlank",
"is",
"the",
"validation",
"function",
"for",
"validating",
"if",
"the",
"current",
"field",
"has",
"a",
"value",
"or",
"length",
"greater",
"than",
"zero",
"or",
"is",
"not",
"a",
"space",
"only",
"string",
"."
] | e25e66164b537d7b3161dfede38466880534e783 | https://github.com/go-playground/validator/blob/e25e66164b537d7b3161dfede38466880534e783/non-standard/validators/notblank.go#L12-L25 |
21,092 | go-playground/validator | baked_in.go | wrapFunc | func wrapFunc(fn Func) FuncCtx {
if fn == nil {
return nil // be sure not to wrap a bad function.
}
return func(ctx context.Context, fl FieldLevel) bool {
return fn(fl)
}
} | go | func wrapFunc(fn Func) FuncCtx {
if fn == nil {
return nil // be sure not to wrap a bad function.
}
return func(ctx context.Context, fl FieldLevel) bool {
return fn(fl)
}
} | [
"func",
"wrapFunc",
"(",
"fn",
"Func",
")",
"FuncCtx",
"{",
"if",
"fn",
"==",
"nil",
"{",
"return",
"nil",
"// be sure not to wrap a bad function.",
"\n",
"}",
"\n",
"return",
"func",
"(",
"ctx",
"context",
".",
"Context",
",",
"fl",
"FieldLevel",
")",
"bo... | // wrapFunc wraps noramal Func makes it compatible with FuncCtx | [
"wrapFunc",
"wraps",
"noramal",
"Func",
"makes",
"it",
"compatible",
"with",
"FuncCtx"
] | e25e66164b537d7b3161dfede38466880534e783 | https://github.com/go-playground/validator/blob/e25e66164b537d7b3161dfede38466880534e783/baked_in.go#L30-L37 |
21,093 | go-playground/validator | baked_in.go | isUnique | func isUnique(fl FieldLevel) bool {
field := fl.Field()
v := reflect.ValueOf(struct{}{})
switch field.Kind() {
case reflect.Slice, reflect.Array:
m := reflect.MakeMap(reflect.MapOf(field.Type().Elem(), v.Type()))
for i := 0; i < field.Len(); i++ {
m.SetMapIndex(field.Index(i), v)
}
return field.Len() ... | go | func isUnique(fl FieldLevel) bool {
field := fl.Field()
v := reflect.ValueOf(struct{}{})
switch field.Kind() {
case reflect.Slice, reflect.Array:
m := reflect.MakeMap(reflect.MapOf(field.Type().Elem(), v.Type()))
for i := 0; i < field.Len(); i++ {
m.SetMapIndex(field.Index(i), v)
}
return field.Len() ... | [
"func",
"isUnique",
"(",
"fl",
"FieldLevel",
")",
"bool",
"{",
"field",
":=",
"fl",
".",
"Field",
"(",
")",
"\n",
"v",
":=",
"reflect",
".",
"ValueOf",
"(",
"struct",
"{",
"}",
"{",
"}",
")",
"\n\n",
"switch",
"field",
".",
"Kind",
"(",
")",
"{",... | // isUnique is the validation function for validating if each array|slice|map value is unique | [
"isUnique",
"is",
"the",
"validation",
"function",
"for",
"validating",
"if",
"each",
"array|slice|map",
"value",
"is",
"unique"
] | e25e66164b537d7b3161dfede38466880534e783 | https://github.com/go-playground/validator/blob/e25e66164b537d7b3161dfede38466880534e783/baked_in.go#L220-L243 |
21,094 | go-playground/validator | baked_in.go | isMAC | func isMAC(fl FieldLevel) bool {
_, err := net.ParseMAC(fl.Field().String())
return err == nil
} | go | func isMAC(fl FieldLevel) bool {
_, err := net.ParseMAC(fl.Field().String())
return err == nil
} | [
"func",
"isMAC",
"(",
"fl",
"FieldLevel",
")",
"bool",
"{",
"_",
",",
"err",
":=",
"net",
".",
"ParseMAC",
"(",
"fl",
".",
"Field",
"(",
")",
".",
"String",
"(",
")",
")",
"\n\n",
"return",
"err",
"==",
"nil",
"\n",
"}"
] | // IsMAC is the validation function for validating if the field's value is a valid MAC address. | [
"IsMAC",
"is",
"the",
"validation",
"function",
"for",
"validating",
"if",
"the",
"field",
"s",
"value",
"is",
"a",
"valid",
"MAC",
"address",
"."
] | e25e66164b537d7b3161dfede38466880534e783 | https://github.com/go-playground/validator/blob/e25e66164b537d7b3161dfede38466880534e783/baked_in.go#L246-L251 |
21,095 | go-playground/validator | baked_in.go | isCIDRv4 | func isCIDRv4(fl FieldLevel) bool {
ip, _, err := net.ParseCIDR(fl.Field().String())
return err == nil && ip.To4() != nil
} | go | func isCIDRv4(fl FieldLevel) bool {
ip, _, err := net.ParseCIDR(fl.Field().String())
return err == nil && ip.To4() != nil
} | [
"func",
"isCIDRv4",
"(",
"fl",
"FieldLevel",
")",
"bool",
"{",
"ip",
",",
"_",
",",
"err",
":=",
"net",
".",
"ParseCIDR",
"(",
"fl",
".",
"Field",
"(",
")",
".",
"String",
"(",
")",
")",
"\n\n",
"return",
"err",
"==",
"nil",
"&&",
"ip",
".",
"T... | // IsCIDRv4 is the validation function for validating if the field's value is a valid v4 CIDR address. | [
"IsCIDRv4",
"is",
"the",
"validation",
"function",
"for",
"validating",
"if",
"the",
"field",
"s",
"value",
"is",
"a",
"valid",
"v4",
"CIDR",
"address",
"."
] | e25e66164b537d7b3161dfede38466880534e783 | https://github.com/go-playground/validator/blob/e25e66164b537d7b3161dfede38466880534e783/baked_in.go#L254-L259 |
21,096 | go-playground/validator | baked_in.go | isCIDR | func isCIDR(fl FieldLevel) bool {
_, _, err := net.ParseCIDR(fl.Field().String())
return err == nil
} | go | func isCIDR(fl FieldLevel) bool {
_, _, err := net.ParseCIDR(fl.Field().String())
return err == nil
} | [
"func",
"isCIDR",
"(",
"fl",
"FieldLevel",
")",
"bool",
"{",
"_",
",",
"_",
",",
"err",
":=",
"net",
".",
"ParseCIDR",
"(",
"fl",
".",
"Field",
"(",
")",
".",
"String",
"(",
")",
")",
"\n\n",
"return",
"err",
"==",
"nil",
"\n",
"}"
] | // IsCIDR is the validation function for validating if the field's value is a valid v4 or v6 CIDR address. | [
"IsCIDR",
"is",
"the",
"validation",
"function",
"for",
"validating",
"if",
"the",
"field",
"s",
"value",
"is",
"a",
"valid",
"v4",
"or",
"v6",
"CIDR",
"address",
"."
] | e25e66164b537d7b3161dfede38466880534e783 | https://github.com/go-playground/validator/blob/e25e66164b537d7b3161dfede38466880534e783/baked_in.go#L270-L275 |
21,097 | go-playground/validator | baked_in.go | isIPv6 | func isIPv6(fl FieldLevel) bool {
ip := net.ParseIP(fl.Field().String())
return ip != nil && ip.To4() == nil
} | go | func isIPv6(fl FieldLevel) bool {
ip := net.ParseIP(fl.Field().String())
return ip != nil && ip.To4() == nil
} | [
"func",
"isIPv6",
"(",
"fl",
"FieldLevel",
")",
"bool",
"{",
"ip",
":=",
"net",
".",
"ParseIP",
"(",
"fl",
".",
"Field",
"(",
")",
".",
"String",
"(",
")",
")",
"\n\n",
"return",
"ip",
"!=",
"nil",
"&&",
"ip",
".",
"To4",
"(",
")",
"==",
"nil",... | // IsIPv6 is the validation function for validating if the field's value is a valid v6 IP address. | [
"IsIPv6",
"is",
"the",
"validation",
"function",
"for",
"validating",
"if",
"the",
"field",
"s",
"value",
"is",
"a",
"valid",
"v6",
"IP",
"address",
"."
] | e25e66164b537d7b3161dfede38466880534e783 | https://github.com/go-playground/validator/blob/e25e66164b537d7b3161dfede38466880534e783/baked_in.go#L286-L291 |
21,098 | go-playground/validator | baked_in.go | isIP | func isIP(fl FieldLevel) bool {
ip := net.ParseIP(fl.Field().String())
return ip != nil
} | go | func isIP(fl FieldLevel) bool {
ip := net.ParseIP(fl.Field().String())
return ip != nil
} | [
"func",
"isIP",
"(",
"fl",
"FieldLevel",
")",
"bool",
"{",
"ip",
":=",
"net",
".",
"ParseIP",
"(",
"fl",
".",
"Field",
"(",
")",
".",
"String",
"(",
")",
")",
"\n\n",
"return",
"ip",
"!=",
"nil",
"\n",
"}"
] | // IsIP is the validation function for validating if the field's value is a valid v4 or v6 IP address. | [
"IsIP",
"is",
"the",
"validation",
"function",
"for",
"validating",
"if",
"the",
"field",
"s",
"value",
"is",
"a",
"valid",
"v4",
"or",
"v6",
"IP",
"address",
"."
] | e25e66164b537d7b3161dfede38466880534e783 | https://github.com/go-playground/validator/blob/e25e66164b537d7b3161dfede38466880534e783/baked_in.go#L294-L299 |
21,099 | go-playground/validator | baked_in.go | isSSN | func isSSN(fl FieldLevel) bool {
field := fl.Field()
if field.Len() != 11 {
return false
}
return sSNRegex.MatchString(field.String())
} | go | func isSSN(fl FieldLevel) bool {
field := fl.Field()
if field.Len() != 11 {
return false
}
return sSNRegex.MatchString(field.String())
} | [
"func",
"isSSN",
"(",
"fl",
"FieldLevel",
")",
"bool",
"{",
"field",
":=",
"fl",
".",
"Field",
"(",
")",
"\n\n",
"if",
"field",
".",
"Len",
"(",
")",
"!=",
"11",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"return",
"sSNRegex",
".",
"MatchString",
"... | // IsSSN is the validation function for validating if the field's value is a valid SSN. | [
"IsSSN",
"is",
"the",
"validation",
"function",
"for",
"validating",
"if",
"the",
"field",
"s",
"value",
"is",
"a",
"valid",
"SSN",
"."
] | e25e66164b537d7b3161dfede38466880534e783 | https://github.com/go-playground/validator/blob/e25e66164b537d7b3161dfede38466880534e783/baked_in.go#L302-L311 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.