Closes #33

This PR converts the SocketServer to supporting async requests by implementing a thread pool and processing each new socket connection on a new thread.

For context, our communication model creates a new connection for each request/response, thus for each request/response we create a new job on a thread and the job finishes once the request is returned.

Why make the server async

• Do not block on 1 request. For example we may want to query the enclave health while a proxy request to the secure app is still processing.
• Take load off the socket by minimizing connection queue size - the OS can handle a finite of requests to connect. The more requests the application layer (think socket server) can accept, the more we can reduce rejected connection requests

Given these goals, pure performance is not the main concern but instead we mainly want to focus on making ours server non-blocking while aligning with our security goals of robust and easy to audit code.

Why a thread pool?

When I set out I originally intended to use async Rust code, which does not necessarily imply multithreading but just that code can be executed in a non-blocking way. In order to run async code in Rust you need an executor (example), which is not provided by the standard library. Note that executors can be both multithreaded and non blocking on a single thread.

There are several popular executors, but the most popular today is probably: https://github.com/tokio-rs/tokio, which implements an async runtime. From what I understand the internals of tokio is quite complex and appears to be a significant review burden.

There are some other options for executors, the simples of which appears to be the futures crate thread pool executor. futures is an extremely popular crate as it provides many of the shared primitive types used across async runtimes in the Rust ecosystem. However, my thinking here is that we can avoid futures all together by implementing our own thread pool.

Relevant reading

• Thread pool impl in the rust book, which this thread pool is based on - https://doc.rust-lang.org/book/ch20-02-multithreaded.html
• Shared stated concurrency - https://doc.rust-lang.org/book/ch16-03-shared-state.html
• Primer async rust - https://rust-lang.github.io/async-book/01_getting_started/03_state_of_async_rust.html