private static async Task <Tuple <PrimeDnsMapRow, bool> > DoWorkAsync(PrimeDnsMapRow pMapRow, CancellationToken pToken) { var result = Tuple.Create(pMapRow, false); try { result = await DnsResolver.DnsResolve(pMapRow, pToken); } catch (Exception e) { PrimeDns.Log._LogError("DoWorkAsync in Map Updater caused EXCEPTION!", Logger.Logger.ConstDnsResolver, e); } return(result); }
private static async Task <Tuple <PrimeDnsMapRow, bool> > DoWorkAsync(PrimeDnsMapRow pMapRow) { var result = Tuple.Create(pMapRow, false); try { result = await TimeToLiveResolver.TtlResolve(pMapRow); } catch (Exception e) { PrimeDns.Log._LogError("DoWorkAsync in TTL Updater caused EXCEPTION!", Logger.Logger.ConstTtlUpdater, e); } return(result); }
public static async Task <Tuple <PrimeDnsMapRow, bool> > TtlResolve(PrimeDnsMapRow pMapRow) { var request = new ClientRequest(PrimeDns.Config.DnsResolver); // Requesting NS for the domain request.Questions.Add(new Question(Domain.FromString(pMapRow.HostName), RecordType.NS)); request.RecursionDesired = false; var ttl = 300; try { var response = await request.Resolve(); // Get all the NS for the domain IList <IPAddress> nameServers = response.AnswerRecords .Where(r => r.Type == RecordType.NS) .Cast <IPAddressResourceRecord>() .Select(r => r.IPAddress) .ToList(); foreach (var ip in nameServers) { var ttlRequest = new ClientRequest(ip); // Requesting NS for the domain ttlRequest.Questions.Add(new Question(Domain.FromString(pMapRow.HostName), RecordType.A)); ttlRequest.RecursionDesired = false; var ttlResponse = await ttlRequest.Resolve(); var recordList = ttlResponse.AnswerRecords; ttl = recordList.Select(r => r.TimeToLive.Seconds).Concat(new[] { ttl }).Min(); } //PrimeDns.Log._LogInformation("Ttl Resolved successfully for Domain - " + pMapRow.HostName, Logger.Logger.CDnsResolver, null); Telemetry.Telemetry.PushDnsCallsData(pMapRow.HostName, "Success", "TtlResolver", 0, 0, "SUCCESS"); pMapRow.TimeToLiveInSeconds = ttl; return(Tuple.Create(pMapRow, true)); } catch (Exception e) { PrimeDns.Log._LogError("Error occured while Ttl resolution for Domain - " + pMapRow.HostName, Logger.Logger.ConstDnsResolver, e); Telemetry.Telemetry.PushDnsCallsData(pMapRow.HostName, "Failure", "TtlResolver", 0, 0, e.Message); return(Tuple.Create(pMapRow, false)); } }
public void TestDnsResolveServFail() { /* * The following assignments is made to trigger the constructor of PrimeDNS class. It won't work without that. */ var primeDns = new PrimeDns(); var mapRow = new PrimeDnsMapRow("www.dev5-bing-int1.com"); var result = Tuple.Create(mapRow, false); var source = new CancellationTokenSource(); var token = source.Token; try { result = DnsResolver.DnsResolve(mapRow, token).Result; } catch (Exception e) { throw new AssertFailedException(e.Message); } Assert.IsFalse(result.Item2); }
public static async Task <Tuple <PrimeDnsMapRow, bool> > DnsResolve(PrimeDnsMapRow pMapRow, CancellationToken pToken) { var newlyAddedIpAddressCount = 0; var removedIpAddressCount = 0; var isChanged = false; var lookup = new LookupClient { UseCache = false }; try { var ipToBeAdded = new List <IPAddress>(); var result = await lookup.QueryAsync(pMapRow.HostName, QueryType.A, QueryClass.IN, pToken); if (result.Header.ResponseCode == DnsHeaderResponseCode.NoError) { pMapRow.LastCheckedTime = DateTime.Now; var records = result.Answers.ARecords().Distinct(); var aRecords = records.ToList(); foreach (var ar in from ar in aRecords let flag = Enumerable.Contains(pMapRow.IpAddressList, ar?.Address) where !flag select ar) { ipToBeAdded.Add(ar?.Address); pMapRow.LastUpdatedTime = DateTime.Now; newlyAddedIpAddressCount++; } var ipToBeRemoved = new List <IPAddress>(); foreach (var ip in pMapRow.IpAddressList) { var flag = aRecords.Any(ar => ip.Equals(ar?.Address)); if (flag) { continue; } ipToBeRemoved.Add(ip); pMapRow.LastUpdatedTime = DateTime.Now; removedIpAddressCount++; } foreach (var i in ipToBeAdded) { pMapRow.IpAddressList.Add(i); } foreach (var i in ipToBeRemoved) { pMapRow.IpAddressList.Remove(i); } Telemetry.Telemetry.PushDnsCallsData(pMapRow.HostName, "Success", "DnsResolver", newlyAddedIpAddressCount, removedIpAddressCount, "SUCCESS"); //PrimeDns.Log._LogInformation("Dns Resolver successful for domain - " + pMapRow.HostName, Logger.Logger.CDnsResolver, null); } else { PrimeDns.Log._LogError("Dns Resolver Failed for domain - " + pMapRow.HostName + "With Error " + result.Header.ResponseCode.ToString(), Logger.Logger.ConstDnsResolver, null); Telemetry.Telemetry.PushDnsCallsData(pMapRow.HostName, "Success", "DnsResolver", newlyAddedIpAddressCount, removedIpAddressCount, result.Header.ResponseCode.ToString()); //PrimeDns.Log._LogInformation("Dns Resolver successful for domain with a non NoError Response Code - " + pMapRow.HostName, Logger.Logger.CDnsResolver, null); } } catch (Exception e) { PrimeDns.Log._LogError("Dns Resolver Failed for domain - " + pMapRow.HostName, Logger.Logger.ConstDnsResolver, e); Telemetry.Telemetry.PushDnsCallsData(pMapRow.HostName, "Failure", "DnsResolver", newlyAddedIpAddressCount, removedIpAddressCount, e.Message); } if (newlyAddedIpAddressCount + removedIpAddressCount > 0) { isChanged = true; } return(Tuple.Create(pMapRow, isChanged)); }
/* * AddNewEntriesToPrimeDnsMap() goes through _criticalDomains, * for each domain name, it checks whether it still exists in IsDomainCritical Dictionary, * if yes and it's value is true, it means the domain name is not a new entry, so nothing to be done. * if yes and it's value is false, it is absurd as no function marks them false and hence this is logged. * if no, then it's a new entry, * if the Domain Name is valid, * DNS Resolver is called and the result is written to PrimeDNSMap, * isDomainCritical() updated. * if Domain Name is invalid, it's logged as a warning. */ private async Task AddNewEntriesToPrimeDnsMap() { var tasks = new List <Task <Tuple <PrimeDnsMapRow, bool> > >(); var source = new CancellationTokenSource(); PrimeDns.DnsResolverCancellationToken = source.Token; foreach (string domain in _criticalDomains) { try { var value = IsDomainCritical[domain]; if (!value) { PrimeDns.Log._LogInformation("Dictionary having a FALSE entry!!!!? " + domain, Logger.Logger.ConstDomainsWatcher, null); } } catch (KeyNotFoundException) { if (IsDomainNameValid(domain)) { var mapRow = new PrimeDnsMapRow(domain); tasks.Add(DoWorkAsync(mapRow, PrimeDns.DnsResolverCancellationToken)); } else { PrimeDns.Log._LogWarning("Invalid Domain Name Found in File!", Logger.Logger.ConstDomainsWatcher, null); Telemetry.Telemetry.PushDnsCallsData(domain, "Failure", "InvalidDomain", 0, 0, "INVALID-DOMAIN"); } /* * if (tasks.Count > PrimeDns.Config.ParallelDnsCallsLimit) * { * foreach (var task in await Task.WhenAll(tasks)) * { * if (task.Item2) * { * MapUpdater.WriteToPrimeDnsMap(task.Item1); * IsDomainCritical.Add(domain, true); * PrimeDns.Log._LogInformation("Added the New Domain to PrimeDNSMap " + domain, Logger.Logger.CDomainsWatcher, null); * //Console.WriteLine("Ending Dns Resolver {0}", task.Item1.HostName); * } * } * tasks.Clear(); * } */ } } if (tasks.Count > 0) { var isMapUpdated = false; foreach (var(item1, item2) in await Task.WhenAll(tasks)) { if (item2) { try { if (DomainYetToBeAddedToMap[item1.HostName]) { PrimeDns.Log._LogInformation(" New Domain successfully added to PrimeDNSMap " + item1.HostName, Logger.Logger.ConstDomainsWatcher, null); DomainYetToBeAddedToMap.Remove(item1.HostName); } } catch (KeyNotFoundException) { PrimeDns.Log._LogInformation("Added the New Domain to PrimeDNSMap " + item1.HostName, Logger.Logger.ConstDomainsWatcher, null); } MapUpdater.WriteToPrimeDnsMap(item1); IsDomainCritical.Add(item1.HostName, true); isMapUpdated = true; //Console.WriteLine("Ending Dns Resolver {0}", task.Item1.HostName); } else { PrimeDns.Log._LogInformation("Failure in adding New Domain to PrimeDNSMap " + item1.HostName, Logger.Logger.ConstDomainsWatcher, null); try { if (!DomainYetToBeAddedToMap[item1.HostName]) { DomainYetToBeAddedToMap[item1.HostName] = true; } } catch (KeyNotFoundException) { DomainYetToBeAddedToMap.Add(item1.HostName, true); } } } tasks.Clear(); if (isMapUpdated) { MapUpdater.UpdatePrimeDnsState(AppConfig.ConstPrimeDnsMapUpdated, 1); } } }
internal async Task UpdateTimeToLive() { var selectCommand = string.Format("Select * from " + AppConfig.ConstTableNamePrimeDnsMap); var tasks = new List <Task <Tuple <PrimeDnsMapRow, bool> > >(); var ttlUpdateList = new List <PrimeDnsMapRow>(); using (var connection = new SqliteConnection(_mapConnectionString)) { connection.Open(); using (var c = new SqliteCommand(selectCommand, connection)) { using (var query = c.ExecuteReader()) { while (query.Read()) { var hostName = query.GetString(0); var timeToLive = query.GetInt32(4); if (DomainsConfig.IsDomainNameValid(hostName)) { var updatedMapRow = new PrimeDnsMapRow(hostName); tasks.Add(DoWorkAsync(updatedMapRow)); } if (tasks.Count > PrimeDns.Config.ParallelTtlCallsLimit) { foreach (var(item1, item2) in await Task.WhenAll(tasks)) { if (item2) { ttlUpdateList.Add(item1); //Console.WriteLine("Ending Ttl Resolver {0}", task.Item1.HostName); } else { PrimeDns.TtlUpdaterErrorCount++; } } tasks.Clear(); } if (PrimeDns.TtlUpdaterErrorCount >= PrimeDns.Config.TtlUpdaterErrorLimit) { PrimeDns.Log._LogWarning("TOO MANY ERRORS IN TTL UPDATER!! Breaking..", Logger.Logger.ConstTtlUpdater, null); break; } } } } connection.Close(); GC.Collect(); GC.WaitForPendingFinalizers(); } if (tasks.Count > 0) { foreach (var(item1, item2) in await Task.WhenAll(tasks)) { if (item2) { ttlUpdateList.Add(item1); //Console.WriteLine("Ending Ttl Resolver {0}", task.Item1.HostName); } } tasks.Clear(); } if (ttlUpdateList.Count > 0) { foreach (var mapElement in ttlUpdateList) { UpdatePrimeDnsMapRow(mapElement.HostName, mapElement.TimeToLiveInSeconds); } } }