hosting

func (*Host) Run(ctx context.Context) error
{
	ctx, cancel := context.WithCancel(ctx)
	defer cancel()

	h.mu.Lock()
	h.cancel = cancel
	h.mu.Unlock()

	h.state.Store(int32(HostStarting))

	for _, fn := range h.onStart {
		fn()
	}

	startupCtx, startupCancel := context.WithTimeout(ctx, h.startupTimeout)
	defer startupCancel()

	for _, svc := range h.hostedServices {
		if err := svc.Start(startupCtx); err != nil {
			startupCancel()
			h.shutdownHosted(ctx)
			return fmt.Errorf("hosted service start failed: %w", err)
		}
	}

	var wg sync.WaitGroup
	errCh := make(chan error, len(h.services))

	for _, svc := range h.services {
		s := svc
		wg.Add(1)
		go func() {
			defer wg.Done()
			if err := s.Execute(ctx); err != nil {
				errCh <- err
			}
		}()
	}

	h.state.Store(int32(HostRunning))

	sigCh := make(chan os.Signal, 1)
	signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)

	var firstErr error
	select {
	case <-sigCh:
	case <-ctx.Done():
	case err := <-errCh:
		firstErr = err
	}

	cancel()

	h.state.Store(int32(HostStopping))

	h.shutdownHosted(ctx)

	stopped := make(chan struct{})
	go func() {
		wg.Wait()
		close(stopped)
	}()

	timeout := h.ShutdownTimeout
	if timeout == 0 {
		timeout = 30 * time.Second
	}

	select {
	case <-stopped:
	case <-time.After(timeout):
	}

	for _, fn := range h.onStop {
		fn()
	}

	h.state.Store(int32(HostStopped))

	if firstErr != nil {
		return firstErr
	}
	return nil
}

func (*BackgroundServiceAdapter) Start(ctx context.Context) error
{
	errCh := make(chan error, 1)
	go func() {
		errCh <- a.Svc.Execute(ctx)
	}()
	select {
	case err := <-errCh:
		return err
	case <-ctx.Done():
		return ctx.Err()
	}
}

func (*HostBuilder) Build() *Host
{
	h := &Host{
		services:        append([]BackgroundService{}, b.services...),
		hostedServices:  append([]HostedService{}, b.hostedServices...),
		onStart:         b.onStart,
		onStop:          b.onStop,
		ShutdownTimeout: b.shutdownTimeout,
		startupTimeout:  b.startupTimeout,
		HealthRegistry:  b.healthRegistry,
	}

	if b.di != nil {
		c, err := b.di.Build()
		if err != nil {
			panic(err)
		}
		h.Container = c
	}
	if b.web != nil {
		addr := b.webAddr
		if addr == "" {
			addr = ":8080"
		}
		s := &webService{server: b.web, container: h.Container, addr: addr}
		h.services = append(h.services, s)
		h.Server = b.web
	}

	if h.HealthRegistry != nil && h.Server != nil {
		h.Server.MapGet("/health/live", func(ctx *srv.Context) error {
			return ctx.JSON(200, map[string]string{"status": "alive"})
		})
		h.Server.MapGet("/health/ready", func(ctx *srv.Context) error {
			results := h.HealthRegistry.CheckAll(ctx.Request.Context())
			healthy := true
			details := make(map[string]string, len(results))
			for name, report := range results {
				details[name] = report.Status.String()
				if report.Status == health.StatusUnhealthy {
					healthy = false
				}
			}
			code := 200
			status := "ready"
			if !healthy {
				code = 503
				status = "not ready"
			}
			return ctx.JSON(code, map[string]any{
				"status":  status,
				"details": details,
			})
		})
	}

	return h
}

func (*webService) Execute(ctx context.Context) error
{
	errCh := make(chan error, 1)
	go func() {
		errCh <- w.server.ListenAndServe(w.addr)
	}()
	select {
	case <-ctx.Done():
		w.server.Shutdown(context.Background())
		return nil
	case err := <-errCh:
		return err
	}
}