public void EventDataInputHandler_EventDataFactoryExtension()
{
var pipelineId = Guid.NewGuid().ToString();
var logHandler = new LogQueueHandler();
ProcessingServer.Server.SetupPipeline(pipelineId, s =>
{
s.Register(() =>
{
var pipeline = new EventPipeline();
pipeline.AddHandler(new ConsoleOutputHandler());
pipeline.AddHandler(logHandler);
return(pipeline);
});
s.Register(new EventDataInputHandler());
});
var portalId = "portal";
var message = new LogMessage {
Message = "StaticServer_NewPipelinePerEvent2"
};
var client = new EventDispatcher();
client.Process(pipelineId, f => f.BuildFrom(message)
.Add(() => portalId));
ProcessingServer.Server.WaitAll(pipelineId);
Assert.AreEqual(logHandler.Log.First(), "[Title -> ] [Message -> StaticServer_NewPipelinePerEvent2] [Level -> ] [portalId -> portal] ");
}
public void PluginManagerTests_BuildConfig()
{
var ctx = new ActivationContext();
ctx.Register <IEventDataConverter, EventDataConverter>();
var inputPlugin = _pluginMgr.GetPlugin(typeof(IInputHandler), "CustomInput");
var input = ctx.Resolve <IInputHandler>(inputPlugin.Type);
var outputPlugin = _pluginMgr.GetPlugin(typeof(IOutputHandler), "ConsoleOutput");
var output = ctx.Resolve <IOutputHandler>(outputPlugin.Type);
var pipelineId = Guid.NewGuid().ToString();
var loghandler = new LogQueueHandler();
var cnt = 0;
var server = new ProcessingServer();
server.SetupPipeline(pipelineId, s =>
{
s.Register(() =>
{
var pipeline = new EventPipeline();
pipeline.AddHandler(output);
pipeline.AddHandler(loghandler);
cnt = cnt + 1;
return(pipeline);
});
s.Register(input);
});
var client = new EventDispatcher(server);
client.Process(pipelineId, new LogMessage {
Message = "Event1"
});
client.Process(pipelineId, new LogMessage {
Message = "Event2"
});
server.WaitAll(pipelineId);
//Assert.That(cnt == 1, () => $"Count is {cnt} but is expected to be 1");
Assert.That(loghandler.Log.Count() == 2, () => $"Logcount is {loghandler.Log.Count()} but is expected to be 2");
}
public void StaticServer_SetupPipeline_SimpleServer()
{
var pipelineId = new Guid("42C75D31-8679-49B4-B0EE-2B90D4C6B893").ToString();
var server = new ProcessingServer();
server.SetupPipeline(pipelineId, s =>
{
s.Register(() =>
{
var pipeline = new EventPipeline();
pipeline.AddHandler(new ConsoleOutputHandler());
return(pipeline);
});
s.Register(new LogInputHandler());
});
var client = new EventDispatcher(server);
client.Process(pipelineId, new LogMessage {
Message = "SetupPipeline_SimpleServer"
});
}
public void InstanceServer_FactorySetEventBus()
{
var pipelineId = Guid.NewGuid().ToString();
var factory = new EventBusFactory();
factory.Register(pipelineId, () =>
{
var pipeline = new EventPipeline();
pipeline.AddHandler(new ConsoleOutputHandler());
return(pipeline);
});
factory.Register(pipelineId, new EventBus(() => null, pipelineId));
var server = new ProcessingServer(factory);
server.Register(pipelineId, new LogInputHandler());
var client = new EventDispatcher(server);
client.Process(pipelineId, new LogMessage {
Message = "InstanceServer"
});
}
public void EventBusFactory_UpdatePipeline()
{
var factory = new EventBusFactory();
factory.Register("test", () =>
{
var pipeline = new EventPipeline();
pipeline.AddHandler(new ConsoleOutputHandler());
return(pipeline);
});
var first = factory.GetEventBus("test");
var second = factory.GetEventBus("test");
Assert.AreSame(first, second);
factory.Register("test", () =>
{
var pipeline = new EventPipeline();
pipeline.AddHandler(new ConsoleOutputHandler());
return(pipeline);
});
var third = factory.GetEventBus("test");
Assert.AreNotSame(first, third);
}
public void Server_CustomEventBus()
{
var pipelineId = Guid.NewGuid().ToString();
var cnt = 0;
ProcessingServer.Server.SetupPipeline(pipelineId, s =>
{
s.Register(() =>
{
var pipeline = new EventPipeline();
pipeline.AddHandler(new ConsoleOutputHandler());
cnt = cnt + 1;
return(pipeline);
});
s.Register(new CustomEventBus(pipelineId));
s.Register(new CustomInputHandler());
});
var client = new EventDispatcher();
client.Process(pipelineId, new LogMessage {
Message = "StaticServer_NewPipelinePerEvent1"
});
client.Process(pipelineId, new LogMessage {
Message = "StaticServer_NewPipelinePerEvent2"
});
Assert.That(cnt == 1);
}
/// <summary>
/// Build the pipeline based on the configuration
/// </summary>
/// <param name="server"></param>
/// <param name="config"></param>
public void BuildPipeline(IProcessingServer server, PipelineConfiguration config)
{
_logger.Write($"Setup Pipeline:{config}", Category.Log, LogLevel.Debug, "PipelineBuilder");
server.SetupPipeline(config.Id, s =>
{
var rootCtx = GlobalConfiguration.Configuration.Resolve <IActivationContext>();
s.Register(() =>
{
var pipeline = new EventPipeline();
foreach (var node in config.OutputHandlers)
{
var ctx = rootCtx.ChildContext();
var outputHandler = BuildHandler <IOutputHandler>(ctx, node);
var converter = node.BuildDataFilter();
if (converter.Filters.Any(f => f.FilterType == Filters.FilterType.Property))
{
outputHandler = new DataFilterDecorator(converter, outputHandler);
}
pipeline.AddHandler(outputHandler);
}
return(pipeline);
}, config.Options);
var inputHandler = BuildHandler <IInputHandler>(rootCtx.ChildContext(), config.InputHandler);
s.Register(inputHandler);
});
}
public void StaticServer_WaitAll()
{
var pipelineId = Guid.NewGuid().ToString();
var logHandler = new LogQueueHandler();
ProcessingServer.Server.SetupPipeline(pipelineId, s =>
{
s.Register(() =>
{
var pipeline = new EventPipeline();
pipeline.AddHandler(new ConsoleOutputHandler());
pipeline.AddHandler(logHandler);
return(pipeline);
});
s.Register(new CustomInputHandler());
});
var client = new EventDispatcher();
client.Process(pipelineId, new LogMessage {
Message = "StaticServer_NewPipelinePerEvent1"
});
client.Process(pipelineId, new LogMessage {
Message = "StaticServer_NewPipelinePerEvent2"
});
ProcessingServer.Server.WaitAll(pipelineId);
Assert.AreEqual(2, logHandler.Log.Count());
client.Process(pipelineId, new LogMessage {
Message = "StaticServer_NewPipelinePerEvent3"
});
client.Process(pipelineId, new LogMessage {
Message = "StaticServer_NewPipelinePerEvent4"
});
ProcessingServer.Server.WaitAll(pipelineId);
Assert.AreEqual(4, logHandler.Log.Count());
}
public void EventPipeline_AddHandler()
{
var handler = new Mock <IOutputHandler>();
var pipeline = new EventPipeline();
pipeline.AddHandler(handler.Object);
Assert.That(pipeline.Handlers.Any());
}
public void LoadTest_HeavyWork()
{
// start with the warmup...
var cnt = 0;
var proc = 0;
var pipelineId = Guid.NewGuid().ToString();
var server = new ProcessingServer();
server.Register(pipelineId, () =>
{
var pipeline = new EventPipeline();
pipeline.AddHandler(new LoadTestOuptuHandler(e =>
{
proc += 1;
// do some heavy work
Thread.Sleep(100);
}));
return(pipeline);
});
server.Register(pipelineId, new InputHandler <InputItem>());
var client = new EventDispatcher(server);
var profiler = ProfilerSession.StartSession()
.SetIterations(1000)
.SetThreads(5)
.Task(() =>
{
lock (pipelineId)
{
cnt += 1;
}
client.Process(pipelineId, new InputItem
{
Value = "StaticServer",
Name = "test",
Number = cnt
});
}).RunSession();
server.WaitAll(pipelineId);
profiler.Trace();
var monitor = new StatisticsApi(pipelineId);
var processed = monitor.GetMetricValue <long>(MetricType.ProcessedEvents);
Assert.AreEqual(processed, cnt, "Processed events are not equal to sent events {0} to {1}", processed, cnt);
}
public void EventPipeline_Run()
{
var handler = new Mock <IOutputHandler>();
var pipeline = new EventPipeline();
pipeline.AddHandler(handler.Object);
pipeline.Run(new Event("id", "value"));
handler.Verify(exp => exp.Handle(It.Is <Event>(e => e.PipelineId == "id")), Times.Once);
}
public void PerformanceMeasures_FullProcess()
{
GlobalConfiguration.Setup(s => s.UseOptions(new Options
{
MaxItemsInQueue = 10,
MaxProcessors = 30
}));
// start with the warmup...
var cnt = 0;
var pipelineId = Guid.NewGuid().ToString();
var server = new ProcessingServer();
server.Register(pipelineId, () =>
{
var pipeline = new EventPipeline();
pipeline.AddHandler(new LoadTestOuptuHandler(e => { }));
return(pipeline);
});
server.Register(pipelineId, new InputHandler <InputItem>());
var client = new EventDispatcher(server);
var sw = new Stopwatch();
sw.Start();
for (var i = 0; i < 10; i++)
{
client.Process(pipelineId, new InputItem
{
Value = "StaticServer",
Name = "test",
Number = i
});
}
//sw.Stop();
var time1 = sw.Elapsed;
server.WaitAll(pipelineId);
sw.Stop();
var time2 = sw.Elapsed;
Assert.Less(time1, TimeSpan.FromMilliseconds(30));
Assert.Less(time2, TimeSpan.FromMilliseconds(600));
}
public void EventBus()
{
var pipelineId = Guid.NewGuid().ToString();
var eventBus = new EventBus(() =>
{
var pipeline = new EventPipeline();
pipeline.AddHandler(new ConsoleOutputHandler());
return(pipeline);
}, pipelineId);
var @event = new Event(pipelineId, "Testdata");
eventBus.Publish(@event);
}
public void PerformanceMeasures_WorkersCount(string id, int maxitems, int maxprocessors, int workers, int ticks)
{
var server = new ProcessingServer();
server.Register(id, () =>
{
var pipeline = new EventPipeline();
pipeline.AddHandler(new LoadTestOuptuHandler(e => { }));
return(pipeline);
});
server.Register(id, new InputHandler <InputItem>());
var client = new EventDispatcher(server);
GlobalConfiguration.Setup(s => s.UseOptions(new Options
{
MinProcessors = workers,
MaxItemsInQueue = maxitems,
MaxProcessors = maxprocessors
}));
var result = ProfilerSession.StartSession()
.Setup(() =>
{
})
.Task(() =>
{
for (var i = 0; i < 1000; i++)
{
client.Process(id, new InputItem
{
Value = "StaticServer",
Name = "test",
Number = i
});
}
server.WaitAll(id);
})
.RunSession();
result.Trace();
Assert.Less(result.AverageMilliseconds, ticks);
}
public void Setup_Register_Factory_Register_OutputHandler()
{
var pipelineId = Guid.NewGuid().ToString();
var handler = new SetupOutputHandler();
var server = new ProcessingServer();
server.Register(pipelineId, () =>
{
var pipeline = new EventPipeline();
pipeline.AddHandler(handler);
return pipeline;
});
Assert.AreSame(handler, GetOutputHandlers(server, pipelineId).Single());
}
public void Setup_Register_Factory_SetupPipeline_FilterDecorator()
{
var pipelineId = Guid.NewGuid().ToString();
var handler = new SetupOutputHandler();
var server = new ProcessingServer();
server.SetupPipeline(pipelineId, c =>
{
c.Register(() =>
{
var pipeline = new EventPipeline();
pipeline.AddHandler(handler, new[] { "Level -> dst_lvl", "Message" });
return pipeline;
});
});
Assert.IsAssignableFrom<DataFilterDecorator>(GetOutputHandlers(server, pipelineId).Single());
}
public void Setup_Register_Factory_SetupPipeline_AddFilters()
{
var pipelineId = Guid.NewGuid().ToString();
var handler = new SetupOutputHandler();
var server = new ProcessingServer();
server.SetupPipeline(pipelineId, c =>
{
c.Register(() =>
{
var pipeline = new EventPipeline();
pipeline.AddHandler(handler, new[] {"Level -> dst_lvl", "Message"});
return pipeline;
});
});
Assert.That(((DataFilterDecorator)GetOutputHandlers(server, pipelineId).Single()).Converter.Filters.Count() == 2);
}
public void StaticServer()
{
var pipelineId = Guid.NewGuid().ToString();
ProcessingServer.Server.Register(pipelineId, () =>
{
var pipeline = new EventPipeline();
pipeline.AddHandler(new ConsoleOutputHandler());
return(pipeline);
});
ProcessingServer.Server.Register(pipelineId, new LogInputHandler());
var client = new EventDispatcher();
client.Process(pipelineId, new LogMessage {
Message = "StaticServer"
});
}
public void StaticServer_SamePipelineAllEvents()
{
var pipelineId = new Guid("FB4336C9-23E7-42B0-B25F-0A92D06508A7").ToString();
var cnt = 0;
ProcessingServer.Server.SetupPipeline(pipelineId, s =>
{
s.Register(() =>
{
var pipeline = new EventPipeline();
pipeline.AddHandler(new ConsoleOutputHandler());
cnt = cnt + 1;
return(pipeline);
});
s.Register(new CustomInputHandler());
});
var client = new EventDispatcher();
client.Process(pipelineId, new LogMessage {
Message = "StaticServer_NewPipelinePerEvent1"
});
client.Process(pipelineId, new LogMessage {
Message = "StaticServer_NewPipelinePerEvent2"
});
Assert.That(cnt >= 0);
ProcessingServer.Server.WaitAll(pipelineId);
Assert.That(cnt >= 1);
}
