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); } }
/// <summary> /// Emit the event specified and send the data /// </summary> /// <param name="eventName">Event to emit</param> /// <param name="o">Object to be sended</param> /// <returns>If the event was emitted</returns> public bool Emit(string eventName, object o) { try { Message msg = SerializeMessage.Serialize(o); byte[] serializedEvent = new byte[1024 + 255]; byte[] serializedEventName = new byte[255]; byte[] encodedEventName = Encoding.ASCII.GetBytes(eventName); int j = 0; for (int i = 0; i < encodedEventName.Length; i++) { serializedEvent[i] = encodedEventName[i]; } for (int i = 255; i < (255 + msg.Data.Length); i++) { serializedEvent[i] = msg.Data[j]; j++; } this.connection.Send(serializedEvent); return(true); } catch (SocketException e) { return(false); } }
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 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 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); }
/// <summary> /// Listen for a server request /// </summary> public void Listen() { Message msg = new Message(); object objReceived; string strEvent = ""; byte[] eventName; byte[] serializedEvent; bool connected = true; int objectIndex; try { while (connected) { serializedEvent = new byte[1024 + 255]; eventName = new byte[255]; msg.Data = new byte[1024]; objectIndex = 0; this.connection.Receive(serializedEvent, 0, 1024 + 255, SocketFlags.None); //Getting the event name buffer for (int i = 0; i < 255; i++) { eventName[i] = serializedEvent[i]; } strEvent = Utils.Buffer2String(eventName); //Getting the object buffer for (int i = 255; i < (1024 + 255); i++) { msg.Data[objectIndex] = serializedEvent[i]; objectIndex++; } objReceived = SerializeMessage.Deserialize(msg); this.executeEvent(strEvent, objReceived); } } catch (SocketException e) { this.executeEvent("disconnect", e.Message); } }
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 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 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 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); }