/// <summary>
        /// Execute Sensor data retention
        /// </summary>
        public static bool Retention(IKLog klog)
        {
            if (Configuration.Worker)
            {
                klog.Trace($"Worker Detected.");

                DataRetention.Execute();
            }

            return(true);
        }
        /// <summary>
        /// Upload all Sensor Capsule records to Azure SQL Server.
        /// </summary>
        /// <param name="capsule"></param>
        public static void Execute(IKLog klog, Capsule capsule)
        {
            try
            {
                string result = AddRecords.Insert(capsule.GenerateSQLRecords(klog));

                if (!string.IsNullOrEmpty(result) && result.Contains("Result: True"))
                {
                    klog.Trace($"{result}");
                }
                else
                {
                    klog.Error($"Capsule Upload Failure: {result}");
                }
            }
            catch (Exception ex)
            {
                klog.Error($"UploadCapsule::Execute | {ex}");
            }
        }
        /// <summary>
        /// Evaluate IP address for match on a known provided region.
        /// </summary>
        /// <param name="capsule"></param>
        public static void Execute(IKLog klog, ref Capsule capsule)
        {
            foreach (var article in capsule.DNSRecords)
            {
                var dnsConfig = article.DNSConfiguration;
                var ips       = article.IPRecords;

                try
                {
                    foreach (var ipRecord in ips)
                    {
                        var ipString = ipRecord.IP.ToString();

                        if (ipRecord.IPStatus == "OFFLINE")
                        {
                            ipRecord.Datacenter    = "ERROR";
                            ipRecord.DatacenterTag = "ERR";

                            break;
                        }

                        // Check if configuration data exsits and deserialize
                        if (dnsConfig.Contains(Configuration.IpAddress))
                        {
                            var jsonObject = JsonConvert.DeserializeObject <List <EndpointRecord> >(dnsConfig);

                            // Match IPAddress with Data Center
                            ipRecord.Datacenter    = jsonObject.Where(x => x.IpAddress == ipString).Select(x => x.DataCenter).FirstOrDefault();
                            ipRecord.DatacenterTag = jsonObject.Where(x => x.IpAddress == ipString).Select(x => x.DataCenterTag).FirstOrDefault();

                            // Set sensor with Data Center
                            ipRecord.IPStatus = Configuration.StatusOnline;
                        }
                        else
                        {
                            if (dnsConfig.Contains("empty"))
                            {
                                klog.Error($"DNS Config is missing");
                            }
                            else
                            {
                                klog.Error($"DNS Config is malformed");
                            }

                            ipRecord.Datacenter    = Configuration.UnknownDataCenter;
                            ipRecord.DatacenterTag = Configuration.UnknownDataCenterTag;
                        }

                        if (ipRecord.Datacenter == null)
                        {
                            ipRecord.Datacenter    = Configuration.UnknownDataCenter;
                            ipRecord.DatacenterTag = Configuration.UnknownDataCenterTag;
                        }

                        klog.Trace($"DNS: {article.DNSName} IP: {ipRecord.IP} Datacenter: {ipRecord.Datacenter} Tag: {ipRecord.DatacenterTag}");
                    }
                }
                catch (Exception e)
                {
                    klog.Error($"TagIPAddress - Excepection: {e}");
                }
            }
        }
Esempio n. 4
0
        /// <summary>
        /// TCP Ping IPV4 IP for latency.
        /// </summary>
        /// <param name="capsule"></param>
        public static void Execute(IKLog klog, ref Capsule capsule)
        {
            // TODO: Hard code loop size, in future allow for use config. Add logic to check loop count, and check if it's above 3, otherwise enforce 3.
            // 3 because, remove 1 min, remove 1 max, atleast one remains as "base" value.
            foreach (var article in capsule.DNSRecords)
            {
                klog.Trace($"DNS: {article.DNSName}");
                var ips = article.IPRecords;

                try
                {
                    foreach (var ip in ips)
                    {
                        TCPRecord tcpRecord = new TCPRecord();

                        var ipString = ip.IP.ToString();

                        if (ip.IPStatus == "OFFLINE")
                        {
                            tcpRecord.SetOffline();

                            ip.TCPRecord = tcpRecord;

                            break;
                        }

                        uint       ipUint     = BitConverter.ToUInt32(System.Net.IPAddress.Parse(ipString).GetAddressBytes(), 0);
                        IPEndPoint ipEndpoint = new IPEndPoint(ipUint, 443);

                        var latencyList = new List <double>();
                        for (int i = 0; i < 4; i++)
                        {
                            var sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                            sock.Blocking = true;

                            var stopwatch = new Stopwatch();

                            // Measure the Connect call only
                            stopwatch.Start();
                            sock.Connect(ipEndpoint);
                            stopwatch.Stop();

                            double t = stopwatch.Elapsed.TotalMilliseconds;
                            latencyList.Add(t);

                            sock.Close();

                            Thread.Sleep(1000);
                        }

                        // logic to remove min and max, avg the rest
                        klog.Trace($"IP: {ipString} Min: {latencyList.Min()}");
                        latencyList.Remove(latencyList.Min());

                        klog.Trace($"IP: {ipString} Max: {latencyList.Max()}");
                        latencyList.Remove(latencyList.Max());

                        klog.Trace($"IP: {ipString} Avg: {latencyList.Average()}");
                        var avgLatency = latencyList.Average();

                        // Add Avg Latency to the IPRecord
                        tcpRecord.Latency = avgLatency;
                        tcpRecord.Port    = "443";

                        ip.TCPRecord = tcpRecord;
                    }
                }
                catch (Exception e)
                {
                    klog.Error($"GetTCPLatency - Exception: {e.ToString()}");
                }
            }
        }