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)); }