mosquitto 0.2 → 0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 92a30539c75dec74a32576327cc88bd883502e89
-  data.tar.gz: 7d44ae4edbd3c241ba38048d1ae46ec1e2948194
+  metadata.gz: 9b3853298fbced225fd9fe2c425183e4f95ed036
+  data.tar.gz: 929f570d1f74476e6c21baffbe4c12aedc1d48c0
 SHA512:
-  metadata.gz: 99410f286d02e75c29f7663522c8b8a9f05bb35ccb7fce3f0e9ed8b6ea95b560ec2bd217dfc4c576db50bc38125a63d686cc4bcc3caf56ee77951dbe1e7a22d1
-  data.tar.gz: 49240900ce920a90cb5d5be4a7a5b9add7d576b1edf236b8623b0d95b4c9fb54879a86f20821ead46ba6d62f11674aa14ec9c1fb3ee307742781a84b120021e7
+  metadata.gz: 32319113ea684f52dab351e4dbd00c0c93bf8c610e1eb8b8cc2a22cc9e610ab377401a4e77330d046b7749398ca958543ebc71128b6a137e456fcd4905c5e996
+  data.tar.gz: a64bde7305272ce12d885b60c182de90f61387911f413fedf4ad532df72dde881161fa6b464e0c9bb08bcb8a68cc8b6491f290d7f71be0f72a1a0fa5b67acb60

data/.gitignore

@@ -18,4 +18,5 @@ doc/*
 pkg
 scratch
 ext/mosquitto/Makefile
-.yardoc
+.yardoc
+test/mosquitto.conf

data/.travis.yml

@@ -1,14 +1,17 @@
 language: ruby
 before_install:
   - sudo apt-get update -qq
-  - sudo apt-get install pkg-config cmake openssl
-  - wget http://mosquitto.org/files/source/mosquitto-1.2.3.tar.gz
+  - sudo apt-get install pkg-config cmake openssl libc-ares-dev
+  - wget http://mosquitto.org/files/source/mosquitto-1.3.1.tar.gz
 install:
-  - tar xzf mosquitto-1.2.3.tar.gz
-  - cd mosquitto-1.2.3
+  - tar xzf mosquitto-1.3.1.tar.gz
+  - cd mosquitto-1.3.1
   - cmake .
   - sudo make install
   - bundle install
+before_script:
+  - erb $TRAVIS_BUILD_DIR/test/mosquitto.conf.erb > $TRAVIS_BUILD_DIR/test/mosquitto.conf
+  - mosquitto -d -c $TRAVIS_BUILD_DIR/test/mosquitto.conf
 bundler_args: --quiet
 rvm:
   - 1.9.3
@@ -18,12 +21,12 @@ rvm:
 env:
   - GC_STRESS=0
   - GC_STRESS=1
-script: "bundle exec rake"
+script:
+  - bundle exec rake test:unit
+  - bundle exec rake test:integration
 gemfile:
   - Gemfile
 notifications:
   recipients:
     - lourens@methodmissing.com
-branches:
-  only:
-    - master
+    - errordeveloper@gmail.com

data/Gemfile

@@ -1,6 +1,3 @@
 source 'https://rubygems.org'
 
-gemspec
-
-gem 'rake'
-gem 'rdoc'
+gemspec

data/Gemfile.lock

@@ -1,25 +1,20 @@
 PATH
   remote: .
   specs:
-    mosquitto (0.1)
+    mosquitto (0.2)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    json (1.8.1)
-    rake (10.1.1)
+    rake (10.2.2)
     rake-compiler (0.9.2)
       rake
-    rdoc (4.1.1)
-      json (~> 1.4)
-    yard (0.8.7.3)
+    yard (0.8.7.4)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   mosquitto!
-  rake
   rake-compiler (~> 0.9.2)
-  rdoc
   yard

data/README.md

@@ -6,9 +6,9 @@ The mosquitto gem is meant to serve as an easy, performant and standards complia
 
 The API consists of two classes:
 
-[Mosquitto::Client](http://rubydoc.info/github/bear-metal/mosquitto/master/Mosquitto/Client) - the client
+[Mosquitto::Client](http://rubydoc.info/github/xively/mosquitto/master/Mosquitto/Client) - the client
 
-[Mosquitto::Message](http://rubydoc.info/github/bear-metal/mosquitto/master/Mosquitto/Message) - returned from the client
+[Mosquitto::Message](http://rubydoc.info/github/xively/mosquitto/master/Mosquitto/Message) - returned from the client
 
 ## About MQTT and libmosquitto
 
@@ -37,7 +37,7 @@ See the [project website](http://mosquitto.org/) for more information.
 
 ## Requirements
 
-This gem links against version 1.2.3 of `libmosquitto` . You will need to install additional packages for your system.
+This gem links against version 1.3.1 of `libmosquitto` . You will need to install additional packages for your system.
 
 ### OS X
 
@@ -51,17 +51,17 @@ brew install mosquitto
 
 ``` sh
 sudo apt-get update
-sudo apt-get install pkg-config cmake openssl
+sudo apt-get install pkg-config cmake openssl libc-ares-dev
 ```
 
-The current Ubuntu packages aren't on 1.2.3 yet - it's recommended to build libmosquitto from source (see below) until further notice. OpenSSL is an optional dependency - libmosquitto builds without it, however TLS specific features would not be available.
+The current Ubuntu packages aren't on 1.3.1 yet - it's recommended to build libmosquitto from source (see below) until further notice. OpenSSL is an optional dependency - libmosquitto builds without it, however TLS specific features would not be available.
 
 ### Building libmosquitto from source
 
 ``` sh
-wget http://mosquitto.org/files/source/mosquitto-1.2.3.tar.gz
-tar xzf mosquitto-1.2.3.tar.gz
-cd mosquitto-1.2.3
+wget http://mosquitto.org/files/source/mosquitto-1.3.1.tar.gz
+tar xzf mosquitto-1.3.1.tar.gz
+cd mosquitto-1.3.1
 cmake .
 sudo make install
 ```
@@ -87,7 +87,7 @@ When are requirements or dependencies are met, the following should install mosq
 gem install mosquitto
 ```
 
-The extension checks for libmosquitto presence as well as a 1.2.3 version.
+The extension checks for libmosquitto presence as well as a 1.3.1 version.
 
 ## Usage
 
@@ -180,17 +180,17 @@ publisher.connect("test.mosquitto.org", 1883, 10)
 
 The following callbacks are supported (please follow links for further documentation) :
 
-* [connect](http://rubydoc.info/github/bear-metal/mosquitto/master/Mosquitto/Client:on_connect) - called when the broker sends a CONNACK message in response to a connection.
-* [disconnect](http://rubydoc.info/github/bear-metal/mosquitto/master/Mosquitto/Client:on_disconnect) - called when the broker has received the DISCONNECT command and has disconnected the client.
-* [log](http://rubydoc.info/github/bear-metal/mosquitto/master/Mosquitto/Client:on_log) - should be used if you want event logging information from the client library.
-* [subscribe](http://rubydoc.info/github/bear-metal/mosquitto/master/Mosquitto/Client:on_subscribe) - called when the broker responds to a subscription request.
-* [unsubscribe](http://rubydoc.info/github/bear-metal/mosquitto/master/Mosquitto/Client:on_unsubscribe) - called when the broker responds to a unsubscription request.
-* [publish](http://rubydoc.info/github/bear-metal/mosquitto/master/Mosquitto/Client:on_publish) - called when a message initiated with Mosquitto::Client#publish has been sent to the broker successfully.
-* [message](http://rubydoc.info/github/bear-metal/mosquitto/master/Mosquitto/Client:on_message) - called when a message is received from the broker.
+* [connect](http://rubydoc.info/github/xively/mosquitto/master/Mosquitto/Client:on_connect) - called when the broker sends a CONNACK message in response to a connection.
+* [disconnect](http://rubydoc.info/github/xively/mosquitto/master/Mosquitto/Client:on_disconnect) - called when the broker has received the DISCONNECT command and has disconnected the client.
+* [log](http://rubydoc.info/github/xively/mosquitto/master/Mosquitto/Client:on_log) - should be used if you want event logging information from the client library.
+* [subscribe](http://rubydoc.info/github/xively/mosquitto/master/Mosquitto/Client:on_subscribe) - called when the broker responds to a subscription request.
+* [unsubscribe](http://rubydoc.info/github/xively/mosquitto/master/Mosquitto/Client:on_unsubscribe) - called when the broker responds to a unsubscription request.
+* [publish](http://rubydoc.info/github/xively/mosquitto/master/Mosquitto/Client:on_publish) - called when a message initiated with Mosquitto::Client#publish has been sent to the broker successfully.
+* [message](http://rubydoc.info/github/xively/mosquitto/master/Mosquitto/Client:on_message) - called when a message is received from the broker.
 
 ### TLS / SSL
 
-libmosquitto builds with TLS support by default, however [pre-shared key (PSK)](http://rubydoc.info/github/bear-metal/mosquitto/master/Mosquitto/Client:tls_psk_set) support is not available when linked against older OpenSSL versions.
+libmosquitto builds with TLS support by default, however [pre-shared key (PSK)](http://rubydoc.info/github/xively/mosquitto/master/Mosquitto/Client:tls_psk_set) support is not available when linked against older OpenSSL versions.
 
 ``` ruby
 tls_client = Mosquitto::Client.new
@@ -207,13 +207,13 @@ tls_client.tls_set('/path/to/mosquitto.org.crt'), nil, nil, nil, nil)
 tls_client.connect('test.mosquitto.org', 8883, 10)
 ```
 
-See [documentation](http://rubydoc.info/github/bear-metal/mosquitto) for the full API specification.
+See [documentation](http://rubydoc.info/github/xively/mosquitto) for the full API specification.
 
 ## Contact, feedback and bugs
 
 This extension is currently maintained by Lourens Naudé (http://github.com/methodmissing) and contributors.
 
-Please file bugs / issues and feature requests on the [issue tracker](https://github.com/bear-metal/mosquitto/issues)
+Please file bugs / issues and feature requests on the [issue tracker](https://github.com/xively/mosquitto/issues)
 
 ## Development
 
@@ -222,9 +222,9 @@ Use 'bundle install' to install the necessary development and testing gems:
 
 ``` sh
 bundle install
-rake
+bundle exec rake
 ```
-Tests by default run against the public `test.mosquitto.org` MQTT server, which supports TLS as well. More information is available at http://test.mosquitto.org/. Alternatively, should you wish you run tests against a local MQTT broker, change the following constants in the test helper to `localhost`:
+Tests by default run against an MQTT server on localhost, which is expected to support TLS on port 8883 as well.
 
 ``` ruby
 class MosquittoTestCase < Test::Unit::TestCase
@@ -237,7 +237,7 @@ class MosquittoTestCase < Test::Unit::TestCase
 
 ## Resources
 
-Documentation available at http://rubydoc.info/github/bear-metal/mosquitto
+Documentation available at http://rubydoc.info/github/xively/mosquitto
 
 ## Special Thanks
 

data/Rakefile

@@ -17,18 +17,20 @@ Rake::ExtensionTask.new('mosquitto') do |ext|
   CLEAN.include 'lib/**/mosquitto_ext.*'
 end
 
-desc 'Run mosquitto tests'
-Rake::TestTask.new(:test) do |t|
-  t.test_files = Dir.glob("test/**/test_*.rb")
-  t.verbose = true
-  t.warning = true
-end
+namespace :test do
+  desc 'Run mosquitto tests'
+  Rake::TestTask.new(:unit) do |t|
+    t.test_files = Dir.glob("test/**/test_*.rb").reject{|t| t =~ /integration/ }
+    t.verbose = true
+    t.warning = true
+  end
 
-desc 'Run mosquitto integration tests'
-Rake::TestTask.new(:integration) do |t|
-  t.test_files = Dir.glob("test/test_integration.rb")
-  t.verbose = true
-  t.warning = true
+  desc 'Run mosquitto integration tests'
+  Rake::TestTask.new(:integration) do |t|
+    t.test_files = Dir.glob("test/test_integration.rb")
+    t.verbose = true
+    t.warning = true
+  end
 end
 
 namespace :debug do
@@ -38,5 +40,7 @@ namespace :debug do
   end
 end
 
-task :test => :compile
+task 'test:unit' => :compile
+task 'test:integration' => :compile
+task :test => ['test:unit', 'test:integration']
 task :default => :test

data/ext/mosquitto/client.c

@@ -1,14 +1,16 @@
 #include "mosquitto_ext.h"
 
 static void rb_mosquitto_run_callback(mosquitto_callback_t *callback);
+static void rb_mosquitto_free_callback(mosquitto_callback_t *callback);
+static void rb_mosquitto_client_reap_event_thread(mosquitto_client_wrapper *client);
 
 VALUE mosquitto_tls_password;
 
 static int rb_mosquitto_tls_password_callback(char *buf, int size, int rwflag, void *obj)
 {
     strncpy(buf, StringValueCStr(mosquitto_tls_password), size);
-    return RSTRING_LEN(mosquitto_tls_password);
     rb_gc_unregister_address(&mosquitto_tls_password);
+    return RSTRING_LEN(mosquitto_tls_password);
 }
 
 /*
@@ -47,10 +49,10 @@ static mosquitto_callback_t *mosquitto_callback_queue_pop(mosquitto_client_wrapp
  *  Only applicable to clients that run with the threaded Mosquitto::Client#loop_start event loop
  *
  */
-static void *mosquitto_wait_for_callbacks(void *w)
+static void *mosquitto_wait_for_callbacks(void *c)
 {
-    mosquitto_callback_waiting_t *waiter = (mosquitto_callback_waiting_t *)w;
-    mosquitto_client_wrapper *client = waiter->client;
+    mosquitto_client_wrapper *client = (mosquitto_client_wrapper *)c;
+    mosquitto_callback_waiting_t *waiter = client->waiter;
 
     pthread_mutex_lock(&client->callback_mutex);
     while (!waiter->abort && (waiter->callback = mosquitto_callback_queue_pop(client)) == NULL)
@@ -69,13 +71,17 @@ static void *mosquitto_wait_for_callbacks(void *w)
  *  Only applicable to clients that run with the threaded Mosquitto::Client#loop_start event loop
  *
  */
-static void mosquitto_stop_waiting_for_callbacks(void *w)
+static void mosquitto_stop_waiting_for_callbacks(void *c)
 {
-    mosquitto_callback_waiting_t *waiter = (mosquitto_callback_waiting_t *)w;
-    mosquitto_client_wrapper *client = waiter->client;
+    mosquitto_client_wrapper *client = (mosquitto_client_wrapper *)c;
+    mosquitto_callback_waiting_t *waiter = client->waiter;
+    mosquitto_callback_t *callback = NULL;
 
     pthread_mutex_lock(&client->callback_mutex);
     waiter->abort = 1;
+    while ((callback = mosquitto_callback_queue_pop(client)) != NULL) {
+        rb_mosquitto_free_callback(callback);
+    }
     pthread_mutex_unlock(&client->callback_mutex);
     pthread_cond_signal(&client->callback_cond);
 }
@@ -168,18 +174,10 @@ static void rb_mosquitto_handle_callback(int *error_tag, mosquitto_callback_t *c
                                     args[0] = client->connect_cb;
                                     args[1] = (VALUE)1;
                                     args[2] = INT2NUM(cb->rc);
-                                    switch (cb->rc) {
-                                        case 1:
-                                                MosquittoError("connection refused (unacceptable protocol version)");
-                                                break;
-                                        case 2:
-                                                MosquittoError("connection refused (identifier rejected)");
-                                                break;
-                                        case 3:
-                                                MosquittoError("connection refused (broker unavailable)");
-                                                break;
-                                        default:
-                                                 rb_mosquitto_funcall_protected(error_tag, args);           
+                                    if (cb->rc == 0) {
+                                        rb_mosquitto_funcall_protected(error_tag, args);
+                                    } else {
+                                        MosquittoError(mosquitto_connack_string(cb->rc));
                                     }
                                   }
                                   break;
@@ -269,19 +267,17 @@ static void rb_mosquitto_run_callback(mosquitto_callback_t *callback)
 static VALUE rb_mosquitto_callback_thread(void *obj)
 {
     mosquitto_client_wrapper *client = (mosquitto_client_wrapper *)obj;
-    mosquitto_callback_waiting_t waiter;
-    waiter.callback = NULL;
-    waiter.abort = 0;
-    waiter.client = client;
-    while (!waiter.abort)
+    mosquitto_callback_waiting_t *waiter = client->waiter;
+    waiter->callback = NULL;
+    waiter->abort = 0;
+    while (!waiter->abort)
     {
-        rb_thread_call_without_gvl(mosquitto_wait_for_callbacks, (void *)&waiter, mosquitto_stop_waiting_for_callbacks, (void *)&waiter);
-        if (waiter.callback)
+        rb_thread_call_without_gvl(mosquitto_wait_for_callbacks, (void *)client, mosquitto_stop_waiting_for_callbacks, (void *)client);
+        if (waiter->callback)
         {
-            rb_mosquitto_run_callback(waiter.callback);
+            rb_mosquitto_run_callback(waiter->callback);
         }
     }
-
     return Qnil;
 }
 
@@ -444,7 +440,14 @@ static void rb_mosquitto_free_client(void *ptr)
 {
     mosquitto_client_wrapper *client = (mosquitto_client_wrapper *)ptr;
     if (client) {
-        mosquitto_destroy(client->mosq);
+        if (client->mosq != NULL) {
+            if (!NIL_P(client->callback_thread)) {
+                mosquitto_stop_waiting_for_callbacks(client);
+                mosquitto_loop_stop(client->mosq, true);
+                rb_mosquitto_client_reap_event_thread(client);
+            }
+            if (client->mosq != NULL) mosquitto_destroy(client->mosq);
+        }
         xfree(client);
     }
 }
@@ -508,6 +511,7 @@ static VALUE rb_mosquitto_client_s_new(int argc, VALUE *argv, VALUE client)
     cl->log_cb = Qnil;
     cl->callback_thread = Qnil;
     cl->callback_queue = NULL;
+    cl->waiter = NULL;
     rb_obj_call_init(client, 0, NULL);
     return client;
 }
@@ -688,7 +692,7 @@ static VALUE rb_mosquitto_client_auth(VALUE obj, VALUE username, VALUE password)
 
 /*
  * call-seq:
- *   client.tls_set('/certs/all-ca.crt'), '/certs', '/certs/client.crt'), '/certs/client.key') -> Boolean
+ *   client.tls_set('/certs/all-ca.crt'), '/certs', '/certs/client.crt'), '/certs/client.key', 'password') -> Boolean
  *
  * Configure the client for certificate based SSL/TLS support.
  * 
@@ -714,7 +718,7 @@ static VALUE rb_mosquitto_client_auth(VALUE obj, VALUE username, VALUE password)
  * @raise [Mosquitto::Error] on invalid input params or when TLS is not supported
  * @note This must be called before calling Mosquitto::Client#connect
  * @example
- *   client.tls_set('/certs/all-ca.crt'), '/certs', '/certs/client.crt'), '/certs/client.key')
+ *   client.tls_set('/certs/all-ca.crt'), '/certs', '/certs/client.crt'), '/certs/client.key', 'password')
  *
  */
 static VALUE rb_mosquitto_client_tls_set(VALUE obj, VALUE cafile, VALUE capath, VALUE certfile, VALUE keyfile, VALUE password)
@@ -1175,13 +1179,17 @@ static void *rb_mosquitto_client_disconnect_nogvl(void *ptr)
 static VALUE rb_mosquitto_client_disconnect(VALUE obj)
 {
     int ret;
+    bool retried = false;
+    struct timeval time;
     MosquittoGetClient(obj);
+  retry_once:
     ret = (int)rb_thread_call_without_gvl(rb_mosquitto_client_disconnect_nogvl, (void *)client->mosq, RUBY_UBF_IO, 0);
     switch (ret) {
        case MOSQ_ERR_INVAL:
            MosquittoError("invalid input params");
            break;
        case MOSQ_ERR_NO_CONN:
+           RetryNotConnectedOnce();
            MosquittoError("client not connected to broker");
            break;
        default:
@@ -1219,6 +1227,8 @@ static VALUE rb_mosquitto_client_publish(VALUE obj, VALUE mid, VALUE topic, VALU
 {
     struct nogvl_publish_args args;
     int ret, msg_id;
+    struct timeval time;
+    bool retried = false;
     MosquittoGetClient(obj);
     Check_Type(topic, T_STRING);
     MosquittoEncode(topic);
@@ -1236,6 +1246,7 @@ static VALUE rb_mosquitto_client_publish(VALUE obj, VALUE mid, VALUE topic, VALU
     args.payload = (const char *)(args.payloadlen == 0 ? NULL : StringValueCStr(payload));
     args.qos = NUM2INT(qos);
     args.retain = (retain == Qtrue) ? true : false;
+  retry_once:
     ret = (int)rb_thread_call_without_gvl(rb_mosquitto_client_publish_nogvl, (void *)&args, RUBY_UBF_IO, 0);
     switch (ret) {
        case MOSQ_ERR_INVAL:
@@ -1245,6 +1256,7 @@ static VALUE rb_mosquitto_client_publish(VALUE obj, VALUE mid, VALUE topic, VALU
            rb_memerror();
            break;
        case MOSQ_ERR_NO_CONN:
+           RetryNotConnectedOnce();
            MosquittoError("client not connected to broker");
            break;
        case MOSQ_ERR_PROTOCOL:
@@ -1286,6 +1298,8 @@ static VALUE rb_mosquitto_client_subscribe(VALUE obj, VALUE mid, VALUE subscript
 {
     struct nogvl_subscribe_args args;
     int ret, msg_id;
+    struct timeval time;
+    bool retried = false;
     MosquittoGetClient(obj);
     Check_Type(subscription, T_STRING);
     MosquittoEncode(subscription);
@@ -1298,6 +1312,7 @@ static VALUE rb_mosquitto_client_subscribe(VALUE obj, VALUE mid, VALUE subscript
     args.mid = NIL_P(mid) ? NULL : &msg_id;
     args.subscription = StringValueCStr(subscription);
     args.qos = NUM2INT(qos);
+  retry_once:
     ret = (int)rb_thread_call_without_gvl(rb_mosquitto_client_subscribe_nogvl, (void *)&args, RUBY_UBF_IO, 0);
     switch (ret) {
        case MOSQ_ERR_INVAL:
@@ -1307,6 +1322,7 @@ static VALUE rb_mosquitto_client_subscribe(VALUE obj, VALUE mid, VALUE subscript
            rb_memerror();
            break;
        case MOSQ_ERR_NO_CONN:
+           RetryNotConnectedOnce();
            MosquittoError("client not connected to broker");
            break;
        default:
@@ -1340,6 +1356,8 @@ static VALUE rb_mosquitto_client_unsubscribe(VALUE obj, VALUE mid, VALUE subscri
 {
     struct nogvl_subscribe_args args;
     int ret, msg_id;
+    struct timeval time;
+    bool retried = false;
     MosquittoGetClient(obj);
     Check_Type(subscription, T_STRING);
     MosquittoEncode(subscription);
@@ -1350,6 +1368,7 @@ static VALUE rb_mosquitto_client_unsubscribe(VALUE obj, VALUE mid, VALUE subscri
     args.mosq = client->mosq;
     args.mid = NIL_P(mid) ? NULL : &msg_id;
     args.subscription = StringValueCStr(subscription);
+  retry_once:
     ret = (int)rb_thread_call_without_gvl(rb_mosquitto_client_unsubscribe_nogvl, (void *)&args, RUBY_UBF_IO, 0);
     switch (ret) {
        case MOSQ_ERR_INVAL:
@@ -1359,6 +1378,7 @@ static VALUE rb_mosquitto_client_unsubscribe(VALUE obj, VALUE mid, VALUE subscri
            rb_memerror();
            break;
        case MOSQ_ERR_NO_CONN:
+           RetryNotConnectedOnce();
            MosquittoError("client not connected to broker");
            break;
        default:
@@ -1426,12 +1446,15 @@ static VALUE rb_mosquitto_client_loop(VALUE obj, VALUE timeout, VALUE max_packet
 {
     struct nogvl_loop_args args;
     int ret;
+    struct timeval time;
+    bool retried = false;
     MosquittoGetClient(obj);
     Check_Type(timeout, T_FIXNUM);
     Check_Type(max_packets, T_FIXNUM);
     args.mosq = client->mosq;
     args.timeout = NUM2INT(timeout);
     args.max_packets = NUM2INT(max_packets);
+  retry_once:
     ret = (int)rb_thread_call_without_gvl(rb_mosquitto_client_loop_nogvl, (void *)&args, RUBY_UBF_IO, 0);
     switch (ret) {
        case MOSQ_ERR_INVAL:
@@ -1441,6 +1464,7 @@ static VALUE rb_mosquitto_client_loop(VALUE obj, VALUE timeout, VALUE max_packet
            rb_memerror();
            break;
        case MOSQ_ERR_NO_CONN:
+           RetryNotConnectedOnce();
            MosquittoError("client not connected to broker");
            break;
        case MOSQ_ERR_CONN_LOST:
@@ -1493,12 +1517,15 @@ static VALUE rb_mosquitto_client_loop_forever(VALUE obj, VALUE timeout, VALUE ma
 {
     struct nogvl_loop_args args;
     int ret;
+    struct timeval time;
+    bool retried = false;
     MosquittoGetClient(obj);
     Check_Type(timeout, T_FIXNUM);
     Check_Type(max_packets, T_FIXNUM);
     args.mosq = client->mosq;
     args.timeout = NUM2INT(timeout);
     args.max_packets = NUM2INT(max_packets);
+  retry_once:
     ret = (int)rb_thread_call_without_gvl(rb_mosquitto_client_loop_forever_nogvl, (void *)&args, rb_mosquitto_client_loop_forever_ubf, client);
     switch (ret) {
        case MOSQ_ERR_INVAL:
@@ -1508,6 +1535,7 @@ static VALUE rb_mosquitto_client_loop_forever(VALUE obj, VALUE timeout, VALUE ma
            rb_memerror();
            break;
        case MOSQ_ERR_NO_CONN:
+           RetryNotConnectedOnce();
            MosquittoError("client not connected to broker");
            break;
        case MOSQ_ERR_CONN_LOST:
@@ -1559,8 +1587,9 @@ static VALUE rb_mosquitto_client_loop_start(VALUE obj)
            MosquittoError("thread support is not available");
            break;
        default:
-           pthread_mutex_init(&client->callback_mutex, NULL);
-           pthread_cond_init(&client->callback_cond, NULL);
+           client->waiter = MOSQ_ALLOC(mosquitto_callback_waiting_t);
+           if (pthread_mutex_init(&client->callback_mutex, NULL) != 0) MosquittoError("failed to create callback thread mutex");
+           if (pthread_cond_init(&client->callback_cond, NULL) != 0) MosquittoError("failed to create callback thread condition var");
            client->callback_thread = rb_thread_create(rb_mosquitto_callback_thread, client);
            /* Allow the callback thread some startup time */
            time.tv_sec  = 0;
@@ -1576,9 +1605,23 @@ static void *rb_mosquitto_client_loop_stop_nogvl(void *ptr)
     return (VALUE)mosquitto_loop_stop(args->mosq, args->force);
 }
 
+static void rb_mosquitto_client_reap_event_thread(mosquitto_client_wrapper *client)
+{
+    struct timeval time;
+    mosquitto_stop_waiting_for_callbacks(client);
+    /* Allow the callback thread some shutdown time */
+    time.tv_sec  = 0;
+    time.tv_usec = 100 * 1000;  /* 0.1 sec */
+    rb_thread_wait_for(time);
+    if (pthread_mutex_destroy(&client->callback_mutex) == EINVAL) MosquittoError("could not destroy callback thread mutex");
+    if (pthread_cond_destroy(&client->callback_cond) == EINVAL) MosquittoError("could not destroy callback condition var");
+    xfree(client->waiter);
+    client->callback_thread = Qnil;
+}
+
 /*
  * call-seq:
- *   client.loop_start -> Boolean
+ *   client.loop_stop(true) -> Boolean
  *
  * This is part of the threaded client interface. Call this once to stop the
  * network thread previously created with Mosquitto::Client#loop_start. This call
@@ -1591,7 +1634,7 @@ static void *rb_mosquitto_client_loop_stop_nogvl(void *ptr)
  * @return [true] on success
  * @raise [Mosquitto::Error] on invalid input params or if thread support is not available
  * @example
- *   client.loop_start
+ *   client.loop_stop(true)
  *
  */
 static VALUE rb_mosquitto_client_loop_stop(VALUE obj, VALUE force)
@@ -1604,16 +1647,13 @@ static VALUE rb_mosquitto_client_loop_stop(VALUE obj, VALUE force)
     ret = (int)rb_thread_call_without_gvl(rb_mosquitto_client_loop_stop_nogvl, (void *)&args, RUBY_UBF_IO, 0);
     switch (ret) {
        case MOSQ_ERR_INVAL:
-           MosquittoError("invalid input params");
+           MosquittoError("Threaded main loop not running for this client. Are you sure you haven't already called Mosquitto::Client#loop_stop ?");
            break;
        case MOSQ_ERR_NOT_SUPPORTED :
            MosquittoError("thread support is not available");
            break;
        default:
-           pthread_mutex_destroy(&client->callback_mutex);
-           pthread_cond_destroy(&client->callback_cond);
-           rb_thread_kill(client->callback_thread);
-           client->callback_thread = Qnil;
+           rb_mosquitto_client_reap_event_thread(client);
            return Qtrue;
     }
 }
@@ -1784,6 +1824,30 @@ static VALUE rb_mosquitto_client_want_write(VALUE obj)
     return (ret == true) ? Qtrue : Qfalse;
 }
 
+/*
+ * call-seq:
+ *   client.destroy -> Boolean
+ *
+ * Free memory associated with a mosquitto client instance. Used in integration tests only.
+ *
+ * @return [true] true when memory freed
+ * @example
+ *   client.destroy
+ *
+ */
+static VALUE rb_mosquitto_client_destroy(VALUE obj)
+{
+    MosquittoGetClient(obj);
+    if (!NIL_P(client->callback_thread)) {
+        mosquitto_stop_waiting_for_callbacks(client);
+        mosquitto_loop_stop(client->mosq, true);
+        rb_mosquitto_client_reap_event_thread(client);
+    }
+    mosquitto_destroy(client->mosq);
+    client->mosq = NULL;
+    return Qtrue;
+}
+
 /*
  * call-seq:
  *   client.reconnect_delay_set(2, 10, true) -> Boolean
@@ -2160,4 +2224,8 @@ void _init_rb_mosquitto_client()
     rb_define_method(rb_cMosquittoClient, "on_subscribe", rb_mosquitto_client_on_subscribe, -1);
     rb_define_method(rb_cMosquittoClient, "on_unsubscribe", rb_mosquitto_client_on_unsubscribe, -1);
     rb_define_method(rb_cMosquittoClient, "on_log", rb_mosquitto_client_on_log, -1);
+
+    /* For integration testing only (will) */
+    rb_define_method(rb_cMosquittoClient, "destroy", rb_mosquitto_client_destroy, 0);
+
 }