public override List <ClientId> GetAllClientsIds() { List <ClientId> result = new List <ClientId>(); foreach (MessageBusClient client in this._clientsHotSwap) { if (client == null) {// This is normal since items are never removed from list, only set to null. continue; } ClientId id = client.Id; if (id != null) { result.Add(id); } } return(result); }
/// <summary> /// Actually supply the item to client. /// </summary> /// <param name="senderId"></param> /// <param name="receiverId"></param> /// <param name="envelope"></param> /// <param name="requestConfirm">In local mode we have receival confirmation, so this value is ignored here (as result is always assured true).</param> /// <returns></returns> protected virtual SendToClientResultEnum DoSendToClient(ClientId senderId, ClientId receiverId, Envelope envelope, TimeSpan?requestConfirmTimeout) { if (receiverId.MessageBus != this) { //// Maybe this is a "lost" id, try to see if it is one of ours. //if (receiverId.MessageBus == null && _guidToIndexHotSwap.ContainsKey(receiverId.Guid)) //{// Yes! // receiverId.MessageBus = this; //} return(SendToClientResultEnum.ClientNotFound); } MessageBusClient client = GetLocalClientByIndex(receiverId.LocalMessageBusIndex); if (client == null) { return(SendToClientResultEnum.ClientNotFound); } ISerializer serializer = _serializer; if (serializer == null) { return(SendToClientResultEnum.Failure); } // Duplicate what (if anything) as according to envelope duplication model. envelope = envelope.Duplicate(serializer); envelope.History.PushStamp(new EnvelopeStamp(PendingStampId, receiverId, senderId)); if (client.Receive(envelope)) { return(SendToClientResultEnum.Success); } else { return(SendToClientResultEnum.Failure); } }
/// <summary> /// Needs to consume both client and id, since it may be used with client == null. /// </summary> /// <returns>The index of the newly registered client, or InvalidClientIndex on failure.</returns> protected int DoAddClient(MessageBusClient client, ClientId clientId) { int index = 0; if (client != null && client.Id.Equals(clientId) == false) { #if Matrix_Diagnostics InstanceMonitor.Error("Client id mismatch."); #endif return(ClientId.InvalidMessageBusClientIndex); } lock (_syncRoot) { if (clientId.LocalMessageBusIndex != ClientId.InvalidMessageBusClientIndex) {// Client already has an Index assigned, must reuse it. MessageBusClient existingInstance = null; if (_clientsHotSwap.TryGetValue(clientId.LocalMessageBusIndex, ref existingInstance)) {// Successfully acquired existing value for client. // Check if we are OK to assign to this position. if (existingInstance != null && existingInstance != client) {// There is something else at that position. #if Matrix_Diagnostics InstanceMonitor.Error("Client id mismatch."); #endif return(ClientId.InvalidMessageBusClientIndex); } } else {// Failed to acquire value with this message bus index. #if Matrix_Diagnostics InstanceMonitor.Error("Client with this message bus index can not be assigned."); #endif return(ClientId.InvalidMessageBusClientIndex); } // Assign the client to its former spot. _clientsHotSwap[clientId.LocalMessageBusIndex] = client; index = clientId.LocalMessageBusIndex; } else { if (GetClientIndexByGuid(clientId.Guid) >= 0) {// Already added. #if Matrix_Diagnostics InstanceMonitor.Error("Message bus client [" + clientId.ToString() + "] added more than once."); #endif return(ClientId.InvalidMessageBusClientIndex); } // Add the client to a new spot. _clientsHotSwap.Add(client); index = _clientsHotSwap.Count - 1; } // This type of assignment will also work with multiple entries. // This performs an internal hotswap. _guidToIndexHotSwap[clientId.Guid] = index; } if (client != null && client.AssignMessageBus(this, index) == false) { #if Matrix_Diagnostics InstanceMonitor.OperationError("A client has denied adding to Message bus."); #endif RemoveClient(client, true); return(ClientId.InvalidMessageBusClientIndex); } client.UpdateEvent += new MessageBusClient.ClientUpdateDelegate(client_UpdateEvent); RaiseClientAddedEvent(clientId); return(index); }
/// <summary> /// /// </summary> public override bool ContainsClient(ClientId clientId) { return(_guidToIndexHotSwap.ContainsKey(clientId.Guid)); }
protected abstract Outcomes DoSend(ClientId senderIndex, IEnumerable <ClientId> receiversIndeces, Envelope envelope, TimeSpan?requestConfirmTimeout, bool showErrorsDiagnostics);
/// <summary> /// Send an item to a single repicient. /// </summary> /// <returns></returns> public Outcomes Send(ClientId senderId, ClientId receiverId, Envelope envelope, TimeSpan?requestConfirmTimeout, bool showErrorsDiagnostics) { return(Send(senderId, new ClientId[] { receiverId }, envelope, requestConfirmTimeout, showErrorsDiagnostics)); }
/// <summary> /// Send an item to multiple recipients. /// </summary> public Outcomes Send(ClientId senderId, IEnumerable <ClientId> receiversIds, Envelope envelope, TimeSpan?requestConfirmTimeout, bool showErrorsDiagnostics) { return(DoSend(senderId, receiversIds, envelope, requestConfirmTimeout, showErrorsDiagnostics)); }
/// <summary> /// Obtain an instance of the client, in case it is a local client /// and the instance is accessible. This will not work for remote /// (network) associated clients. /// </summary> public abstract MessageBusClient GetLocalClientInstance(ClientId clientId);
public abstract List <string> GetClientSourceTypes(ClientId clientId);
public abstract Type GetClientType(ClientId clientId);
public abstract bool ContainsClient(ClientId client);
/// <summary> /// Constructor. /// </summary> public EnvelopeStamp(long stampId, ClientId receiverId, ClientId senderId) { _stampId = stampId; _receiverId = receiverId; _senderId = senderId; }