ant_hill 0.3.1

data/lib/ant_hill/creep_modifier.rb

@@ -0,0 +1,150 @@
+module AntHill
+
+  # Base class for setup/run logic
+  # Childrens should implement specific logic for particular ant type
+  class CreepModifier
+
+    # Creep object
+    attr_reader :creep
+
+    include DRbUndumped
+
+    # Initialize 
+    # +creep+:: Creep which we gonna change
+    def initialize(creep)
+      @creep = creep
+    end
+
+    # Find diff between current params of creep and ant params
+    def find_diff(ant)
+      diff = {}
+      ant_config = ant.params
+      creep_config = creep.current_params
+
+      ant_config.each_key{|k|
+        diff[k] = ant_config[k] unless ant_config[k] == creep_config[k]
+      }
+      diff
+    end
+    
+    # Run ant
+    # +ant+:: ant to run
+    def run_ant(ant)
+      begin
+        before_run(ant)
+      rescue => e
+        logger.error "Error during run ant_started method: #{e} \n #{e.backtrace}"
+      end
+      begin
+        out = run(ant)
+        ant.output = out
+      rescue => e
+        logger.error "Error during processing run method: #{e} \n #{e.backtrace}"
+      ensure
+        begin
+          after_run(ant)
+        rescue => e
+          logger.error "Error in ant_finished method: #{e} \n #{e.backtrace}"
+        end
+      end
+    end
+
+    # Setup ant for running
+    # +ant+:: Ant to setup
+    def setup_ant(ant)
+      ant.runner = creep
+      ant.change_status(:setup)
+      begin
+        before_setup(ant)
+      rescue => e
+        logger.error "Error during processing before_setup method: #{e} \n #{e.backtrace}"
+      end
+      result = nil
+      begin 
+        result = setup(ant)
+      rescue => e
+        logger.error "Error during processing setup method: #{e} \n #{e.backtrace}"
+      end
+      begin
+        after_setup(ant)
+      rescue => e
+        logger.error "Error during processing after_setup method: #{e} \n #{e.backtrace}"
+      end
+      result
+    end
+
+    # Logger for creep
+    def logger
+      creep.logger
+    end
+
+    # Return calculated setup time for ant
+    # +ant+:: ant to setup
+    # Can be redefined in child class
+    def get_setup_time(ant)
+    end
+   
+    # Return calculated run time for ant
+    # +ant+:: ant to run
+    # Can be redefined in child class
+    def get_run_time(ant)
+    end
+
+    # Before run hook 
+    # +ant+:: ant to run
+    def before_run(ant)
+    end
+
+    # After run hook 
+    # +ant+:: ant was ran
+    def after_run(ant)
+    end
+
+    # Before setup hook 
+    # +ant+:: ant to setup
+    def before_setup(ant)
+    end
+
+    # After setup hook 
+    # +ant+:: ant was set up
+    def after_setup(ant)
+    end
+
+    # Setup failed hook 
+    # +ant+:: ant for wich setup failed
+    def setup_failed(ant)
+    end
+
+    # Before process hook 
+    # +ant+:: ant to be processed
+    def before_process(ant)
+    end
+
+    # After process hook 
+    # +ant+:: ant was processed
+    def after_process(ant)
+    end
+
+    # Setup implementation
+    # +ant+:: ant to set up
+    def setup(ant)
+      true
+    end
+
+    # Run implementation
+    # +ant+:: ant to run
+    def run(ant)
+    end
+
+    # Check node is set up 
+    # +ant+:: ant to check
+    def check(ant)
+      true
+    end
+
+    # Params from ant to be coppied after setup
+    def creep_params
+    end
+  end
+
+end

data/lib/ant_hill/log.rb

@@ -0,0 +1,35 @@
+module AntHill
+  # Log class
+  class Log
+    include DRbUndumped
+    # Singleton class
+    class << self
+      @@loggers = {}
+      # Return logger for specified name
+      def logger_for(name, config = Configuration.config)
+        return @@loggers[name] if @@loggers[name]
+        verbose = config.log_level
+        path = config.log_dir
+        FileUtils.mkdir_p path unless File.exists?(path)
+        logger = Logger.new(path+"/#{name}.log", (config.log_num_old_files) || 5, (config.log_size || 50*1024*1024) )
+        logger.level = level(config.log_level)
+        logger.formatter = Logger::Formatter.new
+        @@loggers[name] = logger 
+      end
+      private
+      # Convert symbol log level to Logger log level
+      #
+      def level(level)
+        case level
+        when :fatal then Logger::FATAL
+        when :error then Logger::ERROR
+        when :warn then Logger::WARN
+        when :info then Logger::INFO
+        when :debug then Logger::DEBUG
+        else Logger::ERROR
+        end
+      end
+    end
+
+  end
+end

data/lib/ant_hill/queen.rb

@@ -0,0 +1,334 @@
+module AntHill
+  # Main class that rule all the kingdom
+  class Queen
+    # +creeps+:: list of creeps
+    # +ants+:: list of ants
+    # +colonies+:: list of colonies
+    attr_reader :creeps, :ants, :colonies
+
+    # Default host for DRb
+    DRB_HOST = '127.0.0.1'
+    # Default port for DRb
+    DRB_PORT = 6666
+    
+    include DRbUndumped
+
+    # Initialize
+    # +config+:: Configuration object
+    def initialize(config = Configuration.config)
+      @config = config
+      @ants = []
+      @colony_queue = []
+      @colonies = []
+      @drb_host = config.drb_host
+      @drb_port = config.drb_port
+      @@mutex = Mutex.new
+      trap("INT") do
+        puts "Terminating... Pls wait"
+        @creeps.each{|c|  c.kill_connections  }
+        @threads.each{|th| th.exit  }
+      end
+      @active = true
+      @loaded_params = {}
+    end
+
+    # Return ants size
+    def size
+      @ants.size
+    end
+
+    # Service method
+    def service
+      @threads = []
+      spawn_creeps(@config.creeps)
+      spawn_drb_queen
+      spawn_colonies_processor
+      at_exit do
+        save_queen(@config.queen_filename || "queen.yml")
+      end
+      @threads.each{|t| t.join}
+    rescue => e
+      logger.error "There was an error in queen. Details: #{e}\n#{e.backtrace.join("\n")}"
+    end
+
+    # Create colony
+    # +params+:: params for colony
+    # +loaded_params+:: loaded params for respawning queen
+    def create_colony(params={}, loaded_params = nil)
+      type = params['type']
+      type = loaded_params[:params]['type'] if loaded_params
+      colony_class = @config.ant_colony_class(type)
+      if colony_class
+        colony = colony_class.new(params)
+        colony.from_hash(loaded_params) if loaded_params
+        @colony_queue << colony unless loaded_params
+        @colonies << colony
+      else
+        logger.error "Couldn't process request #{params} because of previous errors"
+      end
+      colony
+    end
+
+    # Initialize and start threads for each creep
+    # +creeps+: array of hashes with creep params
+    #   Example: [{'name' => 'creep1', 'host'=> 'hostname', 'user' => 'login_user', 'password' => 'user_password'}]
+    def spawn_creeps(creeps)
+      @creeps = []
+      loaded_params = @loaded_params[:creeps]
+      creeps.each do |creep_config|
+        creep_loaded = loaded_params && loaded_params.find{|cr| cr[:hill_cfg]['name'] == creep_config['name'] } || {}
+        add_creep(creep_config, creep_loaded)
+      end
+    end
+
+    # Adding new creep and creatinf thread for it
+    # +creep_config+:: hash of params for creep
+    #   Example: {'name' => 'creep1', 'host'=> 'hostname', 'user' => 'login_user', 'password' => 'user_password'}
+    # +creep_loaded+:: creep loaded from saved file 
+    def add_creep(creep_config, creep_loaded={})
+      @threads << Thread.new{
+        c = Creep.new
+        c.configure(creep_config)
+        c.from_hash(creep_loaded)
+        @creeps << c
+        Thread.current["name"]=c.to_s
+        c.service
+      }
+    end
+
+    # Delete creep
+    # +creep_name+:: creep name to delete
+    # +graceful+:: default true, if true finish processing before delete
+    def delete_creep(creep_name, graceful=true)
+      creep = @creeps.find{|c| c.name.to_s =~ /#{creep_name}/}
+      thread = @threads.find{|t| t['name'] == creep.to_s} if creep
+      if graceful
+        creep.disable!
+        while creep.busy? do
+          sleep 1
+        end
+      end
+      thread.terminate if thread
+      @threads.delete(thread) if thread
+      @creeps.delete(creep) if creep
+    end
+
+    # Create drb interface for queen
+    def spawn_drb_queen
+      @threads << Thread.new{
+        begin 
+          Thread.current["name"]="main"
+          DRb.start_service "druby://#{@drb_host || DRB_HOST}:#{@drb_port || DRB_PORT}", self
+          DRb.thread.join
+        rescue => e
+          logger.error "There was an error in drb_queen =(. Details: #{e}\n#{e.backtrace}"
+        end
+      }
+    end
+
+    # Create thread for processing new colonies
+    def spawn_colonies_processor
+      @threads << Thread.new{
+        Thread.current["name"]="colony queue processor"
+        while true do
+          if @active
+            @colony_processor_busy = true
+            colony = @colony_queue.shift
+            if colony
+              new_ants = colony.get_ants
+              add_ants(new_ants)
+            end
+            @colony_processor_busy = false
+          end
+          sleep 1
+        end
+      }
+    end
+ 
+    # Add new ants to queue
+    def add_ants(ants)
+      @ants += ants
+    end
+    
+    # Find ant for creep
+    # +creep+:: creep to find ant
+    def find_ant(creep)
+      return nil if @ants.empty?
+      winner = nil
+      @@mutex.synchronize{
+        winner = max_priority_ant(creep)
+        @ants.delete(winner) if winner
+      }
+      winner
+    end
+
+    # Return ant with max priority for creep
+    # +creep+:: creep object
+    def max_priority_ant(creep)
+      max_ant = nil
+      max_priority =-Float::INFINITY
+      @ants.each do |a|
+        next if a.prior < max_priority
+        if (prior=a.priority_cache(creep)) > max_priority
+          max_priority = prior
+          max_ant = a
+        end
+      end
+      max_ant
+    rescue NoFreeConnectionError => e
+      logger.error "Couldn't find any free connection for creep #{creep}. #{e}: #{e.backtrace.join("\n")}"
+      creep.disable!
+      nil
+    end
+
+    # Reset priority for specified creep for all ants
+    def reset_priority_for_creep(creep)
+      @ants.each{|a| a.delete_cache_for_creep(creep)}
+    end
+
+    # Return logger for queen
+    def logger
+      Log.logger_for(:queen)
+    end
+
+    # Suspend all processing and wait while it's done 
+    def suspend
+      @active = false
+      while creeps.any?{|creep| creep.busy? }
+        sleep 1
+      end
+      while @colony_processor_busy
+        sleep 1
+      end
+    end
+
+    # Release all processing
+    def release
+      @active = true
+    end
+
+    # Find colonies for params
+    # +params+:: hash of params to match colony
+    def find_colonies(params)
+      @colonies.select do |colony| 
+        colony.is_it_me?(params)
+      end
+    end
+
+    # Kill colonies matching params
+    # +params+:: hash of params
+    def kill_colony(params)
+      if params.is_a?(AntColony)
+        to_kill = [ params ]
+      else
+        to_kill = find_colonies(params)
+      end
+      @@mutex.synchronize{
+        to_kill.each do |colony|
+          colony.kill
+          @ants.reject!{|ant|
+            ant.colony == colony
+          }
+          @colonies.delete(colony)
+        end
+      }
+    end
+
+    # Save queen to file
+    # +filename+:: filename to store queen data
+    def save_queen(filename)
+      queen_hash = to_hash
+      File.open(filename, "w+") { |f| f.puts queen_hash.to_yaml}
+    end
+
+    # Restore queen from file
+    # +filename+:: filenme with queen data
+    def restore_queen(filename)
+      hash = YAML::load_file(filename)
+      @loaded_params = hash
+      from_hash(hash)
+    end
+
+    # Initialize queen from loaded hash
+    # +hash+:: queen hash
+    def from_hash(hash)
+      colonies = hash[:colonies]
+      tmp = {}
+      @config.from_hash(hash[:configuration])
+      colonies.each do |col|
+        colony = create_colony({},col)
+        tmp[col[:id]] = colony
+      end
+      @colonies.each{|c| add_ants(c.ants)}
+      @colony_queue = hash[:colony_queue].collect{|cq| tmp[cq]}
+    end
+
+    # Convert queen to hash
+    # +include_finished+:: should finished colonies and ants be includes to hash?
+    def to_hash(include_finished = false)
+      {
+        :colonies => @colonies.collect{|ac| ac.to_hash(include_finished) },
+        :colony_queue => @colony_queue.collect{|ac| ac.object_id },
+        :creeps => @creeps.collect{|c| c.to_hash },
+        :configuration => @config.to_hash 
+      }
+    end
+
+    # Check if queen is active
+    def active?; @active; end
+
+    # Singleton object
+    class << self
+      # Check if mutex is locked
+      def locked?
+        @@mutex.locked?
+      end
+
+      # Return or create current queen
+      def queen
+        @@queen ||= self.new
+      end
+
+      # Connect to DRb interface of queen
+      # +host+:: host where DRb is started
+      def drb_queen(host = 'localhost')
+        DRb.start_service
+        queen = DRbObject.new_with_uri "druby://#{host}:6666"
+      rescue => e
+        puts e
+      end
+
+      # Creates colony for arguments
+      # +args+:: command line arguments
+      # +host+:: DRb queen host
+      def create_colony(args, host = 'localhost')
+        drb_queen(host).create_colony parse_args(args)
+      end
+
+      # Return list of creeps
+      # +host+:: DRb queen host
+      def creeps(host = 'localhost')
+        drb_queen(host).creeps
+      end
+
+      # Kill colony(colonies) matching arguments
+      # +args+:: command line arguments
+      # +host+:: DRb queen host
+      def kill_colony(args, host = 'localhost')
+        drb_queen(host).kill_colony parse_args(args)
+      end
+
+      private
+      # Convert command line arguments to hash
+      # +args+:: command line arguments
+      def parse_args(args)
+        result = {}
+        args.each do |arg|
+          pair = arg.split("=")
+          result[pair[0]]=pair[1]
+        end
+        result
+      end
+    end
+  end
+end