github/kubernetes
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

add jsonpath to kubectl

Browse Source
This commit is contained in:
Dai Zuozhuo
2015-08-04 16:14:31 +08:00
parent 8a43bd621e
commit b61a905b19
23 changed files with 250 additions and 144 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
pkg/kubectl/cmd/get.go
View File

@@ -69,7 +69,7 @@ func NewCmdGet(f *cmdutil.Factory, out io.Writer) *cobra.Command {
validArgs := p.HandledResources()
cmd := &cobra.Command{
Use: "get [(-o|--output=)json|yaml|template|wide|...] (TYPE [(NAME | -l label] | TYPE/NAME ...) [flags]",
Use: "get [(-o|--output=)json|yaml|template|templatefile|wide|jsonpath|...] (TYPE [NAME | -l label] | TYPE/NAME ...)",
Short: "Display one or many resources",
Long: get_long,
Example: get_example,

4
pkg/kubectl/cmd/util/printing.go
View File

@@ -28,10 +28,10 @@ import (
// AddPrinterFlags adds printing related flags to a command (e.g. output format, no headers, template path)
func AddPrinterFlags(cmd *cobra.Command) {
cmd.Flags().StringP("output", "o", "", "Output format. One of: json|yaml|template|templatefile|wide.")
cmd.Flags().StringP("output", "o", "", "Output format. One of: json|yaml|template|templatefile|wide|jsonpath.")
cmd.Flags().String("output-version", "", "Output the formatted object with the given version (default api-version).")
cmd.Flags().Bool("no-headers", false, "When using the default output, don't print headers.")
cmd.Flags().StringP("template", "t", "", "Template string or path to template file to use when -o=template or -o=templatefile. The template format is golang templates [http://golang.org/pkg/text/template/#pkg-overview]")
cmd.Flags().StringP("template", "t", "", "Template string or path to template file to use when -o=template, -o=templatefile or -o=jsonpath. The template format is golang templates [http://golang.org/pkg/text/template/#pkg-overview]. The jsonpath template is composed of jsonpath expressions enclosed by {}")
cmd.Flags().String("sort-by", "", "If non-empty, sort list types using this field specification. The field specification is expressed as a JSONPath expression (e.g. 'ObjectMeta.Name'). The field in the API resource specified by this JSONPath expression must be an integer or a string.")
cmd.Flags().BoolP("show-all", "a", false, "When printing, show all resources (default hide terminated pods.)")
}

44
pkg/kubectl/resource_printer.go
View File

@@ -35,6 +35,7 @@ import (
"k8s.io/kubernetes/pkg/conversion"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/util"
"k8s.io/kubernetes/pkg/util/jsonpath"
"k8s.io/kubernetes/pkg/volume"
)
@@ -71,6 +72,15 @@ func GetPrinter(format, formatArgument string) (ResourcePrinter, bool, error) {
if err != nil {
return nil, false, fmt.Errorf("error parsing template %s, %v\n", string(data), err)
}
case "jsonpath":
if len(formatArgument) == 0 {
return nil, false, fmt.Errorf("jsonpath format specified but no jsonpath template given")
}
var err error
printer, err = NewJSONPathPrinter(formatArgument)
if err != nil {
return nil, false, fmt.Errorf("error parsing jsonpath %s, %v\n", formatArgument, err)
}
case "wide":
fallthrough
case "":
@@ -1205,3 +1215,37 @@ func indirect(v reflect.Value) (rv reflect.Value, isNil bool) {
}
return v, false
}
// JSONPathPrinter is an implementation of ResourcePrinter which formats data with jsonpath expression.
type JSONPathPrinter struct {
rawTemplate string
*jsonpath.JSONPath
}
func NewJSONPathPrinter(tmpl string) (*JSONPathPrinter, error) {
j := jsonpath.New("out")
if err := j.Parse(tmpl); err != nil {
return nil, err
}
return &JSONPathPrinter{tmpl, j}, nil
}
// PrintObj formats the obj with the JSONPath Template.
func (j *JSONPathPrinter) PrintObj(obj runtime.Object, w io.Writer) error {
data, err := json.Marshal(obj)
if err != nil {
return err
}
out := map[string]interface{}{}
if err := json.Unmarshal(data, &out); err != nil {
return err
}
if err = j.JSONPath.Execute(w, out); err != nil {
fmt.Fprintf(w, "Error executing template: %v\n", err)
fmt.Fprintf(w, "template was:\n\t%v\n", j.rawTemplate)
fmt.Fprintf(w, "raw data was:\n\t%v\n", string(data))
fmt.Fprintf(w, "object given to template engine was:\n\t%+v\n", out)
return fmt.Errorf("error executing jsonpath '%v': '%v'\n----data----\n%+v\n", j.rawTemplate, err, out)
}
return nil
}

23
pkg/kubectl/resource_printer_test.go
View File

@@ -164,6 +164,23 @@ func TestPrintTemplate(t *testing.T) {
}
}
func TestPrintJSONPath(t *testing.T) {
buf := bytes.NewBuffer([]byte{})
printer, found, err := GetPrinter("jsonpath", "{.metadata.name}")
if err != nil || !found {
t.Fatalf("unexpected error: %#v", err)
}
unversionedPod := &api.Pod{ObjectMeta: api.ObjectMeta{Name: "foo"}}
obj, err := api.Scheme.ConvertToVersion(unversionedPod, testapi.Version())
err = printer.PrintObj(obj, buf)
if err != nil {
t.Fatalf("unexpected error: %s %#v", buf, err)
}
if buf.String() != "foo" {
t.Errorf("unexpected output: %s", buf.String())
}
}
func TestPrintEmptyTemplate(t *testing.T) {
if _, _, err := GetPrinter("template", ""); err == nil {
t.Errorf("unexpected non-error")
@@ -450,6 +467,10 @@ func TestPrinters(t *testing.T) {
if err != nil {
t.Fatal(err)
}
jsonpathPrinter, err := NewJSONPathPrinter("{.metadata.name}")
if err != nil {
t.Fatal(err)
}
printers := map[string]ResourcePrinter{
"humanReadable": NewHumanReadablePrinter(true, false, false, false, []string{}),
"humanReadableHeaders": NewHumanReadablePrinter(false, false, false, false, []string{}),
@@ -457,6 +478,7 @@ func TestPrinters(t *testing.T) {
"yaml": &YAMLPrinter{},
"template": templatePrinter,
"template2": templatePrinter2,
"jsonpath": jsonpathPrinter,
}
objects := map[string]runtime.Object{
"pod": &api.Pod{ObjectMeta: om("pod")},
@@ -471,6 +493,7 @@ func TestPrinters(t *testing.T) {
// map of printer name to set of objects it should fail on.
expectedErrors := map[string]util.StringSet{
"template2": util.NewStringSet("pod", "emptyPodList", "endpoints"),
"jsonpath": util.NewStringSet("emptyPodList", "nonEmptyPodList", "endpoints"),
}
for pName, p := range printers {

103
pkg/util/jsonpath/jsonpath.go
View File

@@ -21,7 +21,6 @@ import (
"fmt"
"io"
"reflect"
"strconv"
"k8s.io/kubernetes/third_party/golang/template"
)
@@ -214,10 +213,9 @@ func (j *JSONPath) evalIdentifier(input []reflect.Value, node *IdentifierNode) (
func (j *JSONPath) evalArray(input []reflect.Value, node *ArrayNode) ([]reflect.Value, error) {
result := []reflect.Value{}
for _, value := range input {
if value.Kind() == reflect.Interface {
value = reflect.ValueOf(value.Interface())
}
if value.Kind() != reflect.Array && value.Kind() != reflect.Slice {
value, isNil := template.Indirect(value)
if isNil || (value.Kind() != reflect.Array && value.Kind() != reflect.Slice) {
return input, fmt.Errorf("%v is not array or slice", value)
}
params := node.Params
@@ -265,9 +263,11 @@ func (j *JSONPath) evalField(input []reflect.Value, node *FieldNode) ([]reflect.
results := []reflect.Value{}
for _, value := range input {
var result reflect.Value
if value.Kind() == reflect.Interface {
value = reflect.ValueOf(value.Interface())
value, isNil := template.Indirect(value)
if isNil {
continue
}
if value.Kind() == reflect.Struct {
result = value.FieldByName(node.Value)
} else if value.Kind() == reflect.Map {
@@ -287,6 +287,11 @@ func (j *JSONPath) evalField(input []reflect.Value, node *FieldNode) ([]reflect.
func (j *JSONPath) evalWildcard(input []reflect.Value, node *WildcardNode) ([]reflect.Value, error) {
results := []reflect.Value{}
for _, value := range input {
value, isNil := template.Indirect(value)
if isNil {
continue
}
kind := value.Kind()
if kind == reflect.Struct {
for i := 0; i < value.NumField(); i++ {
@@ -310,6 +315,11 @@ func (j *JSONPath) evalRecursive(input []reflect.Value, node *RecursiveNode) ([]
result := []reflect.Value{}
for _, value := range input {
results := []reflect.Value{}
value, isNil := template.Indirect(value)
if isNil {
continue
}
kind := value.Kind()
if kind == reflect.Struct {
for i := 0; i < value.NumField(); i++ {
@@ -340,9 +350,8 @@ func (j *JSONPath) evalRecursive(input []reflect.Value, node *RecursiveNode) ([]
func (j *JSONPath) evalFilter(input []reflect.Value, node *FilterNode) ([]reflect.Value, error) {
results := []reflect.Value{}
for _, value := range input {
if value.Kind() == reflect.Interface {
value = reflect.ValueOf(value.Interface())
}
value, _ = template.Indirect(value)
if value.Kind() != reflect.Array && value.Kind() != reflect.Slice {
return input, fmt.Errorf("%v is not array or slice", value)
}
@@ -407,77 +416,11 @@ func (j *JSONPath) evalFilter(input []reflect.Value, node *FilterNode) ([]reflec
// evalToText translates reflect value to corresponding text
func (j *JSONPath) evalToText(v reflect.Value) ([]byte, error) {
if v.Kind() == reflect.Interface {
v = reflect.ValueOf(v.Interface())
iface, ok := template.PrintableValue(v)
if !ok {
return nil, fmt.Errorf("can't print type %s", v.Type())
}
var buffer bytes.Buffer
switch v.Kind() {
case reflect.Invalid:
//pass
case reflect.Ptr:
text, err := j.evalToText(reflect.Indirect(v))
if err != nil {
return nil, err
}
buffer.Write(text)
case reflect.Bool:
if variable := v.Bool(); variable {
buffer.WriteString("True")
} else {
buffer.WriteString("False")
}
case reflect.Float32:
buffer.WriteString(strconv.FormatFloat(v.Float(), 'f', -1, 32))
case reflect.Float64:
buffer.WriteString(strconv.FormatFloat(v.Float(), 'f', -1, 64))
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
buffer.WriteString(strconv.FormatInt(v.Int(), 10))
case reflect.String:
buffer.WriteString(v.String())
case reflect.Array, reflect.Slice:
buffer.WriteString("[")
for i := 0; i < v.Len(); i++ {
text, err := j.evalToText(v.Index(i))
if err != nil {
return nil, err
}
buffer.Write(text)
if i != v.Len()-1 {
buffer.WriteString(", ")
}
}
buffer.WriteString("]")
case reflect.Struct:
buffer.WriteString("{")
for i := 0; i < v.NumField(); i++ {
text, err := j.evalToText(v.Field(i))
if err != nil {
return nil, err
}
pair := fmt.Sprintf("%s: %s", v.Type().Field(i).Name, text)
buffer.WriteString(pair)
if i != v.NumField()-1 {
buffer.WriteString(", ")
}
}
buffer.WriteString("}")
case reflect.Map:
buffer.WriteString("{")
for i, key := range v.MapKeys() {
text, err := j.evalToText(v.MapIndex(key))
if err != nil {
return nil, err
}
pair := fmt.Sprintf("%s: %s", key, text)
buffer.WriteString(pair)
if i != len(v.MapKeys())-1 {
buffer.WriteString(", ")
}
}
buffer.WriteString("}")
default:
return nil, fmt.Errorf("%v is not printable", v.Kind())
}
fmt.Fprint(&buffer, iface)
return buffer.Bytes(), nil
}

51
pkg/util/jsonpath/jsonpath_test.go
View File

@@ -19,6 +19,7 @@ package jsonpath
import (
"bytes"
"encoding/json"
"fmt"
"testing"
)
@@ -69,25 +70,30 @@ func testFailJSONPath(tests []jsonpathTest, t *testing.T) {
}
}
type book struct {
Category string
Author string
Title string
Price float32
}
func (b book) String() string {
return fmt.Sprintf("{Category: %s, Author: %s, Title: %s, Price: %v}", b.Category, b.Author, b.Title, b.Price)
}
type bicycle struct {
Color string
Price float32
}
type store struct {
Book []book
Bicycle bicycle
Name string
Labels map[string]int
}
func TestStructInput(t *testing.T) {
type book struct {
Category string
Author string
Title string
Price float32
}
type bicycle struct {
Color string
Price float32
}
type store struct {
Book []book
Bicycle bicycle
Name string
Labels map[string]int
}
storeData := store{
Name: "jsonpath",
@@ -106,7 +112,7 @@ func TestStructInput(t *testing.T) {
storeTests := []jsonpathTest{
{"plain", "hello jsonpath", nil, "hello jsonpath"},
{"recursive", "{..}", []int{1, 2, 3}, "[1, 2, 3]"},
{"recursive", "{..}", []int{1, 2, 3}, "[1 2 3]"},
{"filter", "{[?(@<5)]}", []int{2, 6, 3, 7}, "2 3"},
{"quote", `{"{"}`, nil, "{"},
{"union", "{[1,3,4]}", []int{0, 1, 2, 3, 4}, "1 3 4"},
@@ -197,6 +203,7 @@ func TestKubenates(t *testing.T) {
if err != nil {
t.Error(err)
}
nodesTests := []jsonpathTest{
{"range item", "{range .items[*]}{.metadata.name}, {end}{.kind}", nodesData, `127.0.0.1, 127.0.0.2, List`},
{"range addresss", "{.items[*].status.addresses[*].address}", nodesData,
@@ -205,10 +212,10 @@ func TestKubenates(t *testing.T) {
`127.0.0.1, 127.0.0.2, 127.0.0.3, `},
{"item name", "{.items[*].metadata.name}", nodesData, `127.0.0.1 127.0.0.2`},
{"union nodes capacity", "{.items[*]['metadata.name', 'status.capacity']}", nodesData,
`127.0.0.1 127.0.0.2 {cpu: 4} {cpu: 8}`},
`127.0.0.1 127.0.0.2 map[cpu:4] map[cpu:8]`},
{"range nodes capacity", "{range .items[*]}[{.metadata.name}, {.status.capacity}] {end}", nodesData,
`[127.0.0.1, {cpu: 4}] [127.0.0.2, {cpu: 8}] `},
{"user password", `{.users[?(@.name=="e2e")].user.password}`, nodesData, "secret"},
`[127.0.0.1, map[cpu:4]] [127.0.0.2, map[cpu:8]] `},
{"user password", `{.users[?(@.name=="e2e")].user.password}`, &nodesData, "secret"},
}
testJSONPath(nodesTests, t)
}