private void AddAdditionalOptions()

in src/Amazon.ElasticBeanstalk.Tools/Commands/DeployEnvironmentCommand.cs [440:585]
128 lines of code
23 McCabe index (conditional complexity)

        private void AddAdditionalOptions(IList<ConfigurationOptionSetting> settings, bool createEnvironmentMode, bool isWindowsEnvironment)
        {
            var additionalOptions = this.GetKeyValuePairOrDefault(this.DeployEnvironmentOptions.AdditionalOptions, EBDefinedCommandOptions.ARGUMENT_EB_ADDITIONAL_OPTIONS, false);
            if (additionalOptions != null && additionalOptions.Count > 0)
            {
                foreach (var kvp in additionalOptions)
                {
                    var tokens = kvp.Key.Split(',');
                    if (tokens.Length != 2)
                    {
                        throw new ToolsException("Additional option \"" + kvp.Key + "=" + kvp.Value + "\" in incorrect format. Format should be <option-namespace>,<option-name>=<option-value>.", ToolsException.CommonErrorCode.DefaultsParseFail);
                    }

                    settings.Add(new ConfigurationOptionSetting
                    {
                        Namespace = tokens[0],
                        OptionName = tokens[1],
                        Value = kvp.Value
                    });
                }
            }

            var disableIMDSv1 = this.GetBoolValueOrDefault(this.DeployEnvironmentOptions.DisableIMDSv1, EBDefinedCommandOptions.ARGUMENT_DISABLE_IMDS_V1, false);
            if (disableIMDSv1.HasValue)
            {
                var existingSetting = settings.FirstOrDefault(s => s.Namespace == OPTIONS_NAMESPACE_DISABLE_IMDS_V1 && s.OptionName == OPTIONS_NAME_DISABLE_IMDS_V1);

                if (existingSetting != null)
                {
                    existingSetting.Value = disableIMDSv1.Value.ToString(CultureInfo.InvariantCulture).ToLowerInvariant();
                }
                else
                {
                    settings.Add(new ConfigurationOptionSetting()
                    {
                        Namespace = OPTIONS_NAMESPACE_DISABLE_IMDS_V1,
                        OptionName = OPTIONS_NAME_DISABLE_IMDS_V1,
                        Value = disableIMDSv1.Value.ToString(CultureInfo.InvariantCulture).ToLowerInvariant()
                    });
                }
            }

            var enableXRay = this.GetBoolValueOrDefault(this.DeployEnvironmentOptions.EnableXRay, EBDefinedCommandOptions.ARGUMENT_ENABLE_XRAY, false);
            if(enableXRay.HasValue)
            {
                settings.Add(new ConfigurationOptionSetting()
                {
                    Namespace = "aws:elasticbeanstalk:xray",
                    OptionName = "XRayEnabled",
                    Value = enableXRay.Value.ToString(CultureInfo.InvariantCulture).ToLowerInvariant()
                });

                this.Logger?.WriteLine($"Enable AWS X-Ray: {enableXRay.Value}");
            }

            var enhancedHealthType = this.GetStringValueOrDefault(this.DeployEnvironmentOptions.EnhancedHealthType, EBDefinedCommandOptions.ARGUMENT_ENHANCED_HEALTH_TYPE, false);
            if(!string.IsNullOrWhiteSpace(enhancedHealthType))
            {
                if (!EBConstants.ValidEnhanceHealthType.Contains(enhancedHealthType))
                    throw new ElasticBeanstalkExceptions($"The enhanced value type {enhancedHealthType} is invalid. Valid values are: {string.Join(", ", EBConstants.ValidEnhanceHealthType)}", ElasticBeanstalkExceptions.EBCode.InvalidEnhancedHealthType);

                settings.Add(new ConfigurationOptionSetting()
                {
                    Namespace = "aws:elasticbeanstalk:healthreporting:system",
                    OptionName = "SystemType",
                    Value = enhancedHealthType
                });
            }

            string environmentType, loadBalancerType;
            DetermineEnvironment(out environmentType, out loadBalancerType);
            var healthCheckURL = this.GetStringValueOrDefault(this.DeployEnvironmentOptions.HealthCheckUrl, EBDefinedCommandOptions.ARGUMENT_HEALTH_CHECK_URL, false);

            // If creating a new load balanced environment then a heath check url must be set.
            if (createEnvironmentMode && string.IsNullOrEmpty(healthCheckURL) && EBUtilities.IsLoadBalancedEnvironmentType(environmentType))
            {
                healthCheckURL = "/";
            }

            if (!string.IsNullOrEmpty(healthCheckURL))
            {
                settings.Add(new ConfigurationOptionSetting()
                {
                    Namespace = "aws:elasticbeanstalk:application",
                    OptionName = "Application Healthcheck URL",
                    Value = healthCheckURL
                });

                if (EBUtilities.IsLoadBalancedEnvironmentType(environmentType) && string.Equals(loadBalancerType, EBConstants.LOADBALANCER_TYPE_APPLICATION))
                {
                    settings.Add(new ConfigurationOptionSetting()
                    {
                        Namespace = "aws:elasticbeanstalk:environment:process:default",
                        OptionName = "HealthCheckPath",
                        Value = healthCheckURL
                    });
                }
            }

            if(!isWindowsEnvironment)
            {
                var proxyServer = this.GetStringValueOrDefault(this.DeployEnvironmentOptions.ProxyServer, EBDefinedCommandOptions.ARGUMENT_PROXY_SERVER, false);
                if (!string.IsNullOrEmpty(proxyServer))
                {
                    if (!EBConstants.ValidProxyServer.Contains(proxyServer))
                        throw new ElasticBeanstalkExceptions($"The proxy server {proxyServer} is invalid. Valid values are: {string.Join(", ", EBConstants.ValidProxyServer)}", ElasticBeanstalkExceptions.EBCode.InvalidProxyServer);

                    Logger?.WriteLine($"Configuring reverse proxy to {proxyServer}");
                    settings.Add(new ConfigurationOptionSetting()
                    {
                        Namespace = OPTIONS_NAMESPACE_ENVIRONMENT_PROXY,
                        OptionName = OPTIONS_NAME_PROXY_SERVER,
                        Value = proxyServer
                    });

                }

                var applicationPort = this.GetIntValueOrDefault(this.DeployEnvironmentOptions.ApplicationPort, EBDefinedCommandOptions.ARGUMENT_APPLICATION_PORT, false);
                if (applicationPort.HasValue)
                {
                    Logger?.WriteLine($"Application port to {applicationPort}");
                    settings.Add(new ConfigurationOptionSetting()
                    {
                        Namespace = OPTIONS_NAMESPACE_APPLICATION_ENVIRONMENT,
                        OptionName = OPTIONS_NAME_APPLICATION_PORT,
                        Value = applicationPort.Value.ToString(CultureInfo.InvariantCulture)
                    });
                }
            }

            var enableStickySessions = this.GetBoolValueOrDefault(this.DeployEnvironmentOptions.EnableStickySessions, EBDefinedCommandOptions.ARGUMENT_ENABLE_STICKY_SESSIONS, false);
            if (enableStickySessions.HasValue)
            {
                if(enableStickySessions.Value)
                {
                    Logger?.WriteLine($"Enabling sticky sessions");
                }

                settings.Add(new ConfigurationOptionSetting()
                {
                    Namespace = "aws:elasticbeanstalk:environment:process:default",
                    OptionName = "StickinessEnabled",
                    Value = enableStickySessions.Value.ToString(CultureInfo.InvariantCulture).ToLowerInvariant()
                });
            }
        }