Ejemplo n.º 1
0
        public override string GetProperty(string key, string defaultValue)
        {
            // step 1: check system properties, i.e. -Dkey=value
            //TODO looks like .Net doesn't have such system property?
            string value = null;

            // step 2: check local cached properties file
            if (m_configProperties.ReadFullFence() != null)
            {
                value = m_configProperties.ReadFullFence().GetProperty(key);
            }

            /// <summary>
            /// step 3: check env variable, i.e. PATH=...
            /// normally system environment variables are in UPPERCASE, however there might be exceptions.
            /// so the caller should provide the key in the right case
            /// </summary>
            if (value == null)
            {
                value = System.Environment.GetEnvironmentVariable(key);
            }

            //TODO step 4: check properties file from classpath


            if (value == null && m_configProperties.ReadFullFence() == null)
            {
                logger.Warn(string.Format("Could not load config for namespace {0} from Apollo, please check whether the configs are released in Apollo! Return default value now!", m_namespace));
            }

            return(value == null ? defaultValue : value);
        }
Ejemplo n.º 2
0
 public override Properties GetConfig()
 {
     if (m_configCache.ReadFullFence() == null)
     {
         this.Sync();
     }
     return(TransformApolloConfigToProperties(m_configCache.ReadFullFence()));
 }
Ejemplo n.º 3
0
        /// <summary>
        /// Get the config service info from remote meta server.
        /// </summary>
        /// <returns> the services dto </returns>
        public IList <ServiceDTO> GetConfigServices()
        {
            if (m_configServices.ReadFullFence().Count == 0)
            {
                UpdateConfigServices();
            }

            return(m_configServices.ReadFullFence());
        }
        public override Properties GetConfig()
        {
            if (_configCache.ReadFullFence() == null)
            {
                AsyncHelper.RunSync(SchedulePeriodicRefresh);
            }

            return(TransformApolloConfigToProperties(_configCache.ReadFullFence()));
        }
Ejemplo n.º 5
0
        public override Properties GetConfig()
        {
            if (_syncException != null)
            {
                throw _syncException;
            }

            return(TransformApolloConfigToProperties(_configCache.ReadFullFence()));
        }
Ejemplo n.º 6
0
        public async Task Get()
        {
            try
            {
                var islocalcache = false;
                var apiurl       = _httpUrlRepository.GetApiUrl();
                var client       = _httpClientFactory.CreateClient();
                var response     = await client.SendAsync(new HttpRequestMessage(HttpMethod.Get, apiurl));

                response.EnsureSuccessStatusCode();
                var content = await response.Content.ReadAsStringAsync();

                var output = _jsonHelper.DeserializeObject <ApiInfo>(content);
                if (output != null && output.Value != null && output.Value.Count > 0)
                {
                    _dataList.WriteFullFence(output.Value);
                    islocalcache = true;
                }
                if (islocalcache)
                {
                    _localDataRepository.Set(_dataList.ReadFullFence());
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, $"加载配置错误");
                _dataList.WriteFullFence(_localDataRepository.Get());
            }
        }
Ejemplo n.º 7
0
        /// <summary>
        /// Get the config service info from remote meta server.
        /// </summary>
        /// <returns> the services dto </returns>
        public async Task <IList <ServiceDto> > GetConfigServices()
        {
            var services = _configServices.ReadFullFence();

            if (services.Count == 0)
            {
                await UpdateConfigServices();
            }

            services = _configServices.ReadFullFence();
            if (services.Count == 0)
            {
                throw new ApolloConfigException("No available config service");
            }

            return(services);
        }
Ejemplo n.º 8
0
        private ApolloConfig LoadApolloConfig()
        {
            string    appId      = m_configUtil.AppId;
            string    cluster    = m_configUtil.Cluster;
            string    dataCenter = m_configUtil.DataCenter;
            int       maxRetries = 2;
            Exception exception  = null;

            IList <ServiceDTO> configServices = ConfigServices;
            string             url            = null;

            for (int i = 0; i < maxRetries; i++)
            {
                IList <ServiceDTO> randomConfigServices = new List <ServiceDTO>(configServices);
                randomConfigServices.Shuffle();
                //Access the server which notifies the client first
                if (m_longPollServiceDto.ReadFullFence() != null)
                {
                    randomConfigServices.Insert(0, m_longPollServiceDto.AtomicExchange(null));
                }

                foreach (ServiceDTO configService in randomConfigServices)
                {
                    url = AssembleQueryConfigUrl(configService.HomepageUrl, appId, cluster, m_namespace, dataCenter, m_remoteMessages.ReadFullFence(), m_configCache.ReadFullFence());

                    logger.Debug(string.Format("Loading config from {0}", url));
                    Com.Ctrip.Framework.Apollo.Util.Http.HttpRequest request = new Com.Ctrip.Framework.Apollo.Util.Http.HttpRequest(url);

                    try
                    {
                        HttpResponse <ApolloConfig> response = m_httpUtil.DoGet <ApolloConfig>(request);

                        if (response.StatusCode == 304)
                        {
                            logger.Debug("Config server responds with 304 HTTP status code.");
                            return(m_configCache.ReadFullFence());
                        }

                        ApolloConfig result = response.Body;

                        logger.Debug(
                            string.Format("Loaded config for {0}: {1}", m_namespace, result));

                        return(result);
                    }
                    catch (ApolloConfigStatusCodeException ex)
                    {
                        ApolloConfigStatusCodeException statusCodeException = ex;
                        //config not found
                        if (ex.StatusCode == 404)
                        {
                            string message = string.Format("Could not find config for namespace - appId: {0}, cluster: {1}, namespace: {2}, please check whether the configs are released in Apollo!", appId, cluster, m_namespace);
                            statusCodeException = new ApolloConfigStatusCodeException(ex.StatusCode, message);
                        }
                        logger.Warn(statusCodeException);
                        exception = statusCodeException;
                    }
                    catch (Exception ex)
                    {
                        logger.Warn(ex);
                        exception = ex;
                    }
                }

                Thread.Sleep(1000); //sleep 1 second
            }
            string fallbackMessage = string.Format("Load Apollo Config failed - appId: {0}, cluster: {1}, namespace: {2}, url: {3}", appId, cluster, m_namespace, url);

            throw new ApolloConfigException(fallbackMessage, exception);
        }
        private async Task <ApolloConfig> LoadApolloConfig()
        {
            var appId      = _options.AppId;
            var cluster    = _options.Cluster;
            var dataCenter = _options.DataCenter;

            var configServices = await _serviceLocator.GetConfigServices();

            Exception exception = null;
            string    url       = null;

            var notFound = false;

            for (var i = 0; i < 2; i++)
            {
                IList <ServiceDto> randomConfigServices = new List <ServiceDto>(configServices);
                randomConfigServices.Shuffle();
                //Access the server which notifies the client first
                if (_longPollServiceDto.ReadFullFence() != null)
                {
                    randomConfigServices.Insert(0, _longPollServiceDto.AtomicExchange(null));
                }

                foreach (var configService in randomConfigServices)
                {
                    url = AssembleQueryConfigUrl(configService.HomepageUrl, appId, cluster, Namespace, dataCenter, _remoteMessages.ReadFullFence(), _configCache.ReadFullFence());

                    Logger.Debug($"Loading config from {url}");

                    try
                    {
                        var response = await _httpUtil.DoGetAsync <ApolloConfig>(url);

                        if (response.StatusCode == HttpStatusCode.NotModified)
                        {
                            Logger.Debug("Config server responds with 304 HTTP status code.");
                            return(_configCache.ReadFullFence());
                        }

                        var result = response.Body;

                        Logger.Debug(
                            $"Loaded config for {Namespace}: {result?.Configurations?.Count ?? 0}");

                        return(result);
                    }
                    catch (ApolloConfigStatusCodeException ex)
                    {
                        var statusCodeException = ex;
                        //config not found
                        if (ex.StatusCode == HttpStatusCode.NotFound)
                        {
                            notFound = true;

                            var message = $"Could not find config for namespace - appId: {appId}, cluster: {cluster}, namespace: {Namespace}, please check whether the configs are released in Apollo!";
                            statusCodeException = new ApolloConfigStatusCodeException(ex.StatusCode, message);
                        }

                        Logger.Warn(statusCodeException);
                        exception = statusCodeException;
                    }
                    catch (Exception ex)
                    {
                        Logger.Warn(ex);
                        exception = ex;
                    }
                }

                await Task.Delay(1000); //sleep 1 second
            }

            if (notFound)
            {
                return(null);
            }

            var fallbackMessage = $"Load Apollo Config failed - appId: {appId}, cluster: {cluster}, namespace: {Namespace}, url: {url}";

            throw new ApolloConfigException(fallbackMessage, exception);
        }