Inheritance: ISerializable
 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);
            }
        }
Example #14
0
 /// <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);
 }
Example #15
0
        /// <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);
        }
Example #16
0
 /// <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;
 }
Example #17
0
 /// <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);
 }
Example #18
0
        ///<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);
            }
        }