static DynamicPolicyPlugin()
{
_policyServiceUrl = ConfigurationManager.AppSettings[PolicyServiceUrlSettingKey];
if (string.IsNullOrWhiteSpace(_policyServiceUrl))
{
if (!AntFxConfigWebServiceUtils.Enabled)
{
return;
}
SyncPolicyServiceUrl();
if (string.IsNullOrWhiteSpace(_policyServiceUrl))
{
AntFxConfigWebServiceUtils.SubscribeFxWebServiceConfigUpdateEvent(SyncPolicyServiceUrl);
}
}
Enabled = true;
string policyServiceSyncIntervalSetting = ConfigurationManager.AppSettings[PolicyServiceSyncIntervalSettingKey];
if (!string.IsNullOrWhiteSpace(policyServiceSyncIntervalSetting))
{
int.TryParse(policyServiceSyncIntervalSetting, out PolicyServiceSyncInterval);
if (PolicyServiceSyncInterval < MinPolicyServiceSyncInterval)
{
PolicyServiceSyncInterval = MinPolicyServiceSyncInterval;
}
}
}
private static void SyncPolicyServiceUrl()
{
if (!string.IsNullOrWhiteSpace(_policyServiceUrl))
{
return;
}
string value = AntFxConfigWebServiceUtils.GetConfigItemValue(FxConfigWebServicePolicyServiceUrlSettingKey);
if (!string.IsNullOrWhiteSpace(value))
{
_policyServiceUrl = value.Trim();
}
}
public static void SyncGlobalSetting()
{
try
{
string value = AntFxConfigWebServiceUtils.GetConfigItemValue(FxConfigWebServiceSOAServiceCircuitBreakerTimeoutSettingKey);
int timeout = 0;
int.TryParse(value, out timeout);
TimeSpan globalTimeout = TimeSpan.FromMilliseconds(timeout);
if (globalTimeout >= MinGlobalDefaultCircuitBreakerTimeoutSetting)
{
GlobalDefaultCircuitBreakerTimeoutSetting = globalTimeout;
}
}
catch
{
}
}
void SyncDynamicSettings(object sender, ElapsedEventArgs e)
{
if (_isPolicySyncRunning)
{
return;
}
_isPolicySyncRunning = true;
try
{
if (string.IsNullOrWhiteSpace(_policyServiceUrl))
{
AntFxConfigWebServiceUtils.SyncConfig();
}
if (string.IsNullOrWhiteSpace(_policyServiceUrl))
{
return;
}
if (_policyServiceClient == null)
{
_policyServiceClient = PolicyServiceClient.GetInstance(_policyServiceUrl);
_policyServiceClient.Format = _dataTransferFormat;//"json"
_policyServiceClient.Timeout = TimeSpan.FromSeconds(100);
_policyServiceClient.ReadWriteTimeout = TimeSpan.FromSeconds(300);
_policyServiceClient.EnableCHystrixSupport = false;
}
foreach (ServiceMetadata metadata in EndpointHost.Config.MetadataMap.Values)
{
if (!_serviceEnabledMap[metadata.ServicePath])
{
continue;
}
//获取每个服务的配置 一般都是一个服务
GetServiceSettingsResponseType policySyncResponse = null;
try
{
policySyncResponse = _policyServiceClient.GetServiceSettings(new GetServiceSettingsRequestType()
{
ServiceName = metadata.ServiceName,
ServiceNamespace = metadata.ServiceNamespace
});
}
catch (Exception ex)
{
_log.Error(SyncErrorTitle, ex, new Dictionary <string, string>
{
{ "ErrorCode", "FXD300014" },
{ "ServiceName", metadata.ServiceName },
{ "ServiceNamespace", metadata.ServiceNamespace }
});
continue;
}
try
{
metadata.LogErrorWithRequestInfo = policySyncResponse.ServiceSettings.LogErrorWithRequestInfo;
metadata.LogCommonRequestInfo = policySyncResponse.ServiceSettings.LogCommonRequestInfo;
metadata.CircuitBreakerForceClosed = policySyncResponse.ServiceSettings.CircuitBreakerForceClosed;
Dictionary <string, TimeSpan> timeoutSettings = GenerateOperationTimeoutDictionary(policySyncResponse.ServiceSettings.OperationTimeoutSettings);
foreach (Operation operation in metadata.Operations)
{
//把每个方法的电路设置为连接的状态
operation.HystrixCommand.Properties.CircuitBreakerForceClosed.Set(metadata.CircuitBreakerForceClosed);
string operationName = operation.Name.ToLower();
if (timeoutSettings.ContainsKey(operationName))
{
operation.HystrixCommand.Properties.ExecutionIsolationThreadTimeout.Set(timeoutSettings[operationName]);
}
}
foreach (IPlugin plugin in EndpointHost.Plugins)
{
if (plugin is WhiteListPlugin)
{
bool enabled;
List <string> newWhiteList;
if (plugin is AppIdWhiteListPlugin)
{
enabled = policySyncResponse.ServiceSettings.EnableAppIdWhiteListCheck;
newWhiteList = policySyncResponse.ServiceSettings.AppIdWhiteList;
}
else if (plugin is IPWhiteListPlugin)
{
enabled = policySyncResponse.ServiceSettings.EnableIPWhiteListCheck;
newWhiteList = policySyncResponse.ServiceSettings.IPWhiteList;
}
else
{
continue;
}
WhiteListPlugin whiteListPlugin = plugin as WhiteListPlugin;
whiteListPlugin.Refresh(metadata.ServicePath, enabled, newWhiteList);
}
else if (plugin is BlackListPlugin)
{
bool enabled;
List <string> newBlackList;
if (plugin is AppIdBlackListPlugin)
{
enabled = policySyncResponse.ServiceSettings.EnableAppIdBlackListCheck;
newBlackList = policySyncResponse.ServiceSettings.AppIdBlackList;
}
else if (plugin is IPBlackListPlugin)
{
enabled = policySyncResponse.ServiceSettings.EnableIPBlackListCheck;
newBlackList = policySyncResponse.ServiceSettings.IPBlackList;
}
else
{
continue;
}
BlackListPlugin blackListPlugin = plugin as BlackListPlugin;
blackListPlugin.Refresh(metadata.ServicePath, enabled, newBlackList);
}
else if (plugin is RateLimitingPlugin)
{
bool enabled;
int rateLimit;
if (plugin is RateLimitingWithMapPlugin)
{
Dictionary <string, int> rateLimitMap;
if (plugin is AppIdRateLimitingPlugin)
{
enabled = policySyncResponse.ServiceSettings.EnableAppIdRateLimitingCheck;
rateLimit = policySyncResponse.ServiceSettings.AppIdRateLimit;
rateLimitMap = policySyncResponse.ServiceSettings.AppIdRateLimitSettings.ToDictionary(item => item.AppId, item => item.RateLimit);
}
else if (plugin is IPRateLimitingPlugin)
{
enabled = policySyncResponse.ServiceSettings.EnableIPRateLimitingCheck;
rateLimit = policySyncResponse.ServiceSettings.IPRateLimit;
rateLimitMap = policySyncResponse.ServiceSettings.IPRateLimitSettings.ToDictionary(item => item.IP, item => item.RateLimit);
}
else
{
continue;
}
RateLimitingWithMapPlugin rateLimitingPlugin = plugin as RateLimitingWithMapPlugin;
rateLimitingPlugin.Refresh(metadata.ServicePath, enabled, rateLimit, rateLimitMap);
continue;
}
else
{
if (plugin is ServiceRateLimitingPlugin)
{
enabled = policySyncResponse.ServiceSettings.EnableServiceRateLimitingCheck;
rateLimit = policySyncResponse.ServiceSettings.ServiceRateLimit;
}
else if (plugin is OperationRateLimitingPlugin)
{
enabled = policySyncResponse.ServiceSettings.EnableOperationRateLimitingCheck;
Dictionary <string, int> operationRateLimitMap = policySyncResponse.ServiceSettings.OperationRateLimitSettings
.ToDictionary(i => i.OperationName.Trim().ToLower(), i => i.RateLimit);
OperationRateLimitingPlugin operationRateLimitPlugin = plugin as OperationRateLimitingPlugin;
operationRateLimitPlugin.Refresh(metadata.ServicePath, enabled, operationRateLimitMap);
continue;
}
else
{
continue;
}
RateLimitingPlugin rateLimitingPlugin = plugin as RateLimitingPlugin;
rateLimitingPlugin.Refresh(metadata.ServicePath, enabled, rateLimit);
}
}
}
}
catch (Exception ex)
{
try
{
_log.Fatal(
"Regression Bug",
ex,
new Dictionary <string, string>
{
{ "ErrorCode", "FXD300015" },
{ "ServiceName", metadata.ServiceName },
{ "ServiceNamespace", metadata.ServiceNamespace },
{ "Dynamic Policy Response", TypeSerializer.SerializeToString(policySyncResponse) }
});
}
catch
{
}
}
}
}
catch { }
finally
{
_isPolicySyncRunning = false;
}
}
//After configure called
public static void AfterInit()
{
StartedAt = DateTime.UtcNow;
if (Config.EnableFeatures != Feature.All)
{
if ((Feature.Xml & Config.EnableFeatures) != Feature.Xml)
{
Config.IgnoreFormatsInMetadata.Add("xml");
}
if ((Feature.Json & Config.EnableFeatures) != Feature.Json)
{
Config.IgnoreFormatsInMetadata.Add("json");
}
if ((Feature.Jsv & Config.EnableFeatures) != Feature.Jsv)
{
Config.IgnoreFormatsInMetadata.Add("jsv");
}
if ((Feature.Csv & Config.EnableFeatures) != Feature.Csv)
{
Config.IgnoreFormatsInMetadata.Add("csv");
}
if ((Feature.Html & Config.EnableFeatures) != Feature.Html)
{
Config.IgnoreFormatsInMetadata.Add("html");
}
}
if ((Feature.Html & Config.EnableFeatures) != Feature.Html)
{
Plugins.RemoveAll(x => x is HtmlFormat);
}
if ((Feature.PredefinedRoutes & Config.EnableFeatures) != Feature.PredefinedRoutes)
{
Plugins.RemoveAll(x => x is PredefinedRoutesFeature);
}
if ((Feature.Metadata & Config.EnableFeatures) != Feature.Metadata)
{
Plugins.RemoveAll(x => x is MetadataFeature);
}
if ((Feature.RequestInfo & Config.EnableFeatures) != Feature.RequestInfo)
{
Plugins.RemoveAll(x => x is RequestInfoFeature);
}
if ((Feature.HystrixInfo & Config.EnableFeatures) != Feature.HystrixInfo)
{
Plugins.RemoveAll(x => x is HystrixInfoFeature);
}
if ((Feature.ProtoBuf & Config.EnableFeatures) != Feature.ProtoBuf)
{
Plugins.RemoveAll(x => x is IProtoBufPlugin); //external
}
if ((Feature.MsgPack & Config.EnableFeatures) != Feature.MsgPack)
{
Plugins.RemoveAll(x => x is IMsgPackPlugin); //external
}
if (ExceptionHandler == null)
{
// This is where all framework exceptions are centrally handled
ExceptionHandler = (httpReq, httpRes, ex) =>
{
//httpRes.WriteToResponse always calls .Close in its finally statement so
//if there is a problem writing to response, by now it will be closed
if (!httpRes.IsClosed)
{
httpRes.WriteErrorToResponse(httpReq, httpReq.ResponseContentType, ex);
}
};
}
if (!Plugins.Exists(p => p is DynamicPolicyPlugin))
{
Plugins.Add(new DynamicPolicyPlugin());
}
if (Config.UseConsulDiscovery && !Plugins.Exists(p => p is ConsulFeature))
{
Plugins.Add(new ConsulFeature());
}
if (!Plugins.Exists(p => p is SwaggerServicePlugin))
{
Plugins.Add(new SwaggerServicePlugin());
}
//这里先预留 留着获取动态配置用的
if (AntFxConfigWebServiceUtils.Enabled)
{
HystrixCommandHelper.SyncGlobalSetting();
AntFxConfigWebServiceUtils.SubscribeFxWebServiceConfigUpdateEvent(HystrixCommandHelper.SyncGlobalSetting);
}
ConfigurePlugins();
AppHost.LoadPlugin(Plugins.ToArray());
pluginsLoaded = true;
AfterPluginsLoaded();
foreach (KeyValuePair <string, string> item in ContentTypeFilter.ContentTypeFormats)
{
SupportedFormats[item.Key] = item.Value;
}
if (AppHost.AfterInitCallbacks != null && AppHost.AfterInitCallbacks.Count > 0)
{
AppHost.AfterInitCallbacks.ForEach(t => t.Invoke(AppHost));
}
ReadyAt = DateTime.UtcNow;
}
