public void YamlSerialization_SerializeAndDeserializeValidConfigForAzureStorageQueue_SucceedsWithIdenticalOutput()
{
// Arrange
var azureMetadata = GenerateBogusAzureMetadata();
var azureStorageQueueMetricDefinition = GenerateBogusAzureStorageQueueMetricDefinition();
var metricDefaults = GenerateBogusMetricDefaults();
var scrapingConfiguration = new Core.Scraping.Configuration.Model.MetricsDeclaration
{
AzureMetadata = azureMetadata,
MetricDefaults = metricDefaults,
Metrics = new List <MetricDefinition>
{
azureStorageQueueMetricDefinition
}
};
var configurationSerializer = new ConfigurationSerializer(NullLogger.Instance);
// Act
var serializedConfiguration = configurationSerializer.Serialize(scrapingConfiguration);
var deserializedConfiguration = configurationSerializer.Deserialize(serializedConfiguration);
// Assert
Assert.NotNull(deserializedConfiguration);
AssertAzureMetadata(deserializedConfiguration, azureMetadata);
AssertMetricDefaults(deserializedConfiguration, metricDefaults);
Assert.NotNull(deserializedConfiguration.Metrics);
Assert.Single(deserializedConfiguration.Metrics);
var deserializedMetricDefinition = deserializedConfiguration.Metrics.FirstOrDefault();
AssertMetricDefinition(deserializedMetricDefinition, azureStorageQueueMetricDefinition);
var deserializedAzureStorageQueueMetricDefinition = deserializedMetricDefinition as StorageQueueMetricDefinition;
AssertAzureStorageQueueMetricDefinition(deserializedAzureStorageQueueMetricDefinition, azureStorageQueueMetricDefinition, deserializedMetricDefinition);
}
public void YamlSerialization_SerializeAndDeserializeValidConfigForServiceBus_SucceedsWithIdenticalOutput(string resourceGroupName, string defaultScrapingInterval, string metricScrapingInterval)
{
// Arrange
var azureMetadata = GenerateBogusAzureMetadata();
var serviceBusMetricDefinition = GenerateBogusServiceBusMetricDefinition(resourceGroupName, metricScrapingInterval);
var metricDefaults = GenerateBogusMetricDefaults(defaultScrapingInterval);
var scrapingConfiguration = new Core.Scraping.Configuration.Model.MetricsDeclaration
{
AzureMetadata = azureMetadata,
MetricDefaults = metricDefaults,
Metrics = new List <MetricDefinition>
{
serviceBusMetricDefinition
}
};
var configurationSerializer = new ConfigurationSerializer(NullLogger.Instance);
// Act
var serializedConfiguration = configurationSerializer.Serialize(scrapingConfiguration);
var deserializedConfiguration = configurationSerializer.Deserialize(serializedConfiguration);
// Assert
Assert.NotNull(deserializedConfiguration);
AssertAzureMetadata(deserializedConfiguration, azureMetadata);
AssertMetricDefaults(deserializedConfiguration, metricDefaults);
Assert.NotNull(deserializedConfiguration.Metrics);
Assert.Single(deserializedConfiguration.Metrics);
var deserializedMetricDefinition = deserializedConfiguration.Metrics.FirstOrDefault();
AssertMetricDefinition(deserializedMetricDefinition, serviceBusMetricDefinition);
var deserializedServiceBusMetricDefinition = deserializedMetricDefinition as ServiceBusQueueMetricDefinition;
AssertServiceBusQueueMetricDefinition(deserializedServiceBusMetricDefinition, serviceBusMetricDefinition);
}
public void YamlSerialization_SerializeAndDeserializeValidConfigForCosmosDb_SucceedsWithIdenticalOutput(string resourceGroupName, string defaultScrapingInterval, string metricScrapingInterval)
{
// Arrange
var azureMetadata = GenerateBogusAzureMetadata();
var cosmosDbMetricDefinition = GenerateBogusCosmosDbMetricDefinition(resourceGroupName, metricScrapingInterval);
var metricDefaults = GenerateBogusMetricDefaults(defaultScrapingInterval);
var scrapingConfiguration = new MetricsDeclarationV1
{
Version = SpecVersion.v1.ToString(),
AzureMetadata = azureMetadata,
MetricDefaults = metricDefaults,
Metrics = new List <MetricDefinitionV1>
{
cosmosDbMetricDefinition
}
};
var configurationSerializer = new ConfigurationSerializer(NullLogger.Instance, Mapper);
// Act
var serializedConfiguration = configurationSerializer.Serialize(scrapingConfiguration);
var deserializedConfiguration = configurationSerializer.Deserialize(serializedConfiguration);
// Assert
Assert.NotNull(deserializedConfiguration);
AssertAzureMetadata(deserializedConfiguration, azureMetadata);
AssertMetricDefaults(deserializedConfiguration, metricDefaults);
Assert.NotNull(deserializedConfiguration.Metrics);
Assert.Single(deserializedConfiguration.Metrics);
var deserializedMetricDefinition = deserializedConfiguration.Metrics.FirstOrDefault();
AssertMetricDefinition(deserializedMetricDefinition, cosmosDbMetricDefinition);
AssertCosmosDbMetricDefinition(deserializedMetricDefinition, cosmosDbMetricDefinition);
}
static ExecutorConfiguration ReadConfig(string[] args)
{
var configFilePath = ExecutorConfiguration.DEFAULT_FILENAME;
if (args.Any())
{
configFilePath = args[0];
}
_logger.LogDebug("Checking config file at '{0}'", configFilePath);
if (!File.Exists(configFilePath))
{
_logger.LogError("Could not find any config file at '{0}'", configFilePath);
return(null);
}
var serializer = new ConfigurationSerializer();
try
{
var configContent = File.ReadAllText(configFilePath);
var config = serializer.Deserialize(configContent);
return(config);
}
catch (Exception ex)
{
_logger.LogError(ex, "Deserializing of config not possible");
return(null);
}
}
public virtual MetricsDeclaration Get(bool applyDefaults = false, IErrorReporter errorReporter = null)
{
var rawMetricsDeclaration = ReadRawDeclaration();
errorReporter ??= new ErrorReporter();
var config = _configurationSerializer.Deserialize(rawMetricsDeclaration, errorReporter);
if (!errorReporter.HasErrors && applyDefaults)
{
foreach (var metric in config.Metrics)
{
// Apply the default aggregation interval if none is specified
metric.AzureMetricConfiguration ??= new AzureMetricConfiguration();
metric.AzureMetricConfiguration.Aggregation ??= new MetricAggregation();
metric.AzureMetricConfiguration.Aggregation.Interval ??= config.MetricDefaults.Aggregation?.Interval;
metric.AzureMetricConfiguration.Limit ??= config.MetricDefaults.Limit;
// Apply the default scraping interval if none is specified
metric.Scraping ??= config.MetricDefaults.Scraping;
// Apply the default scraping interval if none is specified
metric.Scraping.Schedule ??= config.MetricDefaults.Scraping.Schedule;
}
}
return(config);
}
public static Dictionary <string, Dictionary <string, string> > ParseLocalization(string json, string keyPrefix = null)
{
var localizationFile = ConfigurationSerializer.Deserialize <Dictionary <string, string>[]>(json);
// language code: key: value
var localization = new Dictionary <string, Dictionary <string, string> >();
foreach (var row in localizationFile)
{
if (row.TryGetValue(KeyColumn, out var key) &&
(keyPrefix == null || key.StartsWith(keyPrefix)))
{
foreach (var language in row.Keys.Where(k => k.Equals(KeyColumn) == false))
{
if (localization.TryGetValue(language, out var languageDictionary) == false)
{
languageDictionary = new Dictionary <string, string>();
localization.Add(language, languageDictionary);
}
languageDictionary.Add(key, row[language]);
}
}
}
return(localization);
}
public void YamlSerialization_SerializeAndDeserializeValidConfigForAzureStorageQueue_SucceedsWithIdenticalOutput(string resourceGroupName, string defaultScrapingInterval, string metricScrapingInterval, string sasTokenRawValue, string sasTokenEnvironmentVariable)
{
// Arrange
var azureMetadata = GenerateBogusAzureMetadata();
var azureStorageQueueMetricDefinition = GenerateBogusAzureStorageQueueMetricDefinition(resourceGroupName, metricScrapingInterval, sasTokenRawValue, sasTokenEnvironmentVariable);
var metricDefaults = GenerateBogusMetricDefaults(defaultScrapingInterval);
var scrapingConfiguration = new Promitor.Core.Scraping.Configuration.Serialization.v1.Model.MetricsDeclarationV1
{
Version = SpecVersion.v1.ToString(),
AzureMetadata = azureMetadata,
MetricDefaults = metricDefaults,
Metrics = new List <MetricDefinitionV1>
{
azureStorageQueueMetricDefinition
}
};
var configurationSerializer = new ConfigurationSerializer(NullLogger.Instance, Mapper);
// Act
var serializedConfiguration = configurationSerializer.Serialize(scrapingConfiguration);
var deserializedConfiguration = configurationSerializer.Deserialize(serializedConfiguration);
// Assert
Assert.NotNull(deserializedConfiguration);
AssertAzureMetadata(deserializedConfiguration, azureMetadata);
AssertMetricDefaults(deserializedConfiguration, metricDefaults);
Assert.NotNull(deserializedConfiguration.Metrics);
Assert.Single(deserializedConfiguration.Metrics);
var deserializedMetricDefinition = deserializedConfiguration.Metrics.FirstOrDefault();
AssertMetricDefinition(deserializedMetricDefinition, azureStorageQueueMetricDefinition);
AssertAzureStorageQueueMetricDefinition(deserializedMetricDefinition, azureStorageQueueMetricDefinition);
}
public TrayIcon()
{
Application.ApplicationExit += OnApplicationExit;
InitializeComponent();
_configuration = new Configuration();
_configurationSerializer = new Utilities.ConfigurationSerializer <Configuration>("configuration.json", _configuration);
_configuration = _configurationSerializer.Deserialize();
// Todo visibility dependent on configuration. If not, only show config form on 2nd startup
_logForm = new LogForm()
{
Visible = false
};
_mainForm = new MainForm();
_trayIcon.Visible = _configuration.ShowTrayIcon;
InitializeApplication();
//Debug.WriteLine(Reboot.GetUptime());
//Debug.WriteLine(Reboot.GetUptime2());
//Reboot.Shutdown(ShutdownType.Reboot, ForceExit.Force,ShutdownReason.MinorOther);
}
public virtual MetricsDeclaration Get()
{
var rawMetricsDeclaration = ReadRawDeclaration();
var config = ConfigurationSerializer.Deserialize(rawMetricsDeclaration);
return(config);
}
public void Deserialize_SerializedYaml_CanDeserializeToRuntimeModel()
{
// Arrange
var yaml = _configurationSerializer.Serialize(_metricsDeclaration);
// Act
var runtimeModel = _configurationSerializer.Deserialize(yaml, _errorReporter);
// Assert
Assert.NotNull(runtimeModel);
var firstMetric = runtimeModel.Metrics.ElementAt(0);
Assert.Equal(ResourceType.Generic, firstMetric.ResourceType);
Assert.Equal("promitor_demo_generic_queue_size", firstMetric.PrometheusMetricDefinition.Name);
Assert.Equal("Amount of active messages of the 'orders' queue (determined with Generic provider)", firstMetric.PrometheusMetricDefinition.Description);
Assert.Collection(firstMetric.Resources,
r =>
{
var definition = Assert.IsType <GenericAzureResourceDefinition>(r);
Assert.Equal("EntityName eq 'orders'", definition.Filter);
Assert.Equal("Microsoft.ServiceBus/namespaces/promitor-messaging", definition.ResourceUri);
},
r =>
{
var definition = Assert.IsType <GenericAzureResourceDefinition>(r);
Assert.Equal("EntityName eq 'accounts'", definition.Filter);
Assert.Equal("Microsoft.ServiceBus/namespaces/promitor-messaging", definition.ResourceUri);
});
var secondMetric = runtimeModel.Metrics.ElementAt(1);
Assert.Equal(ResourceType.ServiceBusNamespace, secondMetric.ResourceType);
Assert.Equal("promitor_demo_servicebusqueue_queue_size", secondMetric.PrometheusMetricDefinition.Name);
Assert.Equal("Amount of active messages of the 'orders' queue (determined with ServiceBusNamespace provider)", secondMetric.PrometheusMetricDefinition.Description);
Assert.Collection(secondMetric.Resources,
r =>
{
var definition = Assert.IsType <ServiceBusNamespaceResourceDefinition>(r);
Assert.Equal("promitor-messaging", definition.Namespace);
Assert.Equal("orders", definition.QueueName);
Assert.Equal("promitor-demo-group", definition.ResourceGroupName);
});
Assert.NotNull(secondMetric.ResourceDiscoveryGroups);
Assert.Single(secondMetric.ResourceDiscoveryGroups);
var resourceDiscoveryGroup = secondMetric.ResourceDiscoveryGroups.First();
Assert.Equal("example-resource-collection", resourceDiscoveryGroup.Name);
}
public virtual MetricsDeclaration Get(bool applyDefaults = false)
{
var rawMetricsDeclaration = ReadRawDeclaration();
var config = _configurationSerializer.Deserialize(rawMetricsDeclaration);
if (applyDefaults)
{
foreach (var metric in config.Metrics)
{
// Apply AzureMetadata.ResourceGroupName to metrics with no other RG specified
if (string.IsNullOrWhiteSpace(metric.ResourceGroupName))
{
metric.ResourceGroupName = config.AzureMetadata.ResourceGroupName;
}
// Apply the default aggregation interval if none is specified
if (metric.AzureMetricConfiguration == null)
{
metric.AzureMetricConfiguration = new AzureMetricConfiguration();
}
if (metric.AzureMetricConfiguration?.Aggregation == null)
{
metric.AzureMetricConfiguration.Aggregation = new MetricAggregation();
}
if (metric.AzureMetricConfiguration?.Aggregation.Interval == null)
{
metric.AzureMetricConfiguration.Aggregation.Interval = config.MetricDefaults.Aggregation.Interval;
}
// Apply the default scraping interval if none is specified
if (metric.Scraping == null)
{
metric.Scraping = config.MetricDefaults.Scraping;
}
// Apply the default scraping interval if none is specified
if (metric.Scraping.Schedule == null)
{
metric.Scraping.Schedule = config.MetricDefaults.Scraping.Schedule;
}
}
}
return(config);
}
public void YamlSerialization_SerializeAndDeserializeValidConfigForServiceBus_SucceedsWithIdenticalOutput()
{
// Arrange
var azureMetadata = GenerateBogusAzureMetadata();
var serviceBusMetricDefinition = GenerateBogusServiceBusMetricDefinition();
var scrapingConfiguration = new MetricsDeclaration
{
AzureMetadata = azureMetadata,
Metrics = new List <Core.Scraping.Configuration.Model.Metrics.MetricDefinition>
{
serviceBusMetricDefinition
}
};
// Act
var serializedConfiguration = ConfigurationSerializer.Serialize(scrapingConfiguration);
var deserializedConfiguration = ConfigurationSerializer.Deserialize(serializedConfiguration);
// Assert
Assert.NotNull(deserializedConfiguration);
Assert.NotNull(deserializedConfiguration.AzureMetadata);
Assert.Equal(azureMetadata.TenantId, deserializedConfiguration.AzureMetadata.TenantId);
Assert.Equal(azureMetadata.ResourceGroupName, deserializedConfiguration.AzureMetadata.ResourceGroupName);
Assert.Equal(azureMetadata.SubscriptionId, deserializedConfiguration.AzureMetadata.SubscriptionId);
Assert.NotNull(deserializedConfiguration.Metrics);
Assert.Single(deserializedConfiguration.Metrics);
var deserializedMetricDefinition = deserializedConfiguration.Metrics.FirstOrDefault();
Assert.NotNull(deserializedMetricDefinition);
Assert.Equal(serviceBusMetricDefinition.Name, deserializedMetricDefinition.Name);
Assert.Equal(serviceBusMetricDefinition.Description, deserializedMetricDefinition.Description);
Assert.Equal(serviceBusMetricDefinition.ResourceType, deserializedMetricDefinition.ResourceType);
var deserializedServiceBusMetricDefinition = deserializedMetricDefinition as ServiceBusQueueMetricDefinition;
Assert.NotNull(deserializedServiceBusMetricDefinition);
Assert.Equal(serviceBusMetricDefinition.Namespace, deserializedServiceBusMetricDefinition.Namespace);
Assert.Equal(serviceBusMetricDefinition.QueueName, deserializedServiceBusMetricDefinition.QueueName);
Assert.NotNull(deserializedMetricDefinition.AzureMetricConfiguration);
Assert.Equal(serviceBusMetricDefinition.AzureMetricConfiguration.MetricName, deserializedMetricDefinition.AzureMetricConfiguration.MetricName);
Assert.Equal(serviceBusMetricDefinition.AzureMetricConfiguration.Aggregation, deserializedMetricDefinition.AzureMetricConfiguration.Aggregation);
}
public virtual MetricsDeclaration Get(bool applyDefaults = false)
{
var rawMetricsDeclaration = ReadRawDeclaration();
var config = _configurationSerializer.Deserialize(rawMetricsDeclaration);
if (applyDefaults)
{
foreach (var metric in config.Metrics)
{
// Apply the default aggregation interval if none is specified
if (metric.AzureMetricConfiguration == null)
{
metric.AzureMetricConfiguration = new AzureMetricConfiguration();
}
if (metric.AzureMetricConfiguration?.Aggregation == null)
{
metric.AzureMetricConfiguration.Aggregation = new MetricAggregation();
}
if (metric.AzureMetricConfiguration?.Aggregation.Interval == null)
{
metric.AzureMetricConfiguration.Aggregation.Interval = config.MetricDefaults.Aggregation?.Interval;
}
// Apply the default scraping interval if none is specified
if (metric.Scraping == null)
{
metric.Scraping = config.MetricDefaults.Scraping;
}
// Apply the default scraping interval if none is specified
if (metric.Scraping.Schedule == null)
{
metric.Scraping.Schedule = config.MetricDefaults.Scraping.Schedule;
}
}
}
return(config);
}
private void ProcessSimulationStateMessage(Message message)
{
if (message is ITAlert.Photon.Messages.Simulation.States.InitializedMessage initializedMessage)
{
LogProxy.Info("InitializingState: Received InitializedMessage");
if (string.IsNullOrEmpty(initializedMessage.PlayerConfiguration) ||
string.IsNullOrEmpty(initializedMessage.ScenarioName) ||
_scenarioLoader.TryGetScenario(initializedMessage.ScenarioName, out var scenario) == false)
{
throw new InvalidOperationException("Received invalid InitializedMessage.");
}
try
{
scenario.Configuration.PlayerConfiguration = ConfigurationSerializer.Deserialize <List <PlayerConfig> >(initializedMessage.PlayerConfiguration);
// TODO: extract simulation initialization to somewhere else
var simulationRoot = SimulationInstaller.CreateSimulationRoot(scenario);
if (_director.Initialize(simulationRoot, _photonClient.CurrentRoom.Player.PhotonId, _photonClient.CurrentRoom.Players))
{
_photonClient.CurrentRoom.Messenger.SendMessage(new InitializedMessage
{
PlayerPhotonId = _photonClient.CurrentRoom.Player.PhotonId
});
}
}
catch (Exception ex)
{
//TODO: transition back to lobby, or show error message
throw new SimulationException("Error creating simulation root", ex);
}
}
else
{
throw new Exception("Unhandled Simulation State Message: " + message);
}
}
private void ThreadWorker()
{
while (true)
{
try
{
var handle = WaitHandle.WaitAny(new WaitHandle[] { _terminateSignal, _messageSignal });
if (handle == 0)
{
LogProxy.Warning("Director: Terminating thread worker.");
break;
}
if (handle == 1)
{
if (!_queueBeingProcessed)
{
_queueBeingProcessed = true;
var queuedMessages = new List <Tuple <TickMessage, Tick> >();
lock (_queueLock)
{
var orderedMessages = _queuedMessages.Select(m => new Tuple <TickMessage, Tick>(m, ConfigurationSerializer.Deserialize <Tick>(m.TickString))).OrderBy(m => m.Item2.CurrentTick).ToArray();
_queuedMessages.Clear();
if (orderedMessages.Length > 50)
{
if (SimulationRoot.ECS.CurrentTick + 1 > orderedMessages[0].Item2.CurrentTick)
{
orderedMessages = orderedMessages.Where(m => m.Item2.CurrentTick >= SimulationRoot.ECS.CurrentTick + 1).ToArray();
}
while (SimulationRoot.ECS.CurrentTick + 1 < orderedMessages[0].Item2.CurrentTick)
{
SimulationRoot.ECS.Tick();
}
}
for (var m = 0; m < orderedMessages.Length; m++)
{
if (m + SimulationRoot.ECS.CurrentTick + 1 == orderedMessages[m].Item2.CurrentTick)
{
queuedMessages.Add(orderedMessages[m]);
}
else
{
_queuedMessages.Enqueue(orderedMessages[m].Item1);
}
}
}
var i = 1;
foreach (var tickMessage in queuedMessages)
{
var fastForward = i++ < queuedMessages.Count;
var success = true;
foreach (var command in tickMessage.Item2.CommandQueue)
{
success &= CommandSystem.TryHandleCommand(command, tickMessage.Item2.CurrentTick);
}
if (success != true)
{
throw new SimulationIntegrationException("Local Simulation failed to apply command(s).");
}
SimulationRoot.ECS.Tick();
if (fastForward)
{
LogProxy.Warning($"Simulation fast forwarding tick {SimulationRoot.ECS.CurrentTick}");
}
else
{
if (tickMessage.Item2.CurrentTick != SimulationRoot.ECS.CurrentTick)
{
throw new SimulationSynchronisationException($"Simulation out of sync: Local tick {SimulationRoot.ECS.CurrentTick} doesn't not match master {tickMessage.Item2.CurrentTick}");
}
var localTick = SimulationRoot.ECS.CurrentTick;
SimulationRoot.GetEntityState(out var crc);
#if LOG_ENTITYSTATE
System.IO.File.WriteAllText($"d:\\temp\\{SimulationRoot.ECS.CurrentTick}.{Player.PhotonId}.json", state);
#endif
if (tickMessage.Item1.CRC != crc)
{
throw new SimulationSynchronisationException($"Simulation out of sync at tick {localTick}: Local CRC {crc} doest not match master {tickMessage.Item1.CRC}");
}
}
}
_updateSignal.Set();
_updateCompleteSignal.WaitOne();
_queueBeingProcessed = false;
}
else
{
LogProxy.Warning("ProcessQueuedMessages not called as already running");
}
}
}
catch (Exception ex)
{
LogProxy.Error($"Simulation worker thread terminating due to error: {ex}");
ThreadWorkerException = new SimulationIntegrationException("Terminating simulation worker thread", ex);
_workerThreadExceptionSignal.Set();
break;
}
}
LogProxy.Warning("Director: Thread Worker Terminated.");
}
