private void GetMessage()
{
try
{
using (MQQueueManager queueManager = new MQQueueManager(qMgr, connectionParams))
{
var openOptions = MQC.MQOO_INPUT_AS_Q_DEF + MQC.MQOO_OUTPUT + MQC.MQOO_FAIL_IF_QUIESCING + MQC.MQOO_INQUIRE;
MQQueue queue = queueManager.AccessQueue(queueName, openOptions);
MQGetMessageOptions getOptions = new MQGetMessageOptions {
WaitInterval = 5, Options = MQC.MQGMO_WAIT
};
MQMessage msg = new MQMessage {
Format = MQC.MQFMT_STRING
};
queue.Get(msg, getOptions);
queue.Close();
}
}
catch (Exception ex)
{
if (!isLogger)
{
logger.Error($"Unable to maintain queue: {queueName}: {ex.Message}");
}
}
}
public IEnumerable JustReadYieldAllMessageFromQueue(string queueName)
{
queue = queueManager.AccessQueue(queueName, MQC.MQOO_BROWSE + MQC.MQOO_FAIL_IF_QUIESCING);
while (true)
{
try
{
queueMessage = new MQMessage();
queueMessage.Format = MQC.MQFMT_STRING;
MQGetMessageOptions mQGetMessageOptions = new MQGetMessageOptions();
//mQGetMessageOptions.Options = MQC.MQGMO_BROWSE_FIRST;
mQGetMessageOptions.Options = MQC.MQGMO_BROWSE_NEXT + MQC.MQGMO_NO_WAIT + MQC.MQGMO_FAIL_IF_QUIESCING;
queue.Get(queueMessage, mQGetMessageOptions);
}
catch (MQException mqexp)
{
queue.Close();
yield break;
}
yield return(queueMessage.ReadString(queueMessage.MessageLength));
}
}
public void MaintainQueueInline()
{
try
{
using (MQQueueManager queueManager = new MQQueueManager(qMgr, connectionParams))
{
int openOptions = MQC.MQOO_INPUT_AS_Q_DEF + MQC.MQOO_OUTPUT + MQC.MQOO_FAIL_IF_QUIESCING + MQC.MQOO_INQUIRE;
MQQueue queue = queueManager.AccessQueue(queueName, openOptions);
MQGetMessageOptions getOptions = new MQGetMessageOptions {
WaitInterval = 5, Options = MQC.MQGMO_WAIT
};
MQMessage msg = new MQMessage {
Format = MQC.MQFMT_STRING
};
while (queue.CurrentDepth > this.maxMessages)
{
GetMessage();
}
queue.Close();
}
}
catch (Exception ex)
{
if (!isLogger)
{
logger.Error($"Unable to maintain queue: {queueName}: {ex.Message}");
}
}
}
/// <summary>
/// Read Message from Local Queue
/// </summary>
/// <param name="strqueueName">Queue Name</param>
/// <returns>Text Message</returns>
public MQMessageStatus ReadLocalQMsg(string strQueueName)
{
MQMessageStatus messageStatus = new MQMessageStatus();
string strReturn = string.Empty;
ReceiveQueueName = strQueueName;
try
{
queue = queueManager.AccessQueue(ReceiveQueueName,
MQC.MQOO_INPUT_AS_Q_DEF + MQC.MQOO_FAIL_IF_QUIESCING);
queueMessage = new MQMessage();
queueMessage.Format = MQC.MQFMT_STRING;
queueGetMessageOptions = new MQGetMessageOptions();
queue.Get(queueMessage, queueGetMessageOptions);
strReturn = queueMessage.ReadString(queueMessage.MessageLength);
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);
}
public void TopicPublish_Ok()
{
var message = "PublishInTopic";
using (var broker = MQQueueManager.Connect(QueueManagerName, 0, Channel, ConnectionInfo))
using (var topic = new MQTopic(broker, TopicName, string.Empty, MQC.MQTOPIC_OPEN_AS_PUBLICATION, MQC.MQOO_OUTPUT + MQC.MQOO_FAIL_IF_QUIESCING))
{
var outgoing = new MQMessage()
{
CharacterSet = MQC.CODESET_UTF,
Encoding = MQC.MQENC_NORMAL
};
outgoing.WriteString(message);
topic.Publish(outgoing, new MQPutMessageOptions());
}
using (var broker = MQQueueManager.Connect(QueueManagerName, 0, Channel, ConnectionInfo))
using (var q = broker.AccessQueue("QL.R4.EMPLEADOSANDREANI.SUBSCRIBER", MQC.MQOO_INPUT_AS_Q_DEF + MQC.MQOO_FAIL_IF_QUIESCING))
{
var incoming = new MQMessage();
MQGetMessageOptions gmo = new MQGetMessageOptions();
gmo.WaitInterval = (int)TimeSpan.FromSeconds(30).TotalMilliseconds; //MQC.MQWI_UNLIMITED;
gmo.Options |= MQC.MQGMO_WAIT;
gmo.Options |= MQC.MQGMO_SYNCPOINT;
q.Get(incoming, gmo);
Assert.AreEqual(message, incoming.ReadString(incoming.DataLength));
}
}
public void GetMessage(MQMessage message, MQGetMessageOptions getOptions)
{
Transaction currentTx = Transaction.Current;
if (currentTx != null)
{
getOptions.Options |= MQC.MQGMO_SYNCPOINT;
currentTx.EnlistVolatile(this, EnlistmentOptions.None);
}
try
{
Queue.Get(message, getOptions);
}
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;
}
}
private void testLoop(MQQueue inQ)
{
bool flag = true;
MQGetMessageOptions gmo = new MQGetMessageOptions();
gmo.Options |= MQC.MQGMO_WAIT | MQC.MQGMO_FAIL_IF_QUIESCING;
gmo.WaitInterval = 2500; // 2.5 seconds wait time or use MQC.MQEI_UNLIMITED to wait forever
MQMessage msg = null;
while (flag)
{
try
{
msg = new MQMessage();
inQ.Get(msg, gmo);
System.Console.Out.WriteLine("Message Data: " + msg.ReadString(msg.MessageLength));
}
catch (MQException mqex)
{
System.Console.Out.WriteLine("MQTest62 CC=" + mqex.CompletionCode + " : RC=" + mqex.ReasonCode);
if (mqex.Reason == MQC.MQRC_NO_MSG_AVAILABLE)
{
// no meesage - life is good - loop again
}
else
{
flag = false; // severe error - time to exit
}
}
catch (System.IO.IOException ioex)
{
System.Console.Out.WriteLine("MQTest62 ioex=" + ioex);
}
}
}
void PurgeInputQueue()
{
MQGetMessageOptions getMessageOptions = new MQGetMessageOptions();
getMessageOptions.Options |= MQC.MQGMO_NO_WAIT;
bool isContinue = true;
while (isContinue)
{
MQMessage message = new MQMessage();
try
{
receiveResourceManager.GetMessage(message, getMessageOptions);
}
catch (MQException mqe)
{
// report reason, if any
if (mqe.Reason == MQC.MQRC_NO_MSG_AVAILABLE)
{
isContinue = false;
}
else
{
// general report for other reasons
throw new ApplicationException("MQQueue::Get ended with " + mqe.Message);
}
}
}
}
private MQMessage getMessagebyCorelationId(MQQueue queue, string correlationId)
{
MQGetMessageOptions gmo = new MQGetMessageOptions();
gmo.Options = MQC.MQGMO_FAIL_IF_QUIESCING | MQC.MQGMO_WAIT | MQC.MQGMO_SYNCPOINT | MQC.MQMO_MATCH_CORREL_ID;
;
gmo.WaitInterval = 5000;
MQMessage message = new MQMessage();
message.CorrelationId = System.Text.ASCIIEncoding.ASCII.GetBytes(correlationId);
MQQueueManager manager = _mqManagerReviewQueue;
try
{
//wait for message
queue.Get(message, gmo);;
manager.Commit();
}
catch (MQException ex)
{
message = null;
if (ex.CompletionCode == MQC.MQCC_FAILED && ex.ReasonCode == MQC.MQRC_NO_MSG_AVAILABLE)
{
return(null);
}
else
{
throw ex;
}
}
return(message);
}
private string GetMessage(MQGetMessageOptions getMessageOptions)
{
// transactions: add wait
// transactions: add rollback wait check
try
{
// if transaction exists, add transaction complete handler
var message = new MQMessage();
_queue.Get(message, getMessageOptions);
var result = message.ReadString(message.MessageLength);
message.ClearMessage();
return(result);
}
catch (MQException mqe)
{
// queue empty
if (mqe.ReasonCode == 2033)
{
return(null);
}
// wrap exception
throw;
}
}
public void Put1InQueue_Ok()
{
string message = "Put1InQueue";
using (var broker = MQQueueManager.Connect(QueueManagerName, 0, Channel, ConnectionInfo))
{
var outgoing = new MQMessage()
{
CharacterSet = MQC.CODESET_UTF,
Encoding = MQC.MQENC_NORMAL
};
outgoing.WriteString(message);
var od = new MQObjectDescriptor
{
ObjectType = MQC.MQOT_Q,
ObjectName = QueueName
};
broker.Put1(od, outgoing, new MQPutMessageOptions());
using (var q = broker.AccessQueue(QueueName, MQC.MQOO_INPUT_AS_Q_DEF + MQC.MQOO_OUTPUT + MQC.MQOO_FAIL_IF_QUIESCING))
{
var incoming = new MQMessage();
MQGetMessageOptions gmo = new MQGetMessageOptions();
gmo.WaitInterval = (int)TimeSpan.FromSeconds(30).TotalMilliseconds; //MQC.MQWI_UNLIMITED;
gmo.Options |= MQC.MQGMO_WAIT;
gmo.Options |= MQC.MQGMO_SYNCPOINT;
q.Get(incoming, gmo);
Assert.AreEqual(message, incoming.ReadString(incoming.DataLength));
}
}
}
/// <summary>
/// 获取队列消息
/// </summary>
private string GetQueueMsg(string business)
{
string message = string.Empty;
try
{
string queueName = string.Format(IBMWMQConfig.TOPIC_TEMPLATE, business);
using (var mqmgr = MQQueueManager.Connect(IBMWMQConfig.QUEUE_MGR_NAME, MQC.MQCO_NONE, IBMWMQConfig.CHANNEL, IBMWMQConfig.CONNECTION_INFO))
using (var q = mqmgr.AccessQueue(queueName, MQC.MQOO_INPUT_AS_Q_DEF + MQC.MQOO_OUTPUT + MQC.MQOO_FAIL_IF_QUIESCING))
{
var incoming = new MQMessage();
MQGetMessageOptions gmo = new MQGetMessageOptions();
gmo.WaitInterval = 10 * 1000; //MQC.MQWI_UNLIMITED;
gmo.Options |= MQC.MQGMO_WAIT;
gmo.Options |= MQC.MQGMO_SYNCPOINT;
q.Get(incoming, gmo);
message = incoming.ReadString(incoming.DataLength);
}
}
catch (MQException e)
{
message = e.Reason.ToString();
}
return(message);
}
private bool SetBrowseCursorAtMessageId(MQQueue queue, byte[] msgId)
{
var getMsgOpts = new MQGetMessageOptions()
{
Options = MQC.MQGMO_FAIL_IF_QUIESCING | MQC.MQGMO_BROWSE_FIRST
};
try
{
getMsgOpts.MatchOptions = MQC.MQMO_MATCH_MSG_ID;
var msg = new MQMessage
{
MessageId = msgId
};
queue.Get(msg, getMsgOpts);
return(true);
}
catch (MQException ex)
{
if (ex.ReasonCode != MQC.MQRC_NO_MSG_AVAILABLE)
{
throw;
}
return(false);
}
}
public string ReadOneMensage()
{
MQQueueManager qMgr = new MQQueueManager(IbmConection.DbConection[5], _queueManagerProperties);
// Agora especifique a fila que queremos abrir e as opções de abertura
MQQueue fila = qMgr.AccessQueue(IbmConection.DbConection[6], MQC.MQQA_GET_ALLOWED + MQC.MQQA_GET_INHIBITED + MQC.MQOO_INPUT_AS_Q_DEF + MQC.MQOO_OUTPUT + MQC.MQOO_FAIL_IF_QUIESCING + MQC.MQOO_INQUIRE + MQC.MQOO_BROWSE);
MQMessage retrievedMessage = new MQMessage();
// Defina as opções de obtenção de mensagens
MQGetMessageOptions gmo = new MQGetMessageOptions(); // aceita os padrões
// mesmo que MQGMO_DEFAULT
string msgText = "";
if (fila.CurrentDepth > 0)
{
// Tire a mensagem da fila
fila.Get(retrievedMessage, gmo);
msgText = retrievedMessage.ReadUTF();
return(msgText);
}
else
{
return(msgText);
}
}
public List <MQMessage> BrowseMessages(string queueName)
{
int totalMessages = MessageCount(queueName);
MQQueue mqQueue = _mqQueueManager.AccessQueue(queueName, MQC.MQOO_BROWSE);
MQGetMessageOptions messageOptions = new MQGetMessageOptions {
Options = MQC.MQGMO_BROWSE_FIRST
};
if (totalMessages > 0)
{
List <MQMessage> messages = new List <MQMessage>();
for (int i = 1; i <= totalMessages; i++)
{
// Gettin an IBM MQ message from the queue.
MQMessage message = new MQMessage();
mqQueue.Get(message, messageOptions);
messages.Add(message);
// get next message
messageOptions.Options = MQC.MQGMO_BROWSE_NEXT;
}
mqQueue.Close();
return(messages);
}
mqQueue.Close();
return(null);
}
/**
* 通过匹配的msgID来从Queue中获取消息
* @param msgId Q队列的消息标识
* @param para MQ连接实例对象
* @param type 设置接收消息
* @param timeout < 0:则无限等待;< 0:从MQ队列连接的超时时间，单位秒
* @return
* @throws EisException
*/
public static MQMessage getMsgFromQueue(byte[] msgId, MQCParameter para, int timeout)
{
try{
MQGetMessageOptions gmo = getGMOFromPara(timeout);
if (para.qManager == null || para.queue == null)
{
connectMQExce(para, MQQueueAccesser.MQ_MSGRECEIVE_TYPE);
}
MQMessage msg = new MQMessage();
if (msgId != null)
{
msg.MessageId = msgId;
}
printMsgId("before get MsgId", msg.MessageId);
// 从MQ请求队列拿消息
para.queue.Get(msg, gmo);
printMsgId("after get MsgId", msg.MessageId);
return(msg);
}catch (MQException mqe) {
throw mqe;
}catch (Exception e) {
throw new EisException(MQCException.MQ_MSG_RECEIVE_GETMSG_ERROR_EXCEPTION_CODE);
}
// return null;
}
public string ReadMsg()
{
String strReturn = "";
try
{
queue = queueManager.AccessQueue(QueueName,
MQC.MQOO_INPUT_AS_Q_DEF + MQC.MQOO_FAIL_IF_QUIESCING);
queueMessage = new MQMessage();
queueMessage.Format = MQC.MQFMT_STRING;
queueGetMessageOptions = new MQGetMessageOptions();
queue.Get(queueMessage, queueGetMessageOptions);
strReturn =
queueMessage.ReadString(queueMessage.MessageLength);
}
catch (MQException MQexp)
{
strReturn = "Exception : " + MQexp.Message;
}
catch (Exception exp)
{
strReturn = "Exception: " + exp.Message;
}
return(strReturn);
}
private MQMessage getMessage(MQQueue queue)
{
MQGetMessageOptions gmo = new MQGetMessageOptions();
gmo.Options = MQC.MQGMO_FAIL_IF_QUIESCING | MQC.MQGMO_WAIT | MQC.MQGMO_SYNCPOINT;
gmo.WaitInterval = 5000;
MQMessage message = new MQMessage();
try
{
//wait for message
queue.Get(message, gmo);;
}
catch (MQException ex)
{
message = null;
if (ex.CompletionCode == MQC.MQCC_FAILED && ex.ReasonCode == MQC.MQRC_NO_MSG_AVAILABLE)
{
return(null);
}
else
{
throw ex;
}
}
return(message);
}
/// <summary>
/// Receive a reply message
/// </summary>
/// <returns></returns>
public String ReceiveMessage(byte[] messageId)
{
String retMsg = "";
MQMessage mqMsg = null;
try
{
mqMsg = new MQMessage();
mqMsg.CorrelationId = messageId;
MQGetMessageOptions gmo = new MQGetMessageOptions();
gmo.MatchOptions |= MQC.MQMO_MATCH_CORREL_ID;
gmo.WaitInterval = 3000;
gmo.Options |= MQC.MQGMO_WAIT;
replyQ.Get(mqMsg, gmo);
retMsg = mqMsg.ReadUTF();
}
catch (MQException ex)
{
if (ex.Reason == 2033)
{
retMsg = "";
}
else
{
throw ex;
}
}
return(retMsg);
}
public void LoopThruMessages()
{
MQGetMessageOptions gmo = new MQGetMessageOptions();
gmo.Options |= MQC.MQGMO_WAIT | MQC.MQGMO_FAIL_IF_QUIESCING;
gmo.WaitInterval = 2500; // 2.5 seconds wait time or use MQC.MQEI_UNLIMITED to wait forever
MQMessage msg = null;
while (running)
{
try
{
msg = new MQMessage();
inQ.Get(msg, gmo);
System.Console.Out.WriteLine("Message Data: " + msg.ReadString(msg.MessageLength));
}
catch (MQException mqex)
{
if (mqex.Reason == MQC.MQRC_NO_MSG_AVAILABLE)
{
// no meesage - life is good - loop again
}
else
{
running = false; // severe error - time to exit
System.Console.Out.WriteLine("MQException CC=" + mqex.CompletionCode + " : RC=" + mqex.ReasonCode);
}
}
catch (System.IO.IOException ioex)
{
System.Console.Out.WriteLine("ioex=" + ioex);
}
}
try
{
if (inQ != null)
{
inQ.Close();
System.Console.Out.WriteLine("Closed queue");
}
}
catch (MQException mqex)
{
System.Console.Out.WriteLine("MQException CC=" + mqex.CompletionCode + " : RC=" + mqex.ReasonCode);
}
try
{
if (qMgr != null)
{
qMgr.Disconnect();
System.Console.Out.WriteLine("disconnected from queue manager");
}
}
catch (MQException mqex)
{
System.Console.Out.WriteLine("MQException CC=" + mqex.CompletionCode + " : RC=" + mqex.ReasonCode);
}
}
/// <summary>
/// ITestStep.Execute() implementation
/// </summary>
/// <param name='testConfig'>The Xml fragment containing the configuration for this test step</param>
/// <param name='context'>The context for the test, this holds state that is passed beteen tests</param>
public void Execute(XmlNode testConfig, Context context)
{
var qmgr = context.ReadConfigAsString(testConfig, "QueueManager");
try
{
context.LogInfo("Opening queue manager '{0}'.", qmgr);
using (var queueManager = new MQQueueManager(qmgr))
{
var queueNodes = testConfig.SelectNodes("Queue");
foreach (XmlNode queueNode in queueNodes)
{
var q = queueNode.InnerText;
context.LogInfo("Opening queue '{0}'.", q);
using (
var queue = queueManager.AccessQueue(q,
MQC.MQOO_INPUT_AS_Q_DEF + MQC.MQOO_FAIL_IF_QUIESCING))
{
try
{
var mqMsg = new MQMessage();
var mqMsgOpts = new MQGetMessageOptions();
var i = 0;
while (true)
{
try
{
// Get message from queue
queue.Get(mqMsg, mqMsgOpts);
i++;
}
catch (MQException mqe)
{
if (mqe.Reason == 2033) // No more messages.
{
break;
}
throw;
}
}
context.LogInfo("Cleared {0} messages from queue '{1}'.", i, q);
}
catch (Exception e)
{
context.LogError("Failed to clear queue \"{0}\" with the following exception: {1}", q,
e.ToString());
throw;
}
}
}
}
}
catch (MQException e)
{
throw new InvalidOperationException(string.Format("Failed to open queue manager {0}.", qmgr), e);
}
}
public void DeleteMessages(IList <IMessage> messages, CancellationToken ct, IProgress <int> progress = null)
{
if (messages == null)
{
throw new ArgumentNullException(nameof(messages));
}
try
{
var ibmQueue = OpenQueueCore(OpenQueueMode.ForRead);
try
{
var mqGetMsgOpts = new MQGetMessageOptions
{
Options = MQC.MQGMO_FAIL_IF_QUIESCING,
MatchOptions = MQC.MQMO_MATCH_MSG_ID
};
int count = 0;
foreach (var m in messages)
{
if (progress != null && ct.IsCancellationRequested)
{
break;
}
try
{
var msg = ((WsMessage)m).IbmMessage;
ibmQueue.Get(msg, mqGetMsgOpts);
count++;
progress?.Report(count);
}
catch (MQException ex)
{
if (ex.ReasonCode == 2033 /* MQRC_NO_MSG_AVAILABLE */)
{
}
else
{
throw;
}
}
}
}
finally
{
ibmQueue.Close();
}
}
catch (MQException ibmEx)
{
throw ibmEx.ToMqException(AddExtraInfoToError);
}
}
public void ReadMQMessage()
{
try
{
// get message options
MQGetMessageOptions mqGMO = new MQGetMessageOptions();
mqGMO.Options = MQC.MQGMO_FAIL_IF_QUIESCING + MQC.MQGMO_NO_WAIT + MQC.MQGMO_BROWSE_NEXT; // browse with no wait
mqGMO.MatchOptions = MQC.MQMO_NONE;
queueManager = new MQQueueManager(queueManagerName, mqProperties);
//queIn = queueManager.AccessQueue(queueName, MQC.MQOO_FAIL_IF_QUIESCING);
queIn = queueManager.AccessQueue(queueName, MQC.MQOO_INPUT_AS_Q_DEF + MQC.MQOO_FAIL_IF_QUIESCING);
while (true)
{
try
{
queueManager = new MQQueueManager(queueManagerName, mqProperties);
queIn = queueManager.AccessQueue(queueName, MQC.MQOO_INPUT_AS_Q_DEF + MQC.MQOO_FAIL_IF_QUIESCING);
while (true)
{
mqMessage = new MQMessage();
//queIn.Get(mqMessage, mqGMO);
queIn.Get(mqMessage);
string message = mqMessage.ReadString(mqMessage.MessageLength);
mqMessage.ClearMessage();
bool isFileSaved = SaveFile(message);
}
}
catch (MQException mqe)
{
if (queIn != null && queIn.IsOpen)
{
queIn.Close();
}
if (queueManager != null && queueManager.IsConnected)
{
queueManager.Disconnect();
}
if (mqe.ReasonCode == 2033)
{
Console.WriteLine("No Message");
Thread.Sleep(10000);
}
else
{
Console.WriteLine(mqe.ReasonCode + " : " + mqe.Reason);
}
}
}
}
catch (MQException mqe)
{
Console.WriteLine("Conneciton Error: " + mqe.ReasonCode + " : " + mqe.Reason);
}
//Thread.Sleep(10000);
}
public MQGetMessageOptions NewMQGMO()
{
uint method = 0x2e7;
this.TrEntry(method);
MQGetMessageOptions result = new MQGetMessageOptions();
base.TrExit(method, result);
return(result);
}
public string GetMessageBlock()
{
var getMessageOptions = new MQGetMessageOptions();
// transactions:
// getMessageOptions.Options += MQC.MQGMO_SYNCPOINT;
getMessageOptions.Options += MQC.MQGMO_WAIT;
getMessageOptions.WaitInterval = _queueOptions.WaitMilliseconds;
return(GetMessage(getMessageOptions));
}
public void getFileFromMQ()
{
if (!String.IsNullOrEmpty(RecvQueue) || !String.IsNullOrEmpty(RecvFolder))
{
try
{
IList FileList = new ArrayList();
string fileName = "";
//初始化环境变量
MQEnvironment.Hostname = HostName; //服务器的IP
MQEnvironment.Channel = SvrCHL; //服务器连接通道
MQEnvironment.Port = HostPort;
Environment.SetEnvironmentVariable("MQCCSID", CCSID);
string qManager = MQName; //队列管理器
string QLName = RecvQueue; //接收队列
MQQueueManager queueManager = new MQQueueManager(qManager);
int OutOpenOptions = MQC.MQOO_INPUT_AS_Q_DEF | MQC.MQOO_INQUIRE;
queueGetMessageOptions = new MQGetMessageOptions();
queueGetMessageOptions.Options = MQC.MQGMO_FAIL_IF_QUIESCING | MQC.MQGMO_WAIT;
queueGetMessageOptions.MatchOptions = MQC.MQMO_MATCH_CORREL_ID;
queueGetMessageOptions.WaitInterval = 500;
queueMessage = new MQMessage();
queueMessage.Format = MQC.MQFMT_STRING;
queue = queueManager.AccessQueue(QLName, OutOpenOptions);
while (queue.CurrentDepth > 0)
{
queue.Get(queueMessage, queueGetMessageOptions);
fileName = saveRecvFile(queueMessage, RecvFolder);
//if (!FileList.Contains(fileName))
//{
// FileList.Add(fileName);
//}
Console.Write("[" + DateTime.Now.ToString("MM-dd HH:mm:ss") + "]提取成功:" + fileName + "\r\n");
}
}
catch (MQException MQExp)
{
Console.Write("[" + DateTime.Now.ToString("MM-dd HH:mm:ss") + "]提取失败:" + MQExp.Message + "\r\n");
}
finally
{
if (queue != null)
{
queue.Close();
}
}
}
else
{
Console.Write("[" + DateTime.Now.ToString("MM-dd HH:mm:ss") + "]提取失败:无RecvQueue配置\r\n");
}
}
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)));
}
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();
}
public bool MessageWaiting(string queueName, int timeOutms)
{
bool hasMessage = false;
MQQueue queue = null;
MQMessage message = new MQMessage();
try
{
// MQOO_BROWSE option means the message is NOT removed from the queue when it is read
// We just want to know if there is at least one message in the queue so the listener
// can take the appropriate action
queue = _queueManager.AccessQueue(queueName, MQC.MQOO_BROWSE + MQC.MQOO_FAIL_IF_QUIESCING);
MQGetMessageOptions opt = new MQGetMessageOptions();
if (opt != null)
{
opt.Options = IBM.WMQ.MQC.MQGMO_BROWSE_FIRST;
message.CorrelationId = IBM.WMQ.MQC.MQMI_NONE;
message.MessageId = IBM.WMQ.MQC.MQMI_NONE;
if (timeOutms > 0)
{
opt.Options += IBM.WMQ.MQC.MQGMO_WAIT;
opt.WaitInterval = timeOutms;
}
}
queue.Get(message, opt);
hasMessage = true;
}
catch (MQException mqe)
{
if (mqe.ReasonCode == 2033)
{
hasMessage = false;
}
else
{
//eventLog1.WriteEntry("MQException caught: {0} - {1}", mqe.ReasonCode, mqe.Message);
}
}
catch (Exception ex)
{
//eventLog1.WriteEntry(ex);
}
finally
{
if (queue != null)
{
queue.Close();
}
}
return(hasMessage);
}
/// <summary>
/// Get a message from an MQ Queue using a message id
/// </summary>
/// <param name="correlationId">correlation id</param>
/// <returns>Response message</returns>
public string GetMQResponseMessage(string correlationId)
{
string location = "NBK.EAI.Adapters.MQAdapter.GetMQResponseMessage";
MQMessage rsMsg = new MQMessage();
rsMsg.MessageId = NBK.Common.Foundations.Utilities.
ConversionUtilities.HexToBin(correlationId);
MQGetMessageOptions gmo = new MQGetMessageOptions();
gmo.Options = MQC.MQGMO_WAIT;
gmo.MatchOptions = MQC.MQMO_MATCH_MSG_ID;
gmo.WaitInterval = pollingTimeout;
try
{
mqGetQueue.Get(rsMsg, gmo);
NBK.Common.Foundations.Logging.LoggerHelper.Information
(location, "Read MQ Message with CorrelationId: "
+ NBK.Common.Foundations.Utilities.ConversionUtilities.BinToHex(rsMsg.CorrelationId));
return(rsMsg.ReadString(rsMsg.DataLength));
}
catch (MQException mqe)
{
// Close Reponse Queue if still opened
if (mqGetQueue.OpenStatus)
{
mqGetQueue.Close();
}
// Close Queue manager if still opened
if (mqQueueManager.OpenStatus)
{
mqQueueManager.Close();
}
NBK.Common.Foundations.Logging.LoggerHelper.Information
(location, "Error Reading Message with Correlation ID: "
+ correlationId);
// Check if it a timeout exception
if (MQAdapterErrorReasons.GetMQFailureReasonErrorCode(mqe.Reason) == "MQRC_NO_MSG_AVAILABLE")
{
throw new MQAdapterTimeoutException("Message with correlation Id " + correlationId + " Timed out");
}
// MQ Exception
throw new MQAdapterException("Error Code: " +
MQAdapterErrorReasons.GetMQFailureReasonErrorCode(mqe.Reason));
}
}
/// <summary>
/// Helper method to read a message from 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="waitDelay">The time to wait for the message to be read from the queue</param>
/// <param name="context">The BizUnit context object which holds state and is passed between test steps</param>
/// <param name="msgID">[out] the MQ Series message ID</param>
/// <returns>String containing the data from the MQ series message</returns>
static public string ReadMessage(string queueManagerName, string queueName, int waitDelay, Context context, out byte[] msgID)
{
MQQueueManager queueManager = null;
MQQueue receiveQueue = null;
string message = null;
try
{
context.LogInfo("Opening queue manager: \"{0}\"", queueManagerName);
queueManager = new MQQueueManager(queueManagerName);
context.LogInfo("Opening queue: \"{0}\"", queueName);
receiveQueue = queueManager.AccessQueue(queueName, MQC.MQOO_INPUT_AS_Q_DEF + MQC.MQOO_FAIL_IF_QUIESCING);
MQMessage mqMsg = new MQMessage();
MQGetMessageOptions mqMsgOpts = new MQGetMessageOptions();
mqMsgOpts.WaitInterval = waitDelay*1000;
mqMsgOpts.Options = MQC.MQGMO_WAIT;
context.LogInfo("Reading message from queue '{0}'.", queueName);
receiveQueue.Get(mqMsg,mqMsgOpts);
if(mqMsg.Format.CompareTo(MQC.MQFMT_STRING)==0)
{
mqMsg.Seek(0);
message = System.Text.UTF8Encoding.UTF8.GetString(mqMsg.ReadBytes(mqMsg.MessageLength));
msgID = mqMsg.MessageId;
}
else
{
throw new NotSupportedException(string.Format("Unsupported message format: '{0}' read from queue: {1}.", mqMsg.Format, queueName));
}
}
finally
{
if (receiveQueue != null)
{
receiveQueue.Close();
}
if (queueManager != null)
{
queueManager.Close();
}
}
return message;
}
/// <summary>
/// ITestStep.Execute() implementation
/// </summary>
/// <param name='testConfig'>The Xml fragment containing the configuration for this test step</param>
/// <param name='context'>The context for the test, this holds state that is passed beteen tests</param>
public void Execute(XmlNode testConfig, Context context)
{
string qmgr = context.ReadConfigAsString(testConfig, "QueueManager");
MQQueueManager queueManager;
try
{
context.LogInfo("Opening queue manager '{0}'.", qmgr);
queueManager = new MQQueueManager(qmgr);
}
catch (Exception e)
{
throw new ApplicationException(string.Format("Failed to open queue manager {0}.", qmgr), e);
}
bool errors = false;
try
{
XmlNodeList queueNodes = testConfig.SelectNodes("Queue");
foreach (XmlNode queueNode in queueNodes)
{
string q = queueNode.InnerText;
context.LogInfo("Opening queue '{0}'.", q);
MQQueue queue = queueManager.AccessQueue(q, MQC.MQOO_INPUT_AS_Q_DEF + MQC.MQOO_FAIL_IF_QUIESCING);
try
{
MQMessage mqMsg = new MQMessage();
MQGetMessageOptions mqMsgOpts = new MQGetMessageOptions();
int i = 0;
bool finished = false;
while (!finished)
{
try
{
// Get message from queue
queue.Get(mqMsg,mqMsgOpts);
i++;
}
catch (MQException mqe)
{
if (mqe.Reason == 2033) // No more messages.
{
finished = true;
}
else
{
throw;
}
}
}
context.LogInfo("Cleared {0} messages from queue '{1}'.", i, q);
}
catch (Exception e)
{
context.LogError("Failed to clear queue \"{0}\" with the following exception: {1}", q, e.ToString());
errors = true;
}
finally
{
if (queue != null)
{
queue.Close();
}
}
}
}
finally
{
if (queueManager != null)
{
queueManager.Close();
}
if (errors)
{
throw new ApplicationException("Failed to clear at least one queue.");
}
}
}
public string ReadMsg()
{
String strReturn = "";
try
{
queue = queueManager.AccessQueue("MBK.SESION3.SALIDA",
MQC.MQOO_INPUT_AS_Q_DEF + MQC.MQOO_FAIL_IF_QUIESCING);
queueMessage = new MQMessage();
queueMessage.Format = MQC.MQFMT_STRING;
queueGetMessageOptions = new MQGetMessageOptions();
queue.Get(queueMessage, queueGetMessageOptions);
strReturn = queueMessage.ReadString(queueMessage.MessageLength);
}
catch (MQException MQexp)
{
strReturn = "Exception : " + MQexp.Message;
}
catch (Exception exp)
{
strReturn = "Exception: " + exp.Message;
}
return strReturn;
}
private static Task startTask(MQQueueManager manager, string queueName, int taskNumber, CancellationTokenSource token)
{
long messageCount = 0;
TimeSpan maxLatencyTime = TimeSpan.MinValue;
var options = new MQGetMessageOptions() { WaitInterval = WAIT_TIMEOUT };
return Task.Factory.StartNew(() =>
{
Console.WriteLine("#{0}:\tTask started", taskNumber);
while (!token.IsCancellationRequested)
{
var message = new MQMessage();
try
{
// the actual reading of message
manager
.AccessQueue(queueName, MQC.MQOO_INPUT_AS_Q_DEF + MQC.MQOO_FAIL_IF_QUIESCING)
.Get(message, options);
messageCount++;
}
catch (MQException ex)
{
if (ex.ReasonCode != 2033)
// unless there is no message - code 2033
Console.WriteLine("#{0}:\tError reading message code: {1} message: {2}",
taskNumber, ex.ReasonCode, ex.Message);
continue;
}
// decode timestamp of message when it was putted in source queue
var timestamp = DateTime.ParseExact(
ASCIIEncoding.ASCII.GetString(message.MQMD.PutDate) +
ASCIIEncoding.ASCII.GetString(message.MQMD.PutTime),
"yyyyMMddHHmmssff", CultureInfo.InvariantCulture);
var latency = DateTime.UtcNow - timestamp;
if (latency > maxLatencyTime || messageCount % 100 == 0)
{
// will print only on each 100 messages or when the larger latency detected
if (latency > maxLatencyTime)
maxLatencyTime = latency;
Console.WriteLine("#{0}:\tMax latency time after {1} messages is {2}",
taskNumber, messageCount, maxLatencyTime);
}
}
}, token.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default);
}
private void GetMessages()
{
try
{
// mq properties
Hashtable properties = new Hashtable();
properties.Add(MQC.TRANSPORT_PROPERTY, MQC.TRANSPORT_MQSERIES_MANAGED);
properties.Add(MQC.HOST_NAME_PROPERTY, HostName);
properties.Add(MQC.PORT_PROPERTY, Port);
properties.Add(MQC.CHANNEL_PROPERTY, ChannelName);
// create connection
Console.Write("Connecting to queue manager.. ");
MQQueueManager queueManager = new MQQueueManager(QueueManagerName, properties);
Console.WriteLine("done");
// accessing queue
Console.Write("Accessing queue " + QueueName + ".. ");
MQQueue queue = queueManager.AccessQueue(QueueName, MQC.MQOO_INPUT_AS_Q_DEF + MQC.MQOO_FAIL_IF_QUIESCING);
Console.WriteLine("done");
// creating a message options object
MQGetMessageOptions mqGetMsgOpts = new MQGetMessageOptions();
mqGetMsgOpts.WaitInterval = MessageWaitTimeout;
mqGetMsgOpts.Options = MQC.MQGMO_FAIL_IF_QUIESCING | MQC.MQGMO_WAIT;
// getting messages continuously
bool done = false;
while (!done && !ShuttingDown)
{
try
{
// creating a message object
MQMessage message = new MQMessage();
queue.Get(message, mqGetMsgOpts);
string messageString = message.ReadString(message.MessageLength);
handler.HandleMessage(messageString);
message.ClearMessage();
}
catch (MQException mqe)
{
if (mqe.ReasonCode != 2033)
{
Console.WriteLine("MQException caught: {0} - {1}", mqe.ReasonCode, mqe.Message);
done = true;
}
}
}
// closing queue
Console.Write("Closing queue.. ");
queue.Close();
Console.WriteLine("done");
// disconnecting queue manager
Console.Write("Disconnecting queue manager.. ");
queueManager.Disconnect();
Console.WriteLine("done");
}
catch (MQException mqe)
{
Console.WriteLine("");
Console.WriteLine("MQException caught: {0} - {1}", mqe.ReasonCode, mqe.Message);
Console.WriteLine(mqe.StackTrace);
}
}
/// <summary>
/// Read Message from Local Queue
/// </summary>
/// <param name="strqueueName">Queue Name</param>
/// <returns>Text Message</returns>
public MQMessageStatus ReadLocalQMsg(string strQueueName)
{
MQMessageStatus messageStatus = new MQMessageStatus();
string strReturn = string.Empty;
ReceiveQueueName = strQueueName;
try
{
queue = queueManager.AccessQueue(ReceiveQueueName,
MQC.MQOO_INPUT_AS_Q_DEF + MQC.MQOO_FAIL_IF_QUIESCING);
queueMessage = new MQMessage();
queueMessage.Format = MQC.MQFMT_STRING;
queueGetMessageOptions = new MQGetMessageOptions();
queue.Get(queueMessage, queueGetMessageOptions);
strReturn = queueMessage.ReadString(queueMessage.MessageLength);
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;
}
