fix: create directories in a better way

- allow creation of recursive missing directories
- don't crash on failure, but just skip the dependent operation (log creation, recording creation)

Author: Totto16

src/executables/game/main.cpp

@@ -34,8 +34,11 @@ namespace {
     void initialize_spdlog() {
 
         const auto logs_path = utils::get_root_folder() / "logs";
-        if (not std::filesystem::exists(logs_path)) {
-            std::filesystem::create_directory(logs_path);
+
+        auto created_log_dir = utils::create_directory(logs_path, true);
+        if (created_log_dir.has_value()) {
+            std::cerr << "warning: couldn't create logs directory '" << logs_path.string()
+                      << "': disabled file logger\n";
         }
 
         std::vector<spdlog::sink_ptr> sinks;
@@ -46,9 +49,13 @@ namespace {
 #else
         sinks.push_back(std::make_shared<spdlog::sinks::stdout_sink_mt>());
 #endif
-        sinks.push_back(std::make_shared<spdlog::sinks::rotating_file_sink_mt>(
-                fmt::format("{}/oopetris.log", logs_path.string()), 1024 * 1024 * 10, 5, true
-        ));
+
+        if (not created_log_dir.has_value()) {
+            sinks.push_back(std::make_shared<spdlog::sinks::rotating_file_sink_mt>(
+                    fmt::format("{}/oopetris.log", logs_path.string()), 1024 * 1024 * 10, 5, true
+            ));
+        }
+
         auto combined_logger = std::make_shared<spdlog::logger>("combined_logger", begin(sinks), end(sinks));
         spdlog::set_default_logger(combined_logger);
 

src/helper/graphic_utils.cpp

@@ -147,6 +147,32 @@ utils::ExitException::ExitException(int status_code) noexcept : m_status_code{ s
     return "An exit exception occurred";
 }
 
+std::optional<std::string> utils::create_directory(const std::filesystem::path& folder, bool recursive) {
+
+    if (std::filesystem::exists(folder)) {
+        return std::nullopt;
+    }
+
+    try {
+        if (recursive) {
+            auto result = std::filesystem::create_directories(folder);
+            if (not result) {
+                return "an unknown error occurred";
+            }
+            return std::nullopt;
+        }
+
+
+        auto result = std::filesystem::create_directory(folder);
+        if (not result) {
+            return "an unknown error occurred";
+        }
+        return std::nullopt;
+    } catch (const std::exception& error) {
+        return error.what();
+    }
+}
+
 void utils::exit(int status_code) {
 #if defined(__ANDROID__)
     // calling exit() in android doesn't do the correct job, it completely avoids resource cleanup by the underlying SDLActivity.java

src/helper/graphic_utils.hpp

@@ -7,6 +7,7 @@
 #include "helper/constants.hpp"
 
 #include <SDL.h>
+#include <filesystem>
 #include <spdlog/spdlog.h>
 
 namespace utils {
@@ -34,6 +35,9 @@ namespace utils {
     };
 
 
+    OOPETRIS_GRAPHICS_EXPORTED [[nodiscard]] std::optional<std::string>
+    create_directory(const std::filesystem::path& folder, bool recursive);
+
 // this needs some special handling, so the macro is defined here
 #if defined(_MSC_VER)
 #if defined(OOPETRIS_LIBRARY_GRAPHICS_TYPE) && OOPETRIS_LIBRARY_GRAPHICS_TYPE == 0

src/input/input_creator.cpp

@@ -13,6 +13,7 @@
 #include "input_creator.hpp"
 
 #include <fmt/format.h>
+#include <spdlog/spdlog.h>
 #include <stdexcept>
 
 namespace {
@@ -123,32 +124,34 @@ input::get_game_parameters_for_replay(
 
     const auto recording_directory_path = utils::get_root_folder() / constants::recordings_directory;
 
-    if (not std::filesystem::exists(recording_directory_path)) {
-        std::filesystem::create_directory(recording_directory_path);
-    }
 
-    const auto date_time_str = date.to_string();
+    auto dir_result = utils::create_directory(recording_directory_path, true);
+    if (not dir_result.has_value()) {
 
-    if (not date_time_str.has_value()) {
-        throw std::runtime_error{ fmt::format("Erro in date to string conversion: {}", date_time_str.error()) };
-    }
+        const auto date_time_str = date.to_string();
 
-    const auto filename = fmt::format("{}.{}", date_time_str.value(), constants::recording::extension);
-    const auto file_path = recording_directory_path / filename;
+        if (not date_time_str.has_value()) {
+            throw std::runtime_error{ fmt::format("Erro in date to string conversion: {}", date_time_str.error()) };
+        }
 
+        const auto filename = fmt::format("{}.{}", date_time_str.value(), constants::recording::extension);
+        const auto file_path = recording_directory_path / filename;
 
-    auto recording_writer_create_result =
-            recorder::RecordingWriter::get_writer(file_path, std::move(tetrion_headers), std::move(information));
-    if (not recording_writer_create_result.has_value()) {
-        throw std::runtime_error(recording_writer_create_result.error());
-    }
 
-    const auto recording_writer =
-            std::make_shared<recorder::RecordingWriter>(std::move(recording_writer_create_result.value()));
+        auto recording_writer_create_result =
+                recorder::RecordingWriter::get_writer(file_path, std::move(tetrion_headers), std::move(information));
+        if (not recording_writer_create_result.has_value()) {
+            throw std::runtime_error(recording_writer_create_result.error());
+        }
 
+        const auto recording_writer =
+                std::make_shared<recorder::RecordingWriter>(std::move(recording_writer_create_result.value()));
 
-    std::get<1>(result).recording_writer = recording_writer;
 
+        std::get<1>(result).recording_writer = recording_writer;
+    } else {
+        spdlog::warn("Couldn't create recordings folder {}: skipping creation of a recording", dir_result.value());
+    }
 
     return result;
 }