public void TestConsumerStateChangeNotification()
{
// Consumer JobStateChange
var env = new RPCEnvelope();
var con = new JobStateChange();
env.Message = con;
env.Operation = con.GetType().Name;
con.Id = Guid.NewGuid();
con.Timestamp = DateTime.UtcNow;
con.State = "Setup";
var iso = new Newtonsoft.Json.Converters.IsoDateTimeConverter();
iso.DateTimeFormat = "yyyy'-'MM'-'dd'T'HH':'mm':'ss.fffK";
string json = Newtonsoft.Json.JsonConvert
.SerializeObject(env, iso);
// Orchestrator JobStateChange
JToken token = JObject.Parse(json);
String op = (string)token.SelectToken("Operation");
JToken msg = token.SelectToken("Mesage");
Assert.IsTrue(op == "JobStateChange");
var serializer = new Newtonsoft.Json.JsonSerializer();
Newtonsoft.Json.JsonReader reader = token["Message"].CreateReader();
var job = serializer.Deserialize <JobStateChange>(reader);
Assert.AreEqual(((JobStateChange)env.Message).State, job.State);
}
internal static void Send(JobStateChange msg)
{
var env = new RPCEnvelope();
env.Message = msg;
env.Operation = "JobStateChange";
env.ResponseQueueUrl = null;
Send(msg.GetType().Name, JsonConvert.SerializeObject(env));
}
static public void Send(UnRegister msg)
{
var env = new RPCEnvelope();
env.Message = msg;
env.Operation = "UnRegister";
env.ResponseQueueUrl = null;
Send(msg.GetType().Name, JsonConvert.SerializeObject(env));
}
static public RegistrationInfo SendReceive(Register msg)
{
Debug.WriteLine("Send Register Message", "SimpleMessageConnect.SendReceive");
var env = new RPCEnvelope();
env.Message = msg;
env.Operation = "Register";
env.ResponseQueueUrl = Open(String.Format("{0}{1}", responseQueuePrefix, msg.ConsumerId));
Send(msg.GetType().Name, JsonConvert.SerializeObject(env));
var rsp = ReceiveRegistration(env);
return(rsp);
}
public void SendRegistrationInfo(RPCEnvelope msg)
{
var env = new RPCEnvelope();
var regInfo = new RegistrationInfo();
env.Message = regInfo;
env.Operation = regInfo.GetType().Name;
regInfo.RequestId = msg.Message.Id;
regInfo.Id = Guid.NewGuid();
regInfo.Timestamp = DateTime.UtcNow;
regInfo.JobQueueUrl = submitQueueUrl;
env.Message = regInfo;
Debug.WriteLine("Send RegistrationInfo to " + msg.ResponseQueueUrl);
queue.SendMessage(new Amazon.SQS.Model.SendMessageRequest()
.WithDelaySeconds(0)
.WithQueueUrl(msg.ResponseQueueUrl)
.WithMessageBody(JsonConvert.SerializeObject(env)));
}
public RPCEnvelope[] Listen()
{
Setup();
var rsp = queue.ReceiveMessage(new Amazon.SQS.Model.ReceiveMessageRequest()
.WithWaitTimeSeconds(20)
.WithMaxNumberOfMessages(10)
.WithQueueUrl(requestQueueUrl));
if (!rsp.IsSetReceiveMessageResult())
{
Debug.WriteLine("No Messages Available");
return(null);
}
if (!rsp.ReceiveMessageResult.IsSetMessage())
{
Debug.WriteLine("Message not set");
return(null);
}
List <RPCEnvelope> envList = new List <RPCEnvelope>();
RPCEnvelope env = null;
var deleteList = new List <Amazon.SQS.Model.DeleteMessageBatchRequestEntry> {
};
foreach (var msg in rsp.ReceiveMessageResult.Message)
{
// NOTE: These are SNS Messages so need to parse that envelope off
// Type,MessageId,TopicArn,Subject,Message,Timestamp,SignatureVersion,Signature,
// SigningCertURL,UnsubscribeURL
//
Debug.WriteLine("Message: " + msg.Body);
JToken token = JObject.Parse(msg.Body);
JToken jmsg = token.SelectToken("Message");
JToken subject = token.SelectToken("Subject");
if (msg.IsSetReceiptHandle())
{
deleteList.Add(new Amazon.SQS.Model.DeleteMessageBatchRequestEntry()
.WithReceiptHandle(msg.ReceiptHandle)
.WithId(Guid.NewGuid().ToString()));
}
Dictionary <string, Object> d;
try
{
//env = serializer.Deserialize<RPCEnvelope>(reader);
env = JsonConvert.DeserializeObject <RPCEnvelope>(jmsg.ToString());
d = JsonConvert.DeserializeObject <Dictionary <string, Object> >(jmsg.ToString());
}
catch (Exception ex)
{
Debug.WriteLine(String.Format("Ignore exception deserializing: {0}", ex), GetType().Name);
continue;
}
var responseQueueUrl = env.ResponseQueueUrl;
var operation = env.Operation;
var serializer = new Newtonsoft.Json.JsonSerializer();
Newtonsoft.Json.JsonReader reader = jmsg.CreateReader();
var content = d["Message"].ToString();
if (operation == "Register")
{
Debug.WriteLine("Found: " + operation);
//env.Message = serializer.Deserialize<Register>(reader);
env.Message = JsonConvert.DeserializeObject <Register>(content);
}
else
{
Debug.WriteLine("Ignore: " + operation);
continue;
}
envList.Add(env);
}
var entries = deleteList.ToArray <Amazon.SQS.Model.DeleteMessageBatchRequestEntry>();
// Delete Messages
var deleteResponse = queue.DeleteMessageBatch(new Amazon.SQS.Model.DeleteMessageBatchRequest()
.WithQueueUrl(requestQueueUrl)
.WithEntries(entries));
return(envList.ToArray <RPCEnvelope>());
}
/// <summary>
/// ReceiveRegistration: Response occurs on a dedicated queue so all messages not
/// conforming to expected result are deleted and ignored.
/// </summary>
/// <param name="registerRequest"></param>
/// <returns></returns>
internal static RegistrationInfo ReceiveRegistration(RPCEnvelope registerRequest)
{
Turbine.Consumer.Contract.Behaviors.IConsumerContext ctx = Turbine.Consumer.AppUtility.GetConsumerContext();
IAWSContext awsCtx = Turbine.Consumer.AWS.AppUtility.GetContext();
var queue = Amazon.AWSClientFactory.CreateAmazonSQSClient(
awsCtx.AccessKey, awsCtx.SecretKey,
new Amazon.SQS.AmazonSQSConfig().WithServiceURL(awsCtx.Region)
);
Amazon.SQS.Model.ReceiveMessageResponse receiveMsgResponse;
var entries = new List <Amazon.SQS.Model.DeleteMessageBatchRequestEntry>();
// NOTE: Should only be 1 message on queue, but grab 'all' and delete 'all'.
do
{
Debug.WriteLine(String.Format("Register: Poll Queue {0} for response", registerRequest.ResponseQueueUrl),
registerRequest.Operation);
receiveMsgResponse = queue.ReceiveMessage(new Amazon.SQS.Model.ReceiveMessageRequest()
.WithWaitTimeSeconds(20)
.WithMaxNumberOfMessages(10)
.WithQueueUrl(registerRequest.ResponseQueueUrl));
} while (receiveMsgResponse.IsSetReceiveMessageResult() == false || receiveMsgResponse.ReceiveMessageResult.IsSetMessage() == false);
// Response Message Should Have ResponseQueue & SNS Topic
List <Amazon.SQS.Model.Message> msgResultMsg = receiveMsgResponse.ReceiveMessageResult.Message;
Debug.WriteLine(String.Format("Count {0} Messages found", msgResultMsg.Count), registerRequest.Operation);
if (msgResultMsg.Count == 0)
{
return(null);
}
RegistrationInfo regInfo = null;
//Dictionary<string, Object> d;
// NOTE: Very inefficient, double parsing etc.
// Consider typing at the RPCEnvelope level
foreach (Amazon.SQS.Model.Message smsg in msgResultMsg)
{
Debug.WriteLine(String.Format("Messages found {0}", smsg.Body), registerRequest.Operation);
entries.Add(new Amazon.SQS.Model.DeleteMessageBatchRequestEntry()
.WithId(smsg.MessageId)
.WithReceiptHandle(smsg.ReceiptHandle));
RPCEnvelope registerResponse = null;
JToken token = JObject.Parse(smsg.Body);
JToken jmsg = token.SelectToken("Message");
try
{
registerResponse = JsonConvert.DeserializeObject <RPCEnvelope>(smsg.Body);
//d = JsonConvert.DeserializeObject<Dictionary<string, Object>>(jmsg.ToString());
}
catch (Exception ex)
{
Debug.WriteLine(String.Format("RPCEnvelope ignore exception deserializing: {0}", ex),
registerRequest.Operation);
continue;
}
//ack = (Turbine.Orchestrator.AWS.Data.Contract.Messages.RegistrationInfo)rsp.Message;
var serializer = new Newtonsoft.Json.JsonSerializer();
Newtonsoft.Json.JsonReader reader = jmsg.CreateReader();
//var content = d["Message"].ToString();
var content = jmsg.ToString();
try
{
regInfo = JsonConvert.DeserializeObject <RegistrationInfo>(content);
}
catch (Exception ex)
{
Debug.WriteLine(String.Format("RegistrationInfo ignore exception deserializing: {0}", ex),
registerRequest.Operation);
continue;
}
//registerRequest.Message = regInfo;
if (regInfo.RequestId != registerRequest.Message.Id)
{
var s = String.Format("Mismatch Request-Response Id : {0} != {1}", regInfo.Id, registerRequest.Message.Id);
Debug.WriteLine(s, regInfo.GetType().Name);
continue;
}
break;
}
if (entries.Count > 0)
{
// Delete all messages found
var delMsgBatchRsp = queue.DeleteMessageBatch(
new Amazon.SQS.Model.DeleteMessageBatchRequest()
.WithQueueUrl(registerRequest.ResponseQueueUrl)
.WithEntries(entries.ToArray <Amazon.SQS.Model.DeleteMessageBatchRequestEntry>()));
}
return(regInfo);
}
