fix(b2): return the upload error from Writer.ReadFrom instead of context canceled

.changes/unreleased/Fixed-20261030-130448.yaml

@@ -0,0 +1,3 @@
+kind: Fixed
+body: Writer.ReadFrom and io.Copy now return the recorded large-file upload error instead of masking it with context cancellation (#245).
+time: 2026-10-30T13:04:48.509659-06:00

b2/b2.go

@@ -735,7 +735,7 @@ func (o *Object) URL() string {
 //
 // Callers must close the writer when finished and check the error status.
 func (o *Object) NewWriter(ctx context.Context, opts ...WriterOption) *Writer {
-	ctx, cancel := context.WithCancel(ctx)
+	ctx, cancel := context.WithCancelCause(ctx)
 	w := &Writer{
 		o:             o,
 		name:          o.name,

b2/b2_test.go

@@ -18,6 +18,7 @@ import (
 	"bytes"
 	"context"
 	"crypto/sha1"
+	"errors"
 	"fmt"
 	"io"
 	"io/ioutil"
@@ -1726,6 +1727,7 @@ func TestWriterReturnsError(t *testing.T) {
 	ctx := context.Background()
 	ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
 	defer cancel()
+	want := testError{}
 
 	client := &Client{
 		backend: &beRoot{
@@ -1734,13 +1736,13 @@ func TestWriterReturnsError(t *testing.T) {
 				errs: &errCont{
 					errMap: map[string]map[int]error{
 						"uploadPart": {
-							0: testError{},
-							1: testError{},
-							2: testError{},
-							3: testError{},
-							4: testError{},
-							5: testError{},
-							6: testError{},
+							0: want,
+							1: want,
+							2: want,
+							3: want,
+							4: want,
+							5: want,
+							6: want,
 						},
 					},
 				},
@@ -1756,8 +1758,8 @@ func TestWriterReturnsError(t *testing.T) {
 	r := io.LimitReader(zReader{}, 1e7)
 	w.ChunkSize = 1e4
 	w.ConcurrentUploads = 4
-	if _, err := io.Copy(w, r); err == nil {
-		t.Fatalf("io.Copy: should have returned an error")
+	if _, err := io.Copy(w, r); !errors.Is(err, want) {
+		t.Fatalf("io.Copy error = %v, want %v", err, want)
 	}
 }
 

b2/core_edges_test.go

@@ -49,7 +49,8 @@ func TestObjectLockUpdateInvalidatesCachedInfo(t *testing.T) {
 
 func TestObjectDeleteRejectsFolderStatus(t *testing.T) {
 	file := &testFile{n: "folder", a: "folder", files: map[string]string{"folder": "present"}}
-	object := objectForDeleteOptionTest(file)
+	root := &beRoot{b2i: &testRoot{errs: &errCont{}, bucketMap: make(map[string]map[string]string)}}
+	object := &Object{f: &beFile{b2file: file, ri: root}}
 	if err := object.Delete(context.Background()); err == nil || !strings.Contains(err.Error(), "not a regular file or hide marker") {
 		t.Fatalf("Delete(folder) error = %v, want non-regular-file rejection", err)
 	}

b2/progress_test.go

@@ -300,8 +300,8 @@ func (progressSkipChunk) uploadPart(context.Context, readResetter, string, int,
 }
 
 func TestProgressResumeSkipDoesNotReadClosedBuffer(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+	ctx, cancel := context.WithCancelCause(context.Background())
+	defer cancel(nil)
 	buf := newMemoryBuffer()
 	if _, err := buf.Write([]byte("already uploaded")); err != nil {
 		t.Fatal(err)

b2/writer.go

@@ -83,7 +83,7 @@ type Writer struct {
 
 	csize       int
 	ctx         context.Context
-	cancel      context.CancelFunc // cancels ctx
+	cancel      context.CancelCauseFunc // cancels ctx with the first Writer error
 	ctxf        func() context.Context
 	errf        func(error)
 	ready       chan chunk
@@ -140,6 +140,11 @@ type chunk struct {
 	buf writeBuffer
 }
 
+type writerCause struct{ err error }
+
+func (c writerCause) Error() string { return c.err.Error() }
+func (c writerCause) Unwrap() error { return c.err }
+
 func (w *Writer) setErr(err error) {
 	if err == nil || err == io.EOF {
 		return
@@ -151,7 +156,7 @@ func (w *Writer) setErr(err error) {
 	}
 	blog.V(1).Infof("error writing object: %T", err)
 	w.err = err
-	w.cancel()
+	w.cancel(writerCause{err})
 	w.emux.Unlock()
 	if w.ctxf == nil || w.file == nil {
 		return
@@ -655,16 +660,30 @@ func (w *Writer) sendChunk() error {
 //
 // Note that io.Copy will automatically choose to use ReadFrom.
 //
-// If the Writer's context is cancelled while ReadFrom is copying from a
-// non-seekable r, ReadFrom returns the context error without waiting for a
-// Read on r that is already in progress. Once ReadFrom has returned, nothing
-// more from r is written to w; data read before the cancellation may already
-// have been written. That pending Read may still finish later, so do not reuse
-// r until it has returned (for example, close r first if it supports it).
+// On every path, ReadFrom returns the Writer's error when it cancels itself;
+// caller cancellation returns context.Canceled or context.DeadlineExceeded,
+// even if the caller supplied a custom cause. If the Writer's context is
+// cancelled while copying from a non-seekable r, ReadFrom returns without
+// waiting for a Read on r that is already in progress.
+// When the Writer cancels itself, ReadFrom returns the same first recorded
+// error as Close, so errors.Is and errors.As work and io.Copy sees it rather
+// than context.Canceled.
+// Once ReadFrom has returned, nothing more from r is written to w; data read
+// before cancellation may already have been written. That pending Read may
+// still finish later, so do not reuse r until it has returned (for example,
+// close r first if it supports it).
 //
 // With Resume, ReadFrom uses the ordinary buffered path; if r is seekable,
 // its remaining length supplies the progress total.
-func (w *Writer) ReadFrom(r io.Reader) (int64, error) {
+func (w *Writer) ReadFrom(r io.Reader) (n int64, err error) {
+	defer func() {
+		if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
+			var cause writerCause
+			if errors.As(context.Cause(w.ctx), &cause) {
+				err = cause.err
+			}
+		}
+	}()
 	rs, ok := r.(io.ReadSeeker)
 	if !ok {
 		return copyContext(w.ctx, w, r)

b2/writer_log_security_test.go

@@ -65,7 +65,7 @@ func TestWriterErrorLoggingOmitsErrorText(t *testing.T) {
 	}
 	var output bytes.Buffer
 	log.SetOutput(&output)
-	w := &Writer{name: "object", cancel: func() {}}
+	w := &Writer{name: "object", cancel: func(error) {}}
 	w.setErr(errors.New("server-error-secret"))
 	if strings.Contains(output.String(), "server-error-secret") {
 		t.Fatal("writer logged untrusted error text")