9 files changed, 1070 insertions, 0 deletions
diff --git a/vendor/github.com/vbauerster/mpb/decor/counters.go b/vendor/github.com/vbauerster/mpb/decor/counters.go
new file mode 100644
index 000000000..e4161dc4b
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/decor/counters.go
@@ -0,0 +1,206 @@
+package decor
+
+import (
+	"fmt"
+	"io"
+	"strconv"
+	"strings"
+)
+
+const (
+	_   = iota
+	KiB = 1 << (iota * 10)
+	MiB
+	GiB
+	TiB
+)
+
+const (
+	KB = 1000
+	MB = KB * 1000
+	GB = MB * 1000
+	TB = GB * 1000
+)
+
+const (
+	_ = iota
+	UnitKiB
+	UnitKB
+)
+
+type CounterKiB int64
+
+func (c CounterKiB) Format(st fmt.State, verb rune) {
+	prec, ok := st.Precision()
+
+	if verb == 'd' || !ok {
+		prec = 0
+	}
+	if verb == 'f' && !ok {
+		prec = 6
+	}
+	// retain old beahavior if s verb used
+	if verb == 's' {
+		prec = 1
+	}
+
+	var res, unit string
+	switch {
+	case c >= TiB:
+		unit = "TiB"
+		res = strconv.FormatFloat(float64(c)/TiB, 'f', prec, 64)
+	case c >= GiB:
+		unit = "GiB"
+		res = strconv.FormatFloat(float64(c)/GiB, 'f', prec, 64)
+	case c >= MiB:
+		unit = "MiB"
+		res = strconv.FormatFloat(float64(c)/MiB, 'f', prec, 64)
+	case c >= KiB:
+		unit = "KiB"
+		res = strconv.FormatFloat(float64(c)/KiB, 'f', prec, 64)
+	default:
+		unit = "b"
+		res = strconv.FormatInt(int64(c), 10)
+	}
+
+	if st.Flag(' ') {
+		res += " "
+	}
+	res += unit
+
+	if w, ok := st.Width(); ok {
+		if len(res) < w {
+			pad := strings.Repeat(" ", w-len(res))
+			if st.Flag(int('-')) {
+				res += pad
+			} else {
+				res = pad + res
+			}
+		}
+	}
+
+	io.WriteString(st, res)
+}
+
+type CounterKB int64
+
+func (c CounterKB) Format(st fmt.State, verb rune) {
+	prec, ok := st.Precision()
+
+	if verb == 'd' || !ok {
+		prec = 0
+	}
+	if verb == 'f' && !ok {
+		prec = 6
+	}
+	// retain old beahavior if s verb used
+	if verb == 's' {
+		prec = 1
+	}
+
+	var res, unit string
+	switch {
+	case c >= TB:
+		unit = "TB"
+		res = strconv.FormatFloat(float64(c)/TB, 'f', prec, 64)
+	case c >= GB:
+		unit = "GB"
+		res = strconv.FormatFloat(float64(c)/GB, 'f', prec, 64)
+	case c >= MB:
+		unit = "MB"
+		res = strconv.FormatFloat(float64(c)/MB, 'f', prec, 64)
+	case c >= KB:
+		unit = "kB"
+		res = strconv.FormatFloat(float64(c)/KB, 'f', prec, 64)
+	default:
+		unit = "b"
+		res = strconv.FormatInt(int64(c), 10)
+	}
+
+	if st.Flag(' ') {
+		res += " "
+	}
+	res += unit
+
+	if w, ok := st.Width(); ok {
+		if len(res) < w {
+			pad := strings.Repeat(" ", w-len(res))
+			if st.Flag(int('-')) {
+				res += pad
+			} else {
+				res = pad + res
+			}
+		}
+	}
+
+	io.WriteString(st, res)
+}
+
+// CountersNoUnit is a wrapper around Counters with no unit param.
+func CountersNoUnit(pairFormat string, wcc ...WC) Decorator {
+	return Counters(0, pairFormat, wcc...)
+}
+
+// CountersKibiByte is a wrapper around Counters with predefined unit UnitKiB (bytes/1024).
+func CountersKibiByte(pairFormat string, wcc ...WC) Decorator {
+	return Counters(UnitKiB, pairFormat, wcc...)
+}
+
+// CountersKiloByte is a wrapper around Counters with predefined unit UnitKB (bytes/1000).
+func CountersKiloByte(pairFormat string, wcc ...WC) Decorator {
+	return Counters(UnitKB, pairFormat, wcc...)
+}
+
+// Counters decorator with dynamic unit measure adjustment.
+//
+//	`unit` one of [0|UnitKiB|UnitKB] zero for no unit
+//
+//	`pairFormat` printf compatible verbs for current and total, like "%f" or "%d"
+//
+//	`wcc` optional WC config
+//
+// pairFormat example if UnitKB is chosen:
+//
+//	"%.1f / %.1f" = "1.0MB / 12.0MB" or "% .1f / % .1f" = "1.0 MB / 12.0 MB"
+func Counters(unit int, pairFormat string, wcc ...WC) Decorator {
+	var wc WC
+	for _, widthConf := range wcc {
+		wc = widthConf
+	}
+	wc.Init()
+	d := &countersDecorator{
+		WC:         wc,
+		unit:       unit,
+		pairFormat: pairFormat,
+	}
+	return d
+}
+
+type countersDecorator struct {
+	WC
+	unit        int
+	pairFormat  string
+	completeMsg *string
+}
+
+func (d *countersDecorator) Decor(st *Statistics) string {
+	if st.Completed && d.completeMsg != nil {
+		return d.FormatMsg(*d.completeMsg)
+	}
+
+	var str string
+	switch d.unit {
+	case UnitKiB:
+		str = fmt.Sprintf(d.pairFormat, CounterKiB(st.Current), CounterKiB(st.Total))
+	case UnitKB:
+		str = fmt.Sprintf(d.pairFormat, CounterKB(st.Current), CounterKB(st.Total))
+	default:
+		str = fmt.Sprintf(d.pairFormat, st.Current, st.Total)
+	}
+
+	return d.FormatMsg(str)
+}
+
+func (d *countersDecorator) OnCompleteMessage(msg string) {
+	d.completeMsg = &msg
+}
diff --git a/vendor/github.com/vbauerster/mpb/decor/decorator.go b/vendor/github.com/vbauerster/mpb/decor/decorator.go
new file mode 100644
index 000000000..6aaf6c830
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/decor/decorator.go
@@ -0,0 +1,144 @@
+package decor
+
+import (
+	"fmt"
+	"time"
+	"unicode/utf8"
+)
+
+const (
+	// DidentRight bit specifies identation direction.
+	// |foo   |b     | With DidentRight
+	// |   foo|     b| Without DidentRight
+	DidentRight = 1 << iota
+
+	// DextraSpace bit adds extra space, makes sense with DSyncWidth only.
+	// When DidentRight bit set, the space will be added to the right,
+	// otherwise to the left.
+	DextraSpace
+
+	// DSyncWidth bit enables same column width synchronization.
+	// Effective with multiple bars only.
+	DSyncWidth
+
+	// DSyncWidthR is shortcut for DSyncWidth|DidentRight
+	DSyncWidthR = DSyncWidth | DidentRight
+
+	// DSyncSpace is shortcut for DSyncWidth|DextraSpace
+	DSyncSpace = DSyncWidth | DextraSpace
+
+	// DSyncSpaceR is shortcut for DSyncWidth|DextraSpace|DidentRight
+	DSyncSpaceR = DSyncWidth | DextraSpace | DidentRight
+)
+
+const (
+	ET_STYLE_GO = iota
+	ET_STYLE_HHMMSS
+	ET_STYLE_HHMM
+	ET_STYLE_MMSS
+)
+
+// Statistics is a struct, which gets passed to a Decorator.
+type Statistics struct {
+	ID        int
+	Completed bool
+	Total     int64
+	Current   int64
+}
+
+// Decorator interface.
+// A decorator must implement this interface, in order to be used with mpb library.
+type Decorator interface {
+	Decor(*Statistics) string
+	Syncable
+}
+
+// Syncable interface.
+// All decorators implement this interface implicitly.
+// Its Syncable method exposes width sync channel, if sync is enabled.
+type Syncable interface {
+	Syncable() (bool, chan int)
+}
+
+// OnCompleteMessenger interface.
+// Decorators implementing this interface suppose to return provided string on complete event.
+type OnCompleteMessenger interface {
+	OnCompleteMessage(string)
+}
+
+// AmountReceiver interface.
+// If decorator needs to receive increment amount,
+// so this is the right interface to implement.
+type AmountReceiver interface {
+	NextAmount(int, ...time.Duration)
+}
+
+// ShutdownListener interface.
+// If decorator needs to be notified once upon bar shutdown event,
+// so this is the right interface to implement.
+type ShutdownListener interface {
+	Shutdown()
+}
+
+// Global convenience shortcuts
+var (
+	WCSyncWidth  = WC{C: DSyncWidth}
+	WCSyncWidthR = WC{C: DSyncWidthR}
+	WCSyncSpace  = WC{C: DSyncSpace}
+	WCSyncSpaceR = WC{C: DSyncSpaceR}
+)
+
+// WC is a struct with two public fields W and C, both of int type.
+// W represents width and C represents bit set of width related config.
+type WC struct {
+	W      int
+	C      int
+	format string
+	wsync  chan int
+}
+
+// FormatMsg formats final message according to WC.W and WC.C.
+// Should be called by any Decorator implementation.
+func (wc WC) FormatMsg(msg string) string {
+	if (wc.C & DSyncWidth) != 0 {
+		wc.wsync <- utf8.RuneCountInString(msg)
+		max := <-wc.wsync
+		if max == 0 {
+			max = wc.W
+		}
+		if (wc.C & DextraSpace) != 0 {
+			max++
+		}
+		return fmt.Sprintf(fmt.Sprintf(wc.format, max), msg)
+	}
+	return fmt.Sprintf(fmt.Sprintf(wc.format, wc.W), msg)
+}
+
+// Init initializes width related config.
+func (wc *WC) Init() {
+	wc.format = "%%"
+	if (wc.C & DidentRight) != 0 {
+		wc.format += "-"
+	}
+	wc.format += "%ds"
+	if (wc.C & DSyncWidth) != 0 {
+		wc.wsync = make(chan int)
+	}
+}
+
+func (wc *WC) Syncable() (bool, chan int) {
+	return (wc.C & DSyncWidth) != 0, wc.wsync
+}
+
+// OnComplete returns decorator, which wraps provided decorator, with sole
+// purpose to display provided message on complete event.
+//
+//	`decorator` Decorator to wrap
+//
+//	`message` message to display on complete event
+func OnComplete(decorator Decorator, message string) Decorator {
+	if d, ok := decorator.(OnCompleteMessenger); ok {
+		d.OnCompleteMessage(message)
+	}
+	return decorator
+}
diff --git a/vendor/github.com/vbauerster/mpb/decor/doc.go b/vendor/github.com/vbauerster/mpb/decor/doc.go
new file mode 100644
index 000000000..561a8677c
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/decor/doc.go
@@ -0,0 +1,25 @@
+// Copyright (C) 2016-2018 Vladimir Bauer
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+/*
+ Package decor contains common decorators used by "github.com/vbauerster/mpb" package.
+
+ Some decorators returned by this package might have a closure state. It is ok to use
+ decorators concurrently, unless you share the same decorator among multiple
+ *mpb.Bar instances. To avoid data races, create new decorator per *mpb.Bar instance.
+
+ Don't:
+
+	 p := mpb.New()
+	 name := decor.Name("bar")
+	 p.AddBar(100, mpb.AppendDecorators(name))
+	 p.AddBar(100, mpb.AppendDecorators(name))
+
+ Do:
+
+	p := mpb.New()
+	p.AddBar(100, mpb.AppendDecorators(decor.Name("bar1")))
+	p.AddBar(100, mpb.AppendDecorators(decor.Name("bar2")))
+*/
+package decor
diff --git a/vendor/github.com/vbauerster/mpb/decor/elapsed.go b/vendor/github.com/vbauerster/mpb/decor/elapsed.go
new file mode 100644
index 000000000..649d40a30
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/decor/elapsed.go
@@ -0,0 +1,68 @@
+package decor
+
+import (
+	"fmt"
+	"time"
+)
+
+// Elapsed returns elapsed time decorator.
+//
+//	`style` one of [ET_STYLE_GO|ET_STYLE_HHMMSS|ET_STYLE_HHMM|ET_STYLE_MMSS]
+//
+//	`wcc` optional WC config
+func Elapsed(style int, wcc ...WC) Decorator {
+	var wc WC
+	for _, widthConf := range wcc {
+		wc = widthConf
+	}
+	wc.Init()
+	d := &elapsedDecorator{
+		WC:        wc,
+		style:     style,
+		startTime: time.Now(),
+	}
+	return d
+}
+
+type elapsedDecorator struct {
+	WC
+	style       int
+	startTime   time.Time
+	msg         string
+	completeMsg *string
+}
+
+func (d *elapsedDecorator) Decor(st *Statistics) string {
+	if st.Completed {
+		if d.completeMsg != nil {
+			return d.FormatMsg(*d.completeMsg)
+		}
+		return d.FormatMsg(d.msg)
+	}
+
+	timeElapsed := time.Since(d.startTime)
+	hours := int64((timeElapsed / time.Hour) % 60)
+	minutes := int64((timeElapsed / time.Minute) % 60)
+	seconds := int64((timeElapsed / time.Second) % 60)
+
+	switch d.style {
+	case ET_STYLE_GO:
+		d.msg = fmt.Sprint(time.Duration(timeElapsed.Seconds()) * time.Second)
+	case ET_STYLE_HHMMSS:
+		d.msg = fmt.Sprintf("%02d:%02d:%02d", hours, minutes, seconds)
+	case ET_STYLE_HHMM:
+		d.msg = fmt.Sprintf("%02d:%02d", hours, minutes)
+	case ET_STYLE_MMSS:
+		if hours > 0 {
+			d.msg = fmt.Sprintf("%02d:%02d:%02d", hours, minutes, seconds)
+		} else {
+			d.msg = fmt.Sprintf("%02d:%02d", minutes, seconds)
+		}
+	}
+
+	return d.FormatMsg(d.msg)
+}
+
+func (d *elapsedDecorator) OnCompleteMessage(msg string) {
+	d.completeMsg = &msg
+}
diff --git a/vendor/github.com/vbauerster/mpb/decor/eta.go b/vendor/github.com/vbauerster/mpb/decor/eta.go
new file mode 100644
index 000000000..44a1f03ea
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/decor/eta.go
@@ -0,0 +1,207 @@
+package decor
+
+import (
+	"fmt"
+	"math"
+	"time"
+
+	"github.com/VividCortex/ewma"
+	"github.com/vbauerster/mpb/internal"
+)
+
+type TimeNormalizer func(time.Duration) time.Duration
+
+// EwmaETA exponential-weighted-moving-average based ETA decorator.
+//
+//	`style` one of [ET_STYLE_GO|ET_STYLE_HHMMSS|ET_STYLE_HHMM|ET_STYLE_MMSS]
+//
+//	`age` is the previous N samples to average over.
+//
+//	`wcc` optional WC config
+func EwmaETA(style int, age float64, wcc ...WC) Decorator {
+	return MovingAverageETA(style, ewma.NewMovingAverage(age), NopNormalizer(), wcc...)
+}
+
+// MovingAverageETA decorator relies on MovingAverage implementation to calculate its average.
+//
+//	`style` one of [ET_STYLE_GO|ET_STYLE_HHMMSS|ET_STYLE_HHMM|ET_STYLE_MMSS]
+//
+//	`average` available implementations of MovingAverage [ewma.MovingAverage|NewMedian|NewMedianEwma]
+//
+//	`normalizer` available implementations are [NopNormalizer|FixedIntervalTimeNormalizer|MaxTolerateTimeNormalizer]
+//
+//	`wcc` optional WC config
+func MovingAverageETA(style int, average MovingAverage, normalizer TimeNormalizer, wcc ...WC) Decorator {
+	var wc WC
+	for _, widthConf := range wcc {
+		wc = widthConf
+	}
+	wc.Init()
+	d := &movingAverageETA{
+		WC:         wc,
+		style:      style,
+		average:    average,
+		normalizer: normalizer,
+	}
+	return d
+}
+
+type movingAverageETA struct {
+	WC
+	style       int
+	average     ewma.MovingAverage
+	completeMsg *string
+	normalizer  TimeNormalizer
+}
+
+func (d *movingAverageETA) Decor(st *Statistics) string {
+	if st.Completed && d.completeMsg != nil {
+		return d.FormatMsg(*d.completeMsg)
+	}
+
+	v := internal.Round(d.average.Value())
+	remaining := d.normalizer(time.Duration((st.Total - st.Current) * int64(v)))
+	hours := int64((remaining / time.Hour) % 60)
+	minutes := int64((remaining / time.Minute) % 60)
+	seconds := int64((remaining / time.Second) % 60)
+
+	var str string
+	switch d.style {
+	case ET_STYLE_GO:
+		str = fmt.Sprint(time.Duration(remaining.Seconds()) * time.Second)
+	case ET_STYLE_HHMMSS:
+		str = fmt.Sprintf("%02d:%02d:%02d", hours, minutes, seconds)
+	case ET_STYLE_HHMM:
+		str = fmt.Sprintf("%02d:%02d", hours, minutes)
+	case ET_STYLE_MMSS:
+		if hours > 0 {
+			str = fmt.Sprintf("%02d:%02d:%02d", hours, minutes, seconds)
+		} else {
+			str = fmt.Sprintf("%02d:%02d", minutes, seconds)
+		}
+	}
+
+	return d.FormatMsg(str)
+}
+
+func (d *movingAverageETA) NextAmount(n int, wdd ...time.Duration) {
+	var workDuration time.Duration
+	for _, wd := range wdd {
+		workDuration = wd
+	}
+	lastItemEstimate := float64(workDuration) / float64(n)
+	if math.IsInf(lastItemEstimate, 0) || math.IsNaN(lastItemEstimate) {
+		return
+	}
+	d.average.Add(lastItemEstimate)
+}
+
+func (d *movingAverageETA) OnCompleteMessage(msg string) {
+	d.completeMsg = &msg
+}
+
+// AverageETA decorator.
+//
+//	`style` one of [ET_STYLE_GO|ET_STYLE_HHMMSS|ET_STYLE_HHMM|ET_STYLE_MMSS]
+//
+//	`wcc` optional WC config
+func AverageETA(style int, wcc ...WC) Decorator {
+	var wc WC
+	for _, widthConf := range wcc {
+		wc = widthConf
+	}
+	wc.Init()
+	d := &averageETA{
+		WC:        wc,
+		style:     style,
+		startTime: time.Now(),
+	}
+	return d
+}
+
+type averageETA struct {
+	WC
+	style       int
+	startTime   time.Time
+	completeMsg *string
+}
+
+func (d *averageETA) Decor(st *Statistics) string {
+	if st.Completed && d.completeMsg != nil {
+		return d.FormatMsg(*d.completeMsg)
+	}
+
+	var str string
+	timeElapsed := time.Since(d.startTime)
+	v := internal.Round(float64(timeElapsed) / float64(st.Current))
+	if math.IsInf(v, 0) || math.IsNaN(v) {
+		v = 0
+	}
+	remaining := time.Duration((st.Total - st.Current) * int64(v))
+	hours := int64((remaining / time.Hour) % 60)
+	minutes := int64((remaining / time.Minute) % 60)
+	seconds := int64((remaining / time.Second) % 60)
+
+	switch d.style {
+	case ET_STYLE_GO:
+		str = fmt.Sprint(time.Duration(remaining.Seconds()) * time.Second)
+	case ET_STYLE_HHMMSS:
+		str = fmt.Sprintf("%02d:%02d:%02d", hours, minutes, seconds)
+	case ET_STYLE_HHMM:
+		str = fmt.Sprintf("%02d:%02d", hours, minutes)
+	case ET_STYLE_MMSS:
+		if hours > 0 {
+			str = fmt.Sprintf("%02d:%02d:%02d", hours, minutes, seconds)
+		} else {
+			str = fmt.Sprintf("%02d:%02d", minutes, seconds)
+		}
+	}
+
+	return d.FormatMsg(str)
+}
+
+func (d *averageETA) OnCompleteMessage(msg string) {
+	d.completeMsg = &msg
+}
+
+func MaxTolerateTimeNormalizer(maxTolerate time.Duration) TimeNormalizer {
+	var normalized time.Duration
+	var lastCall time.Time
+	return func(remaining time.Duration) time.Duration {
+		if diff := normalized - remaining; diff <= 0 || diff > maxTolerate || remaining < maxTolerate/2 {
+			normalized = remaining
+			lastCall = time.Now()
+			return remaining
+		}
+		normalized -= time.Since(lastCall)
+		lastCall = time.Now()
+		return normalized
+	}
+}
+
+func FixedIntervalTimeNormalizer(updInterval int) TimeNormalizer {
+	var normalized time.Duration
+	var lastCall time.Time
+	var count int
+	return func(remaining time.Duration) time.Duration {
+		if count == 0 || remaining <= time.Duration(15*time.Second) {
+			count = updInterval
+			normalized = remaining
+			lastCall = time.Now()
+			return remaining
+		}
+		count--
+		normalized -= time.Since(lastCall)
+		lastCall = time.Now()
+		if normalized > 0 {
+			return normalized
+		}
+		return remaining
+	}
+}
+
+func NopNormalizer() TimeNormalizer {
+	return func(remaining time.Duration) time.Duration {
+		return remaining
+	}
+}
diff --git a/vendor/github.com/vbauerster/mpb/decor/moving-average.go b/vendor/github.com/vbauerster/mpb/decor/moving-average.go
new file mode 100644
index 000000000..f9596a27f
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/decor/moving-average.go
@@ -0,0 +1,66 @@
+package decor
+
+import (
+	"sort"
+
+	"github.com/VividCortex/ewma"
+)
+
+// MovingAverage is the interface that computes a moving average over a time-
+// series stream of numbers. The average may be over a window or exponentially
+// decaying.
+type MovingAverage interface {
+	Add(float64)
+	Value() float64
+	Set(float64)
+}
+
+type medianWindow [3]float64
+
+func (s *medianWindow) Len() int           { return len(s) }
+func (s *medianWindow) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+func (s *medianWindow) Less(i, j int) bool { return s[i] < s[j] }
+
+func (s *medianWindow) Add(value float64) {
+	s[0], s[1] = s[1], s[2]
+	s[2] = value
+}
+
+func (s *medianWindow) Value() float64 {
+	tmp := *s
+	sort.Sort(&tmp)
+	return tmp[1]
+}
+
+func (s *medianWindow) Set(value float64) {
+	for i := 0; i < len(s); i++ {
+		s[i] = value
+	}
+}
+
+// NewMedian is fixed last 3 samples median MovingAverage.
+func NewMedian() MovingAverage {
+	return new(medianWindow)
+}
+
+type medianEwma struct {
+	count  uint
+	median MovingAverage
+	MovingAverage
+}
+
+func (s *medianEwma) Add(v float64) {
+	s.median.Add(v)
+	if s.count >= 2 {
+		s.MovingAverage.Add(s.median.Value())
+	}
+	s.count++
+}
+
+// NewMedianEwma is ewma based MovingAverage, which gets its values from median MovingAverage.
+func NewMedianEwma(age ...float64) MovingAverage {
+	return &medianEwma{
+		MovingAverage: ewma.NewMovingAverage(age...),
+		median:        NewMedian(),
+	}
+}
diff --git a/vendor/github.com/vbauerster/mpb/decor/name.go b/vendor/github.com/vbauerster/mpb/decor/name.go
new file mode 100644
index 000000000..a5a5d1469
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/decor/name.go
@@ -0,0 +1,45 @@
+package decor
+
+// StaticName returns name decorator.
+//
+//	`name` string to display
+//
+//	`wcc` optional WC config
+func StaticName(name string, wcc ...WC) Decorator {
+	return Name(name, wcc...)
+}
+
+// Name returns name decorator.
+//
+//	`name` string to display
+//
+//	`wcc` optional WC config
+func Name(name string, wcc ...WC) Decorator {
+	var wc WC
+	for _, widthConf := range wcc {
+		wc = widthConf
+	}
+	wc.Init()
+	d := &nameDecorator{
+		WC:  wc,
+		msg: name,
+	}
+	return d
+}
+
+type nameDecorator struct {
+	WC
+	msg      string
+	complete *string
+}
+
+func (d *nameDecorator) Decor(st *Statistics) string {
+	if st.Completed && d.complete != nil {
+		return d.FormatMsg(*d.complete)
+	}
+	return d.FormatMsg(d.msg)
+}
+
+func (d *nameDecorator) OnCompleteMessage(msg string) {
+	d.complete = &msg
+}
diff --git a/vendor/github.com/vbauerster/mpb/decor/percentage.go b/vendor/github.com/vbauerster/mpb/decor/percentage.go
new file mode 100644
index 000000000..078fbcf89
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/decor/percentage.go
@@ -0,0 +1,39 @@
+package decor
+
+import (
+	"fmt"
+
+	"github.com/vbauerster/mpb/internal"
+)
+
+// Percentage returns percentage decorator.
+//
+//	`wcc` optional WC config
+func Percentage(wcc ...WC) Decorator {
+	var wc WC
+	for _, widthConf := range wcc {
+		wc = widthConf
+	}
+	wc.Init()
+	d := &percentageDecorator{
+		WC: wc,
+	}
+	return d
+}
+
+type percentageDecorator struct {
+	WC
+	completeMsg *string
+}
+
+func (d *percentageDecorator) Decor(st *Statistics) string {
+	if st.Completed && d.completeMsg != nil {
+		return d.FormatMsg(*d.completeMsg)
+	}
+	str := fmt.Sprintf("%d %%", internal.Percentage(st.Total, st.Current, 100))
+	return d.FormatMsg(str)
+}
+
+func (d *percentageDecorator) OnCompleteMessage(msg string) {
+	d.completeMsg = &msg
+}
diff --git a/vendor/github.com/vbauerster/mpb/decor/speed.go b/vendor/github.com/vbauerster/mpb/decor/speed.go
new file mode 100644
index 000000000..395e5d04d
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/decor/speed.go
@@ -0,0 +1,270 @@
+package decor
+
+import (
+	"fmt"
+	"io"
+	"math"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/VividCortex/ewma"
+)
+
+type SpeedKiB float64
+
+func (s SpeedKiB) Format(st fmt.State, verb rune) {
+	prec, ok := st.Precision()
+
+	if verb == 'd' || !ok {
+		prec = 0
+	}
+	if verb == 'f' && !ok {
+		prec = 6
+	}
+	// retain old beahavior if s verb used
+	if verb == 's' {
+		prec = 1
+	}
+
+	var res, unit string
+	switch {
+	case s >= TiB:
+		unit = "TiB/s"
+		res = strconv.FormatFloat(float64(s)/TiB, 'f', prec, 64)
+	case s >= GiB:
+		unit = "GiB/s"
+		res = strconv.FormatFloat(float64(s)/GiB, 'f', prec, 64)
+	case s >= MiB:
+		unit = "MiB/s"
+		res = strconv.FormatFloat(float64(s)/MiB, 'f', prec, 64)
+	case s >= KiB:
+		unit = "KiB/s"
+		res = strconv.FormatFloat(float64(s)/KiB, 'f', prec, 64)
+	default:
+		unit = "b/s"
+		res = strconv.FormatInt(int64(s), 10)
+	}
+
+	if st.Flag(' ') {
+		res += " "
+	}
+	res += unit
+
+	if w, ok := st.Width(); ok {
+		if len(res) < w {
+			pad := strings.Repeat(" ", w-len(res))
+			if st.Flag(int('-')) {
+				res += pad
+			} else {
+				res = pad + res
+			}
+		}
+	}
+
+	io.WriteString(st, res)
+}
+
+type SpeedKB float64
+
+func (s SpeedKB) Format(st fmt.State, verb rune) {
+	prec, ok := st.Precision()
+
+	if verb == 'd' || !ok {
+		prec = 0
+	}
+	if verb == 'f' && !ok {
+		prec = 6
+	}
+	// retain old beahavior if s verb used
+	if verb == 's' {
+		prec = 1
+	}
+
+	var res, unit string
+	switch {
+	case s >= TB:
+		unit = "TB/s"
+		res = strconv.FormatFloat(float64(s)/TB, 'f', prec, 64)
+	case s >= GB:
+		unit = "GB/s"
+		res = strconv.FormatFloat(float64(s)/GB, 'f', prec, 64)
+	case s >= MB:
+		unit = "MB/s"
+		res = strconv.FormatFloat(float64(s)/MB, 'f', prec, 64)
+	case s >= KB:
+		unit = "kB/s"
+		res = strconv.FormatFloat(float64(s)/KB, 'f', prec, 64)
+	default:
+		unit = "b/s"
+		res = strconv.FormatInt(int64(s), 10)
+	}
+
+	if st.Flag(' ') {
+		res += " "
+	}
+	res += unit
+
+	if w, ok := st.Width(); ok {
+		if len(res) < w {
+			pad := strings.Repeat(" ", w-len(res))
+			if st.Flag(int('-')) {
+				res += pad
+			} else {
+				res = pad + res
+			}
+		}
+	}
+
+	io.WriteString(st, res)
+}
+
+// EwmaSpeed exponential-weighted-moving-average based speed decorator,
+// with dynamic unit measure adjustment.
+//
+//	`unit` one of [0|UnitKiB|UnitKB] zero for no unit
+//
+//	`unitFormat` printf compatible verb for value, like "%f" or "%d"
+//
+//	`average` MovingAverage implementation
+//
+//	`wcc` optional WC config
+//
+// unitFormat example if UnitKiB is chosen:
+//
+//	"%.1f" = "1.0MiB/s" or "% .1f" = "1.0 MiB/s"
+func EwmaSpeed(unit int, unitFormat string, age float64, wcc ...WC) Decorator {
+	return MovingAverageSpeed(unit, unitFormat, ewma.NewMovingAverage(age), wcc...)
+}
+
+// MovingAverageSpeed decorator relies on MovingAverage implementation to calculate its average.
+//
+//	`unit` one of [0|UnitKiB|UnitKB] zero for no unit
+//
+//	`unitFormat` printf compatible verb for value, like "%f" or "%d"
+//
+//	`average` MovingAverage implementation
+//
+//	`wcc` optional WC config
+func MovingAverageSpeed(unit int, unitFormat string, average MovingAverage, wcc ...WC) Decorator {
+	var wc WC
+	for _, widthConf := range wcc {
+		wc = widthConf
+	}
+	wc.Init()
+	d := &movingAverageSpeed{
+		WC:         wc,
+		unit:       unit,
+		unitFormat: unitFormat,
+		average:    average,
+	}
+	return d
+}
+
+type movingAverageSpeed struct {
+	WC
+	unit        int
+	unitFormat  string
+	average     ewma.MovingAverage
+	msg         string
+	completeMsg *string
+}
+
+func (d *movingAverageSpeed) Decor(st *Statistics) string {
+	if st.Completed {
+		if d.completeMsg != nil {
+			return d.FormatMsg(*d.completeMsg)
+		}
+		return d.FormatMsg(d.msg)
+	}
+
+	speed := d.average.Value()
+	switch d.unit {
+	case UnitKiB:
+		d.msg = fmt.Sprintf(d.unitFormat, SpeedKiB(speed))
+	case UnitKB:
+		d.msg = fmt.Sprintf(d.unitFormat, SpeedKB(speed))
+	default:
+		d.msg = fmt.Sprintf(d.unitFormat, speed)
+	}
+
+	return d.FormatMsg(d.msg)
+}
+
+func (s *movingAverageSpeed) NextAmount(n int, wdd ...time.Duration) {
+	var workDuration time.Duration
+	for _, wd := range wdd {
+		workDuration = wd
+	}
+	speed := float64(n) / workDuration.Seconds() / 1000
+	if math.IsInf(speed, 0) || math.IsNaN(speed) {
+		return
+	}
+	s.average.Add(speed)
+}
+
+func (d *movingAverageSpeed) OnCompleteMessage(msg string) {
+	d.completeMsg = &msg
+}
+
+// AverageSpeed decorator with dynamic unit measure adjustment.
+//
+//	`unit` one of [0|UnitKiB|UnitKB] zero for no unit
+//
+//	`unitFormat` printf compatible verb for value, like "%f" or "%d"
+//
+//	`wcc` optional WC config
+//
+// unitFormat example if UnitKiB is chosen:
+//
+//	"%.1f" = "1.0MiB/s" or "% .1f" = "1.0 MiB/s"
+func AverageSpeed(unit int, unitFormat string, wcc ...WC) Decorator {
+	var wc WC
+	for _, widthConf := range wcc {
+		wc = widthConf
+	}
+	wc.Init()
+	d := &averageSpeed{
+		WC:         wc,
+		unit:       unit,
+		unitFormat: unitFormat,
+		startTime:  time.Now(),
+	}
+	return d
+}
+
+type averageSpeed struct {
+	WC
+	unit        int
+	unitFormat  string
+	startTime   time.Time
+	msg         string
+	completeMsg *string
+}
+
+func (d *averageSpeed) Decor(st *Statistics) string {
+	if st.Completed {
+		if d.completeMsg != nil {
+			return d.FormatMsg(*d.completeMsg)
+		}
+		return d.FormatMsg(d.msg)
+	}
+
+	timeElapsed := time.Since(d.startTime)
+	speed := float64(st.Current) / timeElapsed.Seconds()
+
+	switch d.unit {
+	case UnitKiB:
+		d.msg = fmt.Sprintf(d.unitFormat, SpeedKiB(speed))
+	case UnitKB:
+		d.msg = fmt.Sprintf(d.unitFormat, SpeedKB(speed))
+	default:
+		d.msg = fmt.Sprintf(d.unitFormat, speed)
+	}
+
+	return d.FormatMsg(d.msg)
+}
+
+func (d *averageSpeed) OnCompleteMessage(msg string) {
+	d.completeMsg = &msg
+}