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

nutella_framework 0.4.5 → 0.4.8

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