func deleteUnneededFiles(srpcClient *srpc.Client, subFS *filesystem.FileSystem,
imgFS *filesystem.FileSystem, logger *log.Logger) bool {
startTime := showStart("compute early files to delete")
pathsToDelete := make([]string, 0)
imgHashToInodesTable := imgFS.HashToInodesTable()
imgFilenameToInodeTable := imgFS.FilenameToInodeTable()
for pathname, inum := range subFS.FilenameToInodeTable() {
if inode, ok := subFS.InodeTable[inum].(*filesystem.RegularInode); ok {
if inode.Size > 0 {
if _, ok := imgHashToInodesTable[inode.Hash]; !ok {
pathsToDelete = append(pathsToDelete, pathname)
}
} else {
if _, ok := imgFilenameToInodeTable[pathname]; !ok {
pathsToDelete = append(pathsToDelete, pathname)
}
}
}
}
showTimeTaken(startTime)
if len(pathsToDelete) < 1 {
return false
}
updateRequest := sub.UpdateRequest{
Wait: true,
PathsToDelete: pathsToDelete}
var updateReply sub.UpdateResponse
startTime = showStart("Subd.Update() for early files to delete")
err := client.CallUpdate(srpcClient, updateRequest, &updateReply)
showTimeTaken(startTime)
if err != nil {
logger.Println(err)
}
return true
}
func spliceComputedFiles(fs *filesystem.FileSystem) error {
if *computedFiles == "" {
return nil
}
computedFileList, err := loadComputedFiles(*computedFiles)
if err != nil {
return errors.New("cannot load computed files list from: " +
*computedFiles + ": " + err.Error())
}
filenameToInodeTable := fs.FilenameToInodeTable()
inodeToFilenamesTable := fs.InodeToFilenamesTable()
for _, computedFile := range computedFileList {
inum, ok := filenameToInodeTable[computedFile.Filename]
if !ok {
return errors.New(computedFile.Filename + ": missing from image")
}
if filenames, ok := inodeToFilenamesTable[inum]; !ok {
panic(computedFile.Filename + ": no corresponding list of files")
} else if len(filenames) != 1 {
return fmt.Errorf("%s: multiple inodes: %d", computedFile.Filename,
len(filenames))
}
if inode, ok :=
fs.InodeTable[inum].(*filesystem.ComputedRegularInode); ok {
inode.Source = computedFile.Source
continue
}
if oldInode, ok := fs.InodeTable[inum].(*filesystem.RegularInode); !ok {
return fmt.Errorf("%s: type: %T is not a regular inode",
computedFile.Filename, fs.InodeTable[inum])
} else {
newInode := new(filesystem.ComputedRegularInode)
newInode.Mode = oldInode.Mode
newInode.Uid = oldInode.Uid
newInode.Gid = oldInode.Gid
newInode.Source = computedFile.Source
fs.InodeTable[inum] = newInode
}
}
fs.ComputeTotalDataBytes()
clearInodePointers(&fs.DirectoryInode, "")
return fs.RebuildInodePointers()
}
func layerImages(baseFS *filesystem.FileSystem,
layerFS *filesystem.FileSystem) error {
for filename, layerInum := range layerFS.FilenameToInodeTable() {
layerInode := layerFS.InodeTable[layerInum]
if _, ok := layerInode.(*filesystem.DirectoryInode); ok {
continue
}
baseInum, ok := baseFS.FilenameToInodeTable()[filename]
if !ok {
return errors.New(filename + " missing in base image")
}
baseInode := baseFS.InodeTable[baseInum]
sameType, sameMetadata, sameData := filesystem.CompareInodes(baseInode,
layerInode, nil)
if !sameType {
return errors.New(filename + " changed type")
}
if sameMetadata && sameData {
continue
}
baseFS.InodeTable[baseInum] = layerInode
}
return nil
}