Exemplo n.º 1
0
        void ISubscriptionStorage.Init()
        {
            var path = MsmqUtilities.GetFullPath(Queue);

            q = new MessageQueue(path);

            bool transactional;
            try
            {
                transactional = q.Transactional;
            }
            catch (Exception ex)
            {
                throw new ArgumentException(string.Format("There is a problem with the subscription storage queue {0}. See enclosed exception for details.", Queue), ex);
            }

            if (!transactional && TransactionsEnabled)
                throw new ArgumentException("Queue must be transactional (" + Queue + ").");

            var messageReadPropertyFilter = new MessagePropertyFilter { Id = true, Body = true, Label = true };

            q.Formatter = new XmlMessageFormatter(new[] { typeof(string) });

            q.MessageReadPropertyFilter = messageReadPropertyFilter;

            foreach (var m in q.GetAllMessages())
            {
                var subscriber = Address.Parse(m.Label);
                var messageTypeString = m.Body as string;
                var messageType = new MessageType(messageTypeString); //this will parse both 2.6 and 3.0 type strings

                entries.Add(new Entry { MessageType = messageType, Subscriber = subscriber });
                AddToLookup(subscriber, messageType, m.Id);
            }
        }
Exemplo n.º 2
0
        public MsmqReceiver()
        {
            if (!Address.Local.Machine.Equals(RuntimeEnvironment.MachineName, StringComparison.OrdinalIgnoreCase))
            {
                throw new InvalidOperationException(String.Format("Input queue [{0}] must be on the same machine as this process [{1}].", Address.Local, RuntimeEnvironment.MachineName));
            }

            queue = new MessageQueue(MsmqUtilities.GetFullPath(Address.Local), false, true, QueueAccessMode.Receive);

            var messageReadPropertyFilter = new MessagePropertyFilter
            {
                Body = true,
                TimeToBeReceived = true,
                Recoverable = true,
                Id = true,
                ResponseQueue = true,
                CorrelationId = true,
                Extension = true,
                AppSpecific = true
            };

            queue.MessageReadPropertyFilter = messageReadPropertyFilter;

            if (PurgeOnStartup)
            {
                queue.Purge();
            }
        }
        public void Init()
        {
            lock (lockObj)
            {
                if (storageQueue != null)
                {
                    return;
                }

                var storageQueueAddress = configure.LocalAddress.SubScope("distributor.storage");
                var path = MsmqUtilities.GetFullPath(storageQueueAddress);
                var messageReadPropertyFilter = new MessagePropertyFilter
                {
                    Id = true,
                    Label = true,
                    ResponseQueue = true,
                };

                storageQueue = new MessageQueue(path, false, true, QueueAccessMode.SendAndReceive)
                {
                    MessageReadPropertyFilter = messageReadPropertyFilter
                };

                if ((!storageQueue.Transactional) && (configure.Settings.Get<bool>("Transactions.Enabled")))
                {
                    throw new Exception(string.Format("Queue [{0}] must be transactional.", path));
                }
            }
        }
 public static void ReturnMessageToSourceQueue(string errorQueueMachine, string errorQueueName, string msmqMessageId)
 {
     string path = string.Format(@"{0}\private$\{1}", errorQueueMachine, errorQueueName);
     MessageQueue errorQueue = new MessageQueue(path);
     {
         MessagePropertyFilter messageReadPropertyFilter = new MessagePropertyFilter
         {
             Body = true,
             TimeToBeReceived = true,
             Recoverable = true,
             Id = true,
             ResponseQueue = true,
             CorrelationId = true,
             Extension = true,
             AppSpecific = true,
             LookupId = true,
         };
         errorQueue.MessageReadPropertyFilter = messageReadPropertyFilter;
         using (TransactionScope scope = new TransactionScope())
         {
             MessageQueueTransactionType transactionType = MessageQueueTransactionType.Automatic;
             Message message = errorQueue.ReceiveById(msmqMessageId, TimeSpan.FromSeconds(5), transactionType);
             string fullPath = ReadFailedQueueHeader(message);
             using (MessageQueue failedQueue = new MessageQueue(fullPath))
             {
                 failedQueue.Send(message, transactionType);
             }
             scope.Complete();
         }
     }
 }
		private static MessageQueue InitializeQueue(MessageQueue q)
		{
			bool transactional;
			try
			{
				transactional = q.Transactional;
			}
			catch (Exception ex)
			{
				throw new InvalidOperationException(
					string.Format("There is a problem with the input queue given: {0}. See the enclosed exception for details.", q.Path),
					ex);
			}

			if (!transactional)
			{
				throw new ArgumentException("Queue must be transactional (" + q.Path + ").");
			}

			var mpf = new MessagePropertyFilter();
			mpf.SetAll();

			q.MessageReadPropertyFilter = mpf;
			return q;
		}
        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 Message()
 {
     this.properties = new MessagePropertyVariants();
     this.receiveCreated = false;
     this.filter = new MessagePropertyFilter();
     this.properties.SetUI1Vector(2, new byte[20]);
     this.filter.Id = true;
 }
 public static MessageQueue GetOrCreateMessageQueue(string name)
 {
     MsmqUtilities.CreateQueueIfNecessary(name);
     var q = new MessageQueue(MsmqUtilities.GetFullPath(name));
     var filter = new MessagePropertyFilter();
     filter.SetAll();
     q.MessageReadPropertyFilter = filter;
     return q;
 }
Exemplo n.º 9
0
        public Consumer(string channelName)
        {
            // Attach to a message queue identified in channelName and set the formatter
            channel = new MessageQueue(channelName) {Formatter = new XmlMessageFormatter(new[] {typeof(string)})};

            // We want to trace message headers such as correlation id, so we need to tell MSMQ to retrieve those by setting the property filter
            MessagePropertyFilter filter = new MessagePropertyFilter();
            filter.SetAll();
            channel.MessageReadPropertyFilter = filter;
        }
Exemplo n.º 10
0
        /// <include file='doc\Message.uex' path='docs/doc[@for="Message.Message"]/*' />
        /// <devdoc>
        ///    <para>
        ///       Initializes a new instance of the <see cref='System.Messaging.Message'/> class with an empty body.
        ///    </para>
        /// </devdoc>
        public Message()
        {
            properties = new MessagePropertyVariants();
            receiveCreated = false;
            this.filter = new MessagePropertyFilter();

            //Always add Id
            properties.SetUI1Vector(NativeMethods.MESSAGE_PROPID_MSGID, new byte[MessageIdSize]);
            this.filter.Id = true;
        }
Exemplo n.º 11
0
        static Filters()
        {
            // setup the filter used for peeking
            Peek = new MSMQ.MessagePropertyFilter();
            Peek.ClearAll();
            Peek.Label = true;

            // we read the body too
            Read = new MSMQ.MessagePropertyFilter {
                Body = true
            };
        }
Exemplo n.º 12
0
        /// <summary>
        ///     Initializes the <see cref="IDequeueMessages" />.
        /// </summary>
        /// <param name="address">The address to listen on.</param>
        /// <param name="settings">The <see cref="TransactionSettings" /> to be used by <see cref="IDequeueMessages" />.</param>
        /// <param name="tryProcessMessage">Called when a message has been dequeued and is ready for processing.</param>
        /// <param name="endProcessMessage">
        ///     Needs to be called by <see cref="IDequeueMessages" /> after the message has been
        ///     processed regardless if the outcome was successful or not.
        /// </param>
        public void Init(Address address, TransactionSettings settings, Func<TransportMessage, bool> tryProcessMessage,
            Action<TransportMessage, Exception> endProcessMessage)
        {
            this.tryProcessMessage = tryProcessMessage;
            this.endProcessMessage = endProcessMessage;
            transactionSettings = settings;

            if (address == null)
            {
                throw new ArgumentException("Input queue must be specified");
            }

            if (!address.Machine.Equals(RuntimeEnvironment.MachineName, StringComparison.OrdinalIgnoreCase))
            {
                throw new InvalidOperationException(
                    string.Format("Input queue [{0}] must be on the same machine as this process [{1}].",
                        address, RuntimeEnvironment.MachineName));
            }

            transactionOptions = new TransactionOptions
            {
                IsolationLevel = transactionSettings.IsolationLevel,
                Timeout = transactionSettings.TransactionTimeout
            };

            queue = new MessageQueue(MsmqUtilities.GetFullPath(address), false, true, QueueAccessMode.Receive);

            if (transactionSettings.IsTransactional && !QueueIsTransactional())
            {
                throw new ArgumentException(
                    "Queue must be transactional if you configure your endpoint to be transactional (" + address + ").");
            }

            var messageReadPropertyFilter = new MessagePropertyFilter
            {
                Body = true,
                TimeToBeReceived = true,
                Recoverable = true,
                Id = true,
                ResponseQueue = true,
                CorrelationId = true,
                Extension = true,
                AppSpecific = true
            };

            queue.MessageReadPropertyFilter = messageReadPropertyFilter;

            if (PurgeOnStartup)
            {
                queue.Purge();
            }
        }
		public static MessageQueue GetOrCreateMessageQueue(string name)
		{
			CheckedQueues.GetOrAdd(name, n =>
			{
				MsmqUtilities.CreateQueueIfNecessary(name);
				return null;
			});

			var q = new MessageQueue(MsmqUtilities.GetFullPath(name), false, true);
			var filter = new MessagePropertyFilter();
			filter.SetAll();
			q.MessageReadPropertyFilter = filter;
			return q;
		}
        public TextBodyHandler()
        {
            MessageReadPropertyFilter = new MessagePropertyFilter();
            MessageReadPropertyFilter.ClearAll();

            MessageReadPropertyFilter.DestinationQueue = true;
            MessageReadPropertyFilter.Id = true;
            MessageReadPropertyFilter.Label = true;
            MessageReadPropertyFilter.Priority = true;
            MessageReadPropertyFilter.MessageType = true;
            MessageReadPropertyFilter.ArrivedTime = true;
            MessageReadPropertyFilter.SentTime = true;
            MessageReadPropertyFilter.Body = true;
        }
Exemplo n.º 15
0
        static void Main(string[] args)
        {
            _mq = new MessageQueue(@".\private$\RequestQFileProcess", QueueAccessMode.Receive);
            _mq.ReceiveCompleted += new ReceiveCompletedEventHandler(_mq_ReceiveCompleted);
            _mq.Formatter = new ActiveXMessageFormatter();
            MessagePropertyFilter filter = new MessagePropertyFilter();
            filter.Label = true;
            filter.Body = true;
            filter.AppSpecific = true;
            _mq.MessageReadPropertyFilter = filter;
            DoReceive();

            Console.ReadLine();
            _mq.Close();
        }
Exemplo n.º 16
0
        public Consumer(string channelName)
        {
            // Attach to a message queue and set the formatter so we can read the messages
            channel = new MessageQueue(channelName) {Formatter = new XmlMessageFormatter(new[] {typeof(string)})};

            // We want to trace message headers such as correlation id, so we need to tell MSMQ to retrieve those
            MessagePropertyFilter filter = new MessagePropertyFilter();
            filter.SetAll();
            channel.MessageReadPropertyFilter = filter;

            //we use a timer to poll the queue at a regular interval, of course this may need to be re-entrant but we have no state to worry about
            timer = new Timer(ConfigurationSettings.PollingInterval) {AutoReset = true};

            // on the Timer's Elapsed event we want to consume messages, so set the callback to our Consume method
            timer.Elapsed += timer_Elapsed;
        }
Exemplo n.º 17
0
        public static void Main(string[] args)
        {
            mongoDBWriter = new MongoDBWriter();
            logQueue = new MessageQueue(@".\private$\loggingMongoDBQueue", QueueAccessMode.Receive);
            logQueue.ReceiveCompleted += MessageQueueReceiveCompleted;
            //we just want to pass around json strings, so we don't care about the contract
            logQueue.Formatter = new XmlMessageFormatter(){TargetTypes = new []{typeof(string)}};

            var filter = new MessagePropertyFilter {Label = true, Body = true, AppSpecific = true};
            logQueue.MessageReadPropertyFilter = filter;

            DoReceive();

            Console.WriteLine("Application running and processing queue. Press any key to quit.");
            Console.ReadLine();
            logQueue.Close();
        }
Exemplo n.º 18
0
        protected override void ProcessRecord()
        {
            var queueAddress = string.Format("FormatName:DIRECT=OS:{0}\\private$\\{1}", Environment.MachineName,QueueName);

            var queue = new MessageQueue(queueAddress);
            var messageReadPropertyFilter = new MessagePropertyFilter {Id = true, Extension = true, ArrivedTime = true};

            queue.MessageReadPropertyFilter = messageReadPropertyFilter;

            var output = queue.GetAllMessages().Select(m => new
                {
                    m.Id,
                    Headers = ParseHeaders(m),
                    m.ArrivedTime
                });

            WriteObject(output, true);
        }
        public static void Pick_From_NServiceBus_Msmq()
        {
            var address = Address.Parse("*****@*****.**");
            address = Address.Parse("MessageMonitorAudit");
            var path = NServiceBus.Utils.MsmqUtilities.GetFullPath(address);
            using (var queue = new MessageQueue(path, QueueAccessMode.PeekAndAdmin))
            {
                var mpf = new MessagePropertyFilter();
                mpf.SetAll();
                queue.MessageReadPropertyFilter = mpf;

                var msg = queue.Peek(TimeSpan.FromMinutes(1));

                var tm = NServiceBus.Utils.MsmqUtilities.Convert(msg);

                if(tm.Is_Failed_Message())
                    tm.To_NServiceBus_Failed_Message();
            }
        }
        public MsmqSubscriptionStorageQueue(MsmqAddress queueAddress, bool useTransactionalQueue)
        {
            transactionTypeToUseForSend = useTransactionalQueue ? MessageQueueTransactionType.Single : MessageQueueTransactionType.None;
            queue = new MessageQueue(queueAddress.FullPath);

            var messageReadPropertyFilter = new MessagePropertyFilter
            {
                Id = true,
                Body = true,
                Label = true,
                ArrivedTime = true
            };

            queue.Formatter = new XmlMessageFormatter(new[]
            {
                typeof(string)
            });

            queue.MessageReadPropertyFilter = messageReadPropertyFilter;
        }
Exemplo n.º 21
0
        public MsmqQueue(Uri uri, IMsmqConfiguration configuration)
        {
            Guard.AgainstNull(uri, "uri");
            Guard.AgainstNull(configuration, "configuration");

            _log = Log.For(this);

            _parser = new MsmqUriParser(uri);

            _timeout = _parser.Local
                           ? TimeSpan.FromMilliseconds(configuration.LocalQueueTimeoutMilliseconds)
                           : TimeSpan.FromMilliseconds(configuration.RemoteQueueTimeoutMilliseconds);

            Uri = _parser.Uri;

            _messagePropertyFilter = new MessagePropertyFilter();
            _messagePropertyFilter.SetAll();

            _dequeuePipelinePool = new ReusableObjectPool<MsmqGetMessagePipeline>();
        }
        public MsmqWorkerAvailabilityManager()
        {
            var storageQueueAddress = Address.Local.SubScope("distributor.storage");
            var path = MsmqUtilities.GetFullPath(storageQueueAddress);
            var messageReadPropertyFilter = new MessagePropertyFilter
            {
                Id = true,
                Label = true,
                ResponseQueue = true,
            };

            storageQueue = new MessageQueue(path, false, true, QueueAccessMode.SendAndReceive)
            {
                MessageReadPropertyFilter = messageReadPropertyFilter
            };

            if ((!storageQueue.Transactional) && (SettingsHolder.Get<bool>("Transactions.Enabled")))
            {
                throw new Exception(string.Format("Queue [{0}] must be transactional.", path));
            }
        }
		public void Instrument()
		{
			foreach (var serviceInfo in Services)
			{
				var address = new Address(serviceInfo.ErrorQueue, MachineName);
				var queue = new MessageQueue(MsmqUtilities.GetFullPath(address));
				var filter = new MessagePropertyFilter();
				filter.SetAll();
				queue.MessageReadPropertyFilter = filter;

				var messages = queue.GetAllMessages();

				foreach (var message in messages)
				{
					var transportMessage = MsmqUtilities.Convert(message);

					if (transportMessage.Headers.ContainsKey(Faults.FaultsHeaderKeys.FailedQ))
					{
						var value = Address.Parse(transportMessage.Headers[Faults.FaultsHeaderKeys.FailedQ]);
						if (serviceInfo.Name.Equals(value.Queue, StringComparison.InvariantCultureIgnoreCase))
						{
							var messageText = Encoding.UTF8.GetString(transportMessage.Body);

							using (var con = GetConnection())
							{
								const string sql = "INSERT INTO Error (ErrorId, ServiceName, MachineName, Message, ErrorMessage, Stacktrace, MessageSentTimeUtc) VALUES(@errorId, @serviceName, @machineName, @message, @errorMessage, @stacktrace, @messageSentTimeUtc)";
								var errorMessage = transportMessage.Headers["NServiceBus.ExceptionInfo.Message"];
								var stackTrace = transportMessage.Headers["NServiceBus.ExceptionInfo.StackTrace"];
								var messageSentTimeUtc = transportMessage.Headers["NServiceBus.TimeOfFailure"].ToUtcDateTime();

								con.Execute(sql, new { ErrorId = Guid.NewGuid(), serviceName = serviceInfo.Name, MachineName, message = messageText, errorMessage, stackTrace, messageSentTimeUtc });
							}
						}
					}
				}
			}
		}
Exemplo n.º 24
0
        /// <include file='doc\Message.uex' path='docs/doc[@for="Message.Message3"]/*' />
        /// <internalonly/>                
        internal Message(MessagePropertyFilter filter)
        {
            properties = new MessagePropertyVariants();
            receiveCreated = true;
            this.filter = filter;
            if (filter.data1 != 0)
            {
                int data = filter.data1;

                if (0 != (data & MessagePropertyFilter.ACKNOWLEDGEMENT))
                    properties.SetUI2(NativeMethods.MESSAGE_PROPID_CLASS, (short)0);

                if (0 != (data & MessagePropertyFilter.ACKNOWLEDGE_TYPE))
                    properties.SetUI1(NativeMethods.MESSAGE_PROPID_ACKNOWLEDGE, (byte)0);

                if (0 != (data & MessagePropertyFilter.ADMIN_QUEUE))
                {
                    properties.SetString(NativeMethods.MESSAGE_PROPID_ADMIN_QUEUE, new byte[DefaultQueueNameSize * 2]);
                    properties.SetUI4(NativeMethods.MESSAGE_PROPID_ADMIN_QUEUE_LEN, DefaultQueueNameSize);
                }
                if (0 != (data & MessagePropertyFilter.BODY))
                {
                    properties.SetUI1Vector(NativeMethods.MESSAGE_PROPID_BODY, new byte[filter.bodySize]);
                    properties.SetUI4(NativeMethods.MESSAGE_PROPID_BODY_SIZE, filter.bodySize);
                    properties.SetUI4(NativeMethods.MESSAGE_PROPID_BODY_TYPE, 0);
                }
                if (0 != (data & MessagePropertyFilter.LABEL))
                {
                    properties.SetString(NativeMethods.MESSAGE_PROPID_LABEL, new byte[filter.labelSize * 2]);
                    properties.SetUI4(NativeMethods.MESSAGE_PROPID_LABEL_LEN, filter.labelSize);
                }
                if (0 != (data & MessagePropertyFilter.ID))
                    properties.SetUI1Vector(NativeMethods.MESSAGE_PROPID_MSGID, new byte[MessageIdSize]);

                if (0 != (data & MessagePropertyFilter.LOOKUP_ID))
                    properties.SetUI8(NativeMethods.MESSAGE_PROPID_LOOKUPID, (long)0);

                if (0 != (data & MessagePropertyFilter.USE_DEADLETTER_QUEUE))
                    properties.SetUI1(NativeMethods.MESSAGE_PROPID_JOURNAL, (byte)0);

                if (0 != (data & MessagePropertyFilter.RESPONSE_QUEUE))
                {
                    properties.SetString(NativeMethods.MESSAGE_PROPID_RESP_QUEUE, new byte[DefaultQueueNameSize * 2]);
                    properties.SetUI4(NativeMethods.MESSAGE_PROPID_RESP_QUEUE_LEN, DefaultQueueNameSize);
                }
                //Acknowledgment and MessageType are overloaded in MQ.
                if ((0 == (data & MessagePropertyFilter.ACKNOWLEDGEMENT)) && (0 != (data & MessagePropertyFilter.MESSAGE_TYPE)))
                    properties.SetUI2(NativeMethods.MESSAGE_PROPID_CLASS, (short)0);

                //Journaling and Deadletter are overloaded in MSMQ
                if ((0 == (data & MessagePropertyFilter.USE_DEADLETTER_QUEUE)) && (0 != (data & MessagePropertyFilter.USE_JOURNALING)))
                    properties.SetUI1(NativeMethods.MESSAGE_PROPID_JOURNAL, (byte)0);
            }

            if (filter.data2 != 0)
            {
                int data = filter.data2;
                if (0 != (data & MessagePropertyFilter.APP_SPECIFIC))
                    properties.SetUI4(NativeMethods.MESSAGE_PROPID_APPSPECIFIC, 0);
                if (0 != (data & MessagePropertyFilter.ARRIVED_TIME))
                    properties.SetUI4(NativeMethods.MESSAGE_PROPID_ARRIVEDTIME, 0);
                if (0 != (data & MessagePropertyFilter.ATTACH_SENDER_ID))
                    properties.SetUI4(NativeMethods.MESSAGE_PROPID_SENDERID_TYPE, 0);
                if (0 != (data & MessagePropertyFilter.AUTHENTICATED))
                    properties.SetUI1(NativeMethods.MESSAGE_PROPID_AUTHENTICATED, (byte)0);

                if (0 != (data & MessagePropertyFilter.CONNECTOR_TYPE))
                    properties.SetGuid(NativeMethods.MESSAGE_PROPID_CONNECTOR_TYPE, new byte[GenericIdSize]);
                if (0 != (data & MessagePropertyFilter.CORRELATION_ID))
                    properties.SetUI1Vector(NativeMethods.MESSAGE_PROPID_CORRELATIONID, new byte[MessageIdSize]);
                if (0 != (data & MessagePropertyFilter.CRYPTOGRAPHIC_PROVIDER_NAME))
                {
                    properties.SetString(NativeMethods.MESSAGE_PROPID_PROV_NAME, new byte[DefaultCryptographicProviderNameSize * 2]);
                    properties.SetUI4(NativeMethods.MESSAGE_PROPID_PROV_NAME_LEN, DefaultCryptographicProviderNameSize);
                }
                if (0 != (data & MessagePropertyFilter.CRYPTOGRAPHIC_PROVIDER_TYPE))
                    properties.SetUI4(NativeMethods.MESSAGE_PROPID_PROV_TYPE, 0);
                if (0 != (data & MessagePropertyFilter.IS_RECOVERABLE))
                    properties.SetUI1(NativeMethods.MESSAGE_PROPID_DELIVERY, (byte)0);
                if (0 != (data & MessagePropertyFilter.DESTINATION_QUEUE))
                {
                    properties.SetString(NativeMethods.MESSAGE_PROPID_DEST_QUEUE, new byte[DefaultQueueNameSize * 2]);
                    properties.SetUI4(NativeMethods.MESSAGE_PROPID_DEST_QUEUE_LEN, DefaultQueueNameSize);
                }
                if (0 != (data & MessagePropertyFilter.DIGITAL_SIGNATURE))
                {
                    properties.SetUI1Vector(NativeMethods.MESSAGE_PROPID_SIGNATURE, new byte[DefaultDigitalSignatureSize]);
                    properties.SetUI4(NativeMethods.MESSAGE_PROPID_SIGNATURE_LEN, DefaultDigitalSignatureSize);
                }
                if (0 != (data & MessagePropertyFilter.ENCRYPTION_ALGORITHM))
                    properties.SetUI4(NativeMethods.MESSAGE_PROPID_ENCRYPTION_ALG, 0);
                if (0 != (data & MessagePropertyFilter.EXTENSION))
                {
                    properties.SetUI1Vector(NativeMethods.MESSAGE_PROPID_EXTENSION, new byte[filter.extensionSize]);
                    properties.SetUI4(NativeMethods.MESSAGE_PROPID_EXTENSION_LEN, filter.extensionSize);
                }
                if (0 != (data & MessagePropertyFilter.FOREIGN_ADMIN_QUEUE))
                {
                    properties.SetString(NativeMethods.MESSAGE_PROPID_XACT_STATUS_QUEUE, new byte[DefaultQueueNameSize * 2]);
                    properties.SetUI4(NativeMethods.MESSAGE_PROPID_XACT_STATUS_QUEUE_LEN, DefaultQueueNameSize);
                }
                if (0 != (data & MessagePropertyFilter.HASH_ALGORITHM))
                    properties.SetUI4(NativeMethods.MESSAGE_PROPID_HASH_ALG, 0);
                if (0 != (data & MessagePropertyFilter.IS_FIRST_IN_TRANSACTION))
                    properties.SetUI1(NativeMethods.MESSAGE_PROPID_FIRST_IN_XACT, (byte)0);
                if (0 != (data & MessagePropertyFilter.IS_LAST_IN_TRANSACTION))
                    properties.SetUI1(NativeMethods.MESSAGE_PROPID_LAST_IN_XACT, (byte)0);
                if (0 != (data & MessagePropertyFilter.PRIORITY))
                    properties.SetUI1(NativeMethods.MESSAGE_PROPID_PRIORITY, (byte)0);
                if (0 != (data & MessagePropertyFilter.SENDER_CERTIFICATE))
                {
                    properties.SetUI1Vector(NativeMethods.MESSAGE_PROPID_SENDER_CERT, new byte[DefaultSenderCertificateSize]);
                    properties.SetUI4(NativeMethods.MESSAGE_PROPID_SENDER_CERT_LEN, DefaultSenderCertificateSize);
                }
                if (0 != (data & MessagePropertyFilter.SENDER_ID))
                {
                    properties.SetUI1Vector(NativeMethods.MESSAGE_PROPID_SENDERID, new byte[DefaultSenderIdSize]);
                    properties.SetUI4(NativeMethods.MESSAGE_PROPID_SENDERID_LEN, DefaultSenderIdSize);
                }
                if (0 != (data & MessagePropertyFilter.SENT_TIME))
                    properties.SetUI4(NativeMethods.MESSAGE_PROPID_SENTTIME, 0);
                if (0 != (data & MessagePropertyFilter.SOURCE_MACHINE))
                    properties.SetGuid(NativeMethods.MESSAGE_PROPID_SRC_MACHINE_ID, new byte[GenericIdSize]);
                if (0 != (data & MessagePropertyFilter.SYMMETRIC_KEY))
                {
                    properties.SetUI1Vector(NativeMethods.MESSAGE_PROPID_DEST_SYMM_KEY, new byte[DefaultSymmetricKeySize]);
                    properties.SetUI4(NativeMethods.MESSAGE_PROPID_DEST_SYMM_KEY_LEN, DefaultSymmetricKeySize);
                }
                if (0 != (data & MessagePropertyFilter.TIME_TO_BE_RECEIVED))
                    properties.SetUI4(NativeMethods.MESSAGE_PROPID_TIME_TO_BE_RECEIVED, 0);
                if (0 != (data & MessagePropertyFilter.TIME_TO_REACH_QUEUE))
                    properties.SetUI4(NativeMethods.MESSAGE_PROPID_TIME_TO_REACH_QUEUE, 0);
                if (0 != (data & MessagePropertyFilter.TRANSACTION_ID))
                    properties.SetUI1Vector(NativeMethods.MESSAGE_PROPID_XACTID, new byte[MessageIdSize]);
                if (0 != (data & MessagePropertyFilter.USE_AUTHENTICATION))
                    properties.SetUI4(NativeMethods.MESSAGE_PROPID_AUTH_LEVEL, 0);
                if (0 != (data & MessagePropertyFilter.USE_ENCRYPTION))
                    properties.SetUI4(NativeMethods.MESSAGE_PROPID_PRIV_LEVEL, 0);
                if (0 != (data & MessagePropertyFilter.USE_TRACING))
                    properties.SetUI1(NativeMethods.MESSAGE_PROPID_TRACE, (byte)0);
                if (0 != (data & MessagePropertyFilter.VERSION))
                    properties.SetUI4(NativeMethods.MESSAGE_PROPID_VERSION, 0);
            }
        }
Exemplo n.º 25
0
        public int Transfer(string subject, string destination, string expression, bool caseInsensitive, bool removeAfter)
        {
            MessageQueueTransaction transaction = null;

            int ret = 0;
            Regex matcher = null;

            if (expression != null)
                matcher = new Regex("(" + expression + ")", RegexOptions.Compiled | (caseInsensitive ? RegexOptions.IgnoreCase : RegexOptions.None));

            var messagePropertyFilter = new MessagePropertyFilter
            {
                ArrivedTime = true,
                Body = true,
                Id = true,
                Label = true
            };

            var messageQueue = new MessageQueue(subject);

            if (!Exists(destination))
            {
                throw new Exception("Can't write to non-existing queue " + destination + ". You can create it with qtouch.");
            }

            var destinationQueue = new MessageQueue(destination);

            if (!destinationQueue.CanWrite)
            {
                throw new Exception("Can't write to non-writable queue " + destination);
            }

            if (destinationQueue.Transactional)
            {
                transaction = new MessageQueueTransaction();
                transaction.Begin();
            }

            destinationQueue.Formatter = messageQueue.Formatter;

            messageQueue.MessageReadPropertyFilter = messagePropertyFilter;

            var messageEnumerator2 = messageQueue.GetMessageEnumerator2();
            while (messageEnumerator2.MoveNext())
            {
                if (messageEnumerator2.Current == null)
                    continue;

                var message = messageEnumerator2.Current;
                if (matcher != null)
                {
                    using (var streamReader = new StreamReader(message.BodyStream))
                    {
                        string body = streamReader.ReadToEnd();

                        if (!matcher.IsMatch(body))
                            continue;

                        Send(message, destinationQueue, transaction);
                    }
                }
                else
                {
                    Send(message, destinationQueue, transaction);
                }

                ret++;

                if (removeAfter)
                    messageEnumerator2.RemoveCurrent();

            }

            if (transaction!=null)
                transaction.Commit();

            return ret;
        }
Exemplo n.º 26
0
        public IEnumerable<MessageDescriptor> Tail(string queue)
        {
            var messagePropertyFilter = new MessagePropertyFilter
                                            {
                                                ArrivedTime = true,
                                                Body = true,
                                                Id = true,
                                                Label = true
                                            };

            var messageQueue = new MessageQueue(queue);
            messageQueue.MessageReadPropertyFilter = messagePropertyFilter;

            var messageEnumerator2 = messageQueue.GetMessageEnumerator2();
            while(true)
            {
                //arbitrary, 1 day.
                while(messageEnumerator2.MoveNext(TimeSpan.FromDays(1)))
                {
                    if(messageEnumerator2.Current == null)
                        continue;

                    yield return CreateMessageDescriptor(messageEnumerator2.Current);
                }
            }
        }
Exemplo n.º 27
0
        public IEnumerable<GrepResult> Grep(string subject, string expression, bool caseInsensitive)
        {
            Regex matcher = new Regex("(" + expression + ")", RegexOptions.Compiled | (caseInsensitive ? RegexOptions.IgnoreCase : RegexOptions.None));
            var messagePropertyFilter = new MessagePropertyFilter
                                            {
                                                ArrivedTime = true,
                                                Body = true,
                                                Id = true,
                                                Label = true
                                            };

            var messageQueue = new MessageQueue(subject);
            messageQueue.MessageReadPropertyFilter = messagePropertyFilter;

            var messageEnumerator2 = messageQueue.GetMessageEnumerator2();
            while (messageEnumerator2.MoveNext())
            {
                if (messageEnumerator2.Current == null)
                    continue;

                var message = messageEnumerator2.Current;
                using (var streamReader = new StreamReader(message.BodyStream))
                {
                    string body = streamReader.ReadToEnd();
                    if (!matcher.IsMatch(body))
                        continue;

                    yield return
                        new GrepResult
                            {Message = CreateMessageDescriptor(message), Text = matcher.HighlightMatch(body, "<{0}>")};
                }
            }
        }
Exemplo n.º 28
0
        public int Count(string queue)
        {
            var messagePropertyFilter = new MessagePropertyFilter
                                            {
                                                AdministrationQueue = false,
                                                ArrivedTime = false,
                                                CorrelationId = false,
                                                Priority = false,
                                                ResponseQueue = false,
                                                SentTime = false,
                                                Body = false,
                                                Label = false,
                                                Id = false
                                            };

            var messageQueue = new MessageQueue(queue);
            messageQueue.MessageReadPropertyFilter = messagePropertyFilter;

            return messageQueue.GetAllMessages().Length;
        }
Exemplo n.º 29
0
        public void Init(Address address, bool transactional)
        {
            useTransactions = transactional;

            if (address == null)
                throw new ArgumentException("Input queue must be specified");

            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()));

            myQueue = new MessageQueue(MsmqUtilities.GetFullPath(address));

            if (useTransactions && !QueueIsTransactional())
                throw new ArgumentException("Queue must be transactional (" + address + ").");

            var mpf = new MessagePropertyFilter();
            mpf.SetAll();

            myQueue.MessageReadPropertyFilter = mpf;

            if (PurgeOnStartup)
                myQueue.Purge();
        }
Exemplo n.º 30
0
		private Message[] PeekMessages(MessageQueue activeQueue, bool blnDynamicConnection, MessageFormat eMessageFormat, System.Type CustomType)
		{
			Message objMessage;
			Message[] arrCurrentMessages = new Message[0];
			Message[] arrCopyOfMessages = null;
			IMessageFormatter objFormatter = null ;
			MessagePropertyFilter objMessagePropertyFilter = new MessagePropertyFilter();
			int intArrayIndex;

			// Message Formatter
			switch (eMessageFormat)
			{
				case MessageFormat.XMLSerialize:
					if (CustomType == null)
					{
						objFormatter = new XmlMessageFormatter();
					}
					else
					{
					// objFormatter = new XmlMessageFormatter(new Type() [CustomType]);
					}

					break;
				case MessageFormat.ActiveXSerialize:
					objFormatter = new ActiveXMessageFormatter();
					break;
				case MessageFormat.BinarySerialize:
					objFormatter = new BinaryMessageFormatter();
					break;
			}

			// Messages in Private Queue
			// Ensure these properties are received (CorrelationID defaults to False)
			objMessagePropertyFilter.SetDefaults();
			objMessagePropertyFilter.CorrelationId = true;
			objMessagePropertyFilter.AppSpecific = true;
			objMessagePropertyFilter.ArrivedTime = true;
			activeQueue.MessageReadPropertyFilter = objMessagePropertyFilter;

			// Message Formatter
			activeQueue.Formatter = objFormatter;

			// Dynamic Connection whilst gathering messages
			if (blnDynamicConnection == true)
			{
				IEnumerator objMessageEnumerator = activeQueue.GetEnumerator();
				intArrayIndex = 0;
				while (objMessageEnumerator.MoveNext())
				{
					objMessage = (Message) objMessageEnumerator.Current;
					if (intArrayIndex > 0)
					{
						arrCopyOfMessages = new Message[intArrayIndex];
						arrCurrentMessages.CopyTo(arrCopyOfMessages,0);
						arrCurrentMessages=arrCopyOfMessages;
					}
					arrCurrentMessages[intArrayIndex] = objMessage;
					intArrayIndex += 1;
				}
			}
			else // Snapshot of messages currently in Queue
			{
				arrCurrentMessages = null ;
				try
				{
					arrCurrentMessages = activeQueue.GetAllMessages();
				}
				catch (System.Messaging.MessageQueueException excM)
				{
					throw excM;
				}
			}

			return arrCurrentMessages;

		}
Exemplo n.º 31
0
        public IEnumerable<CatResult> Cat(string subject, bool withExtension)
        {
            var messagePropertyFilter = new MessagePropertyFilter
            {
                ArrivedTime = true,
                Body = true,
                Id = true,
                Label = true,
                Extension = withExtension
            };

            var messageQueue = new MessageQueue(subject);
            messageQueue.MessageReadPropertyFilter = messagePropertyFilter;

            var messageEnumerator2 = messageQueue.GetMessageEnumerator2();
            while (messageEnumerator2.MoveNext())
            {
                if (messageEnumerator2.Current == null)
                    continue;

                var message = messageEnumerator2.Current;

                using (var streamReader = new StreamReader(message.BodyStream))
                {
                    string body = streamReader.ReadToEnd();

                    yield return
                        new CatResult { Message = CreateMessageDescriptor(message), Text = body, Extension = withExtension ? message.Extension : null };
                }
            }
        }