mosq 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 77871424981b16bc758d319dbabbb63958f96d61
-  data.tar.gz: e61adcdefbc1238c1df36e54ca6e6f6b3dfba294
+  metadata.gz: b296db03c458067273327316bdb11e9e363d671e
+  data.tar.gz: 78c2ba4c4782f25a010398be2823161163b49411
 SHA512:
-  metadata.gz: 8348f60d1caf81225fd7c7ae9b75f5e0030d514a6c0986ac4eef21ea036dad1fefc5977e1ae34d0d6d058092ce0d5c588a59bfa5807a5874edbbd2a81f48a820
-  data.tar.gz: 3e7d5d2ddd4b732905ae73f43bd94bae371a537007065df1d0a1c753692c7731325e49a2dd837b962defa4d5443d5624c1cec9b7ce11ef11dddf791c673cf44d
+  metadata.gz: 07a7d0ab55446f767c6a81eba9eae3a1ea08524c55d2fc6f29a32a26e33e192a3bb01cd9e49ca4a9a0bef36b72d96f76c8f78466f1808d9acf7fb68504180a27
+  data.tar.gz: 41e4acb30e8ae4c775864a1f6df4545f4ebde02850a5c02b3bdd0d100fed4dff417f3232ddd29a1140d2001f75484b26f1ab44f595cc342743860388bd5fbe02

data/ext/mosq/Rakefile

@@ -36,9 +36,15 @@ file_task 'mosquitto', :download => :download_tarball do
 end
 
 file_task "libmosquitto.#{::FFI::Platform::LIBSUFFIX}", :build => :download do
-  mkflags = "WITH_THREADING=no WITH_SRV=no WITH_UUID=false"
-  cmd "/usr/bin/env sh -c 'cd #{FILES[:download]} && make #{mkflags}'"
-  cmd "cp #{FILES[:download]}/lib/#{FILES[:build]}* ./#{FILES[:build]}"
+  begin
+    mkflags = "WITH_THREADING=no WITH_SRV=no WITH_UUID=no"
+    cmd "/usr/bin/env sh -c 'cd #{FILES[:download]} && make #{mkflags}'"
+    cmd "cp #{FILES[:download]}/lib/#{FILES[:build]}* ./#{FILES[:build]}"
+  rescue RuntimeError # make won't work on OSX, asking to use cmake instead.
+    cmkflags = "-DWITH_THREADING=OFF -DWITH_SRV=OFF"
+    cmd "/usr/bin/env sh -c 'cd #{FILES[:download]} && cmake . #{cmkflags} && make'"
+    cmd "cp #{FILES[:download]}/lib/#{FILES[:build]} ./#{FILES[:build]}"
+  end
 end
 
 task :compact => FILES[:build] do

data/lib/mosq/client.rb

@@ -44,7 +44,8 @@ module Mosq
     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!.
+    # yielding control back to the client object by calling methods like
+    # {#run_loop!} and {#run_immediate!}.
     def max_poll_interval
       @options.fetch(:heartbeat) / 2.0
     end
@@ -181,6 +182,70 @@ module Mosq
       self
     end
     
+    # Subscribe to many topics. This is more performant than many calls
+    # to {#subscribe}, as the transactions occur concurrently.
+    #
+    # @param topics [Array<String>] The topic patterns to subscribe to.
+    # @param qos [Integer] The QoS level to use for all publish transaction.
+    # @return [Client] This client.
+    #
+    def subscribe_many(topics, qos: 0)
+      packet_ids = []
+      topics.each do |topic|
+        Util.error_check "subscribing to many topics",
+          FFI.mosquitto_subscribe(ptr, @packet_id_ptr, topic, qos)
+        
+        packet_ids << @packet_id_ptr.read_int
+      end
+      
+      fetch_responses(:subscribe, packet_ids)
+      
+      self
+    end
+    
+    # Unsubscribe from many topics. This is more performant than many calls
+    # to {#unsubscribe}, as the transactions occur concurrently.
+    #
+    # @param topics [Array<String>] The topic patterns to unsubscribe from.
+    # @return [Client] This client.
+    #
+    def unsubscribe_many(topics)
+      packet_ids = []
+      topics.each do |topic|
+        Util.error_check "subscribing to many topics",
+          FFI.mosquitto_unsubscribe(ptr, @packet_id_ptr, topic)
+        
+        packet_ids << @packet_id_ptr.read_int
+      end
+      
+      fetch_responses(:unsubscribe, packet_ids)
+      
+      self
+    end
+    
+    # Publish many pairs of topic/payload as messages. This is more performant
+    # than many calls to {#publish}, as the transactions occur concurrently.
+    #
+    # @param pairs [Array<Array(String, String)>] The topic/payload pairs.
+    # @param qos [Integer] The QoS level to use for all publish transaction.
+    # @param retain [Boolean] Whether the broker should retain the messages.
+    # @return [Client] This client.
+    #
+    def publish_many(pairs, qos: 0, retain: false)
+      packet_ids = []
+      pairs.each do |topic, payload|
+        Util.error_check "publishing many messages",
+          FFI.mosquitto_publish(ptr, @packet_id_ptr,
+            topic, payload.bytesize, payload, qos, retain)
+        
+        packet_ids << @packet_id_ptr.read_int
+      end
+      
+      fetch_responses(:publish, packet_ids)
+      
+      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.
@@ -302,7 +367,8 @@ module Mosq
     end
     
     # Internal implementation of synchronous responses.
-    def fetch_response(expected_type, expected_packet_id, timeout=protocol_timeout, start=Time.now)
+    def fetch_response(expected_type, expected_packet_id,
+                       timeout=protocol_timeout, start=Time.now)
       unwanted_events = []
       
       while (event = fetch_next_event(timeout, start))
@@ -320,5 +386,34 @@ module Mosq
       
       raise FFI::Error::Timeout, "waiting for #{expected_type} response"
     end
+    
+    # Internal implementation of multiple outstanding synchronous responses.
+    def fetch_responses(expected_type, expected_packet_ids,
+                        timeout=protocol_timeout, start=Time.now)
+      return [] if expected_packet_ids.empty?
+      unwanted_events = []
+      wanted_events   = []
+      
+      while (event = fetch_next_event(timeout, start))
+        if (event.fetch(:type) == expected_type) && (
+            expected_packet_ids.include?(event.fetch(:packet_id))
+          )
+          wanted_events.push(event)
+        else
+          unwanted_events.push(event)
+        end
+        
+        if wanted_events.size >= expected_packet_ids.size
+          unwanted_events.reverse_each { |e| @bucket.events.unshift(e) }
+          wanted_events.each do |event|
+            handle_incoming_event(event)
+          end
+          
+          return wanted_events
+        end
+      end
+      
+      raise FFI::Error::Timeout, "waiting for #{expected_type} responses"
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mosq
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Joe McIlvain