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 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();
}
}
public void RecieveActorMessageFromServiceBusTopic()
{
string subscription = "firstsubscription";
string TopicName = "test-" + "RecieveActorMessageFromServiceBusTopic".ToLower();
var Topic = GetServiceBusTopicSender(TopicName);
try
{
CreateTopicAndSubscriptions(TopicName, new string[] { subscription });
string message = "HelloWorld";
var actorMessage = new PingPong.Ping(message);
SerializeMessage <IActorMessage> sMsg = new SerializeMessage <IActorMessage>(actorMessage);
IActorMessageSerializationActor serializer = new IActorMessageSerializationActor();
serializer.OnMessageRecieved(sMsg);
byte[] msgBytes = (byte[])sMsg.ProcessingResult;
Topic.SendMessageAsync(new ServiceBusMessage(msgBytes));
long azureOperatorID = Telegraph.Instance.Register(
new ServiceBusTopicSubscriptionOperator <IActorMessage>(LocalConcurrencyType.DedicatedThreadCount, Connections.ServiceBusConnectionString, TopicName, subscription, false),
(PingPong.Ping foo) => { Assert.IsTrue(message.Equals((string)foo.Message, StringComparison.InvariantCulture)); });
}
finally
{
Telegraph.Instance.UnRegisterAll();
DeleteServiceBusTopic(TopicName);
}
}
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 RecieveActorMessageFromServiceBusQueue()
{
string queueName = "test-" + "RecieveActorMessageFromServiceBusQueue".ToLower();
try
{
this.StartProcessing(queueName);
var sender = GetServiceBusQueueSender(queueName);
string message = "HelloWorld";
var actorMessage = new PingPong.Ping(message);
SerializeMessage <IActorMessage> sMsg = new SerializeMessage <IActorMessage>(actorMessage);
IActorMessageSerializationActor serializer = new IActorMessageSerializationActor();
serializer.OnMessageRecieved(sMsg);
byte[] msgBytes = (byte[])sMsg.ProcessingResult;
sender.SendMessageAsync(new ServiceBusMessage(msgBytes));
long azureOperatorID = Telegraph.Instance.Register(
new ServiceBusQueueSubscriptionOperator <IActorMessage>(LocalConcurrencyType.DedicatedThreadCount, Connections.ServiceBusConnectionString, queueName, false, 2),
(PingPong.Ping foo) => { Assert.IsTrue(message.Equals((string)foo.Message, StringComparison.InvariantCulture)); });
}
finally
{
Telegraph.Instance.UnRegisterAll();
DeleteServiceBusQueue(queueName);
}
}
public void RecieveActorMessageFromEventHub()
{
string eventHubName = "test-" + "RecieveActorMessageFromEventHub".ToLower();
string consumerGroup = eventHubName + Guid.NewGuid().ToString().Substring(0, 6);
CreateEventHub(eventHubName, consumerGroup);
var client = new EventHubProducerClient(Connections.EventHubConnectionString, eventHubName);
try
{
string message = "HelloWorld";
var actorMessage = new PingPong.Ping(message);
SerializeMessage <IActorMessage> sMsg = new SerializeMessage <IActorMessage>(actorMessage);
IActorMessageSerializationActor serializer = new IActorMessageSerializationActor();
serializer.OnMessageRecieved(sMsg);
byte[] msgBytes = (byte[])sMsg.ProcessingResult;
using (var eventBatch = client.CreateBatchAsync().Result)
{
eventBatch.TryAdd(new EventData(msgBytes));
client.SendAsync(eventBatch).Wait();
}
long azureOperatorID = Telegraph.Instance.Register(
new EventHubSubscriptionOperator <IActorMessage>(Connections.EventHubConnectionString, eventHubName, false),
(PingPong.Ping foo) => { Assert.IsTrue(message.Equals((string)foo.Message, StringComparison.InvariantCulture)); });
}
finally
{
Telegraph.Instance.UnRegisterAll();
DeleteEventHub(eventHubName);
}
}
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 void TestSendingObjectToMsmq()
{
Telegraph.Instance.UnRegisterAll();
// create message
string messageString = "Hello World";
string queueName = "TestSendingObjectToMsmq";
MsmqDeliveryOperator <PingPong.Ping> deliveryOp = new MsmqDeliveryOperator <PingPong.Ping>(queueName);
Telegraph.Instance.Register <PingPong.Ping, MsmqDeliveryOperator <PingPong.Ping> >(() => deliveryOp);
// Send message to queue
List <Task> waitTasks = new List <Task>();
int i = 0;
for (i = 0; i < 100; ++i)
{
PingPong.Ping ping = new PingPong.Ping(messageString);
waitTasks.Add(Telegraph.Instance.Ask(ping));
}
Task.WaitAll(waitTasks.ToArray());
Telegraph.Instance.UnRegisterAll();
int count = 0;
MsmqReceptionOperator <PingPong.Ping> receptionOp = new MsmqReceptionOperator <PingPong.Ping>(queueName);
long azureOperatorID = Telegraph.Instance.Register(receptionOp);
Telegraph.Instance.Register <PingPong.Ping>(azureOperatorID, ping =>
{
PingPong.Ping msg = (PingPong.Ping)ping;
System.Threading.Thread.Sleep(100);
System.Threading.Interlocked.Increment(ref count);
});
int attempts = 20;
while (attempts != 0 && count < i)
{
System.Threading.Thread.Sleep(1000);
--attempts;
}
System.Diagnostics.Debug.WriteLine("Count:" + count);
Assert.IsTrue(count == i);
System.Messaging.MessageQueue.Delete(receptionOp.Queue.Path);
}
public void RecieveActorMessageFromDirectoryQueue()
{
string queueName = "test-" + "RecieveActorMessageFromStorageQueue".ToLower();
using (var queue = GetDirectoryQueue(queueName))
{
queue.CreateIfNotExists();
try
{
string message = "HelloWorld";
var actorMessage = new PingPong.Ping(message);
SerializeMessage <IActorMessage> sMsg = new SerializeMessage <IActorMessage>(actorMessage);
IActorMessageSerializationActor serializer = new IActorMessageSerializationActor();
serializer.OnMessageRecieved(sMsg);
byte[] msgBytes = (byte[])sMsg.ProcessingResult;
ManualResetEvent received = new ManualResetEvent(false);
IActorMessageDeserializationActor deserilaizationActor = new IActorMessageDeserializationActor();
Telegraph.Instance.Register <DeserializeMessage <IActorMessage> >(deserilaizationActor);
deserilaizationActor.Register((object msg) => (IActorMessage)msg);
deserilaizationActor.Register((object msg) => (PingPong.Ping)msg);
long azureOperatorID = Telegraph.Instance.Register(
new DirectoryQueueSubscriptionOperator <IActorMessage>(LocalConcurrencyType.DedicatedThreadCount, queueRootPath, queueName, false, 2),
(PingPong.Ping foo) =>
{
Assert.IsTrue(message.Equals((string)foo.Message, StringComparison.InvariantCulture));
received.Set();
});
queue.AddMessage(new DirectoryQueueMessage(msgBytes));
Assert.IsTrue(received.WaitOne(TimeSpan.FromSeconds(13), true), "We did not receive the message");
}
finally
{
Telegraph.Instance.UnRegisterAll();
GetDirectoryQueue(queueName).Delete();
GetDirectoryQueue(queueName + "-deadletter").Delete();
}
}
}
public void TestSendingActorMessageToHybridConnection()
{
string relayName = "TestSendingActorMessageToHybridConnection";
string sendMessage = "Hello";
var actorSendMessage = new PingPong.Ping(sendMessage);
var actorResponseMessage = new PingPong.Pong();
CreateHybridConnection(relayName);
Telegraph.Instance.Register(typeof(Exception), FailOnException);
HybridConnectionListener listener = null;
try
{
listener = CreateHybridListener(relayName, actorResponseMessage);
var relayConnection = new Telegraphy.Azure.Relay.Hybrid.RecieveResponseFromRequest <PingPong.Ping, PingPong.Pong>(Connections.HybridRelayConnectionString, relayName);
IActorMessageSerializationActor serializer = new IActorMessageSerializationActor();
IActorMessageDeserializationActor deserializer = new IActorMessageDeserializationActor();
deserializer.Register <PingPong.Pong>((object msg) => (PingPong.Pong)msg);
Telegraph.Instance.Register <SerializeMessage <PingPong.Ping>, IActorMessageSerializationActor>(() => serializer);
Telegraph.Instance.Register <DeserializeMessage <PingPong.Pong>, IActorMessageDeserializationActor>(() => deserializer);
Telegraph.Instance.Register <PingPong.Ping, Telegraphy.Azure.Relay.Hybrid.RecieveResponseFromRequest <PingPong.Ping, PingPong.Pong> >(() => relayConnection);
var resultTask = Telegraph.Instance.Ask(actorSendMessage);
bool success = resultTask.Wait(TimeSpan.FromSeconds(10));
Assert.IsTrue(success);
if (success)
{
Assert.IsTrue(resultTask.Result is PingPong.Pong);
}
}
finally
{
Telegraph.Instance.UnRegisterAll();
try { listener?.CloseAsync().Wait(); } catch (Exception) { }
DeleteRelay(relayName);
}
}
public void RecieveActorMessageFromStorageQueuePostRegister()
{
string queueName = "test-" + "RecieveActorMessageFromStorageQueuePostRegister".ToLower();
var queue = GetStorageQueue(queueName);
queue.CreateIfNotExists();
try
{
string message = "HelloWorld";
var actorMessage = new PingPong.Ping(message);
SerializeMessage <IActorMessage> sMsg = new SerializeMessage <IActorMessage>(actorMessage);
IActorMessageSerializationActor serializer = new IActorMessageSerializationActor();
serializer.OnMessageRecieved(sMsg);
byte[] msgBytes = (byte[])sMsg.ProcessingResult;
string base64MsgBytes = Convert.ToBase64String(msgBytes);
ManualResetEvent received = new ManualResetEvent(false);
Telegraph.Instance.Register <DeserializeMessage <IActorMessage>, IActorMessageDeserializationActor>(() => new IActorMessageDeserializationActor());
long azureOperatorID = Telegraph.Instance.Register(
new StorageQueueSubscriptionOperator <IActorMessage>(LocalConcurrencyType.DedicatedThreadCount, Connections.StorageConnectionString, queueName, false, 2),
(PingPong.Ping foo) =>
{
Assert.IsTrue(message.Equals((string)foo.Message, StringComparison.InvariantCulture));
received.Set();
});
queue.SendMessage(new BinaryData(base64MsgBytes));
Assert.IsTrue(received.WaitOne(TimeSpan.FromSeconds(3), true), "We did not receive the message");
}
finally
{
Telegraph.Instance.UnRegisterAll();
GetStorageQueue(queueName).DeleteAsync();
GetStorageQueue(queueName + "-deadletter").DeleteAsync();
}
}
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);
}
}
