idx
int64 0
167k
| question
stringlengths 60
3.56k
| target
stringlengths 5
1.43k
| len_question
int64 21
889
| len_target
int64 3
529
|
|---|---|---|---|---|
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 . | 46 | 12 |
101 | func ( l * Logger ) PanicE ( msg string , e error ) { l . Panic ( l . formatErr ( e , msg ) ) } | PanicE prints a string and error then calls panic . | 33 | 12 |
102 | func Warn ( format string , values ... interface { } ) { fmt . Fprintf ( os . Stderr , fmt . Sprintf ( " " , format , '\n' ) , values ... ) } | Warn is just a shorter version of a formatted printing to stderr . It appends a newline for you . | 44 | 25 |
103 | func MustAbs ( dir string ) string { absDir , err := filepath . Abs ( dir ) if err != nil { panic ( fmt . Sprintf ( " \n " , dir , err ) ) } return filepath . Clean ( absDir ) } | MustAbs returns an absolute path . It works like filepath . Abs but panics if it fails . | 54 | 21 |
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 duration conversion failed . | 86 | 72 |
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 . | 46 | 14 |
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 { continue } stats [ app . Name . String ( ) ] = exitCode } return stats , nil } | getExitStatuses returns a map of the statuses of the pod . | 112 | 15 |
107 | func printStatus ( p * pkgPod . Pod ) error { if flagFormat != outputFormatTabbed { pod , err := lib . NewPodFromInternalPod ( p ) if err != nil { return fmt . Errorf ( " " , err ) } switch flagFormat { case outputFormatJSON : result , err := json . Marshal ( pod ) if err != nil { return fmt . Errorf ( " " , err ) } stdout . Print ( string ( result ) ) case outputFormatPrettyJSON : result , err := json . MarshalIndent ( pod , " " , " \t " ) if err != nil { return fmt . Errorf ( " " , err ) } stdout . Print ( string ( result ) ) } return nil } state := p . State ( ) stdout . Printf ( " " , state ) created , err := p . CreationTime ( ) if err != nil { return fmt . Errorf ( " " , p . UUID , err ) } createdStr := created . Format ( defaultTimeLayout ) stdout . Printf ( " " , createdStr ) started , err := p . StartTime ( ) if err != nil { return fmt . Errorf ( " " , p . UUID , err ) } var startedStr string if ! started . IsZero ( ) { startedStr = started . Format ( defaultTimeLayout ) stdout . Printf ( " " , startedStr ) } if state == pkgPod . Running || state == pkgPod . Exited { stdout . Printf ( " " , fmtNets ( p . Nets ) ) } if ! ( state == pkgPod . Running || state == pkgPod . Deleting || state == pkgPod . ExitedDeleting || state == pkgPod . Exited || state == pkgPod . ExitedGarbage ) { return nil } if pid , err := p . Pid ( ) ; err == nil { // the pid file might not be written yet when the state changes to 'Running' // it may also never be written if systemd never executes (e.g.: a bad command) stdout . Printf ( " " , pid ) } stdout . Printf ( " " , ( state == pkgPod . Exited || state == pkgPod . ExitedGarbage ) ) if state != pkgPod . Running { stats , err := getExitStatuses ( p ) if err != nil { return fmt . Errorf ( " " , p . UUID , err ) } for app , stat := range stats { stdout . Printf ( " " , app , stat ) } } return nil } | printStatus prints the pod s pid and per - app status codes | 556 | 13 |
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 . | 42 | 20 |
109 | func printIdentities ( entity * openpgp . Entity ) { lines := [ ] string { " " } for _ , v := range entity . Identities { lines = append ( lines , fmt . Sprintf ( " " , v . Name ) ) } log . Print ( strings . Join ( lines , " \n " ) ) } | printIdentities prints a message that signature was verified . | 71 | 11 |
110 | func DistFromImageString ( is string ) ( dist . Distribution , error ) { u , err := url . Parse ( is ) if err != nil { return nil , errwrap . Wrap ( fmt . Errorf ( " " , is ) , err ) } // Convert user friendly image string names to internal distribution URIs // file:///full/path/to/aci/file.aci -> archive:aci:file%3A%2F%2F%2Ffull%2Fpath%2Fto%2Faci%2Ffile.aci switch u . Scheme { case " " : // no scheme given, hence it is an appc image name or path appImageType := guessAppcOrPath ( is , [ ] string { schema . ACIExtension } ) switch appImageType { case imageStringName : app , err := discovery . NewAppFromString ( is ) if err != nil { return nil , fmt . Errorf ( " " , is , err ) } return dist . NewAppcFromApp ( app ) , nil case imageStringPath : absPath , err := filepath . Abs ( is ) if err != nil { return nil , errwrap . Wrap ( fmt . Errorf ( " " , is ) , err ) } is = " " + absPath // given a file:// image string, call this function again to return an ACI distribution return DistFromImageString ( is ) default : return nil , fmt . Errorf ( " " , appImageType ) } case " " , " " , " " : // An ACI archive with any transport type (file, http, s3 etc...) and final aci extension if filepath . Ext ( u . Path ) == schema . ACIExtension { dist , err := dist . NewACIArchiveFromTransportURL ( u ) if err != nil { return nil , fmt . Errorf ( " " , err ) } return dist , nil } case " " : // Accept both docker: and docker:// uri dockerStr := is if strings . HasPrefix ( dockerStr , " " ) { dockerStr = strings . TrimPrefix ( dockerStr , " " ) } else if strings . HasPrefix ( dockerStr , " " ) { dockerStr = strings . TrimPrefix ( dockerStr , " " ) } dist , err := dist . NewDockerFromString ( dockerStr ) if err != nil { return nil , fmt . Errorf ( " " , err ) } return dist , nil case dist . Scheme : // cimd return dist . Parse ( is ) default : // any other scheme is a an appc image name, i.e. "my-app:v1.0" app , err := discovery . NewAppFromString ( is ) if err != nil { return nil , fmt . Errorf ( " " , is , err ) } return dist . NewAppcFromApp ( app ) , nil } return nil , fmt . Errorf ( " " , is ) } | DistFromImageString return the distribution for the given input image string | 638 | 13 |
111 | func parseCIMD ( u * url . URL ) ( * cimd , error ) { if u . Scheme != Scheme { return nil , fmt . Errorf ( " " , u . Scheme ) } parts := strings . SplitN ( u . Opaque , " " , 3 ) if len ( parts ) < 3 { return nil , fmt . Errorf ( " " , u . String ( ) ) } version , err := strconv . ParseUint ( strings . TrimPrefix ( parts [ 1 ] , " " ) , 10 , 32 ) if err != nil { return nil , fmt . Errorf ( " " , parts [ 1 ] ) } return & cimd { Type : Type ( parts [ 0 ] ) , Version : uint32 ( version ) , Data : parts [ 2 ] , } , nil } | parseCIMD parses the given url and returns a cimd . | 176 | 16 |
112 | func NewCIMDString ( typ Type , version uint32 , data string ) string { return fmt . Sprintf ( " " , Scheme , typ , version , data ) } | NewCIMDString creates a new cimd URL string . | 37 | 14 |
113 | func getApp ( p * pkgPod . Pod ) ( * schema . RuntimeApp , error ) { _ , manifest , err := p . PodManifest ( ) if err != nil { return nil , errwrap . Wrap ( errors . New ( " " ) , err ) } apps := manifest . Apps if flagExportAppName != " " { exportAppName , err := types . NewACName ( flagExportAppName ) if err != nil { return nil , err } for _ , ra := range apps { if * exportAppName == ra . Name { return & ra , nil } } return nil , fmt . Errorf ( " " , flagExportAppName ) } switch len ( apps ) { case 0 : return nil , fmt . Errorf ( " " ) case 1 : return & apps [ 0 ] , nil default : } stderr . Print ( " " ) for _ , ra := range apps { stderr . Printf ( " \t " , ra . Name ) } return nil , fmt . Errorf ( " \" \" " ) } | 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 | 224 | 46 |
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 ( " " ) , err ) } ts , err := treestore . NewStore ( treeStoreDir ( ) , s ) if err != nil { return errwrap . Wrap ( errors . New ( " " ) , err ) } treeStoreID , err := pod . GetAppTreeStoreID ( app . Name ) if err != nil { return err } lower := ts . GetRootFS ( treeStoreID ) imgDir := filepath . Join ( filepath . Join ( pod . Path ( ) , " " ) , treeStoreID ) if _ , err := os . Stat ( imgDir ) ; err != nil { return err } upper := filepath . Join ( imgDir , " " , app . Name . String ( ) ) if _ , err := os . Stat ( upper ) ; err != nil { return err } work := filepath . Join ( imgDir , " " , app . Name . String ( ) ) if _ , err := os . Stat ( work ) ; err != nil { return err } if err := overlay . Mount ( & overlay . MountCfg { lower , upper , work , dest , " " } ) ; err != nil { return errwrap . Wrap ( errors . New ( " " ) , err ) } return nil } | mountOverlay mounts the app from the overlay - rendered pod to the destination directory . | 340 | 17 |
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 ) { return errors . New ( " " ) } else { return errwrap . Wrap ( fmt . Errorf ( " " , target ) , err ) } } gw := gzip . NewWriter ( aciFile ) tr := tar . NewWriter ( gw ) defer func ( ) { tr . Close ( ) gw . Close ( ) aciFile . Close ( ) // e is implicitly assigned by the return statement. As defer runs // after return, but before actually returning, this works. if e != nil { os . Remove ( target ) } } ( ) b , err := ioutil . ReadFile ( manifestPath ) if err != nil { return errwrap . Wrap ( errors . New ( " " ) , err ) } var im schema . ImageManifest if err := im . UnmarshalJSON ( b ) ; err != nil { return errwrap . Wrap ( errors . New ( " " ) , err ) } iw := aci . NewImageWriter ( im , tr ) // Unshift uid and gid when pod was started with --private-user (user namespace) var walkerCb aci . TarHeaderWalkFunc = func ( hdr * tar . Header ) bool { if uidRange != nil { uid , gid , err := uidRange . UnshiftRange ( uint32 ( hdr . Uid ) , uint32 ( hdr . Gid ) ) if err != nil { stderr . PrintE ( " " , err ) return false } hdr . Uid , hdr . Gid = int ( uid ) , int ( gid ) } return true } if err := filepath . Walk ( root , aci . BuildWalker ( root , iw , walkerCb ) ) ; err != nil { return errwrap . Wrap ( errors . New ( " " ) , err ) } if err = iw . Close ( ) ; err != nil { return errwrap . Wrap ( fmt . Errorf ( " " , target ) , err ) } return } | buildAci builds a target aci from the root directory using any uid shift information from uidRange . | 538 | 23 |
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 ( " " ) 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 . | 87 | 29 |
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 ++ // By appc spec, only one seccomp isolator per app is allowed if seenIsolators > 1 { return nil , ErrTooManySeccompIsolators } switch i . Name { case types . LinuxSeccompRemoveSetName : sf . mode = ModeBlacklist sf . syscalls , flag , err = parseLinuxSeccompSet ( p , seccomp ) if err != nil { return nil , err } if flag == " " { // we interpret "remove @empty" to mean "default whitelist" sf . mode = ModeWhitelist sf . syscalls = RktDefaultSeccompWhitelist } case types . LinuxSeccompRetainSetName : sf . mode = ModeWhitelist sf . syscalls , flag , err = parseLinuxSeccompSet ( p , seccomp ) if err != nil { return nil , err } if flag == " " { // Opt-out seccomp filtering return nil , nil } } sf . errno = string ( seccomp . Errno ( ) ) } } // If unset, use rkt default whitelist if seenIsolators == 0 { sf . mode = ModeWhitelist sf . syscalls = RktDefaultSeccompWhitelist } // Non-priv apps *must* have NoNewPrivileges set if they have seccomp sf . forceNoNewPrivileges = ( pa . uid != 0 ) return & sf , nil } | generateSeccompFilter computes the concrete seccomp filter from the isolators | 422 | 18 |
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 ( " " , " " , sf . errno ) ) } var filterPrefix string switch sf . mode { case ModeWhitelist : filterPrefix = sdWhitelistPrefix case ModeBlacklist : filterPrefix = sdBlacklistPrefix default : return nil , fmt . Errorf ( " " , sf . mode ) } // SystemCallFilter options are written down one entry per line, because // filtering sets may be quite large and overlong lines break unit serialization. opts = appendOptionsList ( opts , " " , " " , filterPrefix , sf . syscalls ... ) return opts , nil } | seccompUnitOptions converts a concrete seccomp filter to systemd unit options | 209 | 16 |
119 | func parseLinuxSeccompSet ( p * stage1commontypes . Pod , s types . LinuxSeccompSet ) ( syscallFilter [ ] string , flag string , err error ) { for _ , item := range s . Set ( ) { if item [ 0 ] == '@' { // Wildcards wildcard := strings . SplitN ( string ( item ) , " " , 2 ) if len ( wildcard ) != 2 { continue } scope := wildcard [ 0 ] name := wildcard [ 1 ] switch scope { case " " : // appc-reserved wildcards switch name { case " " : return nil , " " , nil case " " : return nil , " " , nil } case " " : // Docker-originated wildcards switch name { case " " : syscallFilter = append ( syscallFilter , DockerDefaultSeccompBlacklist ... ) case " " : syscallFilter = append ( syscallFilter , DockerDefaultSeccompWhitelist ... ) } case " " : // Custom rkt wildcards switch name { case " " : syscallFilter = append ( syscallFilter , RktDefaultSeccompBlacklist ... ) case " " : syscallFilter = append ( syscallFilter , RktDefaultSeccompWhitelist ... ) } case " " : // Custom systemd wildcards (systemd >= 231) _ , systemdVersion , err := GetFlavor ( p ) if err != nil || systemdVersion < 231 { return nil , " " , errors . New ( " " ) } switch name { case " " : syscallFilter = append ( syscallFilter , " " ) case " " : syscallFilter = append ( syscallFilter , " " ) case " " : syscallFilter = append ( syscallFilter , " " ) case " " : syscallFilter = append ( syscallFilter , " " ) case " " : syscallFilter = append ( syscallFilter , " " ) case " " : syscallFilter = append ( syscallFilter , " " ) case " " : syscallFilter = append ( syscallFilter , " " ) case " " : syscallFilter = append ( syscallFilter , " " ) } } } else { // Plain syscall name syscallFilter = append ( syscallFilter , string ( item ) ) } } return syscallFilter , " " , nil } | parseLinuxSeccompSet gets an appc LinuxSeccompSet and returns an array of values suitable for systemd SystemCallFilter . | 531 | 28 |
120 | func main ( ) { flag . Parse ( ) stage1initcommon . InitDebug ( debug ) log , diag , _ = rktlog . NewLogSet ( " " , debug ) if ! debug { diag . SetOutput ( ioutil . Discard ) } appName , err := types . NewACName ( flagApp ) if err != nil { log . FatalE ( " " , err ) } enterCmd := stage1common . PrepareEnterCmd ( false ) switch flagStage { case 0 : // clean resources in stage0 err = cleanupStage0 ( appName , enterCmd ) case 1 : // clean resources in stage1 err = cleanupStage1 ( appName , enterCmd ) default : // unknown step err = fmt . Errorf ( " " , flagStage ) } if err != nil { log . FatalE ( " " , err ) } os . Exit ( 0 ) } | 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 . | 190 | 32 |
121 | func cleanupStage1 ( appName * types . ACName , enterCmd [ ] string ) error { // TODO(lucab): re-evaluate once/if we support systemd as non-pid1 (eg. host pid-ns inheriting) mnts , err := mountinfo . ParseMounts ( 1 ) if err != nil { return err } appRootFs := filepath . Join ( " " , appName . String ( ) , " " ) mnts = mnts . Filter ( mountinfo . HasPrefix ( appRootFs ) ) // soft-errors here, stage0 may still be able to continue with the removal anyway for _ , m := range mnts { // unlink first to avoid back-propagation _ = syscall . Mount ( " " , m . MountPoint , " " , syscall . MS_PRIVATE | syscall . MS_REC , " " ) // simple unmount, it may fail if the target is busy (eg. overlapping children) if e := syscall . Unmount ( m . MountPoint , 0 ) ; e != nil { // if busy, just detach here and let the kernel clean it once free _ = syscall . Unmount ( m . MountPoint , syscall . MNT_DETACH ) } } return nil } | 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 . | 286 | 40 |
122 | func renameExited ( ) error { if err := pkgPod . WalkPods ( getDataDir ( ) , pkgPod . IncludeRunDir , func ( p * pkgPod . Pod ) { if p . State ( ) == pkgPod . Exited { stderr . Printf ( " " , p . UUID ) if err := p . ToExitedGarbage ( ) ; err != nil && err != os . ErrNotExist { stderr . PrintE ( " " , err ) } } } ) ; err != nil { return err } return nil } | renameExited renames exited pods to the exitedGarbage directory | 126 | 14 |
123 | func renameAborted ( ) error { if err := pkgPod . WalkPods ( getDataDir ( ) , pkgPod . IncludePrepareDir , func ( p * pkgPod . Pod ) { if p . State ( ) == pkgPod . AbortedPrepare { stderr . Printf ( " " , p . UUID ) if err := p . ToGarbage ( ) ; err != nil && err != os . ErrNotExist { stderr . PrintE ( " " , err ) } } } ) ; err != nil { return err } return nil } | renameAborted renames failed prepares to the garbage directory | 127 | 12 |
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 ( fmt . Sprintf ( " " , pp ) , err ) } return } if expiration := time . Unix ( st . Ctim . Unix ( ) ) . Add ( preparedExpiration ) ; time . Now ( ) . After ( expiration ) { stderr . Printf ( " " , p . UUID ) if err := p . ToGarbage ( ) ; err != nil && err != os . ErrNotExist { stderr . PrintE ( " " , err ) } } } ) ; err != nil { return err } return nil } | renameExpired renames expired prepared pods to the garbage directory | 224 | 13 |
125 | func deletePod ( p * pkgPod . Pod ) bool { podState := p . State ( ) if podState != pkgPod . ExitedGarbage && podState != pkgPod . Garbage && podState != pkgPod . ExitedDeleting { stderr . Errorf ( " " , p . UUID , p . State ( ) ) return false } if podState == pkgPod . ExitedGarbage { s , err := imagestore . NewStore ( storeDir ( ) ) if err != nil { stderr . PrintE ( " " , err ) return false } defer s . Close ( ) ts , err := treestore . NewStore ( treeStoreDir ( ) , s ) if err != nil { stderr . PrintE ( " " , err ) return false } if globalFlags . Debug { stage0 . InitDebug ( ) } if newMount , err := mountPodStage1 ( ts , p ) ; err == nil { if err = stage0 . GC ( p . Path ( ) , p . UUID , globalFlags . LocalConfigDir ) ; err != nil { stderr . PrintE ( fmt . Sprintf ( " " , p . UUID ) , err ) } // Linux <4.13 allows an overlay fs to be mounted over itself, so let's // unmount it here to avoid problems when running stage0.MountGC if p . UsesOverlay ( ) && newMount { stage1Mnt := common . Stage1RootfsPath ( p . Path ( ) ) if err := syscall . Unmount ( stage1Mnt , 0 ) ; err != nil && err != syscall . EBUSY { stderr . PrintE ( " " , err ) } } } else { stderr . PrintE ( " " , err ) } // unmount all leftover mounts if err := stage0 . MountGC ( p . Path ( ) , p . UUID . String ( ) ) ; err != nil { stderr . PrintE ( fmt . Sprintf ( " " , p . UUID ) , err ) return false } } // remove the rootfs first; if this fails (eg. due to busy mountpoints), pod manifest // is left in place and clean-up can be re-tried later. rootfsPath , err := p . Stage1RootfsPath ( ) if err == nil { if e := os . RemoveAll ( rootfsPath ) ; e != nil { stderr . PrintE ( fmt . Sprintf ( " " , p . UUID ) , e ) return false } } // finally remove all remaining pieces if err := os . RemoveAll ( p . Path ( ) ) ; err != nil { stderr . PrintE ( fmt . Sprintf ( " " , p . UUID ) , err ) return false } return true } | deletePod cleans up files and resource associated with the pod pod must be under exclusive lock and be in either ExitedGarbage or Garbage state | 610 | 29 |
126 | func ( s * Store ) backupDB ( ) error { if os . Geteuid ( ) != 0 { return ErrDBUpdateNeedsRoot } backupsDir := filepath . Join ( s . dir , " " ) return backup . CreateBackup ( s . dbDir ( ) , backupsDir , backupsNumber ) } | backupDB backs up current database . | 67 | 8 |
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 . Wrap ( errors . New ( " " ) , err ) } keys := make ( [ ] string , len ( aciInfos ) ) for i , aciInfo := range aciInfos { keys [ i ] = aciInfo . BlobKey } return keys , found , nil } | ResolveName resolves an image name to a list of full keys and using the store for resolution . | 160 | 20 |
128 | func ( s * Store ) RemoveACI ( key string ) error { imageKeyLock , err := lock . ExclusiveKeyLock ( s . imageLockDir , key ) if err != nil { return errwrap . Wrap ( errors . New ( " " ) , err ) } defer imageKeyLock . Close ( ) // Firstly remove aciinfo and remote from the db in an unique transaction. // remote needs to be removed or a GetRemote will return a blobKey not // referenced by any ACIInfo. err = s . db . Do ( func ( tx * sql . Tx ) error { if _ , found , err := GetACIInfoWithBlobKey ( tx , key ) ; err != nil { return errwrap . Wrap ( errors . New ( " " ) , err ) } else if ! found { return fmt . Errorf ( " " , key ) } if err := RemoveACIInfo ( tx , key ) ; err != nil { return err } if err := RemoveRemote ( tx , key ) ; err != nil { return err } return nil } ) if err != nil { return errwrap . Wrap ( fmt . Errorf ( " " , key ) , err ) } // Then remove non transactional entries from the blob, imageManifest // and tree store. // TODO(sgotti). Now that the ACIInfo is removed the image doesn't // exists anymore, but errors removing non transactional entries can // leave stale data that will require a cas GC to be implemented. var storeErrors [ ] error for _ , ds := range s . stores { if err := ds . Erase ( key ) ; err != nil { // If there's an error save it and continue with the other stores storeErrors = append ( storeErrors , err ) } } if len ( storeErrors ) > 0 { return & StoreRemovalError { errors : storeErrors } } return nil } | 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 . | 403 | 53 |
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 . | 79 | 27 |
130 | func ( s * Store ) GetImageManifestJSON ( key string ) ( [ ] byte , error ) { key , err := s . ResolveKey ( key ) if err != nil { return nil , errwrap . Wrap ( errors . New ( " " ) , err ) } keyLock , err := lock . SharedKeyLock ( s . imageLockDir , key ) if err != nil { return nil , errwrap . Wrap ( errors . New ( " " ) , err ) } defer keyLock . Close ( ) imj , err := s . stores [ imageManifestType ] . Read ( key ) if err != nil { return nil , errwrap . Wrap ( errors . New ( " " ) , err ) } return imj , nil } | GetImageManifestJSON gets the ImageManifest JSON bytes with the specified key . | 158 | 17 |
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 ( " " ) , err ) } return im , nil } | GetImageManifest gets the ImageManifest with the specified key . | 103 | 14 |
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 . | 31 | 28 |
133 | func keyToString ( k [ ] byte ) string { if len ( k ) != lenHash { panic ( fmt . Sprintf ( " " , k ) ) } return fmt . Sprintf ( " " , hashPrefix , k ) [ 0 : lenKey ] } | keyToString takes a key and returns a shortened and prefixed hexadecimal string version | 57 | 19 |
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 . Close ( ) if stopNow , err := d . Session . HandleStatus ( res ) ; stopNow || err != nil { return err } reader , err := d . Session . BodyReader ( res ) if err != nil { return err } if _ , err := io . Copy ( out , reader ) ; err != nil { return errwrap . Wrap ( fmt . Errorf ( " " , u . String ( ) ) , err ) } if err := out . Sync ( ) ; err != nil { return errwrap . Wrap ( fmt . Errorf ( " " , u . String ( ) ) , err ) } return nil } | Download tries to fetch the passed URL and write the contents into a given writeSyncer instance . | 216 | 19 |
135 | 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 ( " " ) , err ) } switch len ( m . Apps ) { case 0 : return nil , fmt . Errorf ( " " ) case 1 : return & m . Apps [ 0 ] . Name , nil default : } stderr . Print ( " " ) for _ , ra := range m . Apps { stderr . Printf ( " \t " , ra . Name ) } return nil , fmt . Errorf ( " \" \" " ) } | 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 | 185 | 49 |
136 | func getEnterArgv ( p * pkgPod . Pod , cmdArgs [ ] string ) ( [ ] string , error ) { var argv [ ] string if len ( cmdArgs ) < 2 { stderr . Printf ( " " , defaultCmd ) argv = [ ] string { defaultCmd } } else { argv = cmdArgs [ 1 : ] } return argv , nil } | getEnterArgv returns the argv to use for entering the pod | 85 | 14 |
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 ( " " , mountPoint ) , err ) } return nil } | mountFsRO remounts the given mountPoint using the given flags read - only . | 102 | 18 |
138 | func GetEnabledCgroups ( ) ( map [ int ] [ ] string , error ) { cgroupsFile , err := os . Open ( " " ) if err != nil { return nil , err } defer cgroupsFile . Close ( ) cgroups , err := parseCgroups ( cgroupsFile ) if err != nil { return nil , errwrap . Wrap ( errors . New ( " " ) , err ) } return cgroups , nil } | GetEnabledCgroups returns a map with the enabled cgroup controllers grouped by hierarchy | 93 | 16 |
139 | func GetOwnCgroupPath ( controller string ) ( string , error ) { parts , err := parseCgroupController ( " " , controller ) if err != nil { return " " , err } return parts [ 2 ] , nil } | GetOwnCgroupPath returns the cgroup path of this process in controller hierarchy | 49 | 16 |
140 | func GetCgroupPathByPid ( pid int , controller string ) ( string , error ) { parts , err := parseCgroupController ( fmt . Sprintf ( " " , 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 . | 62 | 23 |
141 | func JoinSubcgroup ( controller string , subcgroup string ) error { subcgroupPath := filepath . Join ( " " , controller , subcgroup ) if err := os . MkdirAll ( subcgroupPath , 0600 ) ; err != nil { return errwrap . Wrap ( fmt . Errorf ( " " , subcgroup ) , err ) } pidBytes := [ ] byte ( strconv . Itoa ( os . Getpid ( ) ) ) if err := ioutil . WriteFile ( filepath . Join ( subcgroupPath , " " ) , pidBytes , 0600 ) ; err != nil { return errwrap . Wrap ( fmt . Errorf ( " " , subcgroup ) , err ) } return nil } | JoinSubcgroup makes the calling process join the subcgroup hierarchy on a particular controller | 160 | 18 |
142 | func IsControllerMounted ( c string ) ( bool , error ) { cgroupProcsPath := filepath . Join ( " " , c , " " ) 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 | 81 | 20 |
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 . Pointer ( & dest [ 0 ] ) sz , _ , errno := syscall . Syscall6 ( syscall . SYS_LGETXATTR , uintptr ( unsafe . Pointer ( pathBytes ) ) , uintptr ( unsafe . Pointer ( attrBytes ) ) , uintptr ( destBytes ) , uintptr ( len ( dest ) ) , 0 , 0 ) if errno == syscall . ENODATA { return nil , nil } if errno == syscall . ERANGE { dest = make ( [ ] byte , sz ) destBytes := unsafe . Pointer ( & dest [ 0 ] ) sz , _ , errno = syscall . Syscall6 ( syscall . SYS_LGETXATTR , uintptr ( unsafe . Pointer ( pathBytes ) ) , uintptr ( unsafe . Pointer ( attrBytes ) ) , uintptr ( destBytes ) , uintptr ( len ( dest ) ) , 0 , 0 ) } if errno != 0 { return nil , errno } return dest [ : sz ] , nil } | Returns a nil slice and nil error if the xattr is not set | 329 | 14 |
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 ( " " , path ) return } stat_t , ok := d . Sys ( ) . ( * syscall . Stat_t ) if ! ok { err = fmt . Errorf ( " " ) return } return getDeviceInfo ( mode , stat_t . Rdev ) } | 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 . | 127 | 33 |
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 . | 91 | 17 |
146 | func IsIsolatorSupported ( isolator string ) ( bool , error ) { isUnified , err := IsCgroupUnified ( " " ) if err != nil { return false , errwrap . Wrap ( errors . New ( " " ) , err ) } if isUnified { controllers , err := v2 . GetEnabledControllers ( ) if err != nil { return false , errwrap . Wrap ( errors . New ( " " ) , err ) } for _ , c := range controllers { if c == isolator { return true , nil } } return false , nil } return v1 . IsControllerMounted ( isolator ) } | IsIsolatorSupported returns whether an isolator is supported in the kernel | 136 | 15 |
147 | func CreateBackup ( dir , backupsDir string , limit int ) error { tmpBackupDir := filepath . Join ( backupsDir , " " ) 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 ) // prune backups if err := pruneOldBackups ( backupsDir , limit - 1 ) ; err != nil { return err } if err := shiftBackups ( backupsDir , limit - 2 ) ; err != nil { return err } if err := os . Rename ( tmpBackupDir , filepath . Join ( backupsDir , " " ) ) ; err != nil { return err } return nil } | 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 being 5 the name for the oldest backup would be 4 . If a backups number exceeds the given limit then only newest ones are kept and the rest is removed . | 187 | 92 |
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 { // directory name is not a number, // leave it alone continue } else if num < limit { // directory name is a number lower // than a limit, leave it alone continue } path := filepath . Join ( dir , fi . Name ( ) ) if err := os . RemoveAll ( path ) ; err != nil { return err } } } return nil } | pruneOldBackups removes old backups that is - directories with names greater or equal than given limit . | 145 | 21 |
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 ) { return err } } return nil } | shiftBackups renames all directories with names being numbers up to oldest to names with numbers greater by one . | 106 | 22 |
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 NewACI ( dir , string ( b ) , nil ) } | NewBasicACI creates a new ACI in the given directory with the given name . Used for testing . | 95 | 22 |
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 ( " " ) , err ) } tf , err := ioutil . TempFile ( dir , " " ) if err != nil { return nil , err } defer os . Remove ( tf . Name ( ) ) tw := tar . NewWriter ( tf ) aw := NewImageWriter ( im , tw ) for _ , entry := range entries { // Add default mode if entry . Header . Mode == 0 { if entry . Header . Typeflag == tar . TypeDir { entry . Header . Mode = 0755 } else { entry . Header . Mode = 0644 } } // Add calling user uid and gid or tests will fail entry . Header . Uid = os . Getuid ( ) entry . Header . Gid = os . Getgid ( ) sr := strings . NewReader ( entry . Contents ) if err := aw . AddFile ( entry . Header , sr ) ; err != nil { return nil , err } } if err := aw . Close ( ) ; err != nil { return nil , err } return tf , nil } | NewACI creates a new ACI in the given directory with the given image manifest and entries . Used for testing . | 288 | 24 |
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 ( " " ) } signature := & bytes . Buffer { } if err := openpgp . ArmoredDetachSign ( signature , entityList [ 0 ] , aci , nil ) ; err != nil { return nil , err } return signature , nil } | NewDetachedSignature creates a new openpgp armored detached signature for the given ACI signed with armoredPrivateKey . | 130 | 25 |
153 | 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 ( " " ) , err ) } ms , ok := pm . Annotations . Get ( " " ) if ok { p . mutable , err = strconv . ParseBool ( ms ) if err != nil { return nil , errwrap . Wrap ( errors . New ( " " ) , err ) } } if ! p . mutable { return nil , ErrImmutable } return pm , nil } | 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 . | 155 | 58 |
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 } defer func ( ) { tmpf . Close ( ) os . Remove ( tmpf . Name ( ) ) } ( ) if err := tmpf . Chmod ( mstat . Mode ( ) . Perm ( ) ) ; err != nil { return err } if err := json . NewEncoder ( tmpf ) . Encode ( m ) ; err != nil { return err } if err := os . Rename ( tmpf . Name ( ) , mpath ) ; err != nil { return err } return nil } | 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 . | 201 | 40 |
155 | 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 } | 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 . | 86 | 39 |
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 . | 52 | 10 |
157 | func getDBVersion ( tx * sql . Tx ) ( int , error ) { var version int rows , err := tx . Query ( " " ) 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 . Err ( ) ; err != nil { return - 1 , err } if ! found { return - 1 , fmt . Errorf ( " " ) } return version , nil } | getDBVersion retrieves the current db version | 126 | 9 |
158 | 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 ( " " ) if err != nil { return err } _ , err = tx . Exec ( " " , version ) if err != nil { return err } return nil } | updateDBVersion updates the db version | 84 | 7 |
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 . | 42 | 16 |
160 | func ( a * ACL ) ParseACL ( acl string ) error { acl_from_text , err := getSymbolPointer ( a . lib . handle , " " ) 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 ( " " ) , err ) } a . a = retACL return nil } | ParseACL parses a string representation of an ACL . | 134 | 13 |
161 | func ( a * ACL ) Free ( ) error { acl_free , err := getSymbolPointer ( a . lib . handle , " " ) if err != nil { return err } ret , err := C . my_acl_free ( acl_free , a . a ) if ret < 0 { return errwrap . Wrap ( errors . New ( " " ) , err ) } return a . lib . close ( ) } | Free frees libacl s internal structures and closes libacl . | 93 | 13 |
162 | func ( a * ACL ) SetFileACLDefault ( path string ) error { acl_set_file , err := getSymbolPointer ( a . lib . handle , " " ) 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 errwrap . Wrap ( errors . New ( " " ) , err ) } return nil } | SetFileACLDefault sets the default ACL for path . | 135 | 12 |
163 | func ( a * ACL ) Valid ( ) error { acl_valid , err := getSymbolPointer ( a . lib . handle , " " ) if err != nil { return err } ret , err := C . my_acl_valid ( acl_valid , a . a ) if ret < 0 { return errwrap . Wrap ( errors . New ( " " ) , err ) } return nil } | Valid checks whether the ACL is valid . | 87 | 8 |
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 // set USER_OBJ entry r = mode & userRead == userRead w = mode & userWrite == userWrite x = mode & userExec == userExec if err := a . addBaseEntryFromMode ( TagUserObj , r , w , x ) ; err != nil { return err } // set GROUP_OBJ entry r = mode & groupRead == groupRead w = mode & groupWrite == groupWrite x = mode & groupExec == groupExec if err := a . addBaseEntryFromMode ( TagGroupObj , r , w , x ) ; err != nil { return err } // set OTHER entry r = mode & otherRead == otherRead w = mode & otherWrite == otherWrite x = mode & otherExec == otherExec if err := a . addBaseEntryFromMode ( TagOther , r , w , x ) ; err != nil { return err } return nil } | AddBaseEntries adds the base ACL entries from the file permissions . | 243 | 14 |
165 | func NewAppc ( u * url . URL ) ( Distribution , error ) { c , err := parseCIMD ( u ) if err != nil { return nil , fmt . Errorf ( " " , u . String ( ) , err ) } if c . Type != TypeAppc { return nil , fmt . Errorf ( " " , c . Type ) } appcStr := c . Data for n , v := range u . Query ( ) { appcStr += fmt . Sprintf ( " " , n , v [ 0 ] ) } app , err := discovery . NewAppFromString ( appcStr ) if err != nil { return nil , fmt . Errorf ( " " , u . String ( ) , err ) } return NewAppcFromApp ( app ) , nil } | NewAppc returns an Appc distribution from an Appc distribution URI | 169 | 14 |
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 = v } labels = append ( labels , types . Label { Name : n , Value : v } ) } if len ( labels ) > 0 { queries := make ( [ ] string , len ( labels ) ) rawuri += " " for i , l := range labels { queries [ i ] = fmt . Sprintf ( " " , l . Name , url . QueryEscape ( l . Value ) ) } rawuri += strings . Join ( queries , " " ) } u , err := url . Parse ( rawuri ) if err != nil { panic ( fmt . Errorf ( " " , rawuri , err ) ) } // save the URI as sorted to make it ready for comparison purell . NormalizeURL ( u , purell . FlagSortQuery ) str := app . Name . String ( ) if version != " " { str += fmt . Sprintf ( " " , version ) } labelsort . By ( labelsort . RankedName ) . Sort ( labels ) for _ , l := range labels { if l . Name != " " { str += fmt . Sprintf ( " " , l . Name , l . Value ) } } return & Appc { cimd : u , app : app . Copy ( ) , str : str , } } | NewAppcFromApp returns an Appc distribution from an appc App discovery string | 343 | 17 |
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 | 100 | 17 |
168 | func GetEnabledControllers ( ) ( [ ] string , error ) { controllersFile , err := os . Open ( " " ) 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 ( sc . Text ( ) , " " ) , nil } | GetEnabledControllers returns a list of enabled cgroup controllers | 96 | 12 |
169 | func globGetArgs ( args [ ] string ) globArgs { f , target := standardFlags ( globCmd ) suffix := f . String ( " " , " " , " " ) globbingMode := f . String ( " " , " " , " " ) filelist := f . String ( " " , " " , " " ) var mapTo [ ] string mapToWrapper := common . StringSliceWrapper { Slice : & mapTo } f . Var ( & mapToWrapper , " " , " " ) f . Parse ( args ) if * target == " " { common . Die ( " " ) } mode := globModeFromString ( * globbingMode ) if * filelist == " " { common . Die ( " " ) } if len ( mapTo ) < 1 { common . Die ( " " ) } return globArgs { target : * target , suffix : * suffix , mode : mode , filelist : * filelist , mapTo : mapTo , } } | globGetArgs parses given parameters and returns a target a suffix and a list of files . | 213 | 20 |
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 := range dirs { str := replacePlaceholders ( wildcard , " " , suffix , " " , dir ) makeWildcards = append ( makeWildcards , str ) } return replacePlaceholders ( globMakeFunction , " " , strings . Join ( makeWildcards , " " ) ) } | globGetMakeFunction returns a make snippet which calls wildcard function in all directories where given files are and with a given suffix . | 152 | 27 |
171 | 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, hence we are still in a running phase. // i.e. in pepare, run, exitedGarbage, garbage state. return false default : // some error occurred, bail out. return true } // unlock immediately if err := p . Unlock ( ) ; err != nil { return true } if err := p . refreshState ( ) ; err != nil { return true } // if we're in the gap between preparing and running in a split prepare/run-prepared usage, take a nap if p . isPrepared { time . Sleep ( time . Second ) } return p . IsFinished ( ) } return retry ( ctx , f , 100 * time . Millisecond ) } | 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 . | 227 | 43 |
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 . | 69 | 32 |
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 . C : if f ( ) { return } } } } ( ) return <- errChan } | 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 . | 109 | 37 |
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 := seenInode [ ino ] ; ! ok { seenInode [ ino ] = struct { } { } sz += info . Size ( ) } } else { sz += info . Size ( ) } return err } ) return sz , err } return 0 , nil } | DirSize takes a path and returns its size in bytes | 157 | 11 |
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 . | 49 | 23 |
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 : " " , KernelParams : [ ] string { " " , " " , " " + machineID , } , } driverConfiguration . InitKernelParams ( debug ) startCmd := [ ] string { filepath . Join ( wdPath , driverConfiguration . Bin ) , " " , " " , " " + uuid , " " , " " , strconv . Itoa ( int ( cpu ) ) , " " , strconv . Itoa ( int ( mem ) ) , " " , " " , kernelPath , " " , " " , // relative to run/pods/uuid dir this is a place where systemd resides " " , strings . Join ( driverConfiguration . KernelParams , " " ) , } return append ( startCmd , kvmNetArgs ( nds ) ... ) } | 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 | 244 | 37 |
177 | func kvmNetArgs ( nds [ ] kvm . NetDescriber ) [ ] string { var lkvmArgs [ ] string for _ , nd := range nds { lkvmArgs = append ( lkvmArgs , " " ) lkvmArgs = append ( lkvmArgs , fmt . Sprintf ( " " , nd . IfName ( ) , nd . Gateway ( ) , nd . GuestIP ( ) ) , ) } return 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 | 106 | 45 |
178 | func NewOptionList ( permissibleOptions [ ] string , defaultOptions string ) ( * OptionList , error ) { permissible := make ( map [ string ] struct { } ) ol := & OptionList { allOptions : permissibleOptions , permissible : permissible , typeName : " " , } for _ , o := range permissibleOptions { ol . permissible [ o ] = struct { } { } } if err := ol . Set ( defaultOptions ) ; err != nil { return nil , errwrap . Wrap ( errors . New ( " " ) , err ) } return ol , nil } | 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 | 119 | 45 |
179 | 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 // pods/treeStores being created/referenced keyLock , err := lock . ExclusiveKeyLock ( lockDir ( ) , common . PrepareLock ) if err != nil { return errwrap . Wrap ( errors . New ( " " ) , err ) } defer keyLock . Close ( ) referencedTreeStoreIDs , err := getReferencedTreeStoreIDs ( ) if err != nil { return errwrap . Wrap ( errors . New ( " " ) , err ) } treeStoreIDs , err := ts . GetIDs ( ) if err != nil { return errwrap . Wrap ( errors . New ( " " ) , err ) } for _ , treeStoreID := range treeStoreIDs { if _ , ok := referencedTreeStoreIDs [ treeStoreID ] ; ! ok { if err := ts . Remove ( treeStoreID ) ; err != nil { stderr . PrintE ( fmt . Sprintf ( " " , treeStoreID ) , err ) } else { stderr . Printf ( " " , treeStoreID ) } } } return nil } | gcTreeStore removes all treeStoreIDs not referenced by any non garbage collected pod from the store . | 299 | 20 |
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 ( ) { return } _ , manifest , err := p . PodManifest ( ) if err != nil { errors = append ( errors , newPodListReadError ( p , err ) ) return } pm = * manifest for _ , app := range pm . Apps { runningImages = append ( runningImages , app . Image . ID . String ( ) ) } } ) if err != nil { return nil , err } if len ( errors ) > 0 { return nil , errors [ 0 ] } return runningImages , nil } | getRunningImages will return the image IDs used to create any of the currently running pods | 200 | 17 |
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 { } { } } } return res } | deduplicateMPs removes Mounts with duplicated paths . If there s more than one Mount with the same path it keeps the first one encountered . | 97 | 32 |
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 | 49 | 13 |
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 ( " " ) , err ) } debug ( " " ) if err := prepareStage1Image ( cfg , dir ) ; err != nil { return errwrap . Wrap ( errors . New ( " " ) , err ) } var pmb [ ] byte var err error if len ( cfg . PodManifest ) > 0 { pmb , err = validatePodManifest ( cfg , dir ) } else { pmb , err = generatePodManifest ( cfg , dir ) } if err != nil { return err } cfg . CommonConfig . ManifestData = string ( pmb ) // create pod lock file for app add/rm operations. f , err := os . OpenFile ( common . PodManifestLockPath ( dir ) , os . O_CREATE | os . O_RDWR , 0600 ) if err != nil { return err } f . Close ( ) debug ( " " ) fn := common . PodManifestPath ( dir ) if err := ioutil . WriteFile ( fn , pmb , common . DefaultRegularFilePerm ) ; err != nil { return errwrap . Wrap ( errors . New ( " " ) , err ) } f , err = os . OpenFile ( common . PodCreatedPath ( dir ) , os . O_CREATE | os . O_RDWR , common . DefaultRegularFilePerm ) if err != nil { return err } f . Close ( ) if cfg . UseOverlay { // mark the pod as prepared with overlay f , err := os . Create ( filepath . Join ( dir , common . OverlayPreparedFilename ) ) if err != nil { return errwrap . Wrap ( errors . New ( " " ) , err ) } defer f . Close ( ) } if cfg . PrivateUsers . Shift > 0 { // mark the pod as prepared for user namespaces uidrangeBytes := cfg . PrivateUsers . Serialize ( ) if err := ioutil . WriteFile ( filepath . Join ( dir , common . PrivateUsersPreparedFilename ) , uidrangeBytes , common . DefaultRegularFilePerm ) ; err != nil { return errwrap . Wrap ( errors . New ( " " ) , err ) } } return nil } | Prepare sets up a pod based on the given config . | 533 | 12 |
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 ( " " ) , err ) } treeStoreID , err := ioutil . ReadFile ( common . AppTreeStoreIDPath ( cdir , appName ) ) if err != nil { return err } if err := copyAppManifest ( cdir , appName , ad ) ; err != nil { return err } if err := overlayRender ( cfg , string ( treeStoreID ) , cdir , ad , appName . String ( ) ) ; err != nil { return errwrap . Wrap ( errors . New ( " " ) , err ) } } return ensureMtabExists ( filepath . Join ( ad , " " ) ) } | 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 . | 221 | 43 |
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 ( " " ) , err ) } treeStoreID , _ , err := cfg . TreeStore . Render ( cfg . Stage1Image . String ( ) , false ) if err != nil { return errwrap . Wrap ( errors . New ( " " ) , err ) } if err := writeManifest ( * cfg . CommonConfig , cfg . Stage1Image , s1 ) ; err != nil { return errwrap . Wrap ( errors . New ( " " ) , err ) } if ! cfg . UseOverlay { destRootfs := filepath . Join ( s1 , " " ) cachedTreePath := cfg . TreeStore . GetRootFS ( treeStoreID ) if err := fileutil . CopyTree ( cachedTreePath , destRootfs , cfg . PrivateUsers ) ; err != nil { return errwrap . Wrap ( errors . New ( " " ) , err ) } } fn := path . Join ( cdir , common . Stage1TreeStoreIDFilename ) if err := ioutil . WriteFile ( fn , [ ] byte ( treeStoreID ) , common . DefaultRegularFilePerm ) ; err != nil { return errwrap . Wrap ( errors . New ( " " ) , err ) } return nil } | 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 . | 329 | 35 |
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 } // pass an empty appName if err := overlayRender ( cfg , string ( treeStoreID ) , cdir , s1 , " " ) ; err != nil { return errwrap . Wrap ( errors . New ( " " ) , err ) } // we will later read the status from the upper layer of the overlay fs // force the status directory to be there by touching it statusPath := filepath . Join ( s1 , " " , " " , " " ) if err := os . Chtimes ( statusPath , time . Now ( ) , time . Now ( ) ) ; err != nil { return errwrap . Wrap ( errors . New ( " " ) , err ) } } return nil } | setupStage1Image mounts the overlay filesystem for stage1 . When useOverlay is false it is a noop | 227 | 23 |
187 | func writeManifest ( cfg CommonConfig , img types . Hash , dest string ) error { mb , err := cfg . Store . GetImageManifestJSON ( img . String ( ) ) if err != nil { return err } debug ( " " ) if err := ioutil . WriteFile ( filepath . Join ( dest , " " ) , mb , common . DefaultRegularFilePerm ) ; err != nil { return errwrap . Wrap ( errors . New ( " " ) , err ) } return nil } | writeManifest takes an img ID and writes the corresponding manifest in dest | 112 | 14 |
188 | func copyAppManifest ( cdir string , appName types . ACName , dest string ) error { appInfoDir := common . AppInfoPath ( cdir , appName ) sourceFn := filepath . Join ( appInfoDir , " " ) destFn := filepath . Join ( dest , " " ) if err := fileutil . CopyRegularFile ( sourceFn , destFn ) ; err != nil { return errwrap . Wrap ( errors . New ( " " ) , err ) } return nil } | copyAppManifest copies to saved image manifest for the given appName and writes it in the dest directory . | 111 | 22 |
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 . DefaultRegularDirPerm ) if err != nil { return errwrap . Wrap ( errors . New ( " " ) , err ) } if err = overlay . Mount ( mc ) ; err != nil { return errwrap . Wrap ( errors . New ( " " ) , err ) } return nil } | 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 . | 147 | 33 |
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 , " " ) if err := os . MkdirAll ( dst , imgMode ) ; err != nil { return nil , err } overlayDir := path . Join ( cdir , " " ) if err := os . MkdirAll ( overlayDir , fm ) ; err != nil { return nil , err } // Since the parent directory (rkt/pods/$STATE/$POD_UUID) has the 'S_ISGID' bit, here // we need to explicitly turn the bit off when creating this overlay // directory so that it won't inherit the bit. Otherwise the files // created by users within the pod will inherit the 'S_ISGID' bit // as well. if err := os . Chmod ( overlayDir , fm ) ; err != nil { return nil , err } imgDir := path . Join ( overlayDir , treeStoreID ) if err := os . MkdirAll ( imgDir , fm ) ; err != nil { return nil , err } // Also make 'rkt/pods/$STATE/$POD_UUID/overlay/$IMAGE_ID' to be readable by 'rkt' group // As 'rkt' status will read the 'rkt/pods/$STATE/$POD_UUID/overlay/$IMAGE_ID/upper/rkt/status/$APP' // to get exgid if err := os . Chown ( imgDir , - 1 , gid ) ; err != nil { return nil , err } upper := path . Join ( imgDir , " " , appName ) if err := os . MkdirAll ( upper , imgMode ) ; err != nil { return nil , err } if err := label . SetFileLabel ( upper , lbl ) ; err != nil { return nil , err } work := path . Join ( imgDir , " " , appName ) if err := os . MkdirAll ( work , fm ) ; err != nil { return nil , err } if err := label . SetFileLabel ( work , lbl ) ; err != nil { return nil , err } return & overlay . MountCfg { lower , upper , work , dst , lbl } , nil } | prepateOverlay sets up the needed directories files and permissions for the overlay - rendered pods | 548 | 18 |
191 | 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 , " " ) , store : store } ts . lockDir = filepath . Join ( dir , " " ) 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 . | 115 | 20 |
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 = append ( keys , image . Key ) } imagesString := strings . Join ( keys , " " ) h := sha512 . New ( ) h . Write ( [ ] byte ( imagesString ) ) return " " + hashToKey ( h ) , nil } | 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 . | 144 | 49 |
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 ( " " ) , err ) } // this lock references the treestore dir for the specified id. treeStoreKeyLock , err := lock . ExclusiveKeyLock ( ts . lockDir , id ) if err != nil { return " " , " " , errwrap . Wrap ( errors . New ( " " ) , err ) } defer treeStoreKeyLock . Close ( ) if ! rebuild { rendered , err := ts . IsRendered ( id ) if err != nil { return " " , " " , errwrap . Wrap ( errors . New ( " " ) , err ) } if rendered { return id , " " , nil } } // Firstly remove a possible partial treestore if existing. // This is needed as a previous ACI removal operation could have failed // cleaning the tree store leaving some stale files. if err := ts . remove ( id ) ; err != nil { return " " , " " , err } if hash , err = ts . render ( id , key ) ; err != nil { return " " , " " , err } return id , hash , nil } | 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 . | 284 | 69 |
194 | func ( ts * Store ) Check ( id string ) ( string , error ) { treeStoreKeyLock , err := lock . SharedKeyLock ( ts . lockDir , id ) if err != nil { return " " , errwrap . Wrap ( errors . New ( " " ) , err ) } defer treeStoreKeyLock . Close ( ) return ts . check ( id ) } | Check verifies the treestore consistency for the specified id . | 79 | 13 |
195 | func ( ts * Store ) Remove ( id string ) error { treeStoreKeyLock , err := lock . ExclusiveKeyLock ( ts . lockDir , id ) if err != nil { return errwrap . Wrap ( errors . New ( " " ) , err ) } defer treeStoreKeyLock . Close ( ) if err := ts . remove ( id ) ; err != nil { return errwrap . Wrap ( errors . New ( " " ) , err ) } return nil } | Remove removes the rendered image in tree store with the given id . | 98 | 13 |
196 | 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 ( " " ) , err ) } renderedFilePath := filepath . Join ( treepath , renderedfilename ) // The "rendered" flag file should be the firstly removed file. So if // the removal ends with some error leaving some stale files IsRendered() // will return false. _ , err = os . Stat ( renderedFilePath ) if err != nil && ! os . IsNotExist ( err ) { return err } if ! os . IsNotExist ( err ) { err := os . Remove ( renderedFilePath ) // Ensure that the treepath directory is fsynced after removing the // "rendered" flag file f , err := os . Open ( treepath ) if err != nil { return errwrap . Wrap ( errors . New ( " " ) , err ) } defer f . Close ( ) err = f . Sync ( ) if err != nil { return errwrap . Wrap ( errors . New ( " " ) , err ) } } // Ignore error retrieving image hash key , _ := ts . GetImageHash ( id ) if err := os . RemoveAll ( treepath ) ; err != nil { return err } if key != " " { return ts . store . UpdateTreeStoreSize ( key , 0 ) } return nil } | remove cleans the directory for the provided id | 345 | 8 |
197 | 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 , err } return true , nil } | IsRendered checks if the tree store with the provided id is fully rendered | 102 | 15 |
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 ( " " ) , err ) } hashstring := hashToKey ( hash ) return hashstring , nil } | 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 . | 108 | 44 |
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 " " , errwrap . Wrap ( errors . New ( " " ) , err ) } if curhash != string ( hash ) { return " " , fmt . Errorf ( " " , curhash , hash ) } return curhash , nil } | check calculates the actual rendered ACI s hash and verifies that it matches the saved value . Returns the calculated hash . | 143 | 24 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.