Merge pull request #5 from fboismenu/unified_lib

Support for Isolator interface, with unique Ruby source script for hook and isolator

Author: Frédéric Boismenu

.gitignore

@@ -1 +1,2 @@
 build/
+CMakeFiles/

CMakeLists.txt

@@ -1,23 +1,43 @@
 cmake_minimum_required(VERSION 2.8)
-project(ruby_hook)
 
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -O0 -fpermissive -std=c++11")
+set(PROJECT_NAME mesos_modules_ruby)
+project(${PROJECT_NAME})
+
+set(CMAKE_MACOSX_RPATH 1)
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -O0 -Wno-macro-redefined -std=c++11")
 
 find_package(PkgConfig REQUIRED)
 
 pkg_check_modules(RUBY REQUIRED ruby-2.4)
 
 if(DEFINED ENV{MESOS_BUILD_DIR})
-  set(MESOS_BUILD_DIR "$ENV{MESOS_BUILD_DIR}")
+  set(MESOS_BUILD_DIR $ENV{MESOS_BUILD_DIR})
 else()
   set(MESOS_BUILD_DIR "${PWD}")
 endif()
 
+# Required include path lookup in Build dir
+file(GLOB BOOST_SRCH_PATH "${MESOS_BUILD_DIR}/3rdparty/boost-*")
+find_path(BOOST_INCLUDE_DIR NAMES "boost/version.hpp" PATHS ${BOOST_SRCH_PATH} NO_DEFAULT_PATH)
+
+file(GLOB PROTO_SRCH_PATH "${MESOS_BUILD_DIR}/3rdparty/protobuf-*/src")
+find_path(PROTOBUF_INCLUDE_DIR NAMES "google/protobuf/stubs/common.h" PATHS ${PROTO_SRCH_PATH} NO_DEFAULT_PATH)
+
+file(GLOB GLOG_SRCH_PATH "${MESOS_BUILD_DIR}/3rdparty/glog-*/src")
+find_path(GLOG_INCLUDE_DIR NAMES "glog/logging.h" PATHS ${GLOG_SRCH_PATH} NO_DEFAULT_PATH)
+
+file(GLOB PICOJSON_SRCH_PATH "${MESOS_BUILD_DIR}/3rdparty/picojson-*")
+find_path(PICOJSON_INCLUDE_DIR NAMES "picojson.h" PATHS ${PICOJSON_SRCH_PATH} NO_DEFAULT_PATH)
+
 include_directories(
-  "${MESOS_BUILD_DIR}/3rdparty/boost-1.53.0"
-  "${MESOS_BUILD_DIR}/3rdparty/glog-0.3.3/src"
-  "${MESOS_BUILD_DIR}/3rdparty/protobuf-3.3.0/src"
-)
+  ./include
+  ${BOOST_INCLUDE_DIR}
+  ${GLOG_INCLUDE_DIR}
+  ${PROTOBUF_INCLUDE_DIR}
+  ${PICOJSON_INCLUDE_DIR}
+  ${MESOS_BUILD_DIR}/3rdparty/stout/include
+  ${MESOS_BUILD_DIR}/3rdparty/libprocess/include
+  )
 
 pkg_check_modules(MESOS QUIET mesos)
 
@@ -26,28 +46,29 @@ if (NOT MESOS_FOUND) # Assume build tree has not been installed yet
   set(MESOS_INCLUDE_DIRS ${MESOS_BUILD_DIR}/include)
   set(MESOS_LIBRARY_DIRS ${MESOS_BUILD_DIR}/src/.libs)
   set(MESOS_LIBRARIES mesos)
-  include_directories(
-    "${MESOS_BUILD_DIR}/3rdparty/libprocess/include"
-    "${MESOS_BUILD_DIR}/3rdparty/picojson-1.3.0"
-    "${MESOS_BUILD_DIR}/3rdparty/stout/include"
-  )
 endif()
 
-set(SOURCES
-  RubyEngine.cpp
-  RubyEngine.hpp
-  RubyHook.cpp
-  RubyHook.hpp
+set(MODULES_SOURCES
+  src/RubyEngine.cpp
+  src/RubyHook.cpp
+  src/RubyIsolator.cpp
 )
 
 add_compile_options(${MESOS_CFLAGS} ${RUBY_CFLAGS})
 include_directories(${MESOS_INCLUDE_DIRS} ${RUBY_INCLUDE_DIRS})
 link_directories(${MESOS_LIBRARY_DIRS} ${RUBY_LIBRARY_DIRS})
 link_libraries(${MESOS_LIBRARIES} ${RUBY_LIBRARIES})
 
-add_library(rubyhook SHARED ${SOURCES})
+add_library(${PROJECT_NAME} SHARED ${MODULES_SOURCES})
+
+# Unit Tests building & execution
+
+add_executable(test_rmodules tests/main.cpp)
+
+file(GLOB GTEST_SRCH_PATH "${MESOS_BUILD_DIR}/3rdparty/googletest-*/googletest/include")
+find_path(GTEST_INCLUDE_DIR NAMES "gtest/gtest.h" PATHS ${GTEST_SRCH_PATH} NO_DEFAULT_PATH)
+
+target_include_directories(test_rmodules PUBLIC ${GTEST_INCLUDE_DIR} tests)
+target_link_libraries(test_rmodules ${PROJECT_NAME} ${MESOS_BUILD_DIR}/3rdparty/.libs/libgmock.a)
+add_custom_target(check COMMAND test_rmodules ${CMAKE_SOURCE_DIR}/tests/mesos_modules.rb)
 
-add_executable(test_hook main.cpp)
-target_include_directories(test_hook PUBLIC ${MESOS_BUILD_DIR}/3rdparty/googletest-release-1.8.0/googletest/include)
-target_link_libraries(test_hook rubyhook ${MESOS_BUILD_DIR}/3rdparty/.libs/libgmock.a)
-add_custom_target(check COMMAND test_hook ${CMAKE_SOURCE_DIR}/hook.rb)

README.md

@@ -1,25 +1,25 @@
-Mesos Modules Ruby
-------------------
+## Mesos Modules Ruby
 
 This repository is a collection of **experimental** mesos modules to call ruby scripts implementing hooks.
 
 This project is not battle-tested, use it at your own risk.
 
-Build Instructions
-------------------
+## Build Instructions
 
 ```shell
     $ export MESOS_BUILD_DIR=[ directory where Mesos was BUILT, e.g. ~/repos/mesos/build ]
-    $ export PKG_CONFIG_PATH=[ probably the same directory or ${installdir}/lib/pkgconfig ]
     $ mkdir build
     $ cd build
     $ cmake ..
     $ make
-    $ ./test_hook ../hook.rb
+    $ ./test_rmodules ../tests/mesos_modules.rb
 ```
 
-Scripting Documentation
------------------------
+## Scripting Documentation
+
+Example available in ./tests/mesos_modules.rb
+
+### Ruby based Mesos Hook
 
 RubyHook is currently expecting the following API from the attached Ruby script:
 
@@ -38,4 +38,36 @@ RubyHook is currently expecting the following API from the attached Ruby script:
 
 Both `taskinfo` and `execinfo` are hashes filled from equivalent C++ classes.
 For instance, you can get the name of a task with `taskinfo["name"]` and access
-the labels kv-pairs through `taskinfo["labels"]` as a string-string hash.  
+the labels kv-pairs through `taskinfo["labels"]` as a string-string hash. 
+
+### Ruby based Mesos Isolator
+
+Current implemenation supports the prepare and cleanup callback of the mesos isolator
+For details on the Isolator interface, please check directly the source code:
+ https://github.com/apache/mesos/blob/master/include/mesos/slave/isolator.hpp
+
+```ruby
+  def isolator_prepare params
+    # Params contains the container_id, user,
+    # and environment (pre-launch w/o for example the actual mesos-slave inject environment!)
+
+    return {"pre_exec_commands" => [{"value" => "touch /tmp/rb_isolator"}]} # pre exec commands
+  end
+
+  def isolator_cleanup params
+    # params: hash containing a container_id
+  end
+```
+
+## Deployement & Configuration
+
+This library supports a single source Ruby script, for both supported module interfaces: hook and isolation.
+The hook and isolation modules both supports the `script_path` parameter, and shall be pointing to the same script.
+The library will, on purpose, only take into account the first `script_path` processed.
+
+This is done on purpose to make it explicit that all modules (hook and isolator) will run in the same 
+ruby context (single vm/process).
+
+Example of json configuration file in examples sub-folder.
+Don't forget to add `com_criteo_mesos_RubyIsolator` to the list of slave's activated isolators
+(--isolation="...,com_criteo_mesos_RubyIsolator") 

RubyEngine.cpp

@@ -0,0 +1,67 @@
+#ifndef __RUBYENGINE_HPP__
+#define __RUBYENGINE_HPP__
+
+#include <ruby.h>
+#include <string>
+#include <mutex>
+#include <mesos/mesos.hpp>
+
+const std::string PARAM_SCRIPT_PATH = "script_path";
+
+namespace criteo {
+  namespace mesos {
+
+    namespace helpers{
+      void hash_set(VALUE hash, const std::string& key, const std::string& value);
+      void hash_set(VALUE hash, const std::string& key, VALUE value);
+      bool is_non_empty_hash(VALUE hash);
+      bool is_non_empty_array(VALUE array);
+    }
+
+    // Manages basic initialization of Ruby's engine
+    class RubyEngine
+    {
+      int state = 0;
+
+    public:
+      RubyEngine(const std::string& name);
+      ~RubyEngine();
+
+      bool load_script(const std::string& scriptname);
+      bool is_callback_defined(const std::string& symbol) const;
+
+      std::string handle_exception();
+    };
+
+    // This class is a singleton,
+    // to avoid multiple initializations
+    // from multiple modules.
+    //
+    // Goal is too enforce a single common ruby source script
+    // for all support modules declared here.
+    // TODO: Support Ruby based declaration of the modules
+    //
+    // /!\ First set of mesos module paramater wins!
+    //
+    class RubyEngineSingleton : public RubyEngine
+    {
+      bool started = false;
+      std::mutex m_mutex;
+
+    public:
+      static RubyEngineSingleton& getInstance();
+      void start(const ::mesos::Parameters& parameters);
+      std::mutex* mutex();
+
+    private:
+      RubyEngineSingleton();
+
+    public:
+      // remove capability to copy (by mistake) the object
+      RubyEngineSingleton(RubyEngineSingleton const&) = delete;
+      void operator=(RubyEngineSingleton const&)   = delete;
+    };
+
+  } // criteo.mesos
+}
+#endif // __RUBYENGINE_HPP__

RubyEngine.hpp

@@ -10,9 +10,6 @@
 
 class RubyHook : public mesos::Hook
 {
-  std::mutex mutex;
-  RubyEngine ruby;
-
 public:
   RubyHook(const mesos::Parameters& parameters);
 

module.json.example examples/module.json.examplemodule.json.example renamed to examples/module.json.example

@@ -0,0 +1,61 @@
+#ifndef __RUBY_ISOLATOR_MODULE_HPP__
+#define __RUBY_ISOLATOR_MODULE_HPP__
+
+#include "RubyEngine.hpp"
+
+#include <ruby.h>
+#include <mesos/mesos.hpp>
+#include <mesos/slave/isolator.hpp>
+#include <mesos/module/isolator.hpp>
+
+using ::mesos::slave::ContainerLaunchInfo;
+
+namespace criteo {
+  namespace mesos {
+
+    constexpr const char * PrepareCallbackName = "isolator_prepare";
+    constexpr const char * CleanupCallbackName = "isolator_cleanup";
+
+    class RubyIsolator : public ::mesos::slave::Isolator
+    {
+    public:
+
+      RubyIsolator(const ::mesos::Parameters& parameters);
+
+      virtual process::Future<Option<ContainerLaunchInfo>> prepare(
+          const ::mesos::ContainerID& containerId,
+          const ::mesos::slave::ContainerConfig& containerConfig) override;
+
+      virtual process::Future<Nothing> cleanup(
+          const ::mesos::ContainerID& containerId) override;
+
+    private:
+
+      bool rb2ContainerLaunchInfo(ContainerLaunchInfo& cli, VALUE ruby_value) const;
+
+    };
+   }
+ }
+
+ // Callback used by registration below...
+static mesos::slave::Isolator* createRubyIsolator(const ::mesos::Parameters& parameters)
+{
+  try {
+    return new criteo::mesos::RubyIsolator(parameters);
+  } catch (const std::exception& e) {
+    LOG(ERROR) << "RubyHook error: " << e.what();
+    return nullptr; // already wrapped in a Try<> at calling site
+  }
+}
+
+// Declaration of the isolator
+mesos::modules::Module<mesos::slave::Isolator> com_criteo_mesos_RubyIsolator(
+    MESOS_MODULE_API_VERSION,
+    MESOS_VERSION,
+    "Criteo Mesos",
+    "[email protected]",
+    "Ruby isolator module",
+    nullptr,
+    createRubyIsolator);
+
+#endif //__RUBY_ISOLATOR_MODULE_HPP__