public override async Task ExecuteAsync()

in src/dsc/Commands/Connect/ConnectCommand.cs [235:372]
122 lines of code
27 McCabe index (conditional complexity)

        public override async Task<(ExitCode, string)> ExecuteAsync()
        {
            IRoutingManagementClient routingManagementClient = null;
            IConnectManagementClient connectManagementClient = null;
            IKubernetesManagementClient kubernetesManagementClient = null;
            KubeConfigDetails kubeConfigDetails = null;

            var failureReason = string.Empty;
            try
            {
                this.OnExecute();
                using (IKubeConfigManagementClient kubeConfigClient = _clientFactory.CreateKubeConfigClient(_targetKubeConfigContext))
                {
                    kubeConfigDetails = kubeConfigClient.GetKubeConfigDetails();
                    kubernetesManagementClient = _clientFactory.CreateKubernetesManagementClient(kubeConfigDetails);
                }

                if (!await kubernetesManagementClient.CheckCredentialsAsync(_targetNamespace, this.CancellationToken))
                {
                    throw new InvalidOperationException(Resources.FailedToPerformActionLoginNeeded);
                }

                // If it's not passed, read the namespace from the kubeconfig
                if (string.IsNullOrWhiteSpace(_targetNamespace))
                {
                    this._targetNamespace = kubeConfigDetails.NamespaceName;
                }

                if (_controlPort > 0)
                {
                    using (this.CancellationToken.Register(() => _connectionCancellationSource?.Cancel()))
                    {
                        RemotingHelper.StartRemotingServer(_webHostBuilderFactory, _controlPort, _log, _connectionCancellationSource);
                    }
                }

                RemoteContainerConnectionDetails remoteContainerConnectionDetails = this.ResolveContainerConnectionDetails(_routingHeaderValue, _routingManagerFeatureFlags);

                connectManagementClient = _clientFactory.CreateConnectManagementClient(remoteContainerConnectionDetails, kubeConfigDetails, _useKubernetesServiceEnvironmentVariables, _runContainerized);

                if (!string.IsNullOrEmpty(_routingHeaderValue))
                {
                    routingManagementClient = _clientFactory.CreateRoutingManagementClient(remoteContainerConnectionDetails.NamespaceName, kubeConfigDetails);
                    var validationErrorResponse = await routingManagementClient.GetValidationErrorsAsync(_routingHeaderValue, _connectionCancellationSource.Token);
                    if (validationErrorResponse != null && !string.IsNullOrEmpty(validationErrorResponse.Value))
                    {
                        _out.Error(validationErrorResponse.Value);
                        return (ExitCode.Fail, validationErrorResponse.Value);
                    }
                    var workloadInfo = await connectManagementClient.GetWorkloadInfo();
                    if (workloadInfo.EnvironmentVariables.ContainsKey("DAPR_HTTP_PORT") &&
                        workloadInfo.EnvironmentVariables.ContainsKey("DAPR_GRPC_PORT"))
                    {
                        _out.Error(Resources.IsolationIsNotAvailableWithDaprError);
                        return (ExitCode.Fail, Resources.IsolationIsNotAvailableWithDaprError);
                    }
                }

                ExitCode exitCode = ExitCode.Success;
                if (_runContainerized)
                {
                    return await this.ExecuteInnerContainerizedAsync(connectManagementClient, kubeConfigDetails, this._connectionCancellationSource.Token, routingManagementClient);
                }

                if (this._elevationRequests == null && !_useKubernetesServiceEnvironmentVariables)
                {
                    this._elevationRequests = await connectManagementClient.GetElevationRequestsAsync(CancellationToken);
                    if (this._elevationRequests != null && this._elevationRequests.Any() && !_yesFlag)
                    {
                        // The CLI is being called directly by the user. We output the elevation requests and wait for confirmation before proceeding
                        var sb = new StringBuilder();
                        sb.AppendLine(string.Format(Resources.AdminPermissionsRequiredFormat, Product.NameAbbreviation));
                        foreach (var request in this._elevationRequests)
                        {
                            sb.AppendLine(request.ConvertToReadableString());
                        }
                        sb.AppendLine();
                        sb.AppendLine(Resources.AdminPermissionsDisclaimer);
                        _out.Info(sb.ToString(), newLine: false);

                        if (!ConfirmContinue(defaultConfirmation: Confirmation.No, confirmationMessage: Resources.AdminPermissionsPrompt))
                        {
                            return (ExitCode.Cancel, string.Empty);
                        }
                    }
                }

                _envScriptPath = string.IsNullOrEmpty(_updateScript) ? this.CreateEnvScriptPath() : _updateScript;

                if (!_useKubernetesServiceEnvironmentVariables && (this._elevationRequests != null && this._elevationRequests.Any()))
                {
                    // Invoke the endpoint manager.
                    await connectManagementClient.StartEndpointManagerAsync(CancellationToken);
                }

                bool _relaunch = false;
                do
                {
                    this.RefreshExecuteCancellationSource();
                    _relaunch = false;
                    (exitCode, failureReason) = await this.ExecuteInnerAsync(connectManagementClient, () =>
                    {
                        Task.Run(async () =>
                        {
                            await connectManagementClient.WaitRemoteAgentChangeAsync(this._connectionCancellationSource.Token);

                            _relaunch = true;
                            if (!_executeCancellationSource.IsCancellationRequested)
                            {
                                _executeCancellationSource.Cancel();
                            }
                        }).Forget();
                    }, _executeCancellationSource.Token, routingManagementClient);
                    if (_relaunch && !this._connectionCancellationSource.IsCancellationRequested)
                    {
                        _out.Info(Resources.WorkloadChangeDetected);
                    }
                } while (_relaunch);
                return (exitCode, failureReason);
            }
            catch (Exception e) when (base._sdkErrorHandling.TryHandleKnownException(e, CliConstants.Dependency.ServiceRunPortForward, out failureReason))
            {
                // Message has been logged. Continue.
            }
            finally
            {
                _executeCancellationSource?.Dispose();
                _connectionCancellationSourceRegistration.Dispose();
                _connectionCancellationSource?.Dispose();

                // Dispose management clients
                routingManagementClient?.Dispose();
                connectManagementClient?.Dispose();
                kubernetesManagementClient?.Dispose();
            }

            return (ExitCode.Fail, failureReason);
        }