Server side implementation.

Author: Adrien4193

apps/service.cpp

@@ -25,5 +25,5 @@ using namespace brayns;
 
 int main(int argc, const char **argv)
 {
-    return runService(argc, argv);
+    return runServiceFromArgv(argc, argv);
 }

src/brayns/core/Launcher.cpp

@@ -23,18 +23,39 @@
 
 #include <iostream>
 
+#include <brayns/core/endpoints/CoreEndpoints.h>
 #include <brayns/core/service/Service.h>
 #include <brayns/core/utils/Logger.h>
+#include <brayns/core/utils/String.h>
 
 namespace
 {
 using namespace brayns;
 
-Service createService(const ServiceSettings &settings, Logger &logger)
+void startServerAndRunService(const ServiceSettings &settings, Logger &logger)
 {
     auto level = getEnumValue<LogLevel>(settings.logLevel);
     logger.setLevel(level);
 
+    auto token = StopToken();
+
+    logger.info("Building JSON-RPC API");
+
+    auto api = Api();
+
+    auto builder = ApiBuilder();
+
+    addCoreEndpoints(builder, api, token);
+
+    api = builder.build();
+
+    logger.info("JSON-RCP API ready");
+
+    auto methods = api.getMethods();
+    logger.debug("Available methods:\n    {}", join(methods, "\n    "));
+
+    logger.info("Starting websocket server on {}:{}", settings.host, settings.port);
+
     auto ssl = std::optional<SslSettings>();
 
     if (settings.ssl)
@@ -47,7 +68,7 @@ Service createService(const ServiceSettings &settings, Logger &logger)
         };
     }
 
-    auto server = WebSocketServerSettings{
+    auto serverSettings = WebSocketServerSettings{
         .host = settings.host,
         .port = settings.port,
         .maxThreadCount = settings.maxThreadCount,
@@ -56,21 +77,19 @@ Service createService(const ServiceSettings &settings, Logger &logger)
         .ssl = std::move(ssl),
     };
 
-    auto api = Api({});
+    auto server = startServer(serverSettings, logger);
 
-    auto context = std::make_unique<ServiceContext>(ServiceContext{
-        .logger = logger,
-        .server = std::move(server),
-        .api = std::move(api),
-    });
+    logger.info("Websocket server started");
 
-    return Service(std::move(context));
+    logger.info("Service running");
+
+    runService(server, api, token, logger);
 }
 }
 
 namespace brayns
 {
-int runService(int argc, const char **argv)
+int runServiceFromArgv(int argc, const char **argv)
 {
     auto logger = createConsoleLogger("brayns");
 
@@ -90,20 +109,22 @@ int runService(int argc, const char **argv)
             return 0;
         }
 
-        auto service = createService(settings, logger);
+        logger.info("{}", getCopyright());
+
+        logger.debug("Service options:{}", stringifyArgvSettings(settings));
 
-        service.run();
+        startServerAndRunService(settings, logger);
 
         return 0;
     }
     catch (const std::exception &e)
     {
-        logger.fatal("Cannot start service: {}", e.what());
+        logger.fatal("Fatal error: {}", e.what());
         return 1;
     }
     catch (...)
     {
-        logger.fatal("Cannot start service for unknown reason");
+        logger.fatal("Unknown fatal error");
         return 1;
     }
 }

src/brayns/core/Launcher.h

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

src/brayns/core/api/Api.h

@@ -33,7 +33,7 @@ namespace brayns
 class Api
 {
 public:
-    explicit Api(std::map<std::string, Endpoint> endpoints);
+    explicit Api(std::map<std::string, Endpoint> endpoints = {});
     ~Api();
 
     Api(const Api &) = delete;

src/brayns/core/api/ApiReflector.h

@@ -70,6 +70,25 @@ struct Params
     std::string binary = {};
 };
 
+template<>
+struct ApiReflector<RawParams>
+{
+    static JsonSchema getSchema()
+    {
+        return getJsonSchema<JsonValue>();
+    }
+
+    static RawResult serialize(RawParams)
+    {
+        throw std::invalid_argument("Cannot serialize params");
+    }
+
+    static RawParams deserialize(RawParams params)
+    {
+        return params;
+    }
+};
+
 template<ReflectedJson T>
 struct ApiReflector<Params<T>>
 {
@@ -78,7 +97,7 @@ struct ApiReflector<Params<T>>
         return getJsonSchema<T>();
     }
 
-    static RawResult serialize(Params<T> value)
+    static RawResult serialize(Params<T>)
     {
         throw std::invalid_argument("Cannot serialize params");
     }
@@ -96,6 +115,25 @@ struct Result
     std::string binary = {};
 };
 
+template<>
+struct ApiReflector<RawResult>
+{
+    static JsonSchema getSchema()
+    {
+        return getJsonSchema<JsonValue>();
+    }
+
+    static RawResult serialize(RawResult value)
+    {
+        return value;
+    }
+
+    static RawResult deserialize(RawParams)
+    {
+        throw std::invalid_argument("Cannot deserialize result");
+    }
+};
+
 template<ReflectedJson T>
 struct ApiReflector<Result<T>>
 {
@@ -109,7 +147,7 @@ struct ApiReflector<Result<T>>
         return {serializeToJson(result.value), std::move(result.binary)};
     }
 
-    static Result<T> deserialize(RawParams params)
+    static Result<T> deserialize(RawParams)
     {
         throw std::invalid_argument("Cannot deserialize result");
     }

src/brayns/core/api/Endpoint.h

@@ -41,7 +41,7 @@ struct EndpointSchema
 };
 
 template<>
-struct JsonReflector<EndpointSchema>
+struct JsonObjectReflector<EndpointSchema>
 {
     static auto reflect()
     {

src/brayns/core/api/Progress.h

@@ -38,7 +38,7 @@ struct ProgressInfo
 };
 
 template<>
-struct JsonReflector<ProgressInfo>
+struct JsonObjectReflector<ProgressInfo>
 {
     static auto reflect()
     {

src/brayns/core/api/Task.h

@@ -62,7 +62,8 @@ struct JsonObjectReflector<TaskResult>
     static auto reflect()
     {
         auto builder = JsonBuilder<TaskResult>();
-        builder.field("task_id", [](auto &object) { return &object.taskId; });
+        builder.field("task_id", [](auto &object) { return &object.taskId; })
+            .description("ID of the task started by the method");
         return builder.build();
     }
 };
@@ -72,4 +73,16 @@ struct TaskInfo
     TaskId id;
     ProgressInfo progress;
 };
+
+template<>
+struct JsonObjectReflector<TaskInfo>
+{
+    static auto reflect()
+    {
+        auto builder = JsonBuilder<TaskInfo>();
+        builder.field("id", [](auto &object) { return &object.id; }).description("Task ID to monitor it");
+        builder.field("progress", [](auto &object) { return &object.progress; }).description("Current task progress");
+        return builder.build();
+    }
+};
 }

src/brayns/core/cli/CommandLine.h

@@ -47,6 +47,7 @@ struct ArgvOption
     std::string description;
     std::string defaultValue;
     std::function<void(std::string_view, SettingsType &)> parse;
+    std::function<std::string(const SettingsType &)> toString;
 };
 
 template<typename SettingsType>
@@ -109,6 +110,18 @@ class ArgvInfo
         return result;
     }
 
+    std::string toString(const SettingsType &settings) const
+    {
+        auto stream = std::ostringstream();
+
+        for (const auto &[key, option] : _options)
+        {
+            stream << "\n    --" << key << ": " << option.toString(settings);
+        }
+
+        return stream.str();
+    }
+
 private:
     std::string _description;
     ArgvOptions<SettingsType> _options;
@@ -119,7 +132,7 @@ struct ArgvReflector;
 
 template<typename T>
 concept ReflectedArgvOption = std::same_as<std::string, decltype(ArgvReflector<T>::getType())>
-    && std::same_as<std::string, decltype(ArgvReflector<T>::display(T()))>
+    && std::same_as<std::string, decltype(ArgvReflector<T>::toString(T()))>
     && std::same_as<T, decltype(ArgvReflector<T>::parse(std::string_view()))>;
 
 template<>
@@ -130,7 +143,7 @@ struct ArgvReflector<bool>
         return "boolean";
     }
 
-    static std::string display(bool value)
+    static std::string toString(bool value)
     {
         return value ? "true" : "false";
     }
@@ -155,7 +168,7 @@ struct ArgvReflector<T>
         return std::is_integral_v<T> ? "integer" : "number";
     }
 
-    static std::string display(const T &value)
+    static std::string toString(const T &value)
     {
         return fmt::format("{}", value);
     }
@@ -174,7 +187,7 @@ struct ArgvReflector<std::string>
         return "string";
     }
 
-    static std::string display(const std::string &value)
+    static std::string toString(const std::string &value)
     {
         return value;
     }
@@ -203,7 +216,7 @@ class ArgvOptionBuilder
     template<ReflectedArgvOption T>
     ArgvOptionBuilder defaultValue(const T &value)
     {
-        _option->defaultValue = ArgvReflector<T>::display(value);
+        _option->defaultValue = ArgvReflector<T>::toString(value);
         return *this;
     }
 
@@ -221,7 +234,8 @@ using GetOptionType = std::decay_t<std::remove_pointer_t<std::invoke_result_t<Ge
 
 template<typename GetterType, typename SettingsType>
 concept ArgvOptionGetter =
-    std::invocable<GetterType, SettingsType &> && std::is_pointer_v<std::invoke_result_t<GetterType, SettingsType &>>
+    std::invocable<GetterType, SettingsType &> && std::invocable<GetterType, const SettingsType &>
+    && std::is_pointer_v<std::invoke_result_t<GetterType, SettingsType &>>
     && ReflectedArgvOption<GetOptionType<GetterType, SettingsType>>;
 
 template<typename SettingsType>
@@ -249,6 +263,7 @@ class ArgvBuilder
         option.key = std::move(key);
         option.type = Reflector::getType();
         option.parse = [=](auto data, auto &settings) { *getOptionPtr(settings) = Reflector::parse(data); };
+        option.toString = [=](const auto &settings) { return Reflector::toString(*getOptionPtr(settings)); };
 
         return ArgvOptionBuilder<SettingsType>(option);
     }
@@ -294,4 +309,10 @@ SettingsType parseArgvAs(int argc, const char **argv)
     auto map = parseArgv(argc, argv);
     return parseArgvAs<SettingsType>(map);
 }
+
+template<ReflectedArgvSettings SettingsType>
+std::string stringifyArgvSettings(const SettingsType &settings)
+{
+    return reflectArgvSettings<SettingsType>().toString(settings);
+}
 }