Merge pull request #12202 from daizuozhuo/kubectl

add jsonpath to kubectl
2015-08-20 14:31:45 -07:00
parent 5ec3c78190 85972c44a4
commit 489e75e073
25 changed files with 356 additions and 259 deletions
--- a/pkg/kubectl/cmd/get.go
+++ b/pkg/kubectl/cmd/get.go
@@ -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 ...) [flags]",
 		Short:   "Display one or many resources",
 		Long:    get_long,
 		Example: get_example,
--- a/pkg/kubectl/cmd/util/printing.go
+++ b/pkg/kubectl/cmd/util/printing.go
@@ -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 {} [http://releases.k8s.io/HEAD/docs/user-guide/jsonpath.md]")
 	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.)")
 }
--- a/pkg/kubectl/resource_printer.go
+++ b/pkg/kubectl/resource_printer.go
@@ -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 "":
@@ -1214,3 +1224,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
+}
--- a/pkg/kubectl/resource_printer_test.go
+++ b/pkg/kubectl/resource_printer_test.go
@@ -77,14 +77,6 @@ func TestVersionedPrinter(t *testing.T) {
 	}
 }

-func TestYAMLPrinter(t *testing.T) {
-	testPrinter(t, &YAMLPrinter{}, yaml.Unmarshal)
-}
-
-func TestJSONPrinter(t *testing.T) {
-	testPrinter(t, &JSONPrinter{}, json.Unmarshal)
-}
-
 func TestPrintDefault(t *testing.T) {
 	printer, found, err := GetPrinter("", "")
 	if err != nil {
@@ -95,90 +87,72 @@ func TestPrintDefault(t *testing.T) {
 	}
 }

-type internalType struct {
-	Name string
+type TestPrintType struct {
+	Data string
 }

-func (*internalType) IsAnAPIObject() {
+func (*TestPrintType) IsAnAPIObject() {}

-}
+type TestUnknownType struct{}

-func TestPrintJSONForObject(t *testing.T) {
-	buf := bytes.NewBuffer([]byte{})
-	printer, found, err := GetPrinter("json", "")
-	if err != nil || !found {
-		t.Fatalf("unexpected error: %#v", err)
-	}
-	if err := printer.PrintObj(&internalType{Name: "foo"}, buf); err != nil {
-		t.Fatalf("unexpected error: %#v", err)
-	}
-	obj := map[string]interface{}{}
-	if err := json.Unmarshal(buf.Bytes(), &obj); err != nil {
-		t.Fatalf("unexpected error: %#v\n%s", err, buf.String())
-	}
-	if obj["Name"] != "foo" {
-		t.Errorf("unexpected field: %#v", obj)
-	}
-}
+func (*TestUnknownType) IsAnAPIObject() {}

-func TestPrintJSON(t *testing.T) {
-	buf := bytes.NewBuffer([]byte{})
-	printer, found, err := GetPrinter("json", "")
-	if err != nil || !found {
-		t.Fatalf("unexpected error: %#v", err)
-	}
-	printer.PrintObj(&api.Pod{ObjectMeta: api.ObjectMeta{Name: "foo"}}, buf)
-	obj := map[string]interface{}{}
-	if err := json.Unmarshal(buf.Bytes(), &obj); err != nil {
-		t.Errorf("unexpected error: %#v\n%s", err, buf.String())
-	}
-}
-
-func TestPrintYAML(t *testing.T) {
-	buf := bytes.NewBuffer([]byte{})
-	printer, found, err := GetPrinter("yaml", "")
-	if err != nil || !found {
-		t.Fatalf("unexpected error: %#v", err)
-	}
-	printer.PrintObj(&api.Pod{ObjectMeta: api.ObjectMeta{Name: "foo"}}, buf)
-	obj := map[string]interface{}{}
-	if err := yaml.Unmarshal(buf.Bytes(), &obj); err != nil {
-		t.Errorf("unexpected error: %#v\n%s", err, buf.String())
-	}
-}
-
-func TestPrintTemplate(t *testing.T) {
-	buf := bytes.NewBuffer([]byte{})
-	printer, found, err := GetPrinter("template", "{{if .id}}{{.id}}{{end}}{{if .metadata.name}}{{.metadata.name}}{{end}}")
-	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)
+func TestPrinter(t *testing.T) {
+	//test inputs
+	simpleTest := &TestPrintType{"foo"}
+	podTest := &api.Pod{ObjectMeta: api.ObjectMeta{Name: "foo"}}
+	testapi, err := api.Scheme.ConvertToVersion(podTest, testapi.Version())
 	if err != nil {
-		t.Fatalf("unexpected error: %#v", err)
+		t.Fatalf("unexpected error: %v", err)
 	}
-	if buf.String() != "foo" {
-		t.Errorf("unexpected output: %s", buf.String())
+
+	printerTests := []struct {
+		Name           string
+		Format         string
+		FormatArgument string
+		Input          runtime.Object
+		Expect         string
+	}{
+		{"test json", "json", "", simpleTest, "{\n    \"Data\": \"foo\"\n}\n"},
+		{"test yaml", "yaml", "", simpleTest, "Data: foo\n"},
+		{"test template", "template", "{{if .id}}{{.id}}{{end}}{{if .metadata.name}}{{.metadata.name}}{{end}}",
+			podTest, "foo"},
+		{"test jsonpath", "jsonpath", "{.metadata.name}", podTest, "foo"},
+		{"emits versioned objects", "template", "{{.kind}}", testapi, "Pod"},
 	}
+	for _, test := range printerTests {
+		buf := bytes.NewBuffer([]byte{})
+		printer, found, err := GetPrinter(test.Format, test.FormatArgument)
+		if err != nil || !found {
+			t.Errorf("unexpected error: %#v", err)
+		}
+		if err := printer.PrintObj(test.Input, buf); err != nil {
+			t.Errorf("unexpected error: %#v", err)
+		}
+		if buf.String() != test.Expect {
+			t.Errorf("in %s, expect %q, got %q", test.Name, test.Expect, buf.String(), buf.String())
+		}
+	}
+
 }

-func TestPrintEmptyTemplate(t *testing.T) {
-	if _, _, err := GetPrinter("template", ""); err == nil {
-		t.Errorf("unexpected non-error")
+func TestBadPrinter(t *testing.T) {
+	badPrinterTests := []struct {
+		Name           string
+		Format         string
+		FormatArgument string
+		Error          error
+	}{
+		{"empty template", "template", "", fmt.Errorf("template format specified but no template given")},
+		{"bad template", "template", "{{ .Name", fmt.Errorf("error parsing template {{ .Name, template: output:1: unclosed action\n")},
+		{"bad templatefile", "templatefile", "", fmt.Errorf("templatefile format specified but no template file given")},
+		{"bad jsonpath", "jsonpath", "{.Name", fmt.Errorf("error parsing jsonpath {.Name, unclosed action\n")},
 	}
-}
-
-func TestPrintBadTemplate(t *testing.T) {
-	if _, _, err := GetPrinter("template", "{{ .Name"); err == nil {
-		t.Errorf("unexpected non-error")
-	}
-}
-
-func TestPrintBadTemplateFile(t *testing.T) {
-	if _, _, err := GetPrinter("templatefile", ""); err == nil {
-		t.Errorf("unexpected non-error")
+	for _, test := range badPrinterTests {
+		_, _, err := GetPrinter(test.Format, test.FormatArgument)
+		if err == nil || err.Error() != test.Error.Error() {
+			t.Errorf("in %s, expect %s, got %s", test.Name, test.Error, err)
+		}
 	}
 }

@@ -227,15 +201,13 @@ func testPrinter(t *testing.T, printer ResourcePrinter, unmarshalFunc func(data
 	}
 }

-type TestPrintType struct {
-	Data string
+func TestYAMLPrinter(t *testing.T) {
+	testPrinter(t, &YAMLPrinter{}, yaml.Unmarshal)
 }

-func (*TestPrintType) IsAnAPIObject() {}
-
-type TestUnknownType struct{}
-
-func (*TestUnknownType) IsAnAPIObject() {}
+func TestJSONPrinter(t *testing.T) {
+	testPrinter(t, &JSONPrinter{}, json.Unmarshal)
+}

 func PrintCustomType(obj *TestPrintType, w io.Writer, withNamespace bool, wide bool, showAll bool, columnLabels []string) error {
 	_, err := fmt.Fprintf(w, "%s", obj.Data)
@@ -284,27 +256,6 @@ func TestUnknownTypePrinting(t *testing.T) {
 	}
 }

-func TestTemplateEmitsVersionedObjects(t *testing.T) {
-	// kind is always blank in memory and set on the wire
-	printer, err := NewTemplatePrinter([]byte(`{{.kind}}`))
-	if err != nil {
-		t.Fatalf("tmpl fail: %v", err)
-	}
-	obj, err := api.Scheme.ConvertToVersion(&api.Pod{}, testapi.Version())
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	buffer := &bytes.Buffer{}
-	err = printer.PrintObj(obj, buffer)
-	if err != nil {
-		t.Fatalf("print fail: %v", err)
-	}
-	if e, a := "Pod", string(buffer.Bytes()); e != a {
-		t.Errorf("Expected %v, got %v", e, a)
-	}
-}
-
 func TestTemplatePanic(t *testing.T) {
 	tmpl := `{{and ((index .currentState.info "foo").state.running.startedAt) .currentState.info.net.state.running.startedAt}}`
 	printer, err := NewTemplatePrinter([]byte(tmpl))
@@ -450,6 +401,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 +412,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 +427,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 {
--- a/pkg/util/jsonpath/jsonpath.go
+++ b/pkg/util/jsonpath/jsonpath.go
@@ -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
 }
--- a/pkg/util/jsonpath/jsonpath_test.go
+++ b/pkg/util/jsonpath/jsonpath_test.go
@@ -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,13 +112,13 @@ 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"},
 		{"array", "{[0:2]}", []string{"Monday", "Tudesday"}, "Monday Tudesday"},
 		{"variable", "hello {.Name}", storeData, "hello jsonpath"},
-		{"dict/", "{.Labels.web/html}", storeData, "15"},
+		{"dict/", "{$.Labels.web/html}", storeData, "15"},
 		{"dict-", "{.Labels.k8s-app}", storeData, "20"},
 		{"nest", "{.Bicycle.Color}", storeData, "red"},
 		{"allarray", "{.Book[*].Author}", storeData, "Nigel Rees Evelyn Waugh Herman Melville"},
@@ -197,18 +203,20 @@ 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,
 			`127.0.0.1 127.0.0.2 127.0.0.3`},
 		{"double range", "{range .items[*]}{range .status.addresses[*]}{.address}, {end}{end}", nodesData,
 			`127.0.0.1, 127.0.0.2, 127.0.0.3, `},
+		{"recursive name", "{..name}", nodesData, `127.0.0.1 127.0.0.2 myself e2e`},
 		{"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)
 }
--- a/pkg/util/jsonpath/parser.go
+++ b/pkg/util/jsonpath/parser.go
@@ -151,7 +151,7 @@ func (p *Parser) parseInsideAction(cur *ListNode) error {
 		return fmt.Errorf("unclosed action")
 	case r == ' ':
 		p.consumeText()
-	case r == '@': //the current object, just pass it
+	case r == '@' || r == '$': //the current object, just pass it
 		p.consumeText()
 	case r == '[':
 		return p.parseArray(cur)