private void toolStripButtonCall_Click(object sender, EventArgs e)
{
Report("Sending work to server ...");
// This will send a shout call to all those visible on the current super pool, that implement the interface.
// Since we are single client on the local super pool, and connected to the server super pool, the call
// will be sent to the server.
_poolClient.CallAll <ICommunicationInterface>().DoWork(string.Format("Client[{0}] sends work [{1}].", this.ClientName, toolStripTextBox1.Text));
}
/// <summary>
/// Handle event subscription (Proxy.Event.Subscribe)
/// </summary>
protected override void ProcessReceiveEventSubscription(int methodId, Delegate delegateInstance, bool isAdd)
{
SuperPoolProxyCall pendingCall = null;
if (_pendingThreadsCalls.TryGetValue(Thread.CurrentThread.ManagedThreadId, out pendingCall) == false)
{
#if Matrix_Diagnostics
InstanceMonitor.OperationError("Failed to find corresponding thread proxy call information.");
#endif
return;
}
EventSubscriptionRequest subscriptionRequest = pendingCall.SubscriptionRequest;
if (subscriptionRequest == null)
{
#if Matrix_Diagnostics
InstanceMonitor.OperationError("Failed to find corresponding subscription requests, event subscription failed.");
#endif
return;
}
if (pendingCall.Sender == null || pendingCall.Sender.Id == null)
{
#if Matrix_Diagnostics
InstanceMonitor.OperationError("Failed to establish subscription sender information, subscription failed.");
#endif
return;
}
if (delegateInstance.Target != pendingCall.Sender.Source)
{
#if Matrix_Diagnostics
InstanceMonitor.Error("Only a message super pool client source can subscribe to events.");
#endif
return;
}
ProxyTypeBuilder builder = ProxyTypeBuilder;
if (builder == null)
{
#if Matrix_Diagnostics
InstanceMonitor.OperationError("Failed to find proxy type builder, event subscription failed.");
#endif
return;
}
GeneratedMethodInfo generatedMethodInfo = builder.GetMethodInfoById(methodId);
if (generatedMethodInfo == null)
{
#if Matrix_Diagnostics
InstanceMonitor.OperationError("Failed to find method [id, " + methodId + "] info, event subscription failed.");
#endif
return;
}
if (string.IsNullOrEmpty(generatedMethodInfo.EventName))
{
generatedMethodInfo.EventName = GeneralHelper.GetEventExtendedNameByMethod(generatedMethodInfo.GetMethodInfo(), false, true);
}
// generatedMethodInfo.GetMethodInfo() >> I2.add_AEVent
string extendedEventName = generatedMethodInfo.EventName;
MethodInfo eventAddMethodInfo = generatedMethodInfo.GetMethodInfo();
// *IMPORTANT* the Call<> will cause the currently used pendingCall to be repopulated with information,
// so we ned to extract the *sender id* BEFORE calling the actual Call(), since it will change the
// pendingCall instance immediately.
subscriptionRequest.SenderId = pendingCall.Sender.Id;
subscriptionRequest.ExtendedEventName = extendedEventName;
subscriptionRequest.IsAdd = isAdd;
//subscriptionRequest.EventAddMethodInfo = eventAddMethodInfo;
subscriptionRequest.DelegateInstanceMethodInfo = delegateInstance.Method;
// Process locally.
((ISuperPoolIntercom)this).ProcessSubscriptionUpdate(subscriptionRequest);
SuperPoolClient mainClient = IntercomClient;
if (mainClient == null)
{
#if Matrix_Diagnostics
InstanceMonitor.Error("Failed to obtain super pool main intercom client, so new client handling has failed.");
#endif
}
else
{
// Notify other connected super pools of this subcription,
// since the subscribee(s) may be attached on them.
// *pendingCall swap done here, make sure to not use it on or after this line*
mainClient.CallAll <ISuperPoolIntercom>().ProcessSubscriptionUpdate(subscriptionRequest);
}
}
protected override bool HandleClientAdded(IMessageBus messageBus, ClientId clientId)
{
// Make sure to have this done first, since it will send notifications of clients, and we
// may need those for the establishment of events.
if (base.HandleClientAdded(messageBus, clientId) == false || messageBus == null || clientId == null)
{
return(false);
}
MessageBusClient clientInstance = messageBus.GetLocalClientInstance(clientId);
// Will only work for local AND MessageSuperPoolClient typed clients.
if (clientInstance is SuperPoolClient)
{
lock (_syncRoot)
{
if (_clients.ContainsKey(clientInstance.Id))
{// Already added.
return(false);
}
ClientEventsHandler subscription = new ClientEventsHandler(this, (SuperPoolClient)clientInstance);
_clients.Add(clientInstance.Id, subscription);
}
}
else
{
List <string> sourceTypeNames = messageBus.GetClientSourceTypes(clientId);
if (sourceTypeNames == null)
{
#if Matrix_Diagnostics
InstanceMonitor.Error("Failed to obtain client [" + clientId.ToString() + "] source type.");
#endif
return(false);
}
SuperPoolClient intercomClient = IntercomClient;
if (intercomClient == null)
{
#if Matrix_Diagnostics
InstanceMonitor.Error("Failed to obtain super pool main intercom client, so new client handling has failed.");
#endif
return(false);
}
List <EventSubscriptionRequest> totalRequests = new List <EventSubscriptionRequest>();
if (clientId.IsLocalClientId == false)
{
// Gather all the Super Pool related interfaces and their events, and send global updates for those
// so that any pending subscriptions may be restored.
// This is only done where the client is a remote client instance, since local ones we already know
// of them. This eventing information must be at the local pool for the client, since it is the one
// handling the event and sending it to all interested parties.
foreach (Type interfaceType in ReflectionHelper.GetKnownTypes(sourceTypeNames))
{
if (interfaceType.IsInterface &&
ReflectionHelper.TypeHasCustomAttribute(interfaceType, typeof(SuperPoolInterfaceAttribute), false) == false)
{// Interface type not marked as super pool.
continue;
}
foreach (EventInfo info in interfaceType.GetEvents())
{
string eventName = GeneralHelper.GetEventMethodExtendedName(info, false);
EventSubscriptionInfo eventInfo;
if (_eventSubscriptions.TryGetValue(eventName, out eventInfo))
{
totalRequests.AddRange(eventInfo.GatherSourceRelatedUpdates(clientId));
}
}
}
}
// Send updates for the newly connected client, so that it can obtain any subscription information
// regarding it, it case it has missed some.
foreach (EventSubscriptionRequest request in totalRequests)
{
// Notify other connected super pools of this subcription,
// since the subscribee(s) may be attached on them.
// *pendingCall swap done here, make sure to not use it on or after this line*
intercomClient.CallAll <ISuperPoolIntercom>().ProcessSubscriptionUpdate(request);
}
}
return(true);
}
private void toolStripButtonCall_Click(object sender, EventArgs e)
{
Report("Sending work to all clients...");
_poolClient.CallAll <ICommunicationInterface>().DoWork(toolStripTextBoxWorkParameter.Text);
}