Update to pass lint test

Signed-off-by: Derek McGowan <derek@mcgstyle.net> (github: dmcgowan)

Author: dmcgowan

inmem.go

@@ -11,6 +11,7 @@ import (
 	"github.com/dmcgowan/go/codec"
 )
 
+// Pipe returns an inmemory Sender/Receiver pair.
 func Pipe() (Receiver, Sender) {
 	session := createStreamSession()
 	return session.createPipe()
@@ -25,15 +26,15 @@ type streamSession struct {
 	handler codec.Handle
 
 	referenceLock sync.Mutex
-	referenceId   uint64
+	referenceID   uint64
 	byteStreams   map[uint64]*byteStream
 }
 
 func createStreamSession() *streamSession {
 	session := &streamSession{
 		pipeReaders: make(map[uint64]*io.PipeReader),
 		pipeWriters: make(map[uint64]*io.PipeWriter),
-		referenceId: 2,
+		referenceID: 2,
 		byteStreams: make(map[uint64]*byteStream),
 	}
 	session.handler = getMsgPackHandler(session)
@@ -43,110 +44,110 @@ func createStreamSession() *streamSession {
 func (s *streamSession) createPipe() (Receiver, Sender) {
 	r, w := io.Pipe()
 	s.pipeLock.Lock()
-	pipeId := s.pipeCount + 1
-	s.pipeCount = pipeId
-	s.pipeReaders[pipeId] = r
-	s.pipeWriters[pipeId] = w
+	pipeID := s.pipeCount + 1
+	s.pipeCount = pipeID
+	s.pipeReaders[pipeID] = r
+	s.pipeWriters[pipeID] = w
 	s.pipeLock.Unlock()
 
-	recv := &pipeReceiver{pipeId, s, r, codec.NewDecoder(r, s.handler)}
-	send := &pipeSender{pipeId, s, w, codec.NewEncoder(w, s.handler)}
+	recv := &pipeReceiver{pipeID, s, r, codec.NewDecoder(r, s.handler)}
+	send := &pipeSender{pipeID, s, w, codec.NewEncoder(w, s.handler)}
 	return recv, send
 }
 
 func (s *streamSession) newByteStream() (io.ReadWriteCloser, error) {
 	c1, c2 := net.Pipe()
 	bs := &byteStream{
 		Conn:        c1,
-		referenceId: s.referenceId,
+		referenceID: s.referenceID,
 	}
 	s.referenceLock.Lock()
-	s.byteStreams[s.referenceId] = bs
-	s.byteStreams[s.referenceId+1] = &byteStream{
+	s.byteStreams[s.referenceID] = bs
+	s.byteStreams[s.referenceID+1] = &byteStream{
 		Conn:        c2,
-		referenceId: s.referenceId + 1,
+		referenceID: s.referenceID + 1,
 		session:     s,
 	}
-	s.referenceId = s.referenceId + 2
+	s.referenceID = s.referenceID + 2
 	s.referenceLock.Unlock()
 
 	return bs, nil
 }
 
 func (s *streamSession) encodeReceiver(v reflect.Value) ([]byte, error) {
 	bs := v.Interface().(pipeReceiver)
-	if bs.pipeId == 0 {
+	if bs.pipeID == 0 {
 		return nil, errors.New("bad type")
 	}
 	var buf [8]byte
-	written := binary.PutUvarint(buf[:], uint64(bs.pipeId))
+	written := binary.PutUvarint(buf[:], uint64(bs.pipeID))
 
 	return buf[:written], nil
 }
 
 func (s *streamSession) decodeReceiver(v reflect.Value, b []byte) error {
-	pipeId, readN := binary.Uvarint(b)
+	pipeID, readN := binary.Uvarint(b)
 	if readN == 0 {
 		return errors.New("bad reference id")
 	}
 
-	r, ok := s.pipeReaders[pipeId]
+	r, ok := s.pipeReaders[pipeID]
 	if !ok {
-		return errors.New("Receiver does not exist")
+		return errors.New("receiver does not exist")
 	}
 
-	v.Set(reflect.ValueOf(pipeReceiver{pipeId, s, r, codec.NewDecoder(r, s.handler)}))
+	v.Set(reflect.ValueOf(pipeReceiver{pipeID, s, r, codec.NewDecoder(r, s.handler)}))
 
 	return nil
 }
 
 func (s *streamSession) encodeSender(v reflect.Value) ([]byte, error) {
 	sender := v.Interface().(pipeSender)
-	if sender.pipeId == 0 {
+	if sender.pipeID == 0 {
 		return nil, errors.New("bad type")
 	}
 	var buf [8]byte
-	written := binary.PutUvarint(buf[:], uint64(sender.pipeId))
+	written := binary.PutUvarint(buf[:], uint64(sender.pipeID))
 
 	return buf[:written], nil
 }
 
 func (s *streamSession) decodeSender(v reflect.Value, b []byte) error {
-	pipeId, readN := binary.Uvarint(b)
+	pipeID, readN := binary.Uvarint(b)
 	if readN == 0 {
 		return errors.New("bad reference id")
 	}
 
-	w, ok := s.pipeWriters[pipeId]
+	w, ok := s.pipeWriters[pipeID]
 	if !ok {
-		return errors.New("Receiver does not exist")
+		return errors.New("receiver does not exist")
 	}
 
-	v.Set(reflect.ValueOf(pipeSender{pipeId, s, w, codec.NewEncoder(w, s.handler)}))
+	v.Set(reflect.ValueOf(pipeSender{pipeID, s, w, codec.NewEncoder(w, s.handler)}))
 
 	return nil
 }
 
 func (s *streamSession) encodeStream(v reflect.Value) ([]byte, error) {
 	bs := v.Interface().(byteStream)
-	if bs.referenceId == 0 {
+	if bs.referenceID == 0 {
 		return nil, errors.New("bad type")
 	}
 	var buf [8]byte
-	written := binary.PutUvarint(buf[:], uint64(bs.referenceId)^0x01)
+	written := binary.PutUvarint(buf[:], uint64(bs.referenceID)^0x01)
 
 	return buf[:written], nil
 }
 
 func (s *streamSession) decodeStream(v reflect.Value, b []byte) error {
-	referenceId, readN := binary.Uvarint(b)
+	referenceID, readN := binary.Uvarint(b)
 	if readN == 0 {
 		return errors.New("bad reference id")
 	}
 
-	bs, ok := s.byteStreams[referenceId]
+	bs, ok := s.byteStreams[referenceID]
 	if !ok {
-		return errors.New("Byte stream does not exist")
+		return errors.New("byte stream does not exist")
 	}
 
 	if bs != nil {
@@ -211,7 +212,7 @@ func getMsgPackHandler(session *streamSession) *codec.MsgpackHandle {
 }
 
 type pipeSender struct {
-	pipeId  uint64
+	pipeID  uint64
 	session *streamSession
 	p       *io.PipeWriter
 	encoder *codec.Encoder
@@ -241,7 +242,7 @@ func (w *pipeSender) CreateNestedSender() (Sender, Receiver, error) {
 }
 
 type pipeReceiver struct {
-	pipeId  uint64
+	pipeID  uint64
 	session *streamSession
 	p       *io.PipeReader
 	decoder *codec.Decoder
@@ -257,6 +258,6 @@ func (r *pipeReceiver) Close() error {
 
 type byteStream struct {
 	net.Conn
-	referenceId uint64
+	referenceID uint64
 	session     *streamSession
 }

spdy/conn_test.go

@@ -25,7 +25,7 @@ type RecvMultiMessage struct {
 
 func TestMultiTcpByteStream(t *testing.T) {
 	wait := make(chan bool)
-	client := func(t *testing.T, sender libchan.Sender, s *SpdyTransport) {
+	client := func(t *testing.T, sender libchan.Sender, s *Transport) {
 		<-wait
 		both, connErr := net.Dial("tcp", "localhost:9272")
 		if connErr != nil {
@@ -97,7 +97,7 @@ func TestMultiTcpByteStream(t *testing.T) {
 		in.Close()
 		out.Close()
 	}
-	server := func(t *testing.T, receiver libchan.Receiver, s *SpdyTransport) {
+	server := func(t *testing.T, receiver libchan.Receiver, s *Transport) {
 		listener, listenerErr := net.Listen("tcp", "localhost:9272")
 		if listenerErr != nil {
 			t.Fatalf("Error creating byte stream listener: %s", listenerErr)

spdy/encode.go

@@ -12,7 +12,7 @@ import (
 	"github.com/docker/libchan"
 )
 
-func (s *SpdyTransport) encodeChannel(v reflect.Value) ([]byte, error) {
+func (s *Transport) encodeChannel(v reflect.Value) ([]byte, error) {
 	rc := v.Interface().(channel)
 	if rc.stream == nil {
 		return nil, errors.New("bad type")
@@ -22,23 +22,23 @@ func (s *SpdyTransport) encodeChannel(v reflect.Value) ([]byte, error) {
 	}
 
 	// Get stream identifier?
-	streamId := rc.stream.Identifier()
+	streamID := rc.stream.Identifier()
 	var buf [9]byte
 	if rc.direction == inbound {
 		buf[0] = 0x02 // Reverse direction
 	} else if rc.direction == outbound {
 		buf[0] = 0x01 // Reverse direction
 	} else {
-		return nil, errors.New("Invalid direction")
+		return nil, errors.New("invalid direction")
 	}
-	written := binary.PutUvarint(buf[1:], uint64(streamId))
+	written := binary.PutUvarint(buf[1:], uint64(streamID))
 	if written > 4 {
 		return nil, errors.New("wrote unexpected stream id size")
 	}
 	return buf[:(written + 1)], nil
 }
 
-func (s *SpdyTransport) decodeChannel(v reflect.Value, b []byte) error {
+func (s *Transport) decodeChannel(v reflect.Value, b []byte) error {
 	rc := v.Interface().(channel)
 
 	if b[0] == 0x01 {
@@ -49,11 +49,11 @@ func (s *SpdyTransport) decodeChannel(v reflect.Value, b []byte) error {
 		return errors.New("unexpected direction")
 	}
 
-	streamId, readN := binary.Uvarint(b[1:])
+	streamID, readN := binary.Uvarint(b[1:])
 	if readN > 4 {
 		return errors.New("read unexpected stream id size")
 	}
-	stream := s.conn.FindStream(uint32(streamId))
+	stream := s.conn.FindStream(uint32(streamID))
 	if stream == nil {
 		return errors.New("stream does not exist")
 	}
@@ -64,32 +64,32 @@ func (s *SpdyTransport) decodeChannel(v reflect.Value, b []byte) error {
 	return nil
 }
 
-func (s *SpdyTransport) encodeStream(v reflect.Value) ([]byte, error) {
+func (s *Transport) encodeStream(v reflect.Value) ([]byte, error) {
 	bs := v.Interface().(byteStream)
-	if bs.ReferenceId == 0 {
+	if bs.ReferenceID == 0 {
 		return nil, errors.New("bad type")
 	}
 	var buf [8]byte
-	written := binary.PutUvarint(buf[:], uint64(bs.ReferenceId))
+	written := binary.PutUvarint(buf[:], uint64(bs.ReferenceID))
 
 	return buf[:written], nil
 }
 
-func (s *SpdyTransport) decodeStream(v reflect.Value, b []byte) error {
-	referenceId, readN := binary.Uvarint(b)
+func (s *Transport) decodeStream(v reflect.Value, b []byte) error {
+	referenceID, readN := binary.Uvarint(b)
 	if readN == 0 {
 		return errors.New("bad reference id")
 	}
 
-	bs := s.getByteStream(referenceId)
+	bs := s.getByteStream(referenceID)
 	if bs != nil {
 		v.Set(reflect.ValueOf(*bs))
 	}
 
 	return nil
 }
 
-func (s *SpdyTransport) encodeWrapper(v reflect.Value) ([]byte, error) {
+func (s *Transport) encodeWrapper(v reflect.Value) ([]byte, error) {
 	wrapper := v.Interface().(libchan.ByteStreamWrapper)
 	bs, err := s.createByteStream()
 	if err != nil {
@@ -109,14 +109,14 @@ func (s *SpdyTransport) encodeWrapper(v reflect.Value) ([]byte, error) {
 	return s.encodeStream(reflect.ValueOf(bs).Elem())
 }
 
-func (s *SpdyTransport) decodeWrapper(v reflect.Value, b []byte) error {
+func (s *Transport) decodeWrapper(v reflect.Value, b []byte) error {
 	bs := &byteStream{}
 	s.decodeStream(reflect.ValueOf(bs).Elem(), b)
 	v.FieldByName("ReadWriteCloser").Set(reflect.ValueOf(bs))
 	return nil
 }
 
-func (s *SpdyTransport) waitConn(network, local, remote string, timeout time.Duration) (net.Conn, error) {
+func (s *Transport) waitConn(network, local, remote string, timeout time.Duration) (net.Conn, error) {
 	timeoutChan := time.After(timeout)
 	connChan := make(chan net.Conn)
 
@@ -202,7 +202,7 @@ func decodeString3(b []byte) (string, string, string, error) {
 	return s1, s2, s3, nil
 }
 
-func (s *SpdyTransport) encodeNetConn(v reflect.Value) ([]byte, error) {
+func (s *Transport) encodeNetConn(v reflect.Value) ([]byte, error) {
 	var conn net.Conn
 	switch t := v.Interface().(type) {
 	case net.TCPConn:
@@ -212,14 +212,14 @@ func (s *SpdyTransport) encodeNetConn(v reflect.Value) ([]byte, error) {
 	case net.Conn:
 		conn = t
 	default:
-		return nil, errors.New("Unknown type")
+		return nil, errors.New("unknown type")
 	}
 
 	// Flip remote and local for encoding
 	return encodeString3(conn.LocalAddr().Network(), conn.RemoteAddr().String(), conn.LocalAddr().String())
 }
 
-func (s *SpdyTransport) decodeNetConn(v reflect.Value, b []byte) error {
+func (s *Transport) decodeNetConn(v reflect.Value, b []byte) error {
 	network, local, remote, err := decodeString3(b)
 	if err != nil {
 		return err
@@ -234,7 +234,7 @@ func (s *SpdyTransport) decodeNetConn(v reflect.Value, b []byte) error {
 	return nil
 }
 
-func (s *SpdyTransport) initializeHandler() *codec.MsgpackHandle {
+func (s *Transport) initializeHandler() *codec.MsgpackHandle {
 	mh := &codec.MsgpackHandle{WriteExt: true}
 	mh.RawToString = true
 	err := mh.AddExt(reflect.TypeOf(channel{}), 0x01, s.encodeChannel, s.decodeChannel)

spdy/listener.go

@@ -31,7 +31,7 @@ func (l *TransportListener) Close() error {
 // AcceptTransport waits for a new network connections
 // and creates a new stream.  Connections which fail
 // authentication will not be returned.
-func (l *TransportListener) AcceptTransport() (*SpdyTransport, error) {
+func (l *TransportListener) AcceptTransport() (*Transport, error) {
 	for {
 		conn, err := l.listener.Accept()
 		if err != nil {

spdy/pipe.go

@@ -8,12 +8,12 @@ import (
 )
 
 type pipeSender struct {
-	session *SpdyTransport
+	session *Transport
 	sender  libchan.Sender
 }
 
 type pipeReceiver struct {
-	session  *SpdyTransport
+	session  *Transport
 	receiver libchan.Receiver
 }