public void MessageOfUnknownTypeShouldPauseProcessingTillCorrespondingHandlerIsRegisteredTest() { using (var transport = new Transport(HOST, "guest", "guest")) { IProcessingGroup processingGroup = transport.CreateProcessingGroup(null); var type1Received = new AutoResetEvent(false); var type2Received = new AutoResetEvent(false); processingGroup.Subscribe(TEST_QUEUE, (message, acknowledge) => { type1Received.Set(); acknowledge(true); }, "type1"); processingGroup.Send(TEST_EXCHANGE, new BinaryMessage { Bytes = new byte[] { 0x0, 0x1, 0x2 }, Type = "type1" }, 0); Assert.That(type1Received.WaitOne(500), Is.True, "Message of subscribed type was not delivered"); processingGroup.Send(TEST_EXCHANGE, new BinaryMessage { Bytes = new byte[] { 0x0, 0x1, 0x2 }, Type = "type2" }, 0); //Give time for type2 message to be pushed back by mq //Thread.Sleep(500); processingGroup.Send(TEST_EXCHANGE, new BinaryMessage { Bytes = new byte[] { 0x0, 0x1, 0x2 }, Type = "type1" }, 0); Assert.That(type1Received.WaitOne(500), Is.False, "Message of not subscribed type has not paused processing"); Assert.That(type2Received.WaitOne(500), Is.False, "Message of not subscribed type has not paused processing"); processingGroup.Subscribe(TEST_QUEUE, (message, acknowledge) => { type2Received.Set(); acknowledge(true); }, "type2"); Assert.That(type1Received.WaitOne(500), Is.True, "Processing was not resumed after handler for unknown message type was registered"); Assert.That(type2Received.WaitOne(500), Is.True, "Processing was not resumed after handler for unknown message type was registered"); } }
public void UnknownMessageTypeHandlerWaitingDoesNotPreventTransportDisposeTest() { var received = new ManualResetEvent(false); Thread connectionThread = null; using (var transport = new Transport(HOST, "guest", "guest")) { IProcessingGroup processingGroup = transport.CreateProcessingGroup(null); processingGroup.Subscribe(TEST_QUEUE, (message, acknowledge) => { connectionThread = Thread.CurrentThread; received.Set(); }, "type1"); processingGroup.Send(TEST_EXCHANGE, new BinaryMessage { Bytes = new byte[] { 0x0, 0x1, 0x2 }, Type = "type1" }, 0); Assert.That(received.WaitOne(100), Is.True, "Message was not delivered"); processingGroup.Send(TEST_EXCHANGE, new BinaryMessage { Bytes = new byte[] { 0x0, 0x1, 0x2 }, Type = "type2" }, 0); } Thread.Sleep(200); Assert.That(connectionThread.ThreadState, Is.EqualTo(ThreadState.Stopped), "Processing thread is still active in spite of transport dispose"); }
private void ensureProcessingGroupIsCreated(string destination) { if (m_Instance != null) { if (m_IsQueueGroup != isQueue(destination)) { throw new InvalidOperationException(string.Format("Can not process {0} {1} as it is already used for {2} processing. Sonic does not support processing topic and queue in same thread", m_IsQueueGroup ? "Topic" : "Queue", destination, m_IsQueueGroup ? "Queue" : "Topic")); } return; } lock (m_SyncRoot) { if (m_Instance == null) { m_IsQueueGroup = isQueue(destination); if (m_IsQueueGroup) { m_Instance = new QueueProcessingGroup(m_Connection, m_JailedTag, m_MessageFormat); } else { m_Instance = new TopicProcessingGroup(m_Connection, m_JailedTag, m_MessageFormat); } } } }
public void SendTest() { using (var transport = new InMemoryTransport()) { var delivered1 = new ManualResetEvent(false); var delivered2 = new ManualResetEvent(false); IProcessingGroup processingGroup = transport.CreateProcessingGroup(null); processingGroup.Subscribe(TEST_TOPIC, (message, ack) => { delivered1.Set(); Console.WriteLine("subscription1: message:" + message.Type); }, typeof(byte[]).Name); processingGroup.Subscribe(TEST_TOPIC, (message, ack) => { delivered2.Set(); Console.WriteLine("subscription2: message:" + message.Type); }, typeof(byte[]).Name); processingGroup.Send(TEST_TOPIC, new BinaryMessage { Bytes = new byte[] { 0x0, 0x1, 0x2 }, Type = typeof(byte[]).Name }, 0); Assert.That(delivered1.WaitOne(1000), Is.True, "message was not delivered to all subscribers"); Assert.That(delivered2.WaitOne(1000), Is.True, "message was not delivered to all subscribers"); Thread.Sleep(1000); } }
public void NackTest() { using (var transport = new Transport(HOST, "guest", "guest")) { var delivered = new ManualResetEvent(false); IProcessingGroup processingGroup = transport.CreateProcessingGroup(null); processingGroup.Send(TEST_EXCHANGE, new BinaryMessage { Bytes = new byte[] { 0x0, 0x1, 0x2 }, Type = typeof(byte[]).Name }, 0); processingGroup.Subscribe(TEST_QUEUE, (message, acknowledge) => { Console.WriteLine("message:" + message.Type); delivered.Set(); acknowledge(false); }, typeof(byte[]).Name); Assert.That(delivered.WaitOne(300), Is.True, "Message was not delivered"); } using (var transport = new Transport(HOST, "guest", "guest")) { var delivered = new ManualResetEvent(false); IProcessingGroup processingGroup = transport.CreateProcessingGroup(null); processingGroup.Subscribe(TEST_QUEUE, (message, acknowledge) => delivered.Set(), typeof(byte[]).Name); Assert.That(delivered.WaitOne(1000), Is.True, "Message was not returned to queue"); } }
public void PerformanceTest(int messageSize) { var messageBytes = new byte[messageSize]; new Random().NextBytes(messageBytes); using (var transport = new Transport(HOST, "guest", "guest")) { IProcessingGroup processingGroup = transport.CreateProcessingGroup(null); Stopwatch sw = Stopwatch.StartNew(); processingGroup.Send(TEST_EXCHANGE, new BinaryMessage { Bytes = messageBytes, Type = typeof(byte[]).Name }, 0); int sendCounter; for (sendCounter = 0; sw.ElapsedMilliseconds < 4000; sendCounter++) { processingGroup.Send(TEST_EXCHANGE, new BinaryMessage { Bytes = messageBytes, Type = typeof(byte[]).Name }, 0); } int receiveCounter = 0; var ev = new ManualResetEvent(false); processingGroup.Subscribe(TEST_QUEUE, (message, acknowledge) => receiveCounter++, typeof(byte[]).Name); ev.WaitOne(2000); Console.WriteLine("Send: {0} per second. {1:0.00} Mbit/s", sendCounter / 4, 1.0 * sendCounter * messageSize / 4 / 1024 / 1024 * 8); Console.WriteLine("Receive: {0} per second. {1:0.00} Mbit/s", receiveCounter / 2, 1.0 * receiveCounter * messageSize / 2 / 1024 / 1024 * 8); } }
public void Dispose() { if (ProcessingGroup == null) { return; } ProcessingGroup.Dispose(); ProcessingGroup = null; }
public void AttemptToSubscribeSameDestinationWithoutMessageTypeTwiceFailureTest() { using (var transport = new Transport(HOST, "guest", "guest")) { IProcessingGroup processingGroup = transport.CreateProcessingGroup(null); processingGroup.Subscribe(TEST_QUEUE, (message, acknowledge) => { }, null); processingGroup.Subscribe(TEST_QUEUE, (message, acknowledge) => { }, null); } }
internal void RemoveProcessingGroup(IProcessingGroup <T> processingGroup) { if (processingGroup == null) { throw new ArgumentNullException(nameof(processingGroup)); } _processingGroups.Remove(processingGroup); }
public void Dispose() { if (m_Instance != null) { lock (m_SyncRoot) { if (m_Instance != null) { m_Instance.Dispose(); m_Instance = null; } } } }
public void UnsubscribeTest(string messageType) { using (var transport = new Transport(HOST, "guest", "guest")) { var ev = new AutoResetEvent(false); IProcessingGroup processingGroup = transport.CreateProcessingGroup(null); processingGroup.Send(TEST_EXCHANGE, new BinaryMessage { Bytes = new byte[] { 0x0, 0x1, 0x2 }, Type = messageType }, 0); IDisposable subscription = processingGroup.Subscribe(TEST_QUEUE, (message, acknowledge) => ev.Set(), messageType); Assert.That(ev.WaitOne(500), Is.True, "Message was not delivered"); subscription.Dispose(); Assert.That(ev.WaitOne(500), Is.False, "Message was delivered for canceled subscription"); } }
public void UnsubscribeTest() { using (var transport = new InMemoryTransport()) { var ev = new AutoResetEvent(false); IProcessingGroup processingGroup = transport.CreateProcessingGroup(null); IDisposable subscription = processingGroup.Subscribe(TEST_TOPIC, (message, ack) => ev.Set(), null); processingGroup.Send(TEST_TOPIC, new BinaryMessage { Bytes = new byte[] { 0x0, 0x1, 0x2 }, Type = null }, 0); Assert.That(ev.WaitOne(500), Is.True, "Message was not delivered"); subscription.Dispose(); Assert.That(ev.WaitOne(500), Is.False, "Message was delivered for canceled subscription"); } }
public void DisposeTest() { ManualResetEvent delivered = new ManualResetEvent(false); int deliveredMessagesCount = 0; var transport = new InMemoryTransport(); IProcessingGroup processingGroup = transport.CreateProcessingGroup(null); processingGroup.Subscribe(TEST_TOPIC, (message, ack) => { delivered.WaitOne(); Interlocked.Increment(ref deliveredMessagesCount); }, null); processingGroup.Send(TEST_TOPIC, new BinaryMessage(), 0); Thread.Sleep(200); var task = Task.Factory.StartNew(transport.Dispose); Assert.That(task.Wait(200), Is.False, "transport was disposd before all message processing finished"); delivered.Set(); Assert.That(task.Wait(1000), Is.True, "transport was not disposd after all message processing finished"); }
public void ConnectionFailureTest() { using (var transport = new Transport(HOST, "guest", "guest")) { var onFailureCalled = new AutoResetEvent(false); IProcessingGroup processingGroup = transport.CreateProcessingGroup(() => { onFailureCalled.Set(); Console.WriteLine(Thread.CurrentThread.ManagedThreadId); }); processingGroup.Send(TEST_EXCHANGE, new BinaryMessage { Bytes = new byte[] { 0x0, 0x1, 0x2 }, Type = "messageType" }, 0); processingGroup.Subscribe(TEST_QUEUE, (message, acknowledge) => { }, "messageType"); FieldInfo field = typeof(ProcessingGroup).GetField("m_Connection", BindingFlags.NonPublic | BindingFlags.Instance); var connection = field.GetValue(processingGroup) as IConnection; connection.Abort(1, "All your base are belong to us"); Assert.That(onFailureCalled.WaitOne(500), Is.True, "Subsciptionwas not notefied on failure"); } }
public void HandlerWaitStopsAndMessageOfUnknownTypeReturnsToQueueOnUnsubscribeTest() { using (var transport = new Transport(HOST, "guest", "guest")) { IProcessingGroup processingGroup = transport.CreateProcessingGroup(null); var received = new AutoResetEvent(false); IDisposable subscription = processingGroup.Subscribe(TEST_QUEUE, (message, acknowledge) => { received.Set(); Console.WriteLine(Thread.CurrentThread.ManagedThreadId); }, "type2"); processingGroup.Send(TEST_EXCHANGE, new BinaryMessage { Bytes = new byte[] { 0x0, 0x1, 0x2 }, Type = "type1" }, 0); Assert.That(received.WaitOne(500), Is.False, "Message of not subscribed type has not paused processing"); subscription.Dispose(); processingGroup.Subscribe(TEST_QUEUE, (message, acknowledge) => received.Set(), "type1"); Assert.That(received.WaitOne(500), Is.True, "Message was not returned to queue"); } }
private static void MainMenu() { //------------------------------------------Enumerator Check //var enumerator = sqlORM.GetEnumerator(); //enumerator.MoveNext(); //var current = enumerator.Current; //------------------------------------------ //------------------------------------------MongoDB Check //var connectopn = ConfigurationManager.ConnectionStrings["MongoDBObservationConnection"].ConnectionString; //var newItem = new FlashObservation( 11, 23.3, new Coordinates(12, 12), DateTime.Now); //var mongoStorage = new MongoDBStorage<IEnergyObservation>(connectopn, "observation", "energyObservations"); //mongoStorage.Add(newItem); //var analizer = new MongoDBAnalizer(mongoStorage.ObservationDBCollection); ////mongoStorage.Clear(); ////mongoStorage.Remove(newItem); //Console.WriteLine(analizer.GetMinEnergy(new Coordinates(12, 12))); //var countItems = mongoStorage.Count; //------------------------------------------------------- //--------------------------------------API Plugin Check //var httpClient = new HttpClientService(); //var apiStorage = new APIStorage<IEnergyObservation>(httpClient); //var analizer = new APIAnalizer(httpClient); //var newItem = new FlashObservation(5989, 11, 23.3, new Coordinates(5976, 12, 12), DateTime.Now); ////apiStorage.Remove(newItem); //IEnergyObservation[] array = new IEnergyObservation[45]; //array[0] = newItem; //apiStorage.CopyTo(array, 1); //var result = analizer.GetAverageEnergy(DateTime.Now.AddDays(-2), DateTime.Now); //var result = analizer.GetAverageEnergy(new Coordinates(5979, 45, 19), new Coordinates(5980, 14, 14)); //var result2 = analizer.GetDistributionByEnergyValue(); //var result3 = analizer.GetDistributionByObservationTime(); //var result4 = analizer.GetDistributionByCoordinates(); //var result5 = analizer.GetMinEnergyPosition(); //------------------------------------------------------ LoadPlugin(); ShowMainMenu(); var key = Console.ReadKey(); while (key.Key != ConsoleKey.D0) { if (key.Key == ConsoleKey.D1) { Console.Clear(); ShowProcessorMenu(); do { var processorKey = Console.ReadKey(); if (processorKey.Key == ConsoleKey.D0) { break; } switch (processorKey.Key) //Processors not from plugins { case ConsoleKey.D1: ConsoleProcessingMenu(); break; case ConsoleKey.D2: SaveToFileProcessingMenu(); break; } if (char.IsNumber(processorKey.KeyChar)) //Processors from plugins { Console.Clear(); StartFinishMenu(); var consoleProcessingKey = Console.ReadKey(); int processorIndexInMenu = int.Parse(processorKey.KeyChar.ToString()); var plaginProcessingFactory = _app.ProcessingFactories.ElementAt(processorIndexInMenu + 1 - startPluginProcessorsIndexInMenu); var plaginSourceFactory = _app.SourceFactories.Where(sourceFactory => sourceFactory.GetType().ToString().StartsWith(selectedPluginDllName)).First(); _testRegistration = _app.CreateAndRegisterSource(plaginSourceFactory); attachedProcessingGroup = _testRegistration.AttachProcessingGroup(plaginProcessingFactory); _testRegistration.Start().Wait(); ShowAnalizerResult(attachedProcessingGroup.Analizer); } } while (true); } } }
private static void ProcessFactoriesInApp() { Console.WriteLine("Choose source factory to work with."); int i = 0; foreach (var appSourceFactory in App.SourceFactories) { ++i; Console.WriteLine($"{i}: {appSourceFactory.GetType()}"); } var userChoiceIsValid = false; ISourceFactory <FlashObservation> sourceFactory = null; if (App.SourceFactories.Count == 0) { sourceFactory = new RandomEnergySourceFactory(new Logger()); Console.WriteLine($"The source factory is not defined in plugin, so it will be {nameof(RandomEnergySource)}"); } else { while (!userChoiceIsValid) { if (TryReadUserInput(0, App.SourceFactories.Count, out int userChoice)) { userChoiceIsValid = true; sourceFactory = App.SourceFactories.ElementAt(userChoice - 1); } } } Console.WriteLine("Choose processing factory to work with."); i = 0; foreach (var appProcessingFactory in App.ProcessingFactories) { ++i; Console.WriteLine($"{i}: {appProcessingFactory.GetType()}"); } IProcessingFactory <FlashObservation> processingFactory = null; userChoiceIsValid = false; while (!userChoiceIsValid !) { if (TryReadUserInput(0, App.ProcessingFactories.Count, out int userChoice)) { userChoiceIsValid = true; processingFactory = App.ProcessingFactories.ElementAt(userChoice - 1); } } Console.WriteLine($"Processing source factory {sourceFactory.GetType()}..."); ISourceRegistration <FlashObservation> sourceRegistration = App.CreateAndRegisterSource(sourceFactory); IProcessingGroup <FlashObservation> processingGroup = sourceRegistration.AttachProcessingGroup(processingFactory); SourceRegistrations.Add(sourceRegistration); Console.WriteLine("Click Ctrl+C to stop generating values"); sourceRegistration.Start().Wait(); ProcessAnalyzer(processingGroup.Analizer); }
public void SetProcessingGroup(IProcessingGroup processingGroup) { ProcessingGroup = processingGroup; }
internal void RemoveProcessingGroup(IProcessingGroup processingGroup) { _processingGroups.Remove(processingGroup); }
internal void RemoveProcessingGroup(IProcessingGroup <IEnergyObservation> processingGroup) { _processingGroups.Remove(processingGroup); }