Function dialWithLazyValidation

coderd/x/chatd/dialvalidation.go:45–182

dialWithLazyValidation dials an agent and only consults the database if the original dial is slow or fails quickly. This keeps the common path free of latest-build lookups while still repairing stale bindings. Outcomes: - The dial succeeds before delay, so validation is skipped. - The timer fires a

(
	ctx context.Context,
	agentID uuid.UUID,
	workspaceID uuid.UUID,
	dialFn DialFunc,
	validateFn ValidateFunc,
	delay time.Duration,
)

//   - The dial fails before delay, so validation runs immediately and either
//     switches to a different agent or retries the current one once.
func dialWithLazyValidation(
	ctx context.Context,
	agentID uuid.UUID,
	workspaceID uuid.UUID,
	dialFn DialFunc,
	validateFn ValidateFunc,
	delay time.Duration,
) (DialResult, error) {
	wrapErr := func(err error) error {
		return xerrors.Errorf("dial with lazy validation: %w", err)
	}

	dialCtx, dialCancel := context.WithCancel(ctx)
	results := make(chan dialOut, 1)
	go func() {
		conn, release, err := dialFn(dialCtx, agentID)
		results <- dialOut{conn: conn, release: release, err: err}
	}()

	drained := false
	defer func() {
		dialCancel()
		if drained {
			return
		}
		// Drain without blocking the caller. dialFn may take time to honor
		// cancellation, but any late-arriving successful connection still needs to
		// be released.
		go func() {
			result := <-results
			if result.err == nil && result.release != nil {
				result.release()
			}
		}()
	}()

	resultForAgent := func(dialedAgentID uuid.UUID, result dialOut, switched bool) DialResult {
		return DialResult{
			Conn:        result.conn,
			Release:     result.release,
			AgentID:     dialedAgentID,
			WasSwitched: switched,
		}
	}
	dialAgent := func(targetAgentID uuid.UUID, switched bool) (DialResult, error) {
		conn, release, err := dialFn(ctx, targetAgentID)
		if err != nil {
			return DialResult{}, wrapErr(err)
		}
		return resultForAgent(targetAgentID, dialOut{conn: conn, release: release}, switched), nil
	}
	preferReadyOriginalDial := func() (DialResult, bool) {
		select {
		case result := <-results:
			drained = true
			if result.err != nil {
				return DialResult{}, false
			}