Release Date: October 2025
Codename: "Stable Foundations"
The release represents months of architecture enhancements, bug resolution, and tooling refinement.
Version 0.0.0 focuses on a simple API, core stability, and robust quality control for a clean developer experience.
- 1. Features
- 2. Architectural & Usability Enhancements
- 3. Stability and Quality Assurance
- 4. Scope Clarification
- 5. Expansion Possibilities
- 6. A History of Closed Issues to reach V0.0.0
- Simple API for exposing and calling remote procedures.
- Interface definition through Python conventions (no separate IDL required).
- Plug-and-play architecture — install and start implementing immediately.
- Remote exception propagation
- Stub generation for server and client.
- Live metrics dashboard, displaying call count and latency per procedure.
-
Simplified Server Setup: The server's initialization is greatly simplified by encapsulating all binder logic (thread management, start, stop) within the generated SrpcServerStub.
-
Clean Naming Convention: A project-wide convention was implemented, changing the name from 'rpc' to 'srpc' (Simple RPC) in all library and generated files for improved clarity.
-
Modular Architecture: The project was reorganized to separate client and server logic into distinct directories, enhancing modularity.
-
Networking Stability: Resolved a critical networking bug (Issue #3) by implementing socket-to-port 0 binding, which delegates port selection to the operating system, eliminating the need for conflict checking.
-
Reliable Exception Instantiation: Fixed a bug (Issue #1) related to remote exception rehydration by ensuring the exception type (exc_name) is correctly included in the 400 response, allowing the client-side eval() to correctly instantiate the remote class.
-
Continuous Integration (CI): An automated CI pipeline was established to run Pytest (unit and integration tests) upon every push, ensuring code quality standards are met.
-
Code Style Enforcement: Adopted pre-commit hooks utilizing Black, Flake8, and isort to enforce a consistent and high-quality coding style across the project.
-
Improved Logging: Standardized logging practices using the lightweight Python logging library, including the use of specific exceptions, proper error logging, and custom exception classes.
-
Non-Impactful Metrics: Latency measurement was designed to write metrics to a file, this approach was chosen to avoid impacting server performance.
Protocol Adherence: In this version, the project has consciously decided not to strictly adhere to RFC 1057 (Sun RPC).
SRPC is positioned as a prototyping and academic library rather than a production-ready system, allowing for faster
development and distributed systems principles.
- Performance Benchmarking — Implement comprehensive tests and metrics
(e.g., latency, throughput, resource utilization) to enable users to evaluate real-world behavior. - Security Review — Analysis of serialization, transport layers, failure modes, in order to turn the library for broader deployment.
- Authentication & Authorization Layers — Provide mechanisms for authentication and access control, enabling secure RPC
This timeline reflects the project's maturation from its early stages to a more robust and organized state.
The initial phase focused on building a stable foundation, resolving critical bugs, and setting up the basic development workflow.
Two critical issues concerning stability and network binding were resolved early in the project’s life:
This fundamental networking bug was resolved by adopting an elegant solution: binding the socket to port 0.
This delegates the responsibility of choosing an available, unassigned port to the operating system,
eliminating the need for custom random port generation and conflict checking.
This bug related to remote exception propagation was fixed by ensuring the exception type (exc_name) was correctly included in the 400 response,
allowing the client side's eval() function to correctly instantiate the remote exception class.
Key structural and pipeline decisions were made to prepare the project for scaling:
The repository was reorganized to separate client and server logic into distinct directories, improving modularity.
The core generation script, srpc_stub_gen.py, was also modularized.
A Continuous Integration (CI) pipeline was established. The author successfully implemented a workflow that executes Pytest
for both unit and integration tests upon every push, ensuring code changes meet quality standards before merging.
With the foundation stable, development shifted to code quality, developer experience, and defining the project's scope.
The commitment to clean code was formalized through automated tools:
This enhancement resulted in the adoption of pre-commit hooks utilizing three essential Python tools:
Black (uncompromising code formatter), Flake8 (linting and PEP 8 enforcement), and isort (import sorting).
This enforced a consistent coding style across all commits.
Better logging was a persistent focus, evolving through two issues:
These intertwined issues focused on improving error handling and logging.
The solution involved implementing five best practices: using specific exceptions, proper error logging, defining custom exception classes,
and ensuring graceful handling. The project adopted the standard Python logging library for its lightweight nature.
Latency measurement was implemented for monitoring performance. The author chose an innovative approach to avoid impacting server performance:
metrics are written to a file and a utility srpc_show_metrics.py reads and displays these metrics in real-time.
Defining the Project's Scope.
Issue #9: You should fallow the Remote Procedure Call Protocol Specification (WONTFIX: August 25, 2025):
This crucial decision clarified the project's scope. Due to the removal of the XDR library from Python standards,
the author decided not to strictly adhere to RFC 1057 (Sun RPC). Instead, the RPC-LIB was consciously positioned
as a prototyping and academic library rather than a production-ready system,
allowing for faster development and a more tailored focus on distributed systems principles.
The final closed issues focused on refining the architecture to enhance usability and consistency.
To improve code clarity and help the user distinguish between library code and the user own code, a project-wide convention was implemented,
changing the name from 'rpc' to 'srpc' (Simple RPC) in both library and generated files.
This was a major usability enhancement. The logic for managing the server binder (thread, start, stop)
was fully encapsulated within the generated SrpcServerStub. This simplified the user's server setup significantly,
reducing initialization to the elegant, single-line form:
Before
# rpc_server.py
from Rpc_Server_Binder import RpcServerBinder
from Calc_rpc_server_stub import RpcServerStub # from <Modulename>_rpc_server_stub import RpcServerStub
import threading
HOST = "localhost"
server_stub = RpcServerStub(HOST)
binder = RpcServerBinder(HOST)
binder_thread = threading.Thread(target=binder.start_binder, name="binder_thread", daemon=True)
binder_thread.start()
server_stub.start()
input("Server started, press any key to stop...")
binder.stop()
server_stub.stop()After
# server.py
from srpc_calc_server_stub import SrpcCalcServerStub
calcServerStub = SrpcCalcServerStub()
calcServerStub.start()