mosquitto 0.2

data/ext/mosquitto/client.h

@@ -0,0 +1,145 @@
+#ifndef MOSQUITTO_CLIENT_H
+#define MOSQUITTO_CLIENT_H
+
+typedef struct mosquitto_callback_t mosquitto_callback_t;
+
+typedef struct {
+    struct mosquitto *mosq;
+    VALUE connect_cb;
+    VALUE disconnect_cb;
+    VALUE publish_cb;
+    VALUE message_cb;
+    VALUE subscribe_cb;
+    VALUE unsubscribe_cb;
+    VALUE log_cb;
+    VALUE callback_thread;
+    pthread_mutex_t callback_mutex;
+    pthread_cond_t callback_cond;
+    mosquitto_callback_t *callback_queue;
+} mosquitto_client_wrapper;
+
+#define MosquittoGetClient(obj) \
+    mosquitto_client_wrapper *client = NULL; \
+    Data_Get_Struct(obj, mosquitto_client_wrapper, client); \
+    if (!client) rb_raise(rb_eTypeError, "uninitialized Mosquitto client!");
+
+#define MosquittoAssertCallback(cb, arity) \
+    if (NIL_P(cb)){ \
+        cb = proc; \
+    } else { \
+        if (rb_class_of(cb) != rb_cProc) \
+            rb_raise(rb_eTypeError, "Expected a Proc callback"); \
+        if (rb_proc_arity(cb) != arity) \
+          rb_raise(rb_eArgError, "Callback expects %d argument(s), got %d", arity, NUM2INT(rb_proc_arity(cb))); \
+    }
+
+// TODO: xmalloc, the Ruby VM's preferred allocation method for managing memory pressure fails under GC stress when callbacks
+// fire on a non-Ruby thread ( mosquitto_loop_start )
+#define MOSQ_ALLOC(type) ((type*)malloc(sizeof(type)))
+
+#define ON_CONNECT_CALLBACK 0x00
+#define ON_DISCONNECT_CALLBACK 0x01
+#define ON_PUBLISH_CALLBACK 0x02
+#define ON_MESSAGE_CALLBACK 0x04
+#define ON_SUBSCRIBE_CALLBACK 0x08
+#define ON_UNSUBSCRIBE_CALLBACK 0x10
+#define ON_LOG_CALLBACK 0x20
+
+typedef struct on_connect_callback_args_t on_connect_callback_args_t;
+struct on_connect_callback_args_t {
+    int rc;
+};
+
+typedef struct on_disconnect_callback_args_t on_disconnect_callback_args_t;
+struct on_disconnect_callback_args_t {
+    int rc;
+};
+
+typedef struct on_publish_callback_args_t on_publish_callback_args_t;
+struct on_publish_callback_args_t {
+    int mid;
+};
+
+typedef struct on_message_callback_args_t on_message_callback_args_t;
+struct on_message_callback_args_t {
+    struct mosquitto_message *msg;
+};
+
+typedef struct on_subscribe_callback_args_t on_subscribe_callback_args_t;
+struct on_subscribe_callback_args_t {
+    int mid;
+    int qos_count;
+    const int *granted_qos;
+};
+
+typedef struct on_unsubscribe_callback_args_t on_unsubscribe_callback_args_t;
+struct on_unsubscribe_callback_args_t {
+    int mid;
+};
+
+typedef struct on_log_callback_args_t on_log_callback_args_t;
+struct on_log_callback_args_t {
+    int level;
+    char *str;
+};
+
+struct mosquitto_callback_t {
+    int type;
+    mosquitto_client_wrapper *client;
+    void *data;
+    mosquitto_callback_t *next;
+};
+
+typedef struct mosquitto_callback_waiting_t mosquitto_callback_waiting_t;
+struct mosquitto_callback_waiting_t {
+    mosquitto_callback_t *callback;
+    mosquitto_client_wrapper *client;
+    bool abort;
+};
+
+struct nogvl_connect_args {
+    struct mosquitto *mosq;
+    char *host;
+    int port;
+    int keepalive;
+    char *bind_address;
+};
+
+struct nogvl_loop_stop_args {
+    struct mosquitto *mosq;
+    bool force;
+};
+
+struct nogvl_loop_args {
+    struct mosquitto *mosq;
+    int timeout;
+    int max_packets;
+};
+
+struct nogvl_reinitialise_args {
+    struct mosquitto *mosq;
+    char *client_id;
+    bool clean_session;
+    void *obj;
+};
+
+struct nogvl_publish_args {
+    struct mosquitto *mosq;
+    int *mid;
+    char *topic;
+    int payloadlen;
+    const void *payload;
+    int qos;
+    bool retain;
+};
+
+struct nogvl_subscribe_args {
+    struct mosquitto *mosq;
+    int *mid;
+    const char *subscription;
+    int qos;
+};
+
+void _init_rb_mosquitto_client();
+
+#endif

data/ext/mosquitto/extconf.rb

@@ -0,0 +1,31 @@
+require 'mkmf'
+
+RbConfig::MAKEFILE_CONFIG['CC'] = ENV['CC'] if ENV['CC']
+
+dir_config('mosquitto')
+
+# detect homebrew installs, via @brianmario
+if !have_library 'mosquitto'
+  base = if !`which brew`.empty?
+    `brew --prefix`.strip
+  elsif File.exists?("/usr/local/Cellar/mosquitto")
+    '/usr/local/Cellar'
+  end
+
+  if base and mosquitto = Dir[File.join(base, 'Cellar/mosquitto/*')].sort.last
+    $INCFLAGS << " -I#{mosquitto}/include "
+    $LDFLAGS  << " -L#{mosquitto}/lib "
+  end
+end
+
+(have_header('ruby/thread.h') && have_func('rb_thread_call_without_gvl', 'ruby/thread.h')) || have_func('rb_thread_blocking_region')
+
+(have_header("mosquitto.h") && have_library('mosquitto')) or abort("libmosquitto missing!")
+have_header("pthread.h") or abort('pthread support required!')
+have_macro("LIBMOSQUITTO_VERSION_NUMBER", "mosquitto.h")
+
+$defs << "-pedantic"
+$CFLAGS << ' -Wall -funroll-loops'
+$CFLAGS << ' -Wextra -O0 -ggdb3' if ENV['DEBUG']
+
+create_makefile('mosquitto_ext')

data/ext/mosquitto/message.c

@@ -0,0 +1,168 @@
+#include "mosquitto_ext.h"
+
+/*
+ * :nodoc:
+ *  GC callback for releasing an out of scope Mosquitto::Message object
+ *
+ */
+static void rb_mosquitto_free_message(void *ptr)
+{
+    mosquitto_message_wrapper *message = (mosquitto_message_wrapper *)ptr;
+    if (message) {
+        mosquitto_message_free(&message->msg);
+        xfree(message);
+    }
+}
+
+/*
+ * :nodoc:
+ *  Allocator function for Mosquitto::Message. This is only ever called from within an on_message callback
+ *  within the binding scope, NEVER by the user.
+ *
+ */
+VALUE rb_mosquitto_message_alloc(const struct mosquitto_message *msg)
+{
+    VALUE message;
+    mosquitto_message_wrapper *wrapper = NULL;
+    message = Data_Make_Struct(rb_cMosquittoMessage, mosquitto_message_wrapper, 0, rb_mosquitto_free_message, wrapper);
+    wrapper->msg = msg;
+    rb_obj_call_init(message, 0, NULL);
+    return message;
+}
+
+/*
+ * call-seq:
+ *   msg.mid -> Integer
+ *
+ * Message identifier for this message. Note that although the MQTT protocol doesn't use message ids
+ * for messages with QoS=0, libmosquitto assigns them message ids so they can be tracked with this parameter.
+ *
+ * @return [Integer] message identifier
+ * @example
+ *   msg.mid -> 2
+ *
+ */
+static VALUE rb_mosquitto_message_mid(VALUE obj)
+{
+    struct mosquitto_message *msg;
+    MosquittoGetMessage(obj);
+    msg = message->msg;
+    return INT2NUM(msg->mid);
+}
+
+/*
+ * call-seq:
+ *   msg.topic -> String
+ *
+ * Topic this message was published on.
+ *
+ * @return [String] topic
+ * @example
+ *   msg.topic -> "test"
+ *
+ */
+static VALUE rb_mosquitto_message_topic(VALUE obj)
+{
+    struct mosquitto_message *msg;
+    MosquittoGetMessage(obj);
+    msg = message->msg;
+    return MosquittoEncode(rb_str_new2(msg->topic));
+}
+
+/*
+ * call-seq:
+ *   msg.to_s -> String
+ *
+ * Coerces the Mosquitto::Message payload to a Ruby string.
+ *
+ * @return [String] message payload
+ * @example
+ *   msg.to_s -> "message"
+ *
+ */
+static VALUE rb_mosquitto_message_to_s(VALUE obj)
+{
+    struct mosquitto_message *msg;
+    MosquittoGetMessage(obj);
+    msg = message->msg;
+    return MosquittoEncode(rb_str_new(msg->payload, msg->payloadlen));
+}
+
+/*
+ * call-seq:
+ *   msg.length -> Integer
+ *
+ * The length of the message payload
+ *
+ * @return [Integer] message length
+ * @example
+ *   msg.length -> 7
+ *
+ */
+static VALUE rb_mosquitto_message_length(VALUE obj)
+{
+    struct mosquitto_message *msg;
+    MosquittoGetMessage(obj);
+    msg = message->msg;
+    return INT2NUM(msg->payloadlen);
+}
+
+/*
+ * call-seq:
+ *   msg.qos -> Integer
+ *
+ * Quality of Service used for the message
+ *
+ * @see Mosquitto::AT_MOST_ONCE
+ * @see Mosquitto::AT_LEAST_ONCE
+ * @see Mosquitto::EXACTLY_ONCE
+ *
+ * @return [Integer] message quality of service
+ * @example
+ *   msg.qos -> Mosquitto::AT_MOST_ONCE
+ *
+ */
+static VALUE rb_mosquitto_message_qos(VALUE obj)
+{
+    struct mosquitto_message *msg;
+    MosquittoGetMessage(obj);
+    msg = message->msg;
+    return INT2NUM(msg->qos);
+}
+
+/*
+ * call-seq:
+ *   msg.retain? -> Boolean
+ *
+ * Set to true if this message was flagged to retain.
+ *
+ * @return [true, false] retention flag
+ * @example
+ *   msg.retain? -> true
+ *
+ */
+static VALUE rb_mosquitto_message_retain_p(VALUE obj)
+{
+    struct mosquitto_message *msg;
+    MosquittoGetMessage(obj);
+    msg = message->msg;
+    return (msg->retain == true) ? Qtrue : Qfalse;
+}
+
+/*
+ *  Represents libmosquitto messages. They cannot be allocated or initialized from user code - they are
+ *  spawned exclusively from within on_message callbacks and are thus read-only wrapper objects.
+ *
+ */
+
+void _init_rb_mosquitto_message()
+{
+    rb_cMosquittoMessage = rb_define_class_under(rb_mMosquitto, "Message", rb_cObject);
+
+    rb_define_method(rb_cMosquittoMessage, "mid", rb_mosquitto_message_mid, 0);
+    rb_define_method(rb_cMosquittoMessage, "topic", rb_mosquitto_message_topic, 0);
+    rb_define_method(rb_cMosquittoMessage, "to_s", rb_mosquitto_message_to_s, 0);
+    rb_define_method(rb_cMosquittoMessage, "length", rb_mosquitto_message_length, 0);
+    rb_define_method(rb_cMosquittoMessage, "qos", rb_mosquitto_message_qos, 0);
+    rb_define_method(rb_cMosquittoMessage, "retain?", rb_mosquitto_message_retain_p, 0);
+}

data/ext/mosquitto/message.h

@@ -0,0 +1,16 @@
+#ifndef MOSQUITTO_MESSAGE_H
+#define MOSQUITTO_MESSAGE_H
+
+typedef struct {
+    struct mosquitto_message *msg;
+} mosquitto_message_wrapper;
+
+#define MosquittoGetMessage(obj) \
+    mosquitto_message_wrapper *message = NULL; \
+    Data_Get_Struct(obj, mosquitto_message_wrapper, message); \
+    if (!message) rb_raise(rb_eTypeError, "uninitialized Mosquitto message!");
+
+VALUE rb_mosquitto_message_alloc(const struct mosquitto_message *msg);
+void _init_rb_mosquitto_message();
+
+#endif

data/ext/mosquitto/mosquitto_ext.c

@@ -0,0 +1,88 @@
+#include "mosquitto_ext.h"
+
+VALUE rb_mMosquitto;
+VALUE rb_eMosquittoError;
+VALUE rb_cMosquittoClient;
+VALUE rb_cMosquittoMessage;
+
+VALUE intern_call;
+
+rb_encoding *binary_encoding;
+
+/*
+ *  call-seq:
+ *    Mosquitto.version -> Integer
+ *
+ *  The libmosquitto version linked against. It returns for libmosquitto 1.2.3 an integer as :
+ *
+ *  1002003
+ *
+ * === Examples
+ *  Mosquitto.version -> 1002003
+ *
+ */
+static VALUE rb_mosquitto_version(MOSQ_UNUSED VALUE obj)
+{
+    return INT2NUM(mosquitto_lib_version(NULL, NULL, NULL));
+}
+
+/*
+ *  call-seq:
+ *    Mosquitto.cleanup -> nil
+ *
+ *  Release resources associated with the libmosquitto library.
+ *
+ * === Examples
+ *  Mosquitto.cleanup -> nil
+ *
+ */
+static VALUE rb_mosquitto_cleanup(MOSQ_UNUSED VALUE obj)
+{
+    mosquitto_lib_cleanup();
+    return Qnil;
+}
+
+void Init_mosquitto_ext()
+{
+    mosquitto_lib_init();
+
+    intern_call = rb_intern("call");
+
+    binary_encoding = rb_enc_find("binary");
+
+    rb_mMosquitto = rb_define_module("Mosquitto");
+
+    /*
+     * Message QOS specific constants
+     */
+    rb_define_const(rb_mMosquitto, "AT_MOST_ONCE", INT2NUM(0));
+    rb_define_const(rb_mMosquitto, "AT_LEAST_ONCE", INT2NUM(1));
+    rb_define_const(rb_mMosquitto, "EXACTLY_ONCE", INT2NUM(2));
+
+   /*
+    * Log specific constants *
+    */
+    rb_define_const(rb_mMosquitto, "LOG_NONE", INT2NUM(0x00));
+    rb_define_const(rb_mMosquitto, "LOG_INFO", INT2NUM(0x01));
+    rb_define_const(rb_mMosquitto, "LOG_NOTICE", INT2NUM(0x02));
+    rb_define_const(rb_mMosquitto, "LOG_WARNING", INT2NUM(0x04));
+    rb_define_const(rb_mMosquitto, "LOG_ERR", INT2NUM(0x08));
+    rb_define_const(rb_mMosquitto, "LOG_DEBUG", INT2NUM(0x10));
+    rb_define_const(rb_mMosquitto, "LOG_SUBSCRIBE", INT2NUM(0x20));
+    rb_define_const(rb_mMosquitto, "LOG_UNSUBSCRIBE", INT2NUM(0x40));
+    rb_define_const(rb_mMosquitto, "LOG_ALL", INT2NUM(0xFFFF));
+
+    /*
+     * TLS specific constants
+     */
+    rb_define_const(rb_mMosquitto, "SSL_VERIFY_NONE", INT2NUM(0));
+    rb_define_const(rb_mMosquitto, "SSL_VERIFY_PEER", INT2NUM(1));
+
+    rb_eMosquittoError = rb_define_class_under(rb_mMosquitto, "Error", rb_eStandardError);
+
+    rb_define_module_function(rb_mMosquitto, "version", rb_mosquitto_version, 0);
+    rb_define_module_function(rb_mMosquitto, "cleanup", rb_mosquitto_cleanup, 0);
+
+    _init_rb_mosquitto_client();
+    _init_rb_mosquitto_message();
+}