func progressBarForReader(out io.Writer, r io.Reader) (*pb.ProgressBar, *pb.Reader) {
// setup bar reader
// TODO: get total length of files
bar := pb.New(0).SetUnits(pb.U_BYTES)
bar.Output = out
barR := bar.NewProxyReader(r)
return bar, barR
}
func get(path, outFile string) error {
start := time.Now()
ctx, cancel := context.WithCancel(context.Background())
node, err := core.NewNode(ctx, &core.BuildCfg{
Online: true,
})
if err != nil {
return fmt.Errorf("ipfs NewNode() failed: %s", err)
}
err = node.Bootstrap(core.DefaultBootstrapConfig)
if err != nil {
return fmt.Errorf("node Bootstrap() failed: %s", err)
}
fmt.Fprintf(os.Stderr, "IPFS Node bootstrapping (took %v)\n", time.Since(start))
// Cancel the ipfs node context if the process gets interrupted or killed.
go func() {
interrupts := make(chan os.Signal, 1)
signal.Notify(interrupts, os.Interrupt, os.Kill)
<-interrupts
cancel()
}()
reader, length, err := cat(node.Context(), node, path)
if err != nil {
return fmt.Errorf("cat failed: %s", err)
}
file, err := os.Create(outFile)
if err != nil {
return fmt.Errorf("Creating output file %q failed: %s", outFile, err)
}
bar := pb.New(int(length)).SetUnits(pb.U_BYTES)
bar.Output = os.Stderr
bar.ShowSpeed = false
bar.Start()
writer := io.MultiWriter(file, bar)
if _, err := io.Copy(writer, reader); err != nil {
return fmt.Errorf("copy failed: %s", err)
}
bar.Finish()
fmt.Fprintf(os.Stderr, "Wrote %q to %q (%s) (took %v)\n", path, outFile,
humanize.Bytes(length), time.Since(start))
return nil
}
func main() {
count := 5000
bar := pb.New(count)
// show percents (by default already true)
bar.ShowPercent = true
// show bar (by default already true)
bar.ShowPercent = true
// no need counters
bar.ShowCounters = true
bar.ShowTimeLeft = true
// and start
bar.Start()
for i := 0; i < count; i++ {
bar.Increment()
time.Sleep(time.Millisecond)
}
bar.FinishPrint("The End!")
}
if err != nil {
res.SetError(err, cmds.ErrNormal)
return
}
res.SetLength(length)
reader := io.MultiReader(readers...)
res.SetOutput(reader)
},
PostRun: func(req cmds.Request, res cmds.Response) {
if res.Length() < progressBarMinSize {
return
}
bar := pb.New(int(res.Length())).SetUnits(pb.U_BYTES)
bar.Output = res.Stderr()
bar.Start()
reader := bar.NewProxyReader(res.Output().(io.Reader))
res.SetOutput(&clearlineReader{reader, res.Stderr()})
},
}
func cat(ctx context.Context, node *core.IpfsNode, paths []string) ([]io.Reader, uint64, error) {
readers := make([]io.Reader, 0, len(paths))
length := uint64(0)
for _, fpath := range paths {
read, err := coreunix.Cat(node, fpath)
if err != nil {
return nil, 0, err
func main() {
// check args
if len(os.Args) < 3 {
printUsage()
return
}
sourceName, destName := os.Args[1], os.Args[2]
// check source
var source io.Reader
var sourceSize int64
if strings.HasPrefix(sourceName, "http://") {
// open as url
resp, err := http.Get(sourceName)
if err != nil {
fmt.Printf("Can't get %s: %v\n", sourceName, err)
return
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
fmt.Printf("Server return non-200 status: %v\n", resp.Status)
return
}
i, _ := strconv.Atoi(resp.Header.Get("Content-Length"))
sourceSize = int64(i)
source = resp.Body
} else {
// open as file
s, err := os.Open(sourceName)
if err != nil {
fmt.Printf("Can't open %s: %v\n", sourceName, err)
return
}
defer s.Close()
// get source size
sourceStat, err := s.Stat()
if err != nil {
fmt.Printf("Can't stat %s: %v\n", sourceName, err)
return
}
sourceSize = sourceStat.Size()
source = s
}
// create dest
dest, err := os.Create(destName)
if err != nil {
fmt.Printf("Can't create %s: %v\n", destName, err)
return
}
defer dest.Close()
// create bar
bar := pb.New(int(sourceSize)).SetUnits(pb.U_BYTES).SetRefreshRate(time.Millisecond * 10)
bar.ShowSpeed = true
bar.Start()
// create multi writer
writer := io.MultiWriter(dest, bar)
// and copy
io.Copy(writer, source)
bar.Finish()
}