public async Task ExecuteAsync(string localhost, CancellationToken Token = default)
{
while (!Token.IsCancellationRequested)
{
if (serviceInstance == null)
{
if (!localhost.IsEmpty())
{
await new HttpClient().GetStringAsync($"{localhost}{BasicConfig.HttpReportsServerRegister}");
}
await Task.Delay(TimeSpan.FromSeconds(1), Token);
}
else
{
_logger.LogInformation($"HttpReportsBackgroundService Execute IP:{serviceInstance.LocalIP} Port:{serviceInstance.LocalPort}");
IPerformance performance = await _performanceService.GetPerformance(serviceInstance.LocalIP + ":" + serviceInstance.LocalPort);
if (performance != null)
{
await _storage.AddPerformanceAsync(performance);
}
await Task.Delay(TimeSpan.FromSeconds(10), Token);
}
}
}
public static Penalization Build(IPerformance announced, IPerformance realized, IRules rules)
{
double announcedValue = rules.PrimaryComponent.Get(announced) ?? 0;
double realizedValue = rules.PrimaryComponent.Get(realized) ?? 0;
if (announcedValue <= realizedValue)
{
return(null);
}
var penalization = new Penalization
{
IsShortPerformance = true,
ShortReason = "",
PenalizationId = "Short",
Reason = "Short performance",
Performance = new Performance(),
CardResult = CardResult.Yellow
};
var penalty = rules.ShortCalculation.Evaluate(new CalculationVariables(null, announced, realized));
if (penalty != null)
{
penalty = Math.Round(penalty.Value, 4);
}
rules.PenalizationsTarget.Modify(penalization.Performance, penalty);
return(penalization);
}
private void RunTests(IPerformance performanceTest, string testName)
{
try
{
Output += string.Format("Starting performance test for {0}", testName) + Environment.NewLine;
_watch.Start();
performanceTest.Registration();
Output += string.Format("IOC Registration Time for {0} tests: {1} ms", NumberOfTests, _watch.Elapsed.Milliseconds.ToString()) + Environment.NewLine;
_watch.Restart();
performanceTest.Resolve();
Output += string.Format("IOC Resolution Time for {0} tests: {1} ms", NumberOfTests, _watch.Elapsed.Milliseconds.ToString()) + Environment.NewLine;
}
finally
{
_watch.Stop();
Output += string.Format("Ending performance test {0}", testName) + Environment.NewLine;
Output += Environment.NewLine;
}
}
public Ticket(IPerformance performance, TicketType type)
{
this.Performance = performance;
this.Price = this.CalculatePrice();
this.status = TicketStatus.Unsold;
this.Type = type;
}
protected Ticket(IPerformance performance, TicketType type)
{
this.Performance = performance;
this.Price = this.CalculatePrice();
this.status = TicketStatus.Unsold;
this.Type = type;
}
private bool IsSatisfiedBy(IPerformance performance)
{
return
(performance.Duration == null &&
performance.Distance == null &&
performance.Depth == null &&
performance.Points == null);
}
public void SetPerformance(bool isRun, IPerformance perfmon)
{
if (model != null)
{
model.IsAlive = isRun;
model.SetPerformance(perfmon);
}
}
private T Extract(IPerformance performance)
{
if (performance == null)
{
return(default(T));
}
T?extracted = extractor(performance);
return(extracted == null ? default(T) : extracted.Value);
}
public static double GetPoints(IPerformance performance, ICalculation calculation)
{
var points = calculation.Evaluate(new CalculationVariables(null, null, performance));
if (points == null)
{
return(0);
}
return(Math.Round(points.Value, 4));
}
public async Task WritePerformanceAsync(IPerformance performance)
{
try
{
var reply = await _client.WritePerformanceAsync(performance as HttpReports.Collector.Grpc.Performance);
}
catch (Exception ex)
{
_logger.LogError(ex, "ReportsTransport Error ");
}
}
/// <summary>
/// Delete the performance category if we need to.
/// </summary>
/// <param name="performance"></param>
private static void CreatePerformance(IPerformance performance)
{
if (!performance.DeleteStartUp)
{
return;
}
if (PerformanceCounterCategory.Exists(performance.CategoryName))
{
PerformanceCounterCategory.Delete(performance.CategoryName);
}
}
private decimal TicketsTotalPrice(IPerformance performance)
{
decimal totalPrice = 0;
var soldTickets = performance.Tickets.Where(x => x.Status == TicketStatus.Sold);
foreach (var ticket in soldTickets)
{
totalPrice += ticket.Price;
}
return(totalPrice);
}
public BookingsStagesAnalysis(ICompanyDBRepository _compDbRepo, IThirdpartyDBrepository _tpRepo, IPerformance _perfRepo)
{
compDbRepo = _compDbRepo;
tpRepo = _tpRepo;
perfRepo = _perfRepo;
// used by the select in the view
compSpec.DptsList["All"] = compSpec.DptsList.SelectMany(kvp => kvp.Value).ToList();
compSpec.bookingTypes["All"] = compSpec.bookingTypes.SelectMany(kvp => kvp.Value).ToList();
}
public async Task WritePerformanceAsync(IPerformance performance)
{
try
{
HttpContent content = new StringContent(System.Text.Json.JsonSerializer.Serialize(performance as Performance), System.Text.Encoding.UTF8, "application/json");
var response = await _httpClientFactory.CreateClient(BasicConfig.HttpReportsHttpClient).PostAsync(_options.CollectorAddress, content);
}
catch (Exception ex)
{
//TODO ReTry?
_logger.LogError(ex, "ReportsTransport Error");
}
}
public SqlitePersisterWords(IPerformance performance, IWordsParts wordsParts, int maxNumCharactersPerWords, ILogger logger)
{
// the maximum word len
_maxNumCharactersPerWords = maxNumCharactersPerWords;
// the words parts interfaces
_wordsParts = wordsParts ?? throw new ArgumentNullException(nameof(wordsParts));
// save the logger
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
// create the counter,
_counterAddOrUpdate = new SqlPerformanceCounter(performance, "Database: Add Or Update word", _logger);
}
private string PrintPerformanceReport(IPerformance performance)
{
// <name>: <tickets_sold> ticket(s), total: $<total_price>
// Venue: <venue_name> (<venue_location>)
// Start time: <start_time>
var report = new List <string>();
report.Add(string.Format("{0}: {1} ticket(s), total: ${2}",
performance.Name, GetTicketsSold(performance).Count, TicketsTotalPrice(performance)));
report.Add(string.Format("Venue: <venue_name> (<venue_location>)",
performance.Venue.Name, performance.Venue.Location));
report.Add(string.Format("Start time: {0}", performance.StartTime));
return(string.Join(Environment.NewLine, report));
}
public double?Get(IPerformance performance)
{
switch (data)
{
case 1: return(performance.Distance);
case 2: return(performance.Depth);
case 3: return(performance.DurationSeconds());
case 4: return(performance.Points);
default: return(null);
}
}
public async Task <bool> AddPerformanceAsync(IPerformance performance)
{
performance.Id = MD5_16(Guid.NewGuid().ToString());
string sql = $@"Insert Into ""{Prefix}Performance"" (Id,Service,Instance,GCGen0,GCGen1,GCGen2,HeapMemory,ProcessCPU,ProcessMemory,ThreadCount,PendingThreadCount,CreateTime)
Values (@Id,@Service,@Instance,@GCGen0,@GCGen1,@GCGen2,@HeapMemory,@ProcessCPU,@ProcessMemory,@ThreadCount,@PendingThreadCount,@CreateTime)";
TraceLogSql(sql);
return(await LoggingSqlOperation(async connection => (
await connection.ExecuteAsync(sql, performance)
) > 0));
}
private void Fill(IPerformance performance, IDataReader dataReader, string prefix = "")
{
var sqlDataReader = dataReader as SqlDataReader;
performance.PerformanceID = sqlDataReader.GetSafe <int>("PerformanceID");
performance.EventName = sqlDataReader.GetSafe <string>($"{prefix}EventName");
performance.Description = sqlDataReader.GetSafe <string>($"{prefix}Description");
performance.EventUrl = sqlDataReader.GetSafe <string>($"{prefix}EventUrl");
performance.StartDate = sqlDataReader.GetSafe <DateTime>($"{prefix}StartDate");
performance.StartTime = sqlDataReader.GetSafe <TimeSpan>($"{prefix}StartTime");
performance.StartTime2 = sqlDataReader.GetSafe <TimeSpan>($"{prefix}StartTime2");
//performance.WorkshopTime = (TimeSpan)item("WorkshopTime");
//performance.WorkshopTime2 = (TimeSpan)item("WorkshopTime2");
performance.IsDeleted = sqlDataReader.GetSafe <bool>($"{prefix}IsDeleted");
performance.VenueID = sqlDataReader.GetSafe <int>($"{prefix}VenueID");
}
public async Task <bool> AddPerformanceAsync(IPerformance performance)
{
performance.Id = MD5_16(Guid.NewGuid().ToString());
string sql = $@"Insert Into Performance
(Id,Service,Instance,GCGen0,GCGen1,GCGen2,HeapMemory,ProcessCPU,ProcessMemory,ThreadCount,PendingThreadCount,CreateTime)
Values (:Id,:Service,:Instance,:GCGen0,:GCGen1,:GCGen2,:HeapMemory,:ProcessCPU,:ProcessMemory,:ThreadCount,:PendingThreadCount, to_date('{performance.CreateTime:yyyy-MM-dd HH:mm:ss}','YYYY-MM-DD hh24:mi:ss') )";
TraceLogSql(sql);
return(await LoggingSqlOperation(async _ => (
await _.ExecuteAsync(sql, performance)
) > 0));
}
public async Task <bool> AddPerformanceAsync(IPerformance performance)
{
performance.Id = MD5_16(Guid.NewGuid().ToString());
string sql = $@"Insert Into MonitorJob
(Id,Service,Instance,GCGen0,GCGen1,GCGen2,HeapMemory,ProcessCPU,ProcessMemory,ThreadCount,PendingThreadCount,CreateTime)
Values (:Id,:Service,:Instance,:GCGen0,:GCGen1,:GCGen2,:HeapMemory,:ProcessCPU,:ProcessMemory,:ThreadCount,:PendingThreadCount,:CreateTime)";
TraceLogSql(sql);
return(await LoggingSqlOperation(async connection => (
await connection.ExecuteAsync(sql, performance)
) > 0));
}
public async Task <bool> AddPerformanceAsync(IPerformance performance)
{
performance.Id = MD5_16(Guid.NewGuid().ToString());
string sql = $@"Insert Into [Performance]
([Id],[Service],[Instance],[GCGen0],[GCGen1],[GCGen2],[HeapMemory],[ProcessCPU],[ProcessMemory],[ThreadCount],[PendingThreadCount],[CreateTime])
Values (@Id,@Service,@Instance,@GCGen0,@GCGen1,@GCGen2,@HeapMemory,@ProcessCPU,@ProcessMemory,@ThreadCount,@PendingThreadCount,@CreateTime)";
TraceLogSql(sql);
return(await LoggingSqlOperation(async connection => (
await connection.ExecuteAsync(sql, performance)
) > 0));
}
public Processor(
IList <IFileParser> fileParsers,
IProcessors processorsConfig,
ITimers timersConfig,
IMaintenance maintenanceConfig,
IParser parser,
IPersister persister,
ILogger logger,
IDirectory directory,
IPerformance performance
)
{
// save the logger
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
const string directoryCounterName = "Processor: Average time processing Directories";
const string fileCounterName = "Processor: Average time processing Files";
const string parserCounterName = "Processor: Average time parsing files/folders";
// Create the various processors, they will not start doing anything just yet
// or at least, they shouldn't
var directoriesCounter = new ProcessorPerformanceCounter(performance, directoryCounterName, logger);
var filesCounter = new ProcessorPerformanceCounter(performance, fileCounterName, logger);
var parserCounter = new ProcessorPerformanceCounter(performance, parserCounterName, logger);
_eventTimer = new ProcessorTimer(
new List <IProcessor>
{
new Folders(directoriesCounter, processorsConfig.UpdatesFolderPerEvent, persister, logger, directory, timersConfig.EventsMaxWaitTransactionMs),
new Files(filesCounter, processorsConfig.UpdatesFilesPerEvent, fileParsers, processorsConfig.IgnoreFiles, persister, logger, directory, timersConfig.EventsMaxWaitTransactionMs)
},
_logger, processorsConfig.EventsProcessorMs);
_maintenanceTimer = new ProcessorTimer(
new List <IProcessor>
{
new Maintenance(maintenanceConfig.Active, parser, persister, logger)
},
_logger, (int)TimeSpan.FromMinutes(processorsConfig.MaintenanceProcessorMinutes).TotalMilliseconds);
_parserTimer = new ProcessorTimer(
new List <IProcessor>
{
new Parser(parserCounter, parser, logger)
},
_logger, (int)TimeSpan.FromMinutes(processorsConfig.ParserProcessorMinutes).TotalMilliseconds);
}
public async Task ExecuteAsync(CancellationToken Token = default)
{
while (!Token.IsCancellationRequested)
{
Uri uri = new Uri(_options.Urls);
_logger.LogInformation($"{DateTime.Now:yyyy-MM-dd HH:mm:ss} BackgroundService Execute... ");
IPerformance performance = await _performanceService.GetPerformance(uri.Host + ":" + uri.Port);
if (performance != null)
{
await _transport.WritePerformanceAsync(performance);
}
await Task.Delay(TimeSpan.FromSeconds(10), Token);
}
}
public async Task ExecuteAsync(CancellationToken Token = default)
{
while (!Token.IsCancellationRequested)
{
Uri uri = new Uri(_options.Urls);
IPerformance p = await _performanceService.GetPerformance(uri.Host + ":" + uri.Port);
_logger.LogInformation($"HttpReports.CLR CPU:{p.ProcessCPU} Memory:{p.ProcessMemory} ThreadCount:{p.ThreadCount} CG0:{p.GCGen0} GC1:{p.GCGen1} GC2:{p.GCGen2} ");
if (p != null)
{
await _transport.Transport(p);
}
await Task.Delay(TimeSpan.FromSeconds(10), Token);
}
}
private static TestResult DoPerformanceTests(string testCase, IPerformance performance, int count, bool singleton)
{
switch (testCase)
{
case TestCaseName.A:
performance.DoTestA(1, singleton);
return performance.DoTestA(count, singleton);
case TestCaseName.B:
performance.DoTestB(1, singleton);
return performance.DoTestB(count, singleton);
case TestCaseName.C:
performance.DoTestC(1, singleton);
return performance.DoTestC(count, singleton);
default:
throw new InvalidOperationException();
}
}
public SqlitePersister(IPerformance performance, IList <IFileParser> parsers, ILogger logger,
ConfigSqliteDatabase config,
int maxNumCharactersPerWords,
int maxNumCharactersPerParts
)
{
// save the logger
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
// performance
_performance = performance ?? throw new ArgumentNullException(nameof(performance));
// the configuration
_config = config ?? throw new ArgumentNullException(nameof(config));
// create the configuration table.
Config = new SqlitePersisterConfig();
// create the counters
Counts = new SqlitePersisterCounts(logger);
// word parts
WordsParts = new SqlitePersisterWordsParts(logger);
// create the words
Words = new SqlitePersisterWords(performance, WordsParts, maxNumCharactersPerWords, logger);
// file words.
FilesWords = new SqlitePersisterFilesWords(Words, logger);
// create the files / Folders.
Folders = new SqlitePersisterFolders(Counts, parsers, logger);
// the parts
Parts = new SqlitePersisterParts(maxNumCharactersPerParts);
// the query
Query = new SqlitePersisterQuery(maxNumCharactersPerParts, logger);
}
private void RunTests(IPerformance performanceTest, string testName)
{
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
GC.WaitForPendingFinalizers();
try
{
Output += string.Format("Starting performance test for {0}", testName) + Environment.NewLine;
_watch.Start();
performanceTest.Registration();
Output += string.Format("Avg. IOC Registration Time for {0} tests: {1} ms", NumberOfTests, ((double)_watch.Elapsed.Milliseconds / (double)NumberOfTests).ToString()) + Environment.NewLine;
_watch.Restart();
performanceTest.FirstResolve();
Output += string.Format("IOC First Resolution Time: {0} ms", _watch.Elapsed.Milliseconds.ToString()) + Environment.NewLine;
_watch.Restart();
performanceTest.Resolve();
Output += string.Format("Total IOC Resolution Time for {0} tests: {1} ms", NumberOfTests, _watch.Elapsed.Milliseconds) + Environment.NewLine;
Output += string.Format("Avg. IOC Resolution Time for {0} tests: {1} ms", NumberOfTests, ((double)_watch.Elapsed.Milliseconds / (double)NumberOfTests).ToString()) + Environment.NewLine;
}
finally
{
_watch.Stop();
Output += string.Format("Ending performance test {0}", testName) + Environment.NewLine;
Output += Environment.NewLine;
}
}
public async Task Transport(IPerformance performance)
{
await Retry(async() => {
try
{
HttpContent content = new StringContent(HttpUtility.HtmlEncode(JsonConvert.SerializeObject(performance)), System.Text.Encoding.UTF8, "application/json");
content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json");
content.Headers.Add(BasicConfig.TransportType, typeof(IPerformance).Name);
var client = _httpClientFactory.CreateClient(BasicConfig.HttpReportsHttpClient);
var response = await _httpClientFactory.CreateClient(BasicConfig.HttpReportsHttpClient).PostAsync(_options.CollectorAddress + BasicConfig.TransportPath.Substring(1), content);
return(true);
}
catch (Exception ex)
{
_logger.LogError(ex, "HttpReportsTransport IPerformance Error:" + ex.ToString());
return(false);
}
});
}
private decimal GetTotalTicketsPrice(IPerformance performance)
{
var soldTickets = performance.Tickets.Where(x => x.Status == TicketStatus.Sold);
decimal totalPrice = soldTickets.Sum(ticket => ticket.Price);
return totalPrice;
}
public Task Transport(IPerformance performance)
{
_PerformanceCollection.Flush(performance);
return(Task.CompletedTask);
}
public RegularTicket(IPerformance performance)
: base(performance, TicketType.Regular)
{
}
public VIPticket(IPerformance performance)
: base(performance, TicketType.VIP)
{
}
public StudentTicket(IPerformance performance)
: base(performance, TicketType.Student)
{
}
public StudentTicket(IPerformance performancee)
: base(performancee, TicketType.Student)
{
}
protected void InsertPerformance(IPerformance performance)
{
this.performances.Add(performance);
}
public StudentTicket(IPerformance performance)
: base(performance, TicketType.Student)
{
this.Price = performance.BasePrice * TicketDiscount;
}
private int GetSoldTickets(IPerformance performance)
{
var tickets = performance.Tickets.Count(x => x.Status == TicketStatus.Sold);
return tickets;
}
public VipTicket(IPerformance performance)
: base(performance, TicketType.VIP)
{
this.Price = performance.BasePrice * TicketDiscount;
}
public VipTicket(IPerformance performance)
: base(performance, TicketType.VIP)
{
}