static EnvoyDefaults()

in sfintegration/ServiceData.cs [86:297]
194 lines of code
41 McCabe index (conditional complexity)

        static EnvoyDefaults()
        {
            var connectTimeout = Environment.GetEnvironmentVariable("HttpRequestConnectTimeoutMs");
            if (connectTimeout != null)
            {
                try
                {
                    connect_timeout_ms = Convert.ToInt32(connectTimeout);
                }
                catch { }
            }

            var requestTimeout = Environment.GetEnvironmentVariable("DefaultHttpRequestTimeoutMs");
            if (requestTimeout != null)
            {
                try
                {
                    timeout_ms = Convert.ToInt32(requestTimeout);
                }
                catch { }
            }

            var removeResponseHeaders = Environment.GetEnvironmentVariable("RemoveServiceResponseHeaders");
            if (removeResponseHeaders != null)
            {
                try
                {
                    response_headers_to_remove.AddRange(removeResponseHeaders.Replace(" ", "").Split(','));
                }
                catch { }
            }

            var useHttps = Environment.GetEnvironmentVariable("UseHttps");
            if (useHttps != null && useHttps == "true")
            {
                var verify_certificate_hash = Environment.GetEnvironmentVariable("ServiceCertificateHash");

                var subjectAlternateName = Environment.GetEnvironmentVariable("ServiceCertificateAlternateNames");
                if (subjectAlternateName != null)
                {
                    try
                    {
                        verify_subject_alt_name.AddRange(subjectAlternateName.Replace(" ", "").Split(','));
                    }
                    catch { }
                }
                cluster_ssl_context = new EnvoyClusterSslContext(verify_certificate_hash, verify_subject_alt_name);
            }

            host_ip = Environment.GetEnvironmentVariable("Fabric_NodeIPOrFQDN");
            if (host_ip == null || host_ip == "localhost")
            {
                bool runningInContainer = Environment.GetEnvironmentVariable("__STANDALONE_TESTING__") == null;
                if (runningInContainer)
                {
                    // running in a container outside of Service Fabric or 
                    // running in a container on local dev cluster
                    host_ip = GetInternalGatewayAddress();
                }
                else if (Environment.GetEnvironmentVariable("__USE_LOCALHOST__") == null)
                {
                    // running outside of Service Fabric or 
                    // running on local dev cluster
                    host_ip = GetIpAddress();
                }
                else
                {
                    host_ip = "127.0.0.1";
                }
            }
            var port = Environment.GetEnvironmentVariable("ManagementPort");
            if (port != null)
            {
                management_port = port;
            }

            client_cert_subject_name = Environment.GetEnvironmentVariable("SF_ClientCertCommonName");
            var issuer_thumbprints = Environment.GetEnvironmentVariable("SF_ClientCertIssuerThumbprints");
            if (!string.IsNullOrWhiteSpace(issuer_thumbprints))
            {
                client_cert_issuer_thumbprints = issuer_thumbprints.Split(',');
            }
            var server_common_names = Environment.GetEnvironmentVariable("SF_ClusterCertCommonNames");
            if (!string.IsNullOrWhiteSpace(server_common_names))
            {
                server_cert_common_names = server_common_names.Split(',');
            }
            var server_issuer_thumbprints = Environment.GetEnvironmentVariable("SF_ClusterCertIssuerThumbprints");
            if (!string.IsNullOrWhiteSpace(server_issuer_thumbprints))
            {
                server_cert_issuer_thumbprints = server_issuer_thumbprints.Split(',');
            }

            if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
            {
                fabricUri = new String[] { host_ip + ":" + management_port };
            }
            else
            {
                fabricUri = null;
            }

            LogMessage(String.Format("Management Endpoint = {0}:{1}", host_ip, management_port));
            if (fabricUri != null)
            {
                LogMessage(String.Format("Fabric Uri = {0}", fabricUri));
            }
            else
            {
                LogMessage(String.Format("Fabric Uri = []"));
            }

            if (client_cert_subject_name != null)
            {
                LogMessage(String.Format("SF_ClientCertCommonName = {0}", client_cert_subject_name));
            }
            if (issuer_thumbprints != null)
            {
                LogMessage(String.Format("SF_ClientCertIssuerThumbprints = {0}", issuer_thumbprints));
            }
            if (server_cert_common_names != null)
            {
                LogMessage(String.Format("SF_ClusterCertCommonNames = {0}", server_cert_common_names));
            }
            if (server_issuer_thumbprints != null)
            {
                LogMessage(String.Format("SF_ClusterCertIssuerThumbprints = {0}", server_issuer_thumbprints));
            }

            var gateway_listen_network = "";
            LogMessage("Getting Gateway_Config");
            string gateway_config = Environment.GetEnvironmentVariable("Gateway_Config");
            if (gateway_config != null && gateway_config != "")
            {
                LogMessage(String.Format("Gateway_Config = {0}", gateway_config));
                var gatewayProperties = JsonConvert.DeserializeObject<GatewayResourceDescription>(gateway_config);

                LogMessage(String.Format("Gateway_Config: Deserialized"));
                gateway_listen_network = gatewayProperties.SourceNetwork.Name;

                gateway_map = new Dictionary<string, List<ListenerFilterConfig>>();
                gateway_clusternames = new HashSet<string>();
                LogMessage(String.Format("Gateway_Config: Start processing"));
                if (gatewayProperties.Tcp != null)
                {
                    foreach (var e in gatewayProperties.Tcp)
                    {
                        string serviceName = e.Destination.EnvoyServiceName();
                        if (!gateway_map.ContainsKey(e.Port.ToString()) ||
                            gateway_map[e.Port.ToString()] == null)
                        {
                            gateway_map[e.Port.ToString()] = new List<ListenerFilterConfig>();
                        }
                        gateway_map[e.Port.ToString()].Add(
                            new ListenerFilterConfig(
                                e.Name,
                                ListenerFilterConfig.ListenerFilterType.Tcp,
                                serviceName));
                        gateway_clusternames.Add(serviceName);
                    }
                }
                if (gatewayProperties.Http != null)
                {
                    foreach (var httpConfig in gatewayProperties.Http)
                    {
                        string configName = "gateway_config|" + httpConfig.Port;
                        if (!gateway_map.ContainsKey(httpConfig.Port.ToString()) ||
                            gateway_map[httpConfig.Port.ToString()] == null)
                        {
                            gateway_map[httpConfig.Port.ToString()] = new List<ListenerFilterConfig>();
                        }
                        gateway_map[httpConfig.Port.ToString()].Add(
                            new ListenerHttpFilterConfig(
                                httpConfig.Name,
                                configName,
                                httpConfig.Hosts));
                        foreach (var host in httpConfig.Hosts)
                        {
                            foreach (var e in host.Routes)
                            {
                                var serviceName = e.Destination.EnvoyServiceName();
                                gateway_clusternames.Add(serviceName);
                            }
                        }
                    }
                }
                LogMessage(String.Format("Gateway_Config: End processing"));
            }
            else
                LogMessage("Gateway_Config=null");

            if (gateway_listen_network != null)
            {
                LogMessage(String.Format("Gateway_Listen_Network = {0}", gateway_listen_network));
                gateway_listen_network = "[" + gateway_listen_network + "]";
                var env = Environment.GetEnvironmentVariables();
                var keys = env.Keys;
                foreach (System.Collections.DictionaryEntry de in env)
                {
                    var variable = de.Key.ToString();
                    if (variable.Contains(gateway_listen_network) && variable.StartsWith("Fabric_NET"))
                    {
                        gateway_listen_ip = de.Value.ToString();
                        break;
                    }
                }
            }
            else
                LogMessage("Gateway_Listen_Network=null");

            LogMessage("gateway_listen_ip = " + gateway_listen_ip);
        }