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);
}
}
}
