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 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 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 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);
}
}
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 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 SendStringToServiceBusTopicViaOperator()
{
string TopicName = "test-" + "SendActorStringToServiceBusTopicViaOperator".ToLower();
// we cannot send messages to topics that have no subscriptions in them
var proc = this.StartProcessing(TopicName, "test");
try
{
string message = "HelloWorld";
long localOperatorID = Telegraph.Instance.Register(new LocalQueueOperator(LocalConcurrencyType.DedicatedThreadCount, 2));
long azureOperatorId = Telegraph.Instance.Register(new ServiceBusTopicPublishOperator <string>(Connections.ServiceBusConnectionString, TopicName, true));
Telegraph.Instance.Register <string>(azureOperatorId);
IActorMessageSerializationActor serializer = new IActorMessageSerializationActor();
Telegraph.Instance.Register <SerializeMessage <IActorMessage>, IActorMessageSerializationActor>(localOperatorID, () => serializer);
Telegraph.Instance.Ask(message).Wait();
ServiceBusReceivedMessage sbMessage = null;
WaitForQueue(sbMsgQueue, out sbMessage);
var retMsgs = Encoding.UTF8.GetString(sbMessage.Body.ToArray());
Assert.IsTrue((retMsgs).Equals(message));
}
finally
{
proc.StopProcessingAsync().Wait();
Telegraph.Instance.UnRegisterAll();
DeleteServiceBusTopic(TopicName);
}
}
static void SimpleSendMessageToAzureStorageQueue(string connectionString, string queueName)
{
// Setup send to queue
Telegraph.Instance.Register <PingPong.Ping, SendMessageToStorageQueue <PingPong.Ping> >(() => new SendMessageToStorageQueue <PingPong.Ping>(connectionString, queueName, true));
// Set up serialization
IActorMessageSerializationActor serializer = new IActorMessageSerializationActor();
Telegraph.Instance.Register <SerializeMessage <IActorMessage>, IActorMessageSerializationActor>(() => serializer);
// Send message to queue
Telegraph.Instance.Ask(new PingPong.Ping()).Wait();
// If you look on the queue the binary version of Ping will have been put you can use the Deserialization Actor to pull this message down later
}
static void SendToAzureServiceBusSubscription(string connectionString, string topicName, string subscriptionsToCreate)
{
long azureOperatorId = Telegraph.Instance.Register(new ServiceBusTopicPublishOperator <IActorMessage>(serviceBusConnectionString, topicName, subscriptionsToCreate, true));
Telegraph.Instance.Register <PingPong.Ping>(azureOperatorId);
IActorMessageSerializationActor serializer = new IActorMessageSerializationActor();
long localOperatorID = Telegraph.Instance.Register(new LocalQueueOperator(LocalConcurrencyType.DedicatedThreadCount, 2));
Telegraph.Instance.Register <SerializeMessage <IActorMessage>, IActorMessageSerializationActor>(localOperatorID, () => serializer);
// NOTE: we route all non registered messages to the main operator
for (int i = 0; i < 10; ++i)
{
Telegraph.Instance.Ask(new PingPong.Ping()).Wait();
}
Telegraph.Instance.Ask(new ControlMessages.HangUp()).Wait();
}
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 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();
}
}
}
static void SendMessagesWithServiceBusProperties(string connectionString, string topicName, string subscriptionsToCreate, TimeSpan delay)
{
long azureOperatorId = Telegraph.Instance.Register(new ServiceBusTopicPublishOperator <IActorMessage>(serviceBusConnectionString, topicName, subscriptionsToCreate, true));
Telegraph.Instance.Register <PingPong.Pung>(azureOperatorId);
IActorMessageSerializationActor serializer = new IActorMessageSerializationActor();
long localOperatorID = Telegraph.Instance.Register(new LocalQueueOperator(LocalConcurrencyType.DedicatedThreadCount, 2));
Telegraph.Instance.Register <SerializeMessage <IActorMessage>, IActorMessageSerializationActor>(localOperatorID, () => serializer);
// enqueu in the topic in 1 hour the class Pung implments IServiceBusPropertiesProvider and sets EnequeueTime
// this will tell azure to accept the message but only enqueue it after 1 minute elapses.
for (int i = 0; i < 10; ++i)
{
Telegraph.Instance.Ask(new PingPong.Pung("Pung", DateTime.UtcNow.Add(delay))).Wait();
}
Telegraph.Instance.Ask(new ControlMessages.HangUp()).Wait();
}
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 byte[] SimpleMessageSerializationReturn()
{
Telegraph.Instance.UnRegisterAll();
Telegraph.Instance.Register(new LocalQueueOperator(new LocalSwitchboard(LocalConcurrencyType.ActorsOnThreadPool))); // performs a reset.
IActorMessageSerializationActor serializer = new IActorMessageSerializationActor();
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[]);
return(serializedBytes);
}
public HybridConnectionListener CreateHybridListener(string hybridConnectionName, PingPong.Pong response)
{
RelayConnectionStringBuilder connectionStringBuilder = new RelayConnectionStringBuilder(Connections.HybridRelayConnectionString)
{
EntityPath = hybridConnectionName
};
//var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(connectionStringBuilder.SharedAccessKeyName, connectionStringBuilder.SharedAccessKey);
//var uri = new Uri(string.Format("https://{0}/{1}", connectionStringBuilder.Endpoint.Host, hybridConnectionName));
var listener = new HybridConnectionListener(connectionStringBuilder.ToString());
SerializeMessage <IActorMessage> sMsg = new SerializeMessage <IActorMessage>(response);
IActorMessageSerializationActor serializer = new IActorMessageSerializationActor();
serializer.OnMessageRecieved(sMsg);
byte[] responseBytes = (byte[])sMsg.ProcessingResult;
// Subscribe to the status events.
listener.Connecting += (o, e) => { Console.WriteLine("Connecting"); };
listener.Offline += (o, e) => { Console.WriteLine("Offline"); };
listener.Online += (o, e) => { Console.WriteLine("Online"); };
// Provide an HTTP request handler
listener.RequestHandler = (context) =>
{
// Do something with context.Request.Url, HttpMethod, Headers, InputStream...
context.Response.StatusCode = HttpStatusCode.OK;
context.Response.StatusDescription = "OK";
context.Response.OutputStream.Write(responseBytes, 0, responseBytes.Length);
// The context MUST be closed here
context.Response.Close();
};
listener.OpenAsync().Wait();
Console.WriteLine("Server listening");
return(listener);
}
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);
}
}
public byte[] SerializeSerializeMessageReturn()
{
Telegraph.Instance.UnRegisterAll();
Telegraph.Instance.Register(new LocalQueueOperator(new LocalSwitchboard(LocalConcurrencyType.ActorsOnThreadPool))); // performs a reset.
IActorMessageSerializationActor serializer = new IActorMessageSerializationActor();
SimpleMessage <string> msgToSerialize = new SimpleMessage <string>();
msgToSerialize.Message = "Foo";
SerializeMessage <IActorMessage> serializeMessage = new SerializeMessage <IActorMessage>(msgToSerialize);
msgToSerialize.ProcessingResult = null;
Telegraph.Instance.Register <SerializeMessage <IActorMessage>, IActorMessageSerializationActor>(() => new IActorMessageSerializationActor());
var task = Telegraph.Instance.Ask(serializeMessage);
task.Wait();
byte[] serializedBytes2 = (task.Result.ProcessingResult as byte[]);
return(serializedBytes2);
}
public void SerializeAValueTypeMessage()
{
IActorMessageSerializationActor serialization = new IActorMessageSerializationActor();
IActorMessageDeserializationActor deserialization = new IActorMessageDeserializationActor();
deserialization.Register((object msg) => (ValueTypeMessage <int>)msg);
deserialization.Register((object msg) => (ValueArrayTypeMessage <int>)msg);
deserialization.Register((object msg) => (ValueTypeMessage <double>)msg);
deserialization.Register((object msg) => (ValueArrayTypeMessage <double>)msg);
deserialization.Register((object msg) => (ValueTypeMessage <float>)msg);
deserialization.Register((object msg) => (ValueArrayTypeMessage <float>)msg);
deserialization.Register((object msg) => (ValueTypeMessage <byte>)msg);
deserialization.Register((object msg) => (ValueArrayTypeMessage <byte>)msg);
deserialization.Register((object msg) => (ValueTypeMessage <sbyte>)msg);
deserialization.Register((object msg) => (ValueArrayTypeMessage <sbyte>)msg);
deserialization.Register((object msg) => (ValueTypeMessage <short>)msg);
deserialization.Register((object msg) => (ValueArrayTypeMessage <short>)msg);
deserialization.Register((object msg) => (ValueTypeMessage <ushort>)msg);
deserialization.Register((object msg) => (ValueArrayTypeMessage <ushort>)msg);
deserialization.Register((object msg) => (ValueTypeMessage <uint>)msg);
deserialization.Register((object msg) => (ValueArrayTypeMessage <uint>)msg);
deserialization.Register((object msg) => (ValueTypeMessage <double>)msg);
deserialization.Register((object msg) => (ValueArrayTypeMessage <double>)msg);
deserialization.Register((object msg) => (ValueTypeMessage <long>)msg);
deserialization.Register((object msg) => (ValueArrayTypeMessage <long>)msg);
deserialization.Register((object msg) => (ValueTypeMessage <ulong>)msg);
deserialization.Register((object msg) => (ValueArrayTypeMessage <ulong>)msg);
deserialization.Register((object msg) => (ValueTypeMessage <bool>)msg);
deserialization.Register((object msg) => (ValueArrayTypeMessage <bool>)msg);
deserialization.Register((object msg) => (ValueTypeMessage <decimal>)msg);
deserialization.Register((object msg) => (ValueArrayTypeMessage <decimal>)msg);
deserialization.Register((object msg) => (ValueTypeMessage <char>)msg);
deserialization.Register((object msg) => (ValueArrayTypeMessage <char>)msg);
deserialization.Register((object msg) => (ValueTypeMessage <DateTime>)msg);
deserialization.Register((object msg) => (ValueArrayTypeMessage <DateTime>)msg);
deserialization.Register((object msg) => (ValueTypeMessage <TimeSpan>)msg);
deserialization.Register((object msg) => (ValueArrayTypeMessage <TimeSpan>)msg);
deserialization.Register((object msg) => (ValueTypeMessage <Guid>)msg);
deserialization.Register((object msg) => (ValueArrayTypeMessage <Guid>)msg);
deserialization.Register((object msg) => (ValueTypeMessage <DateTimeOffset>)msg);
deserialization.Register((object msg) => (ValueArrayTypeMessage <DateTimeOffset>)msg);
//deserialization.Register((object msg) => (ValueTypeMessage<ArraySegment<byte>>)msg);
deserialization.Register((object msg) => (ValueTypeMessage <TimeZoneInfo.TransitionTime>)msg);
deserialization.Register((object msg) => (ValueArrayTypeMessage <TimeZoneInfo.TransitionTime>)msg);
DateTime start = DateTime.Now;
DateTime utcStart = start.ToUniversalTime();
TestValType <int>(serialization, deserialization, 4);
TestValTypeArray <int>(serialization, deserialization, new int[] { 4, 3 });
TestValType <double>(serialization, deserialization, 4.2);
TestValTypeArray <double>(serialization, deserialization, new double[] { 4, 3 });
TestValType <float>(serialization, deserialization, 4.1F);
TestValTypeArray <float>(serialization, deserialization, new float[] { 4, 3 });
TestValType <byte>(serialization, deserialization, 8);
TestValTypeArray <byte>(serialization, deserialization, new byte[] { 4, 3 });
TestValType <sbyte>(serialization, deserialization, 2);
TestValTypeArray <sbyte>(serialization, deserialization, new sbyte[] { 4, 3 });
TestValType <short>(serialization, deserialization, 30);
TestValTypeArray <short>(serialization, deserialization, new short[] { 4, 3 });
TestValType <ushort>(serialization, deserialization, 200);
TestValTypeArray <ushort>(serialization, deserialization, new ushort[] { 4, 3 });
TestValType <uint>(serialization, deserialization, uint.MaxValue);
TestValTypeArray <uint>(serialization, deserialization, new uint[] { 4, 3 });
TestValType <long>(serialization, deserialization, long.MinValue);
TestValTypeArray <long>(serialization, deserialization, new long[] { 4, 3 });
TestValType <ulong>(serialization, deserialization, ulong.MaxValue);
TestValTypeArray <ulong>(serialization, deserialization, new ulong[] { 4, 3 });
TestValType <ulong>(serialization, deserialization, ulong.MinValue);
TestValTypeArray <ulong>(serialization, deserialization, new ulong[] { 4, 3 });
TestValType <bool>(serialization, deserialization, true);
TestValTypeArray <bool>(serialization, deserialization, new bool[] { true, false });
TestValType <bool>(serialization, deserialization, false);
TestValType <decimal>(serialization, deserialization, (decimal)5.67);
TestValTypeArray <decimal>(serialization, deserialization, new decimal[] { 4, 3 });
TestValType <char>(serialization, deserialization, 'a');
TestValTypeArray <char>(serialization, deserialization, new char[] { 'a', 'c' });
TestValType <DateTime>(serialization, deserialization, DateTime.Now);
TestValType <TimeSpan>(serialization, deserialization, DateTime.Now - start);
TestValType <Guid>(serialization, deserialization, Guid.NewGuid());
TestValTypeArray <Guid>(serialization, deserialization, new Guid[] { Guid.NewGuid(), Guid.NewGuid() });
TestValType <DateTimeOffset>(serialization, deserialization, new DateTimeOffset(start));
var myDt = DateTime.SpecifyKind(new DateTime(1, 1, 1), DateTimeKind.Unspecified);
TestValType <TimeZoneInfo.TransitionTime>(serialization, deserialization, TimeZoneInfo.TransitionTime.CreateFixedDateRule(myDt, 10, 11));
}
