internal ChannelMessageReader(
IChannelMessageStream channelMessageStream,
IChannelMessageSerializer channelMessageSerializer,
IChannelMessageHandler inboundHandler,
ITaskLauncher taskLauncher)
{
if (channelMessageStream == null)
{
throw new ArgumentNullException(nameof(channelMessageStream));
}
if (channelMessageSerializer == null)
{
throw new ArgumentNullException(nameof(channelMessageSerializer));
}
if (inboundHandler == null)
{
throw new ArgumentNullException(nameof(inboundHandler));
}
if (taskLauncher == null)
{
throw new ArgumentNullException(nameof(taskLauncher));
}
m_ChannelMessageStream = channelMessageStream;
m_ChannelMessageSerializer = channelMessageSerializer;
m_InboundHandler = inboundHandler;
m_TaskLauncher = taskLauncher;
}
public void Unsubscribe(string routingKey)
{
lock (_AccessLock)
{
if (_RoutedMessageHandlers.ContainsKey(routingKey))
{
IChannelMessageHandler channelMessageHandler = OperationContext.Current.GetCallbackChannel <IChannelMessageHandler>();
_Log.Info("Successfully removed client " + ((IClientChannel)channelMessageHandler).LocalAddress.Uri.ToString() + " from routing key " + routingKey);
_RoutedMessageHandlers[routingKey].RemoveChannelMessageHandler(channelMessageHandler);
}
}
}
public SlaveTaskManager(IChannelMessageHandler channelMessageHandler)
{
_channelMessageHandler = channelMessageHandler;
_defaultWorker = Worker.Worker.GetDefaultWorker();
_slaveCacheList = new ConcurrentDictionary <string, DownTransmission>();
_slaveCache = new SlaveCache();
LoadCache();
_excuteCalcThread = new Thread(new ThreadStart(ExcuteCalcThread));
_excuteCalcThread.Name = "ExcuteCalcThread";
_excuteCalcThread.IsBackground = true;
_excuteCalcThread.Start();
}
/// <summary>
/// Connects a client to an exchange.
/// </summary>
public void Connect()
{
IChannelMessageHandler channelMessageHandler = OperationContext.Current.GetCallbackChannel <IChannelMessageHandler>();
lock (_AccessLock)
{
if (!_ConnectedEndpoints.Contains(channelMessageHandler))
{
((IClientChannel)channelMessageHandler).Faulted += new EventHandler(Exchange_Closed);
((IClientChannel)channelMessageHandler).Closed += new EventHandler(Exchange_Closed);
_ConnectedEndpoints.Add(channelMessageHandler);
_Log.Info("Successfully connected to client " + ((IClientChannel)channelMessageHandler).LocalAddress.Uri.ToString());
}
InvokeChannelMessageHandlerAction(p => p.OnAdminMessageReceived(AdminMessageType.ConnectionEstablished, null), channelMessageHandler);
}
}
public MasterTaskManager(IChannelMessageHandler channelMessageHandler)
{
_channelMessageHandler = channelMessageHandler;
_winList = new ConcurrentDictionary <string, IWindowTask>();
_expList = new ConcurrentDictionary <string, IExpressionTask>();
_workList = new ConcurrentDictionary <string, IWorker>();
_masterCacheList = new ConcurrentDictionary <string, byte[]>();
_masterCache = new MasterCache();
_context = new GlobalContext(new ActionBlock <ICalculateContext>(ParallelCalculate, new ExecutionDataflowBlockOptions()
{
MaxDegreeOfParallelism = GlobalConfig.Config.MaxDegreeOfParallelism
}));
LoadCache();
_remoteInvokeThread = new Thread(new ThreadStart(RemoteInvokeThread));
_remoteInvokeThread.Name = "RemoteInvokeThread";
_remoteInvokeThread.IsBackground = true;
_remoteInvokeThread.Start();
}
private void Disconnect(IChannelMessageHandler channelMessageHandler)
{
if (channelMessageHandler != null)
{
lock (_AccessLock)
{
if (!_ConnectedEndpoints.Contains(channelMessageHandler))
{
return;
}
_Log.Info("Disconnecting client " + ((IClientChannel)channelMessageHandler).LocalAddress.Uri.ToString());
foreach (RoutedMessageHandler RoutedMessageHandler in _RoutedMessageHandlers.Values)
{
RoutedMessageHandler.RemoveChannelMessageHandler(channelMessageHandler);
}
_ConnectedEndpoints.Remove(channelMessageHandler);
_Log.Info("Client " + ((IClientChannel)channelMessageHandler).LocalAddress.Uri.ToString() + " disconnected");
}
}
}
public void AddChannelMessageHandler(IChannelMessageHandler channelMessageHandler)
{
_MessageHandlers.Add(channelMessageHandler);
}
public void RemoveChannelMessageHandler(IChannelMessageHandler channelMessageHandler)
{
_MessageHandlers.Remove(channelMessageHandler);
}
private void InvokeChannelMessageHandlerAction(Action <IChannelMessageHandler> action, IChannelMessageHandler channelMessageHandler)
{
try
{
action.Invoke(channelMessageHandler);
}
catch (CommunicationException ex)
{
_Log.Error("An error occurred while communicating with the client", ex);
Disconnect(channelMessageHandler);
}
catch (TimeoutException ex)
{
_Log.Error("An error occurred while communicating with the server", ex);
Disconnect(channelMessageHandler);
}
catch (Exception ex)
{
_Log.Error("An error occurred while communicating with the server", ex);
Disconnect(channelMessageHandler);
}
}
public MasterMessageHandler(IChannelMessageHandler ms)
{
_mh = ms;
}
public SlaveMessageHandler(IChannelMessageHandler mh)
{
_mh = mh;
}
