Function waitUntilCodespaceConnectionReady

internal/codespaces/codespaces.go:78–129

waitUntilCodespaceConnectionReady waits for a Codespace to be running and is able to be connected to.

(ctx context.Context, progress progressIndicator, apiClient apiClient, codespace *api.Codespace)

// waitUntilCodespaceConnectionReady waits for a Codespace to be running and is able to be connected to.
func waitUntilCodespaceConnectionReady(ctx context.Context, progress progressIndicator, apiClient apiClient, codespace *api.Codespace) (*api.Codespace, error) {
	if connectionReady(codespace) {
		return codespace, nil
	}

	progress.StartProgressIndicatorWithLabel("Waiting for codespace to become ready")
	defer progress.StopProgressIndicator()

	lastState := ""
	firstRetry := true

	err := backoff.Retry(func() error {
		var err error
		if firstRetry {
			firstRetry = false
		} else {
			codespace, err = apiClient.GetCodespace(ctx, codespace.Name, true)
			if err != nil {
				return backoff.Permanent(fmt.Errorf("error getting codespace: %w", err))
			}
		}

		if connectionReady(codespace) {
			return nil
		}

		// Only react to changes in the state (so that we don't try to start the codespace twice)
		if codespace.State != lastState {
			if codespace.State == api.CodespaceStateShutdown {
				err = apiClient.StartCodespace(ctx, codespace.Name)
				if err != nil {
					return backoff.Permanent(fmt.Errorf("error starting codespace: %w", err))
				}
			}
		}

		lastState = codespace.State

		return &TimeoutError{message: "codespace not ready yet"}
	}, backoff.WithContext(codespaceStatePollingBackoff, ctx))

	if err != nil {
		var timeoutErr *TimeoutError
		if errors.As(err, &timeoutErr) {
			return nil, errors.New("timed out while waiting for the codespace to start")
		}

		return nil, err
	}

	return codespace, nil
}

// ListenTCP starts a localhost tcp listener on 127.0.0.1 (unless allInterfaces is true) and returns the listener and bound port
func ListenTCP(port int, allInterfaces bool) (*net.TCPListener, int, error) {