NPRG042 Programming in Parallel Environment [2021/22]

Assignment 1

---

---

The objective is to write recursive DNS resolver in C# .NET Core using already implemented methods for individual DNS queries. Of course, all network operations will be simulated by mocks. And since the DNS resolving is rather complex, we have simplified it significantly for the purposes of this assignment:

• Each known domain has exactly 1 IPv4 address. Different domains have different addresses.
• There is no difference between the server and its nameserver (we do not recognize individual record types like A, NS, CNAME...).
• Server holding domain X is the only authority which can answer queries for immediate sub-domains of X (i.e., if one needs to resolve mff.cuni.cz, one must first resolve cuni.cz and then ask it for address of mff).
• Root servers are well known (you will get a list of IPs).
• There is no additional trickery (like CNAMEs), domains are simple identifiers separated by dots.

Your implementation will get an object implementing IDNSClient interface. The interface will provide the following methods:

• IReadOnlyList<IP4Addr> GetRootServers() -- will give you the list IPs of root servers
• Task<IP4Addr> Resolve(IP4Addr server, string subDomain) -- perform single resolving (you can ask specific server for immediate subdomain)
• Task<string> Reverse(IP4Addr server) -- performs reverse translation (will give you full domain name of IP address); this might be handy if you implement some sort of cache and you need to quickly find out whether an IP address is still valid

Your job is to implement class with IRecursiveResolver interface, which has only one method -- Task<IP4Addr> ResolveRecursive(string domain). This method gets full domain name and yields its address. File Serial.cs holds trivial implementation of the resolver. Your codes goes into Solution.cs file, which is also the only file you should submit.

All the interfaces yield Tasks, which might suggest a course of action. Besides low-level tasks, you may also employ async/await approach. The main objective is to use parallelism to lower (average) query latency and increase throughput.

We would suggest implementing the following optimizations: First, when two similar queries are executed simultaneously (e.g., mff.cuni.cz and ff.cuni.cz) the common part may be resolved only once. It can save time by saving resources and it may reduce latency of the query which was started later. Second, you may use whatever caching you deem necessary, but beware that the addresses may change in time. Therefore, you need to verify data from cache (e.g., by reverse translation) before yielding the result.

On the other hand, it is expected that you will not employ any hacking techniques or aggressive methods that might work in real world. E.g., you are forbidden from trying guessing IP addresses of server or scanning the entire IP range.

Your solution will be tested on .NET Core 6.0 (which is both in ReCodEx and on Parlab). The initial solution is in /home/_teaching/para/01-dns-netcore or you may simply download it here. You may compile it using dotnet command:

$> dotnet build -c Release ./dns-netcore.sln

The compiled binary will appear in ./bin subdir.

Please note that ReCodEx is only a first-instance verification. You solution will be subjected to performance evaluation on Parlab after the deadline (all solutions are collected and tested together).