nutella_framework 0.3.1 → 0.4.0

data/lib/core/commands/compile.rb

@@ -1,21 +0,0 @@
-require 'core/run_command'
-require 'core/tmux'
-
-module Nutella
-  class Compile < RunCommand
-    @description = 'Compiles all the actors that need compilation in the project'
-    
-    def run(args=nil)
-
-      # If the current directory is not a nutella project, return
-      return unless Nutella.current_project.exist?
-      
-      # Compile all actors
-      return unless prepare_bot( Nutella.current_project.dir, 'compile', 'Compiling' )
-      
-      # Output success message
-      console.success "All actors compiled for #{Nutella.current_project.config['name']}"
-    end
-    
-  end
-end

data/lib/core/commands/dependencies.rb

@@ -1,21 +0,0 @@
-require 'core/run_command'
-require 'core/tmux'
-
-module Nutella
-  class Dependencies < RunCommand
-    @description = 'Installs the dependencies for all actors in the project'
-    
-    def run(args=nil)
-
-      # If the current directory is not a nutella project, return
-      return unless Nutella.current_project.exist?
-      
-      # Install all dependencies
-      return unless prepare_bot( Nutella.current_project.dir, 'dependencies', 'Installing dependencies for' )
-      
-      # Output success message
-      console.success "All dependencies installed for #{Nutella.current_project.config['name']}"
-    end
-    
-  end
-end

data/lib/core/commands/help.rb

@@ -1,28 +0,0 @@
-require 'core/command'
-
-module Nutella
-    
-  class Help < Command
-    @description = 'Displays what every command does and how to use it'
-  
-    def run(args=nil)
-      message=''
-      Dir["#{File.dirname(__FILE__)}/*.rb"].each do |file|
-        command = File.basename(file, File.extname(file))
-        if command.length > 7
-          message += "#{command}\t"
-        else
-          message += "#{command}\t\t"
-        end
-        message += Object::const_get("Nutella::#{command.capitalize}").description
-        message += "\n"
-      end
-      console.info message
-      console.info 'For more details on individual commands, see https://github.com/nutella-framework/nutella_framework/wiki/Nutella-Command-Line-Interface'
-    end
-    
-  end
-  
-end
-
-

data/lib/core/commands/new.rb

@@ -1,60 +0,0 @@
-require 'core/command'
-require 'fileutils'
-
-module Nutella
-  class New < Command
-    @description = 'Creates a new project'
-  
-    def run(args=nil)
-      cur_prj_dir = args[0]
-    
-      # If no other arguments, show help and quit here
-      if args.empty?
-        console.warn 'You need to specify a name for your new project'
-        return
-      end
-    
-      # Check that a directory (i.e. project) with the same name doesn't already exist
-      # If it does it looks into it to see if there is a nutella.json file and displays
-      # the proper error message
-      if File.directory? cur_prj_dir
-        if File.exist? "#{cur_prj_dir}/nutella.json"
-          console.warn "A project named #{cur_prj_dir} already exists"
-          return
-        else
-          console.warn "A directory named #{cur_prj_dir} already exists"
-          return
-        end
-      end
-    
-      # If all seems good, generate the project structure
-      create_dir_structure cur_prj_dir
-
-      # Display a nice success message and return
-      console.success "Your new project #{cur_prj_dir} is ready!"
-    end
-    
-    
-    private 
-  
-  
-    def create_dir_structure( cur_prj_dir )
-      # Create directories
-      FileUtils.mkdir_p("#{cur_prj_dir}/bots")
-      FileUtils.mkdir_p("#{cur_prj_dir}/interfaces")
-      # Create nutella.json hash
-      config_file_hash = {
-        :name => cur_prj_dir,
-        :version => '0.1.0',
-        :nutella_version => File.open("#{Nutella.config['nutella_home']}VERSION", 'rb').read,
-        :type => 'project',
-        :description => 'A quick description of your project'
-      }
-      # Write nutella.json hash
-      File.open("#{cur_prj_dir}/nutella.json", 'w') do |f|
-        f.write(JSON.pretty_generate(config_file_hash))
-      end
-    end
-  
-  end
-end

data/lib/core/commands/runs.rb

@@ -1,52 +0,0 @@
-require 'core/command'
-
-
-module Nutella
-  class Runs < Command
-    @description = 'Displays list of runs for current project or all projects'
-  
-    def run(args=nil)
-
-      # If invoked with "all" it will show all the runs under this instance of nutella
-      if args[0]=='--all' || args[0]=='-a'
-        display_all_runs
-      else
-        # If current dir is not a nutella project, return
-        return unless Nutella.current_project.exist?
-        # Display list of runs for current nutella project
-        display_project_runs
-      end
-    end
-    
-    
-    private 
-    
-    
-    def display_all_runs
-      if Nutella.runlist.empty?
-        console.info 'You are not running any projects'
-      else
-        console.info 'Currently running:'
-        Nutella.runlist.runs_by_project.each { |run| console.info " #{run}" }
-      end
-    end
-    
-    def display_project_runs
-      project_name = Nutella.current_project.config['name']
-      runs = Nutella.runlist.runs_by_project project_name
-      console.info "Currently running #{runs.length} instances of project #{project_name}:"
-      runs.each do |run|
-        run_id = run.dup
-        run_id.slice! "#{project_name}_"
-        if run==project_name
-          console.info " #{project_name} (default instance)"
-        else
-          console.info " #{run_id}"
-        end
-      end
-    end
-    
-    
-  end
-end
-

data/lib/core/commands/start.rb

@@ -1,271 +0,0 @@
-require 'core/run_command'
-require 'core/tmux'
-
-module Nutella
-  class Start < RunCommand
-    @description = 'Starts all or some of the bots in the current project'
-
-    def run(args=nil)
-
-      # 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 name is different than the project name
-      if run==Nutella.current_project.config['name']
-        console.warn 'Your run name should be different than your project name'
-        return
-      end
-
-      # Extract parameters
-      begin
-        params = extract_parameters args
-      rescue
-        console.warn 'The only supported parameters are --with (-w) and --without (-wo)'
-        return
-      end
-
-      # Check that we are not using 'with' and 'without' options at the same time
-      unless params[:with].empty? || params[:without].empty?
-        console.warn 'You can\'t use both --with and --without at the same time'
-        return
-      end
-
-      # Extract project directory
-      cur_prj_dir = Nutella.current_project.dir
-
-      # Check that there is at least a regular bot that will be started,
-      # otherwise it makes no sense to create a run
-      if bots_list_wo_project(cur_prj_dir, params).empty? && project_bots_started?
-        console.warn "Run #{run} not created: your project bots are already started and you specified no regular bots exclusively for this run"
-        return
-      end
-
-      # 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 running_on_internal_broker?
-        return unless start_internal_broker
-      end
-
-      # Start all nutella internal actors, if needed
-      return unless start_nutella_actors
-
-      # Start all project level actors, if any
-      return unless start_project_bots cur_prj_dir
-
-      # Start all bots
-      return unless start_bots( cur_prj_dir, run_id, params )
-
-      # Output success message
-      output_success_message( run_id, run, 'started' )
-      output_monitoring_details( run_id, cur_prj_dir, params)
-    end
-
-
-    private
-
-
-    def bots_list_wo_project( cur_prj_dir, params )
-      # Fetch the list of project bots
-      project_bots_list = Nutella.current_project.config['project_bots']
-      run_bots_list = run_actors_list("#{cur_prj_dir}/bots/")
-      # Depending on the mode we are in we want to start only some bots, exclude only some bots, start all bots
-      unless params[:with].empty?
-        return project_bots_list.nil? ? params[:with] : params[:with] - project_bots_list
-      end
-      unless params[:without].empty?
-        return project_bots_list.nil? ? run_bots_list - params[:without] : run_bots_list - params[:without] - project_bots_list
-      end
-      if params[:with].empty? && params[:without].empty?
-        return project_bots_list.nil? ? run_bots_list : run_bots_list - project_bots_list
-      end
-    end
-
-
-    def project_bots_started?
-      project_name = Nutella.current_project.config['name']
-      tmux_session_name = "#{project_name}-project-bots"
-      Tmux.session_exist? tmux_session_name
-    end
-
-
-    def add_to_run_list(run_id, prj_dir)
-      unless Nutella.runlist.add?( run_id, prj_dir )
-        # If the run_id is already in the list, check that it's actually live
-        if Tmux.session_exist? run_id
-          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
-      end
-      true
-    end
-
-
-    def start_internal_broker
-      pid_file_path = "#{Nutella.config['broker_dir']}bin/.pid"
-      return true if sanitize_pid_file pid_file_path
-      # Check that broker is not running unsupervised (check port)
-      unless broker_port_free?
-        console.error 'Impossible to start project: looks like a broker is already running on port 1883. Stop it before trying to start the project again'
-        return false
-      end
-      # 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(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
-      true
-    end
-
-
-    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
-      end
-      true
-    end
-
-
-    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['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
-      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 start_project_bots( cur_prj_dir )
-      project_bots_list = Nutella.current_project.config['project_bots']
-      project_name = Nutella.current_project.config['name']
-      tmux_session_name = "#{project_name}-project-bots"
-      bots_dir = "#{cur_prj_dir}/bots/"
-      # If project bots have been started already, then do nothing
-      unless Tmux.session_exist? tmux_session_name
-        # Start all project bots in the list into a new tmux session
-        tmux = Tmux.new tmux_session_name
-        for_each_actor_in_dir bots_dir do |bot|
-          unless project_bots_list.nil? || !project_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_bot_window bot
-          end
-        end
-      end
-      true
-    end
-
-
-    def start_bots( cur_prj_dir, run_id, params )
-      # Create a new tmux instance for this run
-      tmux = Tmux.new run_id
-      # Fetch bots dir
-      bots_dir = "#{cur_prj_dir}/bots/"
-      # Start the appropriate bots
-      bots_list_wo_project( cur_prj_dir, params ).each { |bot| start_bot(bots_dir, bot, tmux) }
-      true
-    end
-
-
-    def start_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 output_monitoring_details( run_id, cur_prj_dir, params )
-      project_bots_list = Nutella.current_project.config['project_bots']
-      project_name = Nutella.current_project.config['name']
-      tmux_session_name = "#{project_name}-project-bots"
-      unless project_bots_list.nil? || project_bots_list.empty?
-        console.success "Do `tmux attach-session -t #{tmux_session_name}` to monitor your project bots."
-      end
-      if bots_list_wo_project(cur_prj_dir, params).empty?
-        console.success 'No tmux session was created for this run because you specified no regular bots exclusively for this run'
-      else
-        console.success "Do `tmux attach-session -t #{run_id}` to monitor your bots."
-      end
-      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,100 +0,0 @@
-require 'core/run_command'
-require 'core/tmux'
-
-module Nutella
-  class Stop < RunCommand
-    @description = 'Stops all or some of the bots in the current project'
-
-    def run(args=nil)
-
-      # 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 project level actors (if any) if needed
-      stop_project_bots
-
-      # Stop all nutella internal actors, if needed
-      if Nutella.runlist.empty?
-        stop_nutella_actors
-      end
-
-      # If running on the internal broker, stop it if needed
-      if Nutella.runlist.empty? and running_on_internal_broker?
-        stop_broker
-      end
-
-      # Output success message
-      output_success_message( run_id, run, 'stopped' )
-    end
-  
-    
-    private
-
-    
-    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 stop_project_bots
-      project_name = Nutella.current_project.config['name']
-      tmux_session_name = "#{project_name}-project-bots"
-      if Tmux.session_exist? tmux_session_name
-        # Are there any runs of this project hinging on the project bots?
-        if Nutella.runlist.runs_by_project(project_name).empty?
-          Tmux.kill_session tmux_session_name
-        end
-      end
-      true
-    end
-
-
-    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 stop_broker
-      pid_file_path = "#{Nutella.config['broker_dir']}/bin/.pid"
-      kill_process_with_pid pid_file_path
-    end
-
-
-    # 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/run_command.rb

@@ -1,106 +0,0 @@
-require 'core/command'
-require 'slop'
-
-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 )
-
-      # Simple `nutella start/stop`
-      if args.nil? || args.empty?
-        run = nil
-        run_id = Nutella.runlist.extract_run_id( '' )
-        return run, run_id
-      end
-
-      # Check if the first argument is a parameter or a run name
-      if args[0].start_with? '-'
-        run = nil
-        run_id = Nutella.runlist.extract_run_id( '' )
-      else
-        # If it's a run name, store the run name and shift so we are left with only
-        # the parameters in args
-        run = args[0]
-        run_id = Nutella.runlist.extract_run_id( args[0] )
-        args.shift
-      end
-
-      return run, run_id
-    end
-
-
-    # Extracts the command line parameters
-    # @param [Array<String>] args command line arguments passed to the command
-    # @return [Hash]  an hash containing the parameters
-    def extract_parameters( args )
-      opts = Slop::Options.new
-      opts.array '-wo', '--without', 'A list of actors NOT to start'
-      opts.array '-w', '--with', 'A list of actors that needs to be started'
-      parser = Slop::Parser.new(opts)
-      result = parser.parse(args)
-      result.to_hash
-    end
-
-
-    # Returns all the actors in a certain directory
-    def run_actors_list( actors_dir )
-      Dir.entries(actors_dir).select {|entry| File.directory?(File.join(actors_dir, entry)) && !(entry =='.' || entry == '..') }
-    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 )
-      run_actors_list(actors_dir).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
-    
-    
-    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 'script' script
-        cur_dir = Dir.pwd
-        Dir.chdir "#{cur_prj_dir}/bots/#{bot}"
-        system "./#{script}"
-        Dir.chdir cur_dir
-      end
-      true
-    end
-
-
-    # If the broker is set to one of the current ip addresses,
-    # localhost or 127.0.0.1 return true.
-    def running_on_internal_broker?
-      broker = Nutella.config['broker']
-      Socket.ip_address_list.find_all{|a| a.ipv4? }.map{|a| a.ip_address}.include?(broker) || broker == 'localhost' || broker == '127.0.0.1'
-    end
-
-
-  end
-
-end