nutella_framework 0.1.2 → 0.2.0

data/lib/core/commands/start.rb

@@ -1,156 +1,169 @@
-require 'core/command'
+require 'core/run_command'
 require 'core/tmux'
 
 module Nutella
-  class Start < Command
+  class Start < RunCommand
     @description = 'Starts all or some of the bots in the current project'
-  
+
     def run(args=nil)
-      # Is current directory a nutella prj?
-      return unless Nutella.currentProject.exist?
-      run_id = Nutella.runlist.extractRunId args[0]
-      # Check the runId is unique and add to the list of runs
-      return unless addToRunsList run_id
-      # Extract project directory
-      @prj_dir = Nutella.currentProject.dir
-      # If running on internal broker, start it
-      if Nutella.config['broker'] == 'localhost' # Are we using the internal broker
-        startBroker
+
+      # If the current directory is not a nutella project, return
+      return unless Nutella.current_project.exist?
+
+      # Extract run (passed run name) and run_id
+      run, run_id = extract_names args
+      # Extract project directory and run_id
+      cur_prj_dir = Nutella.current_project.dir
+
+      # Check that the run_id is unique and add it to the list of runs
+      # If it's not, return (without adding the run_id to the list of course)
+      return unless add_to_run_list( run_id, cur_prj_dir )
+
+      # If running on the internal broker, start it if needed
+      if Nutella.config['broker'] == 'localhost'
+        return unless start_internal_broker
       end
-      # Create .botsconfig file
-      deleteBotsConfig
-      createBotsConfig
-      # Start all the bots
-      installBotsDependencies(run_id)
-      compileBots(run_id)
-      startBots(run_id)
-      # Start all interfaces
-      ports = start_interfaces
-      # Start all "hidden bots"
-      start_hidden_bots
+
+      # Start all nutella internal actors, if needed
+      return unless start_nutella_actors
+
+      # Install dependencies, compile and start all bots
+      return unless prepare_bot( cur_prj_dir, 'dependencies', 'Installing dependencies for' )
+      return unless prepare_bot( cur_prj_dir, 'compile', 'Compiling' )
+      return unless start_bots( cur_prj_dir, run_id )
+
       # Output success message
-      outputSuccessMessage(run_id, args[0])
+      output_success_message( run_id, run, 'started' )
+      output_monitoring_details run_id
     end
-    
-    
+
+
     private
-    
-    
-    def addToRunsList(runid)
-      if !Nutella.runlist.add?(runid)
-        console.error 'Impossible to start project: an instance of this project with the same name is already running!'
-        console.error "You might want to kill it with 'nutella stop "+ runid + "'"
+
+
+    def add_to_run_list(run_id, prj_dir)
+      unless Nutella.runlist.add?( run_id, prj_dir )
+        console.error 'Impossible to start project: an instance of this project with the same run_id is already running!'
+        console.error "You might want to kill it with 'nutella stop #{run_id}'"
         return false
       end
-      return true
+      true
     end
-  
-  
-    def startBroker
-      pidFile = "#{Nutella.config["broker_dir"]}/bin/.pid"
-      if File.exist?(pidFile) # Does the broker pid file exist?
-        pidF = File.open(pidFile, "rb")
-        pid = pidF.read.to_i
-        pidF.close()
+
+
+    def start_internal_broker
+      pid_file_path = "#{Nutella.config['broker_dir']}bin/.pid"
+      return true if sanitize_pid_file pid_file_path
+      # Broker is not running and there is no file so we try to start
+      # and create a new pid file. Note that the pid file is created by
+      # the startup script!
+      pid = fork
+      exec("#{Nutella.config['broker_dir']}/startup") if pid.nil?
+      # Sleep a bit to give the chance to the broker to actually start up
+      sleep(0.8)
+      # 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
-          Process.getpgid(pid) #PID is still alive
-          # broker is already started and I do nothing
+          # 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
-          # broker is dead but we have a stale pid file
-          File.delete(pidFile)
-          startAndCreatePid()
+          # 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
-      else
-        # Broker is not running and there is no file
-        startAndCreatePid()
-      end 
-    end
-  
-    def startAndCreatePid()
-      pid = fork
-      exec("#{Nutella.config["broker_dir"]}/startup") if pid.nil?  
-    end
-  
-    def createBotsConfig
-      botsconfig = Nutella.config.to_h
-      botsconfig.delete(:runs)
-      botsconfig[:prj_name] = Nutella.currentProject.config["name"]
-      File.open("#{@prj_dir}/.botsconfig.json", "w") do |f|
-        f.write(JSON.pretty_generate(botsconfig))
       end
+      # If there is no pid file, there is no process running
+      false
     end
-  
-    def deleteBotsConfig
-      File.delete("#{@prj_dir}/.botsconfig.json") if File.exist?("#{@prj_dir}/.botsconfig.json")
-    end
-  
-    def installBotsDependencies(runid)
-      Dir.entries("#{@prj_dir}/bots").select {|entry| File.directory?(File.join("#{@prj_dir}/bots",entry)) and !(entry =='.' || entry == '..') }.each do |bot|
-        if !File.exist?("#{@prj_dir}/bots/#{bot}/dependencies")
-          next
+
+
+    def start_nutella_actors
+      nutella_actors_dir = "#{Nutella.config['nutella_home']}actors"
+      for_each_actor_in_dir nutella_actors_dir do |actor|
+        if File.exist? "#{nutella_actors_dir}/#{actor}/startup"
+          unless start_nutella_actor "#{nutella_actors_dir}/#{actor}"
+            return false
+          end
         end
-        console.info "Installing dependencies for bot #{bot}."
-        cur_dir = Dir.pwd
-        Dir.chdir "#{@prj_dir}/bots/#{bot}"
-        system "./dependencies"
-        Dir.chdir cur_dir
       end
+      true
     end
-    
-    def compileBots(runid)
-      Dir.entries("#{@prj_dir}/bots").select {|entry| File.directory?(File.join("#{@prj_dir}/bots",entry)) and !(entry =='.' || entry == '..') }.each do |bot|
-        if !File.exist?("#{@prj_dir}/bots/#{bot}/compile")
-          next
-        end
-        console.info "Compiling bot #{bot}."
+
+    def start_nutella_actor( actor_dir )
+      pid_file_path = "#{actor_dir}/.pid"
+      return true if sanitize_pid_file pid_file_path
+      # Actor is not running and there is no pid file so we try to start
+      # the actor and create a new pid file. Note that the pid file is created by
+      # the startup script!
+      nutella_config_file = "#{Nutella.config['nutella_home']}config.json"
+      runs_list_file = "#{Nutella.config['nutella_home']}runlist.json"
+      if nutella_config_file==nil || runs_list_file==nil
+        return false
+      end
+      command = "#{actor_dir}/startup #{nutella_config_file} #{runs_list_file}"
+      pid = fork
+      exec(command) if pid.nil?
+      # All went well so we return true
+      true
+    end
+
+
+    def prepare_bot( cur_prj_dir, script, message )
+      for_each_actor_in_dir cur_prj_dir do |bot|
+        # Skip bot if there is no '' script
+        next unless File.exist? "#{cur_prj_dir}/bots/#{bot}/#{script}"
+        # Output message
+        console.info "#{message} bot #{bot}."
+        # Execute 'dependencies' script
         cur_dir = Dir.pwd
-        Dir.chdir "#{@prj_dir}/bots/#{bot}"
-        system "./compile"
+        Dir.chdir "#{cur_prj_dir}/bots/#{bot}"
+        system "./#{script}"
         Dir.chdir cur_dir
       end
+      true
     end
-    
-    def startBots(runid)
-      @tmux = Tmux.new(runid)
-      Dir.entries("#{@prj_dir}/bots").select {|entry| File.directory?(File.join("#{@prj_dir}/bots",entry)) and !(entry =='.' || entry == '..') }.each do |bot|
-        if !File.exist?("#{@prj_dir}/bots/#{bot}/startup")
+
+
+    def start_bots( cur_prj_dir, run_id )
+      bots_dir = "#{cur_prj_dir}/bots/"
+      # Create a new tmux instance for this run
+      tmux = Tmux.new run_id
+      for_each_actor_in_dir bots_dir do |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
-        @tmux.new_bot_window(bot)
+        # Create a new window in the session for this run
+        tmux.new_bot_window bot
       end
+      true
     end
 
-    def start_interfaces
-      ports = Hash.new
-      Dir.entries("#{@prj_dir}/interfaces").select {|entry| File.directory?(File.join("#{@prj_dir}/interfaces",entry)) and !(entry =='.' || entry == '..') }.each do |iface|
-        if !File.exist?("#{@prj_dir}/interfaces/#{iface}/index.html")
-          console.warn "Impossible to start interface #{iface}. Couldn't locate 'index.html' file."
-          next
-        end
-        ports[iface] = @tmux.new_interface_window(iface)
-      end
-      ports
-    end
 
-    def start_hidden_bots
-      # p ports
-      # puts run_id
-      # Nutella.runlist.length
-      # Nutella.config['broker']
-      # Create the webpage for all interfaces
-      # Start the web_server serving the whole interfaces directory
-      # Output message that shows the port where we are connecting
-    end
-    
-    def outputSuccessMessage(runid, run)
-      if runid == Nutella.currentProject.config["name"]
-        console.success "Project " + Nutella.currentProject.config["name"] + " started. Do `tmux attach-session -t #{Nutella.currentProject.config["name"]}` to monitor your bots."
-      else
-        console.success "Project " + Nutella.currentProject.config["name"] + ", run " + run + " started"
-      end
+    def output_monitoring_details( run_id )
+      console.success "Do `tmux attach-session -t #{run_id}` to monitor your bots."
+      console.success "Go to http://localhost:#{Nutella.config['main_interface_port']}/#{run_id} to access your interfaces"
     end
-   
+
+
   end
   
 end

data/lib/core/commands/stop.rb

@@ -1,70 +1,84 @@
-require 'core/command'
+require 'core/run_command'
 require 'core/tmux'
 
 module Nutella
-  class Stop < Command
-    @description = "Stops all or some of the bots in the current project"
-    # Is current directory a nutella prj?
+  class Stop < RunCommand
+    @description = 'Stops all or some of the bots in the current project'
+
     def run(args=nil)
-      if !Nutella.currentProject.exist? 
-        return
+
+      # If the current directory is not a nutella project, return
+      return unless Nutella.current_project.exist?
+
+      # Extract run (passed run name) and run_id
+      run, run_id = extract_names args
+
+      # Check that the run_id exists in the list and, if it is not,
+      # return false
+      return unless remove_from_run_list run_id
+
+      # Stops all the bots
+      Tmux.kill_session run_id
+
+      # Stop all nutella internal actors, if needed
+      if Nutella.runlist.empty?
+        stop_nutella_actors
       end
-      runid = Nutella.runlist.extractRunId args[0]
-      # Removes the run from the list of runs if it exists
-      removeRunfromList(runid, args[0]) 
-      # Stop broker if needed
-      if Nutella.runlist.empty? and Nutella.config['broker'] == "localhost" 
-        stopBroker
+
+      # If running on the internal broker, stop it if needed
+      if Nutella.runlist.empty? and Nutella.config['broker'] == 'localhost'
+        stop_broker
       end
-      # Stops all the bots
-      Tmux.killSession(runid) 
-      # Deletes bots config file if it exists
-      deleteBotsConfigFile
+
       # Output success message
-      outputSuccessMessage(runid, args[0])
+      output_success_message( run_id, run, 'stopped' )
     end
   
     
     private
+
     
-    
-    
-    def removeRunfromList(runid, run) 
-      if Nutella.runlist.delete?(runid).nil?
-        if runid == Nutella.currentProject.config["name"]
-          console.warn "Run #{runid} doesn't exist. Impossible to stop it."
-        else
-          console.warn "Run #{run} doesn't exist. Impossible to stop it."
-        end
-        return
+    def remove_from_run_list( run_id )
+      unless Nutella.runlist.delete? run_id
+        console.warn "Run #{run_id} doesn't exist. Impossible to stop it."
+        return false
       end
+      true
     end
-  
-    def stopBroker
-      pidFile = "#{Nutella.config["broker_dir"]}/bin/.pid"
-      if File.exist?(pidFile) # Does the broker pid file exist?
-        pidF = File.open(pidFile, "rb")
-        pid = pidF.read.to_i
-        pidF.close()
-        Process.kill("SIGKILL", pid)
-        File.delete(pidFile)
+
+
+    def stop_nutella_actors
+      nutella_actors_dir = "#{Nutella.config['nutella_home']}actors"
+      for_each_actor_in_dir nutella_actors_dir do |actor|
+        pid_file_path = "#{nutella_actors_dir}/#{actor}/.pid"
+        kill_process_with_pid pid_file_path
       end
     end
-    
-    def deleteBotsConfigFile
-      prj_dir = Nutella.currentProject.dir 
-      if File.exist?("#{prj_dir}/.botsconfig.json")
-        File.delete("#{prj_dir}/.botsconfig.json") 
-      end
+
+
+    def stop_broker
+      pid_file_path = "#{Nutella.config['broker_dir']}/bin/.pid"
+      kill_process_with_pid pid_file_path
     end
-    
-    def outputSuccessMessage(runid, run)
-      if runid == Nutella.currentProject.config["name"]
-        console.success "Project #{Nutella.currentProject.config["name"]} stopped"
-      else
-        console.success "Project #{Nutella.currentProject.config["name"]}, run #{run} stopped"
+
+
+    # Does the process pid file exist?
+    # If it does we send a SIGKILL to the process with that pid
+    # to stop the process and delete the pid file
+    def kill_process_with_pid( pid_file_path )
+      if File.exist? pid_file_path
+        pid_file = File.open( pid_file_path, 'rb' )
+        pid = pid_file.read.to_i
+        pid_file.close
+        begin
+          Process.kill( 'SIGKILL', pid )
+        rescue
+          # Pid file exists but process is dead. Do nothing
+        end
+        File.delete pid_file_path
       end
     end
+
   
   end
 end

data/lib/core/nutella_core.rb

@@ -1,32 +1,43 @@
-# Include all commands
-Dir[File.dirname(__FILE__)+"/commands/*.rb"].each do |file|
+# Require all commands by iterating through all the files
+# in the commands directory
+Dir["#{File.dirname(__FILE__)}/commands/*.rb"].each do |file|
+  # noinspection RubyResolve
   require "core/commands/#{File.basename(file, File.extname(file))}"
 end
 
 module Nutella
       
-    # Execute command. Returns nil if all is good, otherwise it exceptions out
-    def Nutella.executeCommand (command, args=nil) 
-      # Check that the command exists
-      if commandExists?(command)
+    # This method executes a particular command
+    # @param command [String] the name of the command
+    # @param args [Array<String>] command line parameters passed to the command
+    def Nutella.execute_command (command, args=nil)
+      # Check that the command exists and if it does,
+      # execute its run method passing the args parameters
+      if command_exists?(command)
         Object::const_get("Nutella::#{command.capitalize}").new.run(args)
       else
         console.error "Unknown command #{command}"
       end
     end
     
-    # Check that a command exists
-    def Nutella.commandExists?(command)
+    # This method checks that a particular command exists
+    # @return [Boolean] true if the command exists, false otherwise
+    def Nutella.command_exists?(command)
       return Nutella.const_get("Nutella::#{command.capitalize}").is_a?(Class)
     rescue NameError
       return false
     end
     
-    # Initialize
+    # This method initializes the nutella configuration file (config.json) with:
+    # - NUTELLA_HOME: the directory nutella is installed in
+    # - tmp_dir: temporary directory used when installing remote templates
+    # - broker_dir: directory where the local broker is installed in
+    # - main_interface_port: the port used to serve interfaces
     def Nutella.init
-      Nutella.config["nutella_home"] = NUTELLA_HOME
-      Nutella.config["tmp_dir"] = NUTELLA_HOME+".tmp"
-      Nutella.config["broker_dir"] = NUTELLA_HOME+"broker"
+      Nutella.config['nutella_home'] = NUTELLA_HOME
+      Nutella.config['tmp_dir'] = "#{NUTELLA_HOME}.tmp/"
+      Nutella.config['broker_dir'] = "#{NUTELLA_HOME}broker/"
+      Nutella.config['main_interface_port'] = 57880
     end
 
 end

data/lib/core/run_command.rb

@@ -0,0 +1,44 @@
+require 'core/command'
+
+module Nutella
+  # This class describes a run command which can be either start or stop.
+  # It is mostly a commodity class for code reuse.
+  class RunCommand < Command
+
+    def run (args=nil)
+      console.error 'Running generic RunCommand!!! WAT?'
+    end
+
+    # Extracts run name and run_id
+    # @param [Array<String>] args command line arguments passed to the command
+    # @return [String, String ]  the run name (cleaned of nils) and the run_id
+    def extract_names( args )
+      # Check that the run name passed as parameter is not nil
+      run = args.nil? ? nil : args[0]
+      # Extract run_id
+      run_id = args.nil? ? Nutella.runlist.extract_run_id( '' ) : Nutella.runlist.extract_run_id( args[0] )
+      return run, run_id
+    end
+
+    # Executes a code block for each actor in a certain directory
+    # @param [String] actors_dir directory where we are iterating
+    # @yield [actor_dir] Gives the actor directory to the block
+    def for_each_actor_in_dir( actors_dir, &block )
+      Dir.entries(actors_dir).select {|entry| File.directory?(File.join(actors_dir, entry)) && !(entry =='.' || entry == '..') }.each do |actor_dir|
+        block.call actor_dir
+      end
+    end
+
+
+    def output_success_message(run_id, run, action)
+      if run_id == Nutella.current_project.config['name']
+        console.success "Project #{Nutella.current_project.config['name']} #{action}!"
+      else
+        console.success "Project #{Nutella.current_project.config['name']}, run #{run} #{action}!"
+      end
+    end
+
+
+  end
+
+end

data/lib/core/tmux.rb

@@ -2,26 +2,27 @@ module Nutella
   
   class Tmux
   
-    def initialize(runId)
-      @runId = runId
+    def initialize( run_id )
+      @run_id = run_id
     end
   
-    def new_bot_window(bot)
-      if !defined?(@sessions)
+    def new_bot_window( bot )
+      if defined? @sessions
+        # If a session already exists,
+        # simply create a new window for 'bot'.
+        # -k destroys the window if it can't be created
+        # Print info about creation of window
+        `tmux new-window -kP -n #{bot} &> /dev/null`
+        @sessions.push bot
+      else
         # If there is no sessions, let's create one and, at the same time, create a new window for the bot
-        `tmux new-session -d -s #{@runId} -n #{bot} &> /dev/null`
+        `tmux new-session -d -s #{@run_id} -n #{bot} &> /dev/null`
         @sessions = [bot]
-      else
-        # Create new window for `bot`
-        # -k destroys it if it can't be created
-        # Pring info about creation of window
-      	`tmux new-window -kP -n #{bot} &> /dev/null` 
-        @sessions.push(bot)
       end
       # Select window
-    	`tmux select-window -t #{@runId}:#{@sessions.length-1} &> /dev/null`
+    	`tmux select-window -t #{@run_id}:#{@sessions.length-1} &> /dev/null`
       # Start bot
-      `tmux send-keys "cd bots/#{bot};./startup #{@runId} #{Nutella.config["broker"]}" C-m`
+      `tmux send-keys "cd bots/#{bot};./startup #{@run_id} #{Nutella.config['broker']}" C-m`
     end
 
     def new_interface_window( iface )
@@ -31,15 +32,16 @@ module Nutella
       `tmux new-window -kP -n #{iface} &> /dev/null`
       @sessions.push(iface)
       # Select window
-      `tmux select-window -t #{@runId}:#{@sessions.length-1} &> /dev/null`
-      port = 57880+@sessions.length
+      `tmux select-window -t #{@run_id}:#{@sessions.length-1} &> /dev/null`
+      port = Nutella.config['main_interface_port'] + @sessions.length
+      url = "http://localhost:#{port}/index.html"
       # Start serving interface
       `tmux send-keys "cd interfaces/#{iface};thin -R #{Nutella.config['nutella_home']}/lib/extra/config.ru -p #{port.to_s} start" C-m`
-      port
+      url
     end
 
-    def self.killSession(runId)
-      `tmux kill-session -t #{runId} &> /dev/null`
+    def self.kill_session( run_id )
+      `tmux kill-session -t #{run_id} &> /dev/null`
     end
       
   end

data/lib/logging/nutella_logging.rb

@@ -8,9 +8,9 @@ module Nutella
     include Singleton
     
     def initialize
-      console = NutellaLogger.new("console")
-      log = NutellaLoggerRemote.new("log")
-      @loggers = {"log" => log, "console" => console}
+      console = NutellaLogger.new('console')
+      log = NutellaLoggerRemote.new('log')
+      @loggers = {:log => log, :console => console}
     end
     
     def logger(name)
@@ -25,11 +25,11 @@ end
 module Kernel
   
   def console
-    Nutella::NutellaLogging.instance.logger('console')
+    Nutella::NutellaLogging.instance.logger(:console)
   end
   
   def log
-    Nutella::NutellaLogging.instance.logger('log')
+    Nutella::NutellaLogging.instance.logger(:log)
   end
   
 end

data/lib/nutella_framework.rb

@@ -1,15 +1,17 @@
-# Nutella main script
+# Import all the modules
 require 'logging/nutella_logging'
 require 'core/nutella_core'
-require 'cli/nutella_cli'
 require 'config/config'
 require 'config/runlist'
-require 'config/project'
+require 'config/current_project'
+require 'cli/nutella_cli'
 
 module Nutella
-  NUTELLA_HOME = File.dirname(__FILE__)+"/../"
-  
-  # Store some constants and defaults in the configuration file
+  home_dir = File.dirname(__FILE__)
+  NUTELLA_HOME = home_dir[0..-4]
+
+  # If the nutella configuration file (config.json) is empty (or doesn't exist) we're going to initialize it
+  # with nutella constants and defaults
   if Nutella.config.empty?
     Nutella.init
   end