RubyGems - nutella_framework - Versions diffs - 0.4.5 → 0.4.8 - Mend

nutella_framework 0.4.5 → 0.4.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (74) hide show

data/framework_components/example_framework_web_interface/node_modules/nutella_lib/test/runner.html ADDED Viewed

@@ -0,0 +1,22 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Nutella Tests</title>
+  <link rel="stylesheet" href="../node_modules/mocha/mocha.css" />
+</head>
+<body>
+  <div id="mocha"></div>
+  <script src="../node_modules/mocha/mocha.js" type="text/javascript"></script>
+	<script src="../node_modules/chai/chai.js" type="text/javascript"></script>
+  <script>
+    mocha.setup('bdd');
+    mocha.setup({ignoreLeaks: true});
+  </script>
+  <script src="../dist/nutella_lib.js"></script>
+  <script src="nutella.test.js"></script>
+  <script>
+    mocha.run();
+  </script>
+</body>
+</html>

data/framework_components/example_framework_web_interface/package.json ADDED Viewed

@@ -0,0 +1,15 @@
+{
+  "name": "example_framework_web_interface",
+  "version": "0.1.0",
+  "description": "An example framework interface",
+  "main": "index.html",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "Alessandro Gnoli",
+  "license": "MIT",
+  "private": true,
+  "dependencies": {
+    "nutella_lib": "*"
+  }
+}

data/framework_components/{order.json.example → order.json} RENAMED Viewed

File without changes

data/framework_components/runs_list_bot/{app_runs_list_bot.rb → runs_list_bot.rb} RENAMED Viewed

@@ -22,15 +22,21 @@ nutella.f.net.handle_requests_on_all_apps('app_runs_list', lambda do |req, app_i
   Nutella.runlist.runs_for_app app_id
 end)
+# Listen for runs_list requests (done by framework interfaces when they connect)
+nutella.f.net.handle_requests('runs_list', lambda do |req, from|
+  Nutella.runlist.all_runs
+end)
-# Whenever the runs list is updated, fire an updated runlist to all the apps
+# Whenever the runs list is updated, fire an updated runlist to all the apps and all framework components
 p = Nutella.runlist.all_runs
-while sleep .5
+while sleep 0.25
   n = Nutella.runlist.all_runs
   if p!=n
-    all_apps.each do |app_id, _|
+    Nutella.runlist.all_apps.each do |app_id, _|
       nutella.f.net.publish_to_app(app_id, 'app_runs_list', Nutella.runlist.runs_for_app(app_id))
     end
+    nutella.f.net.publish 'runs_list', Nutella.runlist.all_runs
     p = n
   end
 end

data/framework_components/runs_list_bot/startup CHANGED Viewed

@@ -1,5 +1,5 @@
 #!/bin/sh
 BASEDIR=$(dirname $0)
-ruby $BASEDIR/app_runs_list_bot.rb > /dev/null 2>&1 &
+ruby $BASEDIR/runs_list_bot.rb > /dev/null 2>&1 &
 echo $! > $BASEDIR/.pid

data/lib/commands/meta/run_command.rb CHANGED Viewed

@@ -1,4 +1,5 @@
 require 'commands/meta/command'
+require 'commands/util/components_list'
 require 'slop'
 module Nutella
@@ -50,40 +51,6 @@ module Nutella
     end
-    # Returns all the components in a certain directory
-    def components_in_dir( dir )
-      Dir.entries(dir).select {|entry| File.directory?(File.join(dir, entry)) && !(entry =='.' || entry == '..') }
-    end
-    # Executes a code block for each component in a certain directory
-    # @param [String] dir directory where we are iterating
-    # @yield [component] Passes the component name to the block
-    def for_each_component_in_dir( dir, &block )
-      components_in_dir(dir).each do |component|
-        block.call component
-      end
-    end
-    # Runs a script for each bot in a certain directory.
-    # Message is displayed in case something goes wrong
-    def run_script_for_all_bots_in( dir, script, message )
-      for_each_component_in_dir dir do |bot|
-        # Skip bot if there is no script
-        next unless File.exist? "#{dir}/bots/#{bot}/#{script}"
-        # Output message
-        console.info "#{message} bot #{bot}."
-        # Execute 'script' script
-        cur_dir = Dir.pwd
-        Dir.chdir "#{dir}/bots/#{bot}"
-        system "./#{script}"
-        Dir.chdir cur_dir
-      end
-      true
-    end
     #  Prints a success message if the command completes correctly
     def print_success_message(app_id, run_id, action)
       if run_id == 'default'
@@ -100,15 +67,33 @@ module Nutella
         console.warn 'The current directory is not a nutella application'
         return
       end
       # Run script
       return unless run_script_for_all_bots_in( Dir.pwd, script, in_progress_message )
       # Output success message
       console.success "All #{complete_message} for #{Nutella.current_app.config['name']}"
     end
+    private
+    # Runs a script for each bot in a certain directory.
+    # Message is displayed in case something goes wrong
+    def run_script_for_all_bots_in( dir, script, message )
+      ComponentsList.for_each_component_in_dir dir do |bot|
+        # Skip bot if there is no script
+        next unless File.exist? "#{dir}/bots/#{bot}/#{script}"
+        # Output message
+        console.info "#{message} bot #{bot}."
+        # Execute 'script' script
+        cur_dir = Dir.pwd
+        Dir.chdir "#{dir}/bots/#{bot}"
+        system "./#{script}"
+        Dir.chdir cur_dir
+      end
+      true
+    end
   end
 end

data/lib/commands/start.rb CHANGED Viewed

@@ -1,5 +1,5 @@
 require 'commands/meta/run_command'
-require 'tmux/tmux'
+require 'commands/util/components_starter'
 module Nutella
   class Start < RunCommand
@@ -14,7 +14,7 @@ module Nutella
       end
       begin
-        run_id, params = parse_cli args
+        run_id, params = parse_cli_arguments args
       rescue StandardError => e
         console.error e.message
         return
@@ -41,7 +41,7 @@ module Nutella
     # Parses command line arguments
-    def parse_cli( args )
+    def parse_cli_arguments( args )
       # Parse run_id
       run_id = parse_run_id_from args
       # Extract parameters
@@ -65,54 +65,10 @@ module Nutella
     # Returns true if both the list of run level bots is empty and the app bots
     # have been started already
     def no_bot_to_start(app_id, app_path, params)
-      return run_level_bots_list(app_path, params).empty? && app_bots_started?(app_id)
+      ComponentsList.run_level_bots_list(app_path, params).empty? && app_bots_started?(app_id)
     end
-    # Returns the list of run-level bots for this run
-    # Depending on the mode we are in, we want to start only some bots, exclude only some bots or start all bots
-    def run_level_bots_list( app_path, params )
-      # Fetch the list of all components in the bots dir
-      all_bots = components_in_dir "#{app_path}/bots/"
-      # Fetch the list of app bots
-      app_bots = Nutella.current_app.config['app_bots']
-      # Return correct list based on the mode we are in
-      case start_mode(params)
-        when :WITH
-          return  get_with_bots_list params[:with], app_bots
-        when :WO
-          return get_wo_bots_list all_bots, app_bots, params[:without]
-        when :ALL
-          return get_all_bots_list all_bots, app_bots
-        else
-          # If we get here it means we are both in with and without mode and something went very wrong...
-          raise 'You are using simultaneously with and without modes. This should not happen. Please contact developers.'
-      end
-    end
-    def start_mode(params)
-      return :WITH unless params[:with].empty?
-      return :WO unless params[:without].empty?
-      :ALL if params[:with].empty? && params[:without].empty?
-    end
-    # If we are in "with mode", we want to run only the bots in the "with list" (minus the ones in app_bots_list)
-    def get_with_bots_list( incl_bots, app_bots)
-      return app_bots.nil? ? incl_bots : incl_bots - app_bots
-    end
-    # If we are in "without mode", we want to run all the bots in the bots_list minus the ones in the "without list" and in the "app bots list"
-    def get_wo_bots_list( all_bots, app_bots, excl_bots )
-      return app_bots.nil? ? all_bots - excl_bots : all_bots - excl_bots - app_bots
-    end
-    # If we are in "all mode", we want to run all the bots minus the ones in the "app bots list"
-    def get_all_bots_list( all_bots, app_bots )
-      return app_bots.nil? ? all_bots : all_bots - app_bots
-    end
     # Returns true if the app bots have been started already
     def app_bots_started?( app_id )
       Tmux.session_exist? Tmux.app_bot_session_name app_id
@@ -137,162 +93,17 @@ module Nutella
     # Starts all the components at all levels for this run
     def start_all_components( app_id, app_path, run_id, params )
       # Start the internal broker
-      return false unless start_internal_broker
+      return false unless ComponentsStarter.start_internal_broker
       # Start all framework-level components (if needed)
-      return false unless start_framework_components
+      return false unless ComponentsStarter.start_framework_components
       # Start all app-level bots (if any, if needed)
-      return false unless start_app_bots(app_id, app_path)
+      return false unless ComponentsStarter.start_app_bots(app_id, app_path)
       # Start all run-level bots
-      false unless start_run_bots( app_path, app_id, run_id, params )
-      true
-    end
-    def start_internal_broker
-      pid_file_path = "#{Nutella.config['broker_dir']}bin/.pid"
-      # Check if the process with pid indicated in the pidfile is alive
-      return true if sanitize_pid_file pid_file_path
-      # Check that broker is not running 'unsupervised' (i.e. check port 1883), if it is, return
-      return true unless broker_port_free?
-      # Broker is not running and there is no pid file so we try to start
-      # the internal broker and create a new pid file. Note that the pid file is created by
-      # the `startup` script, not here.
-      pid = fork
-      exec("#{Nutella.config['broker_dir']}/startup") if pid.nil?
-      # Wait a bit to give the chance to the broker to actually start up
-      sleep 1
-      # All went well so we return true
-      true
-    end
-    # Cleans the pid file of a given process
-    # @param [String] pid_file_path the file storing the pid file of the process
-    # @return [Boolean] true if the pid file exists AND the process with that pid is still alive
-    def sanitize_pid_file( pid_file_path )
-      # Does the pid file exist?
-      # If it does we try to see if the process with that pid is still alive
-      if File.exist? pid_file_path
-        pid_file = File.open(pid_file_path, 'rb')
-        pid = pid_file.read.to_i
-        pid_file.close
-        begin
-          # If this statement doesn't throw an exception then a process with
-          # this pid is still alive so we do nothing and just return true
-          Process.getpgid pid
-          return true
-        rescue
-          # If there is an exception, there is no process with this pid
-          # so we have a stale pid file that we need to remove
-          File.delete pid_file_path
-          return false
-        end
-      end
-      # If there is no pid file, there is no process running
-      false
-    end
-    # Checks if port 1883 (MQTT broker port) is free
-    # or some other service is already listening on it
-    def broker_port_free?
-      begin
-        s = TCPServer.new('0.0.0.0', 1883)
-        s.close
-      rescue
-        return false
-      end
+      false unless ComponentsStarter.start_run_bots(ComponentsList.run_level_bots_list(app_path, params), app_path, app_id, run_id)
       true
     end
-    def start_framework_components
-      nutella_components_dir = "#{Nutella::NUTELLA_HOME}framework_components"
-      if File.exist? "#{nutella_components_dir}/order.json"
-        components_list = JSON.parse IO.read "#{nutella_components_dir}/order.json"
-      else
-        components_list = components_in_dir(nutella_components_dir)
-      end
-      components_list.each do |component|
-        if File.exist? "#{nutella_components_dir}/#{component}/startup"
-          unless start_framework_component "#{nutella_components_dir}/#{component}"
-            return false
-          end
-        end
-      end
-      true
-    end
-    def start_framework_component( component_dir )
-      pid_file_path = "#{component_dir}/.pid"
-      return true if sanitize_pid_file pid_file_path
-      # Component is not running and there is no pid file so we try to start it
-      # and create a new pid file. Note that the pid file is created by
-      # the startup script!
-      nutella_config_file = "#{Nutella.config['config_dir']}config.json"
-      runs_list_file = "#{Nutella.config['config_dir']}runlist.json"
-      if nutella_config_file==nil || runs_list_file==nil
-        return false
-      end
-      # We are passing the configuration file and the run list files paths to the framework components
-      command = "#{component_dir}/startup #{nutella_config_file} #{runs_list_file}"
-      pid = fork
-      exec(command) if pid.nil?
-      # Give it a second so they can start properly
-      sleep 1
-      # All went well so we return true
-      true
-    end
-    def start_app_bots( app_id, app_path )
-      app_bots_list = Nutella.current_app.config['app_bots']
-      bots_dir = "#{app_path}/bots/"
-      # If app bots have been started already, then do nothing
-      unless Tmux.session_exist? Tmux.app_bot_session_name app_id
-        # Start all app bots in the list into a new tmux session
-        tmux = Tmux.new app_id, nil
-        for_each_component_in_dir bots_dir do |bot|
-          unless app_bots_list.nil? || !app_bots_list.include?( bot )
-            # If there is no 'startup' script output a warning (because
-            # startup is mandatory) and skip the bot
-            unless File.exist?("#{bots_dir}#{bot}/startup")
-              console.warn "Impossible to start bot #{bot}. Couldn't locate 'startup' script."
-              next
-            end
-            # Create a new window in the session for this run
-            tmux.new_app_bot_window bot
-          end
-        end
-      end
-      true
-    end
-    def start_run_bots( app_path, app_id, run_id, params )
-      # Create a new tmux instance for this run
-      tmux = Tmux.new app_id, run_id
-      # Fetch bots dir
-      bots_dir = "#{app_path}/bots/"
-      # Start the appropriate bots
-      run_level_bots_list( app_path, params ).each { |bot| start_run_level_bot(bots_dir, bot, tmux) }
-      true
-    end
-    # Starts a run level bot
-    def start_run_level_bot( bots_dir, bot, tmux )
-      # If there is no 'startup' script output a warning (because
-      # startup is mandatory) and skip the bot
-      unless File.exist?("#{bots_dir}#{bot}/startup")
-        console.warn "Impossible to start bot #{bot}. Couldn't locate 'startup' script."
-        return
-      end
-      # Create a new window in the session for this run
-      tmux.new_bot_window bot
-    end
     def print_confirmation( run_id, params, app_id, app_path )
       # If there are no run-level bots to start, do not create the run and error out
       if run_level_bots_list(app_path, params).empty?
@@ -316,8 +127,7 @@ module Nutella
       console.success "Do `tmux attach-session -t #{Tmux.session_name(app_id,run_id)}` to monitor your bots."
       console.success "Go to http://localhost:#{Nutella.config['main_interface_port']}/#{app_id}/#{run_id} to access your interfaces"
     end
   end
 end

data/lib/commands/util/components_list.rb ADDED Viewed

@@ -0,0 +1,68 @@
+# Utility methods to list components
+class ComponentsList
+  # Returns all the components in a certain directory
+  def self.components_in_dir( dir )
+    Dir.entries(dir).select {|entry| File.directory?(File.join(dir, entry)) && !(entry =='.' || entry == '..') }
+  end
+  # Executes a code block for each component in a certain directory
+  # @param [String] dir directory where we are iterating
+  # @yield [component] Passes the component name to the block
+  def self.for_each_component_in_dir( dir, &block )
+    components_in_dir(dir).each { |component| block.call component }
+  end
+  # Returns the list of run-level bots for this run
+  # Depending on the mode we are in, we want to start only some bots, exclude only some bots or start all bots
+  def self.run_level_bots_list( app_path, params )
+    # Fetch the list of all components in the bots dir
+    all_bots = components_in_dir "#{app_path}/bots/"
+    # Fetch the list of app bots
+    app_bots = Nutella.current_app.config['app_bots']
+    # Return correct list based on the mode we are in
+    case start_mode(params)
+      when :WITH
+        return  get_with_bots_list params[:with], app_bots
+      when :WO
+        return get_wo_bots_list all_bots, app_bots, params[:without]
+      when :ALL
+        return get_all_bots_list all_bots, app_bots
+      else
+        # If we get here it means we are both in with and without mode and something went very wrong...
+        raise 'You are using simultaneously with and without modes. This should not happen. Please contact developers.'
+    end
+  end
+  #--- Private class methods --------------
+  def self.start_mode(params)
+    return :WITH unless params[:with].empty?
+    return :WO unless params[:without].empty?
+    :ALL if params[:with].empty? && params[:without].empty?
+  end
+  private_class_method :start_mode
+  # If we are in "with mode", we want to run only the bots in the "with list" (minus the ones in app_bots_list)
+  def self.get_with_bots_list( incl_bots, app_bots)
+    return app_bots.nil? ? incl_bots : incl_bots - app_bots
+  end
+  private_class_method :get_with_bots_list
+  # If we are in "without mode", we want to run all the bots in the bots_list minus the ones in the "without list" and in the "app bots list"
+  def self.get_wo_bots_list( all_bots, app_bots, excl_bots )
+    return app_bots.nil? ? all_bots - excl_bots : all_bots - excl_bots - app_bots
+  end
+  private_class_method :get_wo_bots_list
+  # If we are in "all mode", we want to run all the bots minus the ones in the "app bots list"
+  def self.get_all_bots_list( all_bots, app_bots )
+    return app_bots.nil? ? all_bots : all_bots - app_bots
+  end
+  private_class_method :get_all_bots_list
+end

data/lib/commands/util/components_starter.rb ADDED Viewed

@@ -0,0 +1,169 @@
+require 'commands/util/components_list'
+require 'tmux/tmux'
+# Utility functions to start components
+class ComponentsStarter
+  # Starts the internal broker if it's not started already
+  # @return [boolean] true if the broker is correctly started, false otherwise
+  def self.start_internal_broker
+    pid_file_path = "#{Nutella.config['broker_dir']}bin/.pid"
+    # Check if the process with pid indicated in the pidfile is alive
+    return true if sanitize_pid_file pid_file_path
+    # Check that broker is not running 'unsupervised' (i.e. check port 1883), if it is, return
+    return true unless broker_port_free?
+    # Broker is not running and there is no pid file so we try to start
+    # the internal broker and create a new pid file. Note that the pid file is created by
+    # the `startup` script, not here.
+    pid = fork
+    exec("#{Nutella.config['broker_dir']}/startup") if pid.nil?
+    # Wait a bit to give the chance to the broker to actually start up
+    sleep 1
+    # All went well so we return true
+    true
+  end
+  # Starts all framework components. If order.json is present, components are started
+  # in that order.
+  # @return [boolean] true if all components are started correctly, false otherwise
+  def self.start_framework_components
+    nutella_components_dir = "#{Nutella::NUTELLA_HOME}framework_components"
+    if File.exist? "#{nutella_components_dir}/order.json"
+      components_list = JSON.parse IO.read "#{nutella_components_dir}/order.json"
+    else
+      components_list = ComponentsList.components_in_dir nutella_components_dir
+    end
+    components_list.each do |component|
+      if File.exist? "#{nutella_components_dir}/#{component}/startup"
+        unless start_framework_component "#{nutella_components_dir}/#{component}"
+          return false
+        end
+      end
+    end
+    true
+  end
+  # Starts the application level bots
+  # @return [boolean] true if all bots are started correctly, false otherwise
+  def self.start_app_bots( app_id, app_path )
+    app_bots_list = Nutella.current_app.config['app_bots']
+    bots_dir = "#{app_path}/bots/"
+    # If app bots have been started already, then do nothing
+    unless Tmux.session_exist? Tmux.app_bot_session_name app_id
+      # Start all app bots in the list into a new tmux session
+      tmux = Tmux.new app_id, nil
+      ComponentsList.for_each_component_in_dir bots_dir do |bot|
+        unless app_bots_list.nil? || !app_bots_list.include?( bot )
+          # If there is no 'startup' script output a warning (because
+          # startup is mandatory) and skip the bot
+          unless File.exist?("#{bots_dir}#{bot}/startup")
+            console.warn "Impossible to start bot #{bot}. Couldn't locate 'startup' script."
+            next
+          end
+          # Create a new window in the session for this run
+          tmux.new_app_bot_window bot
+        end
+      end
+    end
+    true
+  end
+  def self.start_run_bots( bots_list, app_path, app_id, run_id )
+    # Create a new tmux instance for this run
+    tmux = Tmux.new app_id, run_id
+    # Fetch bots dir
+    bots_dir = "#{app_path}/bots/"
+    # Start the appropriate bots
+    bots_list.each { |bot| start_run_level_bot(bots_dir, bot, tmux) }
+    true
+  end
+  #--- Private class methods --------------
+  # Cleans the pid file of a given process
+  # @param [String] pid_file_path the file storing the pid file of the process
+  # @return [Boolean] true if the pid file exists AND the process with that pid is still alive
+  def self.sanitize_pid_file( pid_file_path )
+    # Does the pid file exist?
+    # If it does we try to see if the process with that pid is still alive
+    if File.exist? pid_file_path
+      pid_file = File.open(pid_file_path, 'rb')
+      pid = pid_file.read.to_i
+      pid_file.close
+      begin
+        # If this statement doesn't throw an exception then a process with
+        # this pid is still alive so we do nothing and just return true
+        Process.getpgid pid
+        return true
+      rescue
+        # If there is an exception, there is no process with this pid
+        # so we have a stale pid file that we need to remove
+        File.delete pid_file_path
+        return false
+      end
+    end
+    # If there is no pid file, there is no process running
+    false
+  end
+  private_class_method :sanitize_pid_file
+  # Checks if port 1883 (MQTT broker port) is free
+  # or some other service is already listening on it
+  # @return [boolean] true if there is no broker listening on port 1883, false otherwise
+  def self.broker_port_free?
+    begin
+      s = TCPServer.new('0.0.0.0', 1883)
+      s.close
+    rescue
+      return false
+    end
+    true
+  end
+  private_class_method :broker_port_free?
+  # Starts a single framework component
+  # @return [boolean] true if the component has been started successfully, false otherwise
+  def self.start_framework_component( component_dir )
+    pid_file_path = "#{component_dir}/.pid"
+    return true if sanitize_pid_file pid_file_path
+    # Component is not running and there is no pid file so we try to start it
+    # and create a new pid file. Note that the pid file is created by
+    # the startup script!
+    nutella_config_file = "#{Nutella.config['config_dir']}config.json"
+    runs_list_file = "#{Nutella.config['config_dir']}runlist.json"
+    if nutella_config_file==nil || runs_list_file==nil
+      return false
+    end
+    # We are passing the configuration file and the run list files paths to the framework components
+    command = "#{component_dir}/startup #{nutella_config_file} #{runs_list_file}"
+    pid = fork
+    exec(command) if pid.nil?
+    # Give it a second so they can start properly
+    sleep 1
+    # All went well so we return true
+    true
+  end
+  private_class_method :start_framework_component
+  # Starts a run level bot
+  def self.start_run_level_bot( bots_dir, bot, tmux )
+    # If there is no 'startup' script output a warning (because
+    # startup is mandatory) and skip the bot
+    unless File.exist?("#{bots_dir}#{bot}/startup")
+      console.warn "Impossible to start bot #{bot}. Couldn't locate 'startup' script."
+      return
+    end
+    # Create a new window in the session for this run
+    tmux.new_bot_window bot
+  end
+  private_class_method :start_run_level_bot
+end