public MainWindow()
{
InitializeComponent();
// Use this as construction root for simplicity.
// In real world app there should be good framework for this and this should be done
// outside of main window for reason that then mainwindow is interchangeable too if required.
var dataSource = new InMemoryRepository();
// Dummy data for testing...
dataSource.Add(new CarImage {Color="Black", RegisterPlate = "ABC-123", Speed = 140});
var messenger = new MessageAggregator();
var reportViewModel = new ReportViewModel(dataSource, messenger);
var colorFilter = new ColorFilterViewModel();
var filterViewModel = new FiltersViewModel(new List<IFilter> {colorFilter}, messenger);
// Just for testing, apply dummy filter so that data is shown.
messenger.Publish(new Messages.FiltersAppliedMessage());
DataContext = new
{
Report = reportViewModel,
Filters = filterViewModel
};
}
protected override void Configure()
{
_container = new CompositionContainer(new AggregateCatalog(AssemblySource
.Instance
.Select(x => new AssemblyCatalog(x))
.OfType<ComposablePartCatalog>()
)
);
var batch = new CompositionBatch();
_portName = SerialPort.GetPortNames()[0];
_ecr = new Dp25(_portName);
var messenger = new MessageAggregator();
messenger.GetStream<SelectedPortChangedEvent>()
.Subscribe(e => _ecr.ChangePort(e.PortName));
batch.AddExportedValue<IWindowManager>(new WindowManager());
batch.AddExportedValue<IMessageAggregator>(messenger);
batch.AddExportedValue<Dp25>(_ecr);
batch.AddExportedValue(_container);
_container.Compose(batch);
}
public void RegisterWithSingleConsumer_WorksTogether()
{
string message = "Not set";
var messenger = new MessageAggregator();
messenger.Subscribe<TestMessage>(m => message = m.ExampleMessage);
messenger.Publish(new TestMessage {ExampleMessage = "Message example."});
message.Should().Be("Message example.");
}
public ReportViewModel(IRepository dataSource, MessageAggregator messegenger)
{
Null.CheckArgument(() => dataSource);
Null.CheckArgument(() => messegenger);
_dataSource = dataSource;
CarImages = new ObservableCollection<CarImage>();
messegenger.Subscribe<FiltersAppliedMessage>(UpdateData);
}
public async Task A_valid_subscriber_is_assigned_as_a_handler_for_its_message_type()
{
var dispatcher = Substitute.For <IDispatcher>();
var handlerStub = Substitute.For <IHandleAsync <object> >();
var eventAggregator = new MessageAggregator();
Assert.False(eventAggregator.HandlerExistsFor(typeof(object)));
await eventAggregator.SubscribeAsync(handlerStub);
Assert.True(eventAggregator.HandlerExistsFor(typeof(object)));
}
public void AggregateSingleMessage()
{
bool executed = false;
MessageAggregator <TestMessage> aggregator =
new MessageAggregator <TestMessage>(set =>
{
executed = true;
});
aggregator.Aggregate(new TestMessage());
executed.Should().BeTrue("A message in the default domain should be executed immediately.");
}
public void Init()
{
_repository = TestDataTemplates.CreateRepository();
_messenger = new MessageAggregator();
_reportsViewModel = new ReportViewModel(_repository, _messenger);
_colorFilter = new ColorFilterViewModel();
_registerFilter = new RegisterPlateFilterViewModel();
var filters = new List<IFilter> {_colorFilter, _registerFilter};
_filtersViewModel = new FiltersViewModel(filters, _messenger);
}
public async Task A_valid_subscriber_gets_removed_from_the_handler_list()
{
var dispatcher = Substitute.For <IDispatcher>();
var handlerStub = Substitute.For <IHandleAsync <object> >();
var eventAggregator = new MessageAggregator();
await eventAggregator.SubscribeAsync(handlerStub);
Assert.True(eventAggregator.HandlerExistsFor(typeof(object)));
await eventAggregator.UnsubscribeAsync(handlerStub);
Assert.False(eventAggregator.HandlerExistsFor(typeof(object)));
}
public void Publishes_to_handler()
{
var aggregator = new MessageAggregator();
var publisher = new MessagePublisher(aggregator);
var handled = 0;
aggregator.Subscribe <StringMessage>(se => { handled++; });
var sent = publisher.Publish(new StringMessage("Foo"));
Assert.True(sent);
Assert.Equal(1, handled);
}
public MainWindow(FileLogger logger)
{
Logger = logger;
InitializeComponent();
ShutDownButton.IsEnabled = false;
EventProcessor.OnUpdatedInfo += HandleEventProcessorInfo;
App.Engine.OnStateChanged += HandleEngineStateChange;
App.Engine.OnNewAnalyzerInfo += HandleAnalyzerInfo;
Task.Run(() =>
{
while (true)
{
MessageAggregator.Collection.Clear();
for (var i = 0; i < 50; ++i)
{
if (App.Engine.EngineMessages.TryDequeue(out var msg))
{
MessageAggregator.AddMessage(msg, msg.Message.GenerateMessageIdentifierFromString());
}
}
foreach (var messageTracker in MessageAggregator.Collection)
{
MesseageOutputQueue.Enqueue($"{messageTracker.Value.Message} | {messageTracker.Value.AmountCounter} times from {messageTracker.Value.FirstOccurrence} to {messageTracker.Value.LastOccurrence}");
}
for (int i = 1; i <= 14; ++i)
{
if (MesseageOutputQueue.TryDequeue(out string message))
{
//UpdateMessageBox($"{DateTime.UtcNow}\t{message}{Environment.NewLine}");
Logger.AddRow(message);
SnapShotGenerator.AddMessageToSnapShot(DateTime.UtcNow, message);
}
}
}
});
Task.Run(() =>
{
while (true)
{
UpdateSnapshotAnalyzerInfo();
Task.Delay(4000).Wait();
}
});
StartUpdateSelectedAnalyzerTask();
}
//private StatefulHttpClient _httpClient;
protected override void Configure()
{
_container = new CompositionContainer(new AggregateCatalog(AssemblySource.Instance.Select(x => new AssemblyCatalog(x))));
var batch = new CompositionBatch();
//var statefulHttpClient = new StatefulHttpClient(new HttpClient(), new CookieContainer());
var messageAggregator = new MessageAggregator();
_msg = messageAggregator;
//_httpClient = statefulHttpClient;
//batch.AddExportedValue<INavigator>(statefulHttpClient);
batch.AddExportedValue <IWindowManager>(new WindowManager());
batch.AddExportedValue <IMessageAggregator>(messageAggregator);
batch.AddExportedValue(_container);
_container.Compose(batch);
}
public void WithMultipleRegisteredTypes_OnlyReactCorrectlyTypedMessage()
{
string firstMessage = "Not set";
string secondMessage = "Not set";
string doNotTouchMessage = "Should not be changed.";
var messenger = new MessageAggregator();
messenger.Subscribe<TestMessage>(m => firstMessage = m.ExampleMessage);
messenger.Subscribe<TestMessage>(m => secondMessage = m.ExampleMessage);
messenger.Subscribe<NotUsedTestMessage>(m => doNotTouchMessage = "This should not happen.");
messenger.Publish(new TestMessage { ExampleMessage = "Message example." });
firstMessage.Should().Be("Message example.");
secondMessage.Should().Be("Message example.");
doNotTouchMessage.Should().Be("Should not be changed.");
}
public void DontExecuteMultipleMessagesIfOneIsMissing()
{
bool executed = false;
MessageAggregator <TestMessage> aggregator =
new MessageAggregator <TestMessage>(set =>
{
executed = true;
});
TestMessage[] messages = new[] { new TestMessage(), new TestMessage(), new TestMessage() };
MessageDomain.CreateNewDomainsFor(messages);
aggregator.Aggregate(messages[0]);
aggregator.Aggregate(messages[1]);
executed.Should().BeFalse("not all messages were added to the aggregator.");
}
public void Can_subscribe_with_manifold_hierarchical_consumer()
{
var aggregator = new MessageAggregator();
var publisher = new MessagePublisher(aggregator);
var handler = new ManifoldHierarchicalMessageHandler();
aggregator.Subscribe(handler);
var sent = publisher.Publish(new InheritedMessage());
Assert.True(sent);
Assert.Equal(1, handler.HandledInterface);
Assert.Equal(1, handler.HandledBase);
Assert.Equal(1, handler.HandledInherited);
}
public void Publishes_to_multiple_handlers()
{
var aggregator = new MessageAggregator();
var publisher = new MessagePublisher(aggregator);
var handler1 = 0;
var handler2 = 0;
aggregator.Subscribe <StringMessage>(e => { handler1++; });
aggregator.Subscribe <StringMessage>(e => { handler2++; });
var sent = publisher.Publish(new StringMessage("Foo"));
Assert.True(sent);
Assert.Equal(1, handler1);
Assert.Equal(1, handler2);
}
public void ExecuteMultipleMessagesInDefaultDomainSeperately()
{
int count = 0;
MessageAggregator <TestMessage> aggregator =
new MessageAggregator <TestMessage>(set =>
{
count++;
});
TestMessage[] messages = new[] { new TestMessage(), new TestMessage(), new TestMessage() };
foreach (TestMessage message in messages)
{
aggregator.Aggregate(message);
}
count.Should().Be(3, "all messages should execute seperately.");
}
public object GetData(ITabContext context)
{
var messages = context.GetMessages <AdoMessage>().ToList();
var aggregator = new MessageAggregator(messages);
var queryData = aggregator.Aggregate();
SqlStatistics sqlStatistics = SqlStatisticsCalculator.Caluculate(queryData);
return(new
{
queryCount = sqlStatistics.QueryCount,
connectionCount = sqlStatistics.ConnectionCount,
transactionCount = sqlStatistics.TransactionCount,
queryExecutionTime = sqlStatistics.QueryExecutionTime,
connectionOpenTime = sqlStatistics.ConnectionOpenTime
});
}
public async Task A_valid_message_is_published_to_all_handlers()
{
var dispatcher = new XamlDispatcher();
var eventAggregator = new MessageAggregator();
var handler1 = Substitute.For <IHandleAsync <object> >();
var handler2 = Substitute.For <IHandleAsync <object> >();
var handler3 = Substitute.For <IHandle <object> >();
handler1.HandleAsync(Arg.Any <object>()).Returns(async(c) =>
{
Console.WriteLine(
$"{DateTime.Now} - Starting handler 1...");
await Task.Delay(3000);
Console.WriteLine(
$"{DateTime.Now} - Finished handler 1...");
});
handler3.When(c => c.Handle(Arg.Any <object>()))
.Do((c) =>
{
Thread.Sleep(500);
Console.WriteLine($"{DateTime.Now} - executing handler 3...");
});
handler2.HandleAsync(Arg.Any <object>()).Returns(async(c) =>
{
Console.WriteLine(
$"{DateTime.Now} - Starting handler 2...");
await Task.Delay(3000);
Console.WriteLine(
$"{DateTime.Now} - Finished handler 2...");
});
await eventAggregator.SubscribeAsync(handler1);
await eventAggregator.SubscribeAsync(handler2);
await eventAggregator.SubscribeAsync(handler3);
var message = new object();
await eventAggregator.PublishAsync(message);
#pragma warning disable 4014
handler1.Received().HandleAsync(message);
handler2.Received().HandleAsync(message);
handler3.Received().Handle(message);
#pragma warning restore 4014
}
public void AggregateMultipleMessagesInDifferentDomains()
{
bool executed = false;
MessageAggregator <TestMessage> aggregator =
new MessageAggregator <TestMessage>(set =>
{
executed = true;
});
TestMessage[] messages = new[] { new TestMessage(), new TestMessage(), new TestMessage() };
MessageDomain.CreateNewDomainsFor(messages);
foreach (TestMessage message in messages)
{
aggregator.Aggregate(message);
}
executed.Should().BeTrue("all messages were added to the aggregator.");
}
public void DoNotTerminateMessageDomainWhenParameterIsFalse()
{
MessageAggregator <TestMessage> aggregator =
new MessageAggregator <TestMessage>(set =>
{
}, false);
TestMessage[] messages = new[] { new TestMessage(), new TestMessage(), new TestMessage() };
MessageDomain.CreateNewDomainsFor(messages);
foreach (TestMessage message in messages)
{
aggregator.Aggregate(message);
}
foreach (TestMessage message in messages)
{
message.MessageDomain.IsTerminated.Should().BeFalse("message domain should not have been terminated.");
}
}
public void TerminateMessageDomainAutomatically()
{
MessageAggregator <TestMessage> aggregator =
new MessageAggregator <TestMessage>(set =>
{
});
TestMessage[] messages = new[] { new TestMessage(), new TestMessage(), new TestMessage() };
MessageDomain.CreateNewDomainsFor(messages);
foreach (TestMessage message in messages)
{
aggregator.Aggregate(message);
}
foreach (TestMessage message in messages)
{
message.MessageDomain.IsTerminated.Should().BeTrue("message domain should have been terminated.");
}
}
public void Publishes_to_manifold_handler()
{
var aggregator = new MessageAggregator();
var publisher = new MessagePublisher(aggregator);
var handler = new ManifoldMessageHandler();
aggregator.Subscribe(handler);
var sent = publisher.Publish(new StringMessage("Foo"));
Assert.True(sent);
Assert.Equal(1, handler.HandledString);
Assert.Equal(0, handler.HandledInteger);
sent = publisher.Publish(new IntegerMessage(123));
Assert.True(sent);
Assert.Equal(1, handler.HandledString);
Assert.Equal(1, handler.HandledInteger);
}
/// <summary>
/// Constructor of LiNGS Client. Creates a new instance of <see cref="LiNGSClient"/>.
/// </summary>
/// <exception cref="ArgumentNullException">When any of the params is null.</exception>
/// <param name="properties">Properties of the client. These properties cannot be changed after the server is running.</param>
/// <param name="serverInfo">Information used to connect to the server.</param>
/// <param name="networkedClient">Game logic to receive callbacks and manage game objects.</param>
public LiNGSClient(ClientProperties properties, ServerInfo serverInfo, INetworkedClient networkedClient)
{
if (properties == null)
{
throw new ArgumentNullException("The client properties cannot be null.");
}
if (serverInfo == null)
{
throw new ArgumentNullException("The server information cannot be null.");
}
if (networkedClient == null)
{
throw new ArgumentNullException("The networkedClient cannot be null.");
}
this.UpdateManager = new UpdateManager();
this.ClientProperties = new ClientProperties(properties);
this.ServerInfo = new ServerInfo(serverInfo);
NetworkManager = new NetworkManager(this, ServerInfo.IP, ServerInfo.Port);
Router = new Router(this);
MessageAggregator = new MessageAggregator(this);
Manager = new Manager(this);
Analyzer = new Analyzer(this);
ClientLogicProcessor = new ClientLogicProcessor(this);
Simulator = new Simulator(this);
Synchronizer = new Synchronizer(this);
ClientStatus = new ClientStatus(this);
NetworkedClientInstance = networkedClient;
this.UpdateManager.AddUpdatable(MessageAggregator);
this.UpdateManager.AddUpdatable(Manager);
this.UpdateManager.AddUpdatable(Analyzer);
this.UpdateManager.AddUpdatable(ClientLogicProcessor);
this.UpdateManager.AddUpdatable(Simulator);
this.UpdateManager.AddUpdatable(Synchronizer);
}
protected override void Configure()
{
_container = new CompositionContainer(new AggregateCatalog(AssemblySource
.Instance
.Select(x => new AssemblyCatalog(x))
.OfType <ComposablePartCatalog>()
)
);
var batch = new CompositionBatch();
var portNames = SerialPort.GetPortNames();
_portName = portNames.Length > 0 ? portNames[0] : string.Empty;
try
{
_ecr = new Dp25(_portName);
}
catch (Exception ex)
{ }
var messenger = new MessageAggregator();
messenger.GetStream <SelectedPortChangedEvent>()
.Subscribe(e =>
{
MessageBox.Show(
"ChangePort method removed from API, try to set the portname manually in code AppBootstrapper.cs:line 43");
});
batch.AddExportedValue <IWindowManager>(new WindowManager());
batch.AddExportedValue <IMessageAggregator>(messenger);
batch.AddExportedValue <Dp25>(_ecr);
batch.AddExportedValue(_container);
_container.Compose(batch);
}
public override object GetData(ITabContext context)
{
var sanitizer = new CommandSanitizer();
var messages = context.GetMessages <AdoMessage>().ToList();
var aggregator = new MessageAggregator(messages);
var queryMetadata = aggregator.Aggregate();
if (queryMetadata == null)
{
return(null);
}
var connections = new List <object[]> {
new object[] { "Commands per Connection", "Duration" }
};
foreach (var connection in queryMetadata.Connections.Values)
{
if (connection.Commands.Count == 0 && connection.Transactions.Count == 0)
{
continue;
}
var commands = new List <object[]> {
new object[] { "Transaction Start", "Ordinal", "Command", "Parameters", "Records", "Duration", "Offset", "Async", "Transaction End", "Errors" }
};
var commandCount = 1;
foreach (var command in connection.Commands.Values)
{
// Transaction Start
List <object[]> headTransaction = null;
if (command.HeadTransaction != null)
{
headTransaction = new List <object[]> {
new object[] { "\t▼ Transaction - Started", "Isolation Level - " + command.HeadTransaction.IsolationLevel }
};
if (!command.HeadTransaction.Committed.HasValue)
{
headTransaction.Add(new object[] { string.Empty, "Transaction was never completed", "error" });
}
}
// Transaction Finish
List <object[]> tailTransaction = null;
if (command.TailTransaction != null)
{
tailTransaction = new List <object[]> {
new object[] { "\t▲ Transaction - Finished", "Status - " + (command.TailTransaction.Committed.GetValueOrDefault() ? "Committed" : "Rollbacked") }
};
}
// Parameters
List <object[]> parameters = null;
if (command.Parameters.Count > 0)
{
parameters = new List <object[]> {
new object[] { "Name", "Value", "Type", "Size" }
};
foreach (var parameter in command.Parameters)
{
parameters.Add(new[] { parameter.Name, parameter.Value, parameter.Type, parameter.Size });
}
}
// Exception
List <object[]> errors = null;
if (command.Exception != null)
{
var exception = command.Exception.GetBaseException();
var exceptionName = command.Exception != exception ? command.Exception.Message + ": " + exception.Message : exception.Message;
errors = new List <object[]> {
new object[] { "Error", "Stack" }, new object[] { exceptionName, exception.StackTrace }
};
}
// Commands
var records = command.RecordsAffected == null || command.RecordsAffected < 0 ? command.TotalRecords : command.RecordsAffected;
var status = errors != null ? "error" : (command.IsDuplicate ? "warn" : string.Empty);
commands.Add(new object[] { headTransaction, string.Format("{0}{1}", command.HasTransaction ? "\t\t\t" : string.Empty, commandCount++), sanitizer.Process(command.Command, command.Parameters), parameters, records, command.Duration, command.Offset, command.IsAsync, tailTransaction, errors, status });
}
connections.Add(new[] { commands, connection.Duration.HasValue ? (object)connection.Duration.Value : null });
}
if (connections.Count > 1)
{
SqlStatistics sqlStatistics = SqlStatisticsCalculator.Caluculate(queryMetadata);
return(new Dictionary <string, object>
{
{ "SQL Statistics", new object[] { new { sqlStatistics.ConnectionCount, sqlStatistics.QueryCount, sqlStatistics.TransactionCount, sqlStatistics.QueryExecutionTime, sqlStatistics.ConnectionOpenTime } } },
{ "Queries", connections }
});
}
return(null);
}
private async void Start()
{
var aggregator = new MessageAggregator();
_relay = aggregator;
IConfigStore configStore = new AppDataConfigStore();
IPreviewImageStore previewStore = new AppDataPreviewImageStore();
_library = new Library(configStore, _previewBuilder, previewStore, _relay);
var factory = new ImportFolderFactory(_library);
// Main View
var progressModel = new ProgressModel();
var applicationModel = new ApplicationModel(_relay);
var searchViewModel = new SearchModel(_library, _relay);
var itemsViewModel = new ItemsModel(_library, _relay);
// Main Menu
var importFoldersViewModel = new ImportFoldersModel(configStore, factory, _relay);
var savedSearchesViewModel = new SavedSearchesModel(configStore, _relay);
var collectionsViewModel = new CollectionsModel(configStore, _relay);
// Detail Menu
var detailMenuModel = new DetailMenuModel(_library, _relay);
// Dialogs
var addSavedSearchViewModel = new AddSavedSearchModel(_relay);
var addImportFolderViewModel = new AddImportFolderModel(_relay);
var applicationSettingsModel = new ApplicationSettingsModel(configStore);
var userFeedbackModel = new UserFeedbackModel();
var exitingModel = new ExitingModel(_library, OnShutdownComplete);
var editScreenModel = new EditScreenModel(_library);
BindViewModels();
BindSettings();
// Wire up misc items
_disposables.Add(importFoldersViewModel);
_editScreen.MainView = _mainGroup;
// Also restores app settings for import etc.
await applicationSettingsModel.InitializeAsync();
await _library.InitializeAsync();
InitializeViewModelsAsync();
aggregator.Subscribe(
// Main View
progressModel,
searchViewModel,
itemsViewModel,
// Main Menu
importFoldersViewModel,
savedSearchesViewModel,
collectionsViewModel,
// DetailMenu
detailMenuModel,
// Dialogs
addSavedSearchViewModel,
addImportFolderViewModel,
applicationSettingsModel,
userFeedbackModel,
exitingModel,
editScreenModel);
void BindViewModels()
{
// Main View
_progressView.BindTo(progressModel);
_applicationView.BindTo(applicationModel);
_searchView.BindTo(searchViewModel);
_libraryView.BindTo(itemsViewModel);
// Main Menu
_importFoldersView.BindTo(importFoldersViewModel);
_savedSearchesView.BindTo(savedSearchesViewModel);
_collectionsView.BindTo(collectionsViewModel);
// Detail Menu
_detailMenu.BindTo(detailMenuModel);
// Dialogs
_addImportFolderDialog.BindTo(addImportFolderViewModel);
_addSavedSearchDialog.BindTo(addSavedSearchViewModel);
_applicationSettingsDialog.BindTo(applicationSettingsModel);
_userFeedbackDialog.BindTo(userFeedbackModel);
_exitingDialog.BindTo(exitingModel);
_editScreen.BindTo(editScreenModel);
}
void BindSettings()
{
var rt = applicationSettingsModel.RuntimeSettings;
rt.ImportParallelism.ValueChanged += factor => _library.Parallelism = factor;
rt.LogLevel.ValueChanged += logLevel => UnityLogger.LogLevel = logLevel;
rt.UiScalePercent.ValueChanged += factor =>
{
foreach (var canvas in FindObjectsOfType <Canvas>())
{
canvas.scaleFactor = applicationSettingsModel.UiScalePercent / 125f;
}
};
rt.ScrollSensitivity.ValueChanged += sensitivity =>
{
foreach (var area in FindObjectsOfType <ScrollRect>())
{
area.scrollSensitivity = sensitivity;
}
};
rt.PreviewResolution.ValueChanged += res => _previewBuilder.PreviewResolution.Value = Mathf.RoundToInt(Mathf.Pow(2f, res));
rt.PreviewJpegQuality.ValueChanged += quality => _previewBuilder.Quality = quality;
}
async void InitializeViewModelsAsync()
{
await savedSearchesViewModel.InitializeAsync();
await importFoldersViewModel.InitializeAsync();
await collectionsViewModel.InitializeAsync();
}
}
public FiltersViewModel(List<IFilter> filters, MessageAggregator messenger)
{
_filters = filters;
_messenger = messenger;
}
private static void Main(string[] args)
{
SetWindowSize(WindowWidth, WindowHeight);
Clear();
var storageConnection = ConfigurationManager.AppSettings["AzureStorageConnectionString"];
var eventhubConnS = ConfigurationManager.AppSettings["Microsoft.ServiceBus.ConnectionString.Listen"];
Eventhubpath = ConfigurationManager.AppSettings["EventHubPath"];
var alarmQueueConnS = ConfigurationManager.AppSettings["ServiceBus.Queue.Connectionstring"];
var alarmQueueName = ConfigurationManager.AppSettings["ServiceBus.Queue.Name"];
WriteLineAndLog("Starting analyzer for hub: " + Eventhubpath);
var alarmQueue = new ServiceBusConnection <AlarmMessage>(alarmQueueConnS, alarmQueueName);
var alarmManger = new AlarmMessageManager(alarmQueue);
var ruleStorage = new DocumentDBRuleStorage(ConfigurationManager.AppSettings["DocDBEndPointUrl"], ConfigurationManager.AppSettings["AuthorizationKey"], ConfigurationManager.AppSettings["RuleDatabaseId"], ConfigurationManager.AppSettings["RuleCollectionId"]);
Engine = new AnalyzerEngine();
ServiceBusConnectionStringBuilder builder = new ServiceBusConnectionStringBuilder(eventhubConnS);
builder.TransportType = TransportType.Amqp;
var connection = new EventHubProcessor(builder.ToString(), Eventhubpath);
WriteLineAndLog("Starting event receiver.");
var recTask = connection.StartReceiver <EventProc>(storageConnection);
recTask.Wait();
WriteLineAndLog("Receiver waiting.");
var engineStartCounter = 0;
var maxEngineRestarts = 10;
try
{
new Thread(() =>
{
Thread.CurrentThread.IsBackground = true;
while (true)
{
if (!AwaitingInput)
{
Render();
Thread.Sleep(500);
}
}
}).Start();
new Thread(() =>
{
Thread.CurrentThread.IsBackground = true;
while (true)
{
ParseInput();
}
}).Start();
while (true)
{
MessageAggregator.Collection.Clear();
for (var i = 0; i < 500; ++i)
{
TimeStampedMessage <string> msg;
if (Engine.EngineMessages.TryDequeue(out msg))
{
MessageAggregator.AddMessage(msg, msg.Message.GenerateMessageIdentifierFromString());
}
}
foreach (var messageTracker in MessageAggregator.Collection)
{
MesseageOutputQueue.Enqueue($"{messageTracker.Value.Message} | {messageTracker.Value.AmountCounter} times from {messageTracker.Value.FirstOccurrence} to {messageTracker.Value.LastOccurrence}");
}
if (Engine.State == State.ShuttingDown)
{
continue;
}
if (Engine.State == State.Stopped)
{
Engine.StartEngine(ruleStorage, alarmManger);
if (maxEngineRestarts <= engineStartCounter++)
{
var message = $"AnalyserEngine main task has been restared {engineStartCounter - 1} times. Engine is down and can not recover! Resetting start counter.";
Logger.AddRow(message);
MesseageOutputQueue.Enqueue(message);
var alarm = new AlarmMessage(AlarmLevel.High, AppDomain.CurrentDomain.FriendlyName, message);
alarmManger.RaiseAlarm(alarm);
engineStartCounter = 0;
}
}
var timer = new Stopwatch();
timer.Start();
while (!Engine.EngineIsRunning && timer.ElapsedMilliseconds < 30000)
{
MesseageOutputQueue.Enqueue("Awaiting engine start. Waited " + timer.ElapsedMilliseconds + " ms");
Thread.Sleep(1000);
}
timer.Reset();
}
}
catch (Exception ex)
{
var alarm = new AlarmMessage(AlarmLevel.High, AppDomain.CurrentDomain.FriendlyName, $"Exception in main loop.", ex.Message);
alarmManger.RaiseAlarm(alarm);
WriteLineAndLog($"Exception in main loop.");
WriteLineAndLog(ex.ToString());
}
WriteLineAndLog("End of program.");
}
public virtual void Initialize()
{
messageAggregator = new MessageAggregator();
}
public override object GetData(ITabContext context)
{
var messages = context.GetMessages<AdomdMessage>().ToList();
var aggregator = new MessageAggregator(messages);
var metadata = aggregator.Aggregate();
if (metadata == null)
{
return null;
}
var connections = new List<object[]> { new object[] { "Commands per Connection", "Duration" } };
foreach (var connection in metadata.Connections.Values)
{
if (connection.Commands.Count == 0 && connection.Transactions.Count == 0)
{
continue;
}
var commands = new List<object[]> { new object[] { "Transaction Start", "Ordinal", "Command", "Parameters", "Duration", "Offset", "Transaction End", "Errors" } };
var commandCount = 1;
foreach (var command in connection.Commands.Values)
{
// Transaction Start
List<object[]> headTransaction = null;
if (command.HeadTransaction != null)
{
headTransaction = new List<object[]> { new object[] { "\t▼ Transaction - Started", "Isolation Level - " + command.HeadTransaction.IsolationLevel } };
if (!command.HeadTransaction.Committed.HasValue)
{
headTransaction.Add(new object[] { string.Empty, "Transaction was never completed", "error" });
}
}
// Transaction Finish
List<object[]> tailTransaction = null;
if (command.TailTransaction != null)
{
tailTransaction = new List<object[]> { new object[] { "\t▲ Transaction - Finished", "Status - " + (command.TailTransaction.Committed.GetValueOrDefault() ? "Committed" : "Rollbacked") } };
}
// Parameters
List<object[]> parameters = null;
if (command.Parameters.Count > 0)
{
parameters = new List<object[]> { new object[] { "Name", "Value"} };
foreach (var parameter in command.Parameters)
{
parameters.Add(new[] { parameter.Name, parameter.Value });
}
}
// Exception
List<object[]> errors = null;
if (command.Exception != null)
{
var exception = command.Exception.GetBaseException();
var exceptionName = command.Exception != exception ? command.Exception.Message + ": " + exception.Message : exception.Message;
errors = new List<object[]> { new object[] { "Error", "Stack" }, new object[] { exceptionName, exception.StackTrace } };
}
// Commands
var records = command.RecordsAffected == null || command.RecordsAffected < 0 ? command.TotalRecords : command.RecordsAffected;
var status = string.Empty;
commands.Add(new object[] { headTransaction, string.Format("{0}{1}", command.HasTransaction ? "\t\t\t" : string.Empty, commandCount++), command.Command, parameters, command.Duration, command.Offset, tailTransaction, errors, status });
}
connections.Add(new[] { commands, connection.Duration.HasValue ? (object)connection.Duration.Value : null });
}
if (connections.Count > 1)
{
var statistics = MdxStatisticsBuilder.Build(metadata);
return new Dictionary<string, object>()
{
{
"MDX Statistics",
new object[]
{
new
{
statistics.ConnectionCount,
statistics.QueryCount,
statistics.TransactionCount,
statistics.QueryExecutionTime,
statistics.ConnectionOpenTime
}
}
},
{"Queries", connections}
};
}
return null;
}
public void Init()
{
_filters = new List<IFilter> { new ColorFilterViewModel() };
_messenger = new MessageAggregator();
_filtersViewModel = new FiltersViewModel(_filters, _messenger);
}
/// <summary>
/// Initializes static members of the <see cref="MessageAggregator"/> class.
/// </summary>
static MessageAggregator()
{
Aggregator = new MessageAggregator();
}
public TemplatesAggregator(IMessageBoard messageBoard) : base(messageBoard)
{
aggregator = new MessageAggregator <TemplateLoaded>(OnAggregated);
}
public FilesGeneratedAggregator(IMessageBoard messageBoard) : base(messageBoard)
{
aggregator = new MessageAggregator <FileGenerated>(OnAggregated);
}
public void Init()
{
_repository = new InMemoryRepository();
_messagenger = new MessageAggregator();
_viewModel = new ReportViewModel(_repository, _messagenger);
}
