EndpointStatistics.cs

using System;
using System.Collections.Generic;
 
namespace Waher.Networking.XMPP.Server.Statistics
{
    public class EndpointStatistics
    {
        private readonly List<IEndpoint> endpoints = new List<IEndpoint>();
        private readonly object synchObj = new object();
        private readonly string name;
        private readonly string type;
        private DateTime lastConnect = DateTime.MinValue;
        private DateTime lastDisconnect = DateTime.MinValue;
        private long sumConnectionTimeMilliseconds = 0;
        private long nrConnectionTimes = 0;
        private volatile int connectionCount = 0;
 
        public EndpointStatistics(string Name, string Type)
        {
            this.name = Name;
            this.type = Type;
        }
 
        public void EndpointConnected(IEndpoint Endpoint)
        {
            lock (this.synchObj)
            {
                if (!this.endpoints.Contains(Endpoint))
                {
                    if (this.connectionCount == 0)
                        this.lastConnect = DateTime.Now;
 
                    this.endpoints.Add(Endpoint);
                    this.connectionCount++;
                }
            }
        }
 
        public void EndpointDisconnected(IEndpoint Endpoint, long ConnectionTimeMilliseconds)
        {
            lock (this.synchObj)
            {
                if (this.endpoints.Remove(Endpoint))
                {
                    this.sumConnectionTimeMilliseconds += ConnectionTimeMilliseconds;
                    this.nrConnectionTimes++;
 
                    if (this.connectionCount > 0)
                    {
                        this.connectionCount--;
                        if (this.connectionCount == 0)
                            this.lastDisconnect = DateTime.Now;
                    }
                }
            }
        }
 
        public string Name => this.name;
 
        public string Type => this.type;
 
        public IEndpoint[] Endpoints
        {
            get
            {
                lock (this.synchObj)
                {
                    return this.endpoints.ToArray();
                }
            }
        }
 
        public IEndpoint Endpoint
        {
            get
            {
                lock (this.synchObj)
                {
                    if (this.endpoints.Count == 0)
                        return null;
                    else
                        return this.endpoints[0];
                }
            }
        }
 
        public DateTime LastConnect => this.lastConnect;
 
        public DateTime LastDisconnect => this.lastDisconnect;
 
        public int ActiveConnectionCount => this.connectionCount;
 
        public bool Connected => this.connectionCount > 0;
 
        public long TotalConnectionCount
        {
            get
            {
                lock (this.synchObj)
                {
                    return this.nrConnectionTimes + this.connectionCount;
                }
            }
        }
 
        public double? AvgConnectionTimeSeconds
        {
            get
            {
                lock (this.synchObj)
                {
                    if (this.nrConnectionTimes == 0)
                        return null;
 
                    double x = this.sumConnectionTimeMilliseconds;
                    x /= this.nrConnectionTimes;
                    x /= 1000;
 
                    return x;
                }
            }
        }
 
        public string AvgConnectionTime
        {
            get
            {
                double? d = this.AvgConnectionTimeSeconds;
                if (!d.HasValue)
                    return string.Empty;
 
                return ToStr(d.Value);
            }
        }
 
        private static string ToStr(double x)
        {
            if (x < 60)
                return x.ToString("F0") + " s";
            else
            {
                x /= 60;
 
                if (x < 60)
                    return x.ToString("F1") + " min";
                else
                {
                    x /= 60;
 
                    if (x < 24)
                        return x.ToString("F1") + " h";
                    else
                    {
                        x /= 24;
                        return x.ToString("F1") + " days";
                    }
                }
            }
        }
 
        public double? CurrentConnectionTimeSeconds
        {
            get
            {
                lock (this.synchObj)
                {
                    if (this.connectionCount == 0)
                        return null;
 
                    return (DateTime.Now - this.lastConnect).TotalSeconds;
                }
            }
        }
 
        public string CurrentConnectionTime
        {
            get
            {
                double? d = this.CurrentConnectionTimeSeconds;
                if (!d.HasValue)
                    return string.Empty;
 
                return ToStr(d.Value);
            }
        }
 
    }
}