diff --git a/common/config.go b/common/config.go
index aa632ceae..1487ea292 100644
--- a/common/config.go
+++ b/common/config.go
@@ -2,6 +2,7 @@ package common
 
 import (
 	"fmt"
+	"github.com/cheggaaa/pb"
 	"net/url"
 	"os"
 	"path/filepath"
@@ -54,7 +55,7 @@ func SupportedProtocol(u *url.URL) bool {
 
 	// build a dummy NewDownloadClient since this is the only place that valid
 	// protocols are actually exposed.
-	cli := NewDownloadClient(&DownloadConfig{})
+	cli := NewDownloadClient(&DownloadConfig{}, *pb.New(0))
 
 	// Iterate through each downloader to see if a protocol was found.
 	ok := false
@@ -186,7 +187,7 @@ func FileExistsLocally(original string) bool {
 
 	// First create a dummy downloader so we can figure out which
 	// protocol to use.
-	cli := NewDownloadClient(&DownloadConfig{})
+	cli := NewDownloadClient(&DownloadConfig{}, *pb.New(0))
 	d, ok := cli.config.DownloaderMap[u.Scheme]
 	if !ok {
 		return false
diff --git a/common/download.go b/common/download.go
index 09457ef0b..62fcc908e 100644
--- a/common/download.go
+++ b/common/download.go
@@ -18,6 +18,9 @@ import (
 	"strings"
 )
 
+// required import for progress-bar
+import "github.com/cheggaaa/pb"
+
 // imports related to each Downloader implementation
 import (
 	"io"
@@ -81,22 +84,23 @@ func HashForType(t string) hash.Hash {
 
 // NewDownloadClient returns a new DownloadClient for the given
 // configuration.
-func NewDownloadClient(c *DownloadConfig) *DownloadClient {
+func NewDownloadClient(c *DownloadConfig, bar pb.ProgressBar) *DownloadClient {
 	const mtu = 1500 /* ethernet */ - 20 /* ipv4 */ - 20 /* tcp */
 
 	// Create downloader map if it hasn't been specified already.
 	if c.DownloaderMap == nil {
 		c.DownloaderMap = map[string]Downloader{
-			"file":  &FileDownloader{bufferSize: nil},
-			"http":  &HTTPDownloader{userAgent: c.UserAgent},
-			"https": &HTTPDownloader{userAgent: c.UserAgent},
-			"smb":   &SMBDownloader{bufferSize: nil},
+			"file":  &FileDownloader{progress: &bar, bufferSize: nil},
+			"http":  &HTTPDownloader{progress: &bar, userAgent: c.UserAgent},
+			"https": &HTTPDownloader{progress: &bar, userAgent: c.UserAgent},
+			"smb":   &SMBDownloader{progress: &bar, bufferSize: nil},
 		}
 	}
 	return &DownloadClient{config: c}
 }
 
-// A downloader implements the ability to transfer, cancel, or resume a file.
+// A downloader implements the ability to transfer a file, and cancel or resume
+//	it.
 type Downloader interface {
 	Resume()
 	Cancel()
@@ -205,14 +209,6 @@ func (d *DownloadClient) Get() (string, error) {
 	return finalPath, err
 }
 
-func (d *DownloadClient) PercentProgress() int {
-	if d.downloader == nil {
-		return -1
-	}
-
-	return int((float64(d.downloader.Progress()) / float64(d.downloader.Total())) * 100)
-}
-
 // VerifyChecksum tests that the path matches the checksum for the
 // download.
 func (d *DownloadClient) VerifyChecksum(path string) (bool, error) {
@@ -238,6 +234,8 @@ type HTTPDownloader struct {
 	current   uint64
 	total     uint64
 	userAgent string
+
+	progress *pb.ProgressBar
 }
 
 func (d *HTTPDownloader) Cancel() {
@@ -330,6 +328,10 @@ func (d *HTTPDownloader) Download(dst *os.File, src *url.URL) error {
 
 	d.total = d.current + uint64(resp.ContentLength)
 
+	d.progress.Total = int64(d.total)
+	progressBar := d.progress.Start()
+	progressBar.Set64(int64(d.current))
+
 	var buffer [4096]byte
 	for {
 		n, err := resp.Body.Read(buffer[:])
@@ -338,6 +340,7 @@ func (d *HTTPDownloader) Download(dst *os.File, src *url.URL) error {
 		}
 
 		d.current += uint64(n)
+		progressBar.Set64(int64(d.current))
 
 		if _, werr := dst.Write(buffer[:n]); werr != nil {
 			return werr
@@ -347,6 +350,7 @@ func (d *HTTPDownloader) Download(dst *os.File, src *url.URL) error {
 			break
 		}
 	}
+	progressBar.Finish()
 	return nil
 }
 
@@ -366,6 +370,8 @@ type FileDownloader struct {
 	active  bool
 	current uint64
 	total   uint64
+
+	progress *pb.ProgressBar
 }
 
 func (d *FileDownloader) Progress() uint64 {
@@ -456,6 +462,9 @@ func (d *FileDownloader) Download(dst *os.File, src *url.URL) error {
 	}
 	d.total = uint64(fi.Size())
 
+	d.progress.Total = int64(d.total)
+	progressBar := d.progress.Start()
+
 	// no bufferSize specified, so copy synchronously.
 	if d.bufferSize == nil {
 		var n int64
@@ -463,6 +472,7 @@ func (d *FileDownloader) Download(dst *os.File, src *url.URL) error {
 		d.active = false
 
 		d.current += uint64(n)
+		progressBar.Set64(int64(d.current))
 
 		// use a goro in case someone else wants to enable cancel/resume
 	} else {
@@ -475,6 +485,7 @@ func (d *FileDownloader) Download(dst *os.File, src *url.URL) error {
 				}
 
 				d.current += uint64(n)
+				progressBar.Set64(int64(d.current))
 			}
 			d.active = false
 			e <- err
@@ -483,6 +494,7 @@ func (d *FileDownloader) Download(dst *os.File, src *url.URL) error {
 		// ...and we spin until it's done
 		err = <-errch
 	}
+	progressBar.Finish()
 	f.Close()
 	return err
 }
@@ -495,6 +507,8 @@ type SMBDownloader struct {
 	active  bool
 	current uint64
 	total   uint64
+
+	progress *pb.ProgressBar
 }
 
 func (d *SMBDownloader) Progress() uint64 {
@@ -567,6 +581,9 @@ func (d *SMBDownloader) Download(dst *os.File, src *url.URL) error {
 	}
 	d.total = uint64(fi.Size())
 
+	d.progress.Total = int64(d.total)
+	progressBar := d.progress.Start()
+
 	// no bufferSize specified, so copy synchronously.
 	if d.bufferSize == nil {
 		var n int64
@@ -574,6 +591,7 @@ func (d *SMBDownloader) Download(dst *os.File, src *url.URL) error {
 		d.active = false
 
 		d.current += uint64(n)
+		progressBar.Set64(int64(d.current))
 
 		// use a goro in case someone else wants to enable cancel/resume
 	} else {
@@ -586,6 +604,7 @@ func (d *SMBDownloader) Download(dst *os.File, src *url.URL) error {
 				}
 
 				d.current += uint64(n)
+				progressBar.Set64(int64(d.current))
 			}
 			d.active = false
 			e <- err
@@ -594,6 +613,7 @@ func (d *SMBDownloader) Download(dst *os.File, src *url.URL) error {
 		// ...and as usual we spin until it's done
 		err = <-errch
 	}
+	progressBar.Finish()
 	f.Close()
 	return err
 }
diff --git a/common/download_test.go b/common/download_test.go
index c9175b013..6100be1c2 100644
--- a/common/download_test.go
+++ b/common/download_test.go
@@ -12,6 +12,8 @@ import (
 	"runtime"
 	"strings"
 	"testing"
+
+	"github.com/cheggaaa/pb"
 )
 
 func TestDownloadClientVerifyChecksum(t *testing.T) {
@@ -36,7 +38,7 @@ func TestDownloadClientVerifyChecksum(t *testing.T) {
 		Checksum: checksum,
 	}
 
-	d := NewDownloadClient(config)
+	d := NewDownloadClient(config, *pb.New64(0))
 	result, err := d.VerifyChecksum(tf.Name())
 	if err != nil {
 		t.Fatalf("Verify err: %s", err)
@@ -59,7 +61,7 @@ func TestDownloadClient_basic(t *testing.T) {
 		Url:        ts.URL + "/basic.txt",
 		TargetPath: tf.Name(),
 		CopyFile:   true,
-	})
+	}, *pb.New64(0))
 
 	path, err := client.Get()
 	if err != nil {
@@ -95,7 +97,7 @@ func TestDownloadClient_checksumBad(t *testing.T) {
 		Hash:       HashForType("md5"),
 		Checksum:   checksum,
 		CopyFile:   true,
-	})
+	}, *pb.New64(0))
 
 	if _, err := client.Get(); err == nil {
 		t.Fatal("should error")
@@ -121,7 +123,7 @@ func TestDownloadClient_checksumGood(t *testing.T) {
 		Hash:       HashForType("md5"),
 		Checksum:   checksum,
 		CopyFile:   true,
-	})
+	}, *pb.New64(0))
 
 	path, err := client.Get()
 	if err != nil {
@@ -153,7 +155,8 @@ func TestDownloadClient_checksumNoDownload(t *testing.T) {
 		Hash:       HashForType("md5"),
 		Checksum:   checksum,
 		CopyFile:   true,
-	})
+	}, *pb.New64(0))
+
 	path, err := client.Get()
 	if err != nil {
 		t.Fatalf("err: %s", err)
@@ -183,7 +186,7 @@ func TestDownloadClient_notFound(t *testing.T) {
 	client := NewDownloadClient(&DownloadConfig{
 		Url:        ts.URL + "/not-found.txt",
 		TargetPath: tf.Name(),
-	})
+	}, *pb.New64(0))
 
 	if _, err := client.Get(); err == nil {
 		t.Fatal("should error")
@@ -211,7 +214,7 @@ func TestDownloadClient_resume(t *testing.T) {
 		Url:        ts.URL,
 		TargetPath: tf.Name(),
 		CopyFile:   true,
-	})
+	}, *pb.New64(0))
 
 	path, err := client.Get()
 	if err != nil {
@@ -273,7 +276,7 @@ func TestDownloadClient_usesDefaultUserAgent(t *testing.T) {
 		CopyFile:   true,
 	}
 
-	client := NewDownloadClient(config)
+	client := NewDownloadClient(config, *pb.New64(0))
 	_, err = client.Get()
 	if err != nil {
 		t.Fatal(err)
@@ -306,7 +309,7 @@ func TestDownloadClient_setsUserAgent(t *testing.T) {
 		CopyFile:   true,
 	}
 
-	client := NewDownloadClient(config)
+	client := NewDownloadClient(config, *pb.New64(0))
 	_, err = client.Get()
 	if err != nil {
 		t.Fatal(err)
@@ -405,7 +408,7 @@ func TestDownloadFileUrl(t *testing.T) {
 		CopyFile: false,
 	}
 
-	client := NewDownloadClient(config)
+	client := NewDownloadClient(config, *pb.New64(0))
 
 	// Verify that we fail to match the checksum
 	_, err = client.Get()
@@ -436,7 +439,7 @@ func SimulateFileUriDownload(t *testing.T, uri string) (string, error) {
 	}
 
 	// go go go
-	client := NewDownloadClient(config)
+	client := NewDownloadClient(config, *pb.New64(0))
 	path, err := client.Get()
 
 	// ignore any non-important checksum errors if it's not a unc path
diff --git a/common/progress.go b/common/progress.go
new file mode 100644
index 000000000..c90810c9d
--- /dev/null
+++ b/common/progress.go
@@ -0,0 +1,20 @@
+package common
+
+import "github.com/cheggaaa/pb"
+
+// Default progress bar appearance
+func GetDefaultProgressBar() pb.ProgressBar {
+	bar := pb.New64(0)
+	bar.ShowPercent = true
+	bar.ShowCounters = true
+	bar.ShowSpeed = false
+	bar.ShowBar = true
+	bar.ShowTimeLeft = false
+	bar.ShowFinalTime = false
+	bar.SetUnits(pb.U_BYTES)
+	bar.Format("[=>-]")
+	bar.SetRefreshRate(1 * time.Second)
+	bar.SetWidth(80)
+
+	return *bar
+}
diff --git a/common/step_download.go b/common/step_download.go
index 1719c5987..c920cf5d2 100644
--- a/common/step_download.go
+++ b/common/step_download.go
@@ -8,6 +8,7 @@ import (
 	"log"
 	"time"
 
+	"github.com/cheggaaa/pb"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/helper/useragent"
 	"github.com/hashicorp/packer/packer"
@@ -63,6 +64,10 @@ func (s *StepDownload) Run(_ context.Context, state multistep.StateBag) multiste
 
 	ui.Say(fmt.Sprintf("Retrieving %s", s.Description))
 
+	// Get a default-looking progress bar and connect it to the ui.
+	bar := GetDefaultProgressBar()
+	bar.Callback = ui.Message
+
 	// First try to use any already downloaded file
 	// If it fails, proceed to regular download logic
 
@@ -96,7 +101,7 @@ func (s *StepDownload) Run(_ context.Context, state multistep.StateBag) multiste
 		}
 		downloadConfigs[i] = config
 
-		if match, _ := NewDownloadClient(config).VerifyChecksum(config.TargetPath); match {
+		if match, _ := NewDownloadClient(config, bar).VerifyChecksum(config.TargetPath); match {
 			ui.Message(fmt.Sprintf("Found already downloaded, initial checksum matched, no download needed: %s", url))
 			finalPath = config.TargetPath
 			break
@@ -139,7 +144,13 @@ func (s *StepDownload) Cleanup(multistep.StateBag) {}
 func (s *StepDownload) download(config *DownloadConfig, state multistep.StateBag) (string, error, bool) {
 	var path string
 	ui := state.Get("ui").(packer.Ui)
-	download := NewDownloadClient(config)
+
+	// Get a default looking progress bar and connect it to the ui.
+	bar := GetDefaultProgressBar()
+	bar.Callback = ui.Message
+
+	// Create download client with config and progress bar
+	download := NewDownloadClient(config, bar)
 
 	downloadCompleteCh := make(chan error, 1)
 	go func() {
@@ -148,12 +159,11 @@ func (s *StepDownload) download(config *DownloadConfig, state multistep.StateBag
 		downloadCompleteCh <- err
 	}()
 
-	progressTicker := time.NewTicker(5 * time.Second)
-	defer progressTicker.Stop()
-
 	for {
 		select {
 		case err := <-downloadCompleteCh:
+			bar.Finish()
+
 			if err != nil {
 				return "", err, true
 			}
@@ -164,13 +174,10 @@ func (s *StepDownload) download(config *DownloadConfig, state multistep.StateBag
 			}
 
 			return path, nil, true
-		case <-progressTicker.C:
-			progress := download.PercentProgress()
-			if progress >= 0 {
-				ui.Message(fmt.Sprintf("Download progress: %d%%", progress))
-			}
+
 		case <-time.After(1 * time.Second):
 			if _, ok := state.GetOk(multistep.StateCancelled); ok {
+				bar.Finish()
 				ui.Say("Interrupt received. Cancelling download...")
 				return "", nil, false
 			}
diff --git a/vendor/github.com/cheggaaa/pb/LICENSE b/vendor/github.com/cheggaaa/pb/LICENSE
new file mode 100644
index 000000000..511970333
--- /dev/null
+++ b/vendor/github.com/cheggaaa/pb/LICENSE
@@ -0,0 +1,12 @@
+Copyright (c) 2012-2015, Sergey Cherepanov
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+* Neither the name of the author nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
\ No newline at end of file
diff --git a/vendor/github.com/cheggaaa/pb/README.md b/vendor/github.com/cheggaaa/pb/README.md
new file mode 100644
index 000000000..948545110
--- /dev/null
+++ b/vendor/github.com/cheggaaa/pb/README.md
@@ -0,0 +1,179 @@
+# Terminal progress bar for Go  
+
+[![Join the chat at https://gitter.im/cheggaaa/pb](https://badges.gitter.im/cheggaaa/pb.svg)](https://gitter.im/cheggaaa/pb?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+Simple progress bar for console programs.    
+   
+Please check the new version https://github.com/cheggaaa/pb/tree/v2 (currently, it's beta)
+
+## Installation
+
+```
+go get gopkg.in/cheggaaa/pb.v1
+```   
+
+## Usage   
+
+```Go
+package main
+
+import (
+	"gopkg.in/cheggaaa/pb.v1"
+	"time"
+)
+
+func main() {
+	count := 100000
+	bar := pb.StartNew(count)
+	for i := 0; i < count; i++ {
+		bar.Increment()
+		time.Sleep(time.Millisecond)
+	}
+	bar.FinishPrint("The End!")
+}
+
+```
+
+Result will be like this:
+
+```
+> go run test.go
+37158 / 100000 [================>_______________________________] 37.16% 1m11s
+```
+
+## Customization
+
+```Go  
+// create bar
+bar := pb.New(count)
+
+// refresh info every second (default 200ms)
+bar.SetRefreshRate(time.Second)
+
+// show percents (by default already true)
+bar.ShowPercent = true
+
+// show bar (by default already true)
+bar.ShowBar = true
+
+// no counters
+bar.ShowCounters = false
+
+// show "time left"
+bar.ShowTimeLeft = true
+
+// show average speed
+bar.ShowSpeed = true
+
+// sets the width of the progress bar
+bar.SetWidth(80)
+
+// sets the width of the progress bar, but if terminal size smaller will be ignored
+bar.SetMaxWidth(80)
+
+// convert output to readable format (like KB, MB)
+bar.SetUnits(pb.U_BYTES)
+
+// and start
+bar.Start()
+``` 
+
+## Progress bar for IO Operations
+
+```go
+// create and start bar
+bar := pb.New(myDataLen).SetUnits(pb.U_BYTES)
+bar.Start()
+
+// my io.Reader
+r := myReader
+
+// my io.Writer
+w := myWriter
+
+// create proxy reader
+reader := bar.NewProxyReader(r)
+
+// and copy from pb reader
+io.Copy(w, reader)
+
+```
+
+```go
+// create and start bar
+bar := pb.New(myDataLen).SetUnits(pb.U_BYTES)
+bar.Start()
+
+// my io.Reader
+r := myReader
+
+// my io.Writer
+w := myWriter
+
+// create multi writer
+writer := io.MultiWriter(w, bar)
+
+// and copy
+io.Copy(writer, r)
+
+bar.Finish()
+```
+
+## Custom Progress Bar Look-and-feel
+
+```go
+bar.Format("<.- >")
+```
+
+## Multiple Progress Bars (experimental and unstable)
+
+Do not print to terminal while pool is active.
+
+```go
+package main
+
+import (
+    "math/rand"
+    "sync"
+    "time"
+
+    "gopkg.in/cheggaaa/pb.v1"
+)
+
+func main() {
+    // create bars
+    first := pb.New(200).Prefix("First ")
+    second := pb.New(200).Prefix("Second ")
+    third := pb.New(200).Prefix("Third ")
+    // start pool
+    pool, err := pb.StartPool(first, second, third)
+    if err != nil {
+        panic(err)
+    }
+    // update bars
+    wg := new(sync.WaitGroup)
+    for _, bar := range []*pb.ProgressBar{first, second, third} {
+        wg.Add(1)
+        go func(cb *pb.ProgressBar) {
+            for n := 0; n < 200; n++ {
+                cb.Increment()
+                time.Sleep(time.Millisecond * time.Duration(rand.Intn(100)))
+            }
+            cb.Finish()
+            wg.Done()
+        }(bar)
+    }
+    wg.Wait()
+    // close pool
+    pool.Stop()
+}
+```
+
+The result will be as follows:
+
+```
+$ go run example/multiple.go 
+First 141 / 1000 [===============>---------------------------------------] 14.10 % 44s
+Second 139 / 1000 [==============>---------------------------------------] 13.90 % 44s
+Third 152 / 1000 [================>--------------------------------------] 15.20 % 40s
+```
diff --git a/vendor/github.com/cheggaaa/pb/format.go b/vendor/github.com/cheggaaa/pb/format.go
new file mode 100644
index 000000000..0723561c2
--- /dev/null
+++ b/vendor/github.com/cheggaaa/pb/format.go
@@ -0,0 +1,118 @@
+package pb
+
+import (
+	"fmt"
+	"time"
+)
+
+type Units int
+
+const (
+	// U_NO are default units, they represent a simple value and are not formatted at all.
+	U_NO Units = iota
+	// U_BYTES units are formatted in a human readable way (B, KiB, MiB, ...)
+	U_BYTES
+	// U_BYTES_DEC units are like U_BYTES, but base 10 (B, KB, MB, ...)
+	U_BYTES_DEC
+	// U_DURATION units are formatted in a human readable way (3h14m15s)
+	U_DURATION
+)
+
+const (
+	KiB = 1024
+	MiB = 1048576
+	GiB = 1073741824
+	TiB = 1099511627776
+
+	KB = 1e3
+	MB = 1e6
+	GB = 1e9
+	TB = 1e12
+)
+
+func Format(i int64) *formatter {
+	return &formatter{n: i}
+}
+
+type formatter struct {
+	n      int64
+	unit   Units
+	width  int
+	perSec bool
+}
+
+func (f *formatter) To(unit Units) *formatter {
+	f.unit = unit
+	return f
+}
+
+func (f *formatter) Width(width int) *formatter {
+	f.width = width
+	return f
+}
+
+func (f *formatter) PerSec() *formatter {
+	f.perSec = true
+	return f
+}
+
+func (f *formatter) String() (out string) {
+	switch f.unit {
+	case U_BYTES:
+		out = formatBytes(f.n)
+	case U_BYTES_DEC:
+		out = formatBytesDec(f.n)
+	case U_DURATION:
+		out = formatDuration(f.n)
+	default:
+		out = fmt.Sprintf(fmt.Sprintf("%%%dd", f.width), f.n)
+	}
+	if f.perSec {
+		out += "/s"
+	}
+	return
+}
+
+// Convert bytes to human readable string. Like 2 MiB, 64.2 KiB, 52 B
+func formatBytes(i int64) (result string) {
+	switch {
+	case i >= TiB:
+		result = fmt.Sprintf("%.02f TiB", float64(i)/TiB)
+	case i >= GiB:
+		result = fmt.Sprintf("%.02f GiB", float64(i)/GiB)
+	case i >= MiB:
+		result = fmt.Sprintf("%.02f MiB", float64(i)/MiB)
+	case i >= KiB:
+		result = fmt.Sprintf("%.02f KiB", float64(i)/KiB)
+	default:
+		result = fmt.Sprintf("%d B", i)
+	}
+	return
+}
+
+// Convert bytes to base-10 human readable string. Like 2 MB, 64.2 KB, 52 B
+func formatBytesDec(i int64) (result string) {
+	switch {
+	case i >= TB:
+		result = fmt.Sprintf("%.02f TB", float64(i)/TB)
+	case i >= GB:
+		result = fmt.Sprintf("%.02f GB", float64(i)/GB)
+	case i >= MB:
+		result = fmt.Sprintf("%.02f MB", float64(i)/MB)
+	case i >= KB:
+		result = fmt.Sprintf("%.02f KB", float64(i)/KB)
+	default:
+		result = fmt.Sprintf("%d B", i)
+	}
+	return
+}
+
+func formatDuration(n int64) (result string) {
+	d := time.Duration(n)
+	if d > time.Hour*24 {
+		result = fmt.Sprintf("%dd", d/24/time.Hour)
+		d -= (d / time.Hour / 24) * (time.Hour * 24)
+	}
+	result = fmt.Sprintf("%s%v", result, d)
+	return
+}
diff --git a/vendor/github.com/cheggaaa/pb/pb.go b/vendor/github.com/cheggaaa/pb/pb.go
new file mode 100644
index 000000000..19eb4d1a9
--- /dev/null
+++ b/vendor/github.com/cheggaaa/pb/pb.go
@@ -0,0 +1,469 @@
+// Simple console progress bars
+package pb
+
+import (
+	"fmt"
+	"io"
+	"math"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+	"unicode/utf8"
+)
+
+// Current version
+const Version = "1.0.19"
+
+const (
+	// Default refresh rate - 200ms
+	DEFAULT_REFRESH_RATE = time.Millisecond * 200
+	FORMAT               = "[=>-]"
+)
+
+// DEPRECATED
+// variables for backward compatibility, from now do not work
+// use pb.Format and pb.SetRefreshRate
+var (
+	DefaultRefreshRate                         = DEFAULT_REFRESH_RATE
+	BarStart, BarEnd, Empty, Current, CurrentN string
+)
+
+// Create new progress bar object
+func New(total int) *ProgressBar {
+	return New64(int64(total))
+}
+
+// Create new progress bar object using int64 as total
+func New64(total int64) *ProgressBar {
+	pb := &ProgressBar{
+		Total:         total,
+		RefreshRate:   DEFAULT_REFRESH_RATE,
+		ShowPercent:   true,
+		ShowCounters:  true,
+		ShowBar:       true,
+		ShowTimeLeft:  true,
+		ShowFinalTime: true,
+		Units:         U_NO,
+		ManualUpdate:  false,
+		finish:        make(chan struct{}),
+	}
+	return pb.Format(FORMAT)
+}
+
+// Create new object and start
+func StartNew(total int) *ProgressBar {
+	return New(total).Start()
+}
+
+// Callback for custom output
+// For example:
+// bar.Callback = func(s string) {
+//     mySuperPrint(s)
+// }
+//
+type Callback func(out string)
+
+type ProgressBar struct {
+	current  int64 // current must be first member of struct (https://code.google.com/p/go/issues/detail?id=5278)
+	previous int64
+
+	Total                            int64
+	RefreshRate                      time.Duration
+	ShowPercent, ShowCounters        bool
+	ShowSpeed, ShowTimeLeft, ShowBar bool
+	ShowFinalTime                    bool
+	Output                           io.Writer
+	Callback                         Callback
+	NotPrint                         bool
+	Units                            Units
+	Width                            int
+	ForceWidth                       bool
+	ManualUpdate                     bool
+	AutoStat                         bool
+
+	// Default width for the time box.
+	UnitsWidth   int
+	TimeBoxWidth int
+
+	finishOnce sync.Once //Guards isFinish
+	finish     chan struct{}
+	isFinish   bool
+
+	startTime  time.Time
+	startValue int64
+
+	changeTime time.Time
+
+	prefix, postfix string
+
+	mu        sync.Mutex
+	lastPrint string
+
+	BarStart string
+	BarEnd   string
+	Empty    string
+	Current  string
+	CurrentN string
+
+	AlwaysUpdate bool
+}
+
+// Start print
+func (pb *ProgressBar) Start() *ProgressBar {
+	pb.startTime = time.Now()
+	pb.startValue = atomic.LoadInt64(&pb.current)
+	if pb.Total == 0 {
+		pb.ShowTimeLeft = false
+		pb.ShowPercent = false
+		pb.AutoStat = false
+	}
+	if !pb.ManualUpdate {
+		pb.Update() // Initial printing of the bar before running the bar refresher.
+		go pb.refresher()
+	}
+	return pb
+}
+
+// Increment current value
+func (pb *ProgressBar) Increment() int {
+	return pb.Add(1)
+}
+
+// Get current value
+func (pb *ProgressBar) Get() int64 {
+	c := atomic.LoadInt64(&pb.current)
+	return c
+}
+
+// Set current value
+func (pb *ProgressBar) Set(current int) *ProgressBar {
+	return pb.Set64(int64(current))
+}
+
+// Set64 sets the current value as int64
+func (pb *ProgressBar) Set64(current int64) *ProgressBar {
+	atomic.StoreInt64(&pb.current, current)
+	return pb
+}
+
+// Add to current value
+func (pb *ProgressBar) Add(add int) int {
+	return int(pb.Add64(int64(add)))
+}
+
+func (pb *ProgressBar) Add64(add int64) int64 {
+	return atomic.AddInt64(&pb.current, add)
+}
+
+// Set prefix string
+func (pb *ProgressBar) Prefix(prefix string) *ProgressBar {
+	pb.prefix = prefix
+	return pb
+}
+
+// Set postfix string
+func (pb *ProgressBar) Postfix(postfix string) *ProgressBar {
+	pb.postfix = postfix
+	return pb
+}
+
+// Set custom format for bar
+// Example: bar.Format("[=>_]")
+// Example: bar.Format("[\x00=\x00>\x00-\x00]") // \x00 is the delimiter
+func (pb *ProgressBar) Format(format string) *ProgressBar {
+	var formatEntries []string
+	if utf8.RuneCountInString(format) == 5 {
+		formatEntries = strings.Split(format, "")
+	} else {
+		formatEntries = strings.Split(format, "\x00")
+	}
+	if len(formatEntries) == 5 {
+		pb.BarStart = formatEntries[0]
+		pb.BarEnd = formatEntries[4]
+		pb.Empty = formatEntries[3]
+		pb.Current = formatEntries[1]
+		pb.CurrentN = formatEntries[2]
+	}
+	return pb
+}
+
+// Set bar refresh rate
+func (pb *ProgressBar) SetRefreshRate(rate time.Duration) *ProgressBar {
+	pb.RefreshRate = rate
+	return pb
+}
+
+// Set units
+// bar.SetUnits(U_NO) - by default
+// bar.SetUnits(U_BYTES) - for Mb, Kb, etc
+func (pb *ProgressBar) SetUnits(units Units) *ProgressBar {
+	pb.Units = units
+	return pb
+}
+
+// Set max width, if width is bigger than terminal width, will be ignored
+func (pb *ProgressBar) SetMaxWidth(width int) *ProgressBar {
+	pb.Width = width
+	pb.ForceWidth = false
+	return pb
+}
+
+// Set bar width
+func (pb *ProgressBar) SetWidth(width int) *ProgressBar {
+	pb.Width = width
+	pb.ForceWidth = true
+	return pb
+}
+
+// End print
+func (pb *ProgressBar) Finish() {
+	//Protect multiple calls
+	pb.finishOnce.Do(func() {
+		close(pb.finish)
+		pb.write(atomic.LoadInt64(&pb.current))
+		pb.mu.Lock()
+		defer pb.mu.Unlock()
+		switch {
+		case pb.Output != nil:
+			fmt.Fprintln(pb.Output)
+		case !pb.NotPrint:
+			fmt.Println()
+		}
+		pb.isFinish = true
+	})
+}
+
+// IsFinished return boolean
+func (pb *ProgressBar) IsFinished() bool {
+	pb.mu.Lock()
+	defer pb.mu.Unlock()
+	return pb.isFinish
+}
+
+// End print and write string 'str'
+func (pb *ProgressBar) FinishPrint(str string) {
+	pb.Finish()
+	if pb.Output != nil {
+		fmt.Fprintln(pb.Output, str)
+	} else {
+		fmt.Println(str)
+	}
+}
+
+// implement io.Writer
+func (pb *ProgressBar) Write(p []byte) (n int, err error) {
+	n = len(p)
+	pb.Add(n)
+	return
+}
+
+// implement io.Reader
+func (pb *ProgressBar) Read(p []byte) (n int, err error) {
+	n = len(p)
+	pb.Add(n)
+	return
+}
+
+// Create new proxy reader over bar
+// Takes io.Reader or io.ReadCloser
+func (pb *ProgressBar) NewProxyReader(r io.Reader) *Reader {
+	return &Reader{r, pb}
+}
+
+func (pb *ProgressBar) write(current int64) {
+	width := pb.GetWidth()
+
+	var percentBox, countersBox, timeLeftBox, speedBox, barBox, end, out string
+
+	// percents
+	if pb.ShowPercent {
+		var percent float64
+		if pb.Total > 0 {
+			percent = float64(current) / (float64(pb.Total) / float64(100))
+		} else {
+			percent = float64(current) / float64(100)
+		}
+		percentBox = fmt.Sprintf(" %6.02f%%", percent)
+	}
+
+	// counters
+	if pb.ShowCounters {
+		current := Format(current).To(pb.Units).Width(pb.UnitsWidth)
+		if pb.Total > 0 {
+			total := Format(pb.Total).To(pb.Units).Width(pb.UnitsWidth)
+			countersBox = fmt.Sprintf(" %s / %s ", current, total)
+		} else {
+			countersBox = fmt.Sprintf(" %s / ? ", current)
+		}
+	}
+
+	// time left
+	pb.mu.Lock()
+	currentFromStart := current - pb.startValue
+	fromStart := time.Now().Sub(pb.startTime)
+	lastChangeTime := pb.changeTime
+	fromChange := lastChangeTime.Sub(pb.startTime)
+	pb.mu.Unlock()
+	select {
+	case <-pb.finish:
+		if pb.ShowFinalTime {
+			var left time.Duration
+			left = (fromStart / time.Second) * time.Second
+			timeLeftBox = fmt.Sprintf(" %s", left.String())
+		}
+	default:
+		if pb.ShowTimeLeft && currentFromStart > 0 {
+			perEntry := fromChange / time.Duration(currentFromStart)
+			var left time.Duration
+			if pb.Total > 0 {
+				left = time.Duration(pb.Total-currentFromStart) * perEntry
+				left -= time.Since(lastChangeTime)
+				left = (left / time.Second) * time.Second
+			} else {
+				left = time.Duration(currentFromStart) * perEntry
+				left = (left / time.Second) * time.Second
+			}
+			if left > 0 {
+				timeLeft := Format(int64(left)).To(U_DURATION).String()
+				timeLeftBox = fmt.Sprintf(" %s", timeLeft)
+			}
+		}
+	}
+
+	if len(timeLeftBox) < pb.TimeBoxWidth {
+		timeLeftBox = fmt.Sprintf("%s%s", strings.Repeat(" ", pb.TimeBoxWidth-len(timeLeftBox)), timeLeftBox)
+	}
+
+	// speed
+	if pb.ShowSpeed && currentFromStart > 0 {
+		fromStart := time.Now().Sub(pb.startTime)
+		speed := float64(currentFromStart) / (float64(fromStart) / float64(time.Second))
+		speedBox = " " + Format(int64(speed)).To(pb.Units).Width(pb.UnitsWidth).PerSec().String()
+	}
+
+	barWidth := escapeAwareRuneCountInString(countersBox + pb.BarStart + pb.BarEnd + percentBox + timeLeftBox + speedBox + pb.prefix + pb.postfix)
+	// bar
+	if pb.ShowBar {
+		size := width - barWidth
+		if size > 0 {
+			if pb.Total > 0 {
+				curSize := int(math.Ceil((float64(current) / float64(pb.Total)) * float64(size)))
+				emptySize := size - curSize
+				barBox = pb.BarStart
+				if emptySize < 0 {
+					emptySize = 0
+				}
+				if curSize > size {
+					curSize = size
+				}
+
+				cursorLen := escapeAwareRuneCountInString(pb.Current)
+				if emptySize <= 0 {
+					barBox += strings.Repeat(pb.Current, curSize/cursorLen)
+				} else if curSize > 0 {
+					cursorEndLen := escapeAwareRuneCountInString(pb.CurrentN)
+					cursorRepetitions := (curSize - cursorEndLen) / cursorLen
+					barBox += strings.Repeat(pb.Current, cursorRepetitions)
+					barBox += pb.CurrentN
+				}
+
+				emptyLen := escapeAwareRuneCountInString(pb.Empty)
+				barBox += strings.Repeat(pb.Empty, emptySize/emptyLen)
+				barBox += pb.BarEnd
+			} else {
+				pos := size - int(current)%int(size)
+				barBox = pb.BarStart
+				if pos-1 > 0 {
+					barBox += strings.Repeat(pb.Empty, pos-1)
+				}
+				barBox += pb.Current
+				if size-pos-1 > 0 {
+					barBox += strings.Repeat(pb.Empty, size-pos-1)
+				}
+				barBox += pb.BarEnd
+			}
+		}
+	}
+
+	// check len
+	out = pb.prefix + countersBox + barBox + percentBox + speedBox + timeLeftBox + pb.postfix
+	if cl := escapeAwareRuneCountInString(out); cl < width {
+		end = strings.Repeat(" ", width-cl)
+	}
+
+	// and print!
+	pb.mu.Lock()
+	pb.lastPrint = out + end
+	isFinish := pb.isFinish
+	pb.mu.Unlock()
+	switch {
+	case isFinish:
+		return
+	case pb.Output != nil:
+		fmt.Fprint(pb.Output, "\r"+out+end)
+	case pb.Callback != nil:
+		pb.Callback(out + end)
+	case !pb.NotPrint:
+		fmt.Print("\r" + out + end)
+	}
+}
+
+// GetTerminalWidth - returns terminal width for all platforms.
+func GetTerminalWidth() (int, error) {
+	return terminalWidth()
+}
+
+func (pb *ProgressBar) GetWidth() int {
+	if pb.ForceWidth {
+		return pb.Width
+	}
+
+	width := pb.Width
+	termWidth, _ := terminalWidth()
+	if width == 0 || termWidth <= width {
+		width = termWidth
+	}
+
+	return width
+}
+
+// Write the current state of the progressbar
+func (pb *ProgressBar) Update() {
+	c := atomic.LoadInt64(&pb.current)
+	p := atomic.LoadInt64(&pb.previous)
+	if p != c {
+		pb.mu.Lock()
+		pb.changeTime = time.Now()
+		pb.mu.Unlock()
+		atomic.StoreInt64(&pb.previous, c)
+	}
+	pb.write(c)
+	if pb.AutoStat {
+		if c == 0 {
+			pb.startTime = time.Now()
+			pb.startValue = 0
+		} else if c >= pb.Total && pb.isFinish != true {
+			pb.Finish()
+		}
+	}
+}
+
+// String return the last bar print
+func (pb *ProgressBar) String() string {
+	pb.mu.Lock()
+	defer pb.mu.Unlock()
+	return pb.lastPrint
+}
+
+// Internal loop for refreshing the progressbar
+func (pb *ProgressBar) refresher() {
+	for {
+		select {
+		case <-pb.finish:
+			return
+		case <-time.After(pb.RefreshRate):
+			pb.Update()
+		}
+	}
+}
diff --git a/vendor/github.com/cheggaaa/pb/pb_win.go b/vendor/github.com/cheggaaa/pb/pb_win.go
new file mode 100644
index 000000000..72f682835
--- /dev/null
+++ b/vendor/github.com/cheggaaa/pb/pb_win.go
@@ -0,0 +1,141 @@
+// +build windows
+
+package pb
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"sync"
+	"syscall"
+	"unsafe"
+)
+
+var tty = os.Stdin
+
+var (
+	kernel32 = syscall.NewLazyDLL("kernel32.dll")
+
+	// GetConsoleScreenBufferInfo retrieves information about the
+	// specified console screen buffer.
+	// http://msdn.microsoft.com/en-us/library/windows/desktop/ms683171(v=vs.85).aspx
+	procGetConsoleScreenBufferInfo = kernel32.NewProc("GetConsoleScreenBufferInfo")
+
+	// GetConsoleMode retrieves the current input mode of a console's
+	// input buffer or the current output mode of a console screen buffer.
+	// https://msdn.microsoft.com/en-us/library/windows/desktop/ms683167(v=vs.85).aspx
+	getConsoleMode = kernel32.NewProc("GetConsoleMode")
+
+	// SetConsoleMode sets the input mode of a console's input buffer
+	// or the output mode of a console screen buffer.
+	// https://msdn.microsoft.com/en-us/library/windows/desktop/ms686033(v=vs.85).aspx
+	setConsoleMode = kernel32.NewProc("SetConsoleMode")
+
+	// SetConsoleCursorPosition sets the cursor position in the
+	// specified console screen buffer.
+	// https://msdn.microsoft.com/en-us/library/windows/desktop/ms686025(v=vs.85).aspx
+	setConsoleCursorPosition = kernel32.NewProc("SetConsoleCursorPosition")
+)
+
+type (
+	// Defines the coordinates of the upper left and lower right corners
+	// of a rectangle.
+	// See
+	// http://msdn.microsoft.com/en-us/library/windows/desktop/ms686311(v=vs.85).aspx
+	smallRect struct {
+		Left, Top, Right, Bottom int16
+	}
+
+	// Defines the coordinates of a character cell in a console screen
+	// buffer. The origin of the coordinate system (0,0) is at the top, left cell
+	// of the buffer.
+	// See
+	// http://msdn.microsoft.com/en-us/library/windows/desktop/ms682119(v=vs.85).aspx
+	coordinates struct {
+		X, Y int16
+	}
+
+	word int16
+
+	// Contains information about a console screen buffer.
+	// http://msdn.microsoft.com/en-us/library/windows/desktop/ms682093(v=vs.85).aspx
+	consoleScreenBufferInfo struct {
+		dwSize              coordinates
+		dwCursorPosition    coordinates
+		wAttributes         word
+		srWindow            smallRect
+		dwMaximumWindowSize coordinates
+	}
+)
+
+// terminalWidth returns width of the terminal.
+func terminalWidth() (width int, err error) {
+	var info consoleScreenBufferInfo
+	_, _, e := syscall.Syscall(procGetConsoleScreenBufferInfo.Addr(), 2, uintptr(syscall.Stdout), uintptr(unsafe.Pointer(&info)), 0)
+	if e != 0 {
+		return 0, error(e)
+	}
+	return int(info.dwSize.X) - 1, nil
+}
+
+func getCursorPos() (pos coordinates, err error) {
+	var info consoleScreenBufferInfo
+	_, _, e := syscall.Syscall(procGetConsoleScreenBufferInfo.Addr(), 2, uintptr(syscall.Stdout), uintptr(unsafe.Pointer(&info)), 0)
+	if e != 0 {
+		return info.dwCursorPosition, error(e)
+	}
+	return info.dwCursorPosition, nil
+}
+
+func setCursorPos(pos coordinates) error {
+	_, _, e := syscall.Syscall(setConsoleCursorPosition.Addr(), 2, uintptr(syscall.Stdout), uintptr(uint32(uint16(pos.Y))<<16|uint32(uint16(pos.X))), 0)
+	if e != 0 {
+		return error(e)
+	}
+	return nil
+}
+
+var ErrPoolWasStarted = errors.New("Bar pool was started")
+
+var echoLocked bool
+var echoLockMutex sync.Mutex
+
+var oldState word
+
+func lockEcho() (quit chan int, err error) {
+	echoLockMutex.Lock()
+	defer echoLockMutex.Unlock()
+	if echoLocked {
+		err = ErrPoolWasStarted
+		return
+	}
+	echoLocked = true
+
+	if _, _, e := syscall.Syscall(getConsoleMode.Addr(), 2, uintptr(syscall.Stdout), uintptr(unsafe.Pointer(&oldState)), 0); e != 0 {
+		err = fmt.Errorf("Can't get terminal settings: %v", e)
+		return
+	}
+
+	newState := oldState
+	const ENABLE_ECHO_INPUT = 0x0004
+	const ENABLE_LINE_INPUT = 0x0002
+	newState = newState & (^(ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT))
+	if _, _, e := syscall.Syscall(setConsoleMode.Addr(), 2, uintptr(syscall.Stdout), uintptr(newState), 0); e != 0 {
+		err = fmt.Errorf("Can't set terminal settings: %v", e)
+		return
+	}
+	return
+}
+
+func unlockEcho() (err error) {
+	echoLockMutex.Lock()
+	defer echoLockMutex.Unlock()
+	if !echoLocked {
+		return
+	}
+	echoLocked = false
+	if _, _, e := syscall.Syscall(setConsoleMode.Addr(), 2, uintptr(syscall.Stdout), uintptr(oldState), 0); e != 0 {
+		err = fmt.Errorf("Can't set terminal settings")
+	}
+	return
+}
diff --git a/vendor/github.com/cheggaaa/pb/pb_x.go b/vendor/github.com/cheggaaa/pb/pb_x.go
new file mode 100644
index 000000000..bbbe7c2d6
--- /dev/null
+++ b/vendor/github.com/cheggaaa/pb/pb_x.go
@@ -0,0 +1,108 @@
+// +build linux darwin freebsd netbsd openbsd solaris dragonfly
+// +build !appengine
+
+package pb
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"os/signal"
+	"sync"
+	"syscall"
+
+	"golang.org/x/sys/unix"
+)
+
+var ErrPoolWasStarted = errors.New("Bar pool was started")
+
+var (
+	echoLockMutex    sync.Mutex
+	origTermStatePtr *unix.Termios
+	tty              *os.File
+)
+
+func init() {
+	echoLockMutex.Lock()
+	defer echoLockMutex.Unlock()
+
+	var err error
+	tty, err = os.Open("/dev/tty")
+	if err != nil {
+		tty = os.Stdin
+	}
+}
+
+// terminalWidth returns width of the terminal.
+func terminalWidth() (int, error) {
+	echoLockMutex.Lock()
+	defer echoLockMutex.Unlock()
+
+	fd := int(tty.Fd())
+
+	ws, err := unix.IoctlGetWinsize(fd, unix.TIOCGWINSZ)
+	if err != nil {
+		return 0, err
+	}
+
+	return int(ws.Col), nil
+}
+
+func lockEcho() (quit chan int, err error) {
+	echoLockMutex.Lock()
+	defer echoLockMutex.Unlock()
+	if origTermStatePtr != nil {
+		return quit, ErrPoolWasStarted
+	}
+
+	fd := int(tty.Fd())
+
+	oldTermStatePtr, err := unix.IoctlGetTermios(fd, ioctlReadTermios)
+	if err != nil {
+		return nil, fmt.Errorf("Can't get terminal settings: %v", err)
+	}
+
+	oldTermios := *oldTermStatePtr
+	newTermios := oldTermios
+	newTermios.Lflag &^= syscall.ECHO
+	newTermios.Lflag |= syscall.ICANON | syscall.ISIG
+	newTermios.Iflag |= syscall.ICRNL
+	if err := unix.IoctlSetTermios(fd, ioctlWriteTermios, &newTermios); err != nil {
+		return nil, fmt.Errorf("Can't set terminal settings: %v", err)
+	}
+
+	quit = make(chan int, 1)
+	go catchTerminate(quit)
+	return
+}
+
+func unlockEcho() error {
+	echoLockMutex.Lock()
+	defer echoLockMutex.Unlock()
+	if origTermStatePtr == nil {
+		return nil
+	}
+
+	fd := int(tty.Fd())
+
+	if err := unix.IoctlSetTermios(fd, ioctlWriteTermios, origTermStatePtr); err != nil {
+		return fmt.Errorf("Can't set terminal settings: %v", err)
+	}
+
+	origTermStatePtr = nil
+
+	return nil
+}
+
+// listen exit signals and restore terminal state
+func catchTerminate(quit chan int) {
+	sig := make(chan os.Signal, 1)
+	signal.Notify(sig, os.Interrupt, syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGKILL)
+	defer signal.Stop(sig)
+	select {
+	case <-quit:
+		unlockEcho()
+	case <-sig:
+		unlockEcho()
+	}
+}
diff --git a/vendor/github.com/cheggaaa/pb/pool.go b/vendor/github.com/cheggaaa/pb/pool.go
new file mode 100644
index 000000000..bc1a13886
--- /dev/null
+++ b/vendor/github.com/cheggaaa/pb/pool.go
@@ -0,0 +1,82 @@
+// +build linux darwin freebsd netbsd openbsd solaris dragonfly windows
+
+package pb
+
+import (
+	"io"
+	"sync"
+	"time"
+)
+
+// Create and start new pool with given bars
+// You need call pool.Stop() after work
+func StartPool(pbs ...*ProgressBar) (pool *Pool, err error) {
+	pool = new(Pool)
+	if err = pool.start(); err != nil {
+		return
+	}
+	pool.Add(pbs...)
+	return
+}
+
+type Pool struct {
+	Output        io.Writer
+	RefreshRate   time.Duration
+	bars          []*ProgressBar
+	lastBarsCount int
+	quit          chan int
+	m             sync.Mutex
+	finishOnce    sync.Once
+}
+
+// Add progress bars.
+func (p *Pool) Add(pbs ...*ProgressBar) {
+	p.m.Lock()
+	defer p.m.Unlock()
+	for _, bar := range pbs {
+		bar.ManualUpdate = true
+		bar.NotPrint = true
+		bar.Start()
+		p.bars = append(p.bars, bar)
+	}
+}
+
+func (p *Pool) start() (err error) {
+	p.RefreshRate = DefaultRefreshRate
+	quit, err := lockEcho()
+	if err != nil {
+		return
+	}
+	p.quit = make(chan int)
+	go p.writer(quit)
+	return
+}
+
+func (p *Pool) writer(finish chan int) {
+	var first = true
+	for {
+		select {
+		case <-time.After(p.RefreshRate):
+			if p.print(first) {
+				p.print(false)
+				finish <- 1
+				return
+			}
+			first = false
+		case <-p.quit:
+			finish <- 1
+			return
+		}
+	}
+}
+
+// Restore terminal state and close pool
+func (p *Pool) Stop() error {
+	// Wait until one final refresh has passed.
+	time.Sleep(p.RefreshRate)
+
+	p.finishOnce.Do(func() {
+		close(p.quit)
+	})
+	return unlockEcho()
+}
diff --git a/vendor/github.com/cheggaaa/pb/pool_win.go b/vendor/github.com/cheggaaa/pb/pool_win.go
new file mode 100644
index 000000000..63598d378
--- /dev/null
+++ b/vendor/github.com/cheggaaa/pb/pool_win.go
@@ -0,0 +1,45 @@
+// +build windows
+
+package pb
+
+import (
+	"fmt"
+	"log"
+)
+
+func (p *Pool) print(first bool) bool {
+	p.m.Lock()
+	defer p.m.Unlock()
+	var out string
+	if !first {
+		coords, err := getCursorPos()
+		if err != nil {
+			log.Panic(err)
+		}
+		coords.Y -= int16(p.lastBarsCount)
+		if coords.Y < 0 {
+			coords.Y = 0
+		}
+		coords.X = 0
+
+		err = setCursorPos(coords)
+		if err != nil {
+			log.Panic(err)
+		}
+	}
+	isFinished := true
+	for _, bar := range p.bars {
+		if !bar.IsFinished() {
+			isFinished = false
+		}
+		bar.Update()
+		out += fmt.Sprintf("\r%s\n", bar.String())
+	}
+	if p.Output != nil {
+		fmt.Fprint(p.Output, out)
+	} else {
+		fmt.Print(out)
+	}
+	p.lastBarsCount = len(p.bars)
+	return isFinished
+}
diff --git a/vendor/github.com/cheggaaa/pb/pool_x.go b/vendor/github.com/cheggaaa/pb/pool_x.go
new file mode 100644
index 000000000..a8ae14d2f
--- /dev/null
+++ b/vendor/github.com/cheggaaa/pb/pool_x.go
@@ -0,0 +1,29 @@
+// +build linux darwin freebsd netbsd openbsd solaris dragonfly
+
+package pb
+
+import "fmt"
+
+func (p *Pool) print(first bool) bool {
+	p.m.Lock()
+	defer p.m.Unlock()
+	var out string
+	if !first {
+		out = fmt.Sprintf("\033[%dA", p.lastBarsCount)
+	}
+	isFinished := true
+	for _, bar := range p.bars {
+		if !bar.IsFinished() {
+			isFinished = false
+		}
+		bar.Update()
+		out += fmt.Sprintf("\r%s\n", bar.String())
+	}
+	if p.Output != nil {
+		fmt.Fprint(p.Output, out)
+	} else {
+		fmt.Print(out)
+	}
+	p.lastBarsCount = len(p.bars)
+	return isFinished
+}
diff --git a/vendor/github.com/cheggaaa/pb/reader.go b/vendor/github.com/cheggaaa/pb/reader.go
new file mode 100644
index 000000000..9f3148b54
--- /dev/null
+++ b/vendor/github.com/cheggaaa/pb/reader.go
@@ -0,0 +1,25 @@
+package pb
+
+import (
+	"io"
+)
+
+// It's proxy reader, implement io.Reader
+type Reader struct {
+	io.Reader
+	bar *ProgressBar
+}
+
+func (r *Reader) Read(p []byte) (n int, err error) {
+	n, err = r.Reader.Read(p)
+	r.bar.Add(n)
+	return
+}
+
+// Close the reader when it implements io.Closer
+func (r *Reader) Close() (err error) {
+	if closer, ok := r.Reader.(io.Closer); ok {
+		return closer.Close()
+	}
+	return
+}
diff --git a/vendor/github.com/cheggaaa/pb/runecount.go b/vendor/github.com/cheggaaa/pb/runecount.go
new file mode 100644
index 000000000..c617c55ec
--- /dev/null
+++ b/vendor/github.com/cheggaaa/pb/runecount.go
@@ -0,0 +1,17 @@
+package pb
+
+import (
+	"github.com/mattn/go-runewidth"
+	"regexp"
+)
+
+// Finds the control character sequences (like colors)
+var ctrlFinder = regexp.MustCompile("\x1b\x5b[0-9]+\x6d")
+
+func escapeAwareRuneCountInString(s string) int {
+	n := runewidth.StringWidth(s)
+	for _, sm := range ctrlFinder.FindAllString(s, -1) {
+		n -= runewidth.StringWidth(sm)
+	}
+	return n
+}
diff --git a/vendor/github.com/cheggaaa/pb/termios_bsd.go b/vendor/github.com/cheggaaa/pb/termios_bsd.go
new file mode 100644
index 000000000..517ea8ed7
--- /dev/null
+++ b/vendor/github.com/cheggaaa/pb/termios_bsd.go
@@ -0,0 +1,9 @@
+// +build darwin freebsd netbsd openbsd dragonfly
+// +build !appengine
+
+package pb
+
+import "syscall"
+
+const ioctlReadTermios = syscall.TIOCGETA
+const ioctlWriteTermios = syscall.TIOCSETA
diff --git a/vendor/github.com/cheggaaa/pb/termios_sysv.go b/vendor/github.com/cheggaaa/pb/termios_sysv.go
new file mode 100644
index 000000000..b10f61859
--- /dev/null
+++ b/vendor/github.com/cheggaaa/pb/termios_sysv.go
@@ -0,0 +1,13 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build linux solaris
+// +build !appengine
+
+package pb
+
+import "golang.org/x/sys/unix"
+
+const ioctlReadTermios = unix.TCGETS
+const ioctlWriteTermios = unix.TCSETS
diff --git a/vendor/vendor.json b/vendor/vendor.json
index 8e50f2acf..93f044f93 100644
--- a/vendor/vendor.json
+++ b/vendor/vendor.json
@@ -591,6 +591,12 @@
 			"revision": "528c74964609a58f7c17471525659c9b71cd499b",
 			"revisionTime": "2018-02-10T03:43:46Z"
 		},
+        {
+			"checksumSHA1": "ymc5+iJ+1ipls3ihqPdzMjFYCqo=",
+			"path": "github.com/cheggaaa/pb",
+			"revision": "18d384da9bdc1e5a08fc2a62a494c321d9ae74ea",
+			"revisionTime": "2017-12-14T13:20:59Z"
+		},
 		{
 			"checksumSHA1": "/5cvgU+J4l7EhMXTK76KaCAfOuU=",
 			"comment": "v1.0.0-3-g6d21280",