module Nutella::Framework::Net

Public Class Methods

async_request( channel, message=nil, callback ) click to toggle source

Performs an asynchronous request at the framework-level

@param [String] channel the framework-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).

# File lib/nutella_lib/framework_net.rb, line 56
def self.async_request ( channel, message=nil, callback )
  Nutella::Net.async_request_to(channel, message, callback, nil, nil)
end
async_request_to_all_apps(channel, request, callback) click to toggle source

Allows framework-level APIs to send a request to a run-level channel *for ALL runs*

@param [String] channel the app-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).

# File lib/nutella_lib/framework_net.rb, line 461
def self.async_request_to_all_apps(channel, request, callback)
  Nutella.runlist.all_runs.each do |app_id, _|
    Nutella::Net.async_request_to(channel, request, callback, app_id, nil)
  end
end
async_request_to_all_runs(channel, request, callback) click to toggle source

Allows framework-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).

# File lib/nutella_lib/framework_net.rb, line 235
def self.async_request_to_all_runs(channel, request, callback)
  Nutella.runlist.all_runs.each do |app_id, _|
    Nutella.runlist.runs_for_app(app_id).each do |run_id|
      Nutella::Net.async_request_to(channel, request, callback, app_id, run_id)
    end
  end
end
async_request_to_app( app_id, channel, request, callback) click to toggle source

Allows framework-level APIs to make an asynchronous request to a run-level channel within a specific run

@param [String] app_id the specific application we are making the request to @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).

# File lib/nutella_lib/framework_net.rb, line 371
def self.async_request_to_app( app_id, channel, request, callback)
  Nutella::Net.async_request_to(channel, request, callback, app_id, nil)
end
async_request_to_run( app_id, run_id, channel, request, callback) click to toggle source

Allows framework-level APIs to make an asynchronous request to a run-level channel within a specific run

@param [String] app_id the specific application we are making the request to @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).

# File lib/nutella_lib/framework_net.rb, line 136
def self.async_request_to_run( app_id, run_id, channel, request, callback)
  Nutella::Net.async_request_to(channel, request, callback, app_id, run_id)
end
catch_requests_on_all_runs_wildcard(callback) click to toggle source
# File lib/nutella_lib/framework_net.rb, line 283
def self.catch_requests_on_all_runs_wildcard(callback)
  # Pad channel
  padded_channel = Nutella::Net.pad_channel("#", '+', '+')
  mqtt_cb = lambda do |request, mqtt_channel|
    begin
      # Extract nutella fields
      type, from, payload, id = Nutella::Net.extract_fields_from_message request
      app_id, run_id = self.extract_run_id_and_app_id mqtt_channel
      # Only handle requests that have proper id set
      return if type!='request' || id.nil?
      # Execute callback and send response
      regex = Regexp.new '/nutella/apps/[^"\/"]+/runs/[^"\/"]+/'
      unpadded_channel = mqtt_channel.gsub(regex, '')
      callback.call( unpadded_channel, payload, app_id, run_id, from)
    rescue JSON::ParserError
      # Make sure that request contains JSON, if not drop the message
      return
    rescue ArgumentError
      # Check the passed callback has the right number of arguments
      STDERR.puts "The callback you passed to subscribe has the #{$!}: it needs 'request', 'app_id', 'run_id' and 'from'"
    end
  end
  # Subscribe to the channel
  Nutella.mqtt.subscribe( padded_channel, mqtt_cb )
end
handle_requests( channel, callback ) click to toggle source

Handles requests on a certain framework-level channel

@param [String] channel tha framework-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.
# File lib/nutella_lib/framework_net.rb, line 69
def self.handle_requests( channel, callback )
  Nutella::Net.handle_requests_on(channel, callback, nil, nil)
end
handle_requests_on_all_apps(channel, callback) click to toggle source

Allows framework-level APIs to handle requests to a run-level channel *for ALL runs*

@param [String] channel tha app-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] app_id: the app_id of the channel the request 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.
# File lib/nutella_lib/framework_net.rb, line 477
def self.handle_requests_on_all_apps(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, '+', nil)
  mqtt_cb = lambda do |request, mqtt_channel|
    begin
      # Extract nutella fields
      type, from, payload, id = Nutella::Net.extract_fields_from_message request
      app_id  = self.extract_app_id mqtt_channel
      # Only handle requests that have proper id set
      return if type!='request' || id.nil?
      # Execute callback and send response
      m = Nutella::Net.prepare_message_for_response( callback.call( payload, app_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 ArgumentError
      # Check the passed callback has the right number of arguments
      STDERR.puts "The callback you passed to subscribe has the #{$!}: it needs 'request', 'app_id' and 'from'"
    end
  end
  # Subscribe to the channel
  Nutella.mqtt.subscribe( padded_channel, mqtt_cb )
  # Notify subscription
  Nutella::Net.publish_to('subscriptions', {'type' => 'handle_requests', 'channel' => padded_channel}, nil, nil)
end
handle_requests_on_all_runs(channel, callback) click to toggle source

Allows framework-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] app_id: the app_id of the channel the request was sent on
- [String] run_id: the run_id of the channel the request 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.
# File lib/nutella_lib/framework_net.rb, line 254
def self.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 4 parameters (request, run_id, from) when handling requests!' if callback.parameters.length!=4
  # Pad channel
  padded_channel = Nutella::Net.pad_channel(channel, '+', '+')
  mqtt_cb = lambda do |request, mqtt_channel|
    begin
      # Extract nutella fields
      type, from, payload, id = Nutella::Net.extract_fields_from_message request
      app_id, run_id = self.extract_run_id_and_app_id mqtt_channel
      # Only handle requests that have proper id set
      return if type!='request' || id.nil?
      # Execute callback and send response
      m = Nutella::Net.prepare_message_for_response( callback.call( payload, app_id, 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 ArgumentError
      # Check the passed callback has the right number of arguments
      STDERR.puts "The callback you passed to subscribe has the #{$!}: it needs 'request', 'app_id', 'run_id' and 'from'"
    end
  end
  # Subscribe to the channel
  Nutella.mqtt.subscribe( padded_channel, mqtt_cb )
  # Notify subscription
  Nutella::Net.publish_to('subscriptions', {'type' => 'handle_requests', 'channel' => padded_channel}, nil, nil)
end
handle_requests_on_app(app_id, channel, callback) click to toggle source

Allows framework-level APIs to handle requests on a run-level channel within a specific run

@param [String] app_id the specific application requests are coming from @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.
# File lib/nutella_lib/framework_net.rb, line 386
def self.handle_requests_on_app(app_id, channel, callback)
  Nutella::Net.handle_requests_on(channel, callback, app_id, nil)
end
handle_requests_on_run( app_id, run_id, channel, callback ) click to toggle source

Allows framework-level APIs to handle requests on a run-level channel within a specific run

@param [String] app_id the specific application requests are coming from @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.
# File lib/nutella_lib/framework_net.rb, line 151
def self.handle_requests_on_run( app_id, run_id, channel, callback )
  Nutella::Net.handle_requests_on(channel, callback, app_id, run_id)
end
listen() click to toggle source

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.

# File lib/nutella_lib/framework_net.rb, line 515
def self.listen
  Nutella::Net.listen
end
publish(channel, message=nil) click to toggle source

Publishes a message to an framework-level channel

@param [String] channel the framework-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.
# File lib/nutella_lib/framework_net.rb, line 35
def self.publish(channel, message=nil)
  Nutella::Net.publish_to(channel, message, nil, nil)
end
publish_to_all_apps(channel, message) click to toggle source

Allows framework-level APIs to publish a message to an app-level channel *for ALL apps*

@param [String] channel the app-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.
# File lib/nutella_lib/framework_net.rb, line 448
def self.publish_to_all_apps(channel, message)
  Nutella.runlist.all_runs.each do |app_id, _|
    Nutella::Net.publish_to(channel, message, app_id, nil)
  end
end
publish_to_all_runs( channel, message ) click to toggle source

Allows framework-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.
# File lib/nutella_lib/framework_net.rb, line 220
def self.publish_to_all_runs( channel, message )
  Nutella.runlist.all_runs.each do |app_id, _|
    Nutella.runlist.runs_for_app(app_id).each do |run_id|
      Nutella::Net.publish_to(channel, message, app_id, run_id)
    end
  end
end
publish_to_app(app_id, channel, message) click to toggle source

Allows framework-level APIs to publish to an app-level channel within a specific run

@param [String] app_id the specific application 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.
# File lib/nutella_lib/framework_net.rb, line 346
def self.publish_to_app(app_id, channel, message)
  Nutella::Net.publish_to(channel, message, app_id, nil)
end
publish_to_run( app_id, run_id, channel, message ) click to toggle source

Allows framework-level APIs to publish to a run-level channel within a specific run

@param [String] app_id the specific application we are publishing to @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.
# File lib/nutella_lib/framework_net.rb, line 111
def self.publish_to_run( app_id, run_id, channel, message )
  Nutella::Net.publish_to(channel, message, app_id, run_id)
end
subscribe(channel, callback) click to toggle source

Subscribes to a channel or to a set of channels at the framework-level.

@param [String] channel the framework-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 framework-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)
# File lib/nutella_lib/framework_net.rb, line 17
def self.subscribe (channel, callback)
  Nutella::Net.subscribe_to(channel, callback, nil, nil)
end
subscribe_to_all_apps(channel, callback) click to toggle source

Allows framework-level APIs to subscribe to an app-level channel *for ALL apps*

@param [String] channel the app-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] app_id: the app_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)
# File lib/nutella_lib/framework_net.rb, line 408
def self.subscribe_to_all_apps(channel, callback)
  # Check the passed callback has the right number of arguments
  raise 'You need to pass a callback with 3 parameters (payload, app_id, from) when subscribing to all apps!' if callback.parameters.length!=3
  # Pad channel
  padded_channel = Nutella::Net.pad_channel(channel, '+', nil)
  mqtt_cb = lambda do |mqtt_message, mqtt_channel|
    begin
      type, from, payload, _ = Nutella::Net.extract_fields_from_message mqtt_message
      app_id = self.extract_app_id mqtt_channel
      callback.call(payload, app_id, from) if type=='publish'
    rescue JSON::ParserError
      # Make sure the message is JSON, if not drop the message
      return
    rescue ArgumentError
      # Check the passed callback has the right number of arguments
      STDERR.puts "The callback you passed to subscribe has the #{$!}: it needs 'payload', 'app_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 )
  # Notify subscription
  Nutella::Net.publish_to('subscriptions', {'type' => 'subscribe', 'channel' => padded_channel}, nil, nil)
end
subscribe_to_all_runs( channel, callback ) click to toggle source

Allows framework-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] app_id: the app_id of the channel the message was sent on
- [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)
# File lib/nutella_lib/framework_net.rb, line 170
def self.subscribe_to_all_runs( channel, callback )
  # Check the passed callback has the right number of arguments
  raise 'You need to pass a callback with 4 parameters (payload, app_id, run_id, from) when subscribing to all runs!' if callback.parameters.length!=4 && callback.parameters.length!=5
  # Pad channel
  padded_channel = Nutella::Net.pad_channel(channel, '+', '+')
  mqtt_cb = lambda do |mqtt_message, mqtt_channel|
    begin
      type, from, payload, _ = Nutella::Net.extract_fields_from_message mqtt_message
      app_id, run_id = self.extract_run_id_and_app_id mqtt_channel
      if channel.include?('#')
        unpadded_channel = un_pad_wildcard_channel(mqtt_channel)
        callback.call(unpadded_channel, payload, app_id, run_id, from) if type=='publish'
      else
        callback.call(payload, app_id, run_id, from) if type=='publish'
      end
    rescue JSON::ParserError
      # Make sure the message is JSON, if not drop the message
      return
    rescue ArgumentError
      # Check the passed callback has the right number of arguments
      STDERR.puts "The callback you passed to subscribe has the #{$!}: it needs 'payload', 'app_id', '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 )
  # Notify subscription
  Nutella::Net.publish_to('subscriptions', {'type' => 'subscribe', 'channel' => padded_channel}, nil, nil)
end
subscribe_to_app(app_id, channel, callback) click to toggle source

Allows framework-level APIs to subscribe to an app-level channel within a specific run

@param [String] app_id the specific application 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 framework-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)
# File lib/nutella_lib/framework_net.rb, line 325
def self.subscribe_to_app(app_id, channel, callback)
  Nutella::Net.subscribe_to(channel, callback, app_id, nil)
end
subscribe_to_run( app_id, run_id, channel, callback ) click to toggle source

Allows framework-level APIs to subscribe to a run-level channel within a specific run

@param [String] app_id the specific application we are subscribing to @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 framework-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)
# File lib/nutella_lib/framework_net.rb, line 89
def self.subscribe_to_run( app_id, run_id, channel, callback )
  Nutella::Net.subscribe_to(channel, callback, app_id, run_id)
end
sync_request( channel, message=nil ) click to toggle source

Performs a synchronous request at the framework-level

@param [String] channel the framework-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.
# File lib/nutella_lib/framework_net.rb, line 45
def self.sync_request ( channel, message=nil )
  Nutella::Net.sync_request_to(channel, message, nil, nil)
end
sync_request_to_app( app_id, channel, request) click to toggle source

Allows framework-level APIs to make a synchronous request to a run-level channel within a specific run

@param [String] app_id the specific application we are making the request to @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.
# File lib/nutella_lib/framework_net.rb, line 358
def self.sync_request_to_app( app_id, channel, request)
  Nutella::Net.sync_request_to(channel, request, app_id, nil)
end
sync_request_to_run( app_id, run_id, channel, request) click to toggle source

Allows framework-level APIs to make a synchronous request to a run-level channel within a specific run

@param [String] app_id the specific application we are making the request to @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.
# File lib/nutella_lib/framework_net.rb, line 123
def self.sync_request_to_run( app_id, run_id, channel, request)
  Nutella::Net.sync_request_to(channel, request, app_id, run_id)
end
un_pad_wildcard_channel(channel) click to toggle source
# File lib/nutella_lib/framework_net.rb, line 201
def self.un_pad_wildcard_channel(channel)
  regex = Regexp.new '/nutella/apps/[^"\/"]+/runs/[^"\/"]+/'
  channel.gsub(regex, '')
end
unsubscribe( channel ) click to toggle source

Un-subscribes from a framework-level channel

@param [String] channel the framework-level channel we want to unsubscribe from. Can contain wildcard(s).

# File lib/nutella_lib/framework_net.rb, line 25
def self.unsubscribe( channel )
  Nutella::Net.unsubscribe_to(channel, nil, nil)
end
unsubscribe_from_all_apps( channel ) click to toggle source

Allows framework-level APIs to unsubscribe from an app-level channel *for ALL apps*

@param [String] channel the run-level channel we want to unsubscribe from. Can contain wildcard(s).

# File lib/nutella_lib/framework_net.rb, line 438
def self.unsubscribe_from_all_apps( channel )
  Nutella::Net.unsubscribe_to(channel, '+', nil)
end
unsubscribe_from_all_runs( channel ) click to toggle source

Allows framework-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).

# File lib/nutella_lib/framework_net.rb, line 210
def self.unsubscribe_from_all_runs( channel )
  Nutella::Net.unsubscribe_to(channel, '+', '+')
end
unsubscribe_to_app( app_id, channel ) click to toggle source

Allows framework-level APIs to unsubscribe from an app-level channel within a specific run

@param [String] app_id the specific application we are un-subscribing from @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).

# File lib/nutella_lib/framework_net.rb, line 335
def self.unsubscribe_to_app( app_id, channel )
  Nutella::Net.unsubscribe_to(channel, app_id, nil)
end
unsubscribe_to_run( app_id, run_id, channel ) click to toggle source

Allows framework-level APIs to unsubscribe from a run-level channel within a specific run

@param [String] app_id the specific application we are un-subscribing from @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).

# File lib/nutella_lib/framework_net.rb, line 99
def self.unsubscribe_to_run( app_id, run_id, channel )
  Nutella::Net.unsubscribe_to(channel, app_id, run_id)
end

Private Class Methods

extract_app_id( mqtt_channel ) click to toggle source
# File lib/nutella_lib/framework_net.rb, line 529
def self.extract_app_id( mqtt_channel )
  sp =  mqtt_channel.sub('/nutella/apps/', '').split('/')
  return sp[0]
end
extract_run_id_and_app_id( mqtt_channel ) click to toggle source
# File lib/nutella_lib/framework_net.rb, line 523
def self.extract_run_id_and_app_id( mqtt_channel )
  sp =  mqtt_channel.sub('/nutella/apps/', '').split('/')
  return sp[0], sp[2]
end