private void btnAdd_Click(object sender, RoutedEventArgs e)
{
string queueName = ConfigurationManager.AppSettings["MSMQLocation"];
MessageQueue rmTxnQ = new MessageQueue(queueName);
rmTxnQ.Formatter = new XmlMessageFormatter(new Type[] { typeof(ProcessMessage) });
foreach (ListBoxItem itm in files.Items)
{
MessageQueueTransaction msgTx = new MessageQueueTransaction();
msgTx.Begin();
try
{
string argument = "-i \"{0}\" -o \"{1}\" --preset \"" + ConfigurationManager.AppSettings["HandbrakePreset"] + "\"";
string destination = txtDestination.Text + "\\" + System.IO.Path.GetFileNameWithoutExtension(itm.ToolTip.ToString()) + ".m4v";
ProcessMessage p = new ProcessMessage() { CommandLine = argument, DestinationURL = destination, OrignalFileURL = itm.ToolTip.ToString() };
rmTxnQ.Send(p, msgTx);
results.Items.Insert(0, string.Format("{0} added to queue", p.OrignalFileURL));
msgTx.Commit();
}
catch (Exception ex)
{
results.Items.Insert(0, ex.Message);
msgTx.Abort();
}
}
}
public Requestor(string requestQueueName,string replyQueueName)
{
requestQueue = new MessageQueue(requestQueueName);
replyQueue = new MessageQueue(replyQueueName);
replyQueue.MessageReadPropertyFilter.SetAll();
((XmlMessageFormatter)replyQueue.Formatter).TargetTypeNames = new string[] { "System.String,mscorlib" };
}
/// <summary>
/// Sends a startup notification to the StromoLight queue.
/// </summary>
public static void SendNotification(string messageToSend)
{
MessageQueue startupQueue = null;
string startupQueueName = @".\Private$\StromoLight_Startup";
if (MessageQueue.Exists(startupQueueName))
{
startupQueue = new System.Messaging.MessageQueue(@".\Private$\StromoLight_Startup");
System.Messaging.Message message = new System.Messaging.Message();
message.Body = messageToSend;
message.Label = "Message from Task Designer";
startupQueue.Send(message);
}
else
{
startupQueue = MessageQueue.Create(@".\Private$\StromoLight_Startup");
startupQueue = new System.Messaging.MessageQueue(@".\Private$\StromoLight_Startup");
System.Messaging.Message message = new System.Messaging.Message();
message.Body = messageToSend;
message.Label = "Message from Task Designer";
startupQueue.Send(message);
}
}
public void InsertMessageinQueue()
{
try
{
MessageQueue msmq = null;
if (MessageQueue.Exists(connection))
{
msmq = new MessageQueue(connection);
}
else
{
msmq = MessageQueue.Create(connection);
}
var msg = new Message();
msg.Body = "SampleMessage ";
msg.Label = "Msg" + i.ToString();
++i;
msmq.Send(msg);
msmq.Refresh();
//msmq.Close();
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
public void MessageCreator()
{
MessageQueueTemplate mqt = applicationContext["txqueue"] as MessageQueueTemplate;
Assert.IsNotNull(mqt);
string path = @".\Private$\mlptestqueue";
if (MessageQueue.Exists(path))
{
MessageQueue.Delete(path);
}
MessageQueue.Create(path, true);
mqt.MessageQueueFactory.RegisterMessageQueue("newQueueDefinition", delegate
{
MessageQueue mq = new MessageQueue();
mq.Path = path;
// other properties
return mq;
});
Assert.IsTrue(mqt.MessageQueueFactory.ContainsMessageQueue("newQueueDefinition"));
SendAndReceive("newQueueDefinition",mqt);
SimpleCreator sc = new SimpleCreator();
mqt.MessageQueueFactory.RegisterMessageQueue("fooQueueDefinition", sc.CreateQueue );
}
private void recuperarFacturasToolStripMenuItem_Click(object sender, EventArgs e)
{
try
{
string rutaCola = @".\private$\facturas";
if (!MessageQueue.Exists(rutaCola))
MessageQueue.Create(rutaCola);
MessageQueue cola = new MessageQueue(rutaCola);
cola.Formatter = new XmlMessageFormatter(new Type[] { typeof(Factura) });
int total = cola.GetAllMessages().Count();
while (cola.GetAllMessages().Count() != 0)
{
System.Messaging.Message mensaje = cola.Receive();
Factura facturaItem = (Factura)mensaje.Body;
string postdata = "{\"Numero\":\"" + facturaItem.Numero + "\",\"Fecha\":\"" + facturaItem.Fecha + "\",\"Cliente\":\"" + facturaItem.Cliente + "\",\"ImporteBruto\":\"" + facturaItem.ImporteBruto + "\",\"ImporteVenta\":\"" + facturaItem.ImporteVenta + "\",\"ImporteIGV\":\"" + facturaItem.ImporteIGV + "\",\"ImporteTotalVenta\":\"" + facturaItem.ImporteTotalVenta + "\"}";
byte[] data = Encoding.UTF8.GetBytes(postdata);
HttpWebRequest req = (HttpWebRequest)WebRequest.Create("http://localhost:23440/Facturas.svc/Facturas");
req.Method = "POST";
req.ContentLength = data.Length;
req.ContentType = "application/json";
var reqStream = req.GetRequestStream();
reqStream.Write(data, 0, data.Length);
HttpWebResponse res = (HttpWebResponse)req.GetResponse();
StreamReader reader = new StreamReader(res.GetResponseStream());
string compraJson = reader.ReadToEnd();
JavaScriptSerializer js = new JavaScriptSerializer();
}
MessageBox.Show(total + " facturas recuperadas", "Facturas Recuperadas");
}
catch {
MessageBox.Show("Error de comunicación", "Error"); }
}
public void Purge()
{
using (var queue = new MessageQueue(_address.LocalName, QueueAccessMode.ReceiveAndAdmin))
{
queue.Purge();
}
}
static void Main(string[] args)
{
Console.WriteLine("Simple Text");
Console.WriteLine("Input for MSMQ Message:");
string input = Console.ReadLine();
MessageQueue queue = new MessageQueue(@".\private$\test");
queue.Send(input);
Console.WriteLine("Press Enter to continue");
Console.ReadLine();
Console.WriteLine("Output for MSMQ Queue");
Console.WriteLine(queue.Receive().Body.ToString());
Console.ReadLine();
Console.WriteLine("Complex Text");
User tester = new User();
tester.Birthday = DateTime.Now;
tester.Name = "Test Name";
queue.Send(tester);
Console.WriteLine("Output for MSMQ Queue");
User output = (User)queue.Receive().Body;
Console.WriteLine(output.Birthday.ToShortDateString());
Console.ReadLine();
}
private void SendMessage(object item)
{
MessageQueue queue;
if (MessageQueue.Exists(mqCreateTxt.Text))
{
queue = new System.Messaging.MessageQueue(mqCreateTxt.Text);
}
else
{
queue = MessageQueue.Create(mqCreateTxt.Text);
}
System.Messaging.Message messageItem = item as System.Messaging.Message;
if (queue != null)
{
try
{
queue.Send(messageItem);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
}
/// <summary>
/// Get the queued message from the message queue.
/// </summary>
/// <param name="serverAndQueuePath">The server and queue path name.</param>
/// <returns>The queued message.</returns>
public Message GetMessage(string serverAndQueuePath)
{
// Connect to the queue
System.Messaging.MessageQueue serverQueue =
new System.Messaging.MessageQueue(serverAndQueuePath);
// Get the message.
Message message = new Message();
Object o = new Object();
System.Type[] arrTypes = new System.Type[2];
arrTypes[0] = message.GetType();
arrTypes[1] = o.GetType();
serverQueue.Formatter = new XmlMessageFormatter(arrTypes);
// Create a transaction scope.
using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required))
{
// Get the message
message = ((Message)serverQueue.Receive(MessageQueueTransactionType.Automatic).Body);
// Complete the transaction.
scope.Complete();
}
// Return the message from the queue.
return(message);
}
public void Start()
{
Task.Factory.StartNew(() =>
{
var name = string.Format(".\\Private$\\{0}", typeof(IIpcClient).Name);
if (System.Messaging.MessageQueue.Exists(name) == true)
{
queue = new System.Messaging.MessageQueue(name);
}
else
{
queue = System.Messaging.MessageQueue.Create(name);
}
queue.Formatter = new XmlMessageFormatter(new Type[] { typeof(string) });
while (true)
{
var msg = queue.Receive();
var data = msg.Body.ToString();
this.OnReceived(new DataReceivedEventArgs(data));
}
});
}
/// <summary>
/// Required method for Designer support - do not modify
/// the contents of this method with the code editor.
/// </summary>
private void InitializeComponent()
{
this.pictureBox1 = new System.Windows.Forms.PictureBox();
this.drawingMQ = new System.Messaging.MessageQueue();
this.SuspendLayout();
//
// pictureBox1
//
this.pictureBox1.Location = new System.Drawing.Point(8, 8);
this.pictureBox1.Name = "pictureBox1";
this.pictureBox1.Size = new System.Drawing.Size(416, 216);
this.pictureBox1.TabIndex = 0;
this.pictureBox1.TabStop = false;
this.pictureBox1.Paint += new System.Windows.Forms.PaintEventHandler(this.pictureBox1_Paint);
//
// drawingMQ
//
this.drawingMQ.Path = "synergy\\drawings";
this.drawingMQ.SynchronizingObject = this;
this.drawingMQ.ReceiveCompleted += new System.Messaging.ReceiveCompletedEventHandler(this.drawingMQ_ReceiveCompleted);
//
// Form2
//
this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);
this.ClientSize = new System.Drawing.Size(440, 229);
this.Controls.AddRange(new System.Windows.Forms.Control[] {
this.pictureBox1
});
this.Name = "Form2";
this.Text = "Drawing Receiver";
this.Load += new System.EventHandler(this.Form2_Load);
this.ResumeLayout(false);
}
public override void InitializeOutbound(string addressName,
MessagePattern pattern,
bool isTemporary = false)
{
InitializeProperties(Direction.Outbound, addressName, pattern, isTemporary);
_queue = new msmq.MessageQueue(MessageAddress.Address);
}
/// <summary>
/// Connect to or Create the Academic Queue
/// </summary>
private void queueCreate(string mqPath, string mqName)
{
try
{
mqPath = @mqPath;
mqName = @mqName;
if (!System.Messaging.MessageQueue.Exists(mqPath))
{
System.Messaging.MessageQueue.Create(mqPath, false);
SecurityPermissions.ACLQueue(mqPath);
// set other queue parameters
System.Messaging.MessageQueue mq = new System.Messaging.MessageQueue(mqPath);
mq.Label = mqName;
//assumption Queue is on this box
mq.MachineName = ".";
mq.QueueName = mqName;
mq.MaximumQueueSize = 10240; // Set max queue size to 10M
}
}
catch (System.Exception)
{
}
}
public static bool VisualiserLoaded()
{
MessageQueue startupQueue = null;
string startupQueueName = @".\Private$\StromoLight_Startup";
if (MessageQueue.Exists(startupQueueName))
{
startupQueue = new System.Messaging.MessageQueue(@".\Private$\StromoLight_Startup");
System.Messaging.Message peekedMessage = startupQueue.Peek(System.TimeSpan.FromSeconds(20));
object lockObject = new object();
string peekedMessageBody;
lock (lockObject)
{
peekedMessage.Formatter = new XmlMessageFormatter(new String[] { "System.String,mscorlib" });
peekedMessageBody = peekedMessage.Body.ToString();
}
//return true if visualiser started ok
if (peekedMessageBody == "VSOK")
{
return(true);
}
}
return(false);
}
public Queue2()
{
//
// Required for Windows Form Designer support
//
InitializeComponent();
//
// TODO: Add any constructor code after InitializeComponent call
//
//Q Creation
string colaStr = @"FormatName:Direct=TCP:127.0.0.1\\private$\\MyQueue";
// MessageQueue rmQ = new MessageQueue(colaStr);
// rmQ.Send("sent to regular queue - Atul");
if (MessageQueue.Exists(colaStr))
{
mq = new MessageQueue(colaStr);
}
else
{
mq = MessageQueue.Create(colaStr);
}
//if(MessageQueue.Exists(@".\Private$\MyQueue"))
// mq = new MessageQueue(@".\Private$\MyQueue");
//else
// mq = MessageQueue.Create(@".\Private$\MyQueue");
}
public override void Configure(System.Xml.XmlElement element)
{
// Reflect some of the necessary protected methods on the SimpleCache class that are needed
Type type = typeof(SimpleCache);
getCachedItemMethod = type.GetMethod("GetCachedItem", BindingFlags.Instance | BindingFlags.NonPublic);
purgeMethod = type.GetMethod("Purge", BindingFlags.Instance | BindingFlags.NonPublic);
// Instantiate and configure the SimpleCache instance to be used for the local cache
cache = new SimpleCache();
cache.Configure(element);
// Allow the base CacheBase class to configure itself
base.Configure(element);
// Check for and configure the queue
if (element.HasAttribute("path"))
{
string path = element.GetAttribute("path");
if (MessageQueue.Exists(path))
{
queue = new MessageQueue(path);
queue.Formatter = new XmlMessageFormatter(new Type[] { typeof(CachedItem) });
// Start the listener thread
listen = true;
listenThread = new Thread(new ThreadStart(Listen));
listenThread.IsBackground = true;
listenThread.Start();
}
else
{
throw new ConfigurationErrorsException("The specified queue path (" + path + ") does not exist.");
}
}
}
public static MSMQ.MessageQueue GetOrAddQueue(Uri uri, out QueueDetails details)
{
details = default(QueueDetails);
if (uri == null)
{
return(null);
}
details = UriToQueueName(uri);
if (!details.Valid)
{
return(null);
}
var q = (MSMQ.MessageQueue)Queues.Get(details.QueueName);
if (q == null)
{
q = new MSMQ.MessageQueue(details.QueueName);
Queues.AddOrGetExisting(details.QueueName, q, new CacheItemPolicy {
SlidingExpiration = TimeSpan.FromMinutes(20)
});
}
return((MSMQ.MessageQueue)q);
}
public Message getFirstReservation()
{
MessageQueue queue = new MessageQueue(FlyHotelConstant.ADRESSE_QUEUE);
queue.Formatter = new XmlMessageFormatter(new Type[] { typeof(DemandeReservation) });
Message messageResa = queue.Peek();
return messageResa;
}
static void Main(string[] args)
{
var queueAddress = args != null && args.Length == 1 ? args[0] :
".\\private$\\sixeyed.messagequeue.unsubscribe";
using (var queue = new msmq.MessageQueue(queueAddress))
{
while (true)
{
Console.WriteLine("Listening on: {0}", queueAddress);
var message = queue.Receive();
var messageBody = message.BodyStream.ReadFromJson(message.Label);
//TODO - would use a factory/IoC/MEF for this:
var messageType = messageBody.GetType();
if (messageType == typeof(UnsubscribeCommand))
{
Unsubscribe((UnsubscribeCommand)messageBody);
}
else if (messageType == typeof(DoesUserExistRequest))
{
CheckUserExists((DoesUserExistRequest)messageBody, message);
}
}
}
}
private static void PurgeQueue(string queuePath)
{
using (var queue = new MessageQueue(queuePath))
{
queue.Purge();
}
}
public MessageQueue GetMessageQueue(string strQueuePath, bool CreateIfNotExists)
{
MessageQueue _mQueue = null;
try
{
if (MessageQueue.Exists(strQueuePath))
{
//creates an instance MessageQueue
_mQueue = new System.Messaging.MessageQueue(strQueuePath);
}
else
{
if (CreateIfNotExists)
{
//creates a new private queue
_mQueue = MessageQueue.Create(strQueuePath);
_mQueue.SetPermissions("EveryOne", MessageQueueAccessRights.FullControl);
_mQueue.Formatter = new ActiveXMessageFormatter();
}
}
_mQueue.Formatter = new ActiveXMessageFormatter();
return(_mQueue);
}
catch (Exception Ex)
{
Logger.Error("QueueManager", "GetMessageQueue(\"" + strQueuePath + "\")", Ex);
throw Ex;
}
}
/// <summary>
/// Constructs the <see cref="MsmqMessageQueue"/>, using the specified input queue. If the queue does not exist,
/// it will attempt to create it. If it already exists, it will assert that the queue is transactional.
/// </summary>
public MsmqMessageQueue(string inputQueueName, bool allowRemoteQueue = false)
{
if (inputQueueName == null) return;
try
{
machineAddress = GetMachineAddress();
inputQueuePath = MsmqUtil.GetPath(inputQueueName);
MsmqUtil.EnsureMessageQueueExists(inputQueuePath);
MsmqUtil.EnsureMessageQueueIsTransactional(inputQueuePath);
if (!allowRemoteQueue)
{
EnsureMessageQueueIsLocal(inputQueueName);
}
inputQueue = GetMessageQueue(inputQueuePath);
this.inputQueueName = inputQueueName;
}
catch (MessageQueueException e)
{
throw new ArgumentException(
string.Format(
@"An error occurred while initializing MsmqMessageQueue - attempted to use '{0}' as input queue",
inputQueueName), e);
}
}
private void HookQueue()
{
try
{
// This is necessary since we unhook
// when we are stopped.
if (this.qOrders == null)
{
this.qOrders = new System.Messaging.MessageQueue(this.m_Path);
}
// Start waiting for messages to arrive.
this.qOrders.BeginReceive();
}
catch (MessageQueueException exp)
{
this.EventLog.WriteEntry(exp.Message);
}
catch (Exception exp)
{
this.EventLog.WriteEntry(exp.Message);
}
}
/// <include file='doc\QueuePathEditor.uex' path='docs/doc[@for="QueuePathEditor.EditValue"]/*' />
/// <devdoc>
/// Edits the given object value using the editor style provided by
/// GetEditorStyle. A service provider is provided so that any
/// required editing services can be obtained.
/// </devdoc>
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
if (provider != null)
{
IWindowsFormsEditorService edSvc = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
if (edSvc != null)
{
QueuePathDialog dialog = new QueuePathDialog(provider);
MessageQueue queue = null;
if (value is MessageQueue)
queue = (MessageQueue)value;
else if (value is string)
queue = new MessageQueue((string)value);
else if (value != null)
return value;
if (queue != null)
dialog.SelectQueue(queue);
IDesignerHost host = (IDesignerHost)provider.GetService(typeof(IDesignerHost));
DesignerTransaction trans = null;
if (host != null)
trans = host.CreateTransaction();
try
{
if ((context == null || context.OnComponentChanging()) && edSvc.ShowDialog(dialog) == DialogResult.OK)
{
if (dialog.Path != String.Empty)
{
if (context.Instance is MessageQueue || context.Instance is MessageQueueInstaller)
value = dialog.Path;
else
{
value = MessageQueueConverter.GetFromCache(dialog.Path);
if (value == null)
{
value = new MessageQueue(dialog.Path);
MessageQueueConverter.AddToCache((MessageQueue)value);
if (context != null)
context.Container.Add((IComponent)value);
}
}
context.OnComponentChanged();
}
}
}
finally
{
if (trans != null)
{
trans.Commit();
}
}
}
}
return value;
}
private void InitializeComponent()
{
System.Configuration.AppSettingsReader configurationAppSettings = new System.Configuration.AppSettingsReader();
this.qOrders = new System.Messaging.MessageQueue();
//
//qOrders
//
this.qOrders.Formatter = new System.Messaging.XmlMessageFormatter(new string[] { "Server.MSMQOrders,Server" });
this.qOrders.Path = (string)configurationAppSettings.GetValue("msmqOrders.Path", typeof(System.String));
//
//WatchMSMQ
//
this.CanHandlePowerEvent = true;
this.CanPauseAndContinue = true;
this.CanShutdown = true;
this.ServiceName = "WatchMSMQ";
}
public string GetElementFromSource(string pQueuePach)
{
System.Messaging.Message sourceMessage;
string str="";
try
{
sourceQueue = new System.Messaging.MessageQueue(pQueuePach);
((XmlMessageFormatter)sourceQueue.Formatter).TargetTypeNames = new string[]{"System.String"};
if(sourceQueue.GetAllMessages ().Length >0)
{
sourceMessage = sourceQueue.Receive(System.Messaging.MessageQueueTransactionType.Automatic);
// Set the formatter.
// sourceQueue.Formatter = new XmlMessageFormatter(new Type[] {typeof(String)});
((XmlMessageFormatter)sourceQueue.Formatter).TargetTypeNames = new string[]{"Empleado"};
str = (string)sourceMessage.Body;
}
return str;
}
catch(MessageQueueException e)
{
throw e;
}
catch(Exception e)
{
throw e;
}
}
/// <summary>
/// Purge Queue With Path Name.
/// </summary>
/// <param name="path">the queue name.</param>
/// <returns>ResultModel:show the status of the request.</returns>
internal ResultModel PurgeQueue(string path)
{
ResultModel resultModel = new ResultModel();
try
{
System.Messaging.MessageQueue messageQueue = new System.Messaging.MessageQueue(path);
messageQueue.Purge();
resultModel.Result = (int)ResultsEnum.QueuePurged;
_logger.LogDebug(string.Format("Queue : {0} Purged", path));
}
catch (System.Messaging.MessageQueueException ex)
{
KubeMQ.MSMQSDK.Results.MessageQueueException messageEx = new KubeMQ.MSMQSDK.Results.MessageQueueException(ex);
_logger.LogCritical(string.Format("MSMQ Path:{0} Purge failed on ex :{1}", path, ex.Message));
resultModel.Result = (int)ResultsEnum.Error;
resultModel.exception = messageEx;
}
catch (Exception ex)
{
resultModel.Result = (int)ResultsEnum.Error;
_logger.LogCritical(string.Format("MSMQ Path:{0} Purge failed on ex :{1}", path, ex.Message));
resultModel.exception = ex;
}
return(resultModel);
}
public object receiveByID(string MessageID, string InputQueue)
{
// Open existing queue
using (MessageQueue queue = new MessageQueue(InputQueue))
{
//Peek to find message with the MessageID in the label
while (true)
{
Message[] peekedmessage = queue.GetAllMessages();
foreach (Message m in peekedmessage)
{
if (m.Label.StartsWith(MessageID))
{
using (Message message = queue.ReceiveById(m.Id))
{
RequestGuid = MessageID;
// Gets object type from the message label
Type objType = Type.GetType(message.Label.Split('|')[1], true, true);
// Derializes object from the stream
DataContractSerializer serializer = new DataContractSerializer(objType);
return serializer.ReadObject(message.BodyStream);
}
}
}
System.Threading.Thread.Sleep(10);
}
}
}
/// <summary>
/// Send message to existing queue from json format.
/// </summary>
/// <param name="meta">contain the queue general data for exemple:queue path , queue name.</param>
/// <param name="body">the body as string to insert to the queue</param>
/// <returns>ResultModel:show the status of the request.</returns>
internal ResultModel SendJsonRequestToQueue(MSMQMeta meta, string body)
{
ResultModel resultModel = new ResultModel();
try
{
System.Messaging.MessageQueue myQueue = new System.Messaging.MessageQueue(meta.Path);
myQueue.Formatter = new ActiveXMessageFormatter();
System.Messaging.Message MyMessage = MessageConvert.ConvertStringToSystemMessage(body, meta.FormmaterName, meta.Label);
myQueue.Send(MyMessage);
_logger.LogDebug(string.Format("Added json message to Queue:{0}", meta.Path));
resultModel.Result = (int)ResultsEnum.AddedToQueue;
}
catch (System.Messaging.MessageQueueException ex)
{
KubeMQ.MSMQSDK.Results.MessageQueueException messageEx = new KubeMQ.MSMQSDK.Results.MessageQueueException(ex);
_logger.LogCritical("Failed Sending json Message to queue {0} on exception {1}", meta.Path, ex.Message);
resultModel.Result = (int)ResultsEnum.Error;
resultModel.exception = messageEx;
}
catch (Exception ex)
{
resultModel.Result = (int)ResultsEnum.Error;
_logger.LogCritical("Failed Sending json Message to queue {0} on exception {1}", meta.Path, ex.Message);
resultModel.exception = ex;
}
return(resultModel);
}
/// <summary>
/// Peek Event Handler
/// </summary>
private async Task MyPeekCompleted(object source,
PeekCompletedEventArgs asyncResult, string ChannelToReturnTo, string channelPeeked)
{
ResultModel resultModel = new ResultModel();
try
{
// Connect to the queue.
System.Messaging.MessageQueue mq = (System.Messaging.MessageQueue)source;
// End the asynchronous peek operation.
System.Messaging.Message myMessage = mq.EndPeek(asyncResult.AsyncResult);
resultModel.message = MessageConvert.ConvertFromSystemMessage(myMessage);
resultModel.Result = (int)ResultsEnum.Done;
// Restart the asynchronous peek operation.
Response response = await initiator.SendRequestAsync(new KubeMQ.SDK.csharp.CommandQuery.LowLevel.Request()
{
Metadata = "PeekOK",
Body = Converter.ToByteArray(resultModel),
CacheKey = "",
CacheTTL = 0,
Channel = ChannelToReturnTo,
ClientID = clientID,
RequestType = RequestType.Query
});
}
catch (Exception ex)
{
_logger.LogCritical(string.Format("Failed to peek path {0} on ex {1}", channelPeeked, ex.Message));
}
}
public void Dispatch(Commit commit)
{
try
{
Task.Run(() =>
{
foreach (var ev in commit.Events.Select(@event => Converter.ChangeTo(@event.Body, @event.Body.GetType())))
{
try
{
using (var queue = new msmq.MessageQueue(".\\private$\\bankaccount-tx"))
{
var message = new msmq.Message();
var jsonBody = JsonConvert.SerializeObject(ev);
message.BodyStream = new MemoryStream(Encoding.Default.GetBytes(jsonBody));
var tx = new msmq.MessageQueueTransaction();
tx.Begin();
queue.Send(message, tx);
tx.Commit();
}
}
catch (Exception ex)
{
Debugger.Break();
}
}
});
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
private static async Task <string> GetMessage(string queue)
{
return(await Task.Run(() =>
{
try
{
string path = @".\private$\" + queue;
System.Messaging.MessageQueue messageQueue = null;
if (System.Messaging.MessageQueue.Exists(path))
{
messageQueue = new System.Messaging.MessageQueue(path);
}
else
{
messageQueue = System.Messaging.MessageQueue.Create(path);
}
Message message = messageQueue.Receive(new TimeSpan(0, 0, 2));
message.Formatter = new System.Messaging.XmlMessageFormatter(new Type[] { typeof(string) });
return $"队列名称:{queue} 消息内容 {message.Body.ToString()}";
}
catch (Exception ex)
{
return ex.Message;
}
}));
}
private static System.Messaging.MessageQueue GetOrCreateQueue(string queuePath, bool createQueueIfNotFound)
{
if (queuePath == null)
{
throw new ArgumentNullException(nameof(queuePath));
}
if (String.IsNullOrWhiteSpace(queuePath))
{
throw new ArgumentException(String.Format(System.Globalization.CultureInfo.CurrentCulture, Properties.Resources.PropertyCannotBeEmptyOrWhitespace, nameof(queuePath)), nameof(queuePath));
}
lock (_QueueCreationSynchroniser)
{
if (createQueueIfNotFound && !System.Messaging.MessageQueue.Exists(queuePath))
{
System.Messaging.MessageQueue.Create(queuePath, false);
}
}
var retVal = new System.Messaging.MessageQueue(queuePath, false, true, QueueAccessMode.Send);
retVal.Formatter = new MsmqJsonLogEventMessageFormatter();
retVal.DefaultPropertiesToSend.Recoverable = true;
return(retVal);
}
/// <summary>
/// 作者:Vincen
/// 时间：2013.11.14 PM
/// 描述：处理登录日志（消息队列）
/// </summary>
public static void DoLoginLog()
{
InitQueue(MsmqType.LoginLog);
using (var mq = new MessageQueue(MsmpPath + MsmqType.LoginLog))
{
var msgs = mq.GetAllMessages();
foreach (var msg in msgs)
{
try
{
msg.Formatter = new XmlMessageFormatter(new[] { typeof(LoginLogs) });
var item = msg.Body as LoginLogs;
if (null == item)
{
continue;
}
LoginLogsBLL.CreateLoginLogs(item);
}
//记录下（异常）日志信息
catch (Exception e)
{
Common.MSMQ.QueueManager.AddExceptionLog(new ExceptionLogs()
{
ExceptionType = Utility.CommonHelper.To<int>(ExceptionType.Msmq),
Message = string.Format("MSMQ-DoLoginLog：{0};{1};{2}", e.Message, e.InnerException.Message, e.HelpLink),
IsTreat = false,
CreateBy = 0,
CreateTime = DateTime.Now
});
}
}
mq.Purge();
}
}
public void Listen(CancellationToken cancellationToken, int listenerId)
{
cancellationToken.ThrowIfCancellationRequested();
Message newMessage = MSMessageQueue.Receive();
var body = newMessage.Body as byte[];
var message = Encoding.UTF8.GetString(body);
Log.Debug(x => x("Message queue listener received {0}", message));
if (IntegrationJobTypes != null && !IntegrationJobTypes.Any())
{
return;
}
var type = IntegrationJobTypes.FirstOrDefault(t => t.FullName.Equals(message));
var integrationJob = Activator.CreateInstance(type) as IIntegrationJob;
try
{
if (integrationJob != null)
{
integrationJob.Run();
}
}
catch (Exception exception)
{
Log.Error(x => x("Integration job did not run successfully ({0})}", message), exception);
}
}
public bool addReservation(DemandeReservation reservation)
{
MessageQueue queue = new MessageQueue(FlyHotelConstant.ADRESSE_QUEUE);
queue.Send(reservation);
queue.Close();
return true;
}
public ProcessingServiceData GetProcessingServiceData()
{
if (!System.Messaging.MessageQueue.Exists(_remoteControlQueueName))
{
System.Messaging.MessageQueue.Create(_remoteControlQueueName);
}
using (var remoteControlQueue = new System.Messaging.MessageQueue(_remoteControlQueueName, QueueAccessMode.SendAndReceive))
{
remoteControlQueue.Formatter = new XmlMessageFormatter(new[] { typeof(ProcessingServiceData), typeof(RemoteControlCommand) });
var processingServiceDataRequest = new RemoteControlCommand
{
Code = RemoteControlCommandCode.GetProcessingServiceData
};
remoteControlQueue.Send(new Message(processingServiceDataRequest));
do
{
var processingServiceMessage = remoteControlQueue.GetAllMessages().FirstOrDefault();
var processingServiceData = processingServiceMessage?.Body as ProcessingServiceData;
if (processingServiceData == null)
{
Thread.Sleep(_callDelay);
continue;
}
remoteControlQueue.Receive();
return(processingServiceData);
} while (true);
}
}
public string MessageReceiver()
{
const string queue_name = @".\private$\dynamics";
var queue = new MessageQueue(queue_name);
queue.Formatter = new XmlMessageFormatter(new[] { typeof(string) });
return queue.Receive().Body.ToString();
}
/// <summary>
/// Start the listen to the queue for incoming messages and
/// notifiy the handlers as new messges arrive
/// </summary>
private void StartQueueListener()
{
//create a separate connection to the message queue
System.Messaging.MessageQueue listenermq = new System.Messaging.MessageQueue(formatName);
((XmlMessageFormatter)listenermq.Formatter).TargetTypeNames = (string[])(supportedTypes.ToArray(typeof(System.String)));
System.Messaging.Message message = null;
queueListenerStarted = true;
try
{
//listen to the queue continusly through loop
while (queueListenerStarted == true)
{
System.Threading.Thread.Sleep(sleepTime);
if (handler.GetInvocationList().Length > 0)
{
//this is a call that will block the thread if no
//message is in the queue.
message = listenermq.Receive();
SAF.MessageQueue.Message safMessage = new SAF.MessageQueue.Message();
safMessage.Label = message.Label;
safMessage.Content = message.Body;
//fire the event
handler(safMessage, queueName);
}
}
}
finally
{
//close the connetion
listenermq.Close();
}
}
public override void GetMessageFromQueue(string messageId, MessageQueue queue, Action<Message> processMethod)
{
using (var transaction = new MessageQueueTransaction())
{
transaction.Begin();
Logger.DebugFormat("Transaction for {0} started.", messageId);
Message message;
try
{
message = queue.ReceiveById(messageId, TimeSpan.FromSeconds(30), transaction);
Logger.DebugFormat("Message with id {0} received.", messageId);
}
catch (Exception ex)
{
transaction.Abort();
Logger.Error(
string.Concat("Failed to receive message with id ", messageId, "transactions aborted.")
, ex);
return;
}
if (message != null)
{
processMethod(message);
}
if (transaction.Status != MessageQueueTransactionStatus.Aborted)
transaction.Commit();
}
}
private void SendStartupNotification()
{
MessageQueue startupQueue = null;
string startupQueueName = @".\Private$\StromoLight_Startup";
if (MessageQueue.Exists(startupQueueName))
{
startupQueue = new System.Messaging.MessageQueue(@".\Private$\StromoLight_Startup");
System.Messaging.Message message = new System.Messaging.Message();
message.Body = "DSOK";
message.Label = "Message from Diagnostics";
startupQueue.Send(message);
}
else
{
startupQueue = MessageQueue.Create(@".\Private$\StromoLight_Startup");
startupQueue = new System.Messaging.MessageQueue(@".\Private$\StromoLight_Startup");
System.Messaging.Message message = new System.Messaging.Message();
message.Body = "DSOK Started OK";
message.Label = "Message from Diagnostics";
startupQueue.Send(message);
}
}
private static void PurgeSubqueue(string queuePath, string subqueueName)
{
using (var queue = new MessageQueue(queuePath + ";" + subqueueName))
{
queue.Purge();
}
}
/// <summary>
/// Create message compatible with MSMQ
/// </summary>
/// <param name="queueName"></param>
/// <returns></returns>
public virtual IMessageQueue CreateMessageQueue(string queueName, string topicName = null)
{
var pathConfig = System.Configuration.ConfigurationManager.ConnectionStrings[queueName];
if (pathConfig == null)
{
throw new ArgumentException(string.Format("queueName {0} does not exists in connectionStrings section configuration", queueName));
}
var path = pathConfig.ConnectionString;
if (!path.StartsWith("formatname:direct") &&
!System.Messaging.MessageQueue.Exists(path))
{
try
{
string everyone = new System.Security.Principal.SecurityIdentifier(
"S-1-1-0").Translate(typeof(System.Security.Principal.NTAccount)).ToString();
var queue = System.Messaging.MessageQueue.Create(path);
queue.SetPermissions(everyone, MessageQueueAccessRights.FullControl);
}
catch (Exception ex)
{
ex.Data.Add("queueName", queueName);
ex.Data.Add("queuePath", path);
throw ex;
}
}
var result = new System.Messaging.MessageQueue(path, System.Messaging.QueueAccessMode.SendAndReceive);
return(new QueueProviders.MSMQMessageQueue(result, queueName));
}
public static void HandleError(MsmqPoisonMessageException error)
{
ProcessorQueue processorQueue = (ProcessorQueue)error.Data["processorQueue"];
MessageQueue poisonQueue = new System.Messaging.MessageQueue(processorQueue.PoisonQueue);
MessageQueue errorQueue = new System.Messaging.MessageQueue(processorQueue.ErrorQueue);
using (TransactionScope txScope = new TransactionScope(TransactionScopeOption.RequiresNew))
{
try
{
// Send the message to the poison and error message queues.
poisonQueue.Send((IWorkflowMessage)error.Data["message"], MessageQueueTransactionType.Automatic);
errorQueue.Send((WorkflowErrorMessage)error.Data["errorMessage"], MessageQueueTransactionType.Automatic);
txScope.Complete();
}
catch (InvalidOperationException)
{
}
finally
{
poisonQueue.Dispose();
errorQueue.Dispose();
}
}
}
public void Add_ShouldWriteToQueueWithoutChildren()
{
var messageQueue = new MessageQueue <TestPayload>(TestQueueName, null, true);
var payload = new TestPayload
{
Id = Guid.NewGuid(),
Text = "Some test text",
Time = DateTime.Now.TimeOfDay
};
messageQueue.Add(payload);
var msgQueue = new MSFT.MessageQueue(messageQueue.Path)
{
Formatter = new MessageFormatter <TestPayload>()
};
var msg = msgQueue.Receive(TimeSpan.FromSeconds(30));
msg.Body.Should().NotBeNull();
msg.Body.Should().BeOfType <TestPayload>();
var actualPayload = (TestPayload)msg.Body;
actualPayload.Id.Should().Be(payload.Id);
actualPayload.Text.Should().Be(payload.Text);
actualPayload.Time.Should().Be(payload.Time);
}
protected override void OnStart(string[] args)
{
try
{
string queueName = ConfigurationManager.AppSettings["ProvisionQueueName"];
//if (!MessageQueue.Exists(queueName))MessageQueue.Create(queueName, true);
var queue = new MessageQueue(queueName);
Trace.WriteLine("Queue Created in MSMQService at:" + DateTime.Now);
//Console.ReadLine();
queue.Formatter = new XmlMessageFormatter(new Type[] { typeof(String) });
//Below code reads from queue once
Message[] messages = queue.GetAllMessages();
Trace.WriteLine("Reading from queue in MSMQService : " + queueName);
Trace.WriteLine("Number of messages in MSMQService: " + messages.Length);
/**foreach (Message msg in messages)
{
// var decoded = JsonConvert.DeserializeObject(msg.Body.ToString());
Console.WriteLine("message:" + msg.Body);
Console.ReadLine();
}
Console.WriteLine("End of messages");
Console.ReadLine();
**/
//Below code keeps reading from queue
queue.ReceiveCompleted += QueueMessageReceived;
queue.BeginReceive();
signal.WaitOne();
//Console.ReadLine();
}
catch (Exception e)
{
Trace.WriteLine("Error in receiving in MSMQService: " + e.Message);
}
}
public string GetElementFromSource(string pQueuePach)
{
System.Messaging.Message sourceMessage;
string str = "";
try
{
sourceQueue = new System.Messaging.MessageQueue(pQueuePach);
((XmlMessageFormatter)sourceQueue.Formatter).TargetTypeNames = new string[] { "System.String" };
if (sourceQueue.GetAllMessages().Length > 0)
{
sourceMessage = sourceQueue.Receive(System.Messaging.MessageQueueTransactionType.Automatic);
// Set the formatter.
// sourceQueue.Formatter = new XmlMessageFormatter(new Type[] {typeof(String)});
((XmlMessageFormatter)sourceQueue.Formatter).TargetTypeNames = new string[] { "Empleado" };
str = (string)sourceMessage.Body;
}
return(str);
}
catch (MessageQueueException e)
{
throw e;
}
catch (Exception e)
{
throw e;
}
}
protected override void OnStart(string[] args)
{
//HTTP listener
//http://127.0.0.1:8081/sensores?var1=15&var2=514&var3=125&var4=145
HTTPListener listen = new HTTPListener();
listen.Listen();
//Recepcion mensaje
//Los sensores envían 2 mediciones por segundo (en forma independiente y potencialmente simultánea)
mq = new MessageQueue(@".\private$\Sensores");
mq.Formatter = new XmlMessageFormatter(new Type[] { typeof(int[]) });
mq.ReceiveCompleted += new ReceiveCompletedEventHandler(MyReceiveCompleted);
mq.BeginReceive();
//Procesamiento princpal
timer = new System.Timers.Timer();
//El sistema de procesamiento, por limitaciones de hardware, sólo puede procesar información 2 veces por minuto.
timer.Interval = 30000; // 30 seconds = 30000
timer.Elapsed += new System.Timers.ElapsedEventHandler(OnTimer);
timer.Enabled = true;
timer.Start();
signal.WaitOne();
}
public void SendMessageToQueue(string queueName, CallDisposition data)
{
var msMq = new MessageQueue(queueName);
var myMessage = new System.Messaging.Message();
myMessage.Formatter = new XmlMessageFormatter(new Type[] { typeof(CallDisposition) });
myMessage.Body = data;
myMessage.Label = "MessageQueue";
myMessage.UseJournalQueue = true;
myMessage.Recoverable = true;
//message send acknowledgement.
myMessage.AdministrationQueue = new MessageQueue(@".\Private$\MessageAcknowledgeQueue");
myMessage.AcknowledgeType = AcknowledgeTypes.PositiveReceive | AcknowledgeTypes.PositiveArrival;
try
{
msMq.Send(myMessage);
Console.WriteLine("Message sent successfully!");
}
catch (MessageQueueException e)
{
Console.Write(e.ToString());
}
catch (Exception e)
{
Console.Write(e.ToString());
}
finally
{
msMq.Close();
}
}
public void Raven_dtc_bug()
{
new MessageQueue(QueueAddress, QueueAccessMode.ReceiveAndAdmin)
.Purge();
using (var tx = new TransactionScope())
{
using (var session = store.OpenSession())
{
session.Store(new GatewayMessage());
session.SaveChanges();
}
using (var q = new MessageQueue(QueueAddress, QueueAccessMode.Send))
{
var toSend = new Message { BodyStream = new MemoryStream(new byte[8]) };
//sending a message to a msmq queue causes raven to promote the tx
q.Send(toSend, MessageQueueTransactionType.Automatic);
}
//when we complete raven commits it tx but the DTC tx is never commited and eventually times out
tx.Complete();
}
Thread.Sleep(1000);
Assert.AreEqual(1,new MessageQueue(QueueAddress, QueueAccessMode.ReceiveAndAdmin)
.GetAllMessages().Length);
}
public void An_undecipherable_blob_should_be_discarded()
{
var formatName = Endpoint.Address.Uri.GetInboundFormatName();
using (var queue = new MessageQueue(formatName, QueueAccessMode.Send))
{
queue.Send("This is just crap, it will cause pain");
}
try
{
Endpoint.Receive(context =>
{
IConsumeContext<PingMessage> pingContext;
context.TryGetContext(out pingContext);
Assert.Fail("Receive should have thrown a serialization exception");
return null;
}, TimeSpan.Zero);
}
catch (Exception ex)
{
Assert.Fail("Did not expect " + ex.GetType() + " = " + ex.Message);
}
Assert.AreEqual(0, EndpointAddress.GetMsmqMessageCount(), "Endpoint was not empty");
Assert.AreEqual(1, ErrorEndpointAddress.GetMsmqMessageCount(), "Error endpoint did not contain bogus message");
}
static MsmqAddress GetIndependentAddressForQueue(MessageQueue q)
{
var arr = q.FormatName.Split('\\');
var queueName = arr[arr.Length - 1];
var directPrefixIndex = arr[0].IndexOf(DIRECTPREFIX);
if (directPrefixIndex >= 0)
{
return new MsmqAddress(queueName, arr[0].Substring(directPrefixIndex + DIRECTPREFIX.Length));
}
var tcpPrefixIndex = arr[0].IndexOf(DIRECTPREFIX_TCP);
if (tcpPrefixIndex >= 0)
{
return new MsmqAddress(queueName, arr[0].Substring(tcpPrefixIndex + DIRECTPREFIX_TCP.Length));
}
try
{
// the pessimistic approach failed, try the optimistic approach
arr = q.QueueName.Split('\\');
queueName = arr[arr.Length - 1];
return new MsmqAddress(queueName, q.MachineName);
}
catch
{
throw new Exception($"Could not translate format name to independent name: {q.FormatName}");
}
}
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);
}
}
public QueueAgent(string inboundQueue, string outboundQueue)
{
mobjInboundQueue = new MessageQueue(QUEUE_PREFIX + inboundQueue);
mobjOutboundQueue = new MessageQueue(QUEUE_PREFIX + outboundQueue);
}
private bool DoesUserExist(string emailAddress)
{
var responseAddress = Guid.NewGuid().ToString().Substring(0, 6);
responseAddress = ".\\private$\\" + responseAddress;
try
{
using (var responseQueue = msmq.MessageQueue.Create(responseAddress))
{
var doesUserExistRequest = new DoesUserExistRequest
{
EmailAddress = emailAddress
};
using (var requestQueue = new msmq.MessageQueue(
".\\private$\\sixeyed.messagequeue.doesuserexist"))
{
var message = new msmq.Message();
message.BodyStream = doesUserExistRequest.ToJsonStream();
message.Label = doesUserExistRequest.GetMessageType();
message.ResponseQueue = responseQueue;
requestQueue.Send(message);
}
var response = responseQueue.Receive();
var responseBody = response.BodyStream.ReadFromJson <DoesUserExistResponse>();
return(responseBody.Exists);
}
}
finally
{
if (msmq.MessageQueue.Exists(responseAddress))
{
msmq.MessageQueue.Delete(responseAddress);
}
}
}
public string RetriveMessageFromQueue()
{
try
{
MessageQueue mqueu = null;
if (MessageQueue.Exists(connection))
{
mqueu = new MessageQueue(connection);
}
else
{
Console.WriteLine("cannot find queue");
mqueu = MessageQueue.Create(connection);
}
mqueu.Refresh();
string mqvalue = string.Empty;
System.Type[] msgtypes = new System.Type[1];
msgtypes[0] = mqvalue.GetType();
mqueu.Formatter = new System.Messaging.XmlMessageFormatter(msgtypes);
mqvalue = mqueu.Receive(new TimeSpan(0, 0, 5), System.Messaging.MessageQueueTransactionType.Single).Body.ToString();
return mqvalue;
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
return null;
}
}
static void Main(string[] args)
{
var container = new UnityContainer();
container.RegisterType<ITradeContextFactory, TradeContextFactory>();
container.RegisterType<IMessageHandler, ValidateTradeHandler>("ValidateTradeHandler");
container.RegisterType<IMessageHandler, EnrichPartyHandler>("EnrichParty1Handler",
new InjectionConstructor(
new ResolvedParameter<ITradeContextFactory>(),
true, false));
container.RegisterType<IMessageHandler, EnrichPartyHandler>("EnrichParty2Handler",
new InjectionConstructor(
new ResolvedParameter<ITradeContextFactory>(),
false, true));
container.RegisterType<MessageHandlerFactory>();
_HandlerFactory = container.Resolve<MessageHandlerFactory>();
var arguments = Args.Configuration.Configure<Arguments>().CreateAndBind(args);
var queue = new MessageQueue(arguments.InputQueue, QueueAccessMode.Receive);
while (true)
{
var msg = queue.Receive();
Handle(msg);
}
}
public IEnumerable<int> GetEnqueuedJobIds(string queue, int @from, int perPage)
{
var result = new List<int>();
using (var messageQueue = new MessageQueue(String.Format(_pathPattern, queue)))
{
var current = 0;
var end = @from + perPage;
var enumerator = messageQueue.GetMessageEnumerator2();
var formatter = new BinaryMessageFormatter();
while (enumerator.MoveNext())
{
if (current >= @from && current < end)
{
var message = enumerator.Current;
message.Formatter = formatter;
result.Add(int.Parse((string)message.Body));
}
if (current >= end) break;
current++;
}
}
return result;
}
/// <summary>
///
/// </summary>
/// <param name="queuePath"></param>
/// <param name="newEMNoRequest"></param>
public static void AddAPIRequestToQueue(string queuePath,
Emizon.APIModels.MSMQTypes.QueueOrderMessage newEMNoRequest
)
{
System.Messaging.MessageQueue msmq = new System.Messaging.MessageQueue(queuePath);
msmq.Send(newEMNoRequest, "Emizon Order: " + newEMNoRequest.orderID.ToString());
}