Add vendor folder to git

vendor/github.com/coreos/pkg/progressutil/iocopy.go

@@ -0,0 +1,189 @@
+// Copyright 2016 CoreOS Inc
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package progressutil
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"sync"
+	"time"
+)
+
+var (
+	ErrAlreadyStarted = errors.New("cannot add copies after PrintAndWait has been called")
+)
+
+type copyReader struct {
+	reader  io.Reader
+	current int64
+	total   int64
+	pb      *ProgressBar
+}
+
+func (cr *copyReader) Read(p []byte) (int, error) {
+	n, err := cr.reader.Read(p)
+	cr.current += int64(n)
+	err1 := cr.updateProgressBar()
+	if err == nil {
+		err = err1
+	}
+	return n, err
+}
+
+func (cr *copyReader) updateProgressBar() error {
+	cr.pb.SetPrintAfter(cr.formattedProgress())
+
+	progress := float64(cr.current) / float64(cr.total)
+	if progress > 1 {
+		progress = 1
+	}
+	return cr.pb.SetCurrentProgress(progress)
+}
+
+// NewCopyProgressPrinter returns a new CopyProgressPrinter
+func NewCopyProgressPrinter() *CopyProgressPrinter {
+	return &CopyProgressPrinter{results: make(chan error), cancel: make(chan struct{})}
+}
+
+// CopyProgressPrinter will perform an arbitrary number of io.Copy calls, while
+// continually printing the progress of each copy.
+type CopyProgressPrinter struct {
+	results chan error
+	cancel  chan struct{}
+
+	// `lock` mutex protects all fields below it in CopyProgressPrinter struct
+	lock    sync.Mutex
+	readers []*copyReader
+	started bool
+	pbp     *ProgressBarPrinter
+}
+
+// AddCopy adds a copy for this CopyProgressPrinter to perform. An io.Copy call
+// will be made to copy bytes from reader to dest, and name and size will be
+// used to label the progress bar and display how much progress has been made.
+// If size is 0, the total size of the reader is assumed to be unknown.
+// AddCopy can only be called before PrintAndWait; otherwise, ErrAlreadyStarted
+// will be returned.
+func (cpp *CopyProgressPrinter) AddCopy(reader io.Reader, name string, size int64, dest io.Writer) error {
+	cpp.lock.Lock()
+	defer cpp.lock.Unlock()
+
+	if cpp.started {
+		return ErrAlreadyStarted
+	}
+	if cpp.pbp == nil {
+		cpp.pbp = &ProgressBarPrinter{}
+		cpp.pbp.PadToBeEven = true
+	}
+
+	cr := &copyReader{
+		reader:  reader,
+		current: 0,
+		total:   size,
+		pb:      cpp.pbp.AddProgressBar(),
+	}
+	cr.pb.SetPrintBefore(name)
+	cr.pb.SetPrintAfter(cr.formattedProgress())
+
+	cpp.readers = append(cpp.readers, cr)
+
+	go func() {
+		_, err := io.Copy(dest, cr)
+		select {
+		case <-cpp.cancel:
+			return
+		case cpp.results <- err:
+			return
+		}
+	}()
+	return nil
+}
+
+// PrintAndWait will print the progress for each copy operation added with
+// AddCopy to printTo every printInterval. This will continue until every added
+// copy is finished, or until cancel is written to.
+// PrintAndWait may only be called once; any subsequent calls will immediately
+// return ErrAlreadyStarted.  After PrintAndWait has been called, no more
+// copies may be added to the CopyProgressPrinter.
+func (cpp *CopyProgressPrinter) PrintAndWait(printTo io.Writer, printInterval time.Duration, cancel chan struct{}) error {
+	cpp.lock.Lock()
+	if cpp.started {
+		cpp.lock.Unlock()
+		return ErrAlreadyStarted
+	}
+	cpp.started = true
+	cpp.lock.Unlock()
+
+	n := len(cpp.readers)
+	if n == 0 {
+		// Nothing to do.
+		return nil
+	}
+
+	defer close(cpp.cancel)
+	t := time.NewTicker(printInterval)
+	allDone := false
+	for i := 0; i < n; {
+		select {
+		case <-cancel:
+			return nil
+		case <-t.C:
+			_, err := cpp.pbp.Print(printTo)
+			if err != nil {
+				return err
+			}
+		case err := <-cpp.results:
+			i++
+			// Once completion is signaled, further on this just drains
+			// (unlikely) errors from the channel.
+			if err == nil && !allDone {
+				allDone, err = cpp.pbp.Print(printTo)
+			}
+			if err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func (cr *copyReader) formattedProgress() string {
+	var totalStr string
+	if cr.total == 0 {
+		totalStr = "?"
+	} else {
+		totalStr = ByteUnitStr(cr.total)
+	}
+	return fmt.Sprintf("%s / %s", ByteUnitStr(cr.current), totalStr)
+}
+
+var byteUnits = []string{"B", "KB", "MB", "GB", "TB", "PB"}
+
+// ByteUnitStr pretty prints a number of bytes.
+func ByteUnitStr(n int64) string {
+	var unit string
+	size := float64(n)
+	for i := 1; i < len(byteUnits); i++ {
+		if size < 1000 {
+			unit = byteUnits[i-1]
+			break
+		}
+
+		size = size / 1000
+	}
+
+	return fmt.Sprintf("%.3g %s", size, unit)
+}

vendor/github.com/coreos/pkg/progressutil/progressbar.go

@@ -0,0 +1,263 @@
+// Copyright 2016 CoreOS Inc
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package progressutil
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"strings"
+	"sync"
+
+	"golang.org/x/crypto/ssh/terminal"
+)
+
+var (
+	// ErrorProgressOutOfBounds is returned if the progress is set to a value
+	// not between 0 and 1.
+	ErrorProgressOutOfBounds = fmt.Errorf("progress is out of bounds (0 to 1)")
+
+	// ErrorNoBarsAdded is returned when no progress bars have been added to a
+	// ProgressBarPrinter before PrintAndWait is called.
+	ErrorNoBarsAdded = fmt.Errorf("AddProgressBar hasn't been called yet")
+)
+
+// ProgressBar represents one progress bar in a ProgressBarPrinter. Should not
+// be created directly, use the AddProgressBar on a ProgressBarPrinter to
+// create these.
+type ProgressBar struct {
+	lock sync.Mutex
+
+	currentProgress float64
+	printBefore     string
+	printAfter      string
+	done            bool
+}
+
+func (pb *ProgressBar) clone() *ProgressBar {
+	pb.lock.Lock()
+	pbClone := &ProgressBar{
+		currentProgress: pb.currentProgress,
+		printBefore:     pb.printBefore,
+		printAfter:      pb.printAfter,
+		done:            pb.done,
+	}
+	pb.lock.Unlock()
+	return pbClone
+}
+
+func (pb *ProgressBar) GetCurrentProgress() float64 {
+	pb.lock.Lock()
+	val := pb.currentProgress
+	pb.lock.Unlock()
+	return val
+}
+
+// SetCurrentProgress sets the progress of this ProgressBar. The progress must
+// be between 0 and 1 inclusive.
+func (pb *ProgressBar) SetCurrentProgress(progress float64) error {
+	if progress < 0 || progress > 1 {
+		return ErrorProgressOutOfBounds
+	}
+	pb.lock.Lock()
+	pb.currentProgress = progress
+	pb.lock.Unlock()
+	return nil
+}
+
+// GetDone returns whether or not this progress bar is done
+func (pb *ProgressBar) GetDone() bool {
+	pb.lock.Lock()
+	val := pb.done
+	pb.lock.Unlock()
+	return val
+}
+
+// SetDone sets whether or not this progress bar is done
+func (pb *ProgressBar) SetDone(val bool) {
+	pb.lock.Lock()
+	pb.done = val
+	pb.lock.Unlock()
+}
+
+// GetPrintBefore gets the text printed on the line before the progress bar.
+func (pb *ProgressBar) GetPrintBefore() string {
+	pb.lock.Lock()
+	val := pb.printBefore
+	pb.lock.Unlock()
+	return val
+}
+
+// SetPrintBefore sets the text printed on the line before the progress bar.
+func (pb *ProgressBar) SetPrintBefore(before string) {
+	pb.lock.Lock()
+	pb.printBefore = before
+	pb.lock.Unlock()
+}
+
+// GetPrintAfter gets the text printed on the line after the progress bar.
+func (pb *ProgressBar) GetPrintAfter() string {
+	pb.lock.Lock()
+	val := pb.printAfter
+	pb.lock.Unlock()
+	return val
+}
+
+// SetPrintAfter sets the text printed on the line after the progress bar.
+func (pb *ProgressBar) SetPrintAfter(after string) {
+	pb.lock.Lock()
+	pb.printAfter = after
+	pb.lock.Unlock()
+}
+
+// ProgressBarPrinter will print out the progress of some number of
+// ProgressBars.
+type ProgressBarPrinter struct {
+	lock sync.Mutex
+
+	// DisplayWidth can be set to influence how large the progress bars are.
+	// The bars will be scaled to attempt to produce lines of this number of
+	// characters, but lines of different lengths may still be printed. When
+	// this value is 0 (aka unset), 80 character columns are assumed.
+	DisplayWidth int
+	// PadToBeEven, when set to true, will make Print pad the printBefore text
+	// with trailing spaces and the printAfter text with leading spaces to make
+	// the progress bars the same length.
+	PadToBeEven         bool
+	numLinesInLastPrint int
+	progressBars        []*ProgressBar
+	maxBefore           int
+	maxAfter            int
+
+	// printToTTYAlways forces this ProgressBarPrinter to always behave as if
+	// in a tty. Used for tests.
+	printToTTYAlways bool
+}
+
+// AddProgressBar will create a new ProgressBar, register it with this
+// ProgressBarPrinter, and return it. This must be called at least once before
+// PrintAndWait is called.
+func (pbp *ProgressBarPrinter) AddProgressBar() *ProgressBar {
+	pb := &ProgressBar{}
+	pbp.lock.Lock()
+	pbp.progressBars = append(pbp.progressBars, pb)
+	pbp.lock.Unlock()
+	return pb
+}
+
+// Print will print out progress information for each ProgressBar that has been
+// added to this ProgressBarPrinter. The progress will be written to printTo,
+// and if printTo is a terminal it will draw progress bars.  AddProgressBar
+// must be called at least once before Print is called. If printing to a
+// terminal, all draws after the first one will move the cursor up to draw over
+// the previously printed bars.
+func (pbp *ProgressBarPrinter) Print(printTo io.Writer) (bool, error) {
+	pbp.lock.Lock()
+	var bars []*ProgressBar
+	for _, bar := range pbp.progressBars {
+		bars = append(bars, bar.clone())
+	}
+	numColumns := pbp.DisplayWidth
+	pbp.lock.Unlock()
+
+	if len(bars) == 0 {
+		return false, ErrorNoBarsAdded
+	}
+
+	if numColumns == 0 {
+		numColumns = 80
+	}
+
+	if pbp.isTerminal(printTo) {
+		moveCursorUp(printTo, pbp.numLinesInLastPrint)
+	}
+
+	for _, bar := range bars {
+		beforeSize := len(bar.GetPrintBefore())
+		afterSize := len(bar.GetPrintAfter())
+		if beforeSize > pbp.maxBefore {
+			pbp.maxBefore = beforeSize
+		}
+		if afterSize > pbp.maxAfter {
+			pbp.maxAfter = afterSize
+		}
+	}
+
+	allDone := true
+	for _, bar := range bars {
+		if pbp.isTerminal(printTo) {
+			bar.printToTerminal(printTo, numColumns, pbp.PadToBeEven, pbp.maxBefore, pbp.maxAfter)
+		} else {
+			bar.printToNonTerminal(printTo)
+		}
+		allDone = allDone && bar.GetCurrentProgress() == 1
+	}
+
+	pbp.numLinesInLastPrint = len(bars)
+
+	return allDone, nil
+}
+
+// moveCursorUp moves the cursor up numLines in the terminal
+func moveCursorUp(printTo io.Writer, numLines int) {
+	if numLines > 0 {
+		fmt.Fprintf(printTo, "\033[%dA", numLines)
+	}
+}
+
+func (pb *ProgressBar) printToTerminal(printTo io.Writer, numColumns int, padding bool, maxBefore, maxAfter int) {
+	before := pb.GetPrintBefore()
+	after := pb.GetPrintAfter()
+
+	if padding {
+		before = before + strings.Repeat(" ", maxBefore-len(before))
+		after = strings.Repeat(" ", maxAfter-len(after)) + after
+	}
+
+	progressBarSize := numColumns - (len(fmt.Sprintf("%s [] %s", before, after)))
+	progressBar := ""
+	if progressBarSize > 0 {
+		currentProgress := int(pb.GetCurrentProgress() * float64(progressBarSize))
+		progressBar = fmt.Sprintf("[%s%s] ",
+			strings.Repeat("=", currentProgress),
+			strings.Repeat(" ", progressBarSize-currentProgress))
+	} else {
+		// If we can't fit the progress bar, better to not pad the before/after.
+		before = pb.GetPrintBefore()
+		after = pb.GetPrintAfter()
+	}
+
+	fmt.Fprintf(printTo, "%s %s%s\n", before, progressBar, after)
+}
+
+func (pb *ProgressBar) printToNonTerminal(printTo io.Writer) {
+	if !pb.GetDone() {
+		fmt.Fprintf(printTo, "%s %s\n", pb.printBefore, pb.printAfter)
+		if pb.GetCurrentProgress() == 1 {
+			pb.SetDone(true)
+		}
+	}
+}
+
+// isTerminal returns True when w is going to a tty, and false otherwise.
+func (pbp *ProgressBarPrinter) isTerminal(w io.Writer) bool {
+	if pbp.printToTTYAlways {
+		return true
+	}
+	if f, ok := w.(*os.File); ok {
+		return terminal.IsTerminal(int(f.Fd()))
+	}
+	return false
+}

vendor/github.com/coreos/pkg/progressutil/progressbar_test.go

@@ -0,0 +1,111 @@
+// Copyright 2016 CoreOS Inc
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package progressutil
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"strings"
+	"testing"
+)
+
+func TestNoBarsAdded(t *testing.T) {
+	pbp := &ProgressBarPrinter{}
+	allDone, err := pbp.Print(ioutil.Discard)
+	if allDone {
+		t.Errorf("shouldn't have gotten all done when no bars have been added")
+	}
+	if err != ErrorNoBarsAdded {
+		t.Errorf("was expecting ErrorNoBarsAdded, got this instead: %v", err)
+	}
+}
+
+func TestProgressOutOfBounds(t *testing.T) {
+	pbp := &ProgressBarPrinter{}
+	pb := pbp.AddProgressBar()
+
+	for _, testcase := range []struct {
+		progress    float64
+		expectedErr error
+	}{
+		{-0.1, ErrorProgressOutOfBounds},
+		{0, nil},
+		{0.5, nil},
+		{1, nil},
+		{1.1, ErrorProgressOutOfBounds},
+	} {
+		err := pb.SetCurrentProgress(testcase.progress)
+		if err != testcase.expectedErr {
+			t.Errorf("got unexpected error. expected=%v actual=%v", testcase.expectedErr, err)
+		}
+		if err == nil {
+			currProgress := pb.GetCurrentProgress()
+			if currProgress != testcase.progress {
+				t.Errorf("no error was returned, but the progress wasn't updated. should be: %d, actual: %d", testcase.progress, currProgress)
+			}
+		}
+	}
+}
+
+func TestDrawOne(t *testing.T) {
+	pbp := ProgressBarPrinter{}
+	pbp.printToTTYAlways = true
+	pb := pbp.AddProgressBar()
+
+	pbp.Print(ioutil.Discard)
+
+	for _, testcase := range []struct {
+		beforeText   string
+		progress     float64
+		afterText    string
+		shouldBeDone bool
+	}{
+		{"before", 0, "after", false},
+		{"before2", 0.1, "after2", false},
+		{"before3", 0.5, "after3", false},
+		{"before4", 1, "after4", true},
+	} {
+		buf := &bytes.Buffer{}
+		pb.SetPrintBefore(testcase.beforeText)
+		pb.SetPrintAfter(testcase.afterText)
+		err := pb.SetCurrentProgress(testcase.progress)
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		done, err := pbp.Print(buf)
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if done != testcase.shouldBeDone {
+			t.Errorf("unexpected done, expected=%b actual=%b", testcase.shouldBeDone, done)
+		}
+
+		output := buf.String()
+
+		progressBarSize := 80 - len(fmt.Sprintf("%s [] %s", testcase.beforeText, testcase.afterText))
+		currentProgress := int(testcase.progress * float64(progressBarSize))
+
+		bar := fmt.Sprintf("[%s%s]",
+			strings.Repeat("=", currentProgress),
+			strings.Repeat(" ", progressBarSize-currentProgress))
+
+		expectedOutput := fmt.Sprintf("\033[1A%s %s %s\n", testcase.beforeText, bar, testcase.afterText)
+
+		if output != expectedOutput {
+			t.Errorf("unexpected output:\nexpected:\n\n%sactual:\n\n%s", expectedOutput, output)
+		}
+	}
+}