idx int64 0 167k | question stringlengths 64 85.5k | target stringlengths 5 1.43k |
|---|---|---|
100 | func ( l * Logger ) Errorf ( format string , a ... interface { } ) { l . Print ( l . formatErr ( fmt . Errorf ( format , a ... ) , "" ) )
} | Errorf is a convenience function for formatting and printing errors . |
101 | func ( l * Logger ) PanicE ( msg string , e error ) { l . Panic ( l . formatErr ( e , msg ) )
} | PanicE prints a string and error then calls panic . |
102 | func Warn ( format string , values ... interface { } ) { fmt . Fprintf ( os . Stderr , fmt . Sprintf ( "%s%c" , format , '\n' ) , values ... )
} | Warn is just a shorter version of a formatted printing to stderr . It appends a newline for you . |
103 | func MustAbs ( dir string ) string { absDir , err := filepath . Abs ( dir )
if err != nil { panic ( fmt . Sprintf ( "Failed to get absolute path of a directory %q: %v\n" , \n , dir ) )
}
err
} | MustAbs returns an absolute path . It works like filepath . Abs but panics if it fails . |
104 | func parseDuration ( s string ) ( time . Duration , error ) { if s == "" { return time . Duration ( - 1 ) , nil
}
b , err := strconv . ParseBool ( s )
switch { case err != nil : return time . ParseDuration ( s )
case b : return time . Duration ( - 1 ) , nil
}
return time . Duration ( 0 ) , nil
} | parseDuration converts the given string s to a duration value . If it is empty string or a true boolean value according to strconv . ParseBool a negative duration is returned . If the boolean value is false a 0 duration is returned . If the string s is a duration value then it is returned . It returns an error if the d... |
105 | func newContext ( t time . Duration ) context . Context { ctx := context . Background ( )
if t > 0 { ctx , _ = context . WithTimeout ( ctx , t )
}
return ctx
} | newContext returns a new context with timeout t if t > 0 . |
106 | func getExitStatuses ( p * pkgPod . Pod ) ( map [ string ] int , error ) { _ , manifest , err := p . PodManifest ( )
if err != nil { return nil , err
}
stats := make ( map [ string ] int )
for _ , app := range manifest . Apps { exitCode , err := p . AppExitCode ( app . Name . String ( ) )
if err != nil { cont... | getExitStatuses returns a map of the statuses of the pod . |
107 | func printStatus ( p * pkgPod . Pod ) error { if flagFormat != outputFormatTabbed { pod , err := lib . NewPodFromInternalPod ( p )
if err != nil { return fmt . Errorf ( "error converting pod: %v" , err )
}
switch flagFormat { case outputFormatJSON : result , err := json . Marshal ( pod )
if err != nil { return ... | printStatus prints the pod s pid and per - app status codes |
108 | func ascURLFromImgURL ( u * url . URL ) * url . URL { copy := * u
copy . Path = ascPathFromImgPath ( copy . Path )
return & copy
} | ascURLFromImgURL creates a URL to a signature file from passed URL to an image . |
109 | func printIdentities ( entity * openpgp . Entity ) { lines := [ ] string { "signature verified:" }
for _ , v := range entity . Identities { lines = append ( lines , fmt . Sprintf ( " %s" , v . Name ) )
}
log . Print ( strings . Join ( lines , "\n" ) )
} | printIdentities prints a message that signature was verified . |
110 | func DistFromImageString ( is string ) ( dist . Distribution , error ) { u , err := url . Parse ( is )
if err != nil { return nil , errwrap . Wrap ( fmt . Errorf ( "failed to parse image url %q" , is ) , err )
}
switch u . Scheme { case "" : appImageType := guessAppcOrPath ( is , [ ] string { schema . ACIExtensio... | DistFromImageString return the distribution for the given input image string |
111 | func parseCIMD ( u * url . URL ) ( * cimd , error ) { if u . Scheme != Scheme { return nil , fmt . Errorf ( "unsupported scheme: %q" , u . Scheme )
}
parts := strings . SplitN ( u . Opaque , ":" , 3 )
if len ( parts ) < 3 { return nil , fmt . Errorf ( "malformed distribution uri: %q" , u . String ( ) )
}
vers... | parseCIMD parses the given url and returns a cimd . |
112 | func NewCIMDString ( typ Type , version uint32 , data string ) string { return fmt . Sprintf ( "%s:%s:v=%d:%s" , Scheme , typ , version , data )
} | NewCIMDString creates a new cimd URL string . |
113 | func getApp ( p * pkgPod . Pod ) ( * schema . RuntimeApp , error ) { _ , manifest , err := p . PodManifest ( )
if err != nil { return nil , errwrap . Wrap ( errors . New ( "problem getting the pod's manifest" ) , err )
}
apps := manifest . Apps
if flagExportAppName != "" { exportAppName , err := types . NewACNa... | getApp returns the app to export If one was supplied in the flags then it s returned if present If the PM contains a single app that app is returned If the PM has multiple apps the names are printed and an error is returned |
114 | func mountOverlay ( pod * pkgPod . Pod , app * schema . RuntimeApp , dest string ) error { if _ , err := os . Stat ( dest ) ; err != nil { return err
}
s , err := imagestore . NewStore ( getDataDir ( ) )
if err != nil { return errwrap . Wrap ( errors . New ( "cannot open store" ) , err )
}
ts , err := treesto... | mountOverlay mounts the app from the overlay - rendered pod to the destination directory . |
115 | func buildAci ( root , manifestPath , target string , uidRange * user . UidRange ) ( e error ) { mode := os . O_CREATE | os . O_WRONLY
if flagOverwriteACI { mode |= os . O_TRUNC
} else { mode |= os . O_EXCL
}
aciFile , err := os . OpenFile ( target , mode , 0644 )
if err != nil { if os . IsExist ( err ) { ret... | buildAci builds a target aci from the root directory using any uid shift information from uidRange . |
116 | func ensureSuperuser ( cf func ( cmd * cobra . Command , args [ ] string ) ) func ( cmd * cobra . Command , args [ ] string ) { return func ( cmd * cobra . Command , args [ ] string ) { if os . Geteuid ( ) != 0 { stderr . Print ( "cannot run as unprivileged user" )
cmdExitCode = 254
return
}
cf ( cmd , args )
... | ensureSuperuser will error out if the effective UID of the current process is not zero . Otherwise it will invoke the supplied cobra command . |
117 | func generateSeccompFilter ( p * stage1commontypes . Pod , pa * preparedApp ) ( * seccompFilter , error ) { sf := seccompFilter { }
seenIsolators := 0
for _ , i := range pa . app . App . Isolators { var flag string
var err error
if seccomp , ok := i . Value ( ) . ( types . LinuxSeccompSet ) ; ok { seenIsolators... | generateSeccompFilter computes the concrete seccomp filter from the isolators |
118 | func seccompUnitOptions ( opts [ ] * unit . UnitOption , sf * seccompFilter ) ( [ ] * unit . UnitOption , error ) { if sf == nil { return opts , nil
}
if sf . errno != "" { opts = append ( opts , unit . NewUnitOption ( "Service" , "SystemCallErrorNumber" , sf . errno ) )
}
var filterPrefix string
switch sf . ... | seccompUnitOptions converts a concrete seccomp filter to systemd unit options |
119 | func parseLinuxSeccompSet ( p * stage1commontypes . Pod , s types . LinuxSeccompSet ) ( syscallFilter [ ] string , flag string , err error ) { for _ , item := range s . Set ( ) { if item [ 0 ] == '@' { wildcard := strings . SplitN ( string ( item ) , "/" , 2 )
if len ( wildcard ) != 2 { continue
}
scope := wildca... | parseLinuxSeccompSet gets an appc LinuxSeccompSet and returns an array of values suitable for systemd SystemCallFilter . |
120 | func main ( ) { flag . Parse ( )
stage1initcommon . InitDebug ( debug )
log , diag , _ = rktlog . NewLogSet ( "app-rm" , debug )
if ! debug { diag . SetOutput ( ioutil . Discard )
}
appName , err := types . NewACName ( flagApp )
if err != nil { log . FatalE ( "invalid app name" , err )
}
enterCmd := sta... | This is a multi - step entrypoint . It starts in stage0 context then invokes itself again in stage1 context to perform further cleanup at pod level . |
121 | func cleanupStage1 ( appName * types . ACName , enterCmd [ ] string ) error { mnts , err := mountinfo . ParseMounts ( 1 )
if err != nil { return err
}
appRootFs := filepath . Join ( "/opt/stage2" , appName . String ( ) , "rootfs" )
mnts = mnts . Filter ( mountinfo . HasPrefix ( appRootFs ) )
for _ , m := rang... | cleanupStage1 is meant to be executed in stage1 context . It inspects pod systemd - pid1 mountinfo to find all remaining mountpoints for appName and proceed to clean them up . |
122 | func renameExited ( ) error { if err := pkgPod . WalkPods ( getDataDir ( ) , pkgPod . IncludeRunDir , func ( p * pkgPod . Pod ) { if p . State ( ) == pkgPod . Exited { stderr . Printf ( "moving pod %q to garbage" , p . UUID )
if err := p . ToExitedGarbage ( ) ; err != nil && err != os . ErrNotExist { stderr . PrintE ... | renameExited renames exited pods to the exitedGarbage directory |
123 | func renameAborted ( ) error { if err := pkgPod . WalkPods ( getDataDir ( ) , pkgPod . IncludePrepareDir , func ( p * pkgPod . Pod ) { if p . State ( ) == pkgPod . AbortedPrepare { stderr . Printf ( "moving failed prepare %q to garbage" , p . UUID )
if err := p . ToGarbage ( ) ; err != nil && err != os . ErrNotExist ... | renameAborted renames failed prepares to the garbage directory |
124 | 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... | renameExpired renames expired prepared pods to the garbage directory |
125 | 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 . Exit... | deletePod cleans up files and resource associated with the pod pod must be under exclusive lock and be in either ExitedGarbage or Garbage state |
126 | 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 )
} | backupDB backs up current database . |
127 | 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 ... | ResolveName resolves an image name to a list of full keys and using the store for resolution . |
128 | 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 ( )
err = s . db . Do ( func ( tx * sql . Tx ) error { if _ , found , e... | 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 . |
129 | 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
} | GetRemote tries to retrieve a remote with the given ACIURL . If remote doesn t exist it returns ErrRemoteNotFound error . |
130 | 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 , errw... | GetImageManifestJSON gets the ImageManifest JSON bytes with the specified key . |
131 | 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 u... | GetImageManifest gets the ImageManifest with the specified key . |
132 | func ( s * Store ) HasFullKey ( key string ) bool { return s . stores [ imageManifestType ] . Has ( 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 . |
133 | 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 ]
} | keyToString takes a key and returns a shortened and prefixed hexadecimal string version |
134 | 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 . Clos... | Download tries to fetch the passed URL and write the contents into a given writeSyncer instance . |
135 | func getAppName ( p * pkgPod . Pod ) ( * types . ACName , error ) { if flagAppName != "" { return types . NewACName ( flagAppName )
}
_ , m , err := p . PodManifest ( )
if err != nil { return nil , errwrap . Wrap ( errors . New ( "error reading pod manifest" ) , err )
}
switch len ( m . Apps ) { case 0 : retu... | 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 |
136 | 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
} | getEnterArgv returns the argv to use for entering the pod |
137 | 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" , mountPo... | mountFsRO remounts the given mountPoint using the given flags read - only . |
138 | 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/cg... | GetEnabledCgroups returns a map with the enabled cgroup controllers grouped by hierarchy |
139 | func GetOwnCgroupPath ( controller string ) ( string , error ) { parts , err := parseCgroupController ( "/proc/self/cgroup" , controller )
if err != nil { return "" , err
}
return parts [ 2 ] , nil
} | GetOwnCgroupPath returns the cgroup path of this process in controller hierarchy |
140 | 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
} | GetCgroupPathByPid returns the cgroup path of the process with the given pid and given controller . |
141 | 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 :... | JoinSubcgroup makes the calling process join the subcgroup hierarchy on a particular controller |
142 | 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
} | IsControllerMounted returns whether a controller is mounted by checking that cgroup . procs is accessible |
143 | 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 . Po... | Returns a nil slice and nil error if the xattr is not set |
144 | 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 . St... | 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 . |
145 | 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
} | Parse the device info out of the mode bits . Separate for testability . |
146 | 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... | IsIsolatorSupported returns whether an isolator is supported in the kernel |
147 | 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
}
defe... | 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 for limit bei... |
148 | 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 { continue
} else if num < limit { continue
}
path := filepath . Join ( dir , fi . Name ( ... | pruneOldBackups removes old backups that is - directories with names greater or equal than given limit . |
149 | 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... | shiftBackups renames all directories with names being numbers up to oldest to names with numbers greater by one . |
150 | 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 N... | NewBasicACI creates a new ACI in the given directory with the given name . Used for testing . |
151 | 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 ... | NewACI creates a new ACI in the given directory with the given image manifest and entries . Used for testing . |
152 | 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" )
}... | NewDetachedSignature creates a new openpgp armored detached signature for the given ACI signed with armoredPrivateKey . |
153 | func ( p * Pod ) SandboxManifest ( ) ( * schema . PodManifest , error ) { _ , pm , err := p . PodManifest ( )
if err != nil { return nil , errwrap . Wrap ( errors . New ( "error loading pod manifest" ) , err )
}
ms , ok := pm . Annotations . Get ( "coreos.com/rkt/stage1/mutable" )
if ok { p . mutable , err = st... | 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 . |
154 | 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
... | 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 . |
155 | func ( p * Pod ) ExclusiveLockManifest ( ) error { if p . manifestLock != nil { return p . manifestLock . ExclusiveLock ( )
}
l , err := lock . ExclusiveLock ( common . PodManifestLockPath ( p . Path ( ) ) , lock . RegFile )
if err != nil { return err
}
p . manifestLock = l
return nil
} | 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 . |
156 | 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
} | UnlockManifest unlocks the pod manifest lock . |
157 | 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 = tr... | getDBVersion retrieves the current db version |
158 | func updateDBVersion ( tx * sql . Tx , version int ) error { _ , 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
}
return nil
} | updateDBVersion updates the db version |
159 | func InitACL ( ) ( * ACL , error ) { h , err := getHandle ( )
if err != nil { return nil , err
}
return & ACL { lib : h } , nil
} | InitACL dlopens libacl and returns an ACL object if successful . |
160 | 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... | ParseACL parses a string representation of an ACL . |
161 | 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 ( )
} | Free frees libacl s internal structures and closes libacl . |
162 | 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_TYP... | SetFileACLDefault sets the default ACL for path . |
163 | 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
} | Valid checks whether the ACL is valid . |
164 | 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
r = mode & userRead == userRead
w = mode & userWrite == userWrite
x = mode & userExec == userExec
if err := a . addBaseEntryFromMode ( ... | AddBaseEntries adds the base ACL entries from the file permissions . |
165 | 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 ... | NewAppc returns an Appc distribution from an Appc distribution URI |
166 | 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 , typ... | NewAppcFromApp returns an Appc distribution from an appc App discovery string |
167 | 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
} | CloseOnExec sets or clears FD_CLOEXEC flag on a file descriptor |
168 | 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 ... | GetEnabledControllers returns a list of enabled cgroup controllers |
169 | 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" , "" , "Re... | globGetArgs parses given parameters and returns a target a suffix and a list of files . |
170 | 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... | globGetMakeFunction returns a make snippet which calls wildcard function in all directories where given files are and with a given suffix . |
171 | func ( p * Pod ) WaitFinished ( ctx context . Context ) error { f := func ( ) bool { switch err := p . TrySharedLock ( ) ; err { case nil : case lock . ErrLocked : return false
default : return true
}
if err := p . Unlock ( ) ; err != nil { return true
}
if err := p . refreshState ( ) ; err != nil { return tr... | 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 . |
172 | 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 )
} | 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 . |
173 | 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 . ... | 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 . |
174 | 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 ... | DirSize takes a path and returns its size in bytes |
175 | func IsDeviceNode ( path string ) bool { d , err := os . Lstat ( path )
if err == nil { m := d . Mode ( )
return m & os . ModeDevice == os . ModeDevice
}
return false
} | IsDeviceNode checks if the given path points to a block or char device . It doesn t follow symlinks . |
176 | 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... | 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 |
177 | 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 ( ) ) , )
}
ret... | 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 |
178 | 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 . permis... | 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 |
179 | func gcTreeStore ( ts * treestore . Store ) error { keyLock , err := lock . ExclusiveKeyLock ( lockDir ( ) , common . PrepareLock )
if err != nil { return errwrap . Wrap ( errors . New ( "cannot get exclusive prepare lock" ) , err )
}
defer keyLock . Close ( )
referencedTreeStoreIDs , err := getReferencedTreeSt... | gcTreeStore removes all treeStoreIDs not referenced by any non garbage collected pod from the store . |
180 | 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 ( ) ... | getRunningImages will return the image IDs used to create any of the currently running pods |
181 | 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 { } { }
... | deduplicateMPs removes Mounts with duplicated paths . If there s more than one Mount with the same path it keeps the first one encountered . |
182 | func MergeMounts ( mounts [ ] schema . Mount , appMounts [ ] schema . Mount ) [ ] schema . Mount { ml := append ( appMounts , mounts ... )
return deduplicateMPs ( ml )
} | MergeMounts combines the global and per - app mount slices |
183 | 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 := pre... | Prepare sets up a pod based on the given config . |
184 | 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... | 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 . |
185 | 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 .... | 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 . |
186 | 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
}
if err := overlayRender ( cfg , string ( t... | setupStage1Image mounts the overlay filesystem for stage1 . When useOverlay is false it is a noop |
187 | 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 . DefaultRegular... | writeManifest takes an img ID and writes the corresponding manifest in dest |
188 | 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 ... | copyAppManifest copies to saved image manifest for the given appName and writes it in the dest directory . |
189 | 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 . DefaultRegularDirP... | 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 . |
190 | 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 , im... | prepateOverlay sets up the needed directories files and permissions for the overlay - rendered pods |
191 | func NewStore ( dir string , store * imagestore . Store ) ( * Store , error ) { ts := & Store { dir : filepath . Join ( dir , "tree" ) , store : store }
ts . lockDir = filepath . Join ( dir , "treestorelocks" )
if err := os . MkdirAll ( ts . lockDir , 0755 ) ; err != nil { return nil , err
}
return ts , nil
} | NewStore creates a Store for managing filesystem trees including the dependency graph resolution of the underlying image layers . |
192 | 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 = ... | 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 . |
193 | 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 )
}
treeStoreKeyLock , err := lock . ExclusiveKeyLock ( ts . lockDir , id )
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 already rendered . |
194 | 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 )
} | Check verifies the treestore consistency for the specified id . |
195 | 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 . W... | Remove removes the rendered image in tree store with the given id . |
196 | func ( ts * Store ) remove ( id string ) error { treepath := ts . GetPath ( id )
_ , 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 := filepath . J... | remove cleans the directory for the provided id |
197 | func ( ts * Store ) IsRendered ( id string ) ( bool , error ) { treepath := ts . GetPath ( id )
_ , err := os . Stat ( filepath . Join ( treepath , renderedfilename ) )
if os . IsNotExist ( err ) { return false , nil
}
if err != nil { return false , err
}
return true , nil
} | IsRendered checks if the tree store with the provided id is fully rendered |
198 | 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 )
}
... | 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 . |
199 | 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 "" , errw... | check calculates the actual rendered ACI s hash and verifies that it matches the saved value . Returns the calculated hash . |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.