Add conan support

Author: basiliscos

.circleci/config.yml

@@ -53,9 +53,25 @@ jobs:
               cd build && cmake -DBUILD_DOC=on -DBUILD_THREAD=on -DBUILD_BOOST_ASIO=on -DBUILD_EV=on ..
               make -j2 && ctest .
 
+  build_conan:
+    docker:
+      - image: debian:10
+    resource_class: medium
+    steps:
+      - checkout
+      - run:
+          name: "prepare & build"
+          command: |
+              apt-get update
+              apt-get install -y cmake clang python3-pip
+              pip3 install conan
+              conan create conanfile.py rotor/0.20@
+
+
 workflows:
   build-all-workflow:
     jobs:
       - build_gcc
       - build_clang
       - build_arm
+      - build_conan

conanfile.py

@@ -0,0 +1,109 @@
+from conans import ConanFile, CMake, tools
+from conans.errors import ConanInvalidConfiguration
+import os
+
+required_conan_version = ">=1.43.0"
+
+
+class RotorConan(ConanFile):
+    name = "rotor"
+    license = "MIT"
+    homepage = "https://github.com/basiliscos/cpp-rotor"
+    url = "https://github.com/conan-io/conan-center-index"
+    description = (
+        "Event loop friendly C++ actor micro-framework, supervisable"
+    )
+    topics = ("concurrency", "actor-framework", "actors", "actor-model", "erlang", "supervising", "supervisor")
+
+    settings = "os", "arch", "compiler", "build_type"
+    options = {
+        "fPIC": [True, False],
+        "boost_asio": [True, False],
+        "thread": [True, False],
+    }
+    default_options = {
+        "fPIC": True,
+        "boost_asio": True,
+        "thread": True,
+    }
+
+    exports_sources = ["CMakeLists.txt"]
+    generators = "cmake"
+    _cmake = None
+
+    @property
+    def _source_subfolder(self):
+        return "source_subfolder"
+
+    @property
+    def _build_subfolder(self):
+        return "build_subfolder"
+
+    def config_options(self):
+        if self.settings.os == "Windows":
+            del self.options.fPIC
+
+    def requirements(self):
+        self.requires("boost/1.69.0")
+
+
+    def validate(self):
+        minimal_cpp_standard = "17"
+        if self.settings.compiler.get_safe("cppstd"):
+            tools.check_min_cppstd(self, minimal_cpp_standard)
+        minimal_version = {
+            "gcc": "7",
+            "clang": "6",
+            "apple-clang": "10",
+            "Visual Studio": "15"
+        }
+        compiler = str(self.settings.compiler)
+        if compiler not in minimal_version:
+            self.output.warn(
+                "%s recipe lacks information about the %s compiler standard version support" % (self.name, compiler))
+            self.output.warn(
+                "%s requires a compiler that supports at least C++%s" % (self.name, minimal_cpp_standard))
+            return
+
+        version = tools.Version(self.settings.compiler.version)
+        if version < minimal_version[compiler]:
+            raise ConanInvalidConfiguration("%s requires a compiler that supports at least C++%s" % (self.name, minimal_cpp_standard))
+
+    def _configure_cmake(self):
+        if self._cmake:
+            return self._cmake
+
+        self._cmake = CMake(self)
+        self._cmake.definitions["BUILD_BOOST_ASIO"] = self.options.boost_asio
+        self._cmake.definitions["BUILD_THREAD"] = self.options.thread
+        self._cmake.configure(build_folder=self._build_subfolder)
+        return self._cmake
+
+    def build(self):
+        cmake = self._configure_cmake()
+        cmake.build()
+
+    def source(self):
+        tools.get(**self.conan_data["sources"][self.version],
+                  destination=self._source_subfolder, strip_root=True)
+
+    def package(self):
+        cmake = self._configure_cmake()
+        cmake.install()
+        self.copy("license*", src=self._source_subfolder, dst="licenses",  ignore_case=True, keep_path=False)
+        tools.rmdir(os.path.join(self.package_folder, "lib", "cmake"))
+
+    def package_info(self):
+        self.cpp_info.components["core"].libs = ["rotor-core"]
+        self.cpp_info.components["core"].requires = ["boost::date_time", "boost::system", "boost::regex"]
+
+        self.cpp_info.components["asio"].libs = ["rotor-asio"]
+        self.cpp_info.components["asio"].requires = ["core"]
+
+        self.cpp_info.components["thread"].libs = ["rotor-thread"]
+        self.cpp_info.components["thread"].requires = ["core"]
+
+        # TODO: to remove in conan v2 once cmake_find_package* generators removed
+        self.cpp_info.names["cmake_find_package"] = "rotor"
+        self.cpp_info.names["cmake_find_package_multi"] = "rotor"
+

test_package/CMakeLists.txt

@@ -0,0 +1,8 @@
+cmake_minimum_required(VERSION 3.8)
+project(test_package CXX)
+
+find_package("rotor" COMPONENTS asio thread REQUIRED)
+
+add_executable(${PROJECT_NAME} test_package.cpp)
+target_compile_features(${PROJECT_NAME} PRIVATE cxx_std_17)
+target_link_libraries(${PROJECT_NAME} rotor::asio rotor::thread)

test_package/conanfile.py

@@ -0,0 +1,17 @@
+from conans import ConanFile, CMake, tools
+import os
+
+
+class TestPackageConan(ConanFile):
+    settings = "os", "arch", "compiler", "build_type"
+    generators = "cmake_find_package"
+
+    def build(self):
+        cmake = CMake(self)
+        cmake.configure()
+        cmake.build()
+
+    def test(self):
+        if not tools.cross_building(self):
+            self.run("test_package", run_environment=True)
+

test_package/test_package.cpp

@@ -0,0 +1,33 @@
+#include <rotor/asio.hpp>
+#include <rotor/thread.hpp>
+
+namespace asio = boost::asio;
+namespace pt = boost::posix_time;
+
+struct server_actor : public rotor::actor_base_t {
+    using rotor::actor_base_t::actor_base_t;
+    void on_start() noexcept override {
+        rotor::actor_base_t::on_start();
+        std::cout << "hello world\n";
+        do_shutdown();
+    }
+};
+
+int main() {
+    asio::io_context io_context;
+    auto system_context = rotor::asio::system_context_asio_t::ptr_t{new rotor::asio::system_context_asio_t(io_context)};
+    auto strand = std::make_shared<asio::io_context::strand>(io_context);
+    auto timeout = boost::posix_time::milliseconds{500};
+    auto sup =
+        system_context->create_supervisor<rotor::asio::supervisor_asio_t>().strand(strand).timeout(timeout).finish();
+
+    sup->create_actor<server_actor>().timeout(timeout).autoshutdown_supervisor().finish();
+
+    sup->start();
+    io_context.run();
+
+    rotor::thread::system_context_thread_t thread_ctx;
+
+    return 0;
+}
+