naf 2.1.10 → 2.1.11

data/RELEASE_NOTES.rdoc

@@ -1,5 +1,17 @@
 = Release Notes
 
+=== Version 2.1.11
+Bug fixes:
+* Runner behaves correctly when it tries to delete a non-existing running job
+* Adding application schedule prerequisites works correctly
+* Log display outputs custom message when record id is not present
+
+Changes:
+* Only show affinities associated with machines that are not deleted
+* Runner will cleanup other runners after they are dead
+* Machine manager updates machines row if server address or server name match
+* Improvements on naf runner script
+
 === Version 2.1.10
 Bug fixes:
 * LogArchiver correctly removes files and directories

data/app/controllers/naf/log_parsers_controller.rb

@@ -3,10 +3,18 @@ module Naf
 
     def logs
       if naf_cookie_valid?
-        response = params['logical_type'].constantize.new(params).logs
-        if response.present?
-          success = true
+        if params['record_id'].present?
+          response = params['logical_type'].constantize.new(params).logs
+
+          if response.present?
+            success = true
+          else
+            success = false
+          end
         else
+          response = {
+            logs: '&nbsp;&nbsp;<span>Record id is not present</br></span>'
+          }
           success = false
         end
 

data/app/controllers/naf/log_viewer_controller.rb

@@ -1,8 +1,8 @@
 module Naf
   class LogViewerController < Naf::ApplicationController
 
-  	def index
-       if params['record_type'] == 'job'
+    def index
+      if params['record_type'] == 'job'
         @job = ::Naf::HistoricalJob.find_by_id(params['record_id'].to_i)
         @status = ::Logical::Naf::Job.new(@job).status
         @partial = 'job_logs'

data/app/models/logical/naf/construction_zone/boss.rb

@@ -18,17 +18,43 @@ module Logical::Naf::ConstructionZone
       work_order = ApplicationWorkOrder.new(application,
                                             application_run_group_restriction,
                                             application_run_group_name,
-                                            application_run_group_limit = 1,
-                                            priority = 0,
-                                            affinities = [],
-                                            prerequisites = [],
-                                            enqueue_backlogs = false)
+                                            application_run_group_limit,
+                                            priority,
+                                            affinities,
+                                            prerequisites,
+                                            enqueue_backlogs)
       @foreman.enqueue(work_order)
     end
 
-    def enqueue_application_schedule(application_schedule)
-      work_order = ApplicationScheduleWorkOrder.new(application_schedule)
-      @foreman.enqueue(work_order)
+    def enqueue_application_schedule(application_schedule, schedules_queued_already = [])
+      prerequisite_jobs = []
+
+      # Check if schedule has been queued
+      if schedules_queued_already.include? application_schedule.id
+        raise ::Naf::HistoricalJob::JobPrerequisiteLoop.new(application_schedule)
+      end
+
+      # Keep track of queued schedules
+      schedules_queued_already << application_schedule.id
+      # Queue application schedule prerequisites
+      application_schedule.prerequisites.each do |application_schedule_prerequisite|
+        job = enqueue_application_schedule(application_schedule_prerequisite, schedules_queued_already)
+        if job.present?
+          prerequisite_jobs << job
+        else
+          return
+        end
+      end
+
+      # Queue the application
+      return enqueue_application(application_schedule.application,
+                                 application_schedule.application_run_group_restriction,
+                                 application_schedule.application_run_group_name,
+                                 application_schedule.application_run_group_limit,
+                                 application_schedule.priority,
+                                 application_schedule.affinities,
+                                 prerequisite_jobs,
+                                 application_schedule.enqueue_backlogs)
     end
 
     def enqueue_rails_command(command,

data/app/models/logical/naf/log_parser/job.rb

@@ -46,6 +46,8 @@ module Logical::Naf
             return retrieve_log_files_from_s3
           end
         else
+          return [] unless record_id.present?
+
           files = Dir["#{::Naf::PREFIX_PATH}/#{::Naf.schema_name}/jobs/#{record_id}/*"]
           if files.present?
             # Sort log files based on time

data/app/models/naf/affinity.rb

@@ -51,8 +51,17 @@ module Naf
       where(selectable: true)
     end
 
+    def self.deleted_machine_affinities
+      joins(:affinity_classification).
+      joins("INNER JOIN #{Naf.schema_name}.machines AS m
+        ON CAST (m.id AS TEXT) = #{Naf.schema_name}.affinities.affinity_name").
+      where("#{Naf.schema_name}.affinity_classifications.affinity_classification_name = 'machine' AND
+        m.deleted IS TRUE")
+    end
+
     def self.names_list
-      selectable.map do |a|
+      # Don't include affinity that is associated with a deleted machine
+      (selectable - deleted_machine_affinities).map do |a|
         classification = a.affinity_classification
         if classification.affinity_classification_name == 'machine'
           if a.affinity_short_name.present?

data/app/models/naf/historical_job.rb

@@ -313,5 +313,13 @@ module Naf
       application_type.spawn(self)
     end
 
+    def lock_for_runner_use(&block)
+      advisory_lock(&block)
+    end
+
+    def unlock_for_runner_use
+      advisory_unlock
+    end
+
   end
 end

data/app/models/naf/running_job.rb

@@ -1,5 +1,7 @@
 module Naf
   class RunningJob < NafBase
+    include PgAdvisoryLocker
+
     # Protect from mass-assignment issue
     attr_accessible :application_id,
                     :application_schedule_id,
@@ -117,6 +119,13 @@ module Naf
       self.save!
     end
 
+    def lock_for_runner_use(&block)
+      advisory_lock(&block)
+    end
+
+    def unlock_for_runner_use
+      advisory_unlock
+    end
 
   end
 end

data/app/models/process/naf/machine_manager.rb

@@ -28,9 +28,15 @@ module Process::Naf
         machine = ::Naf::Machine.find_by_server_address(@server_address)
         if machine.blank?
           server_name = (`hostname`).strip
-          machine = ::Naf::Machine.create(server_address: @server_address,
-                                          server_name: server_name)
-          add_default_affinities(machine)
+          machine = ::Naf::Machine.find_by_server_name(server_name)
+          if machine.blank?
+            machine = ::Naf::Machine.create(server_address: @server_address,
+                                            server_name: server_name)
+            add_default_affinities(machine)
+          else
+            machine.server_address = @server_address
+            machine.save!
+          end
         end
 
         machine.server_note = @server_note unless @server_note.nil?

data/app/models/process/naf/runner.rb

@@ -4,7 +4,8 @@ module Process::Naf
   class Runner < ::Af::Application
 
     attr_accessor :machine,
-                  :current_invocation
+                  :current_invocation,
+                  :last_cleaned_up_processes
 
     #----------------
     # *** Options ***
@@ -64,14 +65,13 @@ module Process::Naf
       @machine = ::Naf::Machine.find_by_server_address(@server_address)
 
       unless machine.present?
-        logger.fatal "This machine is not configued correctly (ipaddress: #{@server_address})."
-        logger.fatal "Please update #{::Naf::Machine.table_name} with an entry for this machine."
+        logger.fatal escape_html("This machine is not configued correctly (ipaddress: #{@server_address}).")
+        logger.fatal escape_html("Please update #{::Naf::Machine.table_name} with an entry for this machine.")
         logger.fatal "Exiting..."
         exit 1
       end
 
-      machine.lock_for_runner_use
-      begin
+      machine.lock_for_runner_use do
         cleanup_old_processes
         remove_invalid_running_jobs
         wind_down_runners
@@ -85,8 +85,6 @@ module Process::Naf
           create!({ machine_runner_id: machine_runner.id,
                     pid: Process.pid,
                     uuid: @invocation_uuid }.merge!(retrieve_invocation_information))
-      ensure
-        machine.unlock_for_runner_use
       end
 
       begin
@@ -99,14 +97,17 @@ module Process::Naf
     end
 
     def remove_invalid_running_jobs
+      logger.debug "looking for invalid running jobs"
       ::Naf::RunningJob.
         joins("INNER JOIN #{Naf.schema_name}.historical_jobs AS hj ON hj.id = #{Naf.schema_name}.running_jobs.id").
         where('finished_at IS NOT NULL AND hj.started_on_machine_id = ?', @machine.id).readonly(false).each do |job|
+          logger.debug escape_html("removing invalid job #{job.inspect}")
           job.delete
       end
     end
 
     def check_gc_configurations
+      logger.debug "checking garbage collection configurations"
       unless @disable_gc_modifications
         # These configuration changes will help forked processes, not the runner
         ENV['RUBY_HEAP_MIN_SLOTS'] = '500000'
@@ -116,9 +117,11 @@ module Process::Naf
       end
     end
 
-    def cleanup_old_processes
-      machine.machine_runners.each do |runner|
-        runner.machine_runner_invocations.recently_marked_dead(24.hours).each do |invocation|
+    def cleanup_old_processes(created_at_interval = 1.month, marked_dead_interval = 24.hours)
+      @last_cleaned_up_processes = Time.zone.now
+      logger.debug "cleaning up old processes"
+      ::Naf::MachineRunner.where("created_at >= ?", Time.zone.now - created_at_interval).each do |runner|
+        runner.machine_runner_invocations.recently_marked_dead(marked_dead_interval).each do |invocation|
           terminate_old_processes(invocation)
         end
       end
@@ -130,11 +133,11 @@ module Process::Naf
           if invocation.dead_at.blank?
             begin
               retval = Process.kill(0, invocation.pid)
-              logger.detail "#{retval} = kill(0, #{invocation.pid}) -- process alive, marking runner invocation as winding down"
+              logger.detail escape_html("#{retval} = kill(0, #{invocation.pid}) -- process alive, marking runner invocation as winding down")
               invocation.wind_down_at = Time.zone.now
               invocation.save!
             rescue Errno::ESRCH
-              logger.detail "ESRCH = kill(0, #{invocation.pid}) -- marking runner invocation as not running"
+              logger.detail escape_html("ESRCH = kill(0, #{invocation.pid}) -- marking runner invocation as not running")
               invocation.dead_at = Time.zone.now
               invocation.save!
               terminate_old_processes(invocation)
@@ -211,6 +214,7 @@ module Process::Naf
         return false
       end
 
+      logger.debug "marking machine alive"
       machine.mark_alive
 
       check_log_level
@@ -227,6 +231,7 @@ module Process::Naf
       end
 
       cleanup_dead_children
+      cleanup_old_processes(1.week, 75.minutes) if (Time.zone.now - @last_cleaned_up_processes) > 1.hour
 
       return true
     end
@@ -298,7 +303,7 @@ module Process::Naf
             logger.warn e
             pid = @children.first.try(:first)
             status = nil
-            logger.warn "pulling first child off list to clean it up: pid=#{pid}"
+            logger.warn escape_html("pulling first child off list to clean it up: pid=#{pid}")
           end
 
           if pid
@@ -327,7 +332,7 @@ module Process::Naf
     def check_dead_children_not_exited_properly
       dead_children = []
       @children.each do |pid, child|
-        unless is_job_process_alive?(child.reload)
+        unless is_job_process_alive?(child)
           dead_children << child
         end
       end
@@ -346,27 +351,25 @@ module Process::Naf
         child_job.remove_tags([::Naf::HistoricalJob::SYSTEM_TAGS[:work]])
 
         if status.nil? || status.exited? || status.signaled?
-          logger.info { escape_html("cleaning up dead child: #{child_job.reload}") }
+          logger.info { escape_html("cleaning up dead child: #{child_job.inspect}") }
           finish_job(child_job,
                      { exit_status: (status && status.exitstatus), termination_signal: (status && status.termsig) })
         else
           # this can happen if the child is sigstopped
-          logger.warn escape_html("child waited for did not exit: #{child_job}, status: #{status.inspect}")
+          logger.warn escape_html("child waited for did not exit: #{child_job.inspect}, status: #{status.inspect}")
         end
       else
         # XXX ERROR no child for returned pid -- this can't happen
-        logger.warn "child pid: #{pid}, status: #{status.inspect}, not managed by this runner"
+        logger.warn escape_html("child pid: #{pid}, status: #{status.inspect}, not managed by this runner")
       end
     end
 
     def start_new_jobs
-      # start new jobs
-      logger.detail "starting new jobs, num children: #{@children.length}/#{machine.thread_pool_size}"
-      # XXX while @children.length < machine.thread_pool_size && memory_available_to_spawn? && current_invocation.wind_down_at.blank?
+      logger.detail escape_html("starting new jobs, num children: #{@children.length}/#{machine.thread_pool_size}")
       while ::Naf::RunningJob.where(started_on_machine_id: machine.id).count < machine.thread_pool_size &&
         memory_available_to_spawn? && current_invocation.wind_down_at.blank?
 
-        logger.debug_gross "fetching jobs because: children: #{@children.length} < #{machine.thread_pool_size} (poolsize)"
+        logger.debug_gross escape_html("fetching jobs because: children: #{@children.length} < #{machine.thread_pool_size} (poolsize)")
         begin
           running_job = @job_fetcher.fetch_next_job
 
@@ -384,12 +387,12 @@ module Process::Naf
             running_job.historical_job.pid = pid
             running_job.historical_job.failed_to_start = false
             running_job.historical_job.machine_runner_invocation_id = current_invocation.id
-            logger.info escape_html("job started : #{running_job}")
             running_job.save!
             running_job.historical_job.save!
+            logger.info escape_html("job started : #{running_job.inspect}")
           else
             # should never get here (well, hopefully)
-            logger.error escape_html("#{machine}: failed to execute #{running_job}")
+            logger.error escape_html("#{machine}: failed to execute #{running_job.inspect}")
 
             finish_job(running_job, { failed_to_start: true })
           end
@@ -404,7 +407,7 @@ module Process::Naf
       logger.debug_gross "done starting jobs"
     end
 
-    # XXX update_all doesn't support "from_partition" so we have this helper
+    # update_all doesn't support "from_partition" so we have this helper
     def update_historical_job(updates, historical_job_id)
       updates[:updated_at] = Time.zone.now
       update_columns = updates.map{ |k,v| "#{k} = ?" }.join(", ")
@@ -420,14 +423,25 @@ module Process::Naf
     end
 
     def finish_job(running_job, updates = {})
-      if running_job.present?
-        running_job.remove_all_tags
-        running_job.add_tags([::Naf::HistoricalJob::SYSTEM_TAGS[:cleanup]])
-      end
-
-      ::Naf::HistoricalJob.transaction do
-        update_historical_job(updates.merge({ finished_at: Time.zone.now }), running_job.id)
-        running_job.delete
+      # Check to see if running job still exists
+      job = ::Naf::RunningJob.find_by_id(running_job.id)
+      if job.present?
+        job.lock_for_runner_use do
+          ::Naf::HistoricalJob.transaction do
+            update_historical_job(updates.merge({ finished_at: Time.zone.now }), job.id)
+            job.delete
+          end
+        end
+      else
+        job = ::Naf::HistoricalJob.find_by_id(running_job.id)
+        # This does not seem to be need, but just for extra measure
+        if job.present?
+          job.lock_for_runner_use do
+            ::Naf::HistoricalJob.transaction do
+              update_historical_job(updates.merge({ finished_at: Time.zone.now }), job.id)
+            end
+          end
+        end
       end
     end
 
@@ -439,7 +453,10 @@ module Process::Naf
       @children.clone.each do |pid, child|
         send_signal_and_maybe_clean_up(child, "TERM")
       end
+
+      # Wait 2 seconds
       sleep(2)
+
       @children.clone.each do |pid, child|
         send_signal_and_maybe_clean_up(child, "KILL")
 
@@ -456,9 +473,10 @@ module Process::Naf
         logger.detail "no jobs to remove"
         return
       end
+
       logger.info "number of old jobs to sift through: #{jobs.length}"
       jobs.each do |job|
-        logger.detail escape_html("job still around: #{job}")
+        logger.detail escape_html("job still around: #{job.inspect}")
         if job.request_to_terminate == false
           logger.warn "politely asking process: #{job.pid} to terminate itself"
           job.request_to_terminate = true
@@ -482,7 +500,7 @@ module Process::Naf
         return
       end
       jobs.each do |job|
-        logger.warn escape_html("sending SIG_TERM to process: #{job}")
+        logger.warn escape_html("sending SIG_TERM to process: #{job.inspect}")
         send_signal_and_maybe_clean_up(job, "TERM")
       end
 
@@ -496,7 +514,7 @@ module Process::Naf
 
       # kill with fire
       assigned_jobs(record).each do |job|
-        logger.alarm escape_html("sending SIG_KILL to process: #{job}")
+        logger.alarm escape_html("sending SIG_KILL to process: #{job.inspect}")
         send_signal_and_maybe_clean_up(job, "KILL")
 
         # job force job down
@@ -522,6 +540,7 @@ module Process::Naf
 
         return false
       end
+
       return true
     end
 
@@ -545,9 +564,22 @@ module Process::Naf
       Facter.clear
       memory_size = Facter.memorysize_mb.to_f
       memory_free = Facter.memoryfree_mb.to_f
+      memory_free_percentage = ((memory_free + sreclaimable_memory) / memory_size) * 100.0
+
+      if (memory_free_percentage >= @minimum_memory_free)
+        logger.detail "memory available: #{memory_free_percentage}% (free) >= " +
+          "#{@minimum_memory_free}% (min percent)"
+        return true
+      end
+      logger.alarm "#{Facter.hostname}.#{Facter.domain}: not enough memory to spawn: " +
+        "#{memory_free_percentage}% (free) < #{@minimum_memory_free}% (min percent)"
 
-      # Linux breaks out kernel cache-use memory into an SReclaimable stat
-      # in /proc/meminfo which should be counted as free, but facter does not.
+      return false
+    end
+
+    # Linux breaks out kernel cache-use memory into an SReclaimable stat
+    # in /proc/meminfo which should be counted as free, but facter does not.
+    def sreclaimable_memory
       sreclaimable = 0.0
       begin
         File.readlines('/proc/meminfo').each do |l|
@@ -561,17 +593,7 @@ module Process::Naf
       rescue
       end
 
-      memory_free_percentage = ((memory_free + sreclaimable) / memory_size) * 100.0
-
-      if (memory_free_percentage >= @minimum_memory_free)
-        logger.detail "memory available: #{memory_free_percentage}% (free) >= " +
-          "#{@minimum_memory_free}% (min percent)"
-        return true
-      end
-      logger.alarm "#{Facter.hostname}.#{Facter.domain}: not enough memory to spawn: " +
-        "#{memory_free_percentage}% (free) < #{@minimum_memory_free}% (min percent)"
-
-      return false
+      sreclaimable
     end
 
     def escape_html(str)

data/bin/naf

@@ -5,22 +5,36 @@ action, option = ARGV
 if action == 'runner'
   if option == 'up'
     puts "Bringing up the runner(s)..."
-    `screen -d -m bash -c 'source /root/.bash_profile && cd /root/current && a=\`uuidgen\` && script/rails runner ::Process::Naf::Runner.run --invocation-uuid $a 2>&1 |
+    `screen -d -m bash -c 'source /root/.bash_profile && cd /root/current && a=\`uuidgen\` &&
+      script/rails runner ::Process::Naf::Runner.run --invocation-uuid $a 2>&1 |
       script/rails runner ::Process::Naf::Logger::RunnerLog.run --invocation-uuid $a'`
 
   elsif option == 'status'
     num_runners = Integer(`ps -ef | grep Process::Naf::Runner.run | grep -v grep | grep -v uuidgen | wc -l`.strip)
     hostname = `hostname`.strip
     if num_runners == 0
-      puts "down: #{hostname}"
+      puts "Runner down on host: #{hostname}"
     elsif num_runners == 1
-      puts "up: #{hostname}"
+      puts "Runner up on host: #{hostname}"
     else
-      puts "up/w: #{hostname} (#{num_runners})"
+      puts "1 runner up, #{num_runners - 1} runner(s) winding down on host: #{hostname}"
     end
 
   elsif option == 'down'
     puts 'Bringing down runner(s)...'
     `kill $(ps -ef | grep Process::Naf::Runner.run | grep -v grep | grep -v uuidgen | awk '{ print $2 }') | cat`
+
+  elsif option == '--?' || option == '--help'
+    puts "DESCRIPTION\n\tThe following options are available:\n\n" +
+      "\tup\t->\tBrings up new Runner and RunnerLog processes on the host.\n\n" +
+      "\tstatus\t->\tLists the status of the runner based on unix process status. The runner can be down, up, or up/winding down.\n\n" +
+      "\tdown\t->\tTakes down the runner by sending a kill signal to the processes specified by the pid operand."
+  else
+    puts "Sorry, option \'#{option}\' is not available. Available options: up, status, down, --?, --help"
   end
+elsif action == '--?' || action == '--help'
+  puts "DESCRIPTION\n\tThe following actions are available:\n\n" +
+    "\trunner\t->\tControls the Naf runner."
+else
+  puts "Sorry, action \'#{action}\' is not available. Available actions: runner, --?, --help"
 end

data/lib/naf/version.rb

@@ -1,3 +1,3 @@
 module Naf
-  VERSION = '2.1.10'
+  VERSION = '2.1.11'
 end

data/naf.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |s|
   s.name        = 'naf'
   s.version     = Naf::VERSION
   s.license     = 'New BSD License'
-  s.date        = '2014-04-15'
+  s.date        = '2014-04-30'
   s.summary     = 'Creates infrastructure for a customizable and robust Postgres-backed script scheduling/running'
   s.description = 'A cloud based distributed cron, application framework and operations console. Naf works as a distributed script running ' +
                   'system that provides scheduling, logging, alarming, machine redundancy, and the ability to set constraint during script execution'

data/spec/factories/naf.rb

@@ -176,9 +176,9 @@ FactoryGirl.define do
     sequence(:application_run_group_name) { |n| "Run Group #{n}" }
   end
 
-  #############################################################
-  #######   Application Schedule Prerequisites ################
-  #############################################################
+  #############################################
+  #######   Run Interval Style ################
+  #############################################
 
   factory :run_interval_style, class: ::Naf::RunIntervalStyle do
     name 'at beginning of day'

data/spec/models/logical/naf/construction_zone/{boss_rspec.rb → boss_spec.rb}

@@ -34,19 +34,61 @@ module Logical::Naf::ConstructionZone
 
     describe '#enqueue_application' do
       let(:application) { FactoryGirl.create(:application) }
+      let(:prereq) { FactoryGirl.create(:job) }
       let!(:job) {
         boss.enqueue_application(application,
                                  ::Naf::ApplicationRunGroupRestriction.no_limit,
-                                 application.command)
+                                 application.command,
+                                 5,
+                                 1,
+                                 [::Naf::Affinity.first],
+                                 [prereq],
+                                 true)
       }
 
-      it_should_behave_like 'create one historical job', 1
+      it_should_behave_like 'create one historical job', 2
+
+      it 'assign run group restriction correctly' do
+        job.application_run_group_restriction_id.should == ::Naf::ApplicationRunGroupRestriction.no_limit.id
+      end
+
+      it 'assign run group name correctly' do
+        job.application_run_group_name.should == application.command
+      end
+
+      it 'assign run group limit correctly' do
+        job.application_run_group_limit.should == 5
+      end
+
+      it 'assign priority correctly' do
+        job.priority.should == 1
+      end
+
+      it 'assign affinities correctly' do
+        job.historical_job_affinity_tabs.map(&:affinity_id).should == [::Naf::Affinity.first.id]
+      end
+
+      it 'assign prerequisites correctly' do
+        job.historical_job_prerequisites.map(&:prerequisite_historical_job_id).should == [prereq.id]
+      end
+
+      it 'assign enqueue_backlogs correctly' do
+        job.application_run_group_name.should == application.command
+      end
     end
 
     describe '#enqueue_application_schedule' do
       let!(:job) { boss.enqueue_application_schedule(FactoryGirl.create(:schedule)) }
 
       it_should_behave_like 'create one historical job', 1
+
+      it 'create two historical jobs when schedule has a prerequisite' do
+        schedule = FactoryGirl.create(:schedule)
+        FactoryGirl.create(:schedule_prerequisite, application_schedule: schedule)
+        boss.enqueue_application_schedule(schedule)
+
+        ::Naf::HistoricalJob.should have(3).records
+      end
     end
 
     describe '#enqueue_rails_command' do
@@ -82,7 +124,7 @@ module Logical::Naf::ConstructionZone
 
       it 'create two historical jobs when a machine is present' do
         machine = FactoryGirl.create(:machine)
-        classification = FactoryGirl.create(:location_affinity_classification)
+        classification = FactoryGirl.create(:machine_affinity_classification)
         FactoryGirl.create(:affinity, id: 5,
                                       affinity_name: machine.id.to_s,
                                       affinity_classification: classification)

data/spec/models/naf/affinity_spec.rb

@@ -5,6 +5,14 @@ module Naf
     let!(:normal) { FactoryGirl.create(:normal_affinity) }
     let(:canary) { FactoryGirl.create(:canary_affinity) }
     let(:perennial) { FactoryGirl.create(:perennial_affinity) }
+    let!(:machine) { FactoryGirl.create(:machine) }
+    let!(:machine_classification) { FactoryGirl.create(:machine_affinity_classification) }
+    let!(:machine_affinity) {
+      FactoryGirl.create(:affinity, id: 5,
+                                    affinity_classification_id: machine_classification.id,
+                                    affinity_name: machine.id.to_s)
+    }
+
 
     # Mass-assignment
     [:affinity_classification_id,
@@ -94,9 +102,7 @@ module Naf
 
       it 'return proper message when pair value (affinity_classification_id, affinity_name) already exists' do
         normal.affinity_name = FactoryGirl.create(:machine).id.to_s
-        normal.affinity_classification.affinity_classification_name = 'machine'
-        normal.save
-        normal.affinity_classification.save
+        normal.affinity_classification = machine_classification
 
         normal.validate_affinity_name.should == 'An affinity with the pair value (affinity_classification_id, affinity_name) already exists!'
       end
@@ -110,6 +116,7 @@ module Naf
       before do
         canary.update_attributes!(selectable: false)
         perennial.update_attributes!(selectable: false)
+        machine_affinity.update_attributes!(selectable: false)
       end
 
       it "return only selectable affinities" do
@@ -117,5 +124,37 @@ module Naf
       end
     end
 
+    describe "#deleted_machine_affinities" do
+      it "return only affinities that are associated with deleted machines" do
+        machine.update_attributes!(deleted: true, enabled: false)
+        ::Naf::Affinity.deleted_machine_affinities.should == [machine_affinity]
+      end
+    end
+
+    describe "#names_list" do
+      before do
+        canary.update_attributes!(selectable: false)
+        perennial.update_attributes!(selectable: false)
+      end
+
+      it "return affinities not related to machine classification correctly" do
+        ::Naf::Affinity.names_list.should == [['purpose, normal', 1], ['0.0.0.1', 5]]
+      end
+
+      it "return affinities related to machine classification correctly when short name is present" do
+        machine_affinity.update_attributes!(affinity_short_name: 'machine_1')
+        ::Naf::Affinity.names_list.should == [['purpose, normal', 1], ['machine_1', 5]]
+      end
+
+      it "return affinities related to machine classification correctly when affinity_name is used" do
+        ::Naf::Affinity.names_list.should == [['purpose, normal', 1], ['0.0.0.1', 5]]
+      end
+
+      it "return affinities related to machine classification correctly when it is invalid" do
+        machine_affinity.update_attributes!(affinity_name: '100')
+        ::Naf::Affinity.names_list.should == [['purpose, normal', 1], ['Bad affinity: machine, 100', 5]]
+      end
+    end
+
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: naf
 version: !ruby/object:Gem::Version
-  version: 2.1.10
+  version: 2.1.11
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-15 00:00:00.000000000 Z
+date: 2014-04-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -194,6 +194,9 @@ files:
 - app/assets/images/bg-grad.png
 - app/assets/images/clock.png
 - app/assets/images/control_play_blue.png
+- app/assets/images/diagram_affinities.png
+- app/assets/images/diagram_runners.png
+- app/assets/images/diagram_running_system.png
 - app/assets/images/down_arrow.gif
 - app/assets/images/job.png
 - app/assets/images/machine.png
@@ -484,7 +487,7 @@ files:
 - spec/factories/naf.rb
 - spec/helpers/naf/application_helper_spec.rb
 - spec/models/logical/naf/application_spec.rb
-- spec/models/logical/naf/construction_zone/boss_rspec.rb
+- spec/models/logical/naf/construction_zone/boss_spec.rb
 - spec/models/logical/naf/construction_zone/foreman_spec.rb
 - spec/models/logical/naf/construction_zone/proletariat_spec.rb
 - spec/models/logical/naf/construction_zone/work_order_spec.rb
@@ -603,7 +606,7 @@ test_files:
 - spec/factories/naf.rb
 - spec/helpers/naf/application_helper_spec.rb
 - spec/models/logical/naf/application_spec.rb
-- spec/models/logical/naf/construction_zone/boss_rspec.rb
+- spec/models/logical/naf/construction_zone/boss_spec.rb
 - spec/models/logical/naf/construction_zone/foreman_spec.rb
 - spec/models/logical/naf/construction_zone/proletariat_spec.rb
 - spec/models/logical/naf/construction_zone/work_order_spec.rb