mirror of
https://github.com/moby/moby.git
synced 2022-11-09 12:21:53 -05:00
317 lines
8.8 KiB
Go
317 lines
8.8 KiB
Go
package jsonmessage // import "github.com/docker/docker/pkg/jsonmessage"
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"strings"
|
|
"time"
|
|
|
|
gotty "github.com/Nvveen/Gotty"
|
|
"github.com/docker/docker/pkg/term"
|
|
units "github.com/docker/go-units"
|
|
)
|
|
|
|
// RFC3339NanoFixed is time.RFC3339Nano with nanoseconds padded using zeros to
|
|
// ensure the formatted time isalways the same number of characters.
|
|
const RFC3339NanoFixed = "2006-01-02T15:04:05.000000000Z07:00"
|
|
|
|
// JSONError wraps a concrete Code and Message, `Code` is
|
|
// is an integer error code, `Message` is the error message.
|
|
type JSONError struct {
|
|
Code int `json:"code,omitempty"`
|
|
Message string `json:"message,omitempty"`
|
|
}
|
|
|
|
func (e *JSONError) Error() string {
|
|
return e.Message
|
|
}
|
|
|
|
// JSONProgress describes a Progress. terminalFd is the fd of the current terminal,
|
|
// Start is the initial value for the operation. Current is the current status and
|
|
// value of the progress made towards Total. Total is the end value describing when
|
|
// we made 100% progress for an operation.
|
|
type JSONProgress struct {
|
|
terminalFd uintptr
|
|
Current int64 `json:"current,omitempty"`
|
|
Total int64 `json:"total,omitempty"`
|
|
Start int64 `json:"start,omitempty"`
|
|
// If true, don't show xB/yB
|
|
HideCounts bool `json:"hidecounts,omitempty"`
|
|
Units string `json:"units,omitempty"`
|
|
}
|
|
|
|
func (p *JSONProgress) String() string {
|
|
var (
|
|
width = 200
|
|
pbBox string
|
|
numbersBox string
|
|
timeLeftBox string
|
|
)
|
|
|
|
ws, err := term.GetWinsize(p.terminalFd)
|
|
if err == nil {
|
|
width = int(ws.Width)
|
|
}
|
|
|
|
if p.Current <= 0 && p.Total <= 0 {
|
|
return ""
|
|
}
|
|
if p.Total <= 0 {
|
|
switch p.Units {
|
|
case "":
|
|
current := units.HumanSize(float64(p.Current))
|
|
return fmt.Sprintf("%8v", current)
|
|
default:
|
|
return fmt.Sprintf("%d %s", p.Current, p.Units)
|
|
}
|
|
}
|
|
|
|
percentage := int(float64(p.Current)/float64(p.Total)*100) / 2
|
|
if percentage > 50 {
|
|
percentage = 50
|
|
}
|
|
if width > 110 {
|
|
// this number can't be negative gh#7136
|
|
numSpaces := 0
|
|
if 50-percentage > 0 {
|
|
numSpaces = 50 - percentage
|
|
}
|
|
pbBox = fmt.Sprintf("[%s>%s] ", strings.Repeat("=", percentage), strings.Repeat(" ", numSpaces))
|
|
}
|
|
|
|
switch {
|
|
case p.HideCounts:
|
|
case p.Units == "": // no units, use bytes
|
|
current := units.HumanSize(float64(p.Current))
|
|
total := units.HumanSize(float64(p.Total))
|
|
|
|
numbersBox = fmt.Sprintf("%8v/%v", current, total)
|
|
|
|
if p.Current > p.Total {
|
|
// remove total display if the reported current is wonky.
|
|
numbersBox = fmt.Sprintf("%8v", current)
|
|
}
|
|
default:
|
|
numbersBox = fmt.Sprintf("%d/%d %s", p.Current, p.Total, p.Units)
|
|
|
|
if p.Current > p.Total {
|
|
// remove total display if the reported current is wonky.
|
|
numbersBox = fmt.Sprintf("%d %s", p.Current, p.Units)
|
|
}
|
|
}
|
|
|
|
if p.Current > 0 && p.Start > 0 && percentage < 50 {
|
|
fromStart := time.Now().UTC().Sub(time.Unix(p.Start, 0))
|
|
perEntry := fromStart / time.Duration(p.Current)
|
|
left := time.Duration(p.Total-p.Current) * perEntry
|
|
left = (left / time.Second) * time.Second
|
|
|
|
if width > 50 {
|
|
timeLeftBox = " " + left.String()
|
|
}
|
|
}
|
|
return pbBox + numbersBox + timeLeftBox
|
|
}
|
|
|
|
// JSONMessage defines a message struct. It describes
|
|
// the created time, where it from, status, ID of the
|
|
// message. It's used for docker events.
|
|
type JSONMessage struct {
|
|
Stream string `json:"stream,omitempty"`
|
|
Status string `json:"status,omitempty"`
|
|
Progress *JSONProgress `json:"progressDetail,omitempty"`
|
|
ProgressMessage string `json:"progress,omitempty"` //deprecated
|
|
ID string `json:"id,omitempty"`
|
|
From string `json:"from,omitempty"`
|
|
Time int64 `json:"time,omitempty"`
|
|
TimeNano int64 `json:"timeNano,omitempty"`
|
|
Error *JSONError `json:"errorDetail,omitempty"`
|
|
ErrorMessage string `json:"error,omitempty"` //deprecated
|
|
// Aux contains out-of-band data, such as digests for push signing and image id after building.
|
|
Aux *json.RawMessage `json:"aux,omitempty"`
|
|
}
|
|
|
|
/* Satisfied by gotty.TermInfo as well as noTermInfo from below */
|
|
type termInfo interface {
|
|
Parse(attr string, params ...interface{}) (string, error)
|
|
}
|
|
|
|
type noTermInfo struct{} // canary used when no terminfo.
|
|
|
|
func (ti *noTermInfo) Parse(attr string, params ...interface{}) (string, error) {
|
|
return "", fmt.Errorf("noTermInfo")
|
|
}
|
|
|
|
func clearLine(out io.Writer, ti termInfo) {
|
|
// el2 (clear whole line) is not exposed by terminfo.
|
|
|
|
// First clear line from beginning to cursor
|
|
if attr, err := ti.Parse("el1"); err == nil {
|
|
fmt.Fprintf(out, "%s", attr)
|
|
} else {
|
|
fmt.Fprintf(out, "\x1b[1K")
|
|
}
|
|
// Then clear line from cursor to end
|
|
if attr, err := ti.Parse("el"); err == nil {
|
|
fmt.Fprintf(out, "%s", attr)
|
|
} else {
|
|
fmt.Fprintf(out, "\x1b[K")
|
|
}
|
|
}
|
|
|
|
func cursorUp(out io.Writer, ti termInfo, l int) {
|
|
if l == 0 { // Should never be the case, but be tolerant
|
|
return
|
|
}
|
|
if attr, err := ti.Parse("cuu", l); err == nil {
|
|
fmt.Fprintf(out, "%s", attr)
|
|
} else {
|
|
fmt.Fprintf(out, "\x1b[%dA", l)
|
|
}
|
|
}
|
|
|
|
func cursorDown(out io.Writer, ti termInfo, l int) {
|
|
if l == 0 { // Should never be the case, but be tolerant
|
|
return
|
|
}
|
|
if attr, err := ti.Parse("cud", l); err == nil {
|
|
fmt.Fprintf(out, "%s", attr)
|
|
} else {
|
|
fmt.Fprintf(out, "\x1b[%dB", l)
|
|
}
|
|
}
|
|
|
|
// Display displays the JSONMessage to `out`. `termInfo` is non-nil if `out`
|
|
// is a terminal. If this is the case, it will erase the entire current line
|
|
// when displaying the progressbar.
|
|
func (jm *JSONMessage) Display(out io.Writer, termInfo termInfo) error {
|
|
if jm.Error != nil {
|
|
if jm.Error.Code == 401 {
|
|
return fmt.Errorf("authentication is required")
|
|
}
|
|
return jm.Error
|
|
}
|
|
var endl string
|
|
if termInfo != nil && jm.Stream == "" && jm.Progress != nil {
|
|
clearLine(out, termInfo)
|
|
endl = "\r"
|
|
fmt.Fprintf(out, endl)
|
|
} else if jm.Progress != nil && jm.Progress.String() != "" { //disable progressbar in non-terminal
|
|
return nil
|
|
}
|
|
if jm.TimeNano != 0 {
|
|
fmt.Fprintf(out, "%s ", time.Unix(0, jm.TimeNano).Format(RFC3339NanoFixed))
|
|
} else if jm.Time != 0 {
|
|
fmt.Fprintf(out, "%s ", time.Unix(jm.Time, 0).Format(RFC3339NanoFixed))
|
|
}
|
|
if jm.ID != "" {
|
|
fmt.Fprintf(out, "%s: ", jm.ID)
|
|
}
|
|
if jm.From != "" {
|
|
fmt.Fprintf(out, "(from %s) ", jm.From)
|
|
}
|
|
if jm.Progress != nil && termInfo != nil {
|
|
fmt.Fprintf(out, "%s %s%s", jm.Status, jm.Progress.String(), endl)
|
|
} else if jm.ProgressMessage != "" { //deprecated
|
|
fmt.Fprintf(out, "%s %s%s", jm.Status, jm.ProgressMessage, endl)
|
|
} else if jm.Stream != "" {
|
|
fmt.Fprintf(out, "%s%s", jm.Stream, endl)
|
|
} else {
|
|
fmt.Fprintf(out, "%s%s\n", jm.Status, endl)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// DisplayJSONMessagesStream displays a json message stream from `in` to `out`, `isTerminal`
|
|
// describes if `out` is a terminal. If this is the case, it will print `\n` at the end of
|
|
// each line and move the cursor while displaying.
|
|
func DisplayJSONMessagesStream(in io.Reader, out io.Writer, terminalFd uintptr, isTerminal bool, auxCallback func(*json.RawMessage)) error {
|
|
var (
|
|
dec = json.NewDecoder(in)
|
|
ids = make(map[string]int)
|
|
)
|
|
|
|
var termInfo termInfo
|
|
|
|
if isTerminal {
|
|
term := os.Getenv("TERM")
|
|
if term == "" {
|
|
term = "vt102"
|
|
}
|
|
|
|
var err error
|
|
if termInfo, err = gotty.OpenTermInfo(term); err != nil {
|
|
termInfo = &noTermInfo{}
|
|
}
|
|
}
|
|
|
|
for {
|
|
diff := 0
|
|
var jm JSONMessage
|
|
if err := dec.Decode(&jm); err != nil {
|
|
if err == io.EOF {
|
|
break
|
|
}
|
|
return err
|
|
}
|
|
|
|
if jm.Aux != nil {
|
|
if auxCallback != nil {
|
|
auxCallback(jm.Aux)
|
|
}
|
|
continue
|
|
}
|
|
|
|
if jm.Progress != nil {
|
|
jm.Progress.terminalFd = terminalFd
|
|
}
|
|
if jm.ID != "" && (jm.Progress != nil || jm.ProgressMessage != "") {
|
|
line, ok := ids[jm.ID]
|
|
if !ok {
|
|
// NOTE: This approach of using len(id) to
|
|
// figure out the number of lines of history
|
|
// only works as long as we clear the history
|
|
// when we output something that's not
|
|
// accounted for in the map, such as a line
|
|
// with no ID.
|
|
line = len(ids)
|
|
ids[jm.ID] = line
|
|
if termInfo != nil {
|
|
fmt.Fprintf(out, "\n")
|
|
}
|
|
}
|
|
diff = len(ids) - line
|
|
if termInfo != nil {
|
|
cursorUp(out, termInfo, diff)
|
|
}
|
|
} else {
|
|
// When outputting something that isn't progress
|
|
// output, clear the history of previous lines. We
|
|
// don't want progress entries from some previous
|
|
// operation to be updated (for example, pull -a
|
|
// with multiple tags).
|
|
ids = make(map[string]int)
|
|
}
|
|
err := jm.Display(out, termInfo)
|
|
if jm.ID != "" && termInfo != nil {
|
|
cursorDown(out, termInfo, diff)
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type stream interface {
|
|
io.Writer
|
|
FD() uintptr
|
|
IsTerminal() bool
|
|
}
|
|
|
|
// DisplayJSONMessagesToStream prints json messages to the output stream
|
|
func DisplayJSONMessagesToStream(in io.Reader, stream stream, auxCallback func(*json.RawMessage)) error {
|
|
return DisplayJSONMessagesStream(in, stream, stream.FD(), stream.IsTerminal(), auxCallback)
|
|
}
|