1// Copyright 2016 The etcd Authors
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15package command
16
17import (
18	"errors"
19	"fmt"
20	"strings"
21
22	v3 "go.etcd.io/etcd/clientv3"
23	"go.etcd.io/etcd/clientv3/snapshot"
24	pb "go.etcd.io/etcd/etcdserver/etcdserverpb"
25
26	"github.com/dustin/go-humanize"
27)
28
29type printer interface {
30	Del(v3.DeleteResponse)
31	Get(v3.GetResponse)
32	Put(v3.PutResponse)
33	Txn(v3.TxnResponse)
34	Watch(v3.WatchResponse)
35
36	Grant(r v3.LeaseGrantResponse)
37	Revoke(id v3.LeaseID, r v3.LeaseRevokeResponse)
38	KeepAlive(r v3.LeaseKeepAliveResponse)
39	TimeToLive(r v3.LeaseTimeToLiveResponse, keys bool)
40	Leases(r v3.LeaseLeasesResponse)
41
42	MemberAdd(v3.MemberAddResponse)
43	MemberRemove(id uint64, r v3.MemberRemoveResponse)
44	MemberUpdate(id uint64, r v3.MemberUpdateResponse)
45	MemberPromote(id uint64, r v3.MemberPromoteResponse)
46	MemberList(v3.MemberListResponse)
47
48	EndpointHealth([]epHealth)
49	EndpointStatus([]epStatus)
50	EndpointHashKV([]epHashKV)
51	MoveLeader(leader, target uint64, r v3.MoveLeaderResponse)
52
53	Alarm(v3.AlarmResponse)
54	DBStatus(snapshot.Status)
55
56	RoleAdd(role string, r v3.AuthRoleAddResponse)
57	RoleGet(role string, r v3.AuthRoleGetResponse)
58	RoleDelete(role string, r v3.AuthRoleDeleteResponse)
59	RoleList(v3.AuthRoleListResponse)
60	RoleGrantPermission(role string, r v3.AuthRoleGrantPermissionResponse)
61	RoleRevokePermission(role string, key string, end string, r v3.AuthRoleRevokePermissionResponse)
62
63	UserAdd(user string, r v3.AuthUserAddResponse)
64	UserGet(user string, r v3.AuthUserGetResponse)
65	UserList(r v3.AuthUserListResponse)
66	UserChangePassword(v3.AuthUserChangePasswordResponse)
67	UserGrantRole(user string, role string, r v3.AuthUserGrantRoleResponse)
68	UserRevokeRole(user string, role string, r v3.AuthUserRevokeRoleResponse)
69	UserDelete(user string, r v3.AuthUserDeleteResponse)
70
71	AuthStatus(r v3.AuthStatusResponse)
72}
73
74func NewPrinter(printerType string, isHex bool) printer {
75	switch printerType {
76	case "simple":
77		return &simplePrinter{isHex: isHex}
78	case "fields":
79		return &fieldsPrinter{newPrinterUnsupported("fields")}
80	case "json":
81		return newJSONPrinter()
82	case "protobuf":
83		return newPBPrinter()
84	case "table":
85		return &tablePrinter{newPrinterUnsupported("table")}
86	}
87	return nil
88}
89
90type printerRPC struct {
91	printer
92	p func(interface{})
93}
94
95func (p *printerRPC) Del(r v3.DeleteResponse)  { p.p((*pb.DeleteRangeResponse)(&r)) }
96func (p *printerRPC) Get(r v3.GetResponse)     { p.p((*pb.RangeResponse)(&r)) }
97func (p *printerRPC) Put(r v3.PutResponse)     { p.p((*pb.PutResponse)(&r)) }
98func (p *printerRPC) Txn(r v3.TxnResponse)     { p.p((*pb.TxnResponse)(&r)) }
99func (p *printerRPC) Watch(r v3.WatchResponse) { p.p(&r) }
100
101func (p *printerRPC) Grant(r v3.LeaseGrantResponse)                      { p.p(r) }
102func (p *printerRPC) Revoke(id v3.LeaseID, r v3.LeaseRevokeResponse)     { p.p(r) }
103func (p *printerRPC) KeepAlive(r v3.LeaseKeepAliveResponse)              { p.p(r) }
104func (p *printerRPC) TimeToLive(r v3.LeaseTimeToLiveResponse, keys bool) { p.p(&r) }
105func (p *printerRPC) Leases(r v3.LeaseLeasesResponse)                    { p.p(&r) }
106
107func (p *printerRPC) MemberAdd(r v3.MemberAddResponse) { p.p((*pb.MemberAddResponse)(&r)) }
108func (p *printerRPC) MemberRemove(id uint64, r v3.MemberRemoveResponse) {
109	p.p((*pb.MemberRemoveResponse)(&r))
110}
111func (p *printerRPC) MemberUpdate(id uint64, r v3.MemberUpdateResponse) {
112	p.p((*pb.MemberUpdateResponse)(&r))
113}
114func (p *printerRPC) MemberList(r v3.MemberListResponse) { p.p((*pb.MemberListResponse)(&r)) }
115func (p *printerRPC) Alarm(r v3.AlarmResponse)           { p.p((*pb.AlarmResponse)(&r)) }
116func (p *printerRPC) MoveLeader(leader, target uint64, r v3.MoveLeaderResponse) {
117	p.p((*pb.MoveLeaderResponse)(&r))
118}
119func (p *printerRPC) RoleAdd(_ string, r v3.AuthRoleAddResponse) { p.p((*pb.AuthRoleAddResponse)(&r)) }
120func (p *printerRPC) RoleGet(_ string, r v3.AuthRoleGetResponse) { p.p((*pb.AuthRoleGetResponse)(&r)) }
121func (p *printerRPC) RoleDelete(_ string, r v3.AuthRoleDeleteResponse) {
122	p.p((*pb.AuthRoleDeleteResponse)(&r))
123}
124func (p *printerRPC) RoleList(r v3.AuthRoleListResponse) { p.p((*pb.AuthRoleListResponse)(&r)) }
125func (p *printerRPC) RoleGrantPermission(_ string, r v3.AuthRoleGrantPermissionResponse) {
126	p.p((*pb.AuthRoleGrantPermissionResponse)(&r))
127}
128func (p *printerRPC) RoleRevokePermission(_ string, _ string, _ string, r v3.AuthRoleRevokePermissionResponse) {
129	p.p((*pb.AuthRoleRevokePermissionResponse)(&r))
130}
131func (p *printerRPC) UserAdd(_ string, r v3.AuthUserAddResponse) { p.p((*pb.AuthUserAddResponse)(&r)) }
132func (p *printerRPC) UserGet(_ string, r v3.AuthUserGetResponse) { p.p((*pb.AuthUserGetResponse)(&r)) }
133func (p *printerRPC) UserList(r v3.AuthUserListResponse)         { p.p((*pb.AuthUserListResponse)(&r)) }
134func (p *printerRPC) UserChangePassword(r v3.AuthUserChangePasswordResponse) {
135	p.p((*pb.AuthUserChangePasswordResponse)(&r))
136}
137func (p *printerRPC) UserGrantRole(_ string, _ string, r v3.AuthUserGrantRoleResponse) {
138	p.p((*pb.AuthUserGrantRoleResponse)(&r))
139}
140func (p *printerRPC) UserRevokeRole(_ string, _ string, r v3.AuthUserRevokeRoleResponse) {
141	p.p((*pb.AuthUserRevokeRoleResponse)(&r))
142}
143func (p *printerRPC) UserDelete(_ string, r v3.AuthUserDeleteResponse) {
144	p.p((*pb.AuthUserDeleteResponse)(&r))
145}
146func (p *printerRPC) AuthStatus(r v3.AuthStatusResponse) {
147	p.p((*pb.AuthStatusResponse)(&r))
148}
149
150type printerUnsupported struct{ printerRPC }
151
152func newPrinterUnsupported(n string) printer {
153	f := func(interface{}) {
154		ExitWithError(ExitBadFeature, errors.New(n+" not supported as output format"))
155	}
156	return &printerUnsupported{printerRPC{nil, f}}
157}
158
159func (p *printerUnsupported) EndpointHealth([]epHealth) { p.p(nil) }
160func (p *printerUnsupported) EndpointStatus([]epStatus) { p.p(nil) }
161func (p *printerUnsupported) EndpointHashKV([]epHashKV) { p.p(nil) }
162func (p *printerUnsupported) DBStatus(snapshot.Status)  { p.p(nil) }
163
164func (p *printerUnsupported) MoveLeader(leader, target uint64, r v3.MoveLeaderResponse) { p.p(nil) }
165
166func makeMemberListTable(r v3.MemberListResponse) (hdr []string, rows [][]string) {
167	hdr = []string{"ID", "Status", "Name", "Peer Addrs", "Client Addrs", "Is Learner"}
168	for _, m := range r.Members {
169		status := "started"
170		if len(m.Name) == 0 {
171			status = "unstarted"
172		}
173		isLearner := "false"
174		if m.IsLearner {
175			isLearner = "true"
176		}
177		rows = append(rows, []string{
178			fmt.Sprintf("%x", m.ID),
179			status,
180			m.Name,
181			strings.Join(m.PeerURLs, ","),
182			strings.Join(m.ClientURLs, ","),
183			isLearner,
184		})
185	}
186	return hdr, rows
187}
188
189func makeEndpointHealthTable(healthList []epHealth) (hdr []string, rows [][]string) {
190	hdr = []string{"endpoint", "health", "took", "error"}
191	for _, h := range healthList {
192		rows = append(rows, []string{
193			h.Ep,
194			fmt.Sprintf("%v", h.Health),
195			h.Took,
196			h.Error,
197		})
198	}
199	return hdr, rows
200}
201
202func makeEndpointStatusTable(statusList []epStatus) (hdr []string, rows [][]string) {
203	hdr = []string{"endpoint", "ID", "version", "db size", "is leader", "is learner", "raft term",
204		"raft index", "raft applied index", "errors"}
205	for _, status := range statusList {
206		rows = append(rows, []string{
207			status.Ep,
208			fmt.Sprintf("%x", status.Resp.Header.MemberId),
209			status.Resp.Version,
210			humanize.Bytes(uint64(status.Resp.DbSize)),
211			fmt.Sprint(status.Resp.Leader == status.Resp.Header.MemberId),
212			fmt.Sprint(status.Resp.IsLearner),
213			fmt.Sprint(status.Resp.RaftTerm),
214			fmt.Sprint(status.Resp.RaftIndex),
215			fmt.Sprint(status.Resp.RaftAppliedIndex),
216			fmt.Sprint(strings.Join(status.Resp.Errors, ", ")),
217		})
218	}
219	return hdr, rows
220}
221
222func makeEndpointHashKVTable(hashList []epHashKV) (hdr []string, rows [][]string) {
223	hdr = []string{"endpoint", "hash"}
224	for _, h := range hashList {
225		rows = append(rows, []string{
226			h.Ep,
227			fmt.Sprint(h.Resp.Hash),
228		})
229	}
230	return hdr, rows
231}
232
233func makeDBStatusTable(ds snapshot.Status) (hdr []string, rows [][]string) {
234	hdr = []string{"hash", "revision", "total keys", "total size"}
235	rows = append(rows, []string{
236		fmt.Sprintf("%x", ds.Hash),
237		fmt.Sprint(ds.Revision),
238		fmt.Sprint(ds.TotalKey),
239		humanize.Bytes(uint64(ds.TotalSize)),
240	})
241	return hdr, rows
242}
243