[clientv3] Is it safe to reuse client instances?

[ltpquang]

When my service starts, I instantiate one v3 client

	etcdClient, err := etcdv3.New(etcdv3.Config{
		Endpoints:   viper.GetStringSlice("db.etcd_endpoints"),
		DialTimeout: 5 * time.Second,
	})

Later in my service, I regularly watch for keys, in different places

	go func() {
		changes := etcdClient.Watch(context.Background(), key)
                // handle changes
	}()

Is it safe to do that?

From my observation, inwatch.go the watcher will reuse the same watchGrpcStream instance, since the contexts are the same.

	ctxKey := streamKeyFromCtx(ctx)
        // ...
		wgs := w.streams[ctxKey]
		if wgs == nil {
			wgs = w.newWatcherGrpcStream(ctx)
			w.streams[ctxKey] = wgs
		}

However, in watchGrpcStream's run() method, only ONE creation request is send to etcd server at any given time

	for {
		select {
		case req := <-w.reqc:
			switch wreq := req.(type) {
			case *watchRequest:
				// queue up for watcher creation/resume
				w.resuming = append(w.resuming, ws)
				if len(w.resuming) == 1 { // only send out if it's the only request?
					// head of resume queue, can register a new watcher
					if err := wc.Send(ws.initReq.toPB()); err != nil {
						w.lg.Debug("error when sending request", zap.Error(err))
					}
				}
		case pbresp := <-w.respc:
			switch {
			case pbresp.Created:
				// response to head of queue creation
				if len(w.resuming) != 0 {
					if ws := w.resuming[0]; ws != nil {
						w.addSubstream(pbresp, ws)
						w.dispatchEvent(pbresp)
						w.resuming[0] = nil
					}
				}
			}
		}
	}

Therefore, there are chances that:

• I call watcher.Watch() for key A, key B, key C from different goroutines, (without timeout contexts)
• And etcd server is failed to response creation result immediately (because of network latency maybe)
• Then only the first watch request is sent to etcd server, others will be omitted