// memberListCommandFunc executes the "member list" command. func memberListCommandFunc(cmd *cobra.Command, args []string) { endpoint, err := cmd.Flags().GetString("endpoint") if err != nil { ExitWithError(ExitError, err) } conn, err := grpc.Dial(endpoint) if err != nil { ExitWithError(ExitBadConnection, err) } mc := pb.NewClusterClient(conn) resp, err := mc.MemberList(context.TODO(), &pb.MemberListRequest{}) if err != nil { ExitWithError(ExitError, err) } // use https://github.com/olekukonko/tablewriter to print out a pretty table? for _, m := range resp.Members { if len(m.Name) == 0 { fmt.Printf("%16x[unstarted]: peerURLs=%s\n", m.ID, strings.Join(m.PeerURLs, ",")) } else { fmt.Printf("%16x: name=%s peerURLs=%s clientURLs=%s\n", m.ID, m.Name, strings.Join(m.PeerURLs, ","), strings.Join(m.ClientURLs, ",")) } } }
func newClient(cfg *Config) (*Client, error) { if cfg == nil { cfg = &Config{RetryDialer: dialEndpointList} } var creds *credentials.TransportAuthenticator if cfg.TLS != nil { tlscfg, err := cfg.TLS.ClientConfig() if err != nil { return nil, err } c := credentials.NewTLS(tlscfg) creds = &c } // use a temporary skeleton client to bootstrap first connection conn, err := cfg.RetryDialer(&Client{cfg: *cfg, creds: creds}) if err != nil { return nil, err } return &Client{ KV: pb.NewKVClient(conn), Lease: pb.NewLeaseClient(conn), Watch: pb.NewWatchClient(conn), Cluster: pb.NewClusterClient(conn), conn: conn, cfg: *cfg, creds: creds, }, nil }
// memberUpdateCommandFunc executes the "member update" command. func memberUpdateCommandFunc(cmd *cobra.Command, args []string) { if len(args) != 1 { ExitWithError(ExitBadArgs, fmt.Errorf("member ID is not provided")) } id, err := strconv.ParseUint(args[0], 16, 64) if err != nil { ExitWithError(ExitBadArgs, fmt.Errorf("bad member ID arg (%v), expecting ID in Hex", err)) } if len(memberPeerURLs) == 0 { ExitWithError(ExitBadArgs, fmt.Errorf("member peer urls not provided.")) } urls := strings.Split(memberPeerURLs, ",") endpoint, err := cmd.Flags().GetString("endpoint") if err != nil { ExitWithError(ExitError, err) } conn, err := grpc.Dial(endpoint) if err != nil { ExitWithError(ExitBadConnection, err) } mc := pb.NewClusterClient(conn) resp, err := mc.MemberUpdate(context.TODO(), &pb.MemberUpdateRequest{ID: uint64(id), PeerURLs: urls}) if err != nil { ExitWithError(ExitError, err) } fmt.Printf("Member %16x updated in cluster %16x\n", id, resp.Header.ClusterId) }
// memberRemoveCommandFunc executes the "member remove" command. func memberRemoveCommandFunc(cmd *cobra.Command, args []string) { if len(args) != 1 { ExitWithError(ExitBadArgs, fmt.Errorf("member ID is not provided")) } id, err := strconv.ParseUint(args[0], 16, 64) if err != nil { ExitWithError(ExitBadArgs, fmt.Errorf("bad member ID arg (%v), expecting ID in Hex", err)) } endpoint, err := cmd.Flags().GetString("endpoint") if err != nil { ExitWithError(ExitError, err) } conn, err := grpc.Dial(endpoint) if err != nil { ExitWithError(ExitBadConnection, err) } mc := pb.NewClusterClient(conn) resp, err := mc.MemberRemove(context.TODO(), &pb.MemberRemoveRequest{ID: uint64(id)}) if err != nil { ExitWithError(ExitError, err) } fmt.Printf("Member %16x removed from cluster %16x\n", id, resp.Header.ClusterId) }
// memberAddCommandFunc executes the "member add" command. func memberAddCommandFunc(cmd *cobra.Command, args []string) { if len(args) != 1 { ExitWithError(ExitBadArgs, fmt.Errorf("member name not provided.")) } if len(memberPeerURLs) == 0 { ExitWithError(ExitBadArgs, fmt.Errorf("member peer urls not provided.")) } urls := strings.Split(memberPeerURLs, ",") endpoint, err := cmd.Flags().GetString("endpoint") if err != nil { ExitWithError(ExitError, err) } conn, err := grpc.Dial(endpoint) if err != nil { ExitWithError(ExitBadConnection, err) } mc := pb.NewClusterClient(conn) resp, err := mc.MemberAdd(context.TODO(), &pb.MemberAddRequest{PeerURLs: urls}) if err != nil { ExitWithError(ExitError, err) } fmt.Printf("Member %16x added to cluster %16x\n", args[0], resp.Member.ID, resp.Header.ClusterId) }
func toGRPC(c *clientv3.Client) grpcAPI { return grpcAPI{ pb.NewClusterClient(c.ActiveConnection()), pb.NewKVClient(c.ActiveConnection()), pb.NewLeaseClient(c.ActiveConnection()), pb.NewWatchClient(c.ActiveConnection()), } }
func NewCluster(c *Client) Cluster { conn := c.ActiveConnection() return &cluster{ c: c, conn: conn, remote: pb.NewClusterClient(conn), } }
func toGRPC(c *clientv3.Client) grpcAPI { if v, ok := proxies[c]; ok { return v } return grpcAPI{ pb.NewClusterClient(c.ActiveConnection()), grpcproxy.KvServerToKvClient(grpcproxy.NewKvProxy(c)), pb.NewLeaseClient(c.ActiveConnection()), grpcproxy.WatchServerToWatchClient(grpcproxy.NewWatchProxy(c)), pb.NewMaintenanceClient(c.ActiveConnection()), } }
func (c *cluster) switchRemote(prevErr error) error { newConn, err := c.c.retryConnection(c.conn, prevErr) if err != nil { return err } c.mu.Lock() defer c.mu.Unlock() c.conn = newConn c.remote = pb.NewClusterClient(c.conn) return nil }
func newClient(conn *grpc.ClientConn, cfg *Config) *Client { if cfg == nil { cfg = &Config{RetryDialer: dialEndpointList} } return &Client{ KV: pb.NewKVClient(conn), Lease: pb.NewLeaseClient(conn), Watch: pb.NewWatchClient(conn), Cluster: pb.NewClusterClient(conn), conn: conn, cfg: *cfg, } }
func toGRPC(c *clientv3.Client) grpcAPI { pmu.Lock() defer pmu.Unlock() if v, ok := proxies[c]; ok { return v } api := grpcAPI{ pb.NewClusterClient(c.ActiveConnection()), grpcproxy.KvServerToKvClient(grpcproxy.NewKvProxy(c)), pb.NewLeaseClient(c.ActiveConnection()), grpcproxy.WatchServerToWatchClient(grpcproxy.NewWatchProxy(c)), pb.NewMaintenanceClient(c.ActiveConnection()), } proxies[c] = api return api }
func newClient(conn *grpc.ClientConn, cfg *Config) (*Client, error) { if cfg == nil { cfg = &Config{RetryDialer: dialEndpointList} } var creds *credentials.TransportAuthenticator if cfg.TLS != nil { tlscfg, err := cfg.TLS.ClientConfig() if err != nil { return nil, err } c := credentials.NewTLS(tlscfg) creds = &c } return &Client{ KV: pb.NewKVClient(conn), Lease: pb.NewLeaseClient(conn), Watch: pb.NewWatchClient(conn), Cluster: pb.NewClusterClient(conn), conn: conn, cfg: *cfg, creds: creds, }, nil }
// RetryClusterClient implements a ClusterClient that uses the client's FailFast retry policy. func RetryClusterClient(c *Client) pb.ClusterClient { return &retryClusterClient{pb.NewClusterClient(c.conn), c.retryWrapper} }
func NewCluster(c *Client) Cluster { return &cluster{remote: pb.NewClusterClient(c.conn)} }
func (cp *clusterProxy) MemberList(ctx context.Context, r *pb.MemberListRequest) (*pb.MemberListResponse, error) { conn := cp.client.ActiveConnection() return pb.NewClusterClient(conn).MemberList(ctx, r) }
func NewCluster(c *Client) Cluster { ret := &cluster{} f := func(conn *grpc.ClientConn) { ret.remote = pb.NewClusterClient(conn) } ret.rc = newRemoteClient(c, f) return ret }