/// <summary>
/// Write Message to Local Queue
/// </summary>
/// <param name="strInputMsg">Text Message</param>
/// <param name="strqueueName">Queue Name</param>
/// <returns></returns>
public MQMessageStatus WriteLocalQMsg(string strInputMsg, string strQueueName)
{
MQMessageStatus messageStatus = new MQMessageStatus();
string strReturn = string.Empty;
SendQueueName = strQueueName;
try
{
queue = queueManager.AccessQueue(SendQueueName,
MQC.MQOO_OUTPUT + MQC.MQOO_FAIL_IF_QUIESCING);
message = strInputMsg;
queueMessage = new MQMessage();
queueMessage.WriteString(message);
queueMessage.Format = MQC.MQFMT_STRING;
queuePutMessageOptions = new MQPutMessageOptions();
queue.Put(queueMessage, queuePutMessageOptions);
strReturn = "Message sent to the queue successfully";
messageStatus.Message = strReturn;
messageStatus.Status = true;
}
catch (MQException MQexp)
{
strReturn = "Exception: " + MQexp.Message;
messageStatus.Message = strReturn;
messageStatus.Status = false;
}
catch (Exception exp)
{
strReturn = "Exception: " + exp.Message;
messageStatus.Message = strReturn;
messageStatus.Status = false;
}
return(messageStatus);
}
private bool sendMessage(string queueName, int requestId, MQQueue queue, MQQueueManager manager, string messageId, string message, string correlationId, Object lockObject)
{
lock (lockObject)
{
bool sentMessage = false;
try
{
MQPutMessageOptions pmo = new MQPutMessageOptions();
pmo.Options = MQC.MQOO_INQUIRE | MQC.MQPMO_FAIL_IF_QUIESCING | MQC.MQPMO_SYNCPOINT;
MQMessage mqMessage = new MQMessage();
mqMessage.Write(System.Text.ASCIIEncoding.ASCII.GetBytes(message));
mqMessage.Format = MQC.MQFMT_STRING;
mqMessage.MessageId = System.Text.ASCIIEncoding.ASCII.GetBytes(messageId);
mqMessage.CorrelationId = System.Text.ASCIIEncoding.ASCII.GetBytes(correlationId);
queue.Put(mqMessage, pmo);
manager.Commit();
sentMessage = true;
LogUtil.logInfo("Sent message " + requestId + " to " + queueName);
LogUtil.logInfo("End SendMesage:");
}
catch (MQException e)
{
sentMessage = false;
manager.Backout();
LogUtil.log("Error sending the message to " + queue.Name + " queue", e);
}
return(sentMessage);
}
}
public void PutMessage(string destination, MQMessage message, MQPutMessageOptions putOptions)
{
Transaction currentTx = Transaction.Current;
if (currentTx != null)
{
putOptions.Options |= MQC.MQPMO_SYNCPOINT;
currentTx.EnlistVolatile(this, EnlistmentOptions.None);
}
try
{
QueueManager.Put(destination, message, putOptions);
}
catch (MQException mqe)
{
if (mqe.ReasonCode == MQC.MQRC_CONNECTION_BROKEN)
{
// for some reason, the Close method on the Queue fails after
// a connection has been broken.
Queue = null;
QueueManager.Close();
QueueManager = null;
}
throw;
}
}
public string WriteMsg(string strInputMsg)
{
string strReturn = "";
try
{
queue = queueManager.AccessQueue(QueueName,
MQC.MQOO_OUTPUT + MQC.MQOO_FAIL_IF_QUIESCING);
message = strInputMsg;
queueMessage = new MQMessage();
queueMessage.WriteString(message);
queueMessage.Format = MQC.MQFMT_STRING;
queuePutMessageOptions = new MQPutMessageOptions();
queue.Put(queueMessage, queuePutMessageOptions);
strReturn = "Message sent to the queue successfully";
}
catch (MQException MQexp)
{
strReturn = "Exception: " + MQexp.Message;
}
catch (Exception exp)
{
strReturn = "Exception: " + exp.Message;
}
return(strReturn);
}
public bool PutMessage(string queueName, string message)
{
bool success = false;
MQQueue queue = null;
try
{
_log.DebugFormat("Accessing queue {0}", queueName);
queue = _queueManager.AccessQueue(queueName, MQC.MQOO_OUTPUT + MQC.MQOO_FAIL_IF_QUIESCING);
MQMessage queueMessage = new MQMessage();
queueMessage.CharacterSet = 1208; // force to UTF-8 for InService
queueMessage.WriteString(message);
queueMessage.Format = MQC.MQFMT_STRING;
MQPutMessageOptions queuePutMessageOptions = new MQPutMessageOptions();
queue.Put(queueMessage, queuePutMessageOptions);
success = true;
}
catch (MQException mqe)
{
success = false;
_log.ErrorFormat("MQHelper::MQException caught: {0} - {1}", mqe.ReasonCode, mqe.Message);
}
finally
{
if (queue != null)
{
_log.Debug("MQHelper::PutMessage() - Closing queue...");
queue.Close();
}
}
return(success);
}
string sendMessage(string message, string queueName)
{
try
{
queue = qMgr.AccessQueue(queueName, MQC.MQOO_OUTPUT | MQC.MQOO_INPUT_SHARED | MQC.MQOO_INQUIRE);
}
catch (MQException e)
{
return("打开队列失败：" + e.Message);
}
var mqMsg = new MQMessage();
mqMsg.WriteString(message);
var putOptions = new MQPutMessageOptions();
try
{
queue.Put(mqMsg, putOptions);
return("消息放置完毕");
}
catch (MQException mqe)
{
return("发送异常终止：" + mqe.Message);
}
finally
{
try
{
qMgr.Disconnect();
}
catch (MQException e)
{
}
}
}
/// <summary>
/// Puts a message object in the queue.
/// </summary>
/// <param name="queueName"></param>
/// <param name="message"></param>
private void PutRequestMessage(string connectionKeyName, MQMessage message)
{
MQQueue queue = null;
try
{
if (!IsConnected)
{
Connect(connectionKeyName);
}
MQPutMessageOptions queuePutMessageOptions = new MQPutMessageOptions();
queue = _queueManager.AccessQueue(_activeConnection.RequestQueue, MQC.MQOO_OUTPUT + MQC.MQOO_FAIL_IF_QUIESCING);
queue.Put(message, queuePutMessageOptions);
}
catch (MQException mqe)
{
_log.ErrorFormat("Exception in PutRequestMessage(). Message: {0}", mqe.Message);
}
finally
{
if (queue != null)
{
queue.Close();
}
}
}
/// <summary>
/// Helper method to write a message to an MQ Series queue
/// </summary>
/// <param name="queueManagerName">The name of the MQ Series queue manager</param>
/// <param name="queueName">The name of the MQ Series queue to read from</param>
/// <param name="message">The MQ Series queue</param>
/// <param name="correlId">The correlation ID to be set on the new message</param>
/// <param name="context">The BizUnit context object which holds state and is passed between test steps</param>
public static void WriteMessage(string queueManagerName, string queueName, string message, byte[] correlId,
Context context)
{
context.LogInfo("Opening queue manager: \"{0}\"", queueManagerName);
using (var queueManager = new MQQueueManager(queueManagerName))
{
context.LogInfo("Opening queue: '{0}'.", queueName);
using (var sendQueue = queueManager.AccessQueue(queueName, MQC.MQOO_OUTPUT + MQC.MQOO_FAIL_IF_QUIESCING)
)
{
var mqMessage = new MQMessage();
var data = ConvertToBytes(message);
mqMessage.Write(data);
mqMessage.Format = MQC.MQFMT_STRING;
var mqPutMsgOpts = new MQPutMessageOptions();
context.LogInfo("Writing {0} byte message to queue '{1}'.", data.Length, queueName);
if (correlId != null)
{
mqMessage.CorrelationId = correlId;
}
sendQueue.Put(mqMessage, mqPutMsgOpts);
}
}
}
public bool PutMessage(string queueName, string message)
{
bool success = false;
MQQueue queue = null;
try
{
//eventLog1.WriteEntry("Accessing queue {0}", queueName);
queue = _queueManager.AccessQueue(queueName, MQC.MQOO_OUTPUT + MQC.MQOO_FAIL_IF_QUIESCING);
MQMessage queueMessage = new MQMessage();
queueMessage.CharacterSet = 1208; // force to UTF-8 for InService
queueMessage.WriteString(message);
queueMessage.Format = MQC.MQFMT_STRING;
MQPutMessageOptions queuePutMessageOptions = new MQPutMessageOptions();
queue.Put(queueMessage, queuePutMessageOptions);
success = true;
}
catch (MQException mqe)
{
success = false;
//eventLog1.WriteEntry("MQException caught: {0} - {1}", mqe.ReasonCode, mqe.Message);
//throw new Exception(string.Format("Error writing to {0} queue", queueName));
}
finally
{
if (queue != null)
{
//eventLog1.WriteEntry("Closing queue");
queue.Close();
}
}
return(success);
}
/// <summary>
/// 发送
/// </summary>
/// <param name="queueName">队列名称</param>
/// <param name="sendMessages">发送内容</param>
public void SendMessages(string queueName, string sendMessages)
{
MQQueueManager sQMgr = null; //发送消息的队列管理器
MQQueue remoteQ = null; //发送消息的队列
try
{
// 创建一个连接到队列管理器
sQMgr = new MQQueueManager(queueManagerName, ConnProperties);
//现在指定要打开的队列，
//和打开选项…
remoteQ = sQMgr.AccessQueue(queueName, MQC.MQOO_OUTPUT | MQC.MQOO_FAIL_IF_QUIESCING | MQC.MQOO_INQUIRE);
// 定义一个简单的WebSphere MQ消息
MQMessage putMessage = new MQMessage();
putMessage.WriteString(sendMessages);
// 指定消息选项…
MQPutMessageOptions pmo = new MQPutMessageOptions();
// 放入消息到队列
remoteQ.Put(putMessage, pmo);
remoteQ.Close(); //关闭队列
sQMgr.Disconnect(); //关闭队列管理器连接
}
catch
{
}
}
public static MQPutMessageOptions getPMOFromPara()
{
MQPutMessageOptions pmo = new MQPutMessageOptions();
pmo.Options |= MQC.MQPMO_FAIL_IF_QUIESCING;
return(pmo);
}
}// end of method
/**
* 将响应消息放入发送队列
* @param para 连接实例
* @param message 准备发送的消息
* @param type
* @return
* @throws EisException
*/
public static Boolean putMsgToQueue(MQCParameter para, MQMessage message)
{
MQPutMessageOptions pmo = getPMOFromPara();
if (null == message || null == pmo || null == para)
{
throw new EisException(MQCException.MQ_MSG_SEND_PUTMSG_ERROR_EXCEPTION_CODE);
}
try {
if (para.qManager == null || para.queue == null)
{
connectMQExce(para, MQQueueAccesser.MQ_MSGSEND_TYPE);
}
printMsgId("before put MsgId", message.MessageId);
LogUtil.Info("put message.replyToQueueManagerName:", message.ReplyToQueueManagerName);
LogUtil.Info("put message.messageType:", message.MessageType);
LogUtil.Info("put message.report:", message.Report);
LogUtil.Info("message.encoding:", message.Encoding);
LogUtil.Info("message.characterSet:", message.CharacterSet);
LogUtil.Info("message.format:", message.Format);
printMsgId("before put correlationId", message.CorrelationId);
para.queue.Put(message, pmo);
para.qManager.Commit();
printMsgId("after put MsgId", message.MessageId);
return(true);
} catch (MQException mqe) {
throw mqe;
} finally {
pmo = null;
}
}
public void SendMQ(string xm)
{
string messageXML = xm;
bool sent = false;
int tries = 1;
lock (sendLock) {
try {
using (MQQueueManager queueManager = new MQQueueManager(qMgr, connectionParams)) {
var openOptions = MQC.MQOO_OUTPUT + MQC.MQOO_FAIL_IF_QUIESCING;
MQQueue queue = queueManager.AccessQueue(queueName, openOptions);
var message = new MQMessage {
CharacterSet = 1208 // UTF-8
};
message.WriteString(messageXML);
message.Format = MQC.MQFMT_STRING;
MQPutMessageOptions putOptions = new MQPutMessageOptions();
queue.Put(message, putOptions);
queue.Close();
sent = true;
logger.Trace($"===Message Sent to {queueName}");
}
} catch (Exception ex) {
tries++;
logger.Info(ex.Message);
logger.Info("Error send MQ Message");
}
if (!sent)
{
logger.Trace($"===Message NOT Sent to {queueName}");
}
}
}
public async Task <ExchangeMessage> SendMqStuff(ExchangeMessage xm)
{
await Task.Run(() => { });
string messageXML = xm.payload;
bool sent = false;
int tries = 1;
lock (sendLock)
{
do
{
if (tries > maxRetry && maxRetry > 0)
{
xm.sent = false;
xm.status = $"Exceeded Connection retries on MQ {queueName}";
return(xm);
}
try
{
using (MQQueueManager queueManager = new MQQueueManager(qMgr, connectionParams))
{
var openOptions = MQC.MQOO_OUTPUT + MQC.MQOO_FAIL_IF_QUIESCING;
MQQueue queue = queueManager.AccessQueue(queueName, openOptions);
var message = new MQMessage
{
CharacterSet = 1208 // UTF-8
};
message.WriteString(messageXML);
message.Format = MQC.MQFMT_STRING;
MQPutMessageOptions putOptions = new MQPutMessageOptions();
queue.Put(message, putOptions);
queue.Close();
sent = true;
logger.Trace($"===Message Sent {xm.uuid} to {queueName}");
}
}
catch (Exception ex)
{
if (!isLogger)
{
logger.Info("Unable to send message to : " + queueName + " : " + ex.Message);
}
tries++;
}
if (!sent)
{
logger.Trace($"===Message NOT Sent {xm.uuid} to {queueName}");
}
} while (!sent);
}
xm.sent = true;
xm.status = $"Sent to MQ {queueName}";
return(xm);
}
public string WriteLocalQMsg(string strInputMsg, string strQueueName, int queueId, string ChannelInfo, string queueMgrName)
{
string strReturn = "";
SendQueueName = strQueueName;
MQQueueManager queueMgr;
MQQueue queue;
if (queueId == 1)
{
queueMgr = queueManager1;
}
else
{
queueMgr = queueManager2;
}
try
{
if (queueMgr == null || queueMgr.IsConnected == false)
{
ConnectMQ(queueMgrName, ChannelInfo, queueId);
//Reassign After Connection
if (queueId == 1)
{
queueMgr = queueManager1;
}
else
{
queueMgr = queueManager2;
}
}
queue = queueMgr.AccessQueue(SendQueueName,
MQC.MQOO_OUTPUT + MQC.MQOO_FAIL_IF_QUIESCING);
message = strInputMsg;
queueMessage = new MQMessage();
queueMessage.Format = MQC.MQFMT_STRING;
queueMessage.CharacterSet = MQC.CODESET_850;
queueMessage.Encoding = MQC.MQENC_NATIVE;
queueMessage.WriteString(message);
queuePutMessageOptions = new MQPutMessageOptions();
queue.Put(queueMessage, queuePutMessageOptions);
strReturn = "Message sent to the queue successfully";
}
catch (MQException MQexp)
{
strReturn = "Exception: " + MQexp.Message;
}
catch (Exception exp)
{
strReturn = "Exception: " + exp.Message;
}
return(strReturn);
}
public MQPutMessageOptions NewMQPMO()
{
uint method = 0x2e6;
this.TrEntry(method);
MQPutMessageOptions result = new MQPutMessageOptions();
base.TrExit(method, result);
return(result);
}
/// <summary>
/// send a given queue message through the given queue
/// </summary>
/// <param name="queue"></param>
/// <param name="qMessage"></param>
/// <returns></returns>
public bool SendMessage(MQQueue queue, MQMessage qMessage)
{
bool sentFlag = false;
MQPutMessageOptions msgOptions = new MQPutMessageOptions();
queue.Put(qMessage, msgOptions);
sentFlag = true;
return(sentFlag);
}
public void PutMessageBlock(string messageContent)
{
var putMessageOptions = new MQPutMessageOptions();
// add for transactions
// putMessageOptions.Options += MQC.MQPMO_SYNCPOINT;
PutMessage(messageContent, putMessageOptions);
// commit transaction
}
protected MQMessage[] Send(int command, PCFParameter[] parameters)
{
if (parameters == null)
{
throw new Exception("Must specify parameters!");
}
MQQueue queue = this.qMgr.AccessQueue("SYSTEM.DEFAULT.MODEL.QUEUE", 0x2021);
MQMessage message = new MQMessage();
message.ReplyToQueueName = queue.Name;
message.MessageType = 1;
message.Feedback = 0;
message.Format = "MQADMIN ";
message.Report = 0;
MQCFH.Write(message, command, parameters.Length);
for (int i = 0; i < parameters.Length; i++)
{
parameters[i].Write(message);
}
MQQueue queue2 = this.qMgr.AccessQueue(this.qMgr.CommandInputQueueName, 0x2030);
MQPutMessageOptions pmo = new MQPutMessageOptions();
pmo.Options = 0x40;
queue2.Put(message, pmo);
MQGetMessageOptions gmo = new MQGetMessageOptions();
gmo.Options = 0x2001;
gmo.WaitInterval = this.waitInterval;
gmo.MatchOptions = 2;
ArrayList list = new ArrayList();
MQMessage message2 = null;
int compCode = 0;
int reason = 0;
int num4 = 1;
do
{
message2 = new MQMessage();
message2.CorrelationId = message.MessageId;
queue.Get(message2, gmo);
message2.SkipBytes(20);
num4 = message2.ReadInt4();
compCode = message2.ReadInt4();
reason = message2.ReadInt4();
message2.Seek(0);
if (compCode != 0)
{
throw new PCFException(compCode, reason);
}
list.Add(message2);
}while (num4 == 0);
queue2.Close();
queue.Close();
return((MQMessage[])list.ToArray(typeof(MQMessage)));
}
public void SendFile(string filePath, string DesQueueName)
{
using (FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read))
{
byte[] buff = new byte[FILE_SPLIT_LEN];
var fileName = System.IO.Path.GetFileName(filePath);
var queue = queueManager.AccessQueue(DesQueueName,
MQC.MQOO_OUTPUT + MQC.MQOO_FAIL_IF_QUIESCING);
MQPutMessageOptions op = new MQPutMessageOptions();
op.Options = op.Options + MQC.MQPMO_LOGICAL_ORDER;
op.Options = op.Options + MQC.MQPMRF_GROUP_ID;
int count = -1;
MQMessage msg = new MQMessage();
msg.MessageFlags = MQC.MQMF_MSG_IN_GROUP;
msg.MQMD.CorrelId = System.Text.Encoding.Default.GetBytes("000|21");
bool isContainFileName = true;
while (true)
{
if (isContainFileName)
{
byte[] headBytes = System.Text.Encoding.Default.GetBytes(fileName + "|");
List <byte> totalBytes = new List <byte>();
totalBytes.AddRange(headBytes);
byte[] b = new byte[FILE_SPLIT_LEN - headBytes.Length];
var tempCount = fs.Read(b, 0, FILE_SPLIT_LEN - headBytes.Length);
count = tempCount + headBytes.Length;
totalBytes.AddRange(b);
msg.Write(totalBytes.ToArray(), 0, count);
isContainFileName = false;
}
else
{
count = fs.Read(buff, 0, FILE_SPLIT_LEN);
msg.Write(buff, 0, count);
}
if (count == 0)
{
break;
}
if (count < FILE_SPLIT_LEN)
{
msg.MessageFlags = MQC.MQMF_LAST_MSG_IN_GROUP;
}
queue.Put(msg, op);
msg.ClearMessage();
}
queue.Close();
queueManager.Disconnect();
LogMsg(string.Format("【SEND】\t【FILE】\t【{0}】\t【{1}】", DesQueueName, fileName));
}
}
public void Put(string queueName, MQMessage message)
{
MQQueue mqQueue = _mqQueueManager.AccessQueue(queueName, MQC.MQOO_OUTPUT + MQC.MQOO_FAIL_IF_QUIESCING);
MQPutMessageOptions putMessageOptions = new MQPutMessageOptions();
putMessageOptions.Options += MQC.MQGMO_SYNCPOINT;
mqQueue.Put(message, putMessageOptions);
mqQueue.Close();
}
/// <summary>
/// send the message to the MQSeries's queue
/// </summary>
/// <param name="m">a message object to be sent</param>
public void Send(Message m)
{
//create a new MQSeries message
MQMessage message = (MQMessage)queueSession.AccessMessage();
message.WriteString(m.Content.ToString());
MQPutMessageOptions messageOption = (MQPutMessageOptions)queueSession.AccessPutMessageOptions();
//send the message to the MQSeries queue
queue.Put(message, messageOption);
}
private void PutAndGetMqSeries()
{
Hashtable connectionProperties = init(connectionType);
// Create a connection to the queue manager using the connection
// properties just defined
MQQueueManager qMgr = new MQQueueManager(qManager, connectionProperties);
// Set up the options on the queue we want to open
int openOptions = MQC.MQOO_INPUT_AS_Q_DEF | MQC.MQOO_OUTPUT;
// Now specify the queue that we want to open,and the open options
MQQueue system_default_local_queue =
qMgr.AccessQueue("SYSTEM.DEFAULT.LOCAL.QUEUE", openOptions);
// Define an IBM MQ message, writing some text in UTF format
MQMessage hello_world = new MQMessage();
hello_world.WriteUTF("Hello World!");
// Specify the message options
MQPutMessageOptions pmo = new MQPutMessageOptions(); // accept the defaults,
// same as MQPMO_DEFAULT
// Put the message on the queue
system_default_local_queue.Put(hello_world, pmo);
// Get the message back again
// First define an IBM MQ message buffer to receive the message
MQMessage retrievedMessage = new MQMessage();
retrievedMessage.MessageId = hello_world.MessageId;
// Set the get message options
MQGetMessageOptions gmo = new MQGetMessageOptions(); //accept the defaults
//same as MQGMO_DEFAULT
// Get the message off the queue
system_default_local_queue.Get(retrievedMessage, gmo);
// Prove we have the message by displaying the UTF message text
String msgText = retrievedMessage.ReadUTF();
Console.WriteLine("The message is: {0}", msgText);
// Close the queue
system_default_local_queue.Close();
// Disconnect from the queue manager
qMgr.Disconnect();
}
/// <summary>
/// Moves the given message to the configured error queue.
/// </summary>
/// <param name="m"></param>
protected void MoveToErrorQueue(MQMessage m)
{
m.ApplicationIdData = m.ApplicationIdData +
string.Format("<{0}>{1}</{0}>", FAILEDQUEUE, InputQueue);
if (!string.IsNullOrEmpty(this.ErrorQueue))
{
MQPutMessageOptions queuePutMessageOptions = new MQPutMessageOptions();
receiveResourceManager.PutMessage(ErrorQueue, m, queuePutMessageOptions);
}
}
public void OnNext(MQMessage value)
{
if (queue == null || queueManager == null || !queueManager.IsConnected || !queue.IsOpen)
{
queueManager = _mqQueueManagerFactory();
queue = queueManager.AccessQueue(_qname, MQC.MQOO_INPUT_AS_Q_DEF | MQC.MQOO_OUTPUT);
}
MQPutMessageOptions pmo = new MQPutMessageOptions();
queue.Put(value, pmo);
}
/// <summary>
/// Sends reply to reply queue
/// </summary>
/// <param name="replyString"></param>
/// <param name="msgId"></param>
private void sendReply(String replyString, byte[] msgId)
{
MQMessage msgReply = new MQMessage();
msgReply.WriteUTF(replyString);
msgReply.CorrelationId = msgId;
msgReply.Expiry = 3000;
MQPutMessageOptions mqPmo = new MQPutMessageOptions();
mqPmo.Options |= MQC.MQPMO_SYNCPOINT;
_mqReplyQueue.Put(msgReply, mqPmo);
}
/// <summary>
/// Puts a message in an MQ Queue using the user Id provided
/// <param name="message">The message to be put in the queue</param>
/// <returns>Response message</returns>
/// </summary>
public string PushMQRequestMessage(string message)
{
string location = "NBK.EAI.Adapters.MQAdapter.PushMQRequestMessage";
try
{
MQMessage requestMessage = new MQMessage();
requestMessage.Persistence = 0;
requestMessage.ReplyToQueueName = mqResponseQueueName;
requestMessage.ReplyToQueueManagerName = mqQueueManagerName;
requestMessage.Format = MQC.MQFMT_STRING;
requestMessage.CharacterSet = characterSet;
requestMessage.MessageType = MQC.MQMT_REQUEST;
requestMessage.MessageId = NBK.Common.Foundations.Utilities.ConversionUtilities
.HexToBin(GenerateMQMsgId());
MQPutMessageOptions pmo = new MQPutMessageOptions();
pmo.Options = MQC.MQPMO_SET_IDENTITY_CONTEXT;
requestMessage.WriteString(message);
mqPutQueue.Put(requestMessage, pmo);
string _msgId = NBK.Common.Foundations.Utilities.
ConversionUtilities.BinToHex(requestMessage.MessageId);
NBK.Common.Foundations.Logging.LoggerHelper.Information
(location, "Sent MQ Meesage with MessageId : "
+ _msgId);
return(_msgId);
}
catch (MQException mqe)
{
// Close request Queue if still opened
if (mqPutQueue.OpenStatus)
{
mqPutQueue.Close();
}
// Close Queue manager if still opened
if (mqQueueManager.OpenStatus)
{
mqQueueManager.Close();
}
throw new MQAdapterException("Error Code: " +
MQAdapterErrorReasons.GetMQFailureReasonErrorCode(mqe.Reason));
}
}
public void PutMessage(byte[] msg)
{
if (!isConnected)
{
Init();
}
mqMsg = new MQMessage();
mqMsg.Write(msg);
mqMsg.MessageType = MQC.MQMT_DATAGRAM;
mqPutMsgOpts = new MQPutMessageOptions();
mqQueue.Put(mqMsg, mqPutMsgOpts);
}
/// <summary>
/// Convert from a TransportMessage to a MQMessage
/// </summary>
/// <param name="transportMessage"></param>
/// <returns></returns>
public MQMessage Convert(TransportMessage transportMessage)
{
MQMessage queueMessage = new MQMessage();
MQPutMessageOptions queuePutMessageOptions = new MQPutMessageOptions();
Stream messageStream = new MemoryStream();
System.Text.ASCIIEncoding encoding = new System.Text.ASCIIEncoding();
if (transportMessage.Body == null && transportMessage.BodyStream != null)
{
messageStream = transportMessage.BodyStream;
}
else
{
// convert the message body to a stream
this.messageSerializer.Serialize(transportMessage.Body, messageStream);
}
//write content to the message
StreamReader sr = new StreamReader(messageStream);
messageStream.Position = 0;
queueMessage.WriteString(sr.ReadToEnd());
queueMessage.Format = MQC.MQFMT_STRING;
if (transportMessage.CorrelationId != null)
{
queueMessage.GroupId = encoding.GetBytes(transportMessage.CorrelationId);
}
//TODO Set the recoverable and response queue on the message being sent
//toSend.Recoverable = m.Recoverable;
//toSend.ResponseQueue = new MessageQueue(GetFullPath(m.ReturnAddress));
queueMessage.ReplyToQueueName = transportMessage.ReturnAddress;
FillApplicationIdData(queueMessage, transportMessage);
//TODO Can we set the timeout on a message being sent?
//if (m.TimeToBeReceived < MessageQueue.InfiniteTimeout)
// toSend.TimeToBeReceived = m.TimeToBeReceived;
//TODO How can we pass header information on the message
//if (m.Headers != null && m.Headers.Count > 0)
//{
// MemoryStream stream = new MemoryStream();
// headerSerializer.Serialize(stream, m.Headers);
// toSend.Extension = stream.GetBuffer();
//}
return(queueMessage);
}
//private void CheckConfiguration()
//{
// string machine = GetMachineNameFromLogicalName(InputQueue);
// if (machine.ToLower() != Environment.MachineName.ToLower())
// throw new InvalidOperationException("Input queue must be on the same machine as this process.");
//}
//private void CreateQueuesIfNecessary()
//{
// if (!DoNotCreateQueues)
// {
// string iq = GetFullPathWithoutPrefix(InputQueue);
// logger.Debug("Checking if input queue exists.");
// if (!MessageQueue.Exists(iq))
// {
// logger.Warn("Input queue " + InputQueue + " does not exist.");
// logger.Debug("Going to create input queue: " + InputQueue);
// MessageQueue.Create(iq, true);
// logger.Debug("Input queue created.");
// }
// if (!string.IsNullOrEmpty(ErrorQueue))
// {
// logger.Debug("Checking if error queue exists.");
// string errorMachine = GetMachineNameFromLogicalName(ErrorQueue);
// if (errorMachine != Environment.MachineName)
// {
// logger.Debug("Error queue is on remote machine.");
// logger.Debug("If this does not succeed (if the remote machine is disconnected), processing will continue.");
// }
// try
// {
// string eq = GetFullPathWithoutPrefix(ErrorQueue);
// if (!MessageQueue.Exists(eq))
// {
// logger.Warn("Error queue " + ErrorQueue + " does not exist.");
// logger.Debug("Going to create error queue: " + ErrorQueue);
// MessageQueue.Create(eq, true);
// logger.Debug("Error queue created.");
// }
// }
// catch (Exception ex)
// {
// logger.Error("Could not create error queue or check its existence. Processing will still continue.", ex);
// }
// }
// }
//}
#region Method: Send(mqMessage, destination)
/// <summary>
/// Send a constructed MQMessage to a specified destination
/// </summary>
/// <param name="queueMessage"></param>
/// <param name="destination"></param>
public void Send(MQMessage queueMessage, string destination)
{
// checked to make sure we didn't loose connection to the queue manager.
// reconnect if we did lose connection.
if (!sendResourceManager.IsConnected)
{
InitializeQueueManager(sendResourceManager);
InitializeInputQueue(sendResourceManager);
}
MQPutMessageOptions queuePutMessageOptions = new MQPutMessageOptions();
sendResourceManager.PutMessage(destination, queueMessage, queuePutMessageOptions);
}
public string WriteMsg(string strInputMsg)
{
string strReturn = "";
try
{
queue = queueManager.AccessQueue(QueueName,
MQC.MQOO_OUTPUT + MQC.MQOO_FAIL_IF_QUIESCING);
message = strInputMsg;
queueMessage = new MQMessage();
queueMessage.WriteBytes(strInputMsg);
queueMessage.ReplyToQueueName = "MBK.SESION3.SALIDA";
queueMessage.OriginalLength = 120;
queueMessage.ReplyToQueueManagerName = "IB9QMGR";
queueMessage.DataOffset = 328;
queueMessage.Format = MQC.MQFMT_STRING;
queuePutMessageOptions = new MQPutMessageOptions();
try
{
queue.Put(queueMessage, queuePutMessageOptions);
strReturn = "Message sent to the queue successfully";
}
catch (MQException e)
{
strReturn = "Exception: " + "error al colocar(put) el mensaje en la cola " + QueueName + ". " + e.ToString();
}
}
catch (MQException MQexp)
{
strReturn = "Exception: " + MQexp.Message;
}
catch (Exception exp)
{
strReturn = "Exception: " + exp.Message;
}
return strReturn;
}
/// <summary>
/// Write Message to Local Queue
/// </summary>
/// <param name="strInputMsg">Text Message</param>
/// <param name="strqueueName">Queue Name</param>
/// <returns></returns>
public MQMessageStatus WriteLocalQMsg(string strInputMsg, string strQueueName)
{
MQMessageStatus messageStatus = new MQMessageStatus();
string strReturn = string.Empty;
SendQueueName = strQueueName;
try
{
queue = queueManager.AccessQueue(SendQueueName,
MQC.MQOO_OUTPUT + MQC.MQOO_FAIL_IF_QUIESCING);
message = strInputMsg;
queueMessage = new MQMessage();
queueMessage.WriteString(message);
queueMessage.Format = MQC.MQFMT_STRING;
queuePutMessageOptions = new MQPutMessageOptions();
queue.Put(queueMessage, queuePutMessageOptions);
strReturn = "Message sent to the queue successfully";
messageStatus.Message = strReturn;
messageStatus.Status = true;
}
catch (MQException MQexp)
{
strReturn = "Exception: " + MQexp.Message;
messageStatus.Message = strReturn;
messageStatus.Status = false;
}
catch (Exception exp)
{
strReturn = "Exception: " + exp.Message;
messageStatus.Message = strReturn;
messageStatus.Status = false;
}
return messageStatus;
}
/// <summary>
/// Helper method to write a message to an MQ Series queue
/// </summary>
///
/// <param name="queueManagerName">The name of the MQ Series queue manager</param>
/// <param name="queueName">The name of the MQ Series queue to read from</param>
/// <param name="message">The MQ Series queue</param>
/// <param name="correlId">The correlation ID to be set on the new message</param>
/// <param name="context">The BizUnit context object which holds state and is passed between test steps</param>
static public void WriteMessage(string queueManagerName, string queueName, string message, byte[] correlId, Context context)
{
MQQueueManager queueManager = null;
MQQueue sendQueue = null;
MQMessage mqMessage;
MQPutMessageOptions mqPutMsgOpts;
try
{
context.LogInfo("Opening queue manager: \"{0}\"", queueManagerName);
queueManager = new MQQueueManager(queueManagerName);
context.LogInfo("Opening queue: '{0}'.", queueName);
sendQueue = queueManager.AccessQueue(queueName, MQC.MQOO_OUTPUT + MQC.MQOO_FAIL_IF_QUIESCING );
mqMessage = new MQMessage();
byte[] data = ConvertToBytes(message);
mqMessage.Write(data);
mqMessage.Format = MQC.MQFMT_STRING;
mqPutMsgOpts = new MQPutMessageOptions();
context.LogInfo("Writing {0} byte message to queue '{1}'.", data.Length, queueName);
if (correlId != null)
{
mqMessage.CorrelationId = correlId;
}
sendQueue.Put( mqMessage, mqPutMsgOpts );
}
finally
{
if (sendQueue != null)
{
sendQueue.Close();
}
if (queueManager != null)
{
queueManager.Close();
}
}
}
/// <summary>
/// Puts a message in an MQ Queue using the user Id provided
/// <param name="message">The message to be put in the queue</param>
/// <returns>Response message</returns>
/// </summary>
public string postMQRequestMessage(string message)
{
try
{
MQMessage requestMessage = new MQMessage();
requestMessage.Persistence = 0;
requestMessage.ReplyToQueueName = mqRequestQueueName;
requestMessage.ReplyToQueueManagerName = mqQueueManagerName;
requestMessage.Format = MQC.MQFMT_STRING;
requestMessage.CharacterSet = characterSet;
requestMessage.MessageType = MQC.MQMT_REQUEST;
requestMessage.MessageId = HexaDecimalUtility.ConvertToBinary(GenerateMQMsgId());
requestMessage.CorrelationId = requestMessage.MessageId;
MQPutMessageOptions pmo = new MQPutMessageOptions();
pmo.Options = MQC.MQPMO_SET_IDENTITY_CONTEXT;
requestMessage.WriteString(message);
mqPutQueue.Put(requestMessage, pmo);
string _msgId = BinaryUtility.ConvertToHexaDecimal(requestMessage.MessageId);
return _msgId;
}
catch (MQException mqe)
{
// Close request Queue if still opened
if(mqPutQueue.OpenStatus)
mqPutQueue.Close();
// Close Queue manager if still opened
if(mqQueueManager.OpenStatus)
mqQueueManager.Close();
throw new MQAdapterException("Error Code: " +
MQAdapterErrorReasons.GetMQFailureReasonErrorCode(mqe.Reason));
}
}
