nutella_lib 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 607bc8f43c55bdddc4a0496c48cde8f7ff26aa50
-  data.tar.gz: 075da6ca64d50df6ac3b49e48eb818618483c96a
+  metadata.gz: 452fc30366c7f02a64fb608208189e791be03b59
+  data.tar.gz: 9707d639e096aa37f9d34fefba639b198309ddb6
 SHA512:
-  metadata.gz: fd598f8a12fa7d9ed398a5458d7c9ea642506a3376b968363ca9abcbcfedb18ad22d8f58353b4eab3174dc1bfe11db10c2d7454dbc013b052d464640450384d7
-  data.tar.gz: 83fa75629fe26f0358b6d369d33d3566589cacdf5ffe64be982450ebc537f97329ebdb9acd3cd9b6db5c13cf92828c9a6b551337d26703357d475740ec1c53f8
+  metadata.gz: 23a92b1be185d721717535403503bba4eb316ac7a771d2b927329b1748e4a60e81334423bda05aa0d1872188b36e3c2ea88bdd21752b7326963ec21b0fe4fe8f
+  data.tar.gz: 98788b6730515f32623ce4ca3fb785221d1d7454117c4fe4eb577b950c667a2d07b7d6cb4ec89fb5ab8ab71e5401207fd43cf52f9ce5230cb252d4def4663c30

data/Gemfile

@@ -1,6 +1,6 @@
 source 'http://rubygems.org'
 
-gem 'simple_ruby_mqtt_client', '~> 0.3.1', '>= 0.3.1'
+gem 'mqtt', '~> 0.3', '>= 0.3'
 
 group :development do
   gem 'shoulda', '~> 3', '>= 3'

data/README.md

@@ -1,3 +1,6 @@
-# nutella_lib.rb [![Build Status](https://travis-ci.org/nutella-framework/nutella_lib.rb.svg)](https://travis-ci.org/nutella-framework/nutella_lib.rb)
-nutella protocol library for ruby
+[![Gem Version](https://badge.fury.io/rb/nutella_lib.svg)](http://badge.fury.io/rb/nutella_lib)
+[![Build Status](https://travis-ci.org/nutella-framework/nutella_lib.rb.svg)](https://travis-ci.org/nutella-framework/nutella_lib.rb)
+
+# nutella_lib.rb
+nutella library for Ruby
 

data/VERSION

@@ -1 +1 @@
-0.2.2
+0.3.0

data/lib/nutella_lib.rb

@@ -1,9 +1,9 @@
 require 'nutella_lib/core'
 require 'nutella_lib/net'
 require 'nutella_lib/persist'
+require 'simple_mqtt_client/simple_mqtt_client'
 
 # Gems used across the whole library
-require 'simple_ruby_mqtt_client'
 require 'json'
 require 'set'
 

data/lib/nutella_lib/core.rb

@@ -1,37 +1,57 @@
 # This module is the wrapper around the whole nutella library.
 module Nutella
 
+
   # Initializes the nutella library
-  def Nutella.init(args)
-    if args.length < 2
-      STDERR.puts "Couldn't read run_id and broker address from the command line, impossible to initialize library!"
-      return
-    end
-    @run_id = args[0]
-    @actor_name = Nutella.config_actor_name
-    @mqtt = SimpleMQTTClient.new(args[1])
+  # @param [String] run_id
+  # @param [String] broker_hostname
+  # @param [String] component_id
+  def self.init(run_id, broker_hostname, component_id)
+    @run_id = run_id
+    @component_id = component_id
+    @resource_id = nil
+    @mqtt = SimpleMQTTClient.new broker_hostname
   end
 
 
   # Accessors for module instance variables
-  def Nutella.run_id; @run_id end
-  def Nutella.actor_name; @actor_name end
-  def Nutella.mqtt; @mqtt end
+  def self.run_id; @run_id end
+  def self.component_id; @component_id end
+  def self.resource_id; @resource_id end
+  def self.mqtt; @mqtt end
+
 
 
   # Nutella library modules loading
-  def Nutella.net; Nutella::Net end
-  def Nutella.persist; Nutella::Persist end
+  def self.net; Nutella::Net end
+  def self.persist; Nutella::Persist end
+
 
+  # Utility functions
+
+
+  # Parse command line arguments
+  def self.parse_args(args)
+    if args.length < 2
+      STDERR.puts "Couldn't read run_id and broker address from the command line, impossible to initialize library!"
+      return
+    end
+    return args[0], args[1]
+  end
 
-  private
 
   # Extracts the actor name based on the the folder where we are executing
-  def Nutella.config_actor_name
+  def self.extract_component_id
     path = Dir.pwd
     path[path.rindex('/')+1..path.length-1]
   end
 
+
+  # Sets the resource id
+  def self.set_resource_id( resource_id )
+    @resource_id = resource_id
+  end
+
 end
 
 

data/lib/nutella_lib/net.rb

@@ -1,62 +1,79 @@
 module Nutella
 
-  # This class implements the pub/sub nutella protocol
+  # This class implements the pub/sub and request/response nutella protocol
   # @author Alessandro Gnoli <tebemis@gmail.com>
   module Net
 
-    # Subscribe to a channel
-    # The callback takes one parameter and that is the message that is received.
-    # Messages that are not JSON are discarded.
+    # Store the subscriptions and the relative callbacks
+    @subscriptions = []
+    @callbacks = []
+
+    # Subscribe to a channel or to a set of channels if using wildcards
+    #
+    # @param [String] channel the channel we are subscribing to, can be wildcard
+    # @param [Proc] callback a lambda expression that takes as parameters:
+    # - the received message. Messages that are not JSON are discarded.
+    # - the channel the message was received on (in case of wildcard subscription)
+    # - the sender's component_id
+    # - the sender's resource_id (if set by the sender)
     def Net.subscribe (channel, callback)
+      # Maintain unique subscriptions
+      raise 'You can`t subscribe twice to the same channel`' if @subscriptions.include? channel
       # Pad the channel
-      new_channel = Nutella.run_id + '/' + channel
-      # Subscribe
+      new_channel = "#{Nutella.run_id}/#{channel}"
       # Depending on what type of channel we are subscribing to (wildcard or simple)
       # register a different kind of callback
       if Nutella.mqtt.is_channel_wildcard?(channel)
-        Nutella.mqtt.subscribe(
-            new_channel,
-            lambda do |message, channel|
-              # Make sure the message is JSON, if not drop the message
-              begin
-                message_hash = JSON.parse(message)
-                callback.call(message_hash, channel)
-              rescue
-                return
-              end
-            end
-        )
+        mqtt_cb = lambda do |mqtt_message, mqtt_channel|
+          # Make sure the message is JSON, if not drop the message
+          begin
+            mqtt_channel.slice!("#{Nutella.run_id}/")
+            type, payload, component_id, resource_id = extract_fields_from_message mqtt_message
+            callback.call(payload, mqtt_channel, component_id, resource_id) if type=='publish'
+          rescue
+            return
+          end
+        end
       else
-        Nutella.mqtt.subscribe(
-            new_channel,
-            lambda do |message|
-              # Make sure the message is JSON, if not drop the message
-              begin
-                message_hash = JSON.parse(message)
-                callback.call(message_hash)
-              rescue
-                return
-              end
-            end
-        )
+        mqtt_cb = lambda do |message|
+          # Make sure the message is JSON, if not drop the message
+          begin
+            type, payload, component_id, resource_id = extract_fields_from_message message
+            callback.call(payload, component_id, resource_id)  if type=='publish'
+          rescue
+            return
+          end
+        end
       end
+      # Subscribe
+      @subscriptions.push channel
+      @callbacks.push mqtt_cb
+      Nutella.mqtt.subscribe(new_channel, mqtt_cb)
     end
 
+
     # Unsubscribe from a channel
     def Net.unsubscribe(channel)
+      idx = @subscriptions.index channel
+      # If we are not subscribed to this channel, return (no error is given)
+      return if idx.nil?
       # Pad the channel
+      mqtt_cb = @callbacks[idx]
       new_channel = Nutella.run_id + '/' + channel
       # Unsubscribe
-      Nutella.mqtt.unsubscribe(new_channel)
+      @subscriptions.delete_at idx
+      @callbacks.delete_at idx
+      Nutella.mqtt.unsubscribe( new_channel, mqtt_cb )
     end
 
+
     # Publishes a message to a channel
     # Message can be:
     # empty (equivalent of a GET)
     # string (the string will be wrapped into a JSON string automatically. Format: {"payload":"<message>"})
     # hash (the hash will be converted into a JSON string automatically)
     # json string (the JSON string will be sent as is)
-    def Net.publish(channel, message)
+    def Net.publish(channel, message=nil)
       # Pad the channel
       new_channel = Nutella.run_id + '/' + channel
       # Publish
@@ -68,105 +85,92 @@ module Nutella
       end
     end
 
+
     # Performs a synchronous request
     # Message can be:
     # empty (equivalent of a GET)
     # string (the string will be wrapped into a JSON string automatically. Format: {"payload":"<message>"})
     # hash (the hash will be converted into a JSON string automatically)
     # json string (the JSON string will be sent as is)
-    def Net.sync_req (channel, message="")
-      # Generate message unique id
-      id = message.hash
-      # Attach id
-      begin
-        payload = Net.attach_message_id(message, id)
-      rescue
-        STDERR.puts $!
-        return
-      end
-      # Initialize response and response counter
-      ready_to_go = 2
+    def Net.sync_req (channel, message=nil)
+      # Pad channel
+      new_channel = "#{Nutella.run_id}/#{channel}"
+      # Prepare message
+      m, id = prepare_message_for_request message
+      # Initialize response
       response = nil
-      # Subscribe to same channel to collect response
-      Net.subscribe(channel, lambda do |res|
-        if (res["id"]==id)
-          ready_to_go -= 1
-          if ready_to_go==0
-            Net.unsubscribe(channel)
-            response = res
-          end
+      # Prepare callback
+      mqtt_cb = lambda do |mqtt_message|
+        m_id = extract_id_from_message mqtt_message
+        type, payload  = extract_fields_from_response mqtt_message
+        if m_id==id && type=='response'
+          response = payload
+          Nutella.mqtt.unsubscribe( new_channel, mqtt_cb )
         end
-      end)
-      # Send message the message
-      Net.publish(channel, payload)
+      end
+      # Subscribe
+      Nutella.mqtt.subscribe( new_channel, mqtt_cb )
+      # Publish message
+      Nutella.mqtt.publish( new_channel, m )
       # Wait for the response to come back
-      sleep(0.5) until ready_to_go==0
+      sleep(0.1) while response.nil?
       response
     end
 
-    # Performs an asynchronosus request
+
+    # Performs an asynchronous request
     # Message can be:
     # empty (equivalent of a GET)
     # string (the string will be wrapped into a JSON string automatically. Format: {"payload":"<message>"})
     # hash (the hash will be converted into a JSON string automatically)
     # json string (the JSON string will be sent as is)
-    def Net.async_req (channel, message="", callback)
-      # Generate message unique id
-      id = message.hash
-      # Attach id
-      begin
-        payload = Net.attach_message_id(message, id)
-      rescue
-        STDERR.puts $!
-        return
-      end
-      # Initialize flag that prevents handling of our own messages
-      ready_to_go = false
-      # Register callback to handle data the request response whenever it comes
-      Net.subscribe(channel, lambda do |res|
-        # Check that the message we receive is not the one we are sending ourselves.
-        if res["id"]==id
-          if ready_to_go
-            Net.unsubscribe(channel)
-            callback.call(res)
-          else
-            ready_to_go = true
-          end
+    def Net.async_req (channel, message=nil, callback)
+      # Pad channel
+      new_channel = "#{Nutella.run_id}/#{channel}"
+      # Prepare message
+      m, id = prepare_message_for_request message
+      # Initialize response
+      # Prepare callback
+      mqtt_cb = lambda do |message|
+        m_id = extract_id_from_message message
+        type, payload  = extract_fields_from_response message
+        if m_id==id && type=='response'
+          callback.call(payload)
+          Nutella.mqtt.unsubscribe( new_channel, mqtt_cb )
         end
-      end)
-      # Send message
-      Net.publish(channel, payload)
+      end
+      # Subscribe
+      Nutella.mqtt.subscribe( new_channel, mqtt_cb )
+      # Publish message
+      Nutella.mqtt.publish( new_channel, m )
     end
 
-    # Handles requests on a certain channel
-    def Net.handle_requests (channel, &handler)
-      Net.subscribe(channel, lambda do |req|
-        # Ignore anything that doesn't have an id (i.e. not requests)
-        id = req["id"]
-        if id.nil?
-          return
-        end
-        # Ignore recently processed requests
-        if @last_requests.nil?
-          @last_requests = Set.new
-        end
-        if @last_requests.include?(id)
-          @last_requests.delete(id)
-          return
-        end
-        @last_requests.add(id)
-        req.delete("id")
-        res = handler.call(req)
+
+
+    # Handle requests
+    def Net.handle_requests( channel, callback)
+      # Pad the channel
+      new_channel = "#{Nutella.run_id}/#{channel}"
+      mqtt_cb = lambda do |request|
         begin
-          res_and_id = attach_message_id(res, id)
-          Net.publish(channel, res_and_id)
+          # Extract nutella fields
+          type, payload, component_id, resource_id = extract_fields_from_message request
+          id = extract_id_from_message request
+          # Only handle requests that have proper id set
+          return if type!='request' || id.nil?
+          m = Net.prepare_message_for_response( callback.call( payload, component_id, resource_id ), id )
+          Nutella.mqtt.publish( new_channel, m )
+          # Assemble the response and check that it's proper JSON
         rescue
-          STDERR.puts 'When handling a request you need to return JSON'
+          return
         end
-      end)
+      end
+      # Subscribe to the channel
+      Nutella.mqtt.subscribe(new_channel, mqtt_cb)
     end
 
 
+    # Listens for incoming messages
     def Net.listen
       begin
         sleep
@@ -178,37 +182,47 @@ module Nutella
 
     private
 
-    def Net.attach_message_id (message, id)
-      if message.is_a?(Hash)
-        message[:id] = id
-        payload = message.to_json
-      elsif message.is_json?
-        p = JSON.parse(message)
-        p[:id] = id
-        payload = p.to_json
-      elsif message.is_a?(String)
-        payload = { :payload => message, :id => id }.to_json
-      else
-        raise 'Your request is not JSON!'
+    def Net.extract_fields_from_message(message)
+      mh = JSON.parse(message)
+      from = mh['from'].split('/')
+      r_id = from.length==1 ? nil : from[1]
+      return mh['type'], mh['payload'], from[0], r_id
+    end
+
+    def Net.extract_id_from_message( message )
+      mh = JSON.parse(message)
+      mh['id']
+    end
+
+    def Net.extract_fields_from_response( message )
+      mh = JSON.parse(message)
+      return mh['type'], mh['payload']
+    end
+
+    def Net.prepare_message_for_publish( message )
+      from = Nutella.resource_id.nil? ? Nutella.component_id : "#{Nutella.component_id}/#{Nutella.resource_id}"
+      if message.nil?
+        return {type: 'publish', from: from}.to_json
       end
-      payload
+      {type: 'publish', from: from, payload: message}.to_json
     end
 
-    def Net.prepare_message_for_publish (message)
-      if message.is_a?(Hash)
-        message[:from] = Nutella.actor_name
-        payload = message.to_json
-      elsif message.is_json?
-        p = JSON.parse(message)
-        p[:from] = Nutella.actor_name
-        payload = p.to_json
-      elsif message.is_a?(String)
-        payload = { :payload => message, :from => Nutella.actor_name }.to_json
-      else
-        raise 'You are trying to publish something that is not JSON!'
+    def Net.prepare_message_for_response( message, id )
+      from = Nutella.resource_id.nil? ? Nutella.component_id : "#{Nutella.component_id}/#{Nutella.resource_id}"
+      if message.nil?
+        return {id: id, type: 'response', from: from}.to_json
+      end
+      {id: id, type: 'response', from: from, payload: message}.to_json
+    end
+
+    def Net.prepare_message_for_request( message )
+      from = Nutella.resource_id.nil? ? Nutella.component_id : "#{Nutella.component_id}/#{Nutella.resource_id}"
+      if message.nil?
+        return {id: message.hash, type: 'request', from: from}.to_json, message.hash
       end
-      payload
+      return {id: message.hash, type: 'request', from: from, payload: message}.to_json, message.hash
     end
 
+
   end
 end

data/lib/simple_mqtt_client/simple_mqtt_client.rb

@@ -0,0 +1,118 @@
+require 'mqtt'
+
+# Simple asynchronous MQTT client
+#  @author Alessandro Gnoli <tebemis@gmail.com>
+class SimpleMQTTClient
+  
+  # Creates a new MQTT client
+  #  @param [String] host the hostname of the MQTT broker we are connecting to
+  #  @param [String] client_id the **unique** client identifier
+  def initialize(host, client_id=nil)
+    @host = host
+    @channels = Hash.new
+    @client = client_id.nil? ? MQTT::Client.connect(:host => host) : MQTT::Client.connect(host: host, client_id: client_id)
+    @thread = Thread.new('mqtt') do
+      @client.get do |channel, message|
+        cbs = get_callbacks channel
+        # If there is no callback (cb=nil) do nothing, otherwise call the right callback:
+        # single channel callback with one parameter, wildcard channel callback with two.
+        unless cbs.nil?
+          (@channels.has_key? channel) ? cbs.each { |cb| cb.call(message) } : cbs.each { |cb| cb.call(message, channel) }
+        end
+      end
+    end
+  end
+
+  # Subscribes to a channel and registers a callback
+  # Single channel callbacks take only one parameter: the received message
+  # Wildcard callbacks take two parameters: the received message and the channel the message was sent to
+  #  @param [String] channel the channel or filter we are subscribing to
+  #  @param [Proc] callback the callback that gets called
+  #  whenever a messages is received
+  def subscribe(channel, callback)
+    if @channels.include?(channel)
+      @channels[channel] << callback
+    else
+      @channels[channel]=[callback]
+      @client.subscribe channel
+    end
+  end
+
+  # Un-subscribes a specific callback from a channel
+  #  @param [String] channel the channel we are un-subscribing from
+  #  @param [Proc] callback the specific callback we want to remove
+  def unsubscribe(channel, callback)
+    if @channels.include? channel
+      @channels[channel].delete(callback)
+    end
+    if @channels[channel].empty?
+      @client.unsubscribe channel
+      @channels.delete(channel)
+    end
+  end
+
+  # Returns the a hash of all the channels this client is currently subscribed to
+  # with relative callbacks
+  #  @return [Hash] the hash of all the channels this client is currently subscribed to and relative callbacks
+  def get_subscribed_channels
+    @channels
+  end
+
+  # Returns true
+  #  @return [Boolean] true if the channel is a wildcard channel. See MQTT specification for wildcard channels
+  # {http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html#_Toc398718106 here}
+  # @param [String] channel the channel we are testing for wildcard
+  def is_channel_wildcard?( channel )
+    channel.include?('#') || channel.include?('+')
+  end
+
+  # Publishes a message to a channel
+  #  @param [String] channel the channel we are publishing to
+  #  @param [String] message the message we are publishing
+  def publish(channel, message)
+    @client.publish(channel, message)
+  end
+
+  # Disconnects this simple MQTT client instance from the broker
+  def disconnect
+    @client.disconnect
+  end
+
+  private
+
+  # Gets the right callback associated to a channel
+  # Specific callback gets precedence over wildcards
+  def get_callbacks(channel)
+    # First try to see if a callback for the exact channel exists
+    return @channels[channel] if @channels.has_key? channel
+    # If it doesn't then let's try to find a wildcard match
+    pattern = wildcard_match channel
+    return @channels[pattern] unless pattern.nil?
+    # If there's no exact match or wildcard we have to return nil
+    nil
+  end
+
+  # Returns the wildcard pattern, among the ones we subscribed to, that matches the channel.
+  # This IGNORES exact matches!!!
+  # It returns nil if the channel doesn't match any of the channels/filers we are subscribed to.
+  def wildcard_match(channel)
+    @channels.keys.each do |pattern|
+      return pattern if matches_generic_pattern(channel, pattern)
+    end
+    # If we go through the whole list of channels and there is no generic pattern then return nil
+    nil
+  end
+
+  # Returns true if the string matches a pattern (including the exact pattern)
+  def matches_generic_pattern(str, pattern)
+    # If multi-level wildcard is the only character in pattern, then any string will match
+    return true if pattern=='#'
+    # Handle all other multi-level wildcards
+    p_wo_wildcard = pattern[0..-2]
+    str_wo_details = str[0..pattern.length-2]
+    return true if pattern[-1, 1]=='#' && p_wo_wildcard==str_wo_details
+    # TODO Handle single-level wildcards (+)
+    false
+  end
+  
+end

data/nutella_lib.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: nutella_lib 0.2.2 ruby lib
+# stub: nutella_lib 0.3.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "nutella_lib"
-  s.version = "0.2.2"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
   s.authors = ["Alessandro Gnoli"]
-  s.date = "2014-11-17"
+  s.date = "2015-02-17"
   s.description = "Implements the nutella protocol and exposes it natively to ruby developers"
   s.email = "tebemis@gmail.com"
   s.extra_rdoc_files = [
@@ -32,9 +32,11 @@ Gem::Specification.new do |s|
     "lib/nutella_lib/net.rb",
     "lib/nutella_lib/noext.rb",
     "lib/nutella_lib/persist.rb",
+    "lib/simple_mqtt_client/simple_mqtt_client.rb",
     "nutella_lib.gemspec",
     "test/helper.rb",
-    "test/test_nutella_lib.rb"
+    "test/test_nutella_lib.rb",
+    "test/test_simple_mqtt_client.rb"
   ]
   s.homepage = "https://github.com/nutella-framework/nutella_lib.rb"
   s.licenses = ["MIT"]
@@ -45,7 +47,7 @@ Gem::Specification.new do |s|
     s.specification_version = 4
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<simple_ruby_mqtt_client>, [">= 0.3.1", "~> 0.3.1"])
+      s.add_runtime_dependency(%q<mqtt>, [">= 0.3", "~> 0.3"])
       s.add_development_dependency(%q<shoulda>, [">= 3", "~> 3"])
       s.add_development_dependency(%q<minitest>, [">= 5", "~> 5.4"])
       s.add_development_dependency(%q<yard>, [">= 0.8.7", "~> 0.8"])
@@ -54,7 +56,7 @@ Gem::Specification.new do |s|
       s.add_development_dependency(%q<jeweler>, [">= 2.0.1", "~> 2.0.1"])
       s.add_development_dependency(%q<simplecov>, [">= 0", "~> 0"])
     else
-      s.add_dependency(%q<simple_ruby_mqtt_client>, [">= 0.3.1", "~> 0.3.1"])
+      s.add_dependency(%q<mqtt>, [">= 0.3", "~> 0.3"])
       s.add_dependency(%q<shoulda>, [">= 3", "~> 3"])
       s.add_dependency(%q<minitest>, [">= 5", "~> 5.4"])
       s.add_dependency(%q<yard>, [">= 0.8.7", "~> 0.8"])
@@ -64,7 +66,7 @@ Gem::Specification.new do |s|
       s.add_dependency(%q<simplecov>, [">= 0", "~> 0"])
     end
   else
-    s.add_dependency(%q<simple_ruby_mqtt_client>, [">= 0.3.1", "~> 0.3.1"])
+    s.add_dependency(%q<mqtt>, [">= 0.3", "~> 0.3"])
     s.add_dependency(%q<shoulda>, [">= 3", "~> 3"])
     s.add_dependency(%q<minitest>, [">= 5", "~> 5.4"])
     s.add_dependency(%q<yard>, [">= 0.8.7", "~> 0.8"])

data/test/test_nutella_lib.rb

@@ -2,21 +2,77 @@ require 'helper'
 
 class TestNutellaLib < MiniTest::Test
 
-  # def test_that_kernel_extension_works
-  #   assert_instance_of Nutella::Core, nutella
+
+  # def test_connect_and_send_receive_messages_correctly
+  #   cb_executed = false
+  #   nutella.init('my_run_id', 'ltg.evl.uic.edu', 'my_bot_component')
+  #   nutella.set_resource_id 'my_resource_id'
+  #   cb = lambda do |message, component_id, resource_id|
+  #     cb_executed = true
+  #     puts "Received message from #{component_id}/#{resource_id}. Message: #{message}"
+  #   end
+  #   nutella.net.subscribe('demo1', cb)
+  #   sleep 1
+  #   nutella.net.publish('demo1', 'test_message')
+  #   # Make sure we wait for the message to be delivered
+  #   sleep 1
+  #   assert cb_executed
+  # end
+  #
+  #
+  # def test_connect_and_send_receive_wildcard_messages_correctly
+  #   cb_executed = false
+  #   nutella.init('my_run_id', 'ltg.evl.uic.edu', 'my_bot_component')
+  #   nutella.set_resource_id 'my_resource_id'
+  #   cb = lambda do |message, channel, component_id, resource_id|
+  #     cb_executed = true
+  #     puts "Received message on #{channel} from #{component_id}/#{resource_id}. Message: #{message}"
+  #   end
+  #   nutella.net.subscribe('demo1/#', cb)
+  #   sleep 1
+  #   nutella.net.publish('demo1/demo', 'test_message')
+  #   # Make sure we wait for the message to be delivered
+  #   sleep 1
+  #   assert cb_executed
   # end
 
-  # def test_core_module_method_call
-  #   nutella.hello "Ruby"
+
+  # def test_multiple_subscriptions
+  #   nutella.init('my_run_id', 'ltg.evl.uic.edu', 'my_bot_component')
+  #   nutella.set_resource_id 'my_resource_id'
+  #   cb = lambda do |message, component_id, resource_id|
+  #     puts "Received message #{component_id}/#{resource_id}. Message: #{message}"
+  #   end
+  #   nutella.net.subscribe('demo1', cb)
+  #   nutella.net.subscribe('demo1', cb) # This must raise an error
   # end
 
 
-  # tests for sync/asynch_Req
-  # v = nutella.net.sync_req("quakes_schedule", '{"stringa":"json"}')
-  # v = nutella.net.sync_req("quakes_schedule", "messaggio")
-  # v = nutella.net.sync_req("quakes_schedule", {})
-  # v = nutella.net.sync_req("quakes_schedule", {:cane => "dio"})
-  # v = nutella.net.sync_req("quakes_schedule")
+  # def test_request_response
+  #   nutella.init('my_run_id', 'ltg.evl.uic.edu', 'my_bot_component')
+  #   nutella.set_resource_id 'my_resource_id'
+  #
+  #   nutella.net.subscribe('demo1', lambda do |message, component_id, resource_id|
+  #     puts "Received a message from #{component_id}/#{resource_id}. Message: #{message}"
+  #   end)
+  #
+  #   nutella.net.handle_requests( 'demo1', lambda do |message, component_id, resource_id|
+  #     puts "We received a request: message #{message}, from #{component_id}/#{resource_id}"
+  #     #Then we are going to return some JSON
+  #     {my:'json'}
+  #   end)
+  #
+  #   response = nutella.net.sync_req( 'demo1', 'my request is a string' )
+  #   puts 'Response to sync'
+  #   p response
+  #
+  #   nutella.net.async_req( 'demo1', 'my request is a string', lambda do |response|
+  #     puts 'Response to async'
+  #     p response
+  #   end)
+  #
+  #   nutella.net.listen
+  # end
 
 
 end

data/test/test_simple_mqtt_client.rb

@@ -0,0 +1,55 @@
+require 'helper'
+
+class TestSimpleRubyMqttClient < MiniTest::Test
+
+  # def test_connect_and_send_receive_messages_correctly
+  #   cb_executed = false
+  #   sc1 = SimpleMQTTClient.new 'ltg.evl.uic.edu'
+  #   cb1 = lambda do |message|
+  #     cb_executed = true
+  #     assert_equal 'test-message-1', message
+  #     sc1.unsubscribe 'demo1', cb1
+  #   end
+  #   sc1.subscribe('demo1', cb1)
+  #
+  #   sc2 = SimpleMQTTClient.new 'ltg.evl.uic.edu'
+  #   sc2.publish('demo1', 'test-message-1')
+  #   # Make sure we wait for the message to be delivered
+  #   sleep(1)
+  #   assert cb_executed
+  # end
+  #
+  # def test_list_current_subscriptions_correctly
+  #   sc3 = SimpleMQTTClient.new 'ltg.evl.uic.edu'
+  #   cb2 = lambda {|message| puts message}
+  #   cb3 = lambda {|message| puts message}
+  #   sc3.subscribe( 'channel_1', cb2 )
+  #   sc3.subscribe( 'channel_2', cb2 )
+  #   sc3.subscribe( 'channel_3', cb2 )
+  #   sc3.subscribe( 'channel_3', cb3 )
+  #   assert_equal sc3.get_subscribed_channels['channel_3'].length, 2
+  #   sc3.unsubscribe( 'channel_3', cb2 )
+  #   assert_equal sc3.get_subscribed_channels['channel_3'].length, 1
+  # end
+  #
+  # def test_recognize_wildcard_patters_correctly
+  #   sc4 = SimpleMQTTClient.new 'ltg.evl.uic.edu'
+  #   sc4.subscribe('run_id/#', lambda {|m| puts m})
+  #   refute_nil sc4.send(:get_callbacks, 'run_id/one')
+  #   refute_nil sc4.send(:get_callbacks, 'run_id/one/two')
+  # end
+  #
+  #  def test_multiple_subscriptions
+  #   sc5 = SimpleMQTTClient.new 'ltg.evl.uic.edu'
+  #   total = 0
+  #   cb1 = lambda { |message| total += 3; puts "CB1: #{message}"}
+  #   cb2 = lambda { |message| total += 1; puts "CB2: #{message}"}
+  #   sc5.subscribe('demo2', cb1)
+  #   sc5.subscribe('demo2', cb2)
+  #   sc6 = SimpleMQTTClient.new 'ltg.evl.uic.edu'
+  #   sc6.publish('demo2', 'test-message-2')
+  #   # Make sure we wait for the message to be delivered
+  #   sleep(1)
+  #   assert_equal total, 4
+  # end
+end

metadata

@@ -1,35 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: nutella_lib
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Alessandro Gnoli
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-17 00:00:00.000000000 Z
+date: 2015-02-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: simple_ruby_mqtt_client
+  name: mqtt
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.1
+        version: '0.3'
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.1
+        version: '0.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.1
+        version: '0.3'
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.1
+        version: '0.3'
 - !ruby/object:Gem::Dependency
   name: shoulda
   requirement: !ruby/object:Gem::Requirement
@@ -191,9 +191,11 @@ files:
 - lib/nutella_lib/net.rb
 - lib/nutella_lib/noext.rb
 - lib/nutella_lib/persist.rb
+- lib/simple_mqtt_client/simple_mqtt_client.rb
 - nutella_lib.gemspec
 - test/helper.rb
 - test/test_nutella_lib.rb
+- test/test_simple_mqtt_client.rb
 homepage: https://github.com/nutella-framework/nutella_lib.rb
 licenses:
 - MIT