public void SendActorMessageToStorageQueue()
{
string queueName = "test-" + "SendActorMessageToStorageQueue".ToLower();
var queue = GetStorageQueue(queueName);
try
{
string message = "HelloWorld";
PingPong.Ping aMsg = new PingPong.Ping(message);
IActorMessageSerializationActor serializer = new IActorMessageSerializationActor();
Telegraph.Instance.Register <PingPong.Ping, SendMessageToStorageQueue <PingPong.Ping> >(() => new SendMessageToStorageQueue <PingPong.Ping>(Connections.StorageConnectionString, queueName, true));
Telegraph.Instance.Register <SerializeMessage <IActorMessage>, IActorMessageSerializationActor>(() => serializer);
if (!Telegraph.Instance.Ask(aMsg).Wait(new TimeSpan(0, 10, 0)))
{
Assert.Fail("Waited too long to send a message");
}
IActorMessageDeserializationActor deserializer = new IActorMessageDeserializationActor();
deserializer.Register <PingPong.Ping>((object msg) => (PingPong.Ping)msg);
var base64String = queue.ReceiveMessage().Value.Body.ToString();
var messageBytes = Convert.FromBase64String(base64String);
DeserializeMessage <IActorMessage> dMsg = new DeserializeMessage <IActorMessage>(messageBytes);
deserializer.Ask(dMsg);
var retMsgs = (PingPong.Ping)dMsg.ProcessingResult;
Assert.IsTrue(((string)retMsgs.Message).Equals(message));
}
finally
{
Telegraph.Instance.UnRegisterAll();
GetStorageQueue(queueName).DeleteAsync();
GetStorageQueue(queueName + "-deadletter").DeleteAsync();
}
}
private static void TestValTypeArray <T>(IActorMessageSerializationActor serialization, IActorMessageDeserializationActor deserialization, T[] val) where T : IEquatable <T>
{
ValueArrayTypeMessage <T> intType = new ValueArrayTypeMessage <T>(val);
var typeVal = (T[])intType.Message;
string id = intType.Id;
SerializeMessage <IActorMessage> sMsg = new SerializeMessage <IActorMessage>(intType);
if (!serialization.OnMessageRecieved(sMsg))
{
Assert.Fail(string.Format("Seriaization of array {0} Failed", val.GetType().Name));
}
DeserializeMessage <IActorMessage> dMsg = new DeserializeMessage <IActorMessage>(sMsg.ProcessingResult as byte[]);
if (!deserialization.OnMessageRecieved(dMsg))
{
Assert.Fail(string.Format("DeSeriaization of array {0} Failed", val.GetType().Name));
}
T[] message = (T[])(dMsg.ProcessingResult as ValueTypeMessage <T>).Message;
for (int i = 0; i < message.Length; ++i)
{
Assert.IsTrue(message[i].Equals(typeVal[i]));
}
Assert.IsTrue(message.Length != 0);
Assert.IsTrue((dMsg.ProcessingResult as IActorMessageIdentifier).Id.Equals(id));
}
public void SendActorMessageToDirectoryQueue()
{
string queueName = "test-" + "SendActorMessageToStorageQueue".ToLower();
using (var queue = GetDirectoryQueue(queueName))
{
try
{
string message = "HelloWorld";
PingPong.Ping aMsg = new PingPong.Ping(message);
IActorMessageSerializationActor serializer = new IActorMessageSerializationActor();
var sendMessageQueue = new SendMessageToDirectoryQueue <PingPong.Ping>(queueRootPath, queueName, true);
Telegraph.Instance.Register <PingPong.Ping, SendMessageToDirectoryQueue <PingPong.Ping> >(() => sendMessageQueue);
Telegraph.Instance.Register <SerializeMessage <IActorMessage>, IActorMessageSerializationActor>(() => serializer);
if (!Telegraph.Instance.Ask(aMsg).Wait(new TimeSpan(0, 0, 10)))
{
Assert.Fail("Waited too long to send a message");
}
IActorMessageDeserializationActor deserializer = new IActorMessageDeserializationActor();
deserializer.Register <PingPong.Ping>((object msg) => (PingPong.Ping)msg);
DeserializeMessage <IActorMessage> dMsg = new DeserializeMessage <IActorMessage>(queue.GetMessage().AsBytes);
deserializer.Ask(dMsg);
var retMsgs = (PingPong.Ping)dMsg.ProcessingResult;
Assert.IsTrue(((string)retMsgs.Message).Equals(message));
}
finally
{
Telegraph.Instance.UnRegisterAll();
queue.Delete();
GetDirectoryQueue(queueName + "-deadletter").Delete();
}
}
}
public void SendActorMessageToServiceBusTopic()
{
string TopicName = "test-" + "SendActorMessageToServiceBusTopic".ToLower();
// we cannot send messages to topics that have no subscriptions in them
var proc = this.StartProcessing(TopicName, "test");
try
{
string message = "HelloWorld";
PingPong.Ping aMsg = new PingPong.Ping(message);
IActorMessageSerializationActor serializer = new IActorMessageSerializationActor();
Telegraph.Instance.Register <PingPong.Ping, SendMessageToServiceBusTopic <PingPong.Ping> >(() => new SendMessageToServiceBusTopic <PingPong.Ping>(Connections.ServiceBusConnectionString, TopicName, true));
Telegraph.Instance.Register <SerializeMessage <IActorMessage>, IActorMessageSerializationActor>(() => serializer);
IActorMessageDeserializationActor deserializer = new IActorMessageDeserializationActor();
deserializer.Register <PingPong.Ping>((object msg) => (PingPong.Ping)msg);
if (!Telegraph.Instance.Ask(aMsg).Wait(new TimeSpan(0, 0, 10)))
{
Assert.Fail("Waited too long to send a message");
}
ServiceBusReceivedMessage sbMessage = null;
WaitForQueue(sbMsgQueue, out sbMessage);
DeserializeMessage <IActorMessage> dMsg = new DeserializeMessage <IActorMessage>(sbMessage.Body.ToArray());
deserializer.Ask(dMsg);
var retMsgs = (PingPong.Ping)dMsg.ProcessingResult;
Assert.IsTrue(((string)retMsgs.Message).Equals(message));
}
finally
{
proc.StopProcessingAsync().Wait();
Telegraph.Instance.UnRegisterAll();
DeleteServiceBusTopic(TopicName);
}
}
public void SendActorMessageToEventHub()
{
string eventHubName = "test-" + "SendActorMessageToEventHub".ToLower();
string consumerGroup = eventHubName + Guid.NewGuid().ToString().Substring(0, 6);
CreateEventHub(eventHubName, consumerGroup);
try
{
string message = "HelloWorld";
PingPong.Ping aMsg = new PingPong.Ping(message);
IActorMessageSerializationActor serializer = new IActorMessageSerializationActor();
Telegraph.Instance.Register <PingPong.Ping, SendMessageToEventHub <PingPong.Ping> >(() => new SendMessageToEventHub <PingPong.Ping>(Connections.EventHubConnectionString, eventHubName, true));
Telegraph.Instance.Register <SerializeMessage <IActorMessage>, IActorMessageSerializationActor>(() => serializer);
if (!Telegraph.Instance.Ask(aMsg).Wait(new TimeSpan(0, 0, 10)))
{
Assert.Fail("Waited too long to send a message");
}
IActorMessageDeserializationActor deserializer = new IActorMessageDeserializationActor();
deserializer.Register <PingPong.Ping>((object msg) => (PingPong.Ping)msg);
EventData ehMessage = null;
StartEventHubReciever(eventHubName, consumerGroup);
WaitForQueue(ehMsgQueue, out ehMessage);
DeserializeMessage <IActorMessage> dMsg = new DeserializeMessage <IActorMessage>(ehMessage.Body.ToArray());
deserializer.Ask(dMsg);
var retMsgs = (PingPong.Ping)dMsg.ProcessingResult;
Assert.IsTrue(((string)retMsgs.Message).Equals(message));
}
finally
{
Telegraph.Instance.UnRegisterAll();
DeleteEventHub(eventHubName);
}
}
public static void ComplexMessageSerializationDeserialization()
{
Telegraph.Instance.Register(new LocalQueueOperator(new LocalSwitchboard(LocalConcurrencyType.ActorsOnThreadPool))); // performs a reset.
IActorMessageDeserializationActor deserialization = new IActorMessageDeserializationActor();
Telegraph.Instance.Register <SerializeMessage <IActorMessage>, IActorMessageSerializationActor>(() => new IActorMessageSerializationActor());
Telegraph.Instance.Register <DeserializeMessage <IActorMessage>, IActorMessageDeserializationActor>(() => deserialization);
deserialization.Register <CustomSerializableMessage>((object msg) => (CustomSerializableMessage)msg);
CustomSerializableMessage originalMsg = new CustomSerializableMessage(100, "Foo");
SerializeMessage <IActorMessage> serializeRqst = new SerializeMessage <IActorMessage>(originalMsg);
var serializeTask = Telegraph.Instance.Ask(serializeRqst);
serializeTask.Wait();
//NOTE you could also do the following to avoid having to register above
//var serializeTask = (new MessageSerializationActor()).Ask(serializeRqst);
//serializeTask.Wait();
byte[] serializedBytes = (serializeTask.Result.ProcessingResult as byte[]);
DeserializeMessage <IActorMessage> msgToDeSerialize = new DeserializeMessage <IActorMessage>(serializedBytes);
var task = Telegraph.Instance.Ask(msgToDeSerialize);
task.Wait();
CustomSerializableMessage output = (task.Result as CustomSerializableMessage);
Console.WriteLine("Serialized " + output.MyProperty.ToString());
System.Diagnostics.Debug.Assert(100 == output.MyProperty);
}
public static void BasicMessageSerializationDeserialization()
{
Telegraph.Instance.Register(new LocalQueueOperator(new LocalSwitchboard(LocalConcurrencyType.ActorsOnThreadPool))); // performs a reset.
Telegraph.Instance.Register <string>(message => Console.WriteLine("BasicMessageSerializationDeserialization: " + message));
Telegraph.Instance.Register <SerializeMessage <IActorMessage>, IActorMessageSerializationActor>(() => new IActorMessageSerializationActor());
Telegraph.Instance.Register <DeserializeMessage <IActorMessage>, IActorMessageDeserializationActor>(() => new IActorMessageDeserializationActor());
var processingTask = Telegraph.Instance.Ask("foo");
processingTask.Wait();
SerializeMessage <IActorMessage> serializeRqst = new SerializeMessage <IActorMessage>(processingTask.Result);
var serializeTask = Telegraph.Instance.Ask(serializeRqst);
serializeTask.Wait();
//NOTE you could also do the following to avoid having to register above
//var serializeTask = (new MessageSerializationActor()).Ask(serializeRqst);
//serializeTask.Wait();
byte[] serializedBytes = (serializeTask.Result.ProcessingResult as byte[]);
DeserializeMessage <IActorMessage> msgToSerialize2 = new DeserializeMessage <IActorMessage>(serializedBytes);
var task = Telegraph.Instance.Ask(msgToSerialize2);
task.Wait();
string output = (task.Result.Message as string);
System.Diagnostics.Debug.Assert(task.Result.GetType() == typeof(string));
Console.WriteLine("Serialized and De-serialized " + output);
}
public void DeSerializeInDeserializeClass()
{
byte[] serializedBytes = SimpleMessageSerializationReturn();
IActorMessageDeserializationActor deserializer = new IActorMessageDeserializationActor();
DeserializeMessage <IActorMessage> deserializationMessage = new DeserializeMessage <IActorMessage>(serializedBytes);
if (!deserializer.OnMessageRecieved(deserializationMessage))
{
Assert.Fail("De-serialization Failed.");
}
Assert.IsTrue(deserializationMessage.Message.Equals("Foo"));
}
public void DeSerializeDeSerializeMessage()
{
byte[] serializedBytes = SimpleMessageSerializationReturn();
IActorMessageDeserializationActor deserializer = new IActorMessageDeserializationActor();
DeserializeMessage <IActorMessage> deserializationMessage = new DeserializeMessage <IActorMessage>(serializedBytes);
Telegraph.Instance.Register <DeserializeMessage <IActorMessage>, IActorMessageDeserializationActor>(() => new IActorMessageDeserializationActor());
DeserializeMessage <IActorMessage> msgToSerialize2 = new DeserializeMessage <IActorMessage>(serializedBytes);
var task = Telegraph.Instance.Ask(msgToSerialize2);
task.Wait();
string output = (task.Result.Message as string);
Assert.IsTrue(output.Equals("Foo"));
}
public void SimpleMessageDeSerialization()
{
Telegraph.Instance.UnRegisterAll();
Telegraph.Instance.Register(new LocalQueueOperator(new LocalSwitchboard(LocalConcurrencyType.ActorsOnThreadPool))); // performs a reset.
IActorMessageSerializationActor serializer = new IActorMessageSerializationActor();
IActorMessageDeserializationActor deserializer = new IActorMessageDeserializationActor();
SimpleMessage <string> msgToSerialize = new SimpleMessage <string>();
msgToSerialize.Status = GetMessageCompletionMonitor();
msgToSerialize.Message = "Foo";
if (!serializer.OnMessageRecieved(msgToSerialize))
{
Console.Error.WriteLine("Serialization Failed.");
}
msgToSerialize.Status.Task.Wait();
byte[] serializedBytes = (msgToSerialize.Status.Task.Result.ProcessingResult as byte[]);
DeserializeMessage <IActorMessage> deserializationMessage = new DeserializeMessage <IActorMessage>(serializedBytes);
if (!deserializer.OnMessageRecieved(deserializationMessage))
{
Console.Error.WriteLine("De-serialization Failed.");
}
string deserilizedMessage = (deserializationMessage.Message as string);
msgToSerialize.ProcessingResult = null;
Telegraph.Instance.Register <DeserializeMessage <IActorMessage>, IActorMessageDeserializationActor>(() => new IActorMessageDeserializationActor());
DeserializeMessage <IActorMessage> msgToSerialize2 = new DeserializeMessage <IActorMessage>(serializedBytes);
var task = Telegraph.Instance.Ask(msgToSerialize2);
task.Wait();
string output = (task.Result.Message as string);
}
public static async Task <IWhatsAppApi <T> > Deserialize <T>(this IDeserialize <T> self, Task <string> json) where T : class, IDeserialize <T>, new()
{
if (self is null)
{
Error = new JsonError {
IsError = true, CodeOfError = 4, TextError = "WhatsAppMessage is null"
};
var result = new DeserializeMessage <T> {
Result = new T(), Error = Error
};
return(result);
}
var jsonMessage = await json;
if (string.IsNullOrEmpty(jsonMessage))
{
self.Deserialize.Error = new JsonError {
IsError = true, CodeOfError = 0, TextError = "Json file is empty"
};
return(self.Deserialize);
}
try
{
self.Deserialize.Result = JsonConvert.DeserializeObject <T>(jsonMessage, Settings);
self.Deserialize.Error = Error;
}
catch (JsonException)
{
self.Deserialize.Result = (T)self;
self.Deserialize.Error = new JsonError {
IsError = true, CodeOfError = 1, TextError = "Json file is broken"
};
}
self.Deserialize.Result.DateTime = DateTime.Now;
return(self.Deserialize);
}
public void SendActorMessageToServiceBusQueueViaOperator()
{
string queueName = "test-" + "SendActorMessageToServiceBusQueueViaOperator".ToLower();
var proc = this.StartProcessing(queueName);
try
{
string message = "HelloWorld";
PingPong.Ping aMsg = new PingPong.Ping(message);
long localOperatorID = Telegraph.Instance.Register(new LocalQueueOperator(LocalConcurrencyType.DedicatedThreadCount, 2));
long azureOperatorId = Telegraph.Instance.Register(new ServiceBusQueuePublishOperator <IActorMessage>(Connections.ServiceBusConnectionString, queueName, true));
Telegraph.Instance.Register <PingPong.Ping>(azureOperatorId);
IActorMessageSerializationActor serializer = new IActorMessageSerializationActor();
Telegraph.Instance.Register <SerializeMessage <IActorMessage>, IActorMessageSerializationActor>(localOperatorID, () => serializer);
if (!Telegraph.Instance.Ask(aMsg).Wait(new TimeSpan(0, 0, 10)))
{
Assert.Fail("Waited too long to send a message");
}
IActorMessageDeserializationActor deserializer = new IActorMessageDeserializationActor();
deserializer.Register <PingPong.Ping>((object msg) => (PingPong.Ping)msg);
ServiceBusReceivedMessage sbMessage = null;
WaitForQueue(sbMsgQueue, out sbMessage);
DeserializeMessage <IActorMessage> dMsg = new DeserializeMessage <IActorMessage>(sbMessage.Body.ToArray());
deserializer.Ask(dMsg);
var retMsgs = (PingPong.Ping)dMsg.ProcessingResult;
Assert.IsTrue(((string)retMsgs.Message).Equals(message));
}
finally
{
proc.StopProcessingAsync().Wait();
Telegraph.Instance.UnRegisterAll();
DeleteServiceBusQueue(queueName);
}
}
