func buildImageWithHasher(imageSClient *srpc.Client, filter *filter.Filter,
imageFilename string, h *hasher) (*filesystem.FileSystem, error) {
fi, err := os.Lstat(imageFilename)
if err != nil {
return nil, err
}
if fi.IsDir() {
sfs, err := scanner.ScanFileSystem(imageFilename, nil, filter, nil, h,
nil)
if err != nil {
return nil, err
}
return &sfs.FileSystem, nil
}
imageFile, err := os.Open(imageFilename)
if err != nil {
return nil, errors.New("error opening image file: " + err.Error())
}
defer imageFile.Close()
if partitionTable, err := mbr.Decode(imageFile); err != nil {
if err != io.EOF {
return nil, err
} // Else perhaps a tiny tarfile, definitely not a partition table.
} else if partitionTable != nil {
return buildImageFromRaw(imageSClient, filter, imageFile,
partitionTable, h)
}
var imageReader io.Reader
if strings.HasSuffix(imageFilename, ".tar") {
imageReader = imageFile
} else if strings.HasSuffix(imageFilename, ".tar.gz") ||
strings.HasSuffix(imageFilename, ".tgz") {
gzipReader, err := gzip.NewReader(imageFile)
if err != nil {
return nil, errors.New(
"error creating gzip reader: " + err.Error())
}
defer gzipReader.Close()
imageReader = gzipReader
} else {
return nil, errors.New("unrecognised image type")
}
tarReader := tar.NewReader(imageReader)
fs, err := untar.Decode(tarReader, h, filter)
if err != nil {
return nil, errors.New("error building image: " + err.Error())
}
return fs, nil
}
func pushImage(getSubClient getSubClientFunc, imageName string) error {
logger := log.New(os.Stderr, "", log.LstdFlags)
computedInodes := make(map[string]*filesystem.RegularInode)
// Start querying the imageserver for the image.
imageServerAddress := fmt.Sprintf("%s:%d",
*imageServerHostname, *imageServerPortNum)
imgChannel := getImageChannel(imageServerAddress, imageName, timeoutTime)
startTime := showStart("getSubClient()")
srpcClient := getSubClient()
showTimeTaken(startTime)
subObj := lib.Sub{
Hostname: *subHostname,
Client: srpcClient,
ComputedInodes: computedInodes}
if *computedFilesRoot == "" {
subObj.ObjectGetter = nullObjectGetterType{}
} else {
fs, err := scanner.ScanFileSystem(*computedFilesRoot, nil, nil, nil,
nil, nil)
if err != nil {
return err
}
subObj.ObjectGetter = fs
for filename, inum := range fs.FilenameToInodeTable() {
if inode, ok := fs.InodeTable[inum].(*filesystem.RegularInode); ok {
computedInodes[filename] = inode
}
}
}
startTime = showStart("<-imgChannel")
imageResult := <-imgChannel
showTimeTaken(startTime)
fmt.Fprintf(os.Stderr, "Background image fetch took %s\n",
format.Duration(imageResult.duration))
img := imageResult.image
var err error
if *filterFile != "" {
img.Filter, err = filter.Load(*filterFile)
if err != nil {
return err
}
}
if *triggersFile != "" {
img.Triggers, err = triggers.Load(*triggersFile)
if err != nil {
return err
}
} else if *triggersString != "" {
img.Triggers, err = triggers.Decode([]byte(*triggersString))
if err != nil {
return err
}
}
if err := pollFetchAndPush(&subObj, img, imageServerAddress, timeoutTime,
logger); err != nil {
return err
}
var updateRequest sub.UpdateRequest
var updateReply sub.UpdateResponse
startTime = showStart("lib.BuildUpdateRequest()")
if lib.BuildUpdateRequest(subObj, img, &updateRequest, true, logger) {
showBlankLine()
return errors.New("missing computed file(s)")
}
showTimeTaken(startTime)
updateRequest.ImageName = imageName
updateRequest.Wait = true
startTime = showStart("Subd.Update()")
err = client.CallUpdate(srpcClient, updateRequest, &updateReply)
if err != nil {
showBlankLine()
return err
}
showTimeTaken(startTime)
return nil
}