func doVerify(signaturePath string, dir string, woundsPath string, healPath string) error {
if woundsPath == "" {
if healPath == "" {
comm.Opf("Verifying %s", dir)
} else {
comm.Opf("Verifying %s, healing as we go", dir)
}
} else {
if healPath == "" {
comm.Opf("Verifying %s, writing wounds to %s", dir, woundsPath)
} else {
comm.Dief("Options --wounds and --heal cannot be used at the same time")
}
}
startTime := time.Now()
signatureReader, err := eos.Open(signaturePath)
if err != nil {
return errors.Wrap(err, 1)
}
defer signatureReader.Close()
signature, err := pwr.ReadSignature(signatureReader)
if err != nil {
return errors.Wrap(err, 1)
}
vc := &pwr.ValidatorContext{
Consumer: comm.NewStateConsumer(),
WoundsPath: woundsPath,
HealPath: healPath,
}
comm.StartProgressWithTotalBytes(signature.Container.Size)
err = vc.Validate(dir, signature)
if err != nil {
return errors.Wrap(err, 1)
}
comm.EndProgress()
prettySize := humanize.IBytes(uint64(signature.Container.Size))
perSecond := humanize.IBytes(uint64(float64(signature.Container.Size) / time.Since(startTime).Seconds()))
comm.Statf("%s (%s) @ %s/s\n", prettySize, signature.Container.Stats(), perSecond)
if vc.WoundsConsumer.HasWounds() {
if healer, ok := vc.WoundsConsumer.(pwr.Healer); ok {
comm.Statf("%s corrupted data found, %s healed", humanize.IBytes(uint64(vc.WoundsConsumer.TotalCorrupted())), humanize.IBytes(uint64(healer.TotalHealed())))
} else {
comm.Dief("%s corrupted data found", humanize.IBytes(uint64(vc.WoundsConsumer.TotalCorrupted())))
}
}
return nil
}
func unzip(file string, dir string, resumeFile string) {
comm.Opf("Extracting zip %s to %s", file, dir)
settings := archiver.ExtractSettings{
Consumer: comm.NewStateConsumer(),
ResumeFrom: resumeFile,
OnUncompressedSizeKnown: func(uncompressedSize int64) {
comm.StartProgressWithTotalBytes(uncompressedSize)
},
}
res, err := archiver.ExtractPath(file, dir, settings)
comm.EndProgress()
must(err)
comm.Logf("Extracted %d dirs, %d files, %d symlinks", res.Dirs, res.Files, res.Symlinks)
}
func doCp(srcPath string, destPath string, resume bool) error {
src, err := eos.Open(srcPath)
if err != nil {
return err
}
defer src.Close()
dir := filepath.Dir(destPath)
err = os.MkdirAll(dir, 0755)
if err != nil {
return err
}
flags := os.O_CREATE | os.O_WRONLY
dest, err := os.OpenFile(destPath, flags, 0644)
if err != nil {
return err
}
defer dest.Close()
stats, err := src.Stat()
if err != nil {
return err
}
totalBytes := int64(stats.Size())
startOffset := int64(0)
if resume {
startOffset, err = dest.Seek(0, os.SEEK_END)
if err != nil {
return err
}
if startOffset == 0 {
comm.Logf("Downloading %s", humanize.IBytes(uint64(totalBytes)))
} else if startOffset > totalBytes {
comm.Logf("Existing data too big (%s > %s), starting over", humanize.IBytes(uint64(startOffset)), humanize.IBytes(uint64(totalBytes)))
} else if startOffset == totalBytes {
comm.Logf("All %s already there", humanize.IBytes(uint64(totalBytes)))
return nil
}
comm.Logf("Resuming at %s / %s", humanize.IBytes(uint64(startOffset)), humanize.IBytes(uint64(totalBytes)))
_, err = src.Seek(startOffset, os.SEEK_SET)
if err != nil {
return err
}
} else {
comm.Logf("Downloading %s", humanize.IBytes(uint64(totalBytes)))
}
start := time.Now()
comm.Progress(float64(startOffset) / float64(totalBytes))
comm.StartProgressWithTotalBytes(totalBytes)
cw := counter.NewWriterCallback(func(count int64) {
alpha := float64(startOffset+count) / float64(totalBytes)
comm.Progress(alpha)
}, dest)
copiedBytes, err := io.Copy(cw, src)
if err != nil {
return err
}
comm.EndProgress()
totalDuration := time.Since(start)
prettyStartOffset := humanize.IBytes(uint64(startOffset))
prettySize := humanize.IBytes(uint64(copiedBytes))
perSecond := humanize.IBytes(uint64(float64(totalBytes-startOffset) / totalDuration.Seconds()))
comm.Statf("%s + %s copied @ %s/s\n", prettyStartOffset, prettySize, perSecond)
return nil
}