_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q21000 | renameExpired | train | 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 | {
"resource": ""
} |
q21001 | deletePod | train | 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 | {
"resource": ""
} |
q21002 | backupDB | train | 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 | {
"resource": ""
} |
q21003 | ResolveName | train | 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 | {
"resource": ""
} |
q21004 | RemoveACI | train | 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 | {
"resource": ""
} |
q21005 | GetRemote | train | 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 | {
"resource": ""
} |
q21006 | GetImageManifestJSON | train | 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 | {
"resource": ""
} |
q21007 | GetImageManifest | train | 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 | {
"resource": ""
} |
q21008 | HasFullKey | train | func (s *Store) HasFullKey(key string) bool {
return s.stores[imageManifestType].Has(key)
} | go | {
"resource": ""
} |
q21009 | keyToString | train | 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 | {
"resource": ""
} |
q21010 | Download | train | 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 | {
"resource": ""
} |
q21011 | getAppName | train | 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 | {
"resource": ""
} |
q21012 | getEnterArgv | train | 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 | {
"resource": ""
} |
q21013 | mountFsRO | train | 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 | {
"resource": ""
} |
q21014 | GetEnabledCgroups | train | 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 | {
"resource": ""
} |
q21015 | GetOwnCgroupPath | train | func GetOwnCgroupPath(controller string) (string, error) {
parts, err := parseCgroupController("/proc/self/cgroup", controller)
if err != nil {
return "", err
}
return parts[2], nil
} | go | {
"resource": ""
} |
q21016 | GetCgroupPathByPid | train | 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 | {
"resource": ""
} |
q21017 | JoinSubcgroup | train | 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 | {
"resource": ""
} |
q21018 | IsControllerMounted | train | 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 | {
"resource": ""
} |
q21019 | Lgetxattr | train | 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 | {
"resource": ""
} |
q21020 | GetDeviceInfo | train | 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 | {
"resource": ""
} |
q21021 | getDeviceInfo | train | 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 | {
"resource": ""
} |
q21022 | IsIsolatorSupported | train | 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 | {
"resource": ""
} |
q21023 | CreateBackup | train | 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 | {
"resource": ""
} |
q21024 | pruneOldBackups | train | 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 | {
"resource": ""
} |
q21025 | shiftBackups | train | 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 | {
"resource": ""
} |
q21026 | NewBasicACI | train | 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 | {
"resource": ""
} |
q21027 | NewACI | train | 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 | {
"resource": ""
} |
q21028 | NewDetachedSignature | train | 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 | {
"resource": ""
} |
q21029 | SandboxManifest | train | 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 | {
"resource": ""
} |
q21030 | UpdateManifest | train | 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 | {
"resource": ""
} |
q21031 | ExclusiveLockManifest | train | 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 | {
"resource": ""
} |
q21032 | UnlockManifest | train | 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 | {
"resource": ""
} |
q21033 | getDBVersion | train | 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 | {
"resource": ""
} |
q21034 | updateDBVersion | train | 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 | {
"resource": ""
} |
q21035 | InitACL | train | func InitACL() (*ACL, error) {
h, err := getHandle()
if err != nil {
return nil, err
}
return &ACL{lib: h}, nil
} | go | {
"resource": ""
} |
q21036 | ParseACL | train | 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 | {
"resource": ""
} |
q21037 | Free | train | 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 | {
"resource": ""
} |
q21038 | SetFileACLDefault | train | 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 | {
"resource": ""
} |
q21039 | Valid | train | 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 | {
"resource": ""
} |
q21040 | AddBaseEntries | train | 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 | {
"resource": ""
} |
q21041 | NewAppc | train | 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 | {
"resource": ""
} |
q21042 | NewAppcFromApp | train | 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 | {
"resource": ""
} |
q21043 | CloseOnExec | train | 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 | {
"resource": ""
} |
q21044 | GetEnabledControllers | train | 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 | {
"resource": ""
} |
q21045 | globGetArgs | train | 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 | {
"resource": ""
} |
q21046 | globGetMakeFunction | train | 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 | {
"resource": ""
} |
q21047 | WaitFinished | train | 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 | {
"resource": ""
} |
q21048 | WaitReady | train | 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 | {
"resource": ""
} |
q21049 | retry | train | 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 | {
"resource": ""
} |
q21050 | DirSize | train | 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 | {
"resource": ""
} |
q21051 | IsDeviceNode | train | 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 | {
"resource": ""
} |
q21052 | StartCmd | train | 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 | {
"resource": ""
} |
q21053 | kvmNetArgs | train | 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 | {
"resource": ""
} |
q21054 | NewOptionList | train | 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 | {
"resource": ""
} |
q21055 | gcTreeStore | train | 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 | {
"resource": ""
} |
q21056 | getRunningImages | train | 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 | {
"resource": ""
} |
q21057 | deduplicateMPs | train | 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 | {
"resource": ""
} |
q21058 | MergeMounts | train | func MergeMounts(mounts []schema.Mount, appMounts []schema.Mount) []schema.Mount {
ml := append(appMounts, mounts...)
return deduplicateMPs(ml)
} | go | {
"resource": ""
} |
q21059 | Prepare | train | 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 | {
"resource": ""
} |
q21060 | setupAppImage | train | 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 | {
"resource": ""
} |
q21061 | prepareStage1Image | train | 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 | {
"resource": ""
} |
q21062 | setupStage1Image | train | 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 | {
"resource": ""
} |
q21063 | writeManifest | train | 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 | {
"resource": ""
} |
q21064 | copyAppManifest | train | 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 | {
"resource": ""
} |
q21065 | overlayRender | train | 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 | {
"resource": ""
} |
q21066 | prepareOverlay | train | 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 | {
"resource": ""
} |
q21067 | NewStore | train | 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 | {
"resource": ""
} |
q21068 | GetID | train | 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 | {
"resource": ""
} |
q21069 | Render | train | 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 | {
"resource": ""
} |
q21070 | Check | train | 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 | {
"resource": ""
} |
q21071 | Remove | train | 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 | {
"resource": ""
} |
q21072 | remove | train | 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 | {
"resource": ""
} |
q21073 | IsRendered | train | 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 | {
"resource": ""
} |
q21074 | Hash | train | 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 | {
"resource": ""
} |
q21075 | check | train | 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 | {
"resource": ""
} |
q21076 | Size | train | 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 | {
"resource": ""
} |
q21077 | GetImageHash | train | 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 | {
"resource": ""
} |
q21078 | HasPrefix | train | func HasPrefix(p string) FilterFunc {
return FilterFunc(func(m *Mount) bool {
return strings.HasPrefix(m.MountPoint, p)
})
} | go | {
"resource": ""
} |
q21079 | ParseMounts | train | 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 | {
"resource": ""
} |
q21080 | findResources | train | 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 | {
"resource": ""
} |
q21081 | wrapStructLevelFunc | train | func wrapStructLevelFunc(fn StructLevelFunc) StructLevelFuncCtx {
return func(ctx context.Context, sl StructLevel) {
fn(sl)
}
} | go | {
"resource": ""
} |
q21082 | ExtractType | train | func (v *validate) ExtractType(field reflect.Value) (reflect.Value, reflect.Kind, bool) {
return v.extractTypeInternal(field, false)
} | go | {
"resource": ""
} |
q21083 | ReportError | train | 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 | {
"resource": ""
} |
q21084 | ValidateValuer | train | 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 | {
"resource": ""
} |
q21085 | Error | train | func (e *InvalidValidationError) Error() string {
if e.Type == nil {
return "validator: (nil)"
}
return "validator: (nil " + e.Type.String() + ")"
} | go | {
"resource": ""
} |
q21086 | Error | train | 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 | {
"resource": ""
} |
q21087 | Translate | train | 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 | {
"resource": ""
} |
q21088 | Field | train | 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 | {
"resource": ""
} |
q21089 | StructField | train | func (fe *fieldError) StructField() string {
// return fe.structField
return fe.structNs[len(fe.structNs)-int(fe.structfieldLen):]
} | go | {
"resource": ""
} |
q21090 | Error | train | func (fe *fieldError) Error() string {
return fmt.Sprintf(fieldErrMsg, fe.ns, fe.Field(), fe.tag)
} | go | {
"resource": ""
} |
q21091 | NotBlank | train | 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 | {
"resource": ""
} |
q21092 | wrapFunc | train | 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 | {
"resource": ""
} |
q21093 | isUnique | train | 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 | {
"resource": ""
} |
q21094 | isMAC | train | func isMAC(fl FieldLevel) bool {
_, err := net.ParseMAC(fl.Field().String())
return err == nil
} | go | {
"resource": ""
} |
q21095 | isCIDRv4 | train | func isCIDRv4(fl FieldLevel) bool {
ip, _, err := net.ParseCIDR(fl.Field().String())
return err == nil && ip.To4() != nil
} | go | {
"resource": ""
} |
q21096 | isCIDR | train | func isCIDR(fl FieldLevel) bool {
_, _, err := net.ParseCIDR(fl.Field().String())
return err == nil
} | go | {
"resource": ""
} |
q21097 | isIPv6 | train | func isIPv6(fl FieldLevel) bool {
ip := net.ParseIP(fl.Field().String())
return ip != nil && ip.To4() == nil
} | go | {
"resource": ""
} |
q21098 | isIP | train | func isIP(fl FieldLevel) bool {
ip := net.ParseIP(fl.Field().String())
return ip != nil
} | go | {
"resource": ""
} |
q21099 | isSSN | train | func isSSN(fl FieldLevel) bool {
field := fl.Field()
if field.Len() != 11 {
return false
}
return sSNRegex.MatchString(field.String())
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.