func NewMaintenance(c *Client) Maintenance { conn := c.ActiveConnection() return &maintenance{ c: c, conn: conn, remote: pb.NewMaintenanceClient(conn), } }
func toGRPC(c *clientv3.Client) grpcAPI { return grpcAPI{ pb.NewClusterClient(c.ActiveConnection()), pb.NewKVClient(c.ActiveConnection()), pb.NewLeaseClient(c.ActiveConnection()), pb.NewWatchClient(c.ActiveConnection()), pb.NewMaintenanceClient(c.ActiveConnection()), } }
func (m *maintenance) switchRemote(prevErr error) error { m.mu.Lock() defer m.mu.Unlock() newConn, err := m.c.retryConnection(m.conn, prevErr) if err != nil { return err } m.conn = newConn m.remote = pb.NewMaintenanceClient(m.conn) return nil }
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 (m *maintenance) Status(ctx context.Context, endpoint string) (*StatusResponse, error) { conn, err := m.c.Dial(endpoint) if err != nil { return nil, err } remote := pb.NewMaintenanceClient(conn) resp, err := remote.Status(ctx, &pb.StatusRequest{}) if err != nil { return nil, err } return (*StatusResponse)(resp), nil }
func (m *maintenance) Defragment(ctx context.Context, endpoint string) (*DefragmentResponse, error) { conn, err := m.c.Dial(endpoint) if err != nil { return nil, rpctypes.Error(err) } remote := pb.NewMaintenanceClient(conn) resp, err := remote.Defragment(ctx, &pb.DefragmentRequest{}) if err != nil { return nil, rpctypes.Error(err) } return (*DefragmentResponse)(resp), nil }
func (m *maintenance) Status(ctx context.Context, endpoint string) (*StatusResponse, error) { conn, err := m.c.Dial(endpoint) if err != nil { return nil, toErr(ctx, err) } defer conn.Close() remote := pb.NewMaintenanceClient(conn) resp, err := remote.Status(ctx, &pb.StatusRequest{}, grpc.FailFast(false)) if err != nil { return nil, toErr(ctx, err) } return (*StatusResponse)(resp), nil }
func (c *cluster) defrag() error { for _, u := range c.GRPCURLs { plog.Printf("defragmenting %s\n", u) conn, err := grpc.Dial(u, grpc.WithInsecure(), grpc.WithTimeout(5*time.Second)) if err != nil { return err } mt := pb.NewMaintenanceClient(conn) if _, err = mt.Defragment(context.Background(), &pb.DefragmentRequest{}); err != nil { return err } conn.Close() plog.Printf("defragmented %s\n", u) } return nil }
func (m *member) RevHash() (int64, int64, error) { conn, err := m.dialGRPC() if err != nil { return 0, 0, err } mt := pb.NewMaintenanceClient(conn) ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) resp, err := mt.Hash(ctx, &pb.HashRequest{}, grpc.FailFast(false)) cancel() conn.Close() if err != nil { return 0, 0, err } return resp.Header.Revision, int64(resp.Hash), nil }
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 (c *cluster) getRevisionHash() (map[string]int64, map[string]int64, error) { revs := make(map[string]int64) hashes := make(map[string]int64) for _, u := range c.GRPCURLs { conn, err := grpc.Dial(u, grpc.WithInsecure(), grpc.WithTimeout(5*time.Second)) if err != nil { return nil, nil, err } m := pb.NewMaintenanceClient(conn) ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) resp, err := m.Hash(ctx, &pb.HashRequest{}) cancel() conn.Close() if err != nil { return nil, nil, err } revs[u] = resp.Header.Revision hashes[u] = int64(resp.Hash) } return revs, hashes, nil }
func (mp *maintenanceProxy) Snapshot(sr *pb.SnapshotRequest, stream pb.Maintenance_SnapshotServer) error { conn := mp.client.ActiveConnection() ctx, cancel := context.WithCancel(stream.Context()) defer cancel() sc, err := pb.NewMaintenanceClient(conn).Snapshot(ctx, sr) if err != nil { return err } for { rr, err := sc.Recv() if err != nil { return err } err = stream.Send(rr) if err != nil { return err } } }
func NewMaintenance(c *Client) Maintenance { return &maintenance{c: c, remote: pb.NewMaintenanceClient(c.conn)} }
func NewMaintenance(c *Client) Maintenance { ret := &maintenance{c: c} f := func(conn *grpc.ClientConn) { ret.remote = pb.NewMaintenanceClient(conn) } ret.rc = newRemoteClient(c, f) return ret }
func (mp *maintenanceProxy) Status(ctx context.Context, r *pb.StatusRequest) (*pb.StatusResponse, error) { conn := mp.client.ActiveConnection() return pb.NewMaintenanceClient(conn).Status(ctx, r) }
func (mp *maintenanceProxy) Defragment(ctx context.Context, dr *pb.DefragmentRequest) (*pb.DefragmentResponse, error) { conn := mp.client.ActiveConnection() return pb.NewMaintenanceClient(conn).Defragment(ctx, dr) }