/*
* Remove all messages from shutdown queue
*/
private void ClearShutdownQueue()
{
var QueueURL = AppUtility.GetContext().ShutdownQueue;
Amazon.SQS.Model.ReceiveMessageRequest request = new Amazon.SQS.Model.ReceiveMessageRequest();
request.WithMaxNumberOfMessages(10);
request.WithQueueUrl(QueueURL);
var rsp = queue.ReceiveMessage(request);
while (rsp.IsSetReceiveMessageResult() && rsp.ReceiveMessageResult.Message.Count > 0)
{
Debug.WriteLine("Remove Shutdown Messages: " + rsp.ReceiveMessageResult.Message.Count);
var result = rsp.ReceiveMessageResult.Message;
foreach (var msg in rsp.ReceiveMessageResult.Message)
{
//Console.WriteLine("Message: " + msg);
if (msg.IsSetMessageId())
{
//Console.WriteLine("Body: " + msg.Body);
//if (msg.Body == "shutdown")
//{
//}
var delMsg = new Amazon.SQS.Model.DeleteMessageRequest();
delMsg.WithQueueUrl(QueueURL);
delMsg.WithReceiptHandle(msg.ReceiptHandle);
var delRsp = queue.DeleteMessage(delMsg);
}
}
rsp = queue.ReceiveMessage(request);
}
}
public ErrorTypes RemoveTask(object key)
{
ErrorTypes eResult = ErrorTypes.Unknown;
try
{
SQSDataKey oSQSDataKey = (SQSDataKey)key;
string strUrlQueue = GetQueueUrl(oSQSDataKey.m_oPriority);
using (Amazon.SQS.AmazonSQS oSQSClient = Amazon.AWSClientFactory.CreateAmazonSQSClient())
{
Amazon.SQS.Model.DeleteMessageRequest oDeleteRequest = new Amazon.SQS.Model.DeleteMessageRequest();
oDeleteRequest.QueueUrl = strUrlQueue;
oDeleteRequest.ReceiptHandle = (string)oSQSDataKey.m_strReceiptHandle;
oSQSClient.DeleteMessage(oDeleteRequest);
eResult = ErrorTypes.NoError;
}
}
catch (Amazon.SQS.AmazonSQSException)
{
}
catch
{
}
return(eResult);
}
public int GetNotifications()
{
int count = 0;
// Check Queue For Shutdown Message
var request = new Amazon.SQS.Model.ReceiveMessageRequest();
request.WithQueueUrl(AppUtility.GetContext().ShutdownNotificationQueue);
var rsp = queue.ReceiveMessage(request);
if (rsp.IsSetReceiveMessageResult())
{
foreach (var msg in rsp.ReceiveMessageResult.Message)
{
if (msg.IsSetMessageId())
{
Debug.WriteLine("Notification Instance shutdown: " + msg.Body);
var delMsg = new Amazon.SQS.Model.DeleteMessageRequest();
delMsg.WithQueueUrl(AppUtility.GetContext().ShutdownQueue);
delMsg.WithReceiptHandle(msg.ReceiptHandle);
var delRsp = queue.DeleteMessage(delMsg);
count += 1;
}
}
}
return(count);
}
public void AddSetupCB(Func <Amazon.SQS.Model.DeleteMessageRequest, Amazon.SQS.Model.DeleteMessageResponse> callback,
Amazon.SQS.Model.DeleteMessageRequest request, Action <Amazon.SQS.Model.DeleteMessageResponse> check)
{
setupCallbackCheck = check;
setupCallback = callback;
setupCBRequest = request;
}
IEnumerator RepeatRetrieveMessage(float waitTime)
{
bool checkSQS = true;
while (checkSQS)
{
yield return(new WaitForSeconds(waitTime));
if (!string.IsNullOrEmpty(queueUrl))
{
SqsClient.ReceiveMessageAsync(queueUrl, (result) => {
if (result.Exception == null)
{
//Read the message
var messages = result.Response.Messages;
messages.ForEach(m => {
Debug.Log(@"Message Id = " + m.MessageId);
Debug.Log(@"Mesage = " + m.Body);
string[] parts = m.Body.Split(new char [] { ' ' });
string modelName = parts[parts.Length - 1];
this.LoadModel(modelName);
//Process the message
//[do your thing here]
//Delete the message
var delRequest = new Amazon.SQS.Model.DeleteMessageRequest
{
QueueUrl = queueUrl,
ReceiptHandle = m.ReceiptHandle
};
SqsClient.DeleteMessageAsync(delRequest, (delResult) => {
if (delResult.Exception == null)
{
}
else
{
}
});
});
}
else
{
Debug.LogException(result.Exception);
}
});
}
else
{
Debug.Log(@"Queue Url is empty, make sure that the queue is created first");
}
//Debug.Log (".");
}
}
/// <summary>
/// Deletes a message from an SQS queue.
/// </summary>
/// <param name="queueUrl">The sqs queue endpoint to delete the message from.</param>
/// <param name="receiptHandle">The unique receipt handle for the message.</param>
public static Amazon.SQS.Model.DeleteMessageResponse Delete(string queueUrl, string receiptHandle)
{
Amazon.SQS.Model.DeleteMessageResponse response = new Amazon.SQS.Model.DeleteMessageResponse();
using (Amazon.SQS.IAmazonSQS client = new Factory().SQSClient())
{
Amazon.SQS.Model.DeleteMessageRequest request = new Amazon.SQS.Model.DeleteMessageRequest()
{
QueueUrl = queueUrl,
ReceiptHandle = receiptHandle
};
response = client.DeleteMessage(request);
}
return response;
}
public ErrorTypes RemoveTask(object key)
{
ErrorTypes eResult = ErrorTypes.Unknown;
try
{
SQSDataKey oSQSDataKey = (SQSDataKey)key;
string strUrlQueue = GetQueueUrl(oSQSDataKey.m_oPriority);
using (Amazon.SQS.AmazonSQS oSQSClient = Amazon.AWSClientFactory.CreateAmazonSQSClient())
{
Amazon.SQS.Model.DeleteMessageRequest oDeleteRequest = new Amazon.SQS.Model.DeleteMessageRequest();
oDeleteRequest.QueueUrl = strUrlQueue;
oDeleteRequest.ReceiptHandle = (string)oSQSDataKey.m_strReceiptHandle;
oSQSClient.DeleteMessage(oDeleteRequest);
eResult = ErrorTypes.NoError;
}
}
catch (Amazon.SQS.AmazonSQSException)
{
}
catch
{
}
return eResult;
}
/*
* private void CreateQueueListener()
* {
* // SqsClient.CreateQueueAsync(QueueName, (result) =>
* // {
* // if (result.Exception == null)
* // {
* // Debug.Log(@"Queue Created");
* // queueUrl = result.Response.QueueUrl;
* // }
* // else
* // {
* // Debug.LogException(result.Exception);
* // }
* // });
* }
*
* private void DeleteQueueListener()
* {
* // if (!string.IsNullOrEmpty(queueUrl))
* // {
* // SqsClient.DeleteQueueAsync(queueUrl, (result) =>
* // {
* // if (result.Exception == null)
* // {
* // Debug.Log(@"Queue Deleted");
* // }
* // else
* // {
* // Debug.LogException(result.Exception);
* // }
* // });
* // }
* // else
* // {
* // Debug.Log(@"Queue Url is empty, make sure that the queue is created first");
* // }
* }
*
* private void SendMessageListener()
* {
*
* if (!string.IsNullOrEmpty(queueUrl))
* {
* var message = Message.text;
* if (string.IsNullOrEmpty(message))
* {
* Debug.Log("No Message to send");
* return;
* }
*
* SqsClient.SendMessageAsync(queueUrl, message, (result) =>
* {
* if (result.Exception == null)
* {
* Debug.Log("Message Sent");
* }
* else
* {
* Debug.LogException(result.Exception);
* }
* });
* }
* else
* {
* Debug.Log(@"Queue Url is empty, make sure that the queue is created first");
* }
* }
*/
IEnumerator RepeatRetrieveMessage(float waitTime)
{
bool checkSQS = true;
while (checkSQS)
{
yield return(new WaitForSeconds(waitTime));
if (!string.IsNullOrEmpty(queueUrl))
{
SqsClient.ReceiveMessageAsync(queueUrl, (result) =>
{
if (result.Exception == null)
{
//Read the message
var messages = result.Response.Messages;
messages.ForEach(m =>
{
//Debug.Log(@"Message Id = " + m.MessageId);
Debug.Log(@"Mesage = " + m.Body);
//Process the message
//[do your thing here]
//var color = colorDictionay.Where(c => c.Key == m.Body).FirstOrDefault().Value;
if (m.Body == "white")
{
for (int i = 0; i < env_light.Length; i++)
{
env_light[i].color = Color.white;
}
}
if (m.Body == "red")
{
for (int i = 0; i < env_light.Length; i++)
{
env_light[i].color = Color.red;
}
}
else if (m.Body == "blue")
{
for (int i = 0; i < env_light.Length; i++)
{
env_light[i].color = Color.blue;
}
}
else if (m.Body == "green")
{
for (int i = 0; i < env_light.Length; i++)
{
env_light[i].color = Color.green;
}
}
if (m.Body == "off")
{
for (int i = 0; i < env_light.Length; i++)
{
env_light[i].enabled = false;
}
}
else if (m.Body == "on")
{
for (int i = 0; i < env_light.Length; i++)
{
env_light[i].enabled = true;
}
}
if (m.Body == "delete")
{
StartCoroutine(placeObject.ClearRoom());
}
if (m.Body == "undo")
{
StartCoroutine(placeObject.UndoPlacement());
}
//Delete the message
var delRequest = new Amazon.SQS.Model.DeleteMessageRequest
{
QueueUrl = queueUrl,
ReceiptHandle = m.ReceiptHandle
};
SqsClient.DeleteMessageAsync(delRequest, (delResult) =>
{
if (delResult.Exception == null)
{
}
else
{
}
});
});
}
else
{
Debug.LogException(result.Exception);
}
});
}
else
{
Debug.Log(@"Queue Url is empty, make sure that the queue is created first");
}
//Debug.Log (".");
}
}
IEnumerator RepeatRetrieveMessage(float waitTime)
{
bool checkSQS = true;
while (checkSQS)
{
yield return(new WaitForSeconds(waitTime));
if (!string.IsNullOrEmpty(queueUrl))
{
SqsClient.ReceiveMessageAsync(queueUrl, (result) => {
if (result.Exception == null)
{
//Read the message
var messages = result.Response.Messages;
messages.ForEach(m => {
Debug.Log(@"Message Id = " + m.MessageId);
Debug.Log(@"Mesage = " + m.Body);
//Process the message
if (m.Body.Contains("move") || m.Body.Contains("forward"))
{
main.setRoom(main.selectedRoom);
}
else if (m.Body.Contains("grab"))
{
if (main.selectedBall)
{
main.selectedBall.onCommand();
}
else if (main.selectedChest)
{
Debug.Log("open chest");
}
}
else if (m.Body.Contains("throw"))
{
main.holdingBall.onThrow();
}
else if (m.Body.Contains("attack"))
{
main.pewPew();
}
//Delete the message
var delRequest = new Amazon.SQS.Model.DeleteMessageRequest
{
QueueUrl = queueUrl,
ReceiptHandle = m.ReceiptHandle
};
SqsClient.DeleteMessageAsync(delRequest, (delResult) => {
if (delResult.Exception == null)
{
}
else
{
}
});
});
}
else
{
Debug.LogException(result.Exception);
}
});
}
else
{
Debug.Log(@"Queue Url is empty, make sure that the queue is created first");
}
//Debug.Log (".");
}
}
/// <summary>
/// The main entrypoint for the thread that listens to messages.
/// </summary>
private void AWSMessageListener()
{
// Used to eliminate over logging
bool receivedMessage = true;
while (!stopping)
{
try
{
var receiveMessageRequest = new SQS.Model.ReceiveMessageRequest()
{
WaitTimeSeconds = 10,
QueueUrl = sqsQueueUrl
};
if (receivedMessage)
{
Logger.LogTrace("Waiting for message from queue");
}
receivedMessage = false;
var messageResponse = AsyncTaskHelper.RunSync(() => sqsClient.ReceiveMessageAsync(receiveMessageRequest));
if (messageResponse.HttpStatusCode == HttpStatusCode.OK &&
messageResponse.Messages.Count > 0 &&
!stopping)
{
receivedMessage = true;
Logger.LogDebug($"Received {messageResponse.Messages.Count} message(s)");
foreach (var messageResponseMessage in messageResponse.Messages)
{
try
{
ProcessMessage(messageResponseMessage);
}
finally
{
#if (!DONTDELETEMESSAGE)
// Delete the message even in error since it will keep coming back
// Perhaps a better action would be to put in a dead letter queue
DeleteMessage(messageResponseMessage);
#endif
}
}
}
}
catch (Exception ex)
{
Logger.LogError("Error processing message: {0}", ex);
}
}
// Process the received message
void ProcessMessage(SQS.Model.Message messageResponseMessage)
{
Logger.LogTrace($"Received Message ({messageResponseMessage.MessageId}): {messageResponseMessage.Body}");
var snsMessage = SNS.Util.Message.ParseMessage(messageResponseMessage.Body);
var feedEvent = JsonConvert.DeserializeObject <FeedEvent>(snsMessage.MessageText);
Logger.LogInformation($"Feed: {feedEvent.Feed}, Event: {feedEvent.Event}, Package: {feedEvent.Package}, Version: {feedEvent.Version}");
Logger.LogTrace($"Package URL: {feedEvent.PackageUrl}");
var actionableActions =
ApplicationSettings.Actions.Where(action => string.Equals(action.SourceFeed, feedEvent.Feed, StringComparison.InvariantCultureIgnoreCase) && action.Enabled);
Package retrievedPackage = null;
foreach (var actionableAction in actionableActions)
{
Logger.LogTrace($"Found Action ({actionableAction.Name}) for {feedEvent.Feed}");
if (feedEvent.Version.IsPrerelease() && !actionableAction.IncludePrerelease)
{
Logger.LogDebug($"{actionableAction.Name} is ignoring prelease package ({feedEvent.Package}.{feedEvent.Version})");
continue;
}
using (var scope = ServiceProvider.CreateScope())
{
var action = ActionProcessor.CreateAction(scope, actionableAction);
switch (feedEvent.Event)
{
case EventType.Added:
if (retrievedPackage == null)
{
retrievedPackage = AsyncTaskHelper.RunSync(() => action.SourceRepository.FetchAsync(feedEvent.Package, feedEvent.Version));
}
if (retrievedPackage == null)
{
Logger.LogWarning($"{feedEvent.Package}.{feedEvent.Version} not found in feed {feedEvent.Feed}. Ignoring.");
}
else
{
AsyncTaskHelper.RunSync(() => action.ProcessPackageAsync(retrievedPackage, PackageEvent.Added));
}
break;
case EventType.Deleted:
case EventType.Purged:
// We can't retrieve the package because it has been deleted
var deletePackage = new Package
{
Id = feedEvent.Package,
Version = feedEvent.Version
};
AsyncTaskHelper.RunSync(() => action.ProcessPackageAsync(deletePackage, PackageEvent.Deleted));
break;
}
}
}
}
#if (!DONTDELETEMESSAGE)
// Delete the processed message from the queue
void DeleteMessage(SQS.Model.Message messageResponseMessage)
{
var deleteMessageRequest = new SQS.Model.DeleteMessageRequest
{
QueueUrl = sqsQueueUrl,
ReceiptHandle = messageResponseMessage.ReceiptHandle
};
Logger.LogTrace($"Deleting Message: {messageResponseMessage.ReceiptHandle}");
var deleteMessageResponse = AsyncTaskHelper.RunSync(() => sqsClient.DeleteMessageAsync(deleteMessageRequest));
if (deleteMessageResponse.HttpStatusCode == HttpStatusCode.OK)
{
Logger.LogTrace($"Delete Message: {messageResponseMessage.ReceiptHandle}");
}
else
{
Logger.LogWarning($"Unable to delete Message: {messageResponseMessage.ReceiptHandle}. Ignoring.");
}
}
#endif
}
