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.ConstDnsResolver, e);
}
return(result);
}
/*
* WriteToPrimeDnsMap() inserts a given row data into PrimeDNSMap Table.
*/
public static void WriteToPrimeDnsMap(PrimeDnsMapRow pMapRowToBeInserted)
{
PrimeDns.Semaphore.Wait();
var insertSql = "Insert into " + AppConfig.ConstTableNamePrimeDnsMap +
$" ( HostName, IPAddressList, LastUpdatedTime, LastCheckedTime, TimeToLiveInSeconds) values (\"{pMapRowToBeInserted.HostName}\", \"{pMapRowToBeInserted.GetStringOfIpAddressList()}\", \"{pMapRowToBeInserted.LastUpdatedTime}\", \"{pMapRowToBeInserted.LastCheckedTime}\", {pMapRowToBeInserted.TimeToLiveInSeconds})";
try
{
var query = SqliteConnect.ExecuteNonQuery(insertSql, _mapConnectionString);
//PrimeDns.logger._LogInformation("Data inserted into PrimeDNSMap table successfully", Logger.CSqliteExecuteNonQuery, null);
}
catch (Exception error)
{
PrimeDns.Log._LogError("Error occured while inserting data into PrimeDNSMap table", Logger.ConstSqliteExecuteNonQuery, error);
}
PrimeDns.Semaphore.Release();
}
/*
* UpdatePrimeDnsMapRow() updates the row containing the mentioned hostName to newly passed values in PrimeDNSMap Table.
*/
private static void UpdateLastCheckedTime(PrimeDnsMapRow pUpdatedMapRow)
{
PrimeDns.Semaphore.Wait();
var updateCommand = "UPDATE " + AppConfig.ConstTableNamePrimeDnsMap +
$" SET LastCheckedTime=\"{pUpdatedMapRow.LastCheckedTime}\" " +
$" WHERE HostName=\"{pUpdatedMapRow.HostName}\"";
try
{
var query = SqliteConnect.ExecuteNonQuery(updateCommand, _mapConnectionString);
//PrimeDns.logger._LogInformation("Updated PrimeDNSMap table successfully", Logger.CSqliteExecuteNonQuery, null);
}
catch (Exception error)
{
PrimeDns.Log._LogError("Error occured while updating PrimeDNSMap table for Last Checked Time", Logger.ConstSqliteExecuteNonQuery, error);
}
PrimeDns.Semaphore.Release();
}
/*
* CreatePrimeDnsMap() creates the table PrimeDNSMap,
* And also inserts the resolved DNS Data for all the valid domain names from Domains.json into this table.
*/
internal static async Task CreatePrimeDnsMap()
{
var isPrimeDnsMapPresent = SqliteConnect.IsTablePresent(AppConfig.ConstTableNamePrimeDnsMap, _mapConnectionString);
if (isPrimeDnsMapPresent)
{
PrimeDns.Log._LogWarning("PrimeDNSMap Table present in DB, dropping it and creating again.", Logger.ConstPrimeDnsStateIntegrity, null);
SqliteConnect.DropTable(AppConfig.ConstTableNamePrimeDnsMap, _mapConnectionString);
}
CreateTable_PrimeDNSMap();
UpdatePrimeDnsState(AppConfig.ConstPrimeDnsMapCreated, 1);
UpdatePrimeDnsState(AppConfig.ConstPrimeDnsMapUpdated, 1);
var criticalDomains = PrimeDns.DomainsConfig.GetCriticalDomains();
if (criticalDomains == null)
{
return;
}
var source = new CancellationTokenSource();
PrimeDns.DnsResolverCancellationToken = source.Token;
var tasks = new List <Task <Tuple <PrimeDnsMapRow, bool> > >();
foreach (string domain in criticalDomains)
{
if (DomainsConfig.IsDomainNameValid(domain))
{
var mapRow = new PrimeDnsMapRow(domain);
tasks.Add(DoWorkAsync(mapRow, PrimeDns.DnsResolverCancellationToken));
}
else
{
PrimeDns.Log._LogWarning("Invalid Domain Name - " + domain + " Found in File!", Logger.ConstDomainsWatcher, null);
Telemetry.Telemetry.PushDnsCallsData(domain, "Failure", "InvalidDomain", 0, 0, "INVALID-DOMAIN");
}
if (tasks.Count < PrimeDns.Config.ParallelDnsCallsLimit)
{
continue;
}
foreach (var(item1, item2) in await Task.WhenAll(tasks))
{
if (item2)
{
WriteToPrimeDnsMap(item1);
//Console.WriteLine("Ending Dns Resolver {0}", task.Item1.HostName);
}
else
{
PrimeDns.Log._LogInformation("Failure in adding New Domain to PrimeDNSMap " + item1.HostName, Logger.ConstDomainsWatcher, null);
try
{
if (!PrimeDns.DomainsConfig.DomainYetToBeAddedToMap[item1.HostName])
{
PrimeDns.DomainsConfig.DomainYetToBeAddedToMap[item1.HostName] = true;
}
}
catch (KeyNotFoundException)
{
PrimeDns.DomainsConfig.DomainYetToBeAddedToMap.Add(item1.HostName, true);
}
}
}
tasks.Clear();
}
if (tasks.Count > 0)
{
foreach (var(item1, item2) in await Task.WhenAll(tasks))
{
if (item2)
{
WriteToPrimeDnsMap(item1);
//Console.WriteLine("Ending Dns Resolver {0}", task.Item1.HostName);
}
else
{
PrimeDns.Log._LogInformation("Failure in adding New Domain to PrimeDNSMap " + item1.HostName, Logger.ConstDomainsWatcher, null);
try
{
if (!PrimeDns.DomainsConfig.DomainYetToBeAddedToMap[item1.HostName])
{
PrimeDns.DomainsConfig.DomainYetToBeAddedToMap[item1.HostName] = true;
}
}
catch (KeyNotFoundException)
{
PrimeDns.DomainsConfig.DomainYetToBeAddedToMap.Add(item1.HostName, true);
}
}
}
tasks.Clear();
}
PrimeDns.Log._LogInformation("WriteToPrimeDNSMap Successful", Logger.ConstSqliteExecuteNonQuery, null);
}
/*
* UpdatePrimeDnsMap() goes through all those rows of PrimeDNSMap whose TTL is less than the set threshold
* The row gets updated by calling DNS Resolver only if
* Host Name is valid and critical, the other cases are logged.
* If Host Name found in Map is no more critical, that row is deleted from the table.
*/
private static async Task UpdatePrimeDnsMap()
{
PrimeDns.Log._LogInformation("UpdatePrimeDNSMap Started", Logger.ConstStartUp, null);
var selectCommand = "Select * from " + AppConfig.ConstTableNamePrimeDnsMap;
var tasks = new List <Task <Tuple <PrimeDnsMapRow, bool> > >();
var hostNamesToBeDeleted = new List <string>();
using (var connection = new SqliteConnection(_mapConnectionString))
{
connection.Open();
var source = new CancellationTokenSource();
PrimeDns.DnsResolverCancellationToken = source.Token;
using (var c = new SqliteCommand(selectCommand, connection))
{
using (var query = c.ExecuteReader())
{
while (query.Read())
{
var d = query.GetDateTime(3).AddSeconds(query.GetInt32(4) + PrimeDns.Config.TimeToLiveThresholdInSeconds);
if (d > DateTime.Now)
{
continue;
}
var hostName = query.GetString(0);
//Console.WriteLine(hostName);
try
{
var isHostNameCritical = PrimeDns.DomainsConfig.IsDomainCritical[hostName];
if (isHostNameCritical && DomainsConfig.IsDomainNameValid(hostName))
{
var updatedMapRow = new PrimeDnsMapRow(hostName);
updatedMapRow.GetIpAddressListOfString(query.GetString(1));
updatedMapRow.LastCheckedTime = query.GetDateTime(2);
updatedMapRow.LastUpdatedTime = query.GetDateTime(3);
updatedMapRow.TimeToLiveInSeconds = query.GetInt32(4);
tasks.Add(DoWorkAsync(updatedMapRow, PrimeDns.DnsResolverCancellationToken));
}
if (!DomainsConfig.IsDomainNameValid(hostName))
{
PrimeDns.Log._LogWarning("Invalid Domain Name Found in Map!", Logger.ConstDomainsWatcher, null);
hostNamesToBeDeleted.Add(hostName);
}
if (!isHostNameCritical)
{
PrimeDns.Log._LogInformation("Dictionary having a FALSE entry!!!!? " + hostName, Logger.ConstDomainsWatcher, null);
}
}
catch (KeyNotFoundException)
{
PrimeDns.Log._LogInformation("Removed the old Domain from PrimeDNSMap " + hostName, Logger.ConstDomainsWatcher, null);
hostNamesToBeDeleted.Add(hostName);
}
}
/*
* if (tasks.Count > PrimeDns.Config.ParallelDnsCallsLimit)
* {
* foreach (var task in await Task.WhenAll(tasks))
* {
* if (task.Item2)
* {
* UpdatePrimeDnsMapRow(task.Item1);
* //Console.WriteLine("Ending Dns Resolver {0}", task.Item1.HostName);
* }
* }
* tasks.Clear();
* }
*/
}
}
connection.Close();
GC.Collect();
GC.WaitForPendingFinalizers();
}
if (tasks.Count > 0)
{
var isMapUpdated = false;
foreach (var(item1, item2) in await Task.WhenAll(tasks))
{
if (item2)
{
UpdatePrimeDnsMapRow(item1);
isMapUpdated = true;
//Console.WriteLine("Ending Dns Resolver {0}", task.Item1.HostName);
}
else
{
UpdateLastCheckedTime(item1);
}
}
tasks.Clear();
if (isMapUpdated)
{
UpdatePrimeDnsState(AppConfig.ConstPrimeDnsMapUpdated, 1);
}
}
if (hostNamesToBeDeleted.Count > 0)
{
foreach (var s in hostNamesToBeDeleted)
{
DeletePrimeDnsMapRow(s);
}
hostNamesToBeDeleted.Clear();
UpdatePrimeDnsState(AppConfig.ConstPrimeDnsMapUpdated, 1);
}
PrimeDns.Log._LogInformation("Updated PrimeDNSMap table successfully", Logger.ConstSqliteExecuteNonQuery, null);
}
