goldbeef edited a comment on issue #620: 
使用/v4/{project}/registry/microservices/{serviceId}/watcher无法收到回包
URL: 
https://github.com/apache/servicecomb-service-center/issues/620#issuecomment-572928016
 
 
   > 这是两个流程:
   > 
1、服务消费方,会调用/v4/{project}/registry/instances?appId=&serviceName=&version=0+发现提供方的实例信息,进行接口调用,此时服务中心会记录他们之间的调用关系
   > 2、消费方注册成功后,使用注册得到的微服务ID进行watch,此后只要提供方实例发生变化都会感知到
   
   我们就是通过上面2, 来watch, 但是感知不到事件,但是websocket是联通。
   
   服务注册方
   ```go
   func main()  {
        registryClient := &client.RegistryClient{}
   
        err := registryClient.Initialize(
                client.Options{
                        Addrs: []string{"127.0.0.1:30100"},
                })
        if err != nil {
                fmt.Printf("err[%v]\n", err)
                os.Exit(1)
        }
   
        /*
        "myapp1.1", "myserver1", "0.0.1", "")
        */
        service := &proto.MicroService{
                AppId: "myapp1.1",
                ServiceName:"myserver1",
                Version: "0.0.1",
                Environment: "",
        }
   
        ctx := context.Background()
        sid ,err := registryClient.RegisterService(ctx, service)
        if err != nil {
                fmt.Printf("err[%v]\n", err)
                os.Exit(1)
        }
        fmt.Printf("sid[%v]\n", sid)
   
        instance := proto.MicroServiceInstance{
                ServiceId: sid,
                HostName: "insdfsdsdfsdff2",
                Status: common.DefaultStatus,
                Endpoints: []string{"10.146.207.197:8080"},
                Properties: map[string]string{
                        "Name": "12",
                },
        }
   
        iid, err := registryClient.RegisterMicroServiceInstance(ctx, &instance)
        if err != nil {
                fmt.Printf("RegisterMicroServiceInstance, err[%v]\n", err)
                os.Exit(1)
        }
   
   
        //registryClient.WatchMicroService(sid, printEvent)
        cnt := 0
        for ; ;  {
                //registryClient.Heartbeat(ctx, sid, iid)
                cnt++
   
                status := ""
                if cnt % 2 == 0 {
                        status = common.DefaultStatus
                } else {
                        status = "DOWN"
                }
   
                _, err := 
registryClient.UpdateMicroServiceInstanceStatus(context.Background(), sid, iid, 
status)
                if err != nil {
                        fmt.Printf("UpdateMicroServiceInstanceStatus, 
err[%v]\n", err)
                }
                time.Sleep(time.Second)
        }
   
        registryClient.UnregisterMicroServiceInstance(ctx, sid, iid)
   
        fmt.Printf("sid[%v], iid[%v]\n", sid, iid)
   }
   
   func printEvent(event *client.MicroServiceInstanceChangedEvent) {
        content, _ := json.Marshal(event)
        fmt.Printf("event[%v]\n", string(content))
   }
   ```
   
   服务发现方:
   ```go
   func main()  {
        registryClient := &client.RegistryClient{}
   
        err := registryClient.Initialize(
                client.Options{
                        Addrs: []string{"127.0.0.1:30100"},
                })
        if err != nil {
                fmt.Printf("err[%v]\n", err)
                os.Exit(1)
        }
   
        ctx := context.Background()
        sid, err := registryClient.GetMicroServiceID(ctx, "myapp1.1", 
"myserver1", "0.0.1", "")
        if err != nil {
                fmt.Printf("GetMicroServiceID, err[%v]\n", err)
                os.Exit(1)
        }
   
        if sid == "" {
                fmt.Printf("sid[%v], empty\n", sid)
                os.Exit(1)
        }
   
        /*
        for ; ;  {
                instance, err := registryClient.GetMicroServiceInstances(ctx, 
"", sid)
                if err != nil {
                        fmt.Printf("GetMicroServiceID, err[%v]\n", err)
                        os.Exit(1)
                }
   
                content, _ := json.Marshal(instance)
                fmt.Printf("content[%v]\n", string(content))
                time.Sleep(time.Second)
        }*/
   
        for ; ;  {
                err = registryClient.WatchMicroService(sid, printEvent)
                if err != nil {
                        log.Panicf("WatchMicroService, err[%v]", err)
                }
                time.Sleep(time.Second)
        }
   }
   
   func printEvent(event *client.MicroServiceInstanceChangedEvent) {
        content, _ := json.Marshal(event)
        fmt.Printf("event[%v]\n", string(content))
   }
   ```
   
   
![image](https://user-images.githubusercontent.com/5627680/72137751-5886ec80-33c6-11ea-9e4b-a3b613a772b3.png)
   
![image](https://user-images.githubusercontent.com/5627680/72137775-62a8eb00-33c6-11ea-8bee-1dbd60480461.png)
   
   
![image](https://user-images.githubusercontent.com/5627680/72137868-92f08980-33c6-11ea-9895-d7945b5ce2c7.png)
   
   

----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
 
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org


With regards,
Apache Git Services

Reply via email to