internal static Task <ServiceStats> ReadServiceStatsAsync(Stream inputStream)
{
using (XmlReader reader = XmlReader.Create(inputStream))
{
return(ServiceStats.FromServiceXmlAsync(XDocument.Load(reader)));
}
}
/// <summary>
/// Retrieve statistics related to replication for the Table service
/// </summary>
/// <param name="tableClient"></param>
private static async Task ServiceStatsSample(CloudTableClient tableClient)
{
Console.WriteLine();
var originalLocation = tableClient.DefaultRequestOptions.LocationMode;
Console.WriteLine("Service stats:");
try
{
tableClient.DefaultRequestOptions.LocationMode = LocationMode.SecondaryOnly;
ServiceStats stats = await tableClient.GetServiceStatsAsync();
Console.WriteLine(" Last sync time: {0}", stats.GeoReplication.LastSyncTime);
Console.WriteLine(" Status: {0}", stats.GeoReplication.Status);
}
catch (StorageException)
{
// only works on RA-GRS (Read Access – Geo Redundant Storage)
}
finally
{
// Restore original value
tableClient.DefaultRequestOptions.LocationMode = originalLocation;
}
Console.WriteLine();
}
/// <summary>
/// Class constructor.
/// </summary>
public HandlerBase(IErrorHandler errorHandler, IConfig config, ILogger logger, ServiceStats serviceStats)
{
_errorHandler = errorHandler;
_config = config;
_logger = logger;
_serviceStats = serviceStats;
}
public GenericResponse GetStarts()
{
var stats = new ServiceStats();
var users = usersColl.FindAll().ToList();
stats.UserCount = users.Count;
var now = DateTime.Now;
var lastWeekUsers = users.Where(a => (now - a.LastLaunch).Days <= 7).ToList();
stats.LastWeekUserCount = lastWeekUsers.Count();
var userGroups = lastWeekUsers.GroupBy(ver => ver.PlayniteVersion, user => user);
stats.UsersByVersion = new Dictionary <string, int>();
foreach (var userGroup in userGroups.OrderByDescending(a => a.Key))
{
stats.UsersByVersion.Add(userGroup.Key, userGroup.Count());
}
var winGroups = lastWeekUsers.GroupBy(ver => ver.WinVersion, user => user);
stats.UsersByWinVersion = new Dictionary <string, int>();
foreach (var winGroup in winGroups.OrderByDescending(a => a.Key))
{
stats.UsersByWinVersion.Add(winGroup.Key, winGroup.Count());
}
stats.X64Count = lastWeekUsers.Where(a => a.Is64Bit).Count();
stats.X86Count = lastWeekUsers.Where(a => !a.Is64Bit).Count();
return(new ServicesResponse <ServiceStats>(stats));
}
/// <summary>
/// Pings all servers to obtain their round-trips times and their high timestamps.
/// </summary>
public void PingTimestampsNow()
{
Stopwatch watch = new Stopwatch();
foreach (string server in configuration.SecondaryServers)
{
// if the server is not reached yet, we perform a dummy operation for it.
if (!replicas[server].IsContacted())
{
try
{
//we perform a dummy operation to get the rtt latency!
DateTimeOffset?serverTime = null;
long rtt;
if (server.EndsWith("-secondary") && configuration.PrimaryServers.Contains(server.Replace("-secondary", "")))
{
// get the server's last sync time from Azure
// this call only works on Azure secondaries
CloudBlobClient blobClient = ClientRegistry.GetCloudBlobClient(server);
watch.Restart();
ServiceStats stats = blobClient.GetServiceStats();
rtt = watch.ElapsedMilliseconds;
replicas[server].AddRtt(rtt);
if (stats.GeoReplication.LastSyncTime.HasValue)
{
serverTime = stats.GeoReplication.LastSyncTime.Value;
}
}
else
{
// get the server's last sync time from the container's metadata
CloudBlobContainer blobContainer = ClientRegistry.GetCloudBlobContainer(server, configuration.Name);
watch.Restart();
blobContainer.FetchAttributes();
rtt = watch.ElapsedMilliseconds;
if (blobContainer.Metadata.ContainsKey("lastsync"))
{
//if no lastmodified time is provided in the constructor, we still try to be fast.
//So, we check to see if by any chance the container previously has synchronized.
serverTime = DateTimeOffset.Parse(blobContainer.Metadata["lastsync"]);
}
}
if (serverTime.HasValue && serverTime > replicas[server].HighTime)
{
replicas[server].HighTime = serverTime.Value;
}
}
catch (StorageException)
{
// do nothing
}
}
}
}
internal static void VerifyServiceStats(ServiceStats stats)
{
Assert.IsNotNull(stats);
if (stats.GeoReplication.LastSyncTime.HasValue)
{
Assert.AreEqual(GeoReplicationStatus.Live, stats.GeoReplication.Status);
}
else
{
Assert.AreNotEqual(GeoReplicationStatus.Live, stats.GeoReplication.Status);
}
}
/// <summary>
/// Class constructor.
/// </summary>
public Heartbeat(IErrorHandler errorHandler, Config config, ILogger logger, ServiceStats serviceStats, ServiceState serviceState)
{
_errorHandler = errorHandler;
_config = config;
_logger = logger;
_serviceStats = serviceStats;
_serviceState = serviceState;
_timer = new SimpleTimer(Timer_Callback, 1000, false, true, true);
_udpClient = new UdpClient();
_endPoint = new IPEndPoint(IPAddress.Broadcast, 5002);
_configuredInterfaceNames = new HashSet <string>(_config.InterfaceNames);
_discoveredInterfaces = new List <NetworkInterface>();
}
public async Task <GenericResponse> GetStarts()
{
var now = DateTime.Now;
var stats = new ServiceStats();
await Database.Instance.Users.Find(new BsonDocument()).ForEachAsync(user =>
{
stats.UserCount++;
var activeUser = (now - user.LastLaunch).Days <= 7;
if (activeUser)
{
stats.LastWeekUserCount++;
if (stats.UsersByVersion.TryGetValue(user.PlayniteVersion, out var pC))
{
stats.UsersByVersion[user.PlayniteVersion] = pC + 1;
}
else
{
stats.UsersByVersion.Add(user.PlayniteVersion, 1);
}
if (stats.UsersByWinVersion.TryGetValue(user.WinVersion, out var wC))
{
stats.UsersByWinVersion[user.WinVersion] = wC + 1;
}
else
{
stats.UsersByWinVersion.Add(user.WinVersion, 1);
}
if (user.Is64Bit)
{
stats.X64Count++;
}
else
{
stats.X86Count++;
}
}
});
return(new ServicesResponse <ServiceStats>(stats));
}
public async Task <ContentResult> GetServiceStats()
{
DateTime requestTimestamp = DateTime.UtcNow;
IStatusCodeActionResult response;
if (!_context.Database.CanConnect()) // Проверка на доступность дб
{
response = Content("No connection to database.");
}
else
{
List <LogMetadata> allRequests = _context.Logs.ToList();
if (allRequests.Count != 0) // Проверка на наличие записей в таблице
{
double allRequestsProcessingTime = 0;
double avgRequestProcessingTime;
Dictionary <string, int> requestsPerMethod = new Dictionary <string, int>()
{
{ "GET", 0 }, { "POST", 0 }, { "DELETE", 0 }
};
foreach (LogMetadata req in allRequests)
{
allRequestsProcessingTime += req.RequestProcessingTime;
requestsPerMethod[req.RequestMethod] += 1;
}
avgRequestProcessingTime = allRequestsProcessingTime / allRequests.Count;
ServiceStats stats = new ServiceStats(Math.Round(avgRequestProcessingTime, 5), allRequests.Count, requestsPerMethod);
response = Content(JsonSerializer.Serialize(stats));
}
else
{
response = NotFound("No statistics");
}
}
await Logger.LogData(_context, Request, requestTimestamp, response);
return((ContentResult)response);
}
public GenericResponse GetStarts(string serviceKey)
{
var key = Startup.Configuration.GetSection("ServiceKey");
if (key == null || key.Value != serviceKey)
{
return(new ErrorResponse(new Exception("Invalid service key.")));
}
var stats = new ServiceStats();
var users = usersColl.FindAll().ToList();
stats.UserCount = users.Count;
var now = DateTime.Now;
var lastWeekUsers = users.Where(a => (now - a.LastLaunch).Days <= 7).ToList();
stats.LastWeekUserCount = lastWeekUsers.Count();
var userGroups = lastWeekUsers.GroupBy(ver => ver.PlayniteVersion, user => user);
stats.UsersByVersion = new Dictionary <string, int>();
foreach (var userGroup in userGroups.OrderByDescending(a => a.Key))
{
stats.UsersByVersion.Add(userGroup.Key, userGroup.Count());
}
var winGroups = lastWeekUsers.GroupBy(ver => ver.WinVersion, user => user);
stats.UsersByWinVersion = new Dictionary <string, int>();
foreach (var winGroup in winGroups.OrderByDescending(a => a.Key))
{
stats.UsersByWinVersion.Add(winGroup.Key, winGroup.Count());
}
stats.RecentUsers = lastWeekUsers.OrderBy(a => a.LastLaunch).TakeLast(20).ToList();
stats.X64Count = lastWeekUsers.Where(a => a.Is64Bit).Count();
stats.X86Count = lastWeekUsers.Where(a => !a.Is64Bit).Count();
return(new ServicesResponse <ServiceStats>(stats));
}
public ServicesResponse <ServiceStats> GetStarts(string serviceKey)
{
var key = Startup.Configuration.GetSection("ServiceKey");
if (key == null || key.Value != serviceKey)
{
return(new ServicesResponse <ServiceStats>(null, "Invalid service key."));
}
var stats = new ServiceStats();
var users = Program.DatabaseCache.GetCollection <User>(UsersCollection).FindAll().ToList();
stats.UserCount = users.Count;
var now = DateTime.Now;
stats.LastWeekUserCount = users.Where(a => (now - a.LastLaunch).Days <= 7).Count();
var userGroups = users.GroupBy(ver => ver.PlayniteVersion, user => user);
stats.UsersByVersion = new Dictionary <string, int>();
foreach (var userGroup in userGroups.OrderByDescending(a => a.Key))
{
stats.UsersByVersion.Add(userGroup.Key, userGroup.Count());
}
var winGroups = users.GroupBy(ver => ver.WinVersion, user => user);
stats.UsersByWinVersion = new Dictionary <string, int>();
foreach (var winGroup in winGroups.OrderByDescending(a => a.Key))
{
stats.UsersByWinVersion.Add(winGroup.Key, winGroup.Count());
}
stats.RecentUsers = users.OrderBy(a => a.LastLaunch).TakeLast(20).ToList();
return(new ServicesResponse <ServiceStats>(stats, string.Empty));
}
/// <summary>
/// Class constructor.
/// </summary>
public StatisticsHandler(IErrorHandler errorHandler, IConfig config, ILogger logger, ServiceStats serviceStats, List <IStatsWriter> statsWriters)
: base(errorHandler, config, logger, serviceStats)
{
_statsWriters = statsWriters;
}
/// <summary>
/// Class constructor.
/// </summary>
public ConfigHandler(IErrorHandler errorHandler, IConfig config, ILogger logger, ServiceStats serviceStats)
: base(errorHandler, config, logger, serviceStats)
{
}
/// <summary>
/// Class constructor.
/// </summary>
public GpioHandler(IErrorHandler errorHandler, IConfig config, ILogger logger, ServiceStats serviceStats, GpioManager gpio)
: base(errorHandler, config, logger, serviceStats)
{
_gpio = gpio;
}
/// <summary>
/// Starts the service.
/// </summary>
public void Start()
{
try
{
//message
_logger = Log.Instance;
_logger.WriteMessage("Service", "==========================================");
_logger.WriteMessage("Service", "Starting service..");
//start time
_startTime = DateTime.Now;
//events
Console.CancelKeyPress += Console_CancelKeyPress;
//config
_logger.WriteMessage("Service", "Loading configuration..");
IConfigurationRoot root = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("Config.json", optional: true, reloadOnChange: false)
.Build();
_config = new Config(root);
_logger.WriteMessage("Service", $"Service version is {_config.ServiceVersion}");
//init pi (if linux)
if (_config.IsLinux)
{
Pi.Init <BootstrapWiringPi>();
}
//singletons
_logger.WriteMessage("Service", "Creating support structures..");
((Log)Log.Instance).Initialize(_config.IsWindows ? "C:\\Temp\\" : "/var/log/", _config.ServiceVersion);
_errorCache = new ErrorCache(null, _config.ErrorRetention);
_errorHandler = new ErrorHandler(_errorCache, _logger);
_serviceState = new ServiceState(_errorHandler, _logger, ServiceStateType.Down);
_serviceStats = new ServiceStats(_errorHandler);
_heartbeat = new Heartbeat(_errorHandler, _config, _logger, _serviceStats, _serviceState);
_piInfo = new PiInfo(_config);
_gpio = new GpioManager(_errorHandler, _config);
//stats writers
_statsWriters.Add(_serviceState);
_statsWriters.Add(_serviceStats);
_statsWriters.Add(_gpio);
_statsWriters.Add(_piInfo);
_statsWriters.Add((IStatsWriter)_errorCache);
//start health thread
_logger.WriteMessage("Service", "Starting health thread..");
_healthThread = new Thread(Health_Thread)
{
IsBackground = true
};
_healthThread.Start();
//finish init on another thread, finish start
Task.Run(() =>
{
//start gpio loop
_gpio.Initialize();
//wait for ip assignment
WaitForIPAssignment();
//start heatbeat timer
_heartbeat.Start();
//start http listener
StartHttpListener();
});
//log start operation
_serviceStats.LogOperation("ServiceStart", DateTime.Now.Subtract(_startTime));
//wait for exit signal
_exitSignal.WaitOne();
}
catch (Exception ex)
{
if (_errorHandler != null)
{
_errorHandler.LogError(ex);
}
else
{
Console.WriteLine(ex);
}
}
}
