Alanxtl commented on code in PR #1133:
URL: https://github.com/apache/dubbo-go-samples/pull/1133#discussion_r3772208614


##########
graceful_shutdown/go-server/cmd/main.go:
##########
@@ -64,37 +74,69 @@ func (p *GreetProvider) Greet(ctx context.Context, req 
*greet.GreetRequest) (*gr
        return resp, nil
 }
 
+func (p *GreetProvider) triggerShutdownOnFirstGreet() {
+       if !p.shutdownOnFirstGreet {
+               return
+       }
+
+       p.shutdownOnce.Do(func() {
+               go func() {
+                       time.Sleep(200 * time.Millisecond)
+                       proc, err := os.FindProcess(os.Getpid())
+                       if err != nil {
+                               panic(fmt.Sprintf("failed to find current 
process for shutdown trigger: %v", err))
+                       }
+                       if err := proc.Signal(os.Interrupt); err != nil {
+                               panic(fmt.Sprintf("failed to trigger graceful 
shutdown: %v", err))
+                       }
+                       logger.Info("Triggered graceful shutdown after first 
greet request entered provider")
+               }()
+       })
+}
+
 func main() {
        port := flag.Int("port", 20000, "triple listen port")
        timeout := flag.Duration("timeout", 60*time.Second, "overall graceful 
shutdown timeout budget")
        stepTimeout := flag.Duration("step-timeout", 3*time.Second, "timeout 
for waiting provider and consumer in-flight requests")
+       notifyTimeout := flag.Duration("notify-timeout", 5*time.Second, 
"timeout for notifying consumers during graceful shutdown")
        consumerUpdateWait := flag.Duration("consumer-update-wait", 
3*time.Second, "time to wait for consumers to observe instance changes")
        offlineWindow := flag.Duration("offline-window", 3*time.Second, "time 
window for observing late requests after offline")
        requestDelay := flag.Duration("delay", 0, "artificial delay added to 
each greet request")
+       ignoreContextCancel := flag.Bool("ignore-context-cancel", false, 
"continue the artificial delay even if the request context is canceled")
+       shutdownOnFirstGreet := flag.Bool("shutdown-on-first-greet", false, 
"trigger graceful shutdown after the first greet request enters the provider")
        flag.Parse()
 
-       graceful_shutdown.Init(
-               graceful_shutdown.WithTimeout(*timeout),
-               graceful_shutdown.WithStepTimeout(*stepTimeout),
-               
graceful_shutdown.WithConsumerUpdateWaitTime(*consumerUpdateWait),
-               
graceful_shutdown.WithOfflineRequestWindowTimeout(*offlineWindow),
-       )
-       logger.Infof("Graceful shutdown initialized, timeout=%s step-timeout=%s 
consumer-update-wait=%s offline-window=%s request-delay=%s",
-               timeout.String(), stepTimeout.String(), 
consumerUpdateWait.String(), offlineWindow.String(), requestDelay.String())
-
-       srv, err := server.NewServer(
-               server.WithServerProtocol(
+       ins, err := dubbo.NewInstance(
+               dubbo.WithShutdown(
+                       graceful_shutdown.WithTimeout(*timeout),
+                       graceful_shutdown.WithStepTimeout(*stepTimeout),
+                       graceful_shutdown.WithNotifyTimeout(*notifyTimeout),
+                       
graceful_shutdown.WithConsumerUpdateWaitTime(*consumerUpdateWait),
+                       
graceful_shutdown.WithOfflineRequestWindowTimeout(*offlineWindow),
+               ),
+               dubbo.WithProtocol(
                        protocol.WithProtocol("tri"),
                        protocol.WithPort(*port),
                        protocol.WithID("tri"),
                ),
        )
+       if err != nil {
+               logger.Fatalf("failed to create dubbo instance: %v", err)

Review Comment:
   这种里面都加一下panic



##########
graceful_shutdown/go-client/cmd/main.go:
##########
@@ -47,10 +47,20 @@ func main() {
        maxRequests := flag.Int64("max-requests", 0, "maximum number of 
requests to issue across all workers, 0 means unlimited")
        minSuccesses := flag.Int64("min-successes", 0, "minimum number of 
successful requests required before exit")
        minFailures := flag.Int64("min-failures", 0, "minimum number of failed 
requests required before exit")
+       scenario := flag.String("scenario", "", "optional integration scenario 
to run, supported: graceful-shutdown")
        flag.Parse()
 
        logger.Infof("Starting client, addr=%s short=%v concurrency=%d 
interval=%s request-timeout=%s",
                *addr, *shortConn, *concurrency, interval.String(), 
requestTimeout.String())
+       if *scenario != "" {
+               switch *scenario {
+               case "graceful-shutdown":
+                       runGracefulShutdownScenario(*addr, *shortConn, 
*requestTimeout, *namePrefix)
+               default:
+                       panic(fmt.Sprintf("unsupported scenario: %s", 
*scenario))
+               }
+               return
+       }

Review Comment:
   这个scenario 就不用加了 一共就一个scenario 😂



-- 
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.

To unsubscribe, e-mail: [email protected]

For queries about this service, please contact Infrastructure at:
[email protected]


---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]

Reply via email to