Method run

cli/command_server_start.go:199–310

(ctx context.Context)

}

func (c *commandServerStart) run(ctx context.Context) (reterr error) {
	if err := insecureserverbind.ValidateListenAddressIfRestricted(
		c.serverStartInsecure,
		c.serverStartWithoutPassword,
		c.serverStartAllowDangerousUnauthenticatedNetwork,
		c.sf.serverAddress,
	); err != nil {
		return errors.Wrap(err, "listen address not allowed for insecure server without password")
	}

	opts, err := c.serverStartOptions(ctx)
	if err != nil {
		return err
	}

	srv, err := server.New(ctx, opts)
	if err != nil {
		return errors.Wrap(err, "unable to initialize server")
	}

	if err = c.initRepositoryPossiblyAsync(ctx, srv); err != nil {
		return errors.Wrap(err, "unable to initialize repository")
	}

	defer func() {
		// cleanup: disconnect repository
		if err := srv.SetRepository(ctx, nil); err != nil {
			reterr = stderrors.Join(reterr, errors.Wrap(err, "error disconnecting repository"))
		}
	}()

	httpServer := &http.Server{
		ReadHeaderTimeout: 15 * time.Second, //nolint:mnd
		Addr:              stripProtocol(c.sf.serverAddress),
		BaseContext: func(_ net.Listener) context.Context {
			return ctx
		},
	}

	srv.OnShutdown = func(ctx context.Context) error {
		ctx2, cancel := context.WithTimeout(ctx, c.shutdownGracePeriod)
		defer cancel()

		// wait for all connections to finish within a shutdown grace period
		log(ctx2).Debugf("attempting graceful shutdown for %v", c.shutdownGracePeriod)

		// Gracefully shutdown GRPC server first to close GRPC connections
		log(ctx2).Debug("shutting down GRPC server")
		srv.ShutdownGRPCServer()
		log(ctx2).Debug("GRPC server shutdown completed")

		if serr := httpServer.Shutdown(ctx2); serr != nil {
			// graceful shutdown unsuccessful, force close
			log(ctx2).Debugf("unable to shut down gracefully - closing: %v", serr)
			return errors.Wrap(httpServer.Close(), "close")
		}

		log(ctx2).Debug("graceful shutdown succeeded")