archive/tar: simplify Flush

In Go1.0, Writer.Flush used to finish off the current file with zeros
(if it was not already finished) and then write the padding.

Since Go1.1, a regression was made (https://golang.org/cl/5777064) where it was
an error to call Flush if the current file was incomplete. Thus, Flush now only
writes out the final padding bytes, which arguably isn't very useful to anyone.
Since this has been the behavior of Flush for 9 releases of Go (1.1 to 1.9),
we should keep this behavior and just simplify the logic.

We also mark the method as deprecated since it serves no purpose.

Change-Id: I94610d942cb75cad495efd8cf799c1a275a21751
Reviewed-on: https://go-review.googlesource.com/54434
Run-TryBot: Joe Tsai <thebrokentoaster@gmail.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>

diff --git a/src/archive/tar/writer.go b/src/archive/tar/writer.go
index c51c243a8b8efe091d5318483467aaf6e6446566..b75929c89481d23ccaa87edeb9fb13c3d99256ce 100644 (file)
--- a/src/archive/tar/writer.go
+++ b/src/archive/tar/writer.go
@@ -45,26 +45,26 @@ type Writer struct {
 // NewWriter creates a new Writer writing to w.
 func NewWriter(w io.Writer) *Writer { return &Writer{w: w} }
 
-// Flush finishes writing the current file (optional).
+// Flush finishes writing the current file's block padding.
+// The current file must be fully written before Flush can be called.
+//
+// Deprecated: This is unecessary as the next call to WriteHeader or Close
+// will implicitly flush out the file's padding.
 func (tw *Writer) Flush() error {
        if tw.nb > 0 {
                tw.err = fmt.Errorf("archive/tar: missed writing %d bytes", tw.nb)
                return tw.err
        }
+       tw.err = tw.writePadding()
+       return tw.err
+}
 
-       n := tw.nb + tw.pad
-       for n > 0 && tw.err == nil {
-               nr := n
-               if nr > blockSize {
-                       nr = blockSize
-               }
-               var nw int
-               nw, tw.err = tw.w.Write(zeroBlock[0:nr])
-               n -= int64(nw)
+func (tw *Writer) writePadding() error {
+       if _, err := tw.w.Write(zeroBlock[:tw.pad]); err != nil {
+               return err
        }
-       tw.nb = 0
        tw.pad = 0
-       return tw.err
+       return nil
 }
 
 var (
@@ -318,10 +318,7 @@ func (tw *Writer) writePAXHeader(hdr *Header, paxHeaders map[string]string) erro
        if _, err := tw.Write(buf.Bytes()); err != nil {
                return err
        }
-       if err := tw.Flush(); err != nil {
-               return err
-       }
-       return nil
+       return tw.writePadding()
 }
 
 // Write writes to the current entry in the tar archive.