Method ensureModulesLoaded

engine/server/session_workspaces.go:657–720

ensureModulesLoaded loads all pending modules (from compat parsing, the implicit CWD module, and -m flags). Called from serveQuery after ensureWorkspaceLoaded. Uses a mutex+flag instead of sync.Once so that transient failures (e.g. session not yet registered) can be retried.

(ctx context.Context, client *daggerClient)

// ensureWorkspaceLoaded. Uses a mutex+flag instead of sync.Once so that
// transient failures (e.g. session not yet registered) can be retried.
func (srv *Server) ensureModulesLoaded(ctx context.Context, client *daggerClient) error {
	if len(client.pendingModules) == 0 && len(client.pendingExtraModules) == 0 {
		return nil
	}

	client.modulesMu.Lock()
	defer client.modulesMu.Unlock()

	if client.modulesLoaded {
		return client.modulesErr
	}

	// Wait for the client's session attachables to be available.
	// Don't mark as loaded on failure — allow retry on next request.
	if _, err := client.getClientCaller(ctx, client.clientID); err != nil {
		return fmt.Errorf("waiting for client session attachables: %w", err)
	}

	loads := gatherModuleLoadRequests(client.pendingModules, client.pendingExtraModules)
	resolvedLoads := make([]resolvedModuleLoad, len(loads))
	resolveErrs := make([]error, len(loads))

	// Resolve modules in parallel, then apply to client state in deterministic order.
	jobs := parallel.New().
		WithContextualTracer(true).
		WithLimit(moduleResolveParallelism(len(loads)))
	for i, load := range loads {
		i := i
		load := load
		jobs = jobs.WithJob(moduleLoadJobName(load), func(ctx context.Context) error {
			resolved, err := srv.resolveModuleLoad(ctx, client.dag, load)
			if err != nil {
				resolveErrs[i] = err
				return nil //nolint:nilerr // errors collected for deterministic ordering
			}
			resolvedLoads[i] = resolved
			return nil
		})
	}
	if err := jobs.Run(ctx); err != nil {
		client.modulesErr = fmt.Errorf("resolving modules: %w", err)
		client.modulesLoaded = true
		return client.modulesErr
	}

	for i, load := range loads {
		if resolveErrs[i] != nil {
			client.modulesErr = moduleLoadErr(load, resolveErrs[i])
			client.modulesLoaded = true
			return client.modulesErr
		}
	}

	client.stateMu.Lock()
	defer client.stateMu.Unlock()
	if err := srv.serveAllResolvedModuleLoads(client, loads, resolvedLoads); err != nil {
		client.modulesErr = err
		client.modulesLoaded = true