journald-native 1.0.6 → 1.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7074ca755c39b71b382f63b7befe21e0dc7e18ec
-  data.tar.gz: 585840efef3b5ee2b50f97e830ecf21df0ec811b
+  metadata.gz: 4020a007bf01dcb53dde8935a7772ab71e28c882
+  data.tar.gz: b95b33ae4d6014cf76c0b1b6e138829274f3d433
 SHA512:
-  metadata.gz: e19cdf3224ca356c47319c5dd6897cc364a8f4d87a1f9c7d9319a31be19be2b4298cbc1b869024e8f0846f48115947dc296afb9d809de368bc16ae18434cdb2a
-  data.tar.gz: 214828671762b128ae1875fffce35e8a3db25217db47e6bca8d4a127750c3ad1ca55d9c8999c623829dce3a8b998ffe70d2fe62395b3dedf75b3479d3487532a
+  metadata.gz: 6ab72f2d53e00b60be3489609ee7065e293bef46c13145c14cfae7eae4adddbb465e1a4a785ba05930a50f1b97fa5de809a20f0b2d628a9073d7655c82dd3f74
+  data.tar.gz: 3983b62b9f1dc7367013048cab266f2adc71b5c0ed14ae9ad77bafe214866d6310c5d7b70f672d10636319815d7d815b4cab5a1078cbf672909d69c8659ebbef

data/README.md

@@ -30,13 +30,13 @@ Journald::LOG_DEBUG     # debug-level messages
 ```
 
 systemd-journal uses syslog constants to denote level therefore they are equal to those of the Syslog module,
-e.g. ```Journald::LOG_WARNING == Syslog::LOG_WARNING```. 
+e.g. ```Journald::LOG_WARNING == Syslog::LOG_WARNING```.
 [See syslog man page for more info](http://man7.org/linux/man-pages/man3/syslog.3.html)
 
 ### Methods
 
-Methods of Journald::Native class wrap systemd-journal calls. 
-[See sd-journal help for more info](http://www.freedesktop.org/software/systemd/man/sd_journal_print.html) 
+Methods of Journald::Native class wrap systemd-journal calls.
+[See sd-journal help for more info](http://www.freedesktop.org/software/systemd/man/sd_journal_print.html)
 
 ```ruby
 Journald::Native.send "MESSAGE=message", "PRIORITY=#{Journald::LOG_WARNING}"

data/ext/journald_native/extconf.rb

@@ -8,7 +8,7 @@ LIB_DIRS    = [LIBDIR]
 
 dir_config('systemd', HEADER_DIRS, LIB_DIRS)
 
-$CPPFLAGS = '-std=c++11'
+$CFLAGS = '-std=c99'
 
 def have_funcs
   have_funcs = true

data/ext/journald_native/journald_native.c

@@ -0,0 +1,117 @@
+/* Do not add C line and file to the log messages */
+#define SD_JOURNAL_SUPPRESS_LOCATION
+
+#include <ruby.h>
+#include "sd_journal.h"
+
+void Init_journald_native();
+
+/* initializers */
+static void jdl_init_modules();
+static void jdl_init_constants();
+static void jdl_init_methods();
+
+/* methods */
+static VALUE jdl_native_print(VALUE self, VALUE priority, VALUE message);
+static VALUE jdl_native_send(int argc, VALUE* argv, VALUE self);
+static VALUE jdl_native_perror(VALUE self, VALUE message);
+static VALUE jdl_native_is_dummy();
+
+/* globals */
+static VALUE mJournald;
+static VALUE mNative;
+
+void Init_journald_native()
+{
+    jdl_init_modules();
+    jdl_init_constants();
+    jdl_init_methods();
+}
+
+static void jdl_init_modules()
+{
+    mJournald = rb_define_module("Journald");
+    mNative   = rb_define_module_under(mJournald, "Native");
+}
+
+static void jdl_init_constants()
+{
+    rb_define_const(mJournald, "LOG_EMERG",   INT2NUM(LOG_EMERG));    /* system is unusable */
+    rb_define_const(mJournald, "LOG_ALERT",   INT2NUM(LOG_ALERT));    /* action must be taken immediately */
+    rb_define_const(mJournald, "LOG_CRIT",    INT2NUM(LOG_CRIT));     /* critical conditions */
+    rb_define_const(mJournald, "LOG_ERR",     INT2NUM(LOG_ERR));      /* error conditions */
+    rb_define_const(mJournald, "LOG_WARNING", INT2NUM(LOG_WARNING));  /* warning conditions */
+    rb_define_const(mJournald, "LOG_NOTICE",  INT2NUM(LOG_NOTICE));   /* normal but significant condition */
+    rb_define_const(mJournald, "LOG_INFO",    INT2NUM(LOG_INFO));     /* informational */
+    rb_define_const(mJournald, "LOG_DEBUG",   INT2NUM(LOG_DEBUG));    /* debug-level messages */
+
+    // dummy detection const
+    rb_define_const(mNative,   "IS_DUMMY",    jdl_native_is_dummy());
+}
+
+static void jdl_init_methods()
+{
+    rb_define_singleton_method(mNative, "print",  jdl_native_print,  2);
+    rb_define_singleton_method(mNative, "send",   jdl_native_send,  -1); /* -1 to pass as C array */
+    rb_define_singleton_method(mNative, "perror", jdl_native_perror, 1);
+
+    // dummy detection method
+    rb_define_singleton_method(mNative, "dummy?", jdl_native_is_dummy, 0);
+}
+
+static VALUE jdl_native_print(VALUE v_self, VALUE v_priority, VALUE v_message)
+{
+    int priority, result;
+    char *message;
+
+    priority = NUM2INT(v_priority);
+    message  = StringValueCStr(v_message);
+
+    result = sd_journal_print(priority, "%s", message);
+
+    return INT2NUM(result);
+}
+
+static VALUE jdl_native_send(int argc, VALUE* argv, VALUE self)
+{
+    struct iovec *msgs;
+    int i;
+    int result;
+
+    /* first check everything is a string / convertable to string */
+    for (i = 0; i < argc; i++) {
+        StringValue(argv[i]); /* you may get a ruby exception here */
+    }
+
+    /* allocate memory after all checks to avoid possible memory leak */
+    msgs = calloc(argc, sizeof(struct iovec));
+
+    for (i = 0; i < argc; i++) {
+        VALUE v = argv[i];
+        msgs[i].iov_base = RSTRING_PTR(v);
+        msgs[i].iov_len  = RSTRING_LEN(v);
+    }
+
+    result = sd_journal_sendv(msgs, argc);
+
+    free(msgs);
+
+    return INT2NUM(result);
+}
+
+static VALUE jdl_native_perror(VALUE v_self, VALUE v_message)
+{
+    int result;
+    char *message;
+
+    message = StringValueCStr(v_message);
+
+    result = sd_journal_perror(message);
+
+    return INT2NUM(result);
+}
+
+static VALUE jdl_native_is_dummy()
+{
+    return JOURNALD_NATIVE_SD_JOURNAL_DUMMY ? Qtrue : Qfalse;
+}

data/ext/journald_native/sd_journal.h

@@ -1,45 +1,55 @@
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #ifndef JOURNALD_NATIVE_SD_JOURNAL_H
-#define JOURNALD_NATIVE_SD_JOURNAL_H
+    #define JOURNALD_NATIVE_SD_JOURNAL_H
 
-#ifdef __linux__
+    #ifdef __linux__
 
-    #define JOURNALD_NATIVE_SD_JOURNAL_DUMMY false
+        #define JOURNALD_NATIVE_SD_JOURNAL_DUMMY false
 
-    /* do the real stuff */
+        /* do the real stuff */
 
-    #include "extconf.h"
+        #include "extconf.h"
 
-    /* check for extconf results */
+        /* check for extconf results */
 
-    #ifndef HAVE_SYSTEMD_SD_JOURNAL_H
-        #error Cannot include <systemd/sd-journal.h>. Please use linux version with systemd-journal installed
-    #endif
+        #ifndef HAVE_SYSTEMD_SD_JOURNAL_H
+            #error Cannot include <systemd/sd-journal.h>. Please use linux version with systemd-journal installed
+        #endif
 
-    #ifndef HAVE_SD_JOURNAL_PRINT
-        #error Required function sd_journal_print is missing
-    #endif
+        #ifndef HAVE_SD_JOURNAL_PRINT
+            #error Required function sd_journal_print is missing
+        #endif
 
-    #ifndef HAVE_SD_JOURNAL_SENDV
-        #error Required function sd_journal_sendv is missing
-    #endif
+        #ifndef HAVE_SD_JOURNAL_SENDV
+            #error Required function sd_journal_sendv is missing
+        #endif
 
-    #ifndef HAVE_SD_JOURNAL_PERROR
-        #error Required function sd_journal_perror is missing
-    #endif
+        #ifndef HAVE_SD_JOURNAL_PERROR
+            #error Required function sd_journal_perror is missing
+        #endif
 
-    /* Do not add C line and file to the log messages */
-    #define SD_JOURNAL_SUPPRESS_LOCATION
-    /* include systemd-journal headers */
-    #include <systemd/sd-journal.h>
+        /* Do not add C line and file to the log messages */
+        #define SD_JOURNAL_SUPPRESS_LOCATION
+        /* include systemd-journal headers */
+        #include <systemd/sd-journal.h>
 
-#else
+    #else
 
-    #define JOURNALD_NATIVE_SD_JOURNAL_DUMMY true
+        #define JOURNALD_NATIVE_SD_JOURNAL_DUMMY true
 
-    #warning Compiling dummy version of the gem for non-Linux OS
+        #warning Compiling dummy version of the gem for non-Linux OS
 
-    #include "sd_journal_dummy.h"
+        #include "sd_journal_dummy.h"
+
+    #endif
 
+#ifdef __cplusplus
+}
 #endif
 
 #endif // JOURNALD_NATIVE_SD_JOURNAL_H

data/lib/journald/native/version.rb

@@ -1,5 +1,5 @@
 module Journald
   module Native
-    VERSION = '1.0.6'
+    VERSION = '1.0.7'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: journald-native
 version: !ruby/object:Gem::Version
-  version: 1.0.6
+  version: 1.0.7
 platform: ruby
 authors:
 - Anton Smirnov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-10 00:00:00.000000000 Z
+date: 2015-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -65,14 +65,8 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- ext/journald_native/CMakeLists.txt
-- ext/journald_native/cpp14shiv.h
 - ext/journald_native/extconf.rb
-- ext/journald_native/extinit.cpp
-- ext/journald_native/journald_native.cpp
-- ext/journald_native/journald_native.h
-- ext/journald_native/ruby_exception_wrapper.cpp
-- ext/journald_native/ruby_exception_wrapper.h
+- ext/journald_native/journald_native.c
 - ext/journald_native/sd_journal.h
 - ext/journald_native/sd_journal_dummy.h
 - journald-native.gemspec
@@ -98,7 +92,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.3
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: systemd-journal logging native lib wrapper

data/ext/journald_native/CMakeLists.txt

@@ -1,9 +0,0 @@
-# dummy cmake file for CLion
-
-cmake_minimum_required(VERSION 2.8.4)
-project(journald_native)
-
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
-
-set(SOURCE_FILES extinit.cpp journald_native.cpp ruby_exception_wrapper.cpp)
-add_executable(journald_native ${SOURCE_FILES})

data/ext/journald_native/cpp14shiv.h

@@ -1,78 +0,0 @@
-/*
-    unique_ptr from http://isocpp.org/files/papers/N3656.txt
-    index sequence from gcc 4.9 sources
-*/
-
-#include <cstddef>
-#include <memory>
-#include <type_traits>
-#include <utility>
-
-namespace std {
-    template<class T> struct _Unique_if {
-        typedef unique_ptr<T> _Single_object;
-    };
-
-    template<class T> struct _Unique_if<T[]> {
-        typedef unique_ptr<T[]> _Unknown_bound;
-    };
-
-    template<class T, size_t N> struct _Unique_if<T[N]> {
-        typedef void _Known_bound;
-    };
-
-    template<class T, class... Args>
-        typename _Unique_if<T>::_Single_object
-        make_unique(Args&&... args) {
-            return unique_ptr<T>(new T(std::forward<Args>(args)...));
-        }
-
-    template<class T>
-        typename _Unique_if<T>::_Unknown_bound
-        make_unique(size_t n) {
-            typedef typename remove_extent<T>::type U;
-            return unique_ptr<T>(new U[n]());
-        }
-
-    template<class T, class... Args>
-        typename _Unique_if<T>::_Known_bound
-        make_unique(Args&&...) = delete;
-
-    /// Class template integer_sequence
-    template<typename _Tp, _Tp... _Idx>
-    struct integer_sequence
-    {
-        typedef _Tp value_type;
-        static constexpr size_t size() { return sizeof...(_Idx); }
-    };
-
-    template<typename _Tp, _Tp _Num,
-            typename _ISeq = typename _Build_index_tuple<_Num>::__type>
-    struct _Make_integer_sequence;
-
-    template<typename _Tp, _Tp _Num,  size_t... _Idx>
-    struct _Make_integer_sequence<_Tp, _Num, _Index_tuple<_Idx...>>
-    {
-        static_assert( _Num >= 0,
-                "Cannot make integer sequence of negative length" );
-
-        typedef integer_sequence<_Tp, static_cast<_Tp>(_Idx)...> __type;
-    };
-
-    /// Alias template make_integer_sequence
-    template<typename _Tp, _Tp _Num>
-    using make_integer_sequence
-    = typename _Make_integer_sequence<_Tp, _Num>::__type;
-
-    /// Alias template index_sequence
-    template<size_t... _Idx>
-    using index_sequence = integer_sequence<size_t, _Idx...>;
-
-    /// Alias template make_index_sequence
-    template<size_t _Num>
-    using make_index_sequence = make_integer_sequence<size_t, _Num>;
-
-    /// Alias template index_sequence_for
-    template<typename... _Types>
-    using index_sequence_for = make_index_sequence<sizeof...(_Types)>;
-}

data/ext/journald_native/extinit.cpp

@@ -1,7 +0,0 @@
-#include "journald_native.h"
-
-/* initialize ruby extension */
-extern "C" void Init_journald_native()
-{
-    journald_native::init_modules();
-}

data/ext/journald_native/journald_native.cpp

@@ -1,100 +0,0 @@
-#include "journald_native.h"
-#include "sd_journal.h"
-
-#include <memory>
-
-#include "ruby_exception_wrapper.h"
-
-namespace journald_native {
-
-namespace {
-
-/* aux */
-// just a short alias for ruby_raisable_call()
-template <typename Func, typename... Args>
-inline auto r(Func f, Args... args) -> decltype(f(args...))
-{
-    return ruby_exception_wrapper::ruby_raisable_call(f, args...);
-}
-
-/* methods */
-inline VALUE native_print(VALUE v_self, VALUE v_priority, VALUE v_message)
-{
-    int         priority = NUM2INT(v_priority);
-    std::string message  = r(rb_string_value_cstr, &v_message);
-
-    int         result   = sd_journal_print(priority, "%s", message.c_str());
-
-    return INT2NUM(result);
-}
-
-inline VALUE native_send(int argc, VALUE* argv, VALUE v_self)
-{
-    auto msgs = std::make_unique<iovec[]>((size_t)argc);
-
-    for (int i = 0; i < argc; i++) {
-        VALUE v = r(rb_string_value, &argv[i]);
-
-        msgs[i].iov_base = (char *)RSTRING_PTR(v);
-        msgs[i].iov_len  = (size_t)RSTRING_LEN(v);
-    }
-
-    int result = sd_journal_sendv(msgs.get(), argc);
-
-    return INT2NUM(result);
-}
-
-inline VALUE native_perror(VALUE v_self, VALUE v_message)
-{
-    std::string message = r(rb_string_value_cstr, &v_message);
-
-    int         result  = sd_journal_perror(message.c_str());
-
-    return INT2NUM(result);
-}
-
-VALUE is_dummy(VALUE v_self = Qnil)
-{
-    constexpr VALUE dummy = JOURNALD_NATIVE_SD_JOURNAL_DUMMY ? Qtrue : Qfalse;
-    return dummy;
-}
-
-/* initializers */
-inline void init_journald(VALUE module)
-{
-    rb_define_const(module, "LOG_EMERG",   INT2NUM(LOG_EMERG));    /* system is unusable */
-    rb_define_const(module, "LOG_ALERT",   INT2NUM(LOG_ALERT));    /* action must be taken immediately */
-    rb_define_const(module, "LOG_CRIT",    INT2NUM(LOG_CRIT));     /* critical conditions */
-    rb_define_const(module, "LOG_ERR",     INT2NUM(LOG_ERR));      /* error conditions */
-    rb_define_const(module, "LOG_WARNING", INT2NUM(LOG_WARNING));  /* warning conditions */
-    rb_define_const(module, "LOG_NOTICE",  INT2NUM(LOG_NOTICE));   /* normal but significant condition */
-    rb_define_const(module, "LOG_INFO",    INT2NUM(LOG_INFO));     /* informational */
-    rb_define_const(module, "LOG_DEBUG",   INT2NUM(LOG_DEBUG));    /* debug-level messages */
-}
-
-inline void init_native(VALUE module)
-{
-    // methods
-    rb_define_singleton_method(module, "print",  RXW_WRAPPED_METHOD_FUNC(native_print, VALUE, VALUE, VALUE),  2);
-    rb_define_singleton_method(module, "send",   RXW_WRAPPED_METHOD_FUNC(native_send, int, VALUE*, VALUE),   -1); /* -1 to pass as C array */
-    rb_define_singleton_method(module, "perror", RXW_WRAPPED_METHOD_FUNC(native_perror, VALUE, VALUE),        1);
-
-    // dummy detection
-    rb_define_const(module, "IS_DUMMY", is_dummy());
-    rb_define_singleton_method(module, "dummy?", RUBY_METHOD_FUNC(is_dummy), 0);
-}
-
-} // private namespace
-
-void init_modules()
-{
-    // no nontrivial destructors during initialization, no need for ruby catch
-
-    VALUE mJournald = rb_define_module("Journald");
-    VALUE mNative   = rb_define_module_under(mJournald, "Native");
-
-    init_journald(mJournald); // add constants to Journald
-    init_native(mNative);     // add methods to Journald::Native
-}
-
-}

data/ext/journald_native/journald_native.h

@@ -1,12 +0,0 @@
-#ifndef JOURNALD_NATIVE_JOURNALD_NATIVE_H
-#define JOURNALD_NATIVE_JOURNALD_NATIVE_H
-
-#include <string>
-#include <ruby.h>
-
-namespace journald_native {
-    /* initializers */
-    void init_modules();
-}
-
-#endif // JOURNALD_NATIVE_JOURNALD_NATIVE_H

data/ext/journald_native/ruby_exception_wrapper.cpp

@@ -1,16 +0,0 @@
-#include "ruby_exception_wrapper.h"
-
-namespace ruby_exception_wrapper {
-
-// callback for rb_rescue2 to catch ruby exception and wrap it by RbWrappedException
-VALUE rethrow_as_cpp(VALUE put_exception_here_ptr, VALUE exception)
-{
-    // cannot actually throw here, just pass the exception
-    VALUE* excptr = reinterpret_cast<VALUE*>(put_exception_here_ptr);
-
-    *excptr = exception;
-
-    return exception;
-}
-
-}

data/ext/journald_native/ruby_exception_wrapper.h

@@ -1,105 +0,0 @@
-#ifndef RUBY_EXCEPTION_WRAPPER_H
-#define RUBY_EXCEPTION_WRAPPER_H
-
-#include <ruby.h>
-
-#include <functional>
-#include <type_traits>
-#include <utility>
-
-#include "cpp14shiv.h" // make this c++14 code c++11 compatible; remove for c++14
-
-// wrap functions, prototype required, i.e. RXW_WRAPPED_METHOD_FUNC(native_send, int, VALUE*, VALUE)
-// functions can be inline
-#define RXW_WRAPPED_METHOD_FUNC(method, ...) ((VALUE (*)(ANYARGS))::ruby_exception_wrapper::method_wrapper_call<decltype(&method), method, __VA_ARGS__>)
-
-namespace ruby_exception_wrapper {
-
-    class RbWrappedException: public std::exception {
-        VALUE ruby_exception;
-    public:
-        RbWrappedException(VALUE e): ruby_exception(e) {};
-        VALUE getRubyException() { return ruby_exception; }
-    };
-
-    // callback for rb_rescue2 to catch ruby exception and wrap it by RbWrappedException
-    VALUE rethrow_as_cpp(VALUE put_exception_here_ptr, VALUE exception);
-
-    namespace {
-        // do real call of function from template
-        template <typename FuncPointer, typename... Args>
-        inline VALUE call_wrapper_tuple_impl(FuncPointer& fp, Args... args)
-        {
-            // only pointers and VALUE permitted
-            // VALUE guaranteed to be able to contain pointer
-            return reinterpret_cast<VALUE>(fp(args...));
-        }
-
-        // unpack params to do real call
-        template <typename CallTuple, std::size_t... Is>
-        inline VALUE call_wrapper_tuple_unpack(CallTuple& call_tuple, std::index_sequence<Is...>)
-        {
-            return call_wrapper_tuple_impl(std::get<Is>(call_tuple)...);
-        }
-
-        // callback for rb_rescue2 for no exceptions
-        template <typename CallTuple>
-        VALUE call_wrapper_tuple(VALUE v_ct) {
-            CallTuple call_tuple = std::move(*reinterpret_cast<CallTuple*>(v_ct));
-
-            return call_wrapper_tuple_unpack(call_tuple, std::make_index_sequence<std::tuple_size<CallTuple>::value> {});
-        };
-
-        // safely call function
-        template <typename Func, typename... Args>
-        inline auto do_raisable_call(Func f, Args... args) -> decltype(f(args...))
-        {
-            typedef std::function<typename std::remove_pointer<Func>::type> FuncPointer;
-            typedef std::tuple<FuncPointer, Args...> CallTuple;
-
-            FuncPointer fp = f;
-
-            CallTuple call_tuple = std::make_tuple(fp, args...);
-
-            VALUE exception = 0; // get raised exception if any
-
-            VALUE result = rb_rescue2(
-                    RUBY_METHOD_FUNC(call_wrapper_tuple<CallTuple>), reinterpret_cast<VALUE>(&call_tuple),
-                    RUBY_METHOD_FUNC(rethrow_as_cpp), reinterpret_cast<VALUE>(&exception),
-                    rb_eException, Qfalse
-            );
-
-            if (exception) { // nonzero here if rescue called unless some pervert throws Qfalse
-                throw RbWrappedException(exception);
-            }
-
-            return reinterpret_cast<decltype(f(args...))>(result);
-        }
-    }
-
-    template <typename Func, typename... Args>
-    inline auto ruby_raisable_call(Func f, Args... args) -> decltype(f(args...))
-    {
-        static_assert(
-                std::is_same<decltype(f(args...)), VALUE>::value || std::is_pointer<decltype(f(args...))>::value,
-                "Only for funcs returning VALUE or pointer"
-        );
-
-        auto result = do_raisable_call(f, args...);
-
-        return result;
-    }
-
-    template <typename Func, Func func, typename... Args>
-    VALUE method_wrapper_call(Args... args)
-    {
-        try {
-            return func(args...);
-        } catch(RbWrappedException &e) {
-            rb_exc_raise(e.getRubyException());
-        }
-    }
-
-}
-
-#endif