Provide an `OnStart` handler on `server.Restate`

[strobus]

I want my services to self-register their deployment and perform other tasks like initializing cron jobs after the server starts. Currently there is no way to know if the server is started. I am using a combination of goroutines and time.Sleep to approximate what I want. I envision something like this:

func main() {
    server.NewRestate().
        Bind(restate.Reflect(NewMyService()).
        OnStart(handleRestateStart).
        Start(ctx, addr)
}

func handleRestateStart() {
    // register restate deployment (use force=false in multi-pod environments)
    // register cron jobs
    // invoke other startup features that depend on restate
}

[slinkydeveloper]

I would personally merge this https://github.com/restatedev/sdk-go/pull/59/files first, because it makes sense to simply use the go built-in server start functionality, and then see how/if we can plug into that an on start hook.

[strobus]

Go doesn't provide much help in creating OnStart functionality. Here is a possible solution for the Go SDK that can be incorporated into PR #59 : https://gist.github.com/strobus/4673c0ea84492f2f076df8c4133cc444

[khatibomar]

@strobus I have comment/improvement over the gist, I would rewrite detectServerUpAndFireOnStart like that.

func (r *Restate) detectServerUpAndFireOnStart(ctx context.Context, address string) {
	_, port, err := net.SplitHostPort(address)
	if err != nil {
		slog.Error("invalid address", slog.String("address", address), slog.Any("error", err))
		return
	}

	u := &url.URL{
		Scheme: "http",
		Host:   net.JoinHostPort("localhost", port),
		Path:   "/discover",
	}

	httpClient := &http.Client{
		Transport: &http2.Transport{
			AllowHTTP: true,
			DialTLSContext: func(_ context.Context, network, addr string, _ *tls.Config) (net.Conn, error) {
				return net.Dial(network, addr)
			},
		},
	}

	ticker := time.NewTicker(2 * time.Second)
	defer ticker.Stop()

	for {
		select {
		case <-ctx.Done():
			return
		case <-ticker.C:
			checkCtx, cancel := context.WithTimeout(ctx, time.Second)
			defer cancel()

			req, err := http.NewRequestWithContext(checkCtx, http.MethodGet, u.String(), nil)
			if err != nil {
				slog.Error("failed to create HTTP request", slog.Any("error", err))
				continue
			}

			resp, err := httpClient.Do(req)
			if err != nil {
				slog.Debug("server not ready", slog.Any("error", err))
				continue
			}
			resp.Body.Close()

			if resp.StatusCode == http.StatusOK {
				go r.onStart(ctx)
				return
			}
		}
	}
}

this address the following points:

• Reusing http.Client avoids resource leaks and enables performance improvements https://pkg.go.dev/net/http#Client

The [Client.Transport] typically has internal state (cached TCP connections), so Clients should be reused instead of created as needed. Clients are safe for concurrent use by multiple goroutines.

• Using net/url and SplitHostPort ensures safe, correct URL construction
• Closing resp.Body ensures connection reuse and prevents FD leaks
• Logging retries at debug level reduces noise during normal operation

[khatibomar]

case <-ticker.C:
    time.Sleep(time.Duration(rand.Intn(500)) * time.Millisecond)

adding jitter would be also good idea

[strobus]

Looks good!

[slinkydeveloper]

TBH I'm not sure we need this functionality for now, so I would say the gist is a good workaround, especially given your motivations here:

I want my services to self-register their deployment and perform other tasks like initializing cron jobs after the server starts.

For these two specific problems, I think we need some alternative "restate native" solutions...