2014-09-17 15:04:56 +00:00
|
|
|
package stdcopy
|
2013-09-11 18:35:09 +00:00
|
|
|
|
|
|
|
import (
|
|
|
|
"encoding/binary"
|
|
|
|
"errors"
|
|
|
|
"io"
|
2014-07-24 20:37:44 +00:00
|
|
|
|
2015-03-26 22:22:04 +00:00
|
|
|
"github.com/Sirupsen/logrus"
|
2013-09-11 18:35:09 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
const (
|
|
|
|
StdWriterPrefixLen = 8
|
|
|
|
StdWriterFdIndex = 0
|
|
|
|
StdWriterSizeIndex = 4
|
|
|
|
)
|
|
|
|
|
|
|
|
type StdType [StdWriterPrefixLen]byte
|
|
|
|
|
|
|
|
var (
|
|
|
|
Stdin StdType = StdType{0: 0}
|
|
|
|
Stdout StdType = StdType{0: 1}
|
|
|
|
Stderr StdType = StdType{0: 2}
|
|
|
|
)
|
|
|
|
|
|
|
|
type StdWriter struct {
|
|
|
|
io.Writer
|
2013-09-26 22:59:02 +00:00
|
|
|
prefix StdType
|
|
|
|
sizeBuf []byte
|
2013-09-11 18:35:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func (w *StdWriter) Write(buf []byte) (n int, err error) {
|
2014-09-17 13:50:56 +00:00
|
|
|
var n1, n2 int
|
2013-09-11 18:35:09 +00:00
|
|
|
if w == nil || w.Writer == nil {
|
2015-06-24 07:00:14 +00:00
|
|
|
return 0, errors.New("Writer not instantiated")
|
2013-09-11 18:35:09 +00:00
|
|
|
}
|
2013-09-26 22:59:02 +00:00
|
|
|
binary.BigEndian.PutUint32(w.prefix[4:], uint32(len(buf)))
|
2014-09-17 13:50:56 +00:00
|
|
|
n1, err = w.Writer.Write(w.prefix[:])
|
|
|
|
if err != nil {
|
|
|
|
n = n1 - StdWriterPrefixLen
|
|
|
|
} else {
|
|
|
|
n2, err = w.Writer.Write(buf)
|
|
|
|
n = n1 + n2 - StdWriterPrefixLen
|
|
|
|
}
|
|
|
|
if n < 0 {
|
|
|
|
n = 0
|
|
|
|
}
|
|
|
|
return
|
2013-09-11 18:35:09 +00:00
|
|
|
}
|
|
|
|
|
2015-06-24 07:00:14 +00:00
|
|
|
// NewStdWriter instantiates a new Writer.
|
2013-10-16 17:58:53 +00:00
|
|
|
// Everything written to it will be encapsulated using a custom format,
|
|
|
|
// and written to the underlying `w` stream.
|
|
|
|
// This allows multiple write streams (e.g. stdout and stderr) to be muxed into a single connection.
|
|
|
|
// `t` indicates the id of the stream to encapsulate.
|
2015-04-13 09:21:27 +00:00
|
|
|
// It can be stdcopy.Stdin, stdcopy.Stdout, stdcopy.Stderr.
|
2013-09-11 18:35:09 +00:00
|
|
|
func NewStdWriter(w io.Writer, t StdType) *StdWriter {
|
|
|
|
return &StdWriter{
|
2013-09-26 22:59:02 +00:00
|
|
|
Writer: w,
|
|
|
|
prefix: t,
|
|
|
|
sizeBuf: make([]byte, 4),
|
2013-09-11 18:35:09 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
var ErrInvalidStdHeader = errors.New("Unrecognized input header")
|
|
|
|
|
|
|
|
// StdCopy is a modified version of io.Copy.
|
|
|
|
//
|
2013-10-16 17:58:53 +00:00
|
|
|
// StdCopy will demultiplex `src`, assuming that it contains two streams,
|
|
|
|
// previously multiplexed together using a StdWriter instance.
|
|
|
|
// As it reads from `src`, StdCopy will write to `dstout` and `dsterr`.
|
2013-09-11 18:35:09 +00:00
|
|
|
//
|
2013-10-16 17:58:53 +00:00
|
|
|
// StdCopy will read until it hits EOF on `src`. It will then return a nil error.
|
|
|
|
// In other words: if `err` is non nil, it indicates a real underlying error.
|
2013-09-11 18:35:09 +00:00
|
|
|
//
|
2013-10-16 17:58:53 +00:00
|
|
|
// `written` will hold the total number of bytes written to `dstout` and `dsterr`.
|
2013-09-11 18:35:09 +00:00
|
|
|
func StdCopy(dstout, dsterr io.Writer, src io.Reader) (written int64, err error) {
|
|
|
|
var (
|
|
|
|
buf = make([]byte, 32*1024+StdWriterPrefixLen+1)
|
|
|
|
bufLen = len(buf)
|
|
|
|
nr, nw int
|
|
|
|
er, ew error
|
|
|
|
out io.Writer
|
|
|
|
frameSize int
|
|
|
|
)
|
|
|
|
|
|
|
|
for {
|
|
|
|
// Make sure we have at least a full header
|
|
|
|
for nr < StdWriterPrefixLen {
|
|
|
|
var nr2 int
|
|
|
|
nr2, er = src.Read(buf[nr:])
|
|
|
|
nr += nr2
|
2014-06-19 17:42:55 +00:00
|
|
|
if er == io.EOF {
|
|
|
|
if nr < StdWriterPrefixLen {
|
2015-03-26 22:22:04 +00:00
|
|
|
logrus.Debugf("Corrupted prefix: %v", buf[:nr])
|
2014-06-19 17:42:55 +00:00
|
|
|
return written, nil
|
|
|
|
}
|
|
|
|
break
|
|
|
|
}
|
|
|
|
if er != nil {
|
2015-03-26 22:22:04 +00:00
|
|
|
logrus.Debugf("Error reading header: %s", er)
|
2014-06-19 17:42:55 +00:00
|
|
|
return 0, er
|
2014-06-09 12:28:32 +00:00
|
|
|
}
|
2013-09-11 18:35:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Check the first byte to know where to write
|
|
|
|
switch buf[StdWriterFdIndex] {
|
|
|
|
case 0:
|
|
|
|
fallthrough
|
|
|
|
case 1:
|
|
|
|
// Write on stdout
|
|
|
|
out = dstout
|
|
|
|
case 2:
|
|
|
|
// Write on stderr
|
|
|
|
out = dsterr
|
|
|
|
default:
|
2015-03-26 22:22:04 +00:00
|
|
|
logrus.Debugf("Error selecting output fd: (%d)", buf[StdWriterFdIndex])
|
2013-09-11 18:35:09 +00:00
|
|
|
return 0, ErrInvalidStdHeader
|
|
|
|
}
|
|
|
|
|
|
|
|
// Retrieve the size of the frame
|
2013-09-26 22:59:02 +00:00
|
|
|
frameSize = int(binary.BigEndian.Uint32(buf[StdWriterSizeIndex : StdWriterSizeIndex+4]))
|
2015-03-26 22:22:04 +00:00
|
|
|
logrus.Debugf("framesize: %d", frameSize)
|
2013-09-11 18:35:09 +00:00
|
|
|
|
|
|
|
// Check if the buffer is big enough to read the frame.
|
|
|
|
// Extend it if necessary.
|
|
|
|
if frameSize+StdWriterPrefixLen > bufLen {
|
2015-03-26 22:22:04 +00:00
|
|
|
logrus.Debugf("Extending buffer cap by %d (was %d)", frameSize+StdWriterPrefixLen-bufLen+1, len(buf))
|
2014-03-31 17:49:48 +00:00
|
|
|
buf = append(buf, make([]byte, frameSize+StdWriterPrefixLen-bufLen+1)...)
|
2013-09-11 18:35:09 +00:00
|
|
|
bufLen = len(buf)
|
|
|
|
}
|
|
|
|
|
|
|
|
// While the amount of bytes read is less than the size of the frame + header, we keep reading
|
|
|
|
for nr < frameSize+StdWriterPrefixLen {
|
|
|
|
var nr2 int
|
|
|
|
nr2, er = src.Read(buf[nr:])
|
2014-06-19 17:42:55 +00:00
|
|
|
nr += nr2
|
2013-09-11 18:35:09 +00:00
|
|
|
if er == io.EOF {
|
2014-06-19 17:42:55 +00:00
|
|
|
if nr < frameSize+StdWriterPrefixLen {
|
2015-03-26 22:22:04 +00:00
|
|
|
logrus.Debugf("Corrupted frame: %v", buf[StdWriterPrefixLen:nr])
|
2014-06-19 17:42:55 +00:00
|
|
|
return written, nil
|
|
|
|
}
|
|
|
|
break
|
2013-09-11 18:35:09 +00:00
|
|
|
}
|
|
|
|
if er != nil {
|
2015-03-26 22:22:04 +00:00
|
|
|
logrus.Debugf("Error reading frame: %s", er)
|
2013-09-11 18:35:09 +00:00
|
|
|
return 0, er
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Write the retrieved frame (without header)
|
|
|
|
nw, ew = out.Write(buf[StdWriterPrefixLen : frameSize+StdWriterPrefixLen])
|
|
|
|
if ew != nil {
|
2015-03-26 22:22:04 +00:00
|
|
|
logrus.Debugf("Error writing frame: %s", ew)
|
2013-09-11 18:35:09 +00:00
|
|
|
return 0, ew
|
|
|
|
}
|
|
|
|
// If the frame has not been fully written: error
|
|
|
|
if nw != frameSize {
|
2015-03-26 22:22:04 +00:00
|
|
|
logrus.Debugf("Error Short Write: (%d on %d)", nw, frameSize)
|
2013-09-11 18:35:09 +00:00
|
|
|
return 0, io.ErrShortWrite
|
|
|
|
}
|
2014-06-19 17:42:55 +00:00
|
|
|
written += int64(nw)
|
2013-09-11 18:35:09 +00:00
|
|
|
|
|
|
|
// Move the rest of the buffer to the beginning
|
|
|
|
copy(buf, buf[frameSize+StdWriterPrefixLen:])
|
|
|
|
// Move the index
|
|
|
|
nr -= frameSize + StdWriterPrefixLen
|
|
|
|
}
|
|
|
|
}
|