big commit

- remove HandleError() because we now have CloseWithError
- remove Header interface
- remove all Head() methods
- fix locking in chan.go
- use EmitChan in ResponseEmitters
- introduce cmds.ErrClosedEmitter
- fix tests (some still expected errors to be emitted/marshaled)

Author: keks

Diff for: chan.go

@@ -2,7 +2,7 @@ package cmds
 
 import (
 	"context"
-	"fmt"
+	"errors"
 	"io"
 	"sync"
 
@@ -15,43 +15,54 @@ func NewChanResponsePair(req *Request) (ResponseEmitter, Response) {
 	wait := make(chan struct{})
 
 	r := &chanResponse{
-		req:    req,
-		ch:     ch,
-		wait:   wait,
-		closed: make(chan struct{}),
+		req:  req,
+		ch:   ch,
+		wait: wait,
 	}
 
 	re := (*chanResponseEmitter)(r)
 
 	return re, r
 }
 
-type chanResponse struct {
-	wl  sync.Mutex // lock for writing calls, i.e. Emit et al.
-	rl  sync.Mutex // lock for reading calls, i.e. Next
+// chanStream is the struct of both the Response and ResponseEmitter.
+// The methods are defined on chanResponse and chanResponseEmitter, which are
+// just type definitions on chanStream.
+type chanStream struct {
 	req *Request
 
-	// wait makes header requests block until the body is sent
-	wait chan struct{}
-	// waitOnce makes sure we only close wait once
-	waitOnce sync.Once
+	// rl is a lock for reading calls, i.e. Next.
+	rl sync.Mutex
 
-	// ch is used to send values from emitter to response
+	// ch is used to send values from emitter to response.
+	// When Emit received a channel close, it sets it to nil.
+	// It is protected by rl.
 	ch chan interface{}
 
-	emitted bool
-	err     error
-	length  uint64
+	// wl is a lock for writing calls, i.e. Emit, Close(WithError) and SetLength.
+	wl sync.Mutex
+
+	// closed stores whether this stream is closed.
+	// It is protected by wl.
+	closed bool
+
+	// wait is closed when the stream is closed or the first value is emitted.
+	// Error and Length both wait for wait to be closed.
+	// It is protected by wl.
+	wait chan struct{}
+
+	// err is the error that the stream was closed with.
+	// It is written once under lock wl, but only read after wait is closed (which also happens under wl)
+	err error
 
-	closeOnce sync.Once
-	closed    chan struct{}
+	// length is the length of the response.
+	// It can be set by calling SetLength, but only before the first call to Emit, Close or CloseWithError.
+	length uint64
 }
 
-func (r *chanResponse) Request() *Request {
-	if r == nil {
-		return nil
-	}
+type chanResponse chanStream
 
+func (r *chanResponse) Request() *Request {
 	return r.req
 }
 
@@ -75,25 +86,6 @@ func (r *chanResponse) Length() uint64 {
 	return r.length
 }
 
-func (re *chanResponse) Head() Head {
-	<-re.wait
-
-	var err error
-	if re.err != io.EOF {
-		err = re.err
-	}
-
-	cmdErr, ok := err.(*cmdkit.Error)
-	if !ok && err != nil {
-		cmdErr = &cmdkit.Error{Message: err.Error()}
-	}
-
-	return Head{
-		Len: re.length,
-		Err: cmdErr,
-	}
-}
-
 func (r *chanResponse) Next() (interface{}, error) {
 	if r == nil {
 		return nil, io.EOF
@@ -111,18 +103,11 @@ func (r *chanResponse) Next() (interface{}, error) {
 	defer r.rl.Unlock()
 
 	select {
-	case <-r.closed:
-		return nil, r.err
 	case v, ok := <-r.ch:
 		if !ok {
-			r.ch = nil
 			return nil, r.err
 		}
 
-		if err, ok := v.(cmdkit.Error); ok {
-			v = &err
-		}
-
 		switch val := v.(type) {
 		case Single:
 			return val.Value, nil
@@ -138,69 +123,83 @@ type chanResponseEmitter chanResponse
 
 func (re *chanResponseEmitter) Emit(v interface{}) error {
 	// channel emission iteration
-	// TODO maybe remove this and use EmitChan instead of calling Emit directly?
 	if ch, ok := v.(chan interface{}); ok {
 		v = (<-chan interface{})(ch)
 	}
 	if ch, isChan := v.(<-chan interface{}); isChan {
 		return EmitChan(re, ch)
 	}
 
-	// unblock Length(), Error() and Head()
-	re.waitOnce.Do(func() {
-		close(re.wait)
-	})
-
 	re.wl.Lock()
 	defer re.wl.Unlock()
 
 	if _, ok := v.(Single); ok {
-		defer re.closeWithError(io.EOF)
+		defer re.closeWithError(nil)
+	}
 
 	// Initially this library allowed commands to return errors by sending an
 	// error value along a stream. We removed that in favour of CloseWithError,
 	// so we want to make sure we catch situations where some code still uses the
 	// old error emitting semantics and _panic_ in those situations.
 	debug.AssertNotError(v)
 
+	// unblock Length() and Error()
+	select {
+	case <-re.wait:
+	default:
+		close(re.wait)
+	}
+
+	// make sure we check whether the stream is closed *before accessing re.ch*!
+	// re.ch is set to nil, but is not protected by a shared mutex (because that
+	// wouldn't make sense).
+	// re.closed is set in a critical section protected by re.wl (we also took
+	// that lock), so we can be sure that this check is not racy.
+	if re.closed {
+		return ErrClosedEmitter
 	}
 
 	ctx := re.req.Context
 
 	select {
-	case <-re.closed:
-		return fmt.Errorf("emitter closed")
 	case re.ch <- v:
 		return nil
 	case <-ctx.Done():
 		return ctx.Err()
 	}
 }
 
+func (re *chanResponseEmitter) Close() error {
+	return re.CloseWithError(nil)
+}
+
 func (re *chanResponseEmitter) SetLength(l uint64) {
 	re.wl.Lock()
 	defer re.wl.Unlock()
 
-	// don't change value after emitting
-	if re.emitted {
-		return
+	// don't change value after emitting or closing
+	select {
+	case <-re.wait:
+	default:
+		re.length = l
 	}
-
-	re.length = l
-}
-
-func (re *chanResponseEmitter) Close() error {
-	return re.CloseWithError(nil)
 }
 
 func (re *chanResponseEmitter) CloseWithError(err error) error {
 	re.wl.Lock()
 	defer re.wl.Unlock()
 
-	return re.closeWithError(err)
+	if re.closed {
+		return errors.New("close of closed emitter")
+	}
+
+	re.closeWithError(err)
+	return nil
 }
 
-func (re *chanResponseEmitter) closeWithError(err error) error {
+func (re *chanResponseEmitter) closeWithError(err error) {
+	re.closed = true
+
 	if err == nil {
 		err = io.EOF
 	}
@@ -209,16 +208,13 @@ func (re *chanResponseEmitter) closeWithError(err error) error {
 		err = &e
 	}
 
-	re.closeOnce.Do(func() {
-		re.err = err
-		close(re.ch)
-		close(re.closed)
-	})
+	re.err = err
+	close(re.ch)
 
-	// unblock Length(), Error() and Head()
-	re.waitOnce.Do(func() {
+	// unblock Length() and Error()
+	select {
+	case <-re.wait:
+	default:
 		close(re.wait)
-	})
-
-	return nil
+	}
 }

Diff for: cli/responseemitter.go

@@ -51,14 +51,11 @@ type responseEmitter struct {
 	stderr io.Writer
 
 	length  uint64
-	err     *cmdkit.Error // TODO do we really need this?
 	enc     cmds.Encoder
 	encType cmds.EncodingType
 	exit    int
 	closed  bool
 
-	errOccurred bool
-
 	ch chan<- int
 }
 
@@ -93,9 +90,7 @@ func (re *responseEmitter) CloseWithError(err error) error {
 		return errors.New("closing closed emitter")
 	}
 
-	re.errOccurred = true
 	re.exit = 1 // TODO we could let err carry an exit code
-	re.err = e
 
 	_, err = fmt.Fprintln(re.stderr, "Error:", e.Message)
 	if err != nil {
@@ -164,17 +159,6 @@ func (re *responseEmitter) close() error {
 	return nil
 }
 
-// Head returns the current head.
-// TODO: maybe it makes sense to make these pointers to shared memory?
-//   might not be so clever though...concurrency and stuff
-// TODO: can we maybe drop this function? Then we could also remove the err struct field
-func (re *responseEmitter) Head() cmds.Head {
-	return cmds.Head{
-		Len: re.length,
-		Err: re.err,
-	}
-}
-
 func (re *responseEmitter) Emit(v interface{}) error {
 	// unwrap
 	if val, ok := v.(cmds.Single); ok {
@@ -187,9 +171,13 @@ func (re *responseEmitter) Emit(v interface{}) error {
 	// old error emitting semantics and _panic_ in those situations.
 	debug.AssertNotError(v)
 
+	// channel emission iteration
 	if ch, ok := v.(chan interface{}); ok {
 		v = (<-chan interface{})(ch)
 	}
+	if ch, isChan := v.(<-chan interface{}); isChan {
+		return cmds.EmitChan(re, ch)
+	}
 
 	// TODO find a better solution for this.
 	// Idea: use the actual cmd.Type and not *cmd.Type
@@ -201,19 +189,8 @@ func (re *responseEmitter) Emit(v interface{}) error {
 		v = *c
 	}
 
-	if ch, isChan := v.(<-chan interface{}); isChan {
-		log.Debug("iterating over chan...", ch)
-		for v = range ch {
-			err := re.Emit(v)
-			if err != nil {
-				return err
-			}
-		}
-		return nil
-	}
-
 	if re.isClosed() {
-		return io.ErrClosedPipe
+		return cmds.ErrClosedEmitter
 	}
 
 	var err error

Diff for: command_test.go

@@ -185,17 +185,13 @@ func TestPostRun(t *testing.T) {
 			finalLength: 4,
 			next:        []interface{}{14},
 			postRun: func(res Response, re ResponseEmitter) error {
-				defer re.Close()
 				l := res.Length()
 				re.SetLength(l + 1)
 
 				for {
 					v, err := res.Next()
-					if err == io.EOF {
-						return nil
-					}
+					t.Log("PostRun: Next returned", v, err)
 					if err != nil {
-						t.Error(err) // TODO keks: should this go?
 						return err
 					}
 
@@ -221,10 +217,6 @@ func TestPostRun(t *testing.T) {
 						t.Fatal(err)
 					}
 				}
-				err := re.Close()
-				if err != nil {
-					t.Fatal(err)
-				}
 				return nil
 			},
 			PostRun: PostRunMap{
@@ -263,8 +255,9 @@ func TestPostRun(t *testing.T) {
 
 		go func() {
 			err := cmd.PostRun[PostRunType(encType)](postres, postre)
+			err = postre.CloseWithError(err)
 			if err != nil {
-				t.Error("error in PostRun: ", err)
+				t.Error("error closing after PostRun: ", err)
 			}
 		}()
 
@@ -280,6 +273,7 @@ func TestPostRun(t *testing.T) {
 
 			go func() {
 				v, err := res.Next()
+				t.Log("next returned", v, err)
 				if err != nil {
 					close(ch)
 					t.Fatal(err)

Diff for: helpers_test.go

@@ -18,7 +18,9 @@ func (s *testEmitter) Close() error {
 
 func (s *testEmitter) SetLength(_ uint64) {}
 func (s *testEmitter) CloseWithError(err error) error {
-	(*testing.T)(s).Error(err)
+	if err != nil {
+		(*testing.T)(s).Error(err)
+	}
 	return nil
 }
 func (s *testEmitter) Emit(value interface{}) error {