public override void Configure()

in src/dsc/Commands/Connect/ConnectCommand.cs [94:233]
132 lines of code
19 McCabe index (conditional complexity)

        public override void Configure(CommandLineApplication app)
        {
            this._command = app;
            this._command.ShowInHelpText = true;
            this._command.AllowArgumentSeparator = true;
            base.ConfigureHelp(
                description: "Redirect traffic from a service, deployment or pod running in your cluster to your local machine.",
                extendedHelpText: @"
Additional Arguments
  Any arguments passed following the argument separator ""--"" will be interpreted as a command to execute in the Bridge
  environment. This can be used to connect to Kubernetes and start a service in one command line invocation.
  Example: 
  dsc connect --service my-service --local-port 8000 --routing me -y -- dotnet watch --project MyService.API
");

            base.Configure(app);

            var localPortOption = _cliCommandOptionFactory.CreateConnectLocalPortOption();
            var updateScriptOption = _cliCommandOptionFactory.CreateConnectUpdateScriptOption();
            var envOption = _cliCommandOptionFactory.CreateConnectEnvOption();
            var waitPpidOption = _cliCommandOptionFactory.CreateParentProcessIdOption();
            var controlPortOption = _cliCommandOptionFactory.CreateControlPortOption();
            var elevationRequestsOption = _cliCommandOptionFactory.CreateConnectElevationRequestsOptions();
            var routingOption = _cliCommandOptionFactory.CreateConnectRoutingHeaderOption();
            var useKubernetesServiceEnvironmentVariablesOption = _cliCommandOptionFactory.CreateUseKubernetesServiceEnvironmentVariablesOption();
            var runContainerizedOption = _cliCommandOptionFactory.CreateRunContainerizedOption();
            var yesOption = _cliCommandOptionFactory.CreateYesOption();
            var routingManagerFeatureFlagsOption = _cliCommandOptionFactory.CreateRoutingManagerFeatureFlagOption();

            this._command.Options.Add(localPortOption);
            this._command.Options.Add(updateScriptOption);
            this._command.Options.Add(envOption);
            this._command.Options.Add(waitPpidOption);
            this._command.Options.Add(controlPortOption);
            this._command.Options.Add(elevationRequestsOption);
            this._command.Options.Add(routingOption);
            this._command.Options.Add(useKubernetesServiceEnvironmentVariablesOption);
            this._command.Options.Add(runContainerizedOption);
            this._command.Options.Add(yesOption);
            this._command.Options.Add(routingManagerFeatureFlagsOption);

            this._command.OnExecute(() =>
            {
                try
                {
                    this.ParseTargetOptions();
                }
                catch (Exception ex)
                {
                    _out.Error(ex.Message);
                    this._command.ShowHelp();
                    return 1;
                }
                if (localPortOption.HasValue())
                {
                    try
                    {
                        _localPorts = localPortOption.Values.Select(s => int.Parse(s)).ToArray();
                        if (_localPorts.Any(s => s < 0 || s >= 65536))
                        {
                            throw new InvalidUsageException(_operationContext, string.Format(Resources.Error_InvalidPort, localPortOption.Template));
                        }
                    }
                    catch (FormatException ex)
                    {
                        _out.Error(string.Format(Resources.Error_IncorrectOption, CommandConstants.Options.ConnectLocalPort.Option, ex.Message));
                        this._command.ShowHelp();
                        return 1;
                    }
                }
                if (updateScriptOption.HasValue())
                {
                    _updateScript = updateScriptOption.Value();
                }
                if (envOption.HasValue())
                {
                    _envJsonPath = envOption.Value();
                }
                if (waitPpidOption.HasValue())
                {
                    if (int.TryParse(waitPpidOption.Value(), out var pid) && pid > 0)
                    {
                        try
                        {
                            _waitProcesses.Add(Process.GetProcessById(pid));
                        }
                        catch (Exception ex)
                        {
                            throw new InvalidUsageException(_operationContext, string.Format(Resources.Error_FailedToGetProcess, pid, ex.Message));
                        }
                    }
                }
                if (controlPortOption.HasValue())
                {
                    if (!int.TryParse(controlPortOption.Value(), out _controlPort) || _controlPort <= 0 || _controlPort >= 65536)
                    {
                        throw new InvalidUsageException(_operationContext, string.Format(Resources.Error_InvalidPort, controlPortOption.Template));
                    }
                }
                if (elevationRequestsOption.HasValue())
                {
                    try
                    {
                        var jsonElevationRequests = elevationRequestsOption.Value();
                        var elevationRequestsData = JsonHelpers.DeserializeObjectCaseInsensitive<IEnumerable<ElevationRequestData>>(jsonElevationRequests);
                        this._elevationRequests = elevationRequestsData.Select(erd => erd.ConvertToElevationRequest()).ToList();
                    }
                    catch (Exception)
                    {
                        throw new InvalidUsageException(_operationContext, string.Format(Resources.Error_InvalidElevationRequestsValue, elevationRequestsOption.Template));
                    }
                }

                this._operationContext.LoggingProperties[LoggingConstants.Property.IsRoutingEnabled] = routingOption.HasValue();
                if (routingOption.HasValue())
                {
                    try
                    {
                        KubernetesUtilities.IsValidRoutingValue(routingOption.Value());
                        this._routingHeaderValue = routingOption.Value();
                    }
                    catch (Exception e)
                    {
                        throw new InvalidUsageException(_operationContext, e.Message);
                    }
                }
                if (routingManagerFeatureFlagsOption.HasValue())
                {
                    _routingManagerFeatureFlags = routingManagerFeatureFlagsOption.Values;
                }

                this._useKubernetesServiceEnvironmentVariables = useKubernetesServiceEnvironmentVariablesOption.HasValue();
                this._yesFlag = yesOption.HasValue();

                this._runContainerized = runContainerizedOption.HasValue();

                this.SetCommand();
                return 0;
            });
        }