nutella_lib 0.3.1 → 0.4.0

data/lib/nutella_lib/net_app.rb

@@ -0,0 +1,271 @@
+module Nutella
+  module Net
+
+    # This module implements the pub/sub and request/response APIs at the application level
+    module App
+
+
+      # @!group Application-level communication APIs
+
+      # Subscribes to a channel or to a set of channels at the application-level.
+      #
+      # @param [String] channel the application-level channel or filter we are subscribing to. Can contain wildcard(s)
+      # @param [Proc] callback a lambda expression that is fired whenever a message is received.
+      #   The passed callback takes the following parameters:
+      #   - [String] message: the received message. Messages that are not JSON are discarded.
+      #   - [String] channel: the application-level channel the message was received on (optional, only for wildcard subscriptions)
+      #   - [Hash] from: the sender's identifiers (run_id, app_id, component_id and optionally resource_id)
+      def App.subscribe (channel, callback)
+        Nutella::Net.subscribe_to(channel, callback, Nutella.app_id, nil)
+      end
+
+
+      # Un-subscribes from an application-level channel
+      #
+      # @param [String] channel the application level channel we want to unsubscribe from. Can contain wildcard(s).
+      def App.unsubscribe( channel )
+        Nutella::Net.unsubscribe_to(channel, Nutella.app_id, nil)
+      end
+
+
+      # Publishes a message to an application-level channel
+      #
+      # @param [String] channel the application-level channel we want to publish the message to. *CANNOT* contain wildcard(s)!
+      # @param [Object] message the message we are publishing. This can be,
+      #   nil/empty (default), a string, a hash and, in general, anything with a .to_json method.
+      def App.publish(channel, message=nil)
+        Nutella::Net.publish_to(channel, message, Nutella.app_id, nil)
+      end
+
+
+      # Performs a synchronous request at the application-level
+      #
+      # @param [String] channel the application-level channel we want to make the request to. *CANNOT* contain wildcard(s)!
+      # @param [Object] message the body of request. This can be,
+      #   nil/empty (default), a string, a hash and, in general, anything with a .to_json method.
+      def App.sync_request ( channel, message=nil )
+        Nutella::Net.sync_request_to(channel, message, Nutella.app_id, nil)
+      end
+
+
+      # Performs an asynchronous request at the application-level
+      #
+      # @param [String] channel the application-level channel we want to make the request to. *CANNOT* contain wildcard(s)!
+      # @param [Object] message the body of request. This can be,
+      #   nil/empty (default), a string, a hash and, in general, anything with a .to_json method.
+      # @param [Proc] callback the callback that is fired whenever a response is received. It takes one parameter (response).
+      def App.async_request ( channel, message=nil, callback )
+        Nutella::Net.async_request_to(channel, message, callback, Nutella.app_id, nil)
+      end
+
+
+      # Handles requests on a certain application-level channel
+      #
+      # @param [String] channel tha application-level channel we want to listen for requests on. Can contain wildcard(s).
+      # @param [Proc] callback a lambda expression that is fired whenever a message is received.
+      #   The passed callback takes the following parameters:
+      #   - [String] the received message (payload). Messages that are not JSON are discarded.
+      #   - [Hash] the sender's identifiers (run_id, app_id, component_id and optionally resource_id)
+      #   - [*returns* Hash] The response sent back to the client that performed the request. Whatever is returned by the callback is marshaled into a JSON string and sent via MQTT.
+      def App.handle_requests( channel, callback )
+        Nutella::Net.handle_requests_on(channel, callback, Nutella.app_id, nil)
+      end
+
+      # @!endgroup
+
+
+      # @!group Application-level APIs to communicate at the run-level
+
+      # Allows application-level APIs to subscribe to a run-level channel within a specific run
+      #
+      # @param [String] run_id the specific run we are subscribing to
+      # @param [String] channel the run-level channel we are subscribing to. Can be wildcard.
+      # @param [Proc] callback the callback that is fired whenever a message is received on the channel.
+      #   The passed callback takes the following parameters:
+      #   - [String] message: the received message. Messages that are not JSON are discarded.
+      #   - [String] channel: the application-level channel the message was received on (optional, only for wildcard subscriptions)
+      #   - [Hash] from: the sender's identifiers (run_id, app_id, component_id and optionally resource_id)
+      def App.subscribe_to_run( run_id, channel, callback )
+        Nutella::Net.subscribe_to(channel, callback, Nutella.app_id, run_id)
+      end
+
+
+      # Allows application-level APIs to unsubscribe from a run-level channel within a specific run
+      #
+      # @param [String] run_id the specific run we are un-subscribing from
+      # @param [String] channel the run-level channel we want to unsubscribe from. Can contain wildcard(s).
+      def App.unsubscribe_to_run( run_id, channel )
+        Nutella::Net.unsubscribe_to(channel, Nutella.app_id, run_id)
+      end
+
+
+      # Allows application-level APIs to publish to a run-level channel within a specific run
+      #
+      # @param [String] run_id the specific run we are publishing to
+      # @param [String] channel the run-level channel we want to publish the message to. *CANNOT* contain wildcard(s)!
+      # @param [String] message the message we are publishing. This can be,
+      #   nil/empty (default), a string, a hash and, in general, anything with a .to_json method.
+      def App.publish_to_run( run_id, channel, message )
+        Nutella::Net.publish_to(channel, message, Nutella.app_id, run_id)
+      end
+
+
+      # Allows application-level APIs to make a synchronous request to a run-level channel within a specific run
+      #
+      # @param [String] run_id the specific run we are making the request to
+      # @param [String] channel the channel we want to make the request to. *CANNOT* contain wildcard(s)!
+      # @param [Object] request the body of request. This can be,
+      #   nil/empty (default), a string, a hash and, in general, anything with a .to_json method.
+      def App.sync_request_to_run( run_id, channel, request)
+        Nutella::Net.sync_request_to(channel, request, Nutella.app_id, run_id)
+      end
+
+
+      # Allows application-level APIs to make an asynchronous request to a run-level channel within a specific run
+      #
+      # @param [String] run_id the specific run we are making the request to
+      # @param [String] channel the channel we want to make the request to. *CANNOT* contain wildcard(s)!
+      # @param [Object] request the body of request. This can be,
+      #   nil/empty (default), a string, a hash and, in general, anything with a .to_json method.
+      # @param [Proc] callback the callback that is fired whenever a response is received. It takes one parameter (response).
+      def App.async_request_to_run( run_id, channel, request, callback)
+        Nutella::Net.async_request_to(channel, request, callback, Nutella.app_id, run_id)
+      end
+
+
+      # Allows application-level APIs to handle requests on a run-level channel within a specific run
+      #
+      # @param [String] run_id the specific run requests are coming from
+      # @param [String] channel we want to listen for requests on. Can contain wildcard(s).
+      # @param [Proc] callback a lambda expression that is fired whenever a message is received.
+      #   The passed callback takes the following parameters:
+      #   - [String] the received message (payload). Messages that are not JSON are discarded.
+      #   - [Hash] the sender's identifiers (run_id, app_id, component_id and optionally resource_id)
+      #   - [*returns* Hash] The response sent back to the client that performed the request. Whatever is returned by the callback is marshaled into a JSON string and sent via MQTT.
+      def App.handle_requests_on_run( run_id, channel, callback )
+        Nutella::Net.handle_requests_on(channel, callback, Nutella.app_id, run_id)
+      end
+
+      # @!endgroup
+
+
+      # @!group Application level APIs to communicate at the run-level (broadcast)
+
+      # Allows application-level APIs to subscribe to a run-level channel *for ALL runs*
+      #
+      # @param [String] channel the run-level channel we are subscribing to. Can be wildcard.
+      # @param [Proc] callback the callback that is fired whenever a message is received on the channel.
+      #   The passed callback takes the following parameters:
+      #   - [String] message: the received message. Messages that are not JSON are discarded.
+      #   - [String] run_id: the run_id of the channel the message was sent on
+      #   - [Hash] from: the sender's identifiers (run_id, app_id, component_id and optionally resource_id)
+      def App.subscribe_to_all_runs( channel, callback )
+        # Check the passed callback has the right number of arguments
+        raise 'You need to pass a callback with 3 parameters (payload, run_id, from) when subscribing to all runs!' if callback.parameters.length!=3
+        # Pad channel
+        padded_channel = Nutella::Net.pad_channel(channel, Nutella.app_id, '+')
+        mqtt_cb = lambda do |mqtt_message, mqtt_channel|
+          begin
+            type, from, payload, _ = Nutella::Net.extract_fields_from_message mqtt_message
+            run_id = extract_run_id_from_ch(Nutella.app_id, mqtt_channel)
+            callback.call(payload, run_id, from) if type=='publish'
+          rescue JSON::ParserError
+            # Make sure the message is JSON, if not drop the message
+            return
+          rescue
+            # Check the passed callback has the right number of arguments
+            STDERR.puts "The callback you passed to subscribe has the #{$!}: it needs 'payload', 'run_id' and 'from'"
+          end
+        end
+        # Add to subscriptions, save mqtt callback and subscribe
+        Nutella::Net.subscriptions.push padded_channel
+        Nutella::Net.callbacks.push mqtt_cb
+        Nutella.mqtt.subscribe( padded_channel, mqtt_cb )
+      end
+
+
+      # Allows application-level APIs to unsubscribe from a run-level channel *for ALL runs*
+      #
+      # @param [String] channel the run-level channel we want to unsubscribe from. Can contain wildcard(s).
+      def App.unsubscribe_from_all_runs( channel )
+        Nutella::Net.unsubscribe_to(channel, Nutella.app_id, '+')
+      end
+
+
+      # Allows application-level APIs to publish a message to a run-level channel *for ALL runs*
+      #
+      # @param [String] channel the run-level channel we want to publish the message to. *CANNOT* contain wildcard(s)!
+      # @param [Object] message the message we are publishing. This can be,
+      #   nil/empty (default), a string, a hash and, in general, anything with a .to_json method.
+      def App.publish_to_all_runs( channel, message )
+        Nutella.app_runs_list.each do |run_id|
+          Nutella::Net.publish_to(channel, message, Nutella.app_id, run_id)
+        end
+      end
+
+
+      # Allows application-level APIs to send a request to a run-level channel *for ALL runs*
+      #
+      # @param [String] channel the run-level channel we want to make the request to. *CANNOT* contain wildcard(s)!
+      # @param [Object] request the body of request. This can be,
+      #   nil/empty (default), a string, a hash and, in general, anything with a .to_json method.
+      # @param [Proc] callback the callback that is fired whenever a response is received. It takes one parameter (response).
+      def App.async_request_to_all_runs(channel, request, callback)
+        Nutella.app_runs_list.each do |run_id|
+          Nutella::Net.async_request_to(channel, request, callback, Nutella.app_id, run_id)
+        end
+      end
+
+
+      # Allows application-level APIs to handle requests to a run-level channel *for ALL runs*
+      #
+      # @param [String] channel tha run-level channel we want to listen for requests on. Can contain wildcard(s).
+      # @param [Proc] callback a lambda expression that is fired whenever a message is received.
+      #   The passed callback takes the following parameters:
+      #   - [String] the received message (request). Messages that are not JSON are discarded.
+      #   - [String] run_id: the run_id of the channel the message was sent on
+      #   - [Hash] the sender's identifiers (from containing, run_id, app_id, component_id and optionally resource_id)
+      #   - [*returns* Hash] The response sent back to the client that performed the request. Whatever is returned by the callback is marshaled into a JSON string and sent via MQTT.
+      def App.handle_requests_on_all_runs(channel, callback)
+        # Check the passed callback has the right number of arguments
+        raise 'You need to pass a callback with 3 parameters (request, run_id, from) when handling requests!' if callback.parameters.length!=3
+        # Pad channel
+        padded_channel = Nutella::Net.pad_channel(channel, Nutella.app_id, '+')
+        mqtt_cb = lambda do |request, mqtt_channel|
+          begin
+            # Extract nutella fields
+            type, from, payload, id = Nutella::Net.extract_fields_from_message request
+            run_id = extract_run_id_from_ch(Nutella.app_id, mqtt_channel)
+            # Only handle requests that have proper id set
+            return if type!='request' || id.nil?
+            # Execute callback and send response
+            m = Net.prepare_message_for_response( callback.call( payload, run_id, from), id )
+            Nutella.mqtt.publish( mqtt_channel, m )
+          rescue JSON::ParserError
+            # Make sure that request contains JSON, if not drop the message
+            return
+          rescue
+            # Check the passed callback has the right number of arguments
+            STDERR.puts "The callback you passed to subscribe has the #{$!}: it needs 'request', 'run_id' and 'from'"
+          end
+        end
+        # Subscribe to the channel
+        Nutella.mqtt.subscribe( padded_channel, mqtt_cb )
+      end
+
+
+      # @!endgroup
+
+
+      private
+
+      def App.extract_run_id_from_ch( app_id, mqtt_channel )
+        head = "/nutella/apps/#{app_id}/runs/"
+        mqtt_channel.gsub(head, '').split('/')[0]
+      end
+
+
+    end
+
+  end
+end

data/lib/nutella_lib/persist.rb

@@ -1,9 +1,11 @@
 require 'json'
 require 'pstore'
 require 'fileutils'
+require 'thread'
 
 module Nutella
 
+  # Implements basic run-dependent persistence for nutella bots.
   module Persist
 
     # This module exposes a single method to retrieve a JSONStore
@@ -32,6 +34,11 @@ module Nutella
 
   class JSONStore < PStore
 
+    def initialize(path)
+      super
+      @semaphore = Mutex.new
+    end
+
     def dump(table)
       table.to_json
     end
@@ -40,6 +47,13 @@ module Nutella
       JSON.parse(content)
     end
 
+    def transaction(read_only=false, &block)
+      @semaphore.synchronize {
+        # access shared resource
+        super
+      }
+    end
+
     # Dumps the whole store to hash
     # example:
     # store = JSONStore.new("my_file.json")
@@ -68,6 +82,4 @@ module Nutella
   end
 
 
-end
-
-
+end

data/lib/nutella_lib.rb

@@ -1,5 +1,6 @@
 require 'nutella_lib/core'
 require 'nutella_lib/net'
+require 'nutella_lib/net_app'
 require 'nutella_lib/persist'
 require 'simple_mqtt_client/simple_mqtt_client'
 
@@ -12,15 +13,3 @@ require 'set'
 unless defined?(Nutella::NO_EXT)
   require 'nutella_lib/ext/kernel'
 end
-
-# Adding a convenience method to the string class
-# to test if it contains properly formatted JSON
-class String
-  def is_json?
-    begin
-      !!JSON.parse(self)
-    rescue
-      false
-    end
-  end
-end

data/lib/simple_mqtt_client/simple_mqtt_client.rb

@@ -1,35 +1,45 @@
 require 'mqtt'
 
-# Simple asynchronous MQTT client
-#  @author Alessandro Gnoli <tebemis@gmail.com>
+# A simple MQTT client
 class SimpleMQTTClient
-  
+
+  ## Private instance variables
+  # `@channels` is a hash that associates to each channels a set of callbacks
+  # `@client` low-level mqtt client
+  # `@thread` the packet reader thread
+
+
   # 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
+  def initialize( host, client_id=nil )
     @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|
+        # Execute all the appropriate callbacks:
+        # the ones specific to this channel with a single parameter (message)
+        # the ones associated to a wildcard channel, with two parameters (message and channel)
         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) }
+        begin
+          cbs.each { |cb| cb.parameters.length==1 ? cb.call(message) : cb.call(message, channel) }
+        rescue ArgumentError
+          STDERR.puts "The callback you passed for #{channel} has the #{$!}"
         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
+  # 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.
+  # It is possible to register multiple callbacks per channel. All of them will be executed whenever a message
+  # on that channel is received.
+  # Note that overlaps between channel-specific callbacks and wildcard-filters are allowed.
   #  @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)
+  def subscribe( channel, callback )
     if @channels.include?(channel)
       @channels[channel] << callback
     else
@@ -41,7 +51,7 @@ class SimpleMQTTClient
   # 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)
+  def unsubscribe( channel, callback )
     if @channels.include? channel
       @channels[channel].delete(callback)
     end
@@ -51,14 +61,29 @@ class SimpleMQTTClient
     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
+  # 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 )
+    # Check we are not publishing to a wildcard channel
+    STDERR.puts 'Can\'t publish to a wildcard channel!' if is_channel_wildcard? channel
+    @client.publish(channel, message)
+  end
+
+  # Disconnects this simple MQTT client instance from the broker
+  def disconnect
+    @thread.exit
+    @client.disconnect
+    @channels.clear
+  end
+
+  # Returns a hash of all the channels this client is currently subscribed to with relative callbacks
+  #  @return [Hash] all channels this client is currently subscribed to, and relative callbacks
   def get_subscribed_channels
     @channels
   end
 
-  # Returns true
+  # Returns true if a channel is a wildcard channel
   #  @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
@@ -66,53 +91,48 @@ class SimpleMQTTClient
     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
+  private
 
-  # Disconnects this simple MQTT client instance from the broker
-  def disconnect
-    @client.disconnect
+  # Gets all the callbacks associated to a channel
+  def get_callbacks( channel )
+    cbs = Array.new
+    # First, fetch all the channel-specific callbacks...
+    cbs.concat @channels[channel] if @channels.has_key? channel
+    # ...then fetch the callbacks matching all wildcard-filters
+    cbs.concat wildcard_callbacks channel
+    cbs
   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
+  # Gets all wildcard callbacks associated to a channel
+  # Among the filters we are subscribed to, which ones match the channel?
+  def wildcard_callbacks( channel )
+    # First select all filters
+    filters = @channels.keys.select { |ch| is_channel_wildcard? ch}
+    # Then select filters that match channel
+    matching_filters = filters.select { |filter| matches_wildcard_pattern(channel, filter) }
+    # Add all callbacks that are associated to matching filters
+    cbs = Array.new
+    matching_filters.each { |ch| cbs.concat @channels[ch] }
+    cbs
   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
+  # Returns true if the string matches a pattern
+  # See http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html#_Toc398718107
+  # for a formal description of the rules
+  def matches_wildcard_pattern(str, pattern)
+    # First we need to build a regex out of the pattern
+    regex = build_regex_from_pattern pattern
+    # Then we check if the regex matches the string
+    !!(regex =~ str)
   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
+  # Escape '/'
+  # Substitute '+' for '[^"\/"]+' (a string of one or more characters that is are not '/')
+  # Substitute '/#' with '.*' (a string of zero or more characters)
+  # Substitute '#' for '.*' (a string of zero or more characters)
+  def build_regex_from_pattern( pattern )
+    regex_str = pattern.gsub('/','\\/').gsub('+','[^"\/"]+').gsub('\/#','.*').gsub('#','.*')
+    Regexp.new regex_str
   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.3.1 ruby lib
+# stub: nutella_lib 0.4.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "nutella_lib"
-  s.version = "0.3.1"
+  s.version = "0.4.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 = "2015-02-17"
+  s.date = "2015-03-13"
   s.description = "Implements the nutella protocol and exposes it natively to ruby developers"
   s.email = "tebemis@gmail.com"
   s.extra_rdoc_files = [
@@ -30,17 +30,19 @@ Gem::Specification.new do |s|
     "lib/nutella_lib/core.rb",
     "lib/nutella_lib/ext/kernel.rb",
     "lib/nutella_lib/net.rb",
+    "lib/nutella_lib/net_app.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_net.rb",
+    "test/test_nutella_net_app.rb",
     "test/test_simple_mqtt_client.rb"
   ]
   s.homepage = "https://github.com/nutella-framework/nutella_lib.rb"
   s.licenses = ["MIT"]
-  s.rubygems_version = "2.2.2"
+  s.rubygems_version = "2.4.3"
   s.summary = "nutella protocol library for ruby"
 
   if s.respond_to? :specification_version then

data/test/test_nutella_net.rb

@@ -0,0 +1,79 @@
+require 'helper'
+
+class TestNutellaNet < MiniTest::Test
+
+
+  # def test_send_receive
+  #   nutella.init('localhost', 'my_app_id', 'my_run_id' , 'my_component_id')
+  #   cb_executed = false
+  #   cb = lambda do |message, from|
+  #     cb_executed = true
+  #     puts "Received message from #{from['component_id']}/#{from['resource_id']}. Message: #{message}"
+  #   end
+  #   nutella.net.subscribe('demo0', cb)
+  #   sleep 1
+  #   nutella.net.publish('demo0', 'test_message')
+  #   # Make sure we wait for the message to be delivered
+  #   sleep 1
+  #   assert cb_executed
+  # end
+  #
+  #
+  # def test_send_receive_wildcard
+  #   cb_executed = false
+  #   nutella.init('localhost', 'my_app_id', 'my_run_id' , 'my_component_id')
+  #   nutella.set_resource_id 'my_resource_id_1'
+  #   cb = lambda do |message, channel, from|
+  #     cb_executed = true
+  #     puts "Received message on #{channel} from #{from['component_id']}/#{from['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_multiple_subscriptions
+  #   nutella.init('localhost', 'my_app_id', 'my_run_id' , 'my_component_id')
+  #   nutella.set_resource_id 'my_resource_id_2'
+  #   cb = lambda do |message, from|
+  #     puts "Received message #{from['component_id']}/#{from['resource_id']}. Message: #{message}"
+  #   end
+  #   assert_raises RuntimeError do
+  #     nutella.net.subscribe('demo2', cb)
+  #     nutella.net.subscribe('demo2', cb)
+  #   end
+  #   nutella.net.unsubscribe('demo2')
+  #   nutella.net.subscribe('demo2', cb)
+  # end
+  #
+  #
+  # def test_request_response
+  #   nutella.init('localhost', 'my_app_id', 'my_run_id' , 'my_component_id')
+  #   nutella.set_resource_id 'my_resource_id_3'
+  #
+  #   nutella.net.subscribe('demo3', lambda do |message, from|
+  #     puts "Received a message from #{from['component_id']}/#{from['resource_id']}. Message: #{message}"
+  #   end)
+  #
+  #   nutella.net.handle_requests( 'demo3', lambda do |message, from|
+  #     puts "We received a request: message #{message}, from #{from['component_id']}/#{from['resource_id']}."
+  #     #Then we are going to return some random JSON
+  #     {my:'json'}
+  #   end)
+  #
+  #   response = nutella.net.sync_request( 'demo3', 'my request is a string' )
+  #   assert_equal({'my' => 'json'}, response)
+  #
+  #   nutella.net.async_request( 'demo3', 'my request is a string', lambda do |response|
+  #     assert_equal({'my' => 'json'}, response)
+  #   end)
+  #
+  #   sleep(2)
+  # end
+
+
+end