add GameStoreInterface to enable golf persistence (#239)

* add GameStoreInterface to enable golf persistence

 - GameStoreInterface currently has InMemoryGameStore implementation for
   use in tests
 - escapist backed GameStore coming in future change
 - update to c++20
 - remove local state from golf::GameManager
 - add db name to client metadata in escapist c++ client
 - clean up game_manager.h
 - add new golf rpc proto (incomplete)

TODO:
 - add escapist backed GameStore
 - escapist server should read clientContext metadata for db name
   (ideally via Authentication header?)
 - InMemoryGameStore unit tests so we don't have to test via GameManager

* clang-format

* incredible

Author: aaylward

.bazelrc

@@ -6,8 +6,9 @@ common --enable_bzlmod=true
 common --disk_cache=~/bzlcache
 common --repository_cache=~/.bzl_repo_cache
 
-common --cxxopt='-std=c++17'
-common --host_cxxopt='-std=c++17'
+common --cxxopt='-std=c++20'
+common --host_cxxopt='-std=c++20'
+# common --action_env=BAZEL_CXXOPTS="-std=c++20"
 
 build:debug -c dbg
 

MODULE.bazel

@@ -3,13 +3,7 @@ module(
     version = "1.0",
 )
 
-bazel_dep(name = "toolchains_llvm", version = "1.0.0")
-git_override(
-    module_name = "toolchains_llvm",
-    commit = "01132cfdae7d7187a885cf79d5a3ac1ed8a02e5a",
-    remote = "https://github.com/bazel-contrib/toolchains_llvm",
-)
-
+bazel_dep(name = "toolchains_llvm", version = "1.1.2")
 bazel_dep(name = "rules_python", version = "0.34.0")
 bazel_dep(name = "protobuf", version = "27.2", repo_name = "com_google_protobuf")
 bazel_dep(name = "grpc", version = "1.65.0", repo_name = "com_github_grpc_grpc")

MODULE.bazel.lock

@@ -2,16 +2,52 @@ cc_library(
     name = "golf",
     srcs = [
         "game_manager.cc",
-        "game_state.cc",
-        "player.cc",
     ],
     hdrs = [
         "game_manager.h",
-        "game_state.h",
         "golf.h",
-        "player.h",
     ],
     visibility = ["//visibility:public"],
+    deps = [
+        ":game_state",
+        ":game_store",
+        ":player",
+        "//cpp/cards",
+        "@com_google_absl//absl/status:statusor",
+    ],
+)
+
+cc_library(
+    name = "game_store",
+    srcs = ["game_store.cc"],
+    hdrs = ["game_store.h"],
+    visibility = ["//visibility:public"],
+    deps = [
+        ":game_state",
+        ":player",
+        "//cpp/cards",
+        "@com_google_absl//absl/status",
+        "@com_google_absl//absl/status:statusor",
+    ],
+)
+
+cc_library(
+    name = "game_state",
+    srcs = ["game_state.cc"],
+    hdrs = ["game_state.h"],
+    visibility = ["//visibility:public"],
+    deps = [
+        ":player",
+        "//cpp/cards",
+        "@com_google_absl//absl/status:statusor",
+    ],
+)
+
+cc_library(
+    name = "player",
+    srcs = ["player.cc"],
+    hdrs = ["player.h"],
+    visibility = ["//visibility:public"],
     deps = [
         "//cpp/cards",
         "@com_google_absl//absl/status:statusor",
@@ -23,7 +59,7 @@ cc_test(
     size = "small",
     srcs = ["player_test.cc"],
     deps = [
-        ":golf",
+        ":player",
         "@googletest//:gtest_main",
     ],
 )
@@ -33,7 +69,7 @@ cc_test(
     size = "small",
     srcs = ["game_state_test.cc"],
     deps = [
-        ":golf",
+        ":game_state",
         "@googletest//:gtest_main",
     ],
 )

cpp/cards/golf/BUILD.bazel

@@ -14,6 +14,7 @@ namespace golf {
 using namespace cards;
 
 using absl::InvalidArgumentError;
+using absl::Status;
 using absl::StatusOr;
 
 using std::deque;
@@ -23,21 +24,28 @@ using std::vector;
 static const std::string allowedChars =
     "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-";
 
-StatusOr<string> GameManager::registerUser(const string& username) {
-  if (username.size() < 4 || username.size() > 15) {
+auto validate_user_id(const string& user_id) -> Status {
+  if (user_id.size() < 4 || user_id.size() > 15) {
     return InvalidArgumentError("username length must be between 4 and 15 chars");
   }
 
-  if (username.find_first_not_of(allowedChars) != string::npos) {
+  if (user_id.find_first_not_of(allowedChars) != string::npos) {
     return InvalidArgumentError("only alphanumeric, underscore, or dash allowed in username");
   }
+  return absl::OkStatus();
+}
 
-  if (usersOnline.find(username) != usersOnline.end()) {
-    return InvalidArgumentError("username taken");
+StatusOr<string> GameManager::registerUser(const string& user_id) {
+  auto validate_status = validate_user_id(user_id);
+  if (!validate_status.ok()) {
+    return validate_status;
   }
 
-  usersOnline.insert(username);
-  return username;
+  auto save_status = game_store_->AddUser(user_id);
+  if (save_status.ok()) {
+    return user_id;
+  }
+  return save_status;
 }
 
 deque<Card> GameManager::shuffleNewDeck() {
@@ -84,23 +92,21 @@ std::string GameManager::generateRandomAlphanumericString(std::size_t len) const
 std::optional<std::string> GameManager::generateUnusedRandomId() const {
   for (int i = 0; i < 10; i++) {
     auto attempt = generateRandomAlphanumericString(12);
-    if (gamesById.find(attempt) == gamesById.end()) {
+    auto existing_game = game_store_->ReadGame(attempt);
+    if (!existing_game.ok()) {
       return attempt;
     }
   }
   return {};
 }
 
-// TODO: generate random game id
-// TODO: support multiple decks
-StatusOr<GameStatePtr> GameManager::newGame(const string& username, int numberOfPlayers) {
-  if (usersOnline.find(username) == usersOnline.end()) {
-    return InvalidArgumentError("unregistered username");
-  }
-  if (gameIdsByUser.find(username) != gameIdsByUser.end()) {
-    return InvalidArgumentError("already in game");
+// TODO: support multiple decks for many players?
+StatusOr<GameStatePtr> GameManager::newGame(const string& user_id, int number_of_players) {
+  if (!game_store_->UserExists(user_id)) {
+    return InvalidArgumentError("unknown user");
   }
-  if (numberOfPlayers < 2 || numberOfPlayers > 5) {
+
+  if (number_of_players < 2 || number_of_players > 5) {
     return InvalidArgumentError("2 to 5 players");
   }
 
@@ -112,22 +118,22 @@ StatusOr<GameStatePtr> GameManager::newGame(const string& username, int numberOf
   deque<Card> mutableDrawPile = shuffleNewDeck();
 
   vector<Card> allDealt{};
-  for (int i = 0; i < numberOfPlayers * 4; i++) {
+  for (int i = 0; i < number_of_players * 4; i++) {
     allDealt.push_back(mutableDrawPile.back());
     mutableDrawPile.pop_back();
   }
 
   vector<Player> mutablePlayers;
 
   // two up, two down
-  int halfway = numberOfPlayers * 2;
-  for (int i = 0; i < numberOfPlayers; i++) {
+  int halfway = number_of_players * 2;
+  for (int i = 0; i < number_of_players; i++) {
     auto& tl = allDealt.at(2 * i);
     auto& tr = allDealt.at(2 * i + 1);
     auto& bl = allDealt.at(2 * i + halfway);
     auto& br = allDealt.at(2 * i + halfway + 1);
     if (i == 0) {
-      mutablePlayers.emplace_back(username, tl, tr, bl, br);
+      mutablePlayers.emplace_back(user_id, tl, tr, bl, br);
     } else {
       mutablePlayers.emplace_back(tl, tr, bl, br);
     }
@@ -141,29 +147,22 @@ StatusOr<GameStatePtr> GameManager::newGame(const string& username, int numberOf
   const deque<Card> drawPile = std::move(mutableDrawPile);
   const deque<Card> discardPile = std::move(mutableDiscardPile);
 
-  auto emplaceWorked = gamesById.emplace(
-      gameId,
-      std::make_shared<GameState>(GameState{drawPile, discardPile, players, false, 0, -1, gameId}));
-  if (!emplaceWorked.second) {
-    return InvalidArgumentError("could not generate unused game id");
-  }
-
-  usersByGame.insert(std::make_pair(gameId, std::unordered_set<string>{username}));
-  gameIdsByUser[username] = gameId;
-  return gamesById.at(gameId);
+  auto game_state =
+      std::make_shared<GameState>(GameState{drawPile, discardPile, players, false, 0, -1, gameId});
+  return game_store_->NewGame(game_state);
 }
 
-StatusOr<GameStatePtr> GameManager::joinGame(const string& gameId, const string& username) {
-  if (usersOnline.find(username) == usersOnline.end()) {
+StatusOr<GameStatePtr> GameManager::joinGame(const string& game_id, const string& user_id) {
+  if (!game_store_->UserExists(user_id)) {
     return InvalidArgumentError("unregistered username");
   }
 
-  auto gameIter = gamesById.find(gameId);
-  if (gameIter == gamesById.end()) {
+  auto game_read_status = game_store_->ReadGame(game_id);
+  if (!game_read_status.ok()) {
     return InvalidArgumentError("unknown game id");
   }
 
-  auto oldGameState = gameIter->second;
+  auto oldGameState = *game_read_status;
 
   if (oldGameState->allPlayersPresent()) {
     return InvalidArgumentError("no spots available");
@@ -177,28 +176,21 @@ StatusOr<GameStatePtr> GameManager::joinGame(const string& gameId, const string&
       updatedPlayers.push_back(p);
     } else {
       // safe because we know player is not already claimed
-      updatedPlayers.emplace_back(*p.claimHand(username));
+      updatedPlayers.emplace_back(*p.claimHand(user_id));
       playerAdded = true;
     }
   }
 
-  gamesById.erase(gameId);
-  gamesById.emplace(gameId, std::make_shared<GameState>(oldGameState->withPlayers(updatedPlayers)));
-  usersByGame.at(gameId).insert(username);
-  gameIdsByUser[username] = gameId;
-
-  return gamesById.at(gameId);
+  auto updated_game = std::make_shared<GameState>(oldGameState->withPlayers(updatedPlayers));
+  return game_store_->UpdateGame(updated_game);
 }
 
-StatusOr<GameStatePtr> GameManager::getGameStateForUser(const string& username) const {
-  if (usersOnline.find(username) == usersOnline.end()) {
-    return InvalidArgumentError("unregistered username");
-  }
-  if (gameIdsByUser.find(username) == gameIdsByUser.end()) {
-    return InvalidArgumentError("user not in game");
+StatusOr<GameStatePtr> GameManager::getGameStateForUser(const string& user_id) const {
+  if (!game_store_->UserExists(user_id)) {
+    return InvalidArgumentError("unknown user");
   }
 
-  return gamesById.at(gameIdsByUser.at(username));
+  return game_store_->ReadGameByUserId(user_id);
 }
 
 StatusOr<GameStatePtr> GameManager::updateGameState(StatusOr<GameState> updateResult,
@@ -207,10 +199,8 @@ StatusOr<GameStatePtr> GameManager::updateGameState(StatusOr<GameState> updateRe
     return InvalidArgumentError(updateResult.status().message());
   }
 
-  gamesById.erase(gameId);
-  gamesById.emplace(gameId, std::make_shared<GameState>(*updateResult));
-
-  return gamesById.at(gameId);
+  auto game_state = std::make_shared<GameState>(*updateResult);
+  return game_store_->UpdateGame(game_state);
 }
 
 StatusOr<GameStatePtr> GameManager::peekAtDrawPile(const string& username) {
@@ -273,4 +263,44 @@ StatusOr<GameStatePtr> GameManager::knock(const string& username) {
   return updateGameState(game->knock(playerIndex), game->getGameId());
 }
 
+std::unordered_set<string> GameManager::getUsersOnline() const {
+  auto read_users_status = game_store_->GetUsers();
+  if (!read_users_status.ok()) {
+    return {};  // TODO: bubble status to caller
+  }
+  return *read_users_status;
+}
+
+std::unordered_set<GameStatePtr> GameManager::getGames() const {
+  return game_store_->ReadAllGames();
+}
+
+std::unordered_map<string, string> GameManager::getGameIdsByUserId() const {
+  auto games_result = game_store_->ReadAllGames();
+  std::unordered_map<string, string> game_ids_by_user{};
+  for (auto g : games_result) {
+    auto game_id = g->getGameId();
+    for (auto p : g->getPlayers()) {
+      if (p.isPresent() && p.getName().has_value()) {
+        game_ids_by_user[p.getName().value()] = game_id;
+      }
+    }
+  }
+  return game_ids_by_user;
+}
+
+std::unordered_set<string> GameManager::getUsersByGameId(const string& game_id) const {
+  auto game_maybe = game_store_->ReadGame(game_id);
+  if (!game_maybe.ok()) {
+    return {};
+  }
+  std::unordered_set<string> users{};
+  for (auto p : (*game_maybe)->getPlayers()) {
+    if (p.isPresent() && p.getName().has_value()) {
+      users.insert(p.getName().value());
+    }
+  }
+  return users;
+}
+
 }  // namespace golf