Refactoring.

Author: Adrien4193

apps/service.cpp

@@ -19,43 +19,11 @@
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  */
 
-#include <iostream>
-
 #include <brayns/core/Launcher.h>
-#include <brayns/core/Version.h>
-#include <brayns/core/cli/CommandLine.h>
 
 using namespace brayns;
 
 int main(int argc, const char **argv)
 {
-    try
-    {
-        auto settings = parseArgvAs<ServiceSettings>(argc, argv);
-
-        if (settings.version)
-        {
-            std::cout << getCopyright() << '\n';
-            return 0;
-        }
-
-        if (settings.help)
-        {
-            std::cout << getArgvHelp<ServiceSettings>() << '\n';
-            return 0;
-        }
-
-        runService(settings);
-    }
-    catch (const std::exception &e)
-    {
-        std::cout << "Fatal error: " << e.what() << ".\n";
-    }
-    catch (...)
-    {
-        std::cout << "Unknown fatal error.";
-        return 1;
-    }
-
-    return 0;
+    return runService(argc, argv);
 }

src/brayns/core/Launcher.cpp

@@ -21,16 +21,18 @@
 
 #include "Launcher.h"
 
+#include <iostream>
+
 #include <brayns/core/service/Service.h>
 #include <brayns/core/utils/Logger.h>
 
-namespace brayns
+namespace
 {
-void runService(const ServiceSettings &settings)
+using namespace brayns;
+
+Service createService(const ServiceSettings &settings, Logger &logger)
 {
     auto level = getEnumValue<LogLevel>(settings.logLevel);
-
-    auto logger = createConsoleLogger("brayns");
     logger.setLevel(level);
 
     auto ssl = std::optional<SslSettings>();
@@ -54,19 +56,55 @@ void runService(const ServiceSettings &settings)
         .ssl = std::move(ssl),
     };
 
-    auto endpoints = EndpointRegistry({});
-
-    auto tasks = TaskManager();
+    auto api = Api({});
 
     auto context = std::make_unique<ServiceContext>(ServiceContext{
-        .logger = std::move(logger),
+        .logger = logger,
         .server = std::move(server),
-        .endpoints = std::move(endpoints),
-        .tasks = std::move(tasks),
+        .api = std::move(api),
     });
 
-    auto service = Service(std::move(context));
+    return Service(std::move(context));
+}
+}
+
+namespace brayns
+{
+int runService(int argc, const char **argv)
+{
+    auto logger = createConsoleLogger("brayns");
+
+    try
+    {
+        auto settings = parseArgvAs<ServiceSettings>(argc, argv);
+
+        if (settings.help)
+        {
+            std::cout << getArgvHelp<ServiceSettings>() << '\n';
+            return 0;
+        }
+
+        if (settings.version)
+        {
+            std::cout << getCopyright() << '\n';
+            return 0;
+        }
+
+        auto service = createService(settings, logger);
 
-    service.run();
+        service.run();
+
+        return 0;
+    }
+    catch (const std::exception &e)
+    {
+        logger.fatal("Cannot start service: {}", e.what());
+        return 1;
+    }
+    catch (...)
+    {
+        logger.fatal("Cannot start service for unknown reason");
+        return 1;
+    }
 }
 }

src/brayns/core/Launcher.h

@@ -101,5 +101,5 @@ struct ArgvSettingsReflector<ServiceSettings>
     }
 };
 
-void runService(const ServiceSettings &settings);
+int runService(int argc, const char **argv);
 }

src/brayns/core/api/Task.cpp renamed to src/brayns/core/api/Api.cpp

@@ -24,6 +24,7 @@
 #include <cassert>
 
 #include <fmt/format.h>
+#include "Api.h"
 
 namespace
 {
@@ -35,61 +36,125 @@ const RawTask &getTask(const std::map<TaskId, RawTask> &tasks, TaskId id)
 
     if (i == tasks.end())
     {
-        throw InvalidParams(fmt::format("Invalid task ID: {}", id));
+        throw InvalidParams(fmt::format("Task ID not found: {}", id));
     }
 
     return i->second;
 }
+
+TaskId addTask(RawTask task, std::map<TaskId, RawTask> &tasks, IdGenerator<TaskId> ids)
+{
+    auto id = ids.next();
+    assert(!tasks.contains(id));
+
+    try
+    {
+        tasks[id] = std::move(task);
+    }
+    catch (...)
+    {
+        ids.recycle(id);
+        throw;
+    }
+
+    return id;
+}
 }
 
 namespace brayns
 {
-TaskManager::~TaskManager()
+Api::Api(std::map<std::string, Endpoint> endpoints):
+    _endpoints(std::move(endpoints))
+{
+}
+
+Api::~Api()
 {
     for (const auto &[id, task] : _tasks)
     {
         task.cancel();
     }
 }
 
-std::vector<TaskInfo> TaskManager::getTasks() const
+std::vector<std::string> Api::getMethods() const
 {
-    auto infos = std::vector<TaskInfo>();
-    infos.reserve(_tasks.size());
+    auto result = std::vector<std::string>();
+    result.reserve(_endpoints.size());
 
-    for (const auto &[id, task] : _tasks)
+    for (const auto &[method, endpoint] : _endpoints)
     {
-        infos.push_back({id, task.getProgress()});
+        result.push_back(method);
     }
 
-    return infos;
+    return result;
 }
 
-TaskId TaskManager::add(RawTask task)
+const EndpointSchema &Api::getSchema(const std::string &method) const
 {
-    auto id = _ids.next();
-    assert(!_tasks.contains(id));
+    auto i = _endpoints.find(method);
 
-    try
+    if (i == _endpoints.end())
     {
-        _tasks[id] = std::move(task);
+        throw InvalidParams(fmt::format("Invalid endpoint method: '{}'", method));
     }
-    catch (...)
+
+    return i->second.schema;
+}
+
+RawResult Api::execute(const std::string &method, RawParams params)
+{
+    auto i = _endpoints.find(method);
+
+    if (i == _endpoints.end())
     {
-        _ids.recycle(id);
-        throw;
+        throw MethodNotFound(method);
     }
 
-    return id;
+    const auto &endpoint = i->second;
+
+    auto errors = validate(params.json, endpoint.schema.params);
+
+    if (!errors.empty())
+    {
+        throw InvalidParams("Invalid params schema", errors);
+    }
+
+    if (endpoint.schema.async)
+    {
+        const auto &launcher = std::get<TaskLauncher>(endpoint.handler);
+
+        auto task = launcher(std::move(params));
+
+        auto id = addTask(std::move(task), _tasks, _ids);
+
+        return {serializeToJson(TaskResult{id})};
+    }
+
+    const auto &runner = std::get<TaskRunner>(endpoint.handler);
+
+    return runner(std::move(params));
+}
+
+std::vector<TaskInfo> Api::getTasks() const
+{
+    auto infos = std::vector<TaskInfo>();
+    infos.reserve(_tasks.size());
+
+    for (const auto &[id, task] : _tasks)
+    {
+        infos.push_back({id, task.getProgress()});
+    }
+
+    return infos;
 }
 
-ProgressInfo TaskManager::getProgress(TaskId id) const
+ProgressInfo Api::getTaskProgress(TaskId id) const
 {
     const auto &task = getTask(_tasks, id);
     return task.getProgress();
 }
 
-RawResult TaskManager::wait(TaskId id)
+RawResult Api::waitForTaskResult(TaskId id)
 {
     const auto &task = getTask(_tasks, id);
     auto result = task.wait();
@@ -98,7 +163,7 @@ RawResult TaskManager::wait(TaskId id)
     return result;
 }
 
-void TaskManager::cancel(TaskId id)
+void Api::cancelTask(TaskId id)
 {
     const auto &task = getTask(_tasks, id);
     task.cancel();

src/brayns/core/service/RequestHandler.h renamed to src/brayns/core/api/Api.h

@@ -21,22 +21,37 @@
 
 #pragma once
 
-#include <brayns/core/api/Endpoint.h>
-#include <brayns/core/utils/Logger.h>
-#include <brayns/core/websocket/WebSocketHandler.h>
+#include <map>
+
+#include <brayns/core/utils/IdGenerator.h>
+
+#include "Endpoint.h"
+#include "Task.h"
 
 namespace brayns
 {
-class RequestHandler
+class Api
 {
 public:
-    explicit RequestHandler(const EndpointRegistry &endpoints, TaskManager &tasks, Logger &logger);
+    explicit Api(std::map<std::string, Endpoint> endpoints);
+    ~Api();
+
+    Api(const Api &) = delete;
+    Api(Api &&) = default;
+    Api &operator=(const Api &) = delete;
+    Api &operator=(Api &&) = default;
 
-    void handle(const RawRequest &request);
+    std::vector<std::string> getMethods() const;
+    const EndpointSchema &getSchema(const std::string &method) const;
+    RawResult execute(const std::string &method, RawParams params);
+    std::vector<TaskInfo> getTasks() const;
+    ProgressInfo getTaskProgress(TaskId id) const;
+    RawResult waitForTaskResult(TaskId id);
+    void cancelTask(TaskId id);
 
 private:
-    const EndpointRegistry *_endpoints;
-    TaskManager *_tasks;
-    Logger *_logger;
+    std::map<std::string, Endpoint> _endpoints;
+    std::map<TaskId, RawTask> _tasks;
+    IdGenerator<TaskId> _ids;
 };
 }