//*********************************************************************
///
/// <summary>
///
/// </summary>
/// <param name="queue"></param>
/// <param name="messageId"></param>
/// <param name="payload"></param>
/// <param name="queueName"></param>
///
//*********************************************************************
private void EnQueue(QueueClient queue, string messageId,
object payload, QueueNameEnum queueName)
{
var message = new BrokeredMessage(payload)
{
MessageId = messageId
};
while (true)
{
try
{
message.Properties.Add("QueueName", queueName.ToString());
queue.Send(message);
break;
}
catch (MessagingException e)
{
if (!e.IsTransient)
{
Console.WriteLine(e.Message);
throw;
}
else
{
Thread.Sleep(QueueTransientRetryTime);
}
}
}
}
//*********************************************************************
///
/// <summary>
///
/// </summary>
/// <param name="queueName"></param>
/// <returns></returns>
///
//*********************************************************************
public IEnumerable <BrokeredMessage> ReadMessagesbyQueueName(QueueNameEnum queueName)
{
var qc = GetQueue(queueName, true);
var messages = new List <BrokeredMessage>();
try
{
IEnumerable <BrokeredMessage> recdMsg;
while ((recdMsg = qc.ReceiveBatch(200, _BatchReadTimeSpan)) != null)
{
messages.AddRange(recdMsg);
foreach (var msg in recdMsg)
{
msg.Abandon();
}
return(messages);
}
}
catch (MessagingException e)
{
if (!e.IsTransient)
{
throw;
}
Thread.Sleep(QueueTransientRetryTime);
}
return(messages);
}
public IEnumerator CheckQueueNotEmpty(QueueNameEnum queueName)
{
if (this.IsQueueEmpty(queueName))
{
Debug.Log("Queue is empty");
yield return(new WaitForSeconds(0.1f));
}
}
//*********************************************************************
///
/// <summary>
///
/// </summary>
/// <param name="queueName"></param>
/// <param name="timeoutSeconds"></param>
/// <returns></returns>
///
//*********************************************************************
public BrokeredMessage ReadQueue(QueueNameEnum queueName, int timeoutSeconds)
{
try
{
var qc = GetQueue(queueName, true);
return(ReadQueue(qc, timeoutSeconds));
}
catch (Exception ex)
{
throw new Exception("Exception in CmpQueue.ReadQueue() : " +
Utilities.UnwindExceptionMessages(ex));
}
}
//*********************************************************************
///
/// <summary>
///
/// </summary>
/// <param name="queueName"></param>
/// <param name="messageId"></param>
/// <param name="payload"></param>
///
//*********************************************************************
public void EnQueue(QueueNameEnum queueName, string messageId, object payload)
{
try
{
var qc = GetQueue(queueName, true);
EnQueue(qc, messageId, payload, queueName);
}
catch (Exception ex)
{
throw new Exception("Exception in CmpQueue.EnQueue() : " +
Utilities.UnwindExceptionMessages(ex));
}
}
//*********************************************************************
///
/// <summary>
/// Be sure to call CompleteMessage on the returned BrokeredMessage
/// when you are done processing it.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="queueName"></param>
/// <param name="timeoutSeconds"></param>
/// <param name="messageId"></param>
/// <param name="payload"></param>
/// <returns></returns>
///
//*********************************************************************
public BrokeredMessage ReadQueue <T>(QueueNameEnum queueName,
int timeoutSeconds, ref string messageId, ref T payload)
{
try
{
var qc = GetQueue(queueName, true);
var bm = ReadQueue(qc, timeoutSeconds);
if (null != bm)
{
messageId = bm.MessageId;
payload = bm.GetBody <T>();
}
return(bm);
}
catch (Exception ex)
{
throw new Exception("Exception in CmpQueue.ReadQueue() : " +
Utilities.UnwindExceptionMessages(ex));
}
}
public IEnumerable <BrokeredMessage> ReadAllBatch(QueueNameEnum queueNameEnum,
int count, bool getDeadLetter, bool abandon)
{
try
{
QueueClient qc = null;
var queueName = queueNameEnum.ToString();
if (getDeadLetter)
{
queueName = QueueClient.FormatDeadLetterPath(queueName);
}
qc = GetQueue(queueName, true);
return(ReadAllBatch(qc, count, abandon));
}
catch (Exception ex)
{
throw new Exception("Exception in CmpQueue.ReadQueueBatch() : " +
Utilities.UnwindExceptionMessages(ex));
}
}
public bool IsQueueEmpty(QueueNameEnum queueName)
{
bool empty = true;
switch (queueName)
{
case QueueNameEnum.STARTINGPLAYER:
empty = startingPlayerSetQueue.Count.Equals(0);
break;
case QueueNameEnum.OPPONENTMOVE:
empty = opponentMoveQueue.Count.Equals(0);
break;
case QueueNameEnum.CHALLENGEMOVE:
empty = challengeMoveQueue.Count.Equals(0);
break;
case QueueNameEnum.MATCHMAKINGGROUPNUMBER:
empty = matchmakingGroupNumberQueue.Count.Equals(0);
break;
}
return(empty);
}
//*********************************************************************
///
/// <summary>
///
/// </summary>
/// <param name="queueName"></param>
///
//*********************************************************************
public void Close(QueueNameEnum queueName)
{
var qc = GetQueue(queueName, true);
qc.Close();
}
//*********************************************************************
///
/// <summary>
///
/// </summary>
/// <param name="queueName"></param>
/// <param name="count"></param>
/// <param name="abandon"></param>
/// <returns></returns>
///
//*********************************************************************
/*public IEnumerable<BrokeredMessage> ReadQueueBatch(QueueNameEnum queueName, int count, bool abandon)
* {
* try
* {
* QueueClient qc = GetQueue(queueName, true);
* return ReadQueueBatch(qc, count, abandon);
* }
* catch (Exception ex)
* {
* throw new Exception("Exception in CmpQueue.ReadQueueBatch() : " +
* Utilities.UnwindExceptionMessages(ex));
* }
* }*/
public IEnumerable <BrokeredMessage> ReadQueueBatch(QueueNameEnum queueName,
int count, bool abandon)
{
return(ReadQueueBatch(queueName.ToString(), count, abandon));
}
//*********************************************************************
///
/// <summary>
///
/// </summary>
/// <param name="queueNameEnum"></param>
/// <param name="createIfNotExists"></param>
/// <returns></returns>
///
//*********************************************************************
private QueueClient GetQueue(QueueNameEnum queueNameEnum, bool createIfNotExists)
{
return(GetQueue(queueNameEnum.ToString(), createIfNotExists));
}
