protected void FireConfigChange(ConfigChangeEventArgs changeEvent)
{
if (ConfigChanged != null)
{
foreach (ConfigChangeEvent handler in ConfigChanged.GetInvocationList())
{
Task.Factory.StartNew(x =>
{
var h = (ConfigChangeEvent)x;
string methodName;
if (h.Target == null)
{
methodName = h.GetType().Name;
}
else
{
methodName = $"{h.Target.GetType()}.{h.GetType().Name}";
}
try
{
h(this, changeEvent);
}
catch (Exception ex)
{
logger.Error(ex, $"Failed to invoke config change handler {methodName}");
}
}, handler);
}
}
}
public ConfigChangeDeliverTask(IConfigurationListener listener, ConfigChangeEventArgs arguments, string affectedShardName)
{
this.listener = listener;
this.eventArgs = arguments;
//RTD: Temporary - find a better wayyy
this.eventArgs.SetParamValue(EventParamName.ShardName, affectedShardName);
}
protected void FireConfigChange(ConfigChangeEventArgs changeEventCopy)
{
if (ConfigChanged != null)
{
foreach (var @delegate in ConfigChanged.GetInvocationList())
{
var handlerCopy = (ConfigChangeEvent)@delegate;
ExecutorService.StartNew(() =>
{
string methodName;
if (handlerCopy.Target == null)
{
methodName = handlerCopy.Method.Name;
}
else
{
methodName = $"{handlerCopy.Target.GetType()}.{handlerCopy.Method.Name}";
}
try
{
handlerCopy(this, changeEventCopy);
}
catch (Exception ex)
{
Logger.Error($"Failed to invoke config change handler {methodName}", ex);
}
});
}
}
}
protected void FireConfigChange(ConfigChangeEventArgs changeEvent)
{
if (ConfigChanged != null)
{
foreach (ConfigChangeEvent handler in ConfigChanged.GetInvocationList())
{
m_executorService.QueueWorkItem((handlerCopy, changeEventCopy) =>
{
string methodName;
if (handlerCopy.Target == null)
{
methodName = handlerCopy.Method.Name;
}
else
{
methodName = string.Format("{0}.{1}", handlerCopy.Target.GetType(), handlerCopy.Method.Name);
}
try
{
handlerCopy(this, changeEventCopy);
}
catch (Exception ex)
{
logger.Error(string.Format("Failed to invoke config change handler {0}", methodName), ex);
}
}, handler, changeEvent);
}
}
}
private void OnChanged(object sender, ConfigChangeEventArgs changeEvent)
{
foreach (var(key, value) in changeEvent.Changes)
{
Console.WriteLine("Change - key: {0}, oldValue: {1}, newValue: {2}, changeType: {3}",
value.PropertyName, value.OldValue, value.NewValue, value.ChangeType);
}
}
private static void OnChanged(object sender, ConfigChangeEventArgs changeEvent)
{
Console.WriteLine("Changes for namespace {0}", changeEvent.Namespace);
foreach (string key in changeEvent.ChangedKeys)
{
ConfigChange change = changeEvent.GetChange(key);
Console.WriteLine("Change - key: {0}, oldValue: {1}, newValue: {2}, changeType: {3}", change.PropertyName, change.OldValue, change.NewValue, change.ChangeType);
}
}
private void OnChanged(object sender, ConfigChangeEventArgs changeEvent)
{
Console.WriteLine("Changes for namespace {0}", changeEvent.Namespace);
foreach (var change in changeEvent.Changes)
{
Console.WriteLine("Change - key: {0}, oldValue: {1}, newValue: {2}, changeType: {3}",
change.Value.PropertyName, change.Value.OldValue, change.Value.NewValue, change.Value.ChangeType);
}
}
protected void FireConfigChange(ConfigChangeEventArgs changeEvent)
{
if (ConfigChanged != null)
{
foreach (ConfigChangeEvent handler in ConfigChanged.GetInvocationList())
{
//加入线程池执行
ThreadPool.QueueUserWorkItem(state => handler.Invoke(this, changeEvent));
}
}
}
private void OnChanged(object sender, ConfigChangeEventArgs changeEvent)
{
ServiceDiscoveryOptions objServiceDiscovery = JsonConvert.DeserializeObject <ServiceDiscoveryOptions>(_configuration["ServiceDiscovery:content"]);
GlobalObj.ServiceDiscovery = objServiceDiscovery;
Console.WriteLine("Changes for namespace {0}", changeEvent.Config);
foreach (var change in changeEvent.Changes)
{
Console.WriteLine("Change - key: {0}, oldValue: {1}, newValue: {2}, changeType: {3}",
change.Value.PropertyName, change.Value.OldValue, change.Value.NewValue, change.Value.ChangeType);
}
}
private void Config_ConfigChanged(object sender, ConfigChangeEventArgs args)
{
// 更改的配置
foreach (var c in args.Changes)
{
var change = c.Value;
// change.ChangeType
// change.PropertyName
// change.NewValue
// change.OldValue
}
}
private void Config_ConfigChanged(object sender, ConfigChangeEventArgs args)
{
lock (this)
{
var newConfigProperties = CombineProperties();
var actualChanges = UpdateAndCalcConfigChanges(newConfigProperties);
//check double checked result
if (actualChanges.Count == 0)
{
return;
}
FireConfigChange(actualChanges);
}
}
public object OnRequest(IRequest request)
{
try
{
if (request != null)
{
ConfigChangeEventArgs args = (ConfigChangeEventArgs)request.Message;
if (_session != null)
{
_session.NotifyConfigurationChange(args);
}
}
}
catch (ChannelException e)
{
if (LoggerManager.Instance.CONDBLogger != null && LoggerManager.Instance.CONDBLogger.IsErrorEnabled)
{
LoggerManager.Instance.CONDBLogger.Error("Error: OutProcConfigClient.OnRequest()", e.ToString());
}
}
return(null);
}
public void OnMembershipChanged(ConfigChangeEventArgs args)
{
List <string> removableIds = new List <string>();
foreach (ClusterRecoveryJob job in _runningClusteredJobMap.Values)
{
try
{
string cluster = args.GetParamValue <string>(EventParamName.ClusterName);
string shardName = args.GetParamValue <string>(EventParamName.ShardName);
if (job.ActiveConfig.Cluster.Equals(cluster))
{
if (LoggerManager.Instance.RecoveryLogger != null && LoggerManager.Instance.RecoveryLogger.IsInfoEnabled)
{
LoggerManager.Instance.RecoveryLogger.Info("RecoveryManager.CancelOnMembership()", "Canceling job " + job.ActiveConfig.Identifier + " due to membership change of " + shardName);
}
removableIds.Add(job.ActiveConfig.Identifier);
job.Cancel(job.ActiveConfig, shardName);
job.SaveStateToStore();
job.Dispose();
}
}
catch (Exception exp)
{
if (LoggerManager.Instance.RecoveryLogger != null && LoggerManager.Instance.RecoveryLogger.IsErrorEnabled)
{
LoggerManager.Instance.RecoveryLogger.Error("RecoveryManager.CancelOnMembership()", exp.ToString());
}
}
}
foreach (string id in removableIds)
{
_runningClusteredJobMap.Remove(id);
}
}
private void Config_ConfigChanged(object sender, ConfigChangeEventArgs args) => ConfigurationManager.RefreshSection(SectionName);
private void Config_ConfigChanged(IConfig config, ConfigChangeEventArgs args) => ConfigurationManager.RefreshSection(SectionName);
/// <summary>
/// 清理缓存
/// </summary>
/// <param name="sender"></param>
/// <param name="changeEvent"></param>
private static void OnChanged(object sender, ConfigChangeEventArgs changeEvent)
{
// 清理缓存
NamespaceConfigJsonCache.TryRemove(changeEvent.Namespace, out JObject jObject);
}
public void Process()
{
LoggerManager.Instance.SetThreadContext(new LoggerContext()
{
ShardName = context.LocalShardName != null ? context.LocalShardName : "", DatabaseName = ""
});
try
{
this.context.StatusLatch.WaitForAny(NodeStatus.Running);
startSignal.WaitOne();
if (configSession != null)
{
((OutProcConfigurationSession)configSession).RegisterListener(this);
if (clusterInfo == null)
{
clusterInfo = configSession.GetDatabaseClusterInfo(context.ClusterName);
}
if (shardConfig == null)
{
ClusterConfiguration cConfig = configSession.GetDatabaseClusterConfiguration(context.ClusterName);
if (cConfig != null && cConfig.Deployment != null)
{
shardConfig = cConfig.Deployment.GetShard(context.LocalShardName);
}
}
}
while (running)
{
try
{
//To-do: The task should try re-connecting with the CS
ClusterInfo latestInfo = configSession.GetDatabaseClusterInfo(context.ClusterName);
ShardConfiguration latestConfig = null;
ClusterConfiguration cConfig = configSession.GetDatabaseClusterConfiguration(context.ClusterName);
if (cConfig != null && cConfig.Deployment != null)
{
latestConfig = cConfig.Deployment.GetShard(context.LocalShardName);
}
ChangeType type = CheckForClusterInfoConfigChange(clusterInfo, latestInfo);
IList <ConfigChangeParams> changeParams = CheckForLocalShardConfigChange(shardConfig, latestConfig);
if (type != ChangeType.None)
{
clusterInfo = latestInfo;
this._threadPool.ExecuteTask(new ConfigChangeDeliverTask(listener,
new ConfigChangeEventArgs(context.ClusterName, type), affectedShard.Name));
}
if (changeParams != null && changeParams.Count > 0)
{
shardConfig = latestConfig;
foreach (var item in changeParams)
{
ConfigChangeEventArgs args = new ConfigChangeEventArgs();
args.SetParamValue(EventParamName.ShardName, context.LocalShardName);
args.SetParamValue(EventParamName.ClusterName, context.ClusterName);
args.SetParamValue(EventParamName.ConfigurationChangeType, item.ChangeType);
args.SetParamValue(EventParamName.NodeAddress, item.AfftctedNode);
this._threadPool.ExecuteTask(new ConfigChangeDeliverTask(listener,
args, context.LocalShardName));
if (LoggerManager.Instance.ShardLogger != null && LoggerManager.Instance.ShardLogger.IsInfoEnabled)
{
LoggerManager.Instance.ShardLogger.Info("ConfigChangeTask.Run()", "Config change: " + item.ChangeType + " for " + item.AfftctedNode);
}
}
}
}
catch (ThreadAbortException e)
{
if (LoggerManager.Instance.ShardLogger.IsWarnEnabled)
{
LoggerManager.Instance.ShardLogger.Warn("ConfigurationChangeTask.Process", "thread aborted.");
}
_changeTaskThread = null;
break;
}
catch (ManagementException e)
{
if (LoggerManager.Instance.ShardLogger != null && LoggerManager.Instance.ShardLogger.IsErrorEnabled)
{
LoggerManager.Instance.ShardLogger.Error("ConfigurationChangeTask.Process", e.ToString());
}
Pause();
if (LoggerManager.Instance.ShardLogger != null && LoggerManager.Instance.ShardLogger.IsInfoEnabled)
{
LoggerManager.Instance.ShardLogger.Info("ConfigurationChangeTask.Process", "Configuration change task paused.");
}
}
Thread.Sleep(poolingthreshold);
startSignal.WaitOne();
}
}
catch (Exception ex)
{
if (LoggerManager.Instance.ShardLogger.IsErrorEnabled)
{
LoggerManager.Instance.ShardLogger.Error("ConfigurationChangeTask.Process", ex);
}
// RTD: safety check. Needs to be removed later (exception should be caught in the ManagementException section.
if (ex.Message.Contains("No configuration server is available to process the request"))
{
if (!this.IsPaused)
{
this.Pause();
if (LoggerManager.Instance.ShardLogger != null && LoggerManager.Instance.ShardLogger.IsInfoEnabled)
{
LoggerManager.Instance.ShardLogger.Info("ConfigurationChangeTask.Process",
"Configuration change task paused.");
}
}
}
}
finally
{
lock (mutex)
{
running = false;
}
}
}
public void OnConfigurationChanged(ConfigChangeEventArgs arguments)
{
ChangeType type = ChangeType.None;
if (arguments != null)
{
string clusterName = arguments.GetParamValue <string>(EventParamName.ClusterName);
if (clusterName != null && !clusterName.Equals(context.ClusterName))
{
return;
}
type = arguments.GetParamValue <ChangeType>(EventParamName.ConfigurationChangeType);
switch (type)
{
case ChangeType.DistributionStrategyConfigured:
case ChangeType.DatabaseCreated:
case ChangeType.DatabaseDropped:
case ChangeType.CollectionCreated:
case ChangeType.CollectionMoved:
case ChangeType.CollectionDropped:
case ChangeType.ConfigRestored:
case ChangeType.ResyncDatabase:
case ChangeType.IntraShardStateTrxferCompleted:
if (this.configChangeListener != null)
{
configChangeListener.OnConfigurationChanged(arguments);
}
break;
case ChangeType.ConfigurationUpdated:
break;
case ChangeType.ShardAdded:
{
ShardInfo newShard = null;
if (context.ConfigurationSession != null)
{
ClusterInfo latestInfo = context.ConfigurationSession.GetDatabaseClusterInfo(arguments.GetParamValue <string>(EventParamName.ClusterName));
newShard = latestInfo.GetShardInfo(arguments.GetParamValue <string>(EventParamName.ShardName));
}
OnShardAdded(newShard);
if (this._clusterListener != null)
{
_clusterListener.OnShardAdd(newShard);
}
}
break;
case ChangeType.ShardRemovedForceful:
if (this._clusterListener != null)
{
ShardInfo removedShard = new ShardInfo()
{
Name = arguments.GetParamValue <string>(EventParamName.ShardName)
};
_clusterListener.OnShardRemove(removedShard, false);
}
break;
case ChangeType.ShardRemovedGraceful:
if (this._clusterListener != null)
{
ShardInfo removedShard = new ShardInfo()
{
Name = arguments.GetParamValue <string>(EventParamName.ShardName)
};
_clusterListener.OnShardRemove(removedShard, true);
}
break;
case ChangeType.DistributionChanged:
if (this._clusterListener != null)
{
_clusterListener.OnDistributionChanged();
}
break;
//write code for check if the primary has been changed for remote shard(s) connect with the new one
case ChangeType.MembershipChanged:
case ChangeType.PrimarySelected:
case ChangeType.NodeJoined:
// AR: This should be removing the node from the restoration manager of the local shard.
//if (arguments.ConfigurationChangeType == ChangeType.PrimarySelected || arguments.ConfigurationChangeType == ChangeType.PrimaryGone)
//{
// ControlConfigurationChangeTask(arguments);
if (arguments.GetParamValue <ChangeType>(EventParamName.ConfigurationChangeType) == ChangeType.MembershipChanged)
{
HandlePrimaryChangeForRemoteshard(arguments);
}
//}
//if (arguments.ConfigurationChangeType.Equals(ChangeType.PrimarySelected) && arguments.Membership.Primary != null || (arguments.ConfigurationChangeType.Equals(ChangeType.PrimaryGone) && arguments.Membership.Primary == null))
//{
//HandleMembershipChangeForRemoteShard();
//}
//OnMembershipChanged(arguments);
//HandlePrimaryChangeForRemoteshard(arguments);
//HandleMembershipChanged();
break;
case ChangeType.NodeAdded:
case ChangeType.NodeRemoved:
case ChangeType.PriorityChanged:
case ChangeType.NodeLeft:
case ChangeType.PrimaryGone:
if (_localShard != null)
{
((LocalShard)_localShard).OnConfigurationChanged(arguments);
}
break;
case ChangeType.RangeUpdated:
_clusterListener.OnRangesUpdated();
break;
case ChangeType.NewRangeAdded:
_clusterListener.OnNewRangeAdded();
break;
default:
//write code for check if the primary has been changed for remote shard(s) connect with the new one
break;
}
}
}
internal void OnConfigurationChanged(ConfigChangeEventArgs arguments)
{
if (arguments != null && _clusterConfigMgr != null)
{
_clusterConfigMgr.UpdateClusterConfiguration();
Address affectedNode = null;
if (arguments.EventParameters != null && arguments.EventParameters.ContainsKey(EventParamName.NodeAddress))
{
affectedNode = arguments.GetParamValue <Address>(EventParamName.NodeAddress);
}
ChangeType type = arguments.GetParamValue <ChangeType>(EventParamName.ConfigurationChangeType);
if ((type != ChangeType.NodeLeft && type != ChangeType.PrimaryGone) && affectedNode == null)
{
return;
}
if (_membershipManager != null)
{
switch (type)
{
//RTD: look for a better way to handle this scenario.
case ChangeType.NodeAdded:
_membershipManager.OnMemberJoined(new Server(affectedNode, Status.Running));
break;
case ChangeType.NodeRemoved:
_membershipManager.OnMemberLeft(new Server(affectedNode, Status.Running));
break;
case ChangeType.PriorityChanged:
_membershipManager.SanityCheckForTakeoverElect();
break;
case ChangeType.NodeLeft:
//this is the event received by the CS when the leaving node is a primary. Tada-- Why
case ChangeType.PrimaryGone:
Membership membership = null;
if (arguments.EventParameters.ContainsKey(EventParamName.Membership))
{
membership = arguments.GetParamValue <Membership>(EventParamName.Membership);
}
if (membership != null && membership.Servers != null)
{
ShardConfiguration sConfig = _clusterConfigMgr.GetShardConfiguration(context.LocalShardName);
if (sConfig != null && sConfig.Servers != null)
{
foreach (KeyValuePair <string, ServerNode> node in sConfig.Servers.Nodes)
{
if (!membership.Servers.Contains(node.Value))
{
affectedNode = new Address(node.Value.Name, sConfig.Port);
break;
}
}
}
if (affectedNode != null && _shardChannels != null && !_shardChannels.ContainsKey(new Server(affectedNode, Status.Running)))
{
_membershipManager.OnActivityTriggered(Activity.NodeLeaving, affectedNode);
_membershipManager.OnMemberLeft(new Server(affectedNode, Status.Running));
_membershipManager.OnActivityComplete();
}
}
break;
}
}
}
}
//private void OnMembershipChanged(ConfigChangeEventArgs args)
//{
// // needs to be reviewed. Esp for the remote shard purposes.
// //Refactoring required.
// //if (_localShard != null)
// // _localShard.OnMembershipChanged(args);
// if (args.ConfigurationChangeType.Equals(ChangeType.PrimarySelected) && args.Membership.Primary != null || (args.ConfigurationChangeType.Equals(ChangeType.PrimaryGone) && args.Membership.Primary==null))
// {
// HandlePrimaryChangeForRemoteshard(args);
// //HandleMembershipChangeForRemoteShard();
// }
//}
private void HandlePrimaryChangeForRemoteshard(ConfigChangeEventArgs args)
{
try
{
if (_localShard.NodeRole == NodeRole.Primary)
{
if (_remoteShards != null && _remoteShards.Count > 0)
{
string clusterName = args.GetParamValue <string>(EventParamName.ClusterName);
string shardName = args.GetParamValue <string>(EventParamName.ShardName);
if (clusterName == null || shardName == null)
{
return;
}
foreach (KeyValuePair <String, IShard> remoteShard in _remoteShards)
{
if (args != null && clusterName == this.context.ClusterName &&
shardName == remoteShard.Key)
{
if (remoteShard.Value != null)
{
//if (!((RemoteShard)remoteShard.Value).IsStarted)
// remoteShard.Value.Start();
//else
//{
if (context.ConfigurationSession != null)
{
//RTD: Should the dependency on CS be removed?
ClusterInfo latestInfo =
context.ConfigurationSession.GetDatabaseClusterInfo(context.ClusterName);
ShardInfo latestShard = null;
if (latestInfo != null)
{
latestShard = latestInfo.GetShardInfo(remoteShard.Key);
}
if (latestShard != null)
{
((RemoteShard)remoteShard.Value).OnPrimaryChanged(latestShard.Primary,
latestShard.Port);
}
}
//}
break;
}
}
}
}
//if (context.ConfigurationSession != null)
//{
// ClusterInfo latestInfo = context.ConfigurationSession.GetDatabaseClusterInfo(context.ClusterName);
// ShardInfo[] latestShards = latestInfo.ShardInfo;
// if (latestShards.Length > 1)
// {
// foreach (ShardInfo info in latestShards)
// {
// if (info.Name != context.LocalShardName)
// {
// RemoteShard remoteShard = _remoteShards[info.Name] as RemoteShard;
// if (remoteShard != null)
// remoteShard.OnPrimaryChanged(info.Primary, info.Port);
// }
// }
// }
//}
}
}
catch (Exception ex)
{
if (LoggerManager.Instance.ServerLogger != null && LoggerManager.Instance.ServerLogger.IsErrorEnabled)
{
LoggerManager.Instance.ServerLogger.Error("ClusterManager.HandlePrimaryChangedForRemoteshard() ", "HandlePrimaryChangeForRemoteshard :" + ex);
}
}
}
