void ISubscriptionStorage.Unsubscribe(Address client, Type messageType) { if (_storage.ContainsKey(messageType)) { _storage[messageType].Remove(client); } }
public void Unsubscribe(Address address, Type messageType) { if (_subscriptionDictionary.ContainsKey(messageType) && _subscriptionDictionary[messageType].Contains(address)) { _subscriptionDictionary[messageType].Remove(address); } }
public void Subscribe(Address address, Type messageType) { using (var session = _sessionFactory.OpenSession()) { var criteria = session.CreateCriteria<Subscription>(); var subscriberAddress = address.ToString(); var messageTypeName = messageType.AssemblyQualifiedName; criteria.Add(Expression.Eq("SubscriberAddress", subscriberAddress)); criteria.Add(Expression.Eq("MessageType", messageTypeName)); var subscription = criteria.UniqueResult<Subscription>(); if (subscription == null) { subscription = new Subscription { UniqueId = Guid.NewGuid().ToString(), SubscriberAddress = subscriberAddress, MessageType = messageTypeName }; session.Save(subscription); session.Flush(); _memoryStore.Subscribe(address, messageType); _logger.DebugFormat("Subscriber '{0}' subscribes message '{1}'.", subscriberAddress, messageTypeName); } } }
void IMessageTransport.Init(Address address) { if (address == null) { throw new ArgumentNullException("address"); } var machine = address.Machine; if (machine.ToLower() != Environment.MachineName.ToLower()) { throw new InvalidOperationException( string.Format("Input queue [{0}] must be on the same machine as this process [{1}].", address, Environment.MachineName.ToLower())); } var fullPath = MsmqUtilities.GetFullPathWithoutPrefix(address); if (MessageQueue.Exists(fullPath)) { _messageQueue = new MessageQueue(fullPath); } else { _messageQueue = MessageQueue.Create(fullPath); } var mpf = new MessagePropertyFilter(); mpf.SetAll(); _messageQueue.MessageReadPropertyFilter = mpf; if (PurgeOnStartup) { _messageQueue.Purge(); } }
public void ClearAddressSubscriptions(Address address) { using (var connection = _connectionFactory.OpenConnection()) { var subscriberAddress = address.ToString(); var table = Configuration.Instance.GetSetting<string>("subscriptionTable"); connection.Delete(new { SubscriberAddress = subscriberAddress }, table); _memoryStore.ClearAddressSubscriptions(address); _logger.DebugFormat("Cleaned up subscriptions of subscriber address '{0}'", subscriberAddress); } }
public void Subscribe(Address address, Type messageType) { if (!_subscriptionDictionary.ContainsKey(messageType)) { _subscriptionDictionary[messageType] = new List<Address>(); } if (!_subscriptionDictionary[messageType].Contains(address)) { _subscriptionDictionary[messageType].Add(address); } }
void ISubscriptionStorage.Subscribe(Address client, Type messageType) { if (!_storage.ContainsKey(messageType)) { _storage[messageType] = new List<Address>(); } if (!_storage[messageType].Contains(client)) { _storage[messageType].Add(client); } }
public void ClearAddressSubscriptions(Address address) { foreach (var messageType in _subscriptionDictionary.Keys) { var addressArray = new Address[_subscriptionDictionary[messageType].Count]; _subscriptionDictionary[messageType].CopyTo(addressArray); foreach (var subscriberAddress in addressArray) { if (subscriberAddress == address) { _subscriptionDictionary[messageType].Remove(subscriberAddress); } } } }
public void Subscribe(Address address, Type messageType) { using (var connection = _connectionFactory.OpenConnection()) { var subscriberAddress = address.ToString(); var messageTypeName = messageType.AssemblyQualifiedName; var table = Configuration.Instance.GetSetting<string>("subscriptionTable"); var count = connection.GetCount(new { SubscriberAddress = subscriberAddress, MessageType = messageTypeName }, table); if (count == 0) { connection.Insert(new { UniqueId = Guid.NewGuid(), SubscriberAddress = subscriberAddress, MessageType = messageTypeName }, table); _memoryStore.Subscribe(address, messageType); _logger.DebugFormat("Subscriber '{0}' subscribes message '{1}'.", subscriberAddress, messageTypeName); } } }
public void ClearAddressSubscriptions(Address address) { using (var session = _sessionFactory.OpenSession()) { var criteria = session.CreateCriteria<Subscription>(); var subscriberAddress = address.ToString(); criteria.Add(Expression.Eq("SubscriberAddress", subscriberAddress)); var subscriptions = criteria.List<Subscription>(); foreach (var subscription in subscriptions) { session.Delete(subscription); } session.Flush(); _memoryStore.ClearAddressSubscriptions(address); _logger.DebugFormat("Cleaned up subscriptions of subscriber address '{0}'", subscriberAddress); } }
public void Unsubscribe(Address address, Type messageType) { using (var connection = _connectionFactory.OpenConnection()) { var subscriberAddress = address.ToString(); var messageTypeName = messageType.AssemblyQualifiedName; var table = Configuration.Instance.GetSetting<string>("subscriptionTable"); connection.Delete(new { SubscriberAddress = subscriberAddress, MessageType = messageTypeName }, table); _memoryStore.Unsubscribe(address, messageType); _logger.DebugFormat("Subscriber '{0}' unsubscribes message '{1}'.", subscriberAddress, messageTypeName); } }
void IMessageTransport.SendMessage(Message message, Address targetAddress) { if (message == null) { throw new ArgumentNullException("message"); } if (targetAddress == null) { throw new ArgumentNullException("targetAddress"); } var queuePath = MsmqUtilities.GetFullPath(targetAddress); try { using (var messageQueue = new MessageQueue(queuePath, QueueAccessMode.SendAndReceive)) { var msmqMessage = MsmqUtilities.Convert(message); messageQueue.Send(msmqMessage, MessageQueueTransactionType.Automatic); message.Id = msmqMessage.Id; } } catch (MessageQueueException ex) { if (ex.MessageQueueErrorCode == MessageQueueErrorCode.QueueNotFound) { _logger.Error(string.Format("消息队列未找到: [{0}]", targetAddress), ex); throw; } else { _logger.Error(string.Format("发送消息到队列时遇到异常,队列地址:{0}", targetAddress), ex); throw; } } catch (Exception ex) { _logger.Error(string.Format("发送消息到队列时遇到异常,队列地址:{0}", targetAddress), ex); throw; } }
void IMessageTransport.SendMessage(Message message, Address targetAddress) { if (message == null) { throw new ArgumentNullException("message"); } if (targetAddress == null) { throw new ArgumentNullException("targetAddress"); } var queuePath = MsmqUtilities.GetFullPath(targetAddress); try { using (var messageQueue = new MessageQueue(queuePath, QueueAccessMode.SendAndReceive)) { var toSend = MsmqUtilities.Convert(message); if (message.ReplyToAddress != null) { toSend.ResponseQueue = new MessageQueue(MsmqUtilities.GetReturnAddress(message.ReplyToAddress.ToString(), targetAddress.ToString())); } messageQueue.Send(toSend, MessageQueueTransactionType.Automatic); message.Id = toSend.Id; } } catch (MessageQueueException ex) { if (ex.MessageQueueErrorCode == MessageQueueErrorCode.QueueNotFound) { throw new EventSourcingException("消息队列未找到: [{0}]", targetAddress); } else { throw new EventSourcingException("发送消息到队列时遇到异常,队列地址:{0},异常详情:{1}", targetAddress, ex); } } catch (Exception ex) { throw new EventSourcingException("发送消息到队列时遇到异常,队列地址:{0},异常详情:{1}", targetAddress, ex); } }
/// <summary> /// Check this is equal to other Address /// </summary> /// <param name="other">refrence addressed to be checked with this</param> /// <returns>true if this is equal to other</returns> public bool Equals(Address other) { if (ReferenceEquals(null, other)) return false; if (ReferenceEquals(this, other)) return true; return Equals(other.Queue, Queue) && Equals(other.Machine, Machine); }
/// <summary> /// Gets the name of the return address from the provided value. /// If the target includes a machine name, uses the local machine name in the returned value /// otherwise uses the local IP address in the returned value. /// </summary> /// <param name="value"></param> /// <param name="target"></param> /// <returns></returns> public static string GetReturnAddress(Address value, Address target) { var machine = target.Machine; IPAddress targetIpAddress; //see if the target is an IP address, if so, get our own local ip address if (IPAddress.TryParse(machine, out targetIpAddress)) { if (string.IsNullOrEmpty(localIp)) { localIp = LocalIpAddress(targetIpAddress); } return PREFIX_TCP + localIp + PRIVATE + value.Queue; } return PREFIX + GetFullPathWithoutPrefix(value); }
/// <summary> /// Returns the full path without Format or direct os /// from an address. /// </summary> /// <param name="address"></param> /// <returns></returns> public static string GetFullPathWithoutPrefix(Address address) { return address.Machine + PRIVATE + address.Queue; }
/// <summary> /// Turns a '@' separated value into a full path. /// Format is 'queue@machine', or 'queue@ipaddress' /// </summary> /// <param name="value"></param> /// <returns></returns> public static string GetFullPath(Address value) { IPAddress ipAddress; if (IPAddress.TryParse(value.Machine, out ipAddress)) { return PREFIX_TCP + GetFullPathWithoutPrefix(value); } return PREFIX + GetFullPathWithoutPrefix(value); }
///<summary> /// Utility method for creating a queue if it does not exist. ///</summary> ///<param name="address"></param> ///<param name="account">The account to be given permissions to the queue</param> public static void CreateQueueIfNecessary(Address address, string account) { if (address == null) return; var q = GetFullPathWithoutPrefix(address); var isRemote = address.Machine != Environment.MachineName.ToLower(); if (isRemote) { _logger.Debug("Queue is on remote machine."); _logger.Debug("If this does not succeed (like if the remote machine is disconnected), processing will continue."); } _logger.Debug(string.Format("Checking if queue exists: {0}.", address)); try { if (MessageQueue.Exists(q)) { _logger.Debug("Queue exists, going to set permissions."); SetPermissionsForQueue(q, accountToBeAssignedQueuePermissions ?? account); return; } _logger.Warn("Queue " + q + " does not exist."); _logger.Debug("Going to create queue: " + q); CreateQueue(q, account); } catch (MessageQueueException ex) { if (isRemote && (ex.MessageQueueErrorCode == MessageQueueErrorCode.IllegalQueuePathName)) { return; } _logger.Error(string.Format("Could not create queue {0} or check its existence. Processing will still continue.", address), ex); } catch (Exception ex) { _logger.Error(string.Format("Could not create queue {0} or check its existence. Processing will still continue.", address), ex); } }