Rename StorageRsm to ShardRsm

src/io/rsm/shard_rsm.hpp

@@ -11,15 +11,15 @@
 
 #pragma once
 
-/// The StorageRsm is a simple in-memory raft-backed kv store that can be used for simple testing
+/// The ShardRsm is a simple in-memory raft-backed kv store that can be used for simple testing
 /// and implementation of some query engine logic before storage engines are fully implemented.
 ///
 /// To implement multiple read and write commands, change the StorageRead* and StorageWrite* requests
 /// and responses to a std::variant of the different options, and route them to specific handlers in
-/// the StorageRsm's Read and Apply methods. Remember that Read is called immediately when the Raft
+/// the ShardRsm's Read and Apply methods. Remember that Read is called immediately when the Raft
 /// leader receives the request, and does not replicate anything over Raft. Apply is called only
 /// AFTER the StorageWriteRequest is replicated to a majority of Raft peers, and the result of calling
-/// StorageRsm::Apply(StorageWriteRequest) is returned to the client that submitted the request.
+/// ShardRsm::Apply(StorageWriteRequest) is returned to the client that submitted the request.
 
 #include <deque>
 #include <iostream>
@@ -77,7 +77,7 @@ struct StorageReadResponse {
   std::optional<Hlc> latest_known_shard_map_version{std::nullopt};
 };
 
-class StorageRsm {
+class ShardRsm {
   std::map<ShardRsmKey, int> state_;
   ShardRsmKey minimum_key_;
   std::optional<ShardRsmKey> maximum_key_{std::nullopt};

tests/simulation/sharded_map.cpp

@@ -51,9 +51,9 @@ using memgraph::io::rsm::Raft;
 using memgraph::io::rsm::ReadRequest;
 using memgraph::io::rsm::ReadResponse;
 using memgraph::io::rsm::RsmClient;
+using memgraph::io::rsm::ShardRsm;
 using memgraph::io::rsm::StorageReadRequest;
 using memgraph::io::rsm::StorageReadResponse;
-using memgraph::io::rsm::StorageRsm;
 using memgraph::io::rsm::StorageWriteRequest;
 using memgraph::io::rsm::StorageWriteResponse;
 using memgraph::io::rsm::WriteRequest;
@@ -127,13 +127,12 @@ std::optional<StorageClient> DetermineShardLocation(Shard target_shard, const st
 }  // namespace
 
 using ConcreteCoordinatorRsm = CoordinatorRsm<SimulatorTransport>;
-using ConcreteStorageRsm = Raft<SimulatorTransport, StorageRsm, StorageWriteRequest, StorageWriteResponse,
-                                StorageReadRequest, StorageReadResponse>;
+using ConcreteShardRsm = Raft<SimulatorTransport, ShardRsm, StorageWriteRequest, StorageWriteResponse,
+                              StorageReadRequest, StorageReadResponse>;
 
 template <typename IoImpl>
 void RunStorageRaft(
-    Raft<IoImpl, StorageRsm, StorageWriteRequest, StorageWriteResponse, StorageReadRequest, StorageReadResponse>
-        server) {
+    Raft<IoImpl, ShardRsm, StorageWriteRequest, StorageWriteResponse, StorageReadRequest, StorageReadResponse> server) {
   server.Run();
 }
 
@@ -175,9 +174,9 @@ int main() {
   std::vector<Address> a_2_peers = {a_addrs[0], a_addrs[2]};
   std::vector<Address> a_3_peers = {a_addrs[0], a_addrs[1]};
 
-  ConcreteStorageRsm a_1{std::move(a_io_1), a_1_peers, StorageRsm{}};
-  ConcreteStorageRsm a_2{std::move(a_io_2), a_2_peers, StorageRsm{}};
-  ConcreteStorageRsm a_3{std::move(a_io_3), a_3_peers, StorageRsm{}};
+  ConcreteShardRsm a_1{std::move(a_io_1), a_1_peers, ShardRsm{}};
+  ConcreteShardRsm a_2{std::move(a_io_2), a_2_peers, ShardRsm{}};
+  ConcreteShardRsm a_3{std::move(a_io_3), a_3_peers, ShardRsm{}};
 
   auto a_thread_1 = std::jthread(RunStorageRaft<SimulatorTransport>, std::move(a_1));
   simulator.IncrementServerCountAndWaitForQuiescentState(a_addrs[0]);
@@ -195,9 +194,9 @@ int main() {
   std::vector<Address> b_2_peers = {b_addrs[0], b_addrs[2]};
   std::vector<Address> b_3_peers = {b_addrs[0], b_addrs[1]};
 
-  ConcreteStorageRsm b_1{std::move(b_io_1), b_1_peers, StorageRsm{}};
-  ConcreteStorageRsm b_2{std::move(b_io_2), b_2_peers, StorageRsm{}};
-  ConcreteStorageRsm b_3{std::move(b_io_3), b_3_peers, StorageRsm{}};
+  ConcreteShardRsm b_1{std::move(b_io_1), b_1_peers, ShardRsm{}};
+  ConcreteShardRsm b_2{std::move(b_io_2), b_2_peers, ShardRsm{}};
+  ConcreteShardRsm b_3{std::move(b_io_3), b_3_peers, ShardRsm{}};
 
   auto b_thread_1 = std::jthread(RunStorageRaft<SimulatorTransport>, std::move(b_1));
   simulator.IncrementServerCountAndWaitForQuiescentState(b_addrs[0]);