CSE 40771 - Distributed Systems

CSE 40771 - Distributed Systems - Spring 2026

View the Project on GitHub

A3 - Remote Procedure Call

Overview

In this assignment, you will build a simple RPC server that supports access to an in-memory hash table running on a single machine. This will provide the basic capabilities that we will build upon over several assignments to work up to a distributed set of many hash tables sharing files with eachother. The focus of this assignment will be on the remote procedure call (RPC) interface to the system.

For this first assignment, the server will simply keep a hash table in memory and need only support a single client at a time. The client must be able to take a file on disk, serialize it for transport, and add it to the hash table on the server.

The client must also be able to retrieve a file from the server, and write it back to the disk. You will be adding more complexity in later assignments, one at a time.

Hash Table RPC Interface

Your hash table server should support the following five operations:

insert( key, value ) -> Inserts the given key and value into the hash table.
lookup( key ) -> Returns the value associated with a given key.
remove( key ) -> Removes the key and corresponding value from the hash table.  (It should not return the old value, because that would make it non-idempotent.)
size() -> Returns the number of items currently in the table.
query(  key ) -> Returns a value of whether the key is in the table. Does not return the value if present.

Across the calls, keys are plain string with arbitrary contents and length, and values can be any Python object which can be serialized for network communication with JSON or pickle (strings, integers, booleans, dictionaries, lists). The response to query is limited to atomic values. (i.e. no dictionaries or lists)

You should design an appropriate set of messages to represent a request and response for each operation. You can define this however you like, as long as it is consistent and works correctly. For example, a request to insert an item might look like this:

{
"method" : "insert",
"key" : "image.png",
"value" : { "size":1024, "data":<bytes> }
}

In a similar way, the server should return a brief message to indicate the result of the operation. Keep in mind that both the client and server should be able to distinguish between a successful operation, a failed operation, and a completely invalid request. You should have return messages to corresponding to each of these cases.

Take care: Each of the RPC operations may fail under normal use. For example, the user might attempt to remove a key that is not present in the table. If that happens, the server should not crash with an exception, but rather should return a suitable message to the client, so that the client can return an appropriate value or raise an exception to its caller. There should be no way in which the client can cause the server to crash.

General Code Structure

To ensure some degree of consistency across the projects, please break your project down into several files with the following names. (It’s ok if you have additional files as well.)

Invocation

HashTableServer.py should be started by giving a single argument – a port number – on the command line. The server should attempt to listen on the port (if available) and fail otherwise. If the port number zero is given, then the server should listen on any available port. Either way, it should display the port it is listening on:

python HashTableServer.py 9328
Listening on port 9328

python HashTableServer.py 0
Listening on port 10475

HashTableClient.py should provide an API for each method of the hash table interface. You may write additional class methods to provide the functionality required for transporting files, or you can handle everything in the single method. For example:

Class HashTableClient:
    def insert( filename : str, data : any ):
        .
        .
    def load_file( filename: File ) -> dict, bytes, etc ...
        .
        .
        return data

Then in your TestBasics and TestPerformance.py:

    data = Client.load_file("image.png")
    Client.insert("image.png", data)

Each of the test programs should accept a host name and port number that they will connect to. For example:

python TestBasics.py student10.cse.nd.edu 10475

Testing and Measurement

Write two test programs to exercise your service:

What Data to Use

What to Turn In

Please review the general instructions for submitting assignments.

Turn in all of your source code, along with a lab report titled REPORT that describes the following in detail: