Rust Bite - Abstractions

Abstractions are simpified representations of complex entities, things that are composed of many detailed parts and processing. Large software systems may be composed of hundreds of thousands, even millions, of lines of source code. Much more than any developer can understand completely. In order to use and maintain these systems a developer needs to have some way of understanding their properties and expected operations. Most often we factor systems into components that are small enough to be well understood and visualize the complete system as couplings of these smaller components. Often the components themselves may be decomposed into fundamental parts. An abstraction consists of a set of components with specified responsibilities and usually one or more diagrams That illustrate ownership and usage relationships between components.

We will use code from the RustComm repository as an Example for this discussion. RustComm is a message-passing communication system based on Tcp Sockets provided by the Rust std::net library. Figure 1. is a Universal Modeling Language (UML) class diagram that displays the most important types and traits used in the RustComm implementation. The main players are Connector<M,P,L> and Listener<P,L>. Listener<P,L> listens for incoming connection requests, extablishes a connection, and processes received messages, returning a reply for each. P is a generic parameter representing one of a set of processing types that determine what the listener does with incoming messages, and how it replies. L is a generic parameter representing one of a set of loggers used to capture processing events. Connector<M,P,L> attempts to establish connections with a listener at a specified endpoint, ipaddress:port. If a connection is established it then sends messages and receives replies. The generic arguments M, P, and L represent sets of message, processing, and logging types. Each of them are constrained by traits, some of which are shown in Fig. 1. The traits Msg, Sndr<>, Rcvr<>, Process<M> and Logger each define method signatures that types with those traits are obligated to implement. Traits say nothing about the implementation of those methods, so each trait establishes a bound on the types that the library uses.

• Msg defines methods that messages provide for managing their contents. The Msg trait was designed to support more than one style of message. RustComm uses fixed header size messages, but Msg supports other types as well.
• Sndr<M> and Rcvr<M> define method signatures for sending and receiving messages. They are parameterized on a Message type M, so they can be tailored to the type of messages a library defines.
• Process<M> declares methods for processing messages. Both Connector<M,P,L> and Listener<P,L> have process members which are different, but satisfy the same trait bounds.
• Logger defines method signatures for writing to log streams in the console or files.
• The generic parameters: M, P, and L are also bound by some of Rust's std traits, e.g., Debug, Clone, Send, Sync, and in some cases Copy, and 'static.

Connector<M,P,L> and Listener<P,L> use the TcpStream and TcpListener types to provide socet-based Tcp messaging infrastructure. Each of the four layers shown in Fig 1. have a specific role to play in RustComm's implementation:

• The top, traits, layer provides component interfaces that are implementation agnostic. That means that Connector<M,P,L> and Listener<P,L> can easily adopt different messaging and message-passing designs without a lot of breakage, because most of their code uses the trait interfaces.
• The second, generic parameter layer, supports compile-time substitution of specialized components that tailor RustComm behaviors to meet the needs of a specific design.
• The third, custom type layer, holds the connector and listener user-defined types. They provide the framework that supports and uses the first two layers. It is this layer that using code works with to build communicating processes.
• The bottom, std libary component, layer provides all of the low level system processing, greatly simplifying implementation of listener and connector.

You can access all of the code for RustComm in this Repository.

The combination of traits and generic types provides a powerful environment for building flexible systems that can adapt to changing requirements and be used to explore new design ideas. Adding selections from the well crafted Rust std libraries can lead to designs that are easy to use, understand and maintain, and modify for new uses. Highly recommended.