nutella_lib 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 809635436c6083ffcc66ee67660196d6fedd0161
-  data.tar.gz: fc2d5da13567805306c78c295da4642c09b2b168
+  metadata.gz: 6803b3cb787519bd1f861c931211696fa0b35afb
+  data.tar.gz: 20537f9462a2a9bdbacb51c2d24d801788b29ed1
 SHA512:
-  metadata.gz: 637ca3db4ef68539e09bfe8a4889c23f4d56bcb3a70a81ab9fe1be719c5b7810ec2ed6fee6dae1f8918840b373e4757dc0c0920b4acdce964fc818a4e8656a99
-  data.tar.gz: ce91068690716748971db0a22f8874da88641d1f5b2b2b40a8951f6033679fe63b45418a71e16fdc004c95e940e1b53445e35afcdd118ffd3329ee1e43aa5c27
+  metadata.gz: 83cbd543626b9031e998e4cbf1bd4c0e94af45d0d09e4c689d8c2d1a1d34cb80a4c60ff6079c6cfcef73b420daf579dd6f9b09366629beeb064c91bf393a6371
+  data.tar.gz: 086aed862b969022d4cfec48defbe19eacb3e7f949ff4c21da2e0c5d44a9bd81d69e496956ed54af0200acc2e057f80e335782a76ef77cab1cb29e3711b54d41

data/VERSION

@@ -1 +1 @@
-0.3.1
+0.4.0

data/lib/nutella_lib/core.rb

@@ -2,11 +2,12 @@
 module Nutella
 
 
-  # Initializes the nutella library
+  # Initializes this component as a run component
   # @param [String] run_id
   # @param [String] broker_hostname
   # @param [String] component_id
-  def self.init(run_id, broker_hostname, component_id)
+  def self.init( broker_hostname, app_id, run_id, component_id )
+    @app_id = app_id
     @run_id = run_id
     @component_id = component_id
     @resource_id = nil
@@ -14,33 +15,84 @@ module Nutella
   end
 
 
-  # Accessors for module instance variables
+  # Initializes this component as an application component
+  # @param [String] broker_hostname
+  # @param [String] component_id
+  def self.init_as_app_component( broker_hostname, app_id, component_id )
+    @app_id = app_id
+    @run_id = nil
+    @component_id = component_id
+    @resource_id = nil
+    @mqtt = SimpleMQTTClient.new broker_hostname
+    # Fetch the `run_id`s list for this application and subscribe to its updates
+    @app_runs_list = net.app.sync_request('app_runs_list')
+    net.app.subscribe('app_runs_list', lambda {|message, _| @app_runs_list = message })
+  end
+
+
+  # Accessors for app_id
+  def self.app_id; @app_id end
+
+  # Accessors for run_id
   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
 
+  # Accessors for mqtt client
+  def self.mqtt;
+    raise 'Nutella has not been initialized: you need to call the proper init method before you can start using nutella' if @mqtt.nil?
+    @mqtt
+  end
 
+  # Accessors for component_id
+  def self.component_id;
+    raise 'Nutella has not been initialized: you need to call the proper init method before you can start using nutella' if @component_id.nil?
+    @component_id
+  end
+
+  # Accessors for resource_id
+  def self.resource_id; @resource_id end
 
-  # Nutella library modules loading
+  # Accessor for runs list
+  def self.app_runs_list; @app_runs_list end
+
+  # Accessor for the net module
   def self.net; Nutella::Net end
+
+  # Accessor for the persist module
   def self.persist; Nutella::Persist end
 
 
   # Utility functions
 
 
-  # Parse command line arguments
-  def self.parse_args(args)
+  # Parse command line arguments for run level components
+  #
+  # @param [Array] args command line arguments array
+  # @return [String, String, String] broker, app_id and run_id
+  def self.parse_run_component_args(args)
+    if args.length < 3
+      STDERR.puts 'Couldn\'t read broker address, app_id and run_id from the command line, impossible to initialize component!'
+      return
+    end
+    return args[0], args[1], args[2]
+  end
+
+
+  # Parse command line arguments for app level components
+  #
+  # @param [Array] args command line arguments array
+  # @return [String, String] broker and app_id
+  def self.parse_app_component_args(args)
     if args.length < 2
-      STDERR.puts "Couldn't read run_id and broker address from the command line, impossible to initialize library!"
+      STDERR.puts 'Couldn\'t read broker address and app_id from the command line, impossible to initialize component!'
       return
     end
     return args[0], args[1]
   end
 
 
-  # Extracts the actor name based on the the folder where we are executing
+  # Extracts the component name from the folder where the code for this component is located
+  #
+  # @return [String] the component name
   def self.extract_component_id
     path = Dir.pwd
     path[path.rindex('/')+1..path.length-1]
@@ -48,6 +100,8 @@ module Nutella
 
 
   # Sets the resource id
+  #
+  # @param [String] resource_id the resource id (i.e. the particular instance of this component)
   def self.set_resource_id( resource_id )
     @resource_id = resource_id
   end

data/lib/nutella_lib/ext/kernel.rb

@@ -1,3 +1,4 @@
+# Extension to kernel module so we can use nutella as nutella.blah.blah
 module Kernel
 
   def nutella

data/lib/nutella_lib/net.rb

@@ -1,117 +1,282 @@
 module Nutella
 
-  # This class implements the pub/sub and request/response nutella protocol
-  # @author Alessandro Gnoli <tebemis@gmail.com>
+  # This module implements the pub/sub and request/response APIs at the run level
   module Net
 
     # Store the subscriptions and the relative callbacks
     @subscriptions = []
     @callbacks = []
 
-    # Subscribe to a channel or to a set of channels if using wildcards
+    # Provides access to the net.app sub-module
+    def Net.app; Nutella::Net::App end
+
+    # Provides access to the subscriptions
+    def Net.subscriptions; @subscriptions end
+
+    # Provides access to callbacks
+    def Net.callbacks; @callbacks end
+
+
+    # Subscribes to a channel or to a set of channels.
+    #
+    # @param [String] channel the 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 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 Net.subscribe( channel, callback )
+      subscribe_to( channel, callback, Nutella.app_id, Nutella.run_id)
+    end
+
+
+    # Un-subscribes from a channel
+    #
+    # @param [String] channel we want to unsubscribe from. Can contain wildcard(s).
+    def Net.unsubscribe( channel )
+      unsubscribe_to( channel, Nutella.app_id, Nutella.run_id)
+    end
+
+
+    # Publishes a message to a channel
+    #
+    # @param [String] 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 Net.publish( channel, message=nil )
+      publish_to( channel, message, Nutella.app_id, Nutella.run_id)
+    end
+
+
+    # Performs a synchronous request.
+    #
+    # @param [String] 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 Net.sync_request( channel, message=nil )
+      sync_request_to(channel, message, Nutella.app_id, Nutella.run_id)
+    end
+
+
+    # Performs an asynchronous request
+    #
+    # @param [String] 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 Net.async_request( channel, message=nil, callback )
+      async_request_to(channel, message, callback, Nutella.app_id, Nutella.run_id)
+    end
+
+
+    # Handles requests on a certain channel
     #
-    # @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)
+    # @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 Net.handle_requests( channel, callback )
+      handle_requests_on(channel, callback, Nutella.app_id, Nutella.run_id)
+    end
+
+
+    # Listens for incoming messages. All this function
+    # does is to put the thread to sleep and wait for something to
+    # happen over the network to wake up.
+    def Net.listen
+      begin
+        sleep
+      rescue Interrupt
+        # Simply returns once interrupted
+      end
+    end
+
+
+    private
+
+
+    def Net.extract_fields_from_message(message)
+      mh = JSON.parse message
+      return mh['type'], mh['from'], mh['payload'], mh['id']
+    end
+
+    def Net.pad_channel( channel, app_id, run_id )
+      raise 'If the run_id is specified, app_id needs to also be specified' if (!run_id.nil? && app_id.nil?)
+      return "/nutella/#{channel}" if (app_id.nil? && run_id.nil?)
+      return "/nutella/apps/#{app_id}/#{channel}" if (!app_id.nil? && run_id.nil?)
+      "/nutella/apps/#{app_id}/runs/#{run_id}/#{channel}"
+    end
+
+    def Net.un_pad_channel( channel, app_id, run_id )
+      raise 'If the run_id is specified, app_id needs to also be specified' if (!run_id.nil? && app_id.nil?)
+      return channel.gsub('/nutella/', '') if (app_id.nil? && run_id.nil?)
+      return channel.gsub("/nutella/apps/#{app_id}/", '') if (!app_id.nil? && run_id.nil?)
+      channel.gsub("/nutella/apps/#{app_id}/runs/#{run_id}/", '')
+    end
+
+    def Net.assemble_from
+      from = Hash.new
+      if Nutella.run_id.nil?
+        from['type'] = 'app'
+      else
+        from['type'] = 'run'
+        from['run_id'] = Nutella.run_id
+      end
+      from['app_id'] = Nutella.app_id
+      from['component_id'] = Nutella.component_id
+      from['resource_id'] = Nutella.resource_id unless Nutella.resource_id.nil?
+      from
+    end
+
+    def Net.prepare_message_for_publish( message )
+      if message.nil?
+        return {type: 'publish', from: assemble_from}.to_json
+      end
+      {type: 'publish', from: assemble_from, payload: message}.to_json
+    end
+
+    def Net.prepare_message_for_request( message )
+      id = message.hash + Random.rand(100)
+      if message.nil?
+        return {id: id, type: 'request', from: assemble_from}.to_json, id
+      end
+      return {id: id, type: 'request', from: assemble_from, payload: message}.to_json, id
+    end
+
+    def Net.prepare_message_for_response( message, id )
+      if message.nil?
+        return {id: id, type: 'response', from: assemble_from}.to_json
+      end
+      {id: id, type: 'response', from: assemble_from, payload: message}.to_json
+    end
+
+
+    # Subscribes to a channel or to a set of channels.
+    #
+    # @param [String] channel the 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 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)
+    # @param [String] app_id used to pad channels
+    # @param [String] run_id used to pad channels
+    def Net.subscribe_to( channel, callback, app_id, run_id )
+      # Check the passed callback has the right number of arguments
+      if Nutella.mqtt.is_channel_wildcard?(channel)
+        raise 'You need to pass a callback with 3 parameters (message, channel, from) when subscribing to a wildcard channel!' if callback.parameters.length!=3
+      else
+        raise 'You need to pass a callback with 2 parameters (message, from) when subscribing to a channel!' if callback.parameters.length!=2
+      end
+      # Pad channel
+      padded_channel = pad_channel(channel, app_id, run_id)
       # 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}"
+      raise 'You can`t subscribe twice to the same channel`' if @subscriptions.include? padded_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)
+      if Nutella.mqtt.is_channel_wildcard?(padded_channel)
         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
+            type, from, payload, _ = extract_fields_from_message mqtt_message
+            callback.call(payload, un_pad_channel(mqtt_channel, app_id, 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', 'channel' and 'from'"
           end
         end
       else
         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
+            type, from, payload, _ = extract_fields_from_message message
+            callback.call(payload, 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' and 'from'"
           end
         end
       end
-      # Subscribe
-      @subscriptions.push channel
+      # Add to subscriptions, save mqtt callback and subscribe
+      @subscriptions.push padded_channel
       @callbacks.push mqtt_cb
-      Nutella.mqtt.subscribe(new_channel, mqtt_cb)
+      Nutella.mqtt.subscribe( padded_channel, mqtt_cb )
     end
 
 
-    # Unsubscribe from a channel
-    def Net.unsubscribe(channel)
-      idx = @subscriptions.index channel
+    # Un-subscribes from a channel
+    #
+    # @param [String] channel we want to unsubscribe from. Can contain wildcard(s).
+    # @param [String] app_id used to pad channels
+    # @param [String] run_id used to pad channels
+    def Net.unsubscribe_to( channel, app_id, run_id )
+      # Pad channel
+      padded_channel = pad_channel(channel, app_id, run_id)
+      idx = @subscriptions.index padded_channel
       # If we are not subscribed to this channel, return (no error is given)
       return if idx.nil?
-      # Pad the channel
+      # Fetch the mqtt_callback associated with this channel/subscription
       mqtt_cb = @callbacks[idx]
-      new_channel = Nutella.run_id + '/' + channel
-      # Unsubscribe
+      # Remove from subscriptions, callbacks and unsubscribe
       @subscriptions.delete_at idx
       @callbacks.delete_at idx
-      Nutella.mqtt.unsubscribe( new_channel, mqtt_cb )
+      Nutella.mqtt.unsubscribe( padded_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=nil)
-      # Pad the channel
-      new_channel = Nutella.run_id + '/' + channel
-      # Publish
+    #
+    # @param [String] 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.
+    # @param [String] app_id used to pad channels
+    # @param [String] run_id used to pad channels
+    def Net.publish_to( channel, message=nil, app_id, run_id )
+      # Pad channel
+      padded_channel = pad_channel(channel, app_id, run_id)
+      # Throw exception if trying to publish something that is not JSON
       begin
-        m = Net.prepare_message_for_publish(message)
-        Nutella.mqtt.publish(new_channel, m)
+        m = Net.prepare_message_for_publish message
+        Nutella.mqtt.publish( padded_channel, m )
       rescue
-        STDERR.puts $!
+        STDERR.puts 'Error: you are trying to publish something that is not JSON'
       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_request (channel, message=nil)
+    # Performs a synchronous request.
+    #
+    # @param [String] 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 [String] app_id used to pad channels
+    # @param [String] run_id used to pad channels
+    def Net.sync_request_to( channel, message=nil, app_id, run_id )
       # Pad channel
-      new_channel = "#{Nutella.run_id}/#{channel}"
+      padded_channel = pad_channel(channel, app_id, run_id)
       # Prepare message
       m, id = prepare_message_for_request message
       # Initialize response
       response = nil
       # Prepare callback
       mqtt_cb = lambda do |mqtt_message|
-        m_id = extract_id_from_message mqtt_message
-        type, payload  = extract_fields_from_response mqtt_message
+        type, _, payload, m_id = extract_fields_from_message mqtt_message
         if m_id==id && type=='response'
           response = payload
-          Nutella.mqtt.unsubscribe( new_channel, mqtt_cb )
+          Nutella.mqtt.unsubscribe( padded_channel, mqtt_cb )
         end
       end
       # Subscribe
-      Nutella.mqtt.subscribe( new_channel, mqtt_cb )
+      Nutella.mqtt.subscribe( padded_channel, mqtt_cb )
       # Publish message
-      Nutella.mqtt.publish( new_channel, m )
+      Nutella.mqtt.publish( padded_channel, m )
       # Wait for the response to come back
       sleep(0.1) while response.nil?
       response
@@ -119,110 +284,69 @@ module Nutella
 
 
     # 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_request (channel, message=nil, callback)
+    #
+    # @param [String] 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).
+    # @param [String] app_id used to pad channels
+    # @param [String] run_id used to pad channels
+    def Net.async_request_to( channel, message=nil, callback, app_id, run_id )
+      # Check the passed callback has the right number of arguments
+      raise 'You need to pass a callback with 1 parameter (response) when making an asynchronous request!' if callback.parameters.length!=1
       # Pad channel
-      new_channel = "#{Nutella.run_id}/#{channel}"
+      padded_channel = pad_channel(channel, app_id, run_id)
       # 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
+      mqtt_cb = lambda do |mqtt_message|
+        type, _, payload, m_id = extract_fields_from_message mqtt_message
         if m_id==id && type=='response'
           callback.call(payload)
-          Nutella.mqtt.unsubscribe( new_channel, mqtt_cb )
+          Nutella.mqtt.unsubscribe( padded_channel, mqtt_cb )
         end
       end
       # Subscribe
-      Nutella.mqtt.subscribe( new_channel, mqtt_cb )
+      Nutella.mqtt.subscribe( padded_channel, mqtt_cb )
       # Publish message
-      Nutella.mqtt.publish( new_channel, m )
+      Nutella.mqtt.publish( padded_channel, m )
     end
 
 
-
-    # Handle requests
-    def Net.handle_requests( channel, callback)
-      # Pad the channel
-      new_channel = "#{Nutella.run_id}/#{channel}"
+    # Handles requests on a certain channel
+    #
+    # @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.
+    # @param [String] app_id used to pad channels
+    # @param [String] run_id used to pad channels
+    def Net.handle_requests_on( channel, callback, app_id, run_id )
+      # Check the passed callback has the right number of arguments
+      raise 'You need to pass a callback with 2 parameter (request, from) when handling requests!' if callback.parameters.length!=2
+      # Pad channel
+      padded_channel = pad_channel(channel, app_id, run_id)
       mqtt_cb = lambda do |request|
         begin
           # Extract nutella fields
-          type, payload, component_id, resource_id = extract_fields_from_message request
-          id = extract_id_from_message request
+          type, from, payload, id = extract_fields_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
+          # Execute callback and send response
+          m = Net.prepare_message_for_response( callback.call( payload, from), id )
+          Nutella.mqtt.publish( padded_channel, m )
+        rescue JSON::ParserError
+          # Make sure that request contains JSON, if not drop the message
           return
+        rescue
+          # Check that the passed callback has the right number of arguments
+          STDERR.puts "The callback you passed to subscribe has the #{$!}: it needs 'payload' and 'from'"
         end
       end
       # Subscribe to the channel
-      Nutella.mqtt.subscribe(new_channel, mqtt_cb)
+      Nutella.mqtt.subscribe(padded_channel, mqtt_cb)
     end
-
-
-    # Listens for incoming messages
-    def Net.listen
-      begin
-        sleep
-      rescue Interrupt
-        # Simply returns
-      end
-    end
-
-
-    private
-
-    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
-      {type: 'publish', from: from, payload: message}.to_json
-    end
-
-    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
-      return {id: message.hash, type: 'request', from: from, payload: message}.to_json, message.hash
-    end
-
-
   end
 end