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 }