public void ProcessingServer_PipelineOptions()
{
var factory = new EventBusFactory();
var server = new ProcessingServer(factory);
var config = new PipelineConfiguration
{
Id = "test",
InputHandler = new HandlerNode
{
Type = typeof(LogInputHandler)
},
OutputHandlers = new List <HandlerNode>
{
new HandlerNode
{
Type = typeof(ConsoleOutputHandler)
}
},
Options = new PipelineOptions
{
MinProcessors = 1,
MaxItemsInQueue = 100,
MaxProcessors = 1
}
};
server.SetupPipeline("test", config);
var bus = factory.GetEventBus("test");
Assert.AreSame(bus.PipelineFactory.Options, config.Options);
}
public void ProcessingServer_RegisterEventBus_UnequalPipelineId()
{
var bus = new EventBus(() => null, "one");
var server = new ProcessingServer();
Assert.Throws <Exception>(() => server.Register("two", bus));
}
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 ProcessingServer_Publish_NoPipeline()
{
var factory = new Mock <IEventBusFactory>();
var server = new ProcessingServer(factory.Object);
Assert.DoesNotThrow(() => server.Publish(new Event("pipeline", new EventData())));
}
public void ProcessingServer_Dispose_Uninitialized()
{
var factory = new Mock <IEventBusFactory>();
var server = new ProcessingServer(factory.Object);
Assert.DoesNotThrow(() => server.Dispose());
}
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 async Task <IActionResult> TestDisposed()
{
//var temp = ServiceLocator.Instance.GetService<IProcessingServer>();
//temp.Dispose();
ProcessingServer.Dispose();
return(Success());
}
public Service1()
{
InitializeComponent();
server = new ProcessingServer();
server.Login();
dataServer = new LocalStorageServer();
}
public void ProcessingServer_Dispose_RegisterFactory()
{
var factory = new Mock <IEventBusFactory>();
var server = new ProcessingServer(factory.Object);
server.Register("pipeline", () => (EventPipeline)null);
Assert.DoesNotThrow(() => server.Dispose());
}
private static void StartServers()
{
deviceServer = new ProcessingServer();
deviceServer.Login();
deviceServer.Start();
dataServer = new LocalStorageServer();
dataServer.Start();
}
public void InitializServerInHandler()
{
var handler = new InitialieableHandler();
var server = new ProcessingServer();
server.Register(Guid.NewGuid().ToString(), handler);
Assert.AreSame(server, handler.Server);
}
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 Setup_Register_Factory_Register_InputHandler()
{
var pipelineId = Guid.NewGuid().ToString();
var handler = new SetupInputHandler();
var server = new ProcessingServer();
server.Register(pipelineId, handler);
Assert.AreSame(handler, server.InputHandlers.Single(h => h.PipelineId == pipelineId));
}
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 ProcessingServer_Dispose_RegisterEventBus()
{
var factory = new Mock <IEventBusFactory>();
var server = new ProcessingServer(factory.Object);
var bus = new Mock <IEventBus>();
bus.Setup(exp => exp.PipelineId).Returns("pipeline");
server.Register("pipeline", bus.Object);
Assert.DoesNotThrow(() => server.Dispose());
}
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 ProcessingServer_Publish()
{
var bus = new Mock <IEventBus>();
bus.Setup(exp => exp.PipelineId).Returns("pipeline");
var factory = new Mock <IEventBusFactory>();
factory.Setup(exp => exp.GetEventBus(It.IsAny <string>())).Returns(() => bus.Object);
var server = new ProcessingServer(factory.Object);
server.Publish(new Event("pipeline", new EventData()));
bus.Verify(exp => exp.Publish(It.IsAny <Event>()), Times.Once);
}
public void PipelineBuilder_Resolver_Perfomance()
{
var server = new ProcessingServer();
var builder = new PipelineBuilder();
builder.BuildPipeline(server, new PipelineConfiguration
{
Id = "1",
InputHandler = new HandlerNode(typeof(PlainInputHandler)),
OutputHandlers = new List <HandlerNode>
{
new HandlerNode(typeof(PlainOutputHandler))
}
});
builder.BuildPipeline(server, new PipelineConfiguration
{
Id = "2",
InputHandler = new HandlerNode(typeof(CustomInputHandler)),
OutputHandlers = new List <HandlerNode>
{
new HandlerNode(typeof(PlainOutputHandler))
}
});
//server.EventBusFactory.GetEventBus("1").Publish(new Event("1", new EventData()));
//server.EventBusFactory.GetEventBus("2").Publish(new Event("2", new EventData()));
var runner = new BenchmarkRunner();
runner.SetIterations(10);
runner.AddSession("Simple resolver",
ProfilerSession.StartSession()
.Task(() => server.Publish(new Event("1", new EventData())))
.SetThreads(5)
);
runner.AddSession("Complex resolver",
ProfilerSession.StartSession()
.Task(() => server.Publish(new Event("2", new EventData())))
.SetThreads(5)
);
var result = runner.RunSessions();
result.Trace();
}
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 ProcessingServer_Heartbeat_NoRegistration()
{
var storage = new Mock <IStorage>();
GlobalConfiguration.Setup(s => s.Register <IStorage>(storage.Object));
var factory = new EventBusFactory();
var server = new ProcessingServer(factory);
// give the hearbeat some time to execute
Task.Delay(500).Wait();
storage.Verify(exp => exp.Set <ServerModel>(It.IsAny <StorageKey>(), It.IsAny <ServerModel>()), Times.Never);
// cleanup
GlobalConfiguration.Setup(s => { });
}
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 GlobalConfiguration_UseProcessingServer_BuildPipeline_OutputHandlers()
{
var server = new ProcessingServer();
GlobalConfiguration.Setup(c => c.UseProcessingServer(p =>
{
var config = new PipelineConfiguration
{
Id = "pipeline1",
OutputHandlers = new List <HandlerNode>
{
new HandlerNode(typeof(ConsoleOutputHandler))
},
InputHandler = new HandlerNode(typeof(CustomInputHandler))
};
p.BuildPipeline(server, config);
}));
var handlers = GetOutputHandlers(server, "pipeline1");
Assert.IsInstanceOf <ConsoleOutputHandler>(handlers.Single());
}
public void GlobalConfiguration_AddService_ByType_InSetup()
{
GlobalConfiguration.Setup(s => { });
var server = new ProcessingServer();
GlobalConfiguration.Setup(c => c.UseProcessingServer(p =>
{
var config = new PipelineConfiguration
{
Id = "dependency_handler",
OutputHandlers = new List <HandlerNode>
{
new HandlerNode(typeof(DependencyHandler))
},
InputHandler = new HandlerNode("CustomInput")
};
p.BuildPipeline(server, config);
}).AddService <IDependency, Dependency>()
);
Assert.IsNotNull(((DependencyHandler)GetOutputHandlers(server, "dependency_handler").Single()).Instance);
}
public void GlobalConfiguration_UseProcessingServer_BuildPipeline_Filters()
{
var server = new ProcessingServer();
GlobalConfiguration.Setup(c => c.UseProcessingServer(p =>
{
var config = new PipelineConfiguration
{
Id = "pipeline1",
OutputHandlers = new List <HandlerNode>
{
new HandlerNode(typeof(ConsoleOutputHandler))
{
Filters = new List <string>
{
"Level -> lvl",
"Message",
"Id <- ${lvl}_error_${Message}"
}
}
},
InputHandler = new HandlerNode(typeof(CustomInputHandler))
};
p.BuildPipeline(server, config);
}));
var handler = GetOutputHandlers(server, "pipeline1").Single();
Assert.IsAssignableFrom <DataFilterDecorator>(handler);
var converter = ((DataFilterDecorator)handler).Converter;
Assert.That(converter.Filters.Any(f => f.Key == "Level" && f.FilterType == Gaucho.Filters.FilterType.Property));
Assert.That(converter.Filters.Any(f => f.Key == "Message" && f.FilterType == Gaucho.Filters.FilterType.Property));
Assert.That(converter.Filters.Any(f => f.Key == "Id" && f.FilterType == Gaucho.Filters.FilterType.Formatter));
}
public void ProcessingServer_UpdatePipeline()
{
var factory = new EventBusFactory();
var server = new ProcessingServer(factory);
var config = new PipelineConfiguration
{
Id = "test",
InputHandler = new HandlerNode
{
Type = typeof(LogInputHandler)
},
OutputHandlers = new List <HandlerNode>
{
new HandlerNode
{
Type = typeof(ConsoleOutputHandler)
}
}
};
server.SetupPipeline("test", config);
var first = factory.GetEventBus("test");
var second = factory.GetEventBus("test");
Assert.AreSame(first, second);
// update
server.SetupPipeline("test", config);
var third = factory.GetEventBus("test");
Assert.AreNotSame(first, third);
}
private IList <WorkQueue> InternalSelect(int startRowIndex, int maximumRows, out int resultCount)
{
resultCount = 0;
if (maximumRows == 0)
{
return(new List <WorkQueue>());
}
if (SearchKeys != null)
{
IList <WorkQueue> workQueueList = new List <WorkQueue>();
foreach (ServerEntityKey key in SearchKeys)
{
workQueueList.Add(WorkQueue.Load(key));
}
resultCount = workQueueList.Count;
return(workQueueList);
}
WebWorkQueueQueryParameters parameters = new WebWorkQueueQueryParameters
{
StartIndex = startRowIndex,
MaxRowCount = maximumRows
};
if (Partition != null)
{
parameters.ServerPartitionKey = Partition.Key;
}
if (!string.IsNullOrEmpty(PatientsName))
{
string key = PatientsName.Replace("*", "%");
key = key.Replace("?", "_");
parameters.PatientsName = key;
}
if (!string.IsNullOrEmpty(PatientId))
{
string key = PatientId.Replace("*", "%");
key = key.Replace("?", "_");
parameters.PatientID = key;
}
if (!string.IsNullOrEmpty(ProcessingServer))
{
string key = ProcessingServer.Replace("*", "%");
key = key.Replace("?", "_");
parameters.ProcessorID = key;
}
if (String.IsNullOrEmpty(ScheduledDate))
{
parameters.ScheduledTime = null;
}
else
{
parameters.ScheduledTime = DateTime.ParseExact(ScheduledDate, DateFormats, null);
}
if (TypeEnums != null && TypeEnums.Length > 0)
{
string types = "(";
if (TypeEnums.Length == 1)
{
types += TypeEnums[0].Enum;
}
else
{
string separator = "";
foreach (WorkQueueTypeEnum typeEnum in TypeEnums)
{
types += separator + typeEnum.Enum;
separator = ",";
}
}
parameters.Type = types + ")";
}
if (StatusEnums != null && StatusEnums.Length > 0)
{
string statuses = "(";
if (StatusEnums.Length == 1)
{
statuses += StatusEnums[0].Enum;
}
else
{
string separator = "";
foreach (WorkQueueStatusEnum statusEnum in StatusEnums)
{
statuses += separator + statusEnum.Enum;
separator = ",";
}
}
parameters.Status = statuses + ")";
}
if (PriorityEnum != null)
{
parameters.Priority = PriorityEnum;
}
List <string> groupOIDs = new List <string>();
CustomPrincipal user = Thread.CurrentPrincipal as CustomPrincipal;
if (user != null)
{
if (!user.IsInRole(ClearCanvas.Enterprise.Common.AuthorityTokens.DataAccess.AllStudies))
{
foreach (var oid in user.Credentials.DataAccessAuthorityGroups)
{
groupOIDs.Add(oid.ToString());
}
parameters.CheckDataAccess = true;
parameters.UserAuthorityGroupGUIDs = StringUtilities.Combine(groupOIDs, ",");
}
}
IList <WorkQueue> list = _searchController.FindWorkQueue(parameters);
resultCount = parameters.ResultCount;
return(list);
}