grpc.go

package naming

import (

    "encoding/json"

    etcd "github.com/coreos/etcd/clientv3"

    "golang.org/x/net/context"

    "google.golang.org/grpc"

    "google.golang.org/grpc/codes"

    "google.golang.org/grpc/naming"

)

// GRPCResolver creates a grpc.Watcher for a target to track its resolution changes.

//GRPCResolver  创建一个 grpc.Watcher对于目标对象，追踪目标对象的改变

type GRPCResolver struct {

    // Client is an initialized etcd client.

    Client *etcd.Client

}

//监听对象更新

func (gr *GRPCResolver) Update(ctx context.Context, target string, nm naming.Update, opts ...etcd.OpOption) (err error) {

    switch nm.Op {

    case naming.Add:

        var v []byte

        if v, err = json.Marshal(nm); err != nil {

            return grpc.Errorf(codes.InvalidArgument, err.Error())

        }

        _, err = gr.Client.KV.Put(ctx, target+"/"+nm.Addr, string(v), opts...)

    case naming.Delete:

        _, err = gr.Client.Delete(ctx, target+"/"+nm.Addr, opts...)

    default:

        return grpc.Errorf(codes.InvalidArgument, "naming: bad naming op")

    }

    return err

}

func (gr *GRPCResolver) Resolve(target string) (naming.Watcher, error) {

    ctx, cancel := context.WithCancel(context.Background())

    w := &gRPCWatcher{c: gr.Client, target: target + "/", ctx: ctx, cancel: cancel}

    return w, nil

}

type gRPCWatcher struct {

    c      *etcd.Client

    target string

    ctx    context.Context

    cancel context.CancelFunc

    wch    etcd.WatchChan

    err    error

}

// Next gets the next set of updates from the etcd resolver.

// Calls to Next should be serialized; concurrent calls are not safe since

// there is no way to reconcile the update ordering.

func (gw *gRPCWatcher) Next() ([]*naming.Update, error) {

    if gw.wch == nil {

        // first Next() returns all addresses

        return gw.firstNext()

    }

    if gw.err != nil {

        return nil, gw.err

    }

    // process new events on target/*

    wr, ok := <-gw.wch

    if !ok {

        gw.err = grpc.Errorf(codes.Unavailable, "naming: watch closed")

        return nil, gw.err

    }

    if gw.err = wr.Err(); gw.err != nil {

        return nil, gw.err

    }

    updates := make([]*naming.Update, 0, len(wr.Events))

    for _, e := range wr.Events {

        var jupdate naming.Update

        var err error

        switch e.Type {

        case etcd.EventTypePut:

            err = json.Unmarshal(e.Kv.Value, &jupdate)

            jupdate.Op = naming.Add

        case etcd.EventTypeDelete:

            err = json.Unmarshal(e.PrevKv.Value, &jupdate)

            jupdate.Op = naming.Delete

        }

        if err == nil {

            updates = append(updates, &jupdate)

        }

    }

    return updates, nil

}

func (gw *gRPCWatcher) firstNext() ([]*naming.Update, error) {

    // Use serialized request so resolution still works if the target etcd

    // server is partitioned away from the quorum.

    resp, err := gw.c.Get(gw.ctx, gw.target, etcd.WithPrefix(), etcd.WithSerializable())

    if gw.err = err; err != nil {

        return nil, err

    }

    updates := make([]*naming.Update, 0, len(resp.Kvs))

    for _, kv := range resp.Kvs {

        var jupdate naming.Update

        if err := json.Unmarshal(kv.Value, &jupdate); err != nil {

            continue

        }

        updates = append(updates, &jupdate)

    }

    opts := []etcd.OpOption{etcd.WithRev(resp.Header.Revision + 1), etcd.WithPrefix(), etcd.WithPrevKV()}

    gw.wch = gw.c.Watch(gw.ctx, gw.target, opts...)

    return updates, nil

}

func (gw *gRPCWatcher) Close() { gw.cancel() }