Initial commit

Author: cinemast

CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+- Initial implementation of 1.0 and 2.0 server
+- Initial implementation of 1.0 and 2.0 client
+- Test suite for server and client

CMakeLists.txt

@@ -0,0 +1,9 @@
+cmake_minimum_required(VERSION 3.12)
+set(CMAKE_CXX_STANDARD 17)
+project(libjson-rpc-cpp VERSION 2.0.0 LANGUAGES CXX)
+
+add_executable(jsonrpccpp-test src/client.hpp src/dispatcher.hpp src/main.cpp src/client.test.cpp src/typemapper.test.cpp src/dispatcher.test.cpp src/server.test.cpp)
+target_include_directories(jsonrpccpp-test PUBLIC vendor src)
+
+enable_testing()
+add_test(NAME test COMMAND jsonrpccpp-test)

CONTRIBUTING.md

@@ -0,0 +1,2 @@
+# Code style
+Please make sure your editor picks up the [.clang-format](.clang-format) file.

LICENSE

@@ -0,0 +1,18 @@
+Copyright (C) 2019 Peter Spiess-Knafl <[email protected]>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in the
+Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -0,0 +1,40 @@
+**THIS IS A WORK IN PROGRESS PROJECT**
+
+#json-rpc-cxx
+![json-rpc-cxx-icon](doc/icon.png)
+
+A [JSON-RPC](https://www.jsonrpc.org/) (1.0 & 2.0) framework implemented in C++17 using the [nlohmann's json for modern C++](https://github.com/nlohmann/json).
+
+- JSON-RPC 1.0 and 2.0 compliant client
+- JSON-RCP 1.0 and 2.0 compliant server
+- Transport agnostic interfaces
+- Compile time type mapping (using [nlohmann's arbitrary type conversion](https://github.com/nlohmann/json#arbitrary-types-conversions))
+- Runtime type checking
+- Cross-platform (Windows, Linux, OSX)
+
+## Usage
+TBD
+
+### Installation
+TBD, probably vcpkg and header only
+### Examples
+Examples can be found in [src/examples](src/examples)
+
+## Design goals
+- Easy to use interface
+- Type safety where possible
+- Avoid errors at compile time where possible
+- Test driven development
+- Choose expressiveness over speed
+- Minimal dependencies
+
+## License
+This framework is licensed under [MIT](LICENSE).
+
+### Dependencies
+- [nlohmann's JSON for modern C++](https://github.com/nlohmann/json) is licensed under MIT.
+- [Catch](https://github.com/catchorg/Catch2) is licensed under BSL-1.0.
+
+## Developer information
+- [CONTRIBUTING.md](CONTRIBUTING.md)
+- [CHANGELOG.md](CHANGELOG.md)

doc/icon.png

@@ -0,0 +1,193 @@
+#pragma once
+#include "common.hpp"
+#include <exception>
+#include <nlohmann/json.hpp>
+#include <string>
+#include <variant>
+
+namespace jsonrpccpp {
+  enum class version { v1, v2 };
+  enum class param_type { by_position, by_name };
+
+  typedef std::vector<json> positional_parameter;
+  typedef std::map<std::string, json> named_parameter;
+  typedef std::variant<int, std::string> id_type;
+
+  struct JsonRpcResponse {
+    std::string id;
+    json result;
+  };
+
+  class IClientConnector {
+  public:
+    virtual ~IClientConnector() = default;
+    virtual std::string Send(const std::string &request) = 0;
+  };
+
+  //TODO: add batch calls
+
+  class JsonRpcClient {
+  public:
+    JsonRpcClient(IClientConnector &connector, version v) : connector(connector), v(v) {}
+    virtual ~JsonRpcClient() = default;
+
+    JsonRpcResponse CallMethod(const id_type &id, const std::string &name, const positional_parameter &params = {}) { return call_method(id, name, params); }
+    JsonRpcResponse CallMethodNamed(const id_type &id, const std::string &name, const named_parameter &params = {}) { return call_method(id, name, params); }
+
+    void CallNotification(const std::string &name, const positional_parameter &params = {}) { call_notification(name, params); }
+    void CallNotificationNamed(const std::string &name, const named_parameter &params = {}) { call_notification(name, params); }
+
+  protected:
+    IClientConnector &connector;
+
+  private:
+    version v;
+    static inline bool has_key(const json &v, const std::string &key) { return v.find(key) != v.end(); }
+    static inline bool has_key_type(const json &v, const std::string &key, json::value_t type) { return has_key(v, key) && v.at(key).type() == type; }
+
+    inline JsonRpcException get_error(const json &value) {
+      bool has_code = has_key_type(value, "code", json::value_t::number_integer);
+      bool has_message = has_key_type(value, "message", json::value_t::string);
+      bool has_data = has_key(value, "data");
+      if (has_code && has_message) {
+        if (has_data) {
+          return JsonRpcException(value["code"], value["message"], value["data"].get<json>());
+        } else {
+          return JsonRpcException(value["code"], value["message"]);
+        }
+      }
+      return JsonRpcException(-32603, R"(invalid error response: "code" (negative number) and "message" (string) are required)");
+    }
+
+    JsonRpcResponse call_method(const id_type &id, const std::string &name, const json &params) {
+      json j = {{"method", name}};
+      if (std::get_if<int>(&id) != nullptr) {
+        j["id"] = std::get<int>(id);
+      } else {
+        j["id"] = std::get<std::string>(id);
+      }
+      if (v == version::v2) {
+        j["jsonrpc"] = "2.0";
+      }
+      if (!params.empty() && !params.is_null()) {
+        j["params"] = params;
+      } else if (v == version::v1) {
+        j["params"] = nullptr;
+      }
+      try {
+        json response = json::parse(connector.Send(j.dump()));
+        if (has_key_type(response, "error", json::value_t::object)) {
+          throw get_error(response["error"]);
+        }
+        if (has_key(response, "result") && has_key(response, "id")) {
+          return JsonRpcResponse{response["id"].get<std::string>(), response["result"].get<json>()};
+        }
+        throw JsonRpcException(-32603, R"(invalid server response: neither "result" nor "error" fields found)");
+      } catch (json::parse_error &e) {
+        throw JsonRpcException(-32700, std::string("invalid JSON response from server: ") + e.what());
+      }
+    }
+
+    void call_notification(const std::string &name, const nlohmann::json &params) {
+      nlohmann::json j = {{"method", name}};
+      if (v == version::v2) {
+        j["jsonrpc"] = "2.0";
+      } else {
+        j["id"] = nullptr;
+      }
+      if (!params.empty() && !params.is_null()) {
+        j["params"] = params;
+      } else if (v == version::v1) {
+        j["params"] = nullptr;
+      }
+      connector.Send(j.dump());
+    }
+  };
+
+  class BatchRequest {
+  public:
+      BatchRequest() : call(json::array()) {}
+
+      BatchRequest& AddMethodCall(const id_type &id, const std::string& name, const positional_parameter &params = {}) {
+          json request = {{"method", name}, {"params", params}, {"jsonrpc", "2.0"}};
+          if (std::get_if<int>(&id) != nullptr) {
+              request["id"] = std::get<int>(id);
+          } else {
+              request["id"] = std::get<std::string>(id);
+          }
+          call.push_back(request);
+          return *this;
+      }
+
+      BatchRequest& AddNamedMethodCall(const id_type &id, const std::string& name, const named_parameter &params = {}) {
+          json request = {{"method", name}, {"params", params}, {"jsonrpc", "2.0"}};
+          if (std::get_if<int>(&id) != nullptr) {
+              request["id"] = std::get<int>(id);
+          } else {
+              request["id"] = std::get<std::string>(id);
+          }
+          call.push_back(request);
+          return *this;
+      }
+
+      BatchRequest& AddNotificationCall(const std::string& name, const positional_parameter &params = {}) {
+          call.push_back({{"method", name}, {"params", params}, {"jsonrpc", "2.0"}});
+          return *this;
+      }
+
+      BatchRequest& AddNamedNotificationCall(const std::string& name, const named_parameter &params = {}) {
+          call.push_back({{"method", name}, {"params", params}, {"jsonrpc", "2.0"}});
+          return *this;
+      }
+
+      const json& Build() const {
+          return call;
+      }
+  private:
+      json call;
+  };
+
+  class BatchResponse {
+  public:
+      BatchResponse(std::map<json, json>&& results, std::map<json, JsonRpcException> &&errors) {
+          this->errors = errors;
+          this->results = results;
+      }
+
+      template<typename T>
+      T GetResult(const json& id) {
+        if (results.find(id) != results.end()) {
+            //TOOD: catch type conversion error
+            return results[id].get<T>();
+        } else if (errors.find(id) != errors.end()) {
+            throw errors[id];
+        }
+        throw JsonRpcException(-32700, std::string("no result found for id ") + id.dump());
+      }
+
+  private:
+      std::map<json, json> results;
+      std::map<json, JsonRpcException> errors;
+  };
+
+  class JsonRpc2Client : public JsonRpcClient {
+  public:
+      JsonRpc2Client(IClientConnector &connector) : JsonRpcClient(connector, version::v2) {}
+
+      BatchResponse BatchCall(const BatchRequest& request) {
+        try {
+          json response = json::parse(connector.Send(request.Build().dump()));
+          if (!response.is_array()) {
+            throw JsonRpcException(-32700, std::string("invalid JSON response from server: expected array"));
+          }
+          std::map<json, json> results;
+          std::map<json, JsonRpcException> errors;
+
+          return BatchResponse(std::move(results), std::move(errors));
+        } catch (json::parse_error &e) {
+          throw JsonRpcException(-32700, std::string("invalid JSON response from server: ") + e.what());
+        }
+      }
+
+  };
+} // namespace jsonrpccpp