Guard Entry Atomic Object Creation in Distributed Storage
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Distributed key-value storage systems face challenges in ensuring durability, eventual consistency, and atomicity, particularly in managing garbage data and maintaining system integrity across multiple servers, as existing solutions fail to guarantee atomic operations across server boundaries.
Innovation Solution
The proposed method involves creating a guard entry and a garbage collection entry with finite lifetimes on the Name Server and Object Server, respectively, with atomic operations to ensure successful object creation and garbage collection, using a protocol endpoint to manage requests and responses, and maintaining an Active Objects Table to track recently written objects for TTL extension or deletion.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If distributed key-value storage splits the system into multiple parts hosted on different servers for load balancing, then system scalability and load distribution are improved, but system consistency and atomicity across server boundaries deteriorate
Solution Approach 1:
The system is segmented into Name Server (NS) and Object Server (OS) components hosted on different servers. NS stores object names/keys while OS stores object data, allowing independent scaling and load distribution across multiple servers while maintaining logical consistency through coordinated operations.
Solution Approach 2:
A client acts as an intermediary coordinating between NS and OS. The client manages the creation process by first creating a name at NS, then creating corresponding object data at OS, and finally establishing the name-data association. This intermediary coordination ensures atomicity and consistency across the distributed servers.
2Ease of operation
If the system uses conventional object creation processes without special atomicity guarantees, then ease of operation is improved, but atomicity and consistency of name-object pair creation deteriorate
Solution Approach 1:
The system performs preliminary actions in a specific sequence: first create a guard entry at NS, then create object data at OS, and finally atomically replace the guard entry with the actual name. This preliminary structured approach ensures atomicity while maintaining operational simplicity through clear step-by-step procedures.
Solution Approach 2:
A guard entry is created beforehand at the Name Server as a placeholder before actual object creation. This guard entry acts as a cushion that prevents premature name creation and ensures that the name-object pair is only established when both components are ready, guaranteeing atomicity without complicating the operation.
3Reliability
If the system implements guard entries with finite lifetime for atomicity, then atomicity and consistency are improved, but system complexity and overhead increase
Solution Approach 1:
Guard entries are designed as cheap, short-lived objects with finite lifetime (TTL). They serve as temporary placeholders during the atomic creation process and are automatically removed after serving their purpose. This disposable nature reduces complexity overhead while maintaining atomicity guarantees.
Solution Approach 2:
The guard entry has a time-to-live (TTL) parameter that automatically changes its validity state. After the TTL expires, the guard entry is automatically removed, providing a simple mechanism to enforce atomicity without permanent complexity. The parameter change from valid to expired automatically manages the entry's lifecycle.
4Reliability
If the system performs multiple atomic operations across Name Server and Object Server, then consistency and durability are improved, but operation time and processing overhead increase
Solution Approach 1:
The system maintains continuity of useful action by keeping the guard entry in place throughout the object creation process. Rather than performing separate independent operations, the guard entry continuously represents the pending creation state, allowing the client to coordinate the atomic replacement with minimal interruption and reduced overall operation time.
Data Source
AI summary
Method for writing objects into an object storage. Performing, on a protocol end point: receiving a client request for inserting an object into the object storage, wherein the object has a name and object data; generating a unique ID (UID) for the object; sending, to a name server (NS), a request for creating a guard entry (GE). The GE has a lifetime that defines when the name-object pair is inserted into the object storage. A request to an object server (OS) atomically creates a Garbage Collection Entry and assigns space for the object data. The GCE has a lifetime that defines when the object data is inserted into the object storage; sending, to the OS, object data for writing to storage; sending, to the NS, a request for writing the name; and sending response to the client, to report success after requests to the NS and the OS are successful.