2015-12-06 23:34:25 +00:00
|
|
|
package inspect
|
|
|
|
|
|
|
|
import (
|
|
|
|
"bytes"
|
|
|
|
"encoding/json"
|
|
|
|
"io"
|
2017-02-01 20:03:58 +00:00
|
|
|
"strings"
|
2015-12-06 23:34:25 +00:00
|
|
|
"text/template"
|
2016-05-10 14:58:07 +00:00
|
|
|
|
|
|
|
"github.com/Sirupsen/logrus"
|
|
|
|
"github.com/docker/docker/cli"
|
2016-12-12 08:34:03 +00:00
|
|
|
"github.com/docker/docker/pkg/templates"
|
2017-03-09 18:23:45 +00:00
|
|
|
"github.com/pkg/errors"
|
2015-12-06 23:34:25 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
// Inspector defines an interface to implement to process elements
|
|
|
|
type Inspector interface {
|
|
|
|
Inspect(typedElement interface{}, rawElement []byte) error
|
|
|
|
Flush() error
|
|
|
|
}
|
|
|
|
|
|
|
|
// TemplateInspector uses a text template to inspect elements.
|
|
|
|
type TemplateInspector struct {
|
|
|
|
outputStream io.Writer
|
|
|
|
buffer *bytes.Buffer
|
|
|
|
tmpl *template.Template
|
|
|
|
}
|
|
|
|
|
|
|
|
// NewTemplateInspector creates a new inspector with a template.
|
|
|
|
func NewTemplateInspector(outputStream io.Writer, tmpl *template.Template) Inspector {
|
|
|
|
return &TemplateInspector{
|
|
|
|
outputStream: outputStream,
|
|
|
|
buffer: new(bytes.Buffer),
|
|
|
|
tmpl: tmpl,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-05-10 14:58:07 +00:00
|
|
|
// NewTemplateInspectorFromString creates a new TemplateInspector from a string
|
|
|
|
// which is compiled into a template.
|
|
|
|
func NewTemplateInspectorFromString(out io.Writer, tmplStr string) (Inspector, error) {
|
|
|
|
if tmplStr == "" {
|
|
|
|
return NewIndentedInspector(out), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
tmpl, err := templates.Parse(tmplStr)
|
|
|
|
if err != nil {
|
2017-03-09 18:23:45 +00:00
|
|
|
return nil, errors.Errorf("Template parsing error: %s", err)
|
2016-05-10 14:58:07 +00:00
|
|
|
}
|
|
|
|
return NewTemplateInspector(out, tmpl), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetRefFunc is a function which used by Inspect to fetch an object from a
|
|
|
|
// reference
|
|
|
|
type GetRefFunc func(ref string) (interface{}, []byte, error)
|
|
|
|
|
|
|
|
// Inspect fetches objects by reference using GetRefFunc and writes the json
|
|
|
|
// representation to the output writer.
|
|
|
|
func Inspect(out io.Writer, references []string, tmplStr string, getRef GetRefFunc) error {
|
|
|
|
inspector, err := NewTemplateInspectorFromString(out, tmplStr)
|
|
|
|
if err != nil {
|
|
|
|
return cli.StatusError{StatusCode: 64, Status: err.Error()}
|
|
|
|
}
|
|
|
|
|
2017-02-01 20:03:58 +00:00
|
|
|
var inspectErrs []string
|
2016-05-10 14:58:07 +00:00
|
|
|
for _, ref := range references {
|
|
|
|
element, raw, err := getRef(ref)
|
|
|
|
if err != nil {
|
2017-02-01 20:03:58 +00:00
|
|
|
inspectErrs = append(inspectErrs, err.Error())
|
|
|
|
continue
|
2016-05-10 14:58:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if err := inspector.Inspect(element, raw); err != nil {
|
2017-02-01 20:03:58 +00:00
|
|
|
inspectErrs = append(inspectErrs, err.Error())
|
2016-05-10 14:58:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := inspector.Flush(); err != nil {
|
|
|
|
logrus.Errorf("%s\n", err)
|
|
|
|
}
|
|
|
|
|
2017-02-01 20:03:58 +00:00
|
|
|
if len(inspectErrs) != 0 {
|
|
|
|
return cli.StatusError{
|
|
|
|
StatusCode: 1,
|
|
|
|
Status: strings.Join(inspectErrs, "\n"),
|
|
|
|
}
|
2016-05-10 14:58:07 +00:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2015-12-06 23:34:25 +00:00
|
|
|
// Inspect executes the inspect template.
|
|
|
|
// It decodes the raw element into a map if the initial execution fails.
|
|
|
|
// This allows docker cli to parse inspect structs injected with Swarm fields.
|
2015-12-08 03:04:38 +00:00
|
|
|
func (i *TemplateInspector) Inspect(typedElement interface{}, rawElement []byte) error {
|
2015-12-06 23:34:25 +00:00
|
|
|
buffer := new(bytes.Buffer)
|
|
|
|
if err := i.tmpl.Execute(buffer, typedElement); err != nil {
|
2015-12-08 03:04:38 +00:00
|
|
|
if rawElement == nil {
|
2017-03-09 18:23:45 +00:00
|
|
|
return errors.Errorf("Template parsing error: %v", err)
|
2015-12-06 23:34:25 +00:00
|
|
|
}
|
2016-06-07 20:38:02 +00:00
|
|
|
return i.tryRawInspectFallback(rawElement)
|
2015-12-08 03:04:38 +00:00
|
|
|
}
|
|
|
|
i.buffer.Write(buffer.Bytes())
|
|
|
|
i.buffer.WriteByte('\n')
|
|
|
|
return nil
|
|
|
|
}
|
2015-12-06 23:34:25 +00:00
|
|
|
|
2016-06-07 20:38:02 +00:00
|
|
|
// tryRawInspectFallback executes the inspect template with a raw interface.
|
|
|
|
// This allows docker cli to parse inspect structs injected with Swarm fields.
|
|
|
|
func (i *TemplateInspector) tryRawInspectFallback(rawElement []byte) error {
|
|
|
|
var raw interface{}
|
|
|
|
buffer := new(bytes.Buffer)
|
|
|
|
rdr := bytes.NewReader(rawElement)
|
|
|
|
dec := json.NewDecoder(rdr)
|
|
|
|
|
|
|
|
if rawErr := dec.Decode(&raw); rawErr != nil {
|
2017-03-09 18:23:45 +00:00
|
|
|
return errors.Errorf("unable to read inspect data: %v", rawErr)
|
2016-06-07 20:38:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
tmplMissingKey := i.tmpl.Option("missingkey=error")
|
|
|
|
if rawErr := tmplMissingKey.Execute(buffer, raw); rawErr != nil {
|
2017-03-09 18:23:45 +00:00
|
|
|
return errors.Errorf("Template parsing error: %v", rawErr)
|
2016-06-07 20:38:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
i.buffer.Write(buffer.Bytes())
|
|
|
|
i.buffer.WriteByte('\n')
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2016-09-25 08:47:45 +00:00
|
|
|
// Flush writes the result of inspecting all elements into the output stream.
|
2015-12-08 03:04:38 +00:00
|
|
|
func (i *TemplateInspector) Flush() error {
|
2015-12-11 01:36:08 +00:00
|
|
|
if i.buffer.Len() == 0 {
|
|
|
|
_, err := io.WriteString(i.outputStream, "\n")
|
|
|
|
return err
|
|
|
|
}
|
2015-12-06 23:34:25 +00:00
|
|
|
_, err := io.Copy(i.outputStream, i.buffer)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
// IndentedInspector uses a buffer to stop the indented representation of an element.
|
|
|
|
type IndentedInspector struct {
|
|
|
|
outputStream io.Writer
|
2015-12-08 03:04:38 +00:00
|
|
|
elements []interface{}
|
2015-12-18 01:46:48 +00:00
|
|
|
rawElements [][]byte
|
2015-12-06 23:34:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// NewIndentedInspector generates a new IndentedInspector.
|
|
|
|
func NewIndentedInspector(outputStream io.Writer) Inspector {
|
|
|
|
return &IndentedInspector{
|
|
|
|
outputStream: outputStream,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Inspect writes the raw element with an indented json format.
|
2015-12-18 01:46:48 +00:00
|
|
|
func (i *IndentedInspector) Inspect(typedElement interface{}, rawElement []byte) error {
|
|
|
|
if rawElement != nil {
|
|
|
|
i.rawElements = append(i.rawElements, rawElement)
|
|
|
|
} else {
|
|
|
|
i.elements = append(i.elements, typedElement)
|
|
|
|
}
|
2015-12-06 23:34:25 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2016-09-25 08:47:45 +00:00
|
|
|
// Flush writes the result of inspecting all elements into the output stream.
|
2015-12-08 03:04:38 +00:00
|
|
|
func (i *IndentedInspector) Flush() error {
|
2015-12-18 01:46:48 +00:00
|
|
|
if len(i.elements) == 0 && len(i.rawElements) == 0 {
|
2015-12-08 03:04:38 +00:00
|
|
|
_, err := io.WriteString(i.outputStream, "[]\n")
|
|
|
|
return err
|
2015-12-06 23:34:25 +00:00
|
|
|
}
|
|
|
|
|
2015-12-18 01:46:48 +00:00
|
|
|
var buffer io.Reader
|
|
|
|
if len(i.rawElements) > 0 {
|
|
|
|
bytesBuffer := new(bytes.Buffer)
|
|
|
|
bytesBuffer.WriteString("[")
|
|
|
|
for idx, r := range i.rawElements {
|
|
|
|
bytesBuffer.Write(r)
|
|
|
|
if idx < len(i.rawElements)-1 {
|
|
|
|
bytesBuffer.WriteString(",")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
bytesBuffer.WriteString("]")
|
|
|
|
indented := new(bytes.Buffer)
|
|
|
|
if err := json.Indent(indented, bytesBuffer.Bytes(), "", " "); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
buffer = indented
|
|
|
|
} else {
|
|
|
|
b, err := json.MarshalIndent(i.elements, "", " ")
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
buffer = bytes.NewReader(b)
|
2015-12-08 03:04:38 +00:00
|
|
|
}
|
|
|
|
|
2015-12-18 01:46:48 +00:00
|
|
|
if _, err := io.Copy(i.outputStream, buffer); err != nil {
|
2015-12-08 03:04:38 +00:00
|
|
|
return err
|
|
|
|
}
|
2015-12-18 01:46:48 +00:00
|
|
|
_, err := io.WriteString(i.outputStream, "\n")
|
2015-12-06 23:34:25 +00:00
|
|
|
return err
|
|
|
|
}
|