wrapio returns io.ErrNoProgress when it gets many consecutive empty reads/writes

Author: djherbis

buffer_test.go

@@ -704,3 +704,20 @@ func TestPanicWriteAt(t *testing.T) {
 	buf.WriteAt(nil, 0)
 	t.Error("expected a panic!")
 }
+
+type badFile struct{}
+
+func (b badFile) Name() string                             { return "" }
+func (b badFile) Stat() (os.FileInfo, error)               { return nil, errors.New("unsupported") }
+func (b badFile) ReadAt(p []byte, off int64) (int, error)  { return 0, nil }
+func (b badFile) WriteAt(p []byte, off int64) (int, error) { return len(p), nil }
+func (b badFile) Close() error                             { return nil }
+
+func TestWrapioBreakout(t *testing.T) {
+	buf := NewFile(10, badFile{})
+	io.WriteString(buf, "hello world")
+	if _, err := ioutil.ReadAll(buf); err != io.ErrNoProgress {
+		t.Error("expected no progress to be made")
+		t.FailNow()
+	}
+}

wrapio/wrap.go

@@ -1,9 +1,6 @@
 package wrapio
 
-import (
-	"fmt"
-	"io"
-)
+import "io"
 
 // DoerAt is a common interface for wrappers WriteAt or ReadAt functions
 type DoerAt interface {
@@ -98,26 +95,38 @@ func (r *WrapReader) ReadAt(p []byte, off int64) (n int, err error) {
 	return Wrap(r, p, off, r.wrapAt)
 }
 
+// maxConsecutiveEmptyActions determines how many consecutive empty reads/writes can occur before giving up
+const maxConsecutiveEmptyActions = 100
+
 // Wrap causes an action on an array of bytes (like read/write) to be done from an offset off,
 // wrapping at offset wrapAt.
 func Wrap(w DoerAt, p []byte, off int64, wrapAt int64) (n int, err error) {
-	var m int
+	var m, fails int
 
 	off %= wrapAt
 
 	for len(p) > 0 {
 
 		if off+int64(len(p)) < wrapAt {
-			if m, err = w.DoAt(p, off); err != nil && err != io.EOF {
-				fmt.Println(off, m, len(p), err)
-				return n + m, err
-			}
+			m, err = w.DoAt(p, off)
 		} else {
 			space := wrapAt - off
-			if m, err = w.DoAt(p[:space], off); err != nil && err != io.EOF {
-				fmt.Println(off, m, len(p[:space]), err)
-				return n + m, err
-			}
+			m, err = w.DoAt(p[:space], off)
+		}
+
+		if err != nil && err != io.EOF {
+			return n + m, err
+		}
+
+		switch m {
+		case 0:
+			fails++
+		default:
+			fails = 0
+		}
+
+		if fails > maxConsecutiveEmptyActions {
+			return n + m, io.ErrNoProgress
 		}
 
 		n += m