docker-sites-status-server/backend/SiteStatus/SiteStatus/Business/DnsBusiness.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Threading;
using System.Threading.Tasks;
using ARSoft.Tools.Net.Dns;
using Microsoft.Extensions.Options;
using SiteStatus.Dbo;

namespace SiteStatus.Business
{
    public class DnsBusiness
    {
        public SettingsDbo Options { get; }

        public DnsBusiness(IOptions<SettingsDbo> options)
        {
            Options = options.Value;
        }

        public async Task<DnsZoneStatusDbo> GetZoneStatusAsync(string zone, IEnumerable<string> servers)
        {
            var dnsStatus = new DnsZoneStatusDbo
            {
                Zone = zone,
                ServerStatus = new List<DnsZoneServerStatusDbo>()
            };

            var cancellationTokenSource = new CancellationTokenSource();
            var list = new List<KeyValuePair<string, Task<List<SoaRecord>>>>();
            var tasks = new List<Task<List<SoaRecord>>>();
            foreach (var server in servers)
            {
                try
                {
                    var resolver = new DnsStubResolver(new []{IPAddress.Parse(server)});
                    var recordsTask = resolver.ResolveAsync<SoaRecord>(zone, RecordType.Soa, RecordClass.INet, cancellationTokenSource.Token);
                    list.Add(new KeyValuePair<string, Task<List<SoaRecord>>>(server, recordsTask));
                    tasks.Add(recordsTask);
                }
                catch (Exception)
                {
                    tasks.Add(Task.FromResult<List<SoaRecord>>(null));
                }
            }

            try
            {
                var allTasks = Task.WhenAll(tasks.ToArray());
                if (await Task.WhenAny(allTasks, Task.Delay(Options.Dns.Resolve.Timeout)) == allTasks) {
                    await allTasks;
                } else {
                    cancellationTokenSource.Cancel();
                }
            }
            catch (Exception)
            {
                // Ignore, errors will be handled later
            }

            foreach (var recordResult in list)
            {
                try
                {
                    var record = recordResult.Value.Result.FirstOrDefault();
                    dnsStatus.ServerStatus.Add(new DnsZoneServerStatusDbo
                    {
                        Server = recordResult.Key,
                        Soa = record?.ToString()
                    });
                }
                catch (Exception)
                {
                    dnsStatus.ServerStatus.Add(new DnsZoneServerStatusDbo
                    {
                        Server = recordResult.Key,
                        Soa = null
                    });
                }
            }

            return dnsStatus;
        }

        public DnsStatusDbo GetDnsStatus()
        {
            var allTasks = new Dictionary<SettingsDnsViewDbo, IList<Task<DnsZoneStatusDbo>>>();
            foreach (var view in Options.Dns.Views)
            {
                var servers = view.Servers.Select(server => server.Ip).ToList();
                var tasks = view.Zones.Select(zone => GetZoneStatusAsync(zone.Name, servers)).ToArray();

                allTasks.Add(view, tasks);
            }

            Task.WaitAll(allTasks.SelectMany(x => x.Value).ToArray());

            var status = new DnsStatusDbo
            {
                Views = allTasks.Select(pair =>
                {
                    var results = pair.Value.Select(task => task.Result).ToList();

                    return new DnsStatusViewDbo
                    {
                        Name = pair.Key.Name,
                        Zones = results
                    };
                }).ToList()
            };

            return status;
        }
    }
}