mosq 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e3e826b96ac902207ad690a3ea90a49acc266eb0
+  data.tar.gz: b0208ffc9b595687d936b704c15ce3dd0b06b864
+SHA512:
+  metadata.gz: 7b605dbc96e3bd96b3c75fe2d9ed1f20c8ff187c2e752e1f2ae77ea5971bb1621100ade4a59f1f8fe82a74edff215d5779be7449ed417c91fb170cf79a1eef27
+  data.tar.gz: 00d94526260cb7ba5313125ddbfa3aa5e742db6853f072fe52b23b03297885ba334d6f8443c12d8768f6c975280c36028c80bf7cf5b969a315035b162cf49318

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Joe McIlvain
+
+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.

data/README.md

@@ -0,0 +1,9 @@
+# mosq
+
+[![Build Status](https://circleci.com/gh/jemc/ruby-mosq/tree/master.svg?style=svg)](https://circleci.com/gh/jemc/ruby-mosq/tree/master) 
+[![Gem Version](https://badge.fury.io/rb/mosq.png)](http://badge.fury.io/rb/mosq) 
+[![Join the chat at https://gitter.im/jemc/ruby-mosq](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/jemc/ruby-mosq?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+[MQTT](http://mqtt.org/) client library based on [FFI](https://github.com/ffi/ffi/wiki) bindings for [libmosquitto](http://mosquitto.org/man/libmosquitto-3.html).
+
+##### `$ gem install mosq`

data/ext/mosq/Rakefile

@@ -0,0 +1,47 @@
+
+require 'rake/clean'
+require 'ffi'
+
+FILES = {}
+
+task :default => [:build, :compact]
+
+def self.file_task(filename, opts, &block)
+  name, dep = opts.is_a?(Hash) ? opts.to_a.first : [opts, nil]
+  
+  FILES[name] = filename
+  CLEAN.include filename
+  task name => filename
+  
+  if dep
+    file filename => FILES[dep], &block
+  else
+    file filename, &block
+  end
+end
+
+def cmd(string)
+  fail "Command failed: #{string}" unless system(string)
+end
+
+file_task 'mosquitto.tar.gz', :download_tarball do
+  version = "1.4.2"
+  release = "http://mosquitto.org/files/source/mosquitto-#{version}.tar.gz"
+  cmd "wget -O #{FILES[:download_tarball]} #{release}"
+end
+
+file_task 'mosquitto', :download => :download_tarball do
+  cmd "tar -zxf #{FILES[:download_tarball]}"
+  cmd "mv mosquitto-* #{FILES[:download]}"
+end
+
+file_task "libmosquitto.#{::FFI::Platform::LIBSUFFIX}", :build => :download do
+  cmd "/usr/bin/env sh -c 'cd #{FILES[:download]} && env CFLAGS=-g make'"
+  cmd "cp #{FILES[:download]}/lib/#{FILES[:build]}* ./#{FILES[:build]}"
+end
+
+task :compact => FILES[:build] do
+  FILES.each do |key, filename|
+    cmd "rm -rf #{filename}" unless key == :build
+  end
+end

data/lib/mosq.rb

@@ -0,0 +1,13 @@
+
+require_relative 'mosq/util'
+require_relative 'mosq/ffi'
+require_relative 'mosq/ffi/error'
+
+require_relative 'mosq/client'
+
+# Call to initialize the library
+Mosq::Util.error_check "initializing the libmosquitto library",
+  Mosq::FFI.mosquitto_lib_init
+
+# Call cleanup at exit clean up the library
+at_exit { Mosq::FFI.mosquitto_lib_cleanup }

data/lib/mosq/client.rb

@@ -0,0 +1,324 @@
+
+require 'socket'
+
+require_relative 'client/bucket'
+
+
+module Mosq
+  class Client
+    
+    # Raised when an operation is performed on an already-destroyed {Client}.
+    class DestroyedError < RuntimeError; end
+    
+    # Create a new {Client} instance with the given properties.
+    def initialize(*args)
+      @options = Util.connection_info(*args)
+      
+      @options[:heartbeat] ||= 30 # seconds
+      @protocol_timeout = DEFAULT_PROTOCOL_TIMEOUT
+      
+      Util.null_check "creating the client",
+        (@ptr = FFI.mosquitto_new(@options[:client_id], true, nil))
+      
+      @bucket = Bucket.new(@ptr)
+      @event_handlers = {}
+      
+      @packet_id_ptr = Util.mem_ptr(:int)
+      
+      @finalizer = self.class.create_finalizer_for(@ptr)
+      ObjectSpace.define_finalizer(self, @finalizer)
+    end
+    
+    # @api private
+    def self.create_finalizer_for(ptr)
+      Proc.new do
+        FFI.mosquitto_destroy(ptr)
+      end
+    end
+    
+    def username;  @options.fetch(:username);  end
+    def password;  @options.fetch(:password);  end
+    def host;      @options.fetch(:host);      end
+    def port;      @options.fetch(:port);      end
+    def ssl?;      @options.fetch(:ssl);       end
+    def heartbeat; @options.fetch(:heartbeat); end
+    
+    # The maximum time interval the user application should wait between
+    # yielding control back to the client object by calling run_loop!.
+    def max_poll_interval
+      @options.fetch(:heartbeat) / 2.0
+    end
+    
+    def ptr
+      raise DestroyedError unless @ptr
+      @ptr
+    end
+    private :ptr
+    
+    # Initiate the connection with the server.
+    # It is necessary to call this before any other communication.
+    def start
+      Util.error_check "configuring the username and password",
+        FFI.mosquitto_username_pw_set(ptr, @options[:usernam], @options[:password])
+      
+      Util.error_check "connecting to #{@options[:host]}",
+        FFI.mosquitto_connect(ptr, @options[:host], @options[:port], @options[:heartbeat])
+      
+      @ruby_socket = Socket.for_fd(FFI.mosquitto_socket(ptr))
+      @ruby_socket.autoclose = false
+      
+      res = fetch_response(:connect, nil)
+      raise Mosq::FFI::Error::NoConn, res.fetch(:message) \
+        unless res.fetch(:status) == 0
+      
+      self
+    end
+    
+    # Gracefully close the connection with the server.
+    def close
+      @ruby_socket = nil
+      
+      Util.error_check "closing the connection to #{@options[:host]}",
+        FFI.mosquitto_disconnect(ptr)
+      
+      self
+    rescue Mosq::FFI::Error::NoConn
+      self
+    end
+    
+    # Free the native resources associated with this object. This will
+    # be done automatically on garbage collection if not called explicitly.
+    def destroy
+      if @finalizer
+        @finalizer.call
+        ObjectSpace.undefine_finalizer(self)
+      end
+      @ptr = @finalizer = @ruby_socket = @bucket = nil
+      
+      self
+    end
+    
+    # Register a handler for events on the given channel of the given type.
+    # Only one handler for each event type may be registered at a time.
+    # If no callable or block is given, the handler will be cleared.
+    #
+    # @param type [Symbol] The type of event to watch for.
+    # @param callable [#call,nil] The callable handler if no block is given.
+    # @param block [Proc,nil] The handler block to register.
+    # @return [Proc,#call,nil] The given block or callable.
+    # @yieldparam event [Hash] The event passed to the handler.
+    #
+    def on_event(type, callable=nil, &block)
+      handler = block || callable
+      raise ArgumentError, "expected block or callable as the event handler" \
+        unless handler.respond_to?(:call)
+      
+      @event_handlers[type.to_sym] = handler
+      handler
+    end
+    alias_method :on, :on_event
+    
+    # Unregister the event handler associated with the given channel and method.
+    #
+    # @param type [Symbol] The type of protocol method to watch for.
+    # @return [Proc,nil] This removed handler, if any.
+    #
+    def clear_event_handler(type)
+      @event_handlers.delete(type.to_sym)
+    end
+    
+    # The timeout to use when waiting for protocol events, in seconds.
+    # By default, this has the value of {DEFAULT_PROTOCOL_TIMEOUT}.
+    # When set, it affects operations like {#run_loop!}.
+    attr_accessor :protocol_timeout
+    DEFAULT_PROTOCOL_TIMEOUT = 30 # seconds
+    
+    # Subscribe to the given topic. Messages with matching topic will be
+    # delivered to the {:message} event handler registered with {on_event}.
+    #
+    # @param topic [String] The topic patten to subscribe to.
+    # @param qos [Integer] The QoS level to expect for received messages.
+    # @return [Client] This client.
+    #
+    def subscribe(topic, qos: 0)
+      Util.error_check "subscribing to a topic",
+        FFI.mosquitto_subscribe(ptr, @packet_id_ptr, topic, qos)
+      
+      fetch_response(:subscribe, @packet_id_ptr.read_int)
+      
+      self
+    end
+    
+    # Unsubscribe from the given topic.
+    #
+    # @param topic [String] The topic patten to unsubscribe from.
+    # @return [Client] This client.
+    #
+    def unsubscribe(topic)
+      Util.error_check "unsubscribing from a topic",
+        FFI.mosquitto_unsubscribe(ptr, @packet_id_ptr, topic)
+      
+      fetch_response(:unsubscribe, @packet_id_ptr.read_int)
+      
+      self
+    end
+    
+    # Publish a message with the given topic and payload.
+    #
+    # @param topic [String] The topic to publish on.
+    # @param payload [String] The payload to publish.
+    # @param qos [Integer] The QoS level to use for the publish transaction.
+    # @param retain [Boolean] Whether the broker should retain the message.
+    # @return [Client] This client.
+    #
+    def publish(topic, payload, qos: 0, retain: false)
+      Util.error_check "publishing a message",
+        FFI.mosquitto_publish(ptr, @packet_id_ptr,
+          topic, payload.bytesize, payload, qos, retain)
+      
+      fetch_response(:publish, @packet_id_ptr.read_int)
+      
+      self
+    end
+    
+    # Fetch and handle events in a loop that blocks the calling thread.
+    # The loop will continue until the {#break!} method is called from within
+    # an event handler, or until the given timeout duration has elapsed.
+    # Note that this must be called at least as frequently as the heartbeat
+    # interval to ensure that the client is not disconnected - if control is
+    # not yielded to the client transport heartbeats will not be maintained.
+    #
+    # @param timeout [Float] the maximum time to run the loop, in seconds;
+    #   if none is given, the value is {#protocol_timeout} or until {#break!}
+    # @param block [Proc,nil] if given, the block will be yielded each
+    #   non-exception event received on any channel. Other handlers or
+    #   response fetchings that match the event will still be processed,
+    #   as the block does not consume the event or replace the handlers.
+    # @return [undefined] assume no value - reserved for future use.
+    #
+    def run_loop!(timeout: protocol_timeout, &block)
+      timeout = Float(timeout) if timeout
+      fetch_events(timeout, &block)
+      nil
+    end
+    
+    # Yield control to the client object to do any connection-oriented work
+    # that needs to be done, including heartbeating. This is the same as
+    # calling {#run_loop!} with no block and a timeout of 0.
+    #
+    def run_immediate!
+      run_loop!(timeout: 0)
+    end
+    
+    # Stop iterating from within an execution of the {#run_loop!} method.
+    # Call this method only from within an event handler.
+    # It will take effect only after the handler finishes running.
+    #
+    # @return [nil]
+    #
+    def break!
+      @breaking = true
+      nil
+    end
+    
+    private
+    
+    # Calculate the amount of the timeout remaining from the given start time
+    def remaining_timeout(timeout=0, start=Time.now)
+      return nil unless timeout
+      timeout = timeout - (Time.now - start)
+      timeout < 0 ? 0 : timeout
+    end
+    
+    # Block until there is readable data on the internal ruby socket,
+    # returning true if there is readable data, or false if time expired.
+    def select(timeout=0)
+      return false unless @ruby_socket
+      IO.select([@ruby_socket], [], [], timeout) ? true : false
+    rescue Errno::EBADF
+      false
+    end
+    
+    # Execute the handler for this type of event, if any.
+    def handle_incoming_event(event)
+      if (handler = (@event_handlers[event.fetch(:type)]))
+        handler.call(event)
+      end
+    end
+    
+    def connection_housekeeping
+      # Do any pending outbound writes.
+      while FFI.mosquitto_want_write(ptr)
+        Util.error_check "sending outbound packets",
+          FFI.mosquitto_loop_write(ptr, 1)
+      end
+      
+      # Do any pending stateful protocol packets.
+      Util.error_check "handling stateful protocol packets",
+        FFI.mosquitto_loop_misc(ptr)
+    end
+    
+    # Return the next incoming event as a Hash, or nil if time expired.
+    def fetch_next_event(timeout=0, start=Time.now)
+      max_timeout = max_poll_interval
+      
+      # Check if any data is immediately available to read
+      if select(0)
+        Util.error_check "reading immediate inbound packets",
+          FFI.mosquitto_loop_read(ptr, 1)
+      end
+      
+      while true
+        connection_housekeeping
+        
+        # Check for an event already waiting in the bucket
+        return @bucket.events.shift unless @bucket.events.empty?
+        
+        # Calculate remaining timeout and break if breaking or time expired.
+        remaining = remaining_timeout(timeout, start)
+        return nil if remaining && remaining <= 0
+        
+        # Wait for data to arrive on the socket.
+        select_timeout = remaining ? [remaining, max_timeout].min : nil
+        if select(select_timeout)
+          Util.error_check "reading inbound packets",
+            FFI.mosquitto_loop_read(ptr, 1)
+          
+          unless @bucket.events.empty?
+            connection_housekeeping
+            return @bucket.events.shift
+          end
+        end
+      end
+    end
+    
+    # Internal implementation of the {#run_loop!} method.
+    def fetch_events(timeout=protocol_timeout, start=Time.now)
+      while (event = fetch_next_event(timeout, start))
+        handle_incoming_event(event)
+        yield event if block_given?
+        break if @breaking
+      end
+    end
+    
+    # Internal implementation of synchronous responses.
+    def fetch_response(expected_type, expected_packet_id, timeout=protocol_timeout, start=Time.now)
+      unwanted_events = []
+      
+      while (event = fetch_next_event(timeout, start))
+        if (event.fetch(:type) == expected_type) && (
+          !expected_packet_id ||
+            event.fetch(:packet_id) == expected_packet_id
+          )
+          unwanted_events.reverse_each { |e| @bucket.events.unshift(e) }
+          handle_incoming_event(event)
+          return event
+        else
+          unwanted_events.push(event)
+        end
+      end
+      
+      raise FFI::Error::Timeout, "waiting for #{expected_type} response"
+    end
+  end
+end

data/lib/mosq/client/bucket.rb

@@ -0,0 +1,76 @@
+
+module Mosq
+  class Client
+    
+    # @api private
+    class Bucket
+      def initialize(ptr)
+        FFI.mosquitto_connect_callback_set     ptr, method(:on_connect)
+        # FFI.mosquitto_disconnect_callback_set  ptr, method(:on_disconnect)
+        FFI.mosquitto_publish_callback_set     ptr, method(:on_publish)
+        FFI.mosquitto_message_callback_set     ptr, method(:on_message)
+        FFI.mosquitto_subscribe_callback_set   ptr, method(:on_subscribe)
+        FFI.mosquitto_unsubscribe_callback_set ptr, method(:on_unsubscribe)
+        # FFI.mosquitto_log_callback_set         ptr, method(:on_log)
+        
+        @events = []
+      end
+      
+      attr_reader :events
+      
+      def on_connect(ptr, _, status)
+        @events << {
+          type:    :connect,
+          status:  status,
+          message: case status
+                   when 0; "success"
+                   when 1; "connection refused (unacceptable protocol version)"
+                   when 2; "connection refused (identifier rejected)"
+                   when 3; "connection refused (broker unavailable)"
+                   else    "unknown connection failure"
+                   end,
+        }
+      end
+      
+      # def on_disconnect(ptr, _, status)
+        
+      # end
+      
+      def on_publish(ptr, _, packet_id)
+        @events << {
+          type:      :publish,
+          packet_id: packet_id,
+        }
+      end
+      
+      def on_message(ptr, _, message)
+        @events << {
+          type:     :message,
+          topic:    message[:topic].read_string,
+          payload:  message[:payload].read_bytes(message[:payloadlen]),
+          retained: message[:retain],
+          qos:      message[:qos],
+        }
+      end
+      
+      def on_subscribe(ptr, _, packet_id, _, _)
+        @events << {
+          type:      :subscribe,
+          packet_id: packet_id,
+        }
+      end
+      
+      def on_unsubscribe(ptr, _, packet_id)
+        @events << {
+          type:      :unsubscribe,
+          packet_id: packet_id,
+        }
+      end
+      
+      # def on_log(ptr, _, status, string)
+        
+      # end
+    end
+    
+  end
+end

data/lib/mosq/ffi.rb

@@ -0,0 +1,135 @@
+
+require 'ffi'
+
+
+module Mosq
+  
+  # Bindings and wrappers for the native functions and structures exposed by
+  # the libmosquitto C library. This module is for internal use only so that
+  # all dependencies on the implementation of the C library are abstracted.
+  # @api private
+  module FFI
+    extend ::FFI::Library
+    
+    libfile = "libmosquitto.#{::FFI::Platform::LIBSUFFIX}"
+    
+    ffi_lib ::FFI::Library::LIBC
+    ffi_lib \
+      File.expand_path("../../ext/mosq/#{libfile}", File.dirname(__FILE__))
+    
+    opts = {
+      blocking: true  # only necessary on MRI to deal with the GIL.
+    }
+    
+    attach_function :free,   [:pointer], :void,    **opts
+    attach_function :malloc, [:size_t],  :pointer, **opts
+    
+    class Boolean
+      extend ::FFI::DataConverter
+      native_type ::FFI::TypeDefs[:int]
+      def self.to_native val, ctx;   val ? 1 : 0; end
+      def self.from_native val, ctx; val != 0;    end
+    end
+    
+    class Message < ::FFI::Struct
+      layout :mid,        :int,
+             :topic,      :pointer,
+             :payload,    :pointer,
+             :payloadlen, :int,
+             :qos,        :int,
+             :retain,     Boolean
+    end
+    
+    Status = enum ::FFI::TypeDefs[:int], [
+      :conn_pending, -1,
+      :success,       0,
+      :nomem,         1,
+      :protocol,      2,
+      :inval,         3,
+      :no_conn,       4,
+      :conn_refused,  5,
+      :not_found,     6,
+      :conn_lost,     7,
+      :tls,           8,
+      :payload_size,  9,
+      :not_supported, 10,
+      :auth,          11,
+      :acl_denied,    12,
+      :unknown,       13,
+      :errno,         14,
+      :eai,           15,
+      :proxy,         16,
+    ]
+    
+    Option = enum [
+      :protocol_version, 1,
+    ]
+    
+    client = :pointer
+    
+    callback :on_connect,     [client, :pointer, :int],                 :void
+    callback :on_disconnect,  [client, :pointer, :int],                 :void
+    callback :on_publish,     [client, :pointer, :int],                 :void
+    callback :on_message,     [client, :pointer, Message.ptr],          :void
+    callback :on_subscribe,   [client, :pointer, :int, :int, :pointer], :void
+    callback :on_unsubscribe, [client, :pointer, :int],                 :void
+    callback :on_log,         [client, :pointer, :int, :string],        :void
+    
+    attach_function :mosquitto_lib_version,               [:pointer, :pointer, :pointer],                             Status,  **opts
+    attach_function :mosquitto_lib_init,                  [],                                                         Status,  **opts
+    attach_function :mosquitto_lib_cleanup,               [],                                                         Status,  **opts
+    attach_function :mosquitto_new,                       [:string, Boolean, :pointer],                               client,  **opts
+    attach_function :mosquitto_destroy,                   [client],                                                   :void,   **opts
+    attach_function :mosquitto_reinitialise,              [client, :string, Boolean, :pointer],                       Status,  **opts
+    attach_function :mosquitto_will_set,                  [client, :string, :int, :pointer, :int, Boolean],           Status,  **opts
+    attach_function :mosquitto_will_clear,                [client],                                                   Status,  **opts
+    attach_function :mosquitto_username_pw_set,           [client, :string, :string],                                 Status,  **opts
+    attach_function :mosquitto_connect,                   [client, :string, :int, :int],                              Status,  **opts
+    attach_function :mosquitto_connect_bind,              [client, :string, :int, :int, :string],                     Status,  **opts
+    attach_function :mosquitto_connect_async,             [client, :string, :int, :int],                              Status,  **opts
+    attach_function :mosquitto_connect_bind_async,        [client, :string, :int, :int, :string],                     Status,  **opts
+    attach_function :mosquitto_connect_srv,               [client, :string, :int, :string],                           Status,  **opts
+    attach_function :mosquitto_reconnect,                 [client],                                                   Status,  **opts
+    attach_function :mosquitto_reconnect_async,           [client],                                                   Status,  **opts
+    attach_function :mosquitto_disconnect,                [client],                                                   Status,  **opts
+    attach_function :mosquitto_publish,                   [client, :pointer, :string, :int, :pointer, :int, Boolean], Status,  **opts
+    attach_function :mosquitto_subscribe,                 [client, :pointer, :string, :int],                          Status,  **opts
+    attach_function :mosquitto_unsubscribe,               [client, :pointer, :string],                                Status,  **opts
+    attach_function :mosquitto_message_copy,              [Message.ptr, Message.ptr],                                 Status,  **opts
+    attach_function :mosquitto_message_free,              [:pointer],                                                 :void,   **opts
+    attach_function :mosquitto_loop,                      [client, :int, :int],                                       Status,  **opts
+    attach_function :mosquitto_loop_forever,              [client, :int, :int],                                       Status,  **opts
+    attach_function :mosquitto_loop_start,                [client],                                                   Status,  **opts
+    attach_function :mosquitto_loop_stop,                 [client, Boolean],                                          Status,  **opts
+    attach_function :mosquitto_socket,                    [client],                                                   :int,    **opts
+    attach_function :mosquitto_loop_read,                 [client, :int],                                             Status,  **opts
+    attach_function :mosquitto_loop_write,                [client, :int],                                             Status,  **opts
+    attach_function :mosquitto_loop_misc,                 [client],                                                   Status,  **opts
+    attach_function :mosquitto_want_write,                [client],                                                   :bool,   **opts
+    attach_function :mosquitto_threaded_set,              [client, Boolean],                                          Status,  **opts
+    attach_function :mosquitto_opts_set,                  [client, Option, :pointer],                                 Status,  **opts
+    attach_function :mosquitto_tls_set,                   [client],                                                   Status,  **opts
+    attach_function :mosquitto_tls_insecure_set,          [client, Boolean],                                          Status,  **opts
+    attach_function :mosquitto_tls_opts_set,              [client, :int, :string, :string],                           Status,  **opts
+    attach_function :mosquitto_tls_psk_set,               [client, :string, :string, :string],                        Status,  **opts
+    attach_function :mosquitto_connect_callback_set,      [client, :on_connect],                                      :void,   **opts
+    attach_function :mosquitto_disconnect_callback_set,   [client, :on_disconnect],                                   :void,   **opts
+    attach_function :mosquitto_publish_callback_set,      [client, :on_publish],                                      :void,   **opts
+    attach_function :mosquitto_message_callback_set,      [client, :on_message],                                      :void,   **opts
+    attach_function :mosquitto_subscribe_callback_set,    [client, :on_subscribe],                                    :void,   **opts
+    attach_function :mosquitto_unsubscribe_callback_set,  [client, :on_unsubscribe],                                  :void,   **opts
+    attach_function :mosquitto_log_callback_set,          [client, :on_log],                                          :void,   **opts
+    attach_function :mosquitto_reconnect_delay_set,       [client, :uint, :uint, Boolean],                            Status,  **opts
+    attach_function :mosquitto_max_inflight_messages_set, [client, :uint],                                            Status,  **opts
+    attach_function :mosquitto_message_retry_set,         [client, :uint],                                            :void,   **opts
+    attach_function :mosquitto_user_data_set,             [client, :pointer],                                         :void,   **opts
+    attach_function :mosquitto_socks5_set,                [client, :string, :int, :string, :string],                  Status,  **opts
+    attach_function :mosquitto_strerror,                  [Status],                                                   :string, **opts
+    attach_function :mosquitto_connack_string,            [:int],                                                     :string, **opts
+    attach_function :mosquitto_sub_topic_tokenise,        [:string, :pointer, :pointer],                              Status,  **opts
+    attach_function :mosquitto_sub_topic_tokens_free,     [:pointer, :int],                                           Status,  **opts
+    attach_function :mosquitto_topic_matches_sub,         [:string, :string, :pointer],                               Status,  **opts
+    attach_function :mosquitto_pub_topic_check,           [:string],                                                  Status,  **opts
+    attach_function :mosquitto_sub_topic_check,           [:string],                                                  Status,  **opts
+  end
+end

data/lib/mosq/ffi/error.rb

@@ -0,0 +1,58 @@
+
+module Mosq
+  module FFI
+    
+    class Error < RuntimeError
+      def initialize(message=nil)
+        @message = message
+      end
+      
+      def message
+        if @message && status_message; "#{status_message} - #{@message}"
+        elsif @message;                @message
+        elsif status_message;          status_message
+        else;                          ""
+        end
+      end
+      
+      def status_message
+        nil
+      end
+      
+      def self.lookup status
+        if status == :errno
+          @errno_lookup_table.fetch(::FFI.errno)
+        else
+          @lookup_table.fetch(status)
+        end
+      end
+      
+      @errno_lookup_table = {}
+      
+      # Populate the errno_lookup_table
+      Errno.constants.each do |name|
+        kls = Errno.const_get(name)
+        begin
+          errno = kls.const_get(:Errno)
+          @errno_lookup_table[errno] = kls
+        rescue NoMethodError, NameError
+        end
+      end
+      
+      @lookup_table = {}
+      
+      # Populate the FFI::Status lookup_table
+      (FFI::Status.symbols - [:errno]).each do |status|
+        message = FFI.mosquitto_strerror(status)
+        message.gsub!(/\.\s*\Z/, '')
+        kls = Class.new(Error) { define_method(:status_message) { message } }
+        @lookup_table[status] = kls
+        const_set Util.const_name(status), kls
+      end
+      
+      # Custom static class to use for timeouts
+      Timeout = Class.new(Error) { define_method(:status_message) { "timed out" } }
+    end
+    
+  end
+end

data/lib/mosq/util.rb

@@ -0,0 +1,69 @@
+
+module Mosq
+  
+  # Helper functions for this library.
+  # @api private
+  module Util
+    module_function
+    
+    def const_name(lowercase_name)
+      lowercase_name.to_s.gsub(/((?:\A\w)|(?:_\w))/) { |x| x[-1].upcase }
+    end
+    
+    def error_check(action, status)
+      return if status == :success
+      raise Mosq::FFI::Error.lookup(status), "while #{action}"
+    end
+    
+    def null_check(action, obj)
+      return unless obj.nil?
+      raise Mosq::FFI::Error, "while #{action} - got unexpected null"
+    end
+    
+    def mem_ptr(size, count: 1, clear: true, release: true)
+      ptr = ::FFI::MemoryPointer.new(size, count, clear)
+      ptr.autorelease = false unless release
+      ptr
+    end
+    
+    def strdup_ptr(str, **kwargs)
+      str = str + "\x00"
+      ptr = mem_ptr(str.bytesize, **kwargs)
+      ptr.write_string(str)
+      ptr
+    end
+    
+    def strdup_ary_ptr(ary, **kwargs)
+      ptr = mem_ptr(:pointer, count: ary.size)
+      ary.each_with_index do |str, i|
+        cursor = (ptr + i * ::FFI::TypeDefs[:pointer].size)
+        cursor.write_pointer(strdup_ptr(str, **kwargs))
+      end
+      ptr
+    end
+    
+    def connection_info(uri=nil, **overrides)
+      info = {
+        ssl:  false,
+        host: "localhost",
+        port: 1883,
+      }
+      if uri
+        # TODO: support IPv6
+        pattern = %r{\A(?<schema>mqtts?)://((?<username>[^:]+):(?<password>[^@]+)@)?(?<host>[^:]+)(:(?<port>\d+))?\Z}
+        match = pattern.match(uri)
+        if match
+          info[:ssl]  = ("mqtts" == match[:schema])
+          info[:host] = match[:host]
+          info[:port] = match[:port] ? Integer(match[:port]) : (info[:ssl] ? 8883 : 1883)
+          info[:username] = match[:username] if match[:username]
+          info[:password] = match[:password] if match[:password]
+        else
+          info[:host] = uri
+        end
+      end
+      info.merge(overrides)
+    end
+  end
+  
+end

metadata

@@ -0,0 +1,158 @@
+--- !ruby/object:Gem::Specification
+name: mosq
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Joe McIlvain
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-08-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.9.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.9.8
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: fivemat
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: A Ruby MQTT client library based on FFI bindings for libmosquitto.
+email: joe.eli.mac@gmail.com
+executables: []
+extensions:
+- ext/mosq/Rakefile
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- ext/mosq/Rakefile
+- lib/mosq.rb
+- lib/mosq/client.rb
+- lib/mosq/client/bucket.rb
+- lib/mosq/ffi.rb
+- lib/mosq/ffi/error.rb
+- lib/mosq/util.rb
+homepage: https://github.com/jemc/ruby-mosq
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: mosq
+test_files: []
+has_rdoc: