* rewrite printer_json.go

Author: kstrifonoff

Diff for: etcdctl/ctlv3/command/printer_json.go

@@ -17,9 +17,8 @@ package command
 import (
 	"encoding/json"
 	"fmt"
-	"os"
-	"slices"
 
+	pb "go.etcd.io/etcd/api/v3/etcdserverpb"
 	v3 "go.etcd.io/etcd/client/v3"
 )
 
@@ -35,65 +34,130 @@ func newJSONPrinter(isHex bool) printer {
 	}
 }
 
-func (p *jsonPrinter) EndpointHealth(r []epHealth) { p.printJSON(r) }
-func (p *jsonPrinter) EndpointStatus(r []epStatus) { p.printJSON(r) }
-func (p *jsonPrinter) EndpointHashKV(r []epHashKV) { p.printJSON(r) }
+type (
+	HexResponseHeader pb.ResponseHeader
+	HexMember         pb.Member
+)
+
+func (h *HexResponseHeader) MarshalJSON() ([]byte, error) {
+	type Alias pb.ResponseHeader
+
+	return json.Marshal(&struct {
+		ClusterID string `json:"cluster_id"`
+		MemberID  string `json:"member_id"`
+		Alias
+	}{
+		ClusterID: fmt.Sprintf("%x", h.ClusterId),
+		MemberID:  fmt.Sprintf("%x", h.MemberId),
+		Alias:     (Alias)(*h),
+	})
+}
 
-func (p *jsonPrinter) MemberAdd(r v3.MemberAddResponse)   { p.printJSON(r) }
-func (p *jsonPrinter) MemberList(r v3.MemberListResponse) { p.printJSON(r) }
+func (m *HexMember) MarshalJSON() ([]byte, error) {
+	type Alias pb.Member
+
+	return json.Marshal(&struct {
+		ID string `json:"ID"`
+		Alias
+	}{
+		ID:    fmt.Sprintf("%x", m.ID),
+		Alias: (Alias)(*m),
+	})
+}
+
+func (p *jsonPrinter) MemberAdd(r v3.MemberAddResponse)                    { p.printJSON(r) }
+func (p *jsonPrinter) MemberList(r v3.MemberListResponse)                  { p.printJSON(r) }
+func (p *jsonPrinter) MemberPromote(id uint64, r v3.MemberPromoteResponse) { p.printJSON(r) }
+func (p *jsonPrinter) MemberRemove(id uint64, r v3.MemberRemoveResponse)   { p.printJSON(r) }
+func (p *jsonPrinter) MemberUpdate(id uint64, r v3.MemberUpdateResponse)   { p.printJSON(r) }
 
 func printJSON(v any) {
-	b, err := json.Marshal(v)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "%v\n", err)
-		return
-	}
+	b, _ := json.Marshal(v)
 	fmt.Println(string(b))
 }
 
 func (p *jsonPrinter) printJSON(v any) {
-	b, err := json.Marshal(v)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "%v\n", err)
-		return
-	}
+	var data any
 
 	if !p.isHex {
-		fmt.Println(string(b))
+		printJSON(v)
 		return
 	}
 
-	var data any
-	if err = json.Unmarshal(b, &data); err != nil {
-		fmt.Fprintf(os.Stderr, "%v\n", err)
-		return
-	}
+	switch r := v.(type) {
+	case v3.MemberAddResponse:
+		type Alias v3.MemberAddResponse
 
-	convertFieldsToHex(data)
-	b, err = json.Marshal(data)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "%v\n", err)
-		return
-	}
-	fmt.Println(string(b))
-}
+		data = &struct {
+			Header  *HexResponseHeader `json:"header"`
+			Member  *HexMember         `json:"member"`
+			Members []*HexMember       `json:"members"`
+			*Alias
+		}{
+			Header:  (*HexResponseHeader)(r.Header),
+			Member:  (*HexMember)(r.Member),
+			Members: toHexMembers(r.Members),
+			Alias:   (*Alias)(&r),
+		}
+	case v3.MemberListResponse:
+		type Alias v3.MemberListResponse
+
+		data = &struct {
+			Header  *HexResponseHeader `json:"header"`
+			Members []*HexMember       `json:"members"`
+			*Alias
+		}{
+			Header:  (*HexResponseHeader)(r.Header),
+			Members: toHexMembers(r.Members),
+			Alias:   (*Alias)(&r),
+		}
+	case v3.MemberPromoteResponse:
+		type Alias v3.MemberPromoteResponse
 
-func convertFieldsToHex(data any) {
-	keysToConvert := []string{"cluster_id", "member_id", "ID", "leader"}
-
-	switch v := data.(type) {
-	case map[string]any:
-		for key, val := range v {
-			if slices.Contains(keysToConvert, key) {
-				if num, ok := val.(float64); ok {
-					v[key] = fmt.Sprintf("%x", uint64(num))
-				}
-			}
-			convertFieldsToHex(val)
+		data = &struct {
+			Header  *HexResponseHeader `json:"header"`
+			Members []*HexMember       `json:"members"`
+			*Alias
+		}{
+			Header:  (*HexResponseHeader)(r.Header),
+			Members: toHexMembers(r.Members),
+			Alias:   (*Alias)(&r),
 		}
-	case []any:
-		for _, item := range v {
-			convertFieldsToHex(item)
+	case v3.MemberRemoveResponse:
+		type Alias v3.MemberRemoveResponse
+
+		data = &struct {
+			Header  *HexResponseHeader `json:"header"`
+			Members []*HexMember       `json:"members"`
+			*Alias
+		}{
+			Header:  (*HexResponseHeader)(r.Header),
+			Members: toHexMembers(r.Members),
+			Alias:   (*Alias)(&r),
+		}
+	case v3.MemberUpdateResponse:
+		type Alias v3.MemberUpdateResponse
+
+		data = &struct {
+			Header  *HexResponseHeader `json:"header"`
+			Members []*HexMember       `json:"members"`
+			*Alias
+		}{
+			Header:  (*HexResponseHeader)(r.Header),
+			Members: toHexMembers(r.Members),
+			Alias:   (*Alias)(&r),
 		}
+	default:
+		data = v
+	}
+
+	printJSON(data)
+}
+
+func toHexMembers(members []*pb.Member) []*HexMember {
+	hexMembers := make([]*HexMember, len(members))
+	for i, member := range members {
+		hexMembers[i] = (*HexMember)(member)
 	}
+	return hexMembers
 }