mirror of
https://github.com/moby/moby.git
synced 2026-01-11 18:51:37 +00:00
20d594fb79
The stdcopy package is used to produce and read multiplexed streams for "attach" and "logs". It is used both by the API server (to produce), and the client (to read / de-multiplex). Move it to the api package, so that it can be included in the api module. Signed-off-by: Sebastiaan van Stijn <github@gone.nl>
90 lines
2.4 KiB
Go
90 lines
2.4 KiB
Go
package httputils
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"net/url"
|
|
"sort"
|
|
|
|
"github.com/docker/docker/pkg/ioutils"
|
|
"github.com/docker/docker/pkg/jsonmessage"
|
|
"github.com/moby/moby/api/stdcopy"
|
|
"github.com/moby/moby/api/types/backend"
|
|
"github.com/moby/moby/api/types/container"
|
|
)
|
|
|
|
// WriteLogStream writes an encoded byte stream of log messages from the
|
|
// messages channel, multiplexing them with a stdcopy.Writer if mux is true
|
|
func WriteLogStream(_ context.Context, w http.ResponseWriter, msgs <-chan *backend.LogMessage, config *container.LogsOptions, mux bool) {
|
|
// See https://github.com/moby/moby/issues/47448
|
|
// Trigger headers to be written immediately.
|
|
w.WriteHeader(http.StatusOK)
|
|
|
|
wf := ioutils.NewWriteFlusher(w)
|
|
defer wf.Close()
|
|
|
|
wf.Flush()
|
|
|
|
outStream := io.Writer(wf)
|
|
errStream := outStream
|
|
sysErrStream := errStream
|
|
if mux {
|
|
sysErrStream = stdcopy.NewStdWriter(outStream, stdcopy.Systemerr)
|
|
errStream = stdcopy.NewStdWriter(outStream, stdcopy.Stderr)
|
|
outStream = stdcopy.NewStdWriter(outStream, stdcopy.Stdout)
|
|
}
|
|
|
|
for {
|
|
msg, ok := <-msgs
|
|
if !ok {
|
|
return
|
|
}
|
|
// check if the message contains an error. if so, write that error
|
|
// and exit
|
|
if msg.Err != nil {
|
|
fmt.Fprintf(sysErrStream, "Error grabbing logs: %v\n", msg.Err)
|
|
continue
|
|
}
|
|
logLine := msg.Line
|
|
if config.Details {
|
|
logLine = append(attrsByteSlice(msg.Attrs), ' ')
|
|
logLine = append(logLine, msg.Line...)
|
|
}
|
|
if config.Timestamps {
|
|
logLine = append([]byte(msg.Timestamp.Format(jsonmessage.RFC3339NanoFixed)+" "), logLine...)
|
|
}
|
|
if msg.Source == "stdout" && config.ShowStdout {
|
|
_, _ = outStream.Write(logLine)
|
|
}
|
|
if msg.Source == "stderr" && config.ShowStderr {
|
|
_, _ = errStream.Write(logLine)
|
|
}
|
|
}
|
|
}
|
|
|
|
type byKey []backend.LogAttr
|
|
|
|
func (b byKey) Len() int { return len(b) }
|
|
func (b byKey) Less(i, j int) bool { return b[i].Key < b[j].Key }
|
|
func (b byKey) Swap(i, j int) { b[i], b[j] = b[j], b[i] }
|
|
|
|
func attrsByteSlice(a []backend.LogAttr) []byte {
|
|
// Note this sorts "a" in-place. That is fine here - nothing else is
|
|
// going to use Attrs or care about the order.
|
|
sort.Sort(byKey(a))
|
|
|
|
var ret []byte
|
|
for i, pair := range a {
|
|
k, v := url.QueryEscape(pair.Key), url.QueryEscape(pair.Value)
|
|
ret = append(ret, []byte(k)...)
|
|
ret = append(ret, '=')
|
|
ret = append(ret, []byte(v)...)
|
|
if i != len(a)-1 {
|
|
ret = append(ret, ',')
|
|
}
|
|
}
|
|
return ret
|
|
}
|