naf 2.0.4 → 2.1.0

data/app/models/logical/naf/job_creator.rb

@@ -1,151 +0,0 @@
-module Logical
-  module Naf
-    class JobCreator
-      def queue_application(application,
-                            application_run_group_restriction,
-                            application_run_group_name,
-                            application_run_group_limit = 1,
-                            priority = 0,
-                            affinities = [],
-                            prerequisites = [],
-                            enqueue = false)
-
-        # Before adding a job to the queue, check whether the number of
-        # jobs (running/queued) is equal to or greater than the application
-        # run group limit, or if enqueue_backlogs is set to false. If so,
-        # do not add the job to the queue
-        running_jobs = retrieve_jobs(::Naf::RunningJob, application.command, application_run_group_name)
-        queued_jobs = retrieve_jobs(::Naf::QueuedJob, application.command, application_run_group_name)
-
-        if enqueue == false && (running_jobs.present? || queued_jobs.present?)
-          group_limit = running_jobs.try(:application_run_group_limit).to_i + queued_jobs.try(:application_run_group_limit).to_i
-          total_jobs = running_jobs.try(:count).to_i + queued_jobs.try(:count).to_i
-
-          return if group_limit <= total_jobs
-        end
-
-        ::Naf::HistoricalJob.transaction do
-          historical_job = ::Naf::HistoricalJob.create!(application_id: application.id,
-                                                        application_type_id: application.application_type_id,
-                                                        command: application.command,
-                                                        application_run_group_restriction_id: application_run_group_restriction.id,
-                                                        application_run_group_name: application_run_group_name,
-                                                        application_run_group_limit: application_run_group_limit,
-                                                        priority: priority,
-                                                        log_level: application.log_level)
-
-          # Create historical job affinity tabs for each affinity associated with the historical job
-          affinities.each do |affinity|
-            affinity_parameter = ::Naf::ApplicationScheduleAffinityTab.
-              where(affinity_id: affinity.id,
-                    application_schedule_id: application.application_schedule.try(:id)).
-              first.try(:affinity_parameter)
-            ::Naf::HistoricalJobAffinityTab.create(historical_job_id: historical_job.id,
-                                                   affinity_id: affinity.id,
-                                                   affinity_parameter: affinity_parameter)
-          end
-
-          verify_and_create_prerequisites(historical_job, prerequisites)
-
-          create_queue_job(historical_job)
-
-          return historical_job
-        end
-      end
-
-      def retrieve_jobs(klass, command, application_run_group_name)
-        klass.select('application_run_group_limit, MAX(created_at) AS created_at, count(*)').
-          where('command = ? AND application_run_group_name = ?', command, application_run_group_name).
-          group('application_run_group_name, application_run_group_limit').first
-      end
-
-      def queue_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|
-          prerequisite_jobs << queue_application_schedule(application_schedule_prerequisite, schedules_queued_already)
-        end
-
-        # Queue the application
-        return queue_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
-
-      # This method act similar to queue_application but is used for testing purpose
-      def queue_rails_job(command,
-                          application_run_group_restriction = ::Naf::ApplicationRunGroupRestriction.limited_per_all_machines,
-                          application_run_group_name = :command,
-                          application_run_group_limit = 1,
-                          priority = 0,
-                          affinities = [],
-                          prerequisites = [])
-        application_run_group_name = command if application_run_group_name == :command
-        ::Naf::HistoricalJob.transaction do
-          historical_job = ::Naf::HistoricalJob.create!(application_type_id: 1,
-                                                        command: command,
-                                                        application_run_group_restriction_id: application_run_group_restriction.id,
-                                                        application_run_group_name: application_run_group_name,
-                                                        application_run_group_limit: application_run_group_limit,
-                                                        priority: priority)
-          affinities.each do |affinity|
-            ::Naf::HistoricalJobAffinityTab.create(historical_job_id: historical_job.id, affinity_id: affinity.id)
-          end
-
-          verify_and_create_prerequisites(historical_job, prerequisites)
-
-          create_queue_job(historical_job)
-
-          return historical_job
-        end
-      end
-
-      def verify_and_create_prerequisites(job, prerequisites)
-        job.verify_prerequisites(prerequisites)
-        # Create historical job prerequisites for each prerequisite associated with the historical job
-        prerequisites.each do |prerequisite|
-          ::Naf::HistoricalJobPrerequisite.create(historical_job_id: job.id,
-                                                  prerequisite_historical_job_id: prerequisite.id)
-        end
-      end
-
-      def create_queue_job(historical_job)
-        queued_job = ::Naf::QueuedJob.new(application_id: historical_job.application_id,
-                                          application_type_id: historical_job.application_type_id,
-                                          command: historical_job.command,
-                                          application_run_group_restriction_id: historical_job.application_run_group_restriction_id,
-                                          application_run_group_name: historical_job.application_run_group_name,
-                                          application_run_group_limit: historical_job.application_run_group_limit,
-                                          priority: historical_job.priority)
-        queued_job.id = historical_job.id
-        queued_job.save!
-      end
-
-      def queue_test
-        queue_rails_job("#{self.class.name}.test")
-      end
-
-      def self.test(*foo)
-        seconds = rand 120 + 15
-        puts "TEST CALLED: #{Time.zone.now}: #{foo.inspect}: sleeping for #{seconds} seconds"
-        sleep(seconds)
-        puts "TEST DONE: #{Time.zone.now}: #{foo.inspect}"
-      end
-    end
-
-    MiddleClass = JobCreator
-  end
-end

data/app/views/naf/applications/_application_schedule.html.erb

@@ -1,80 +0,0 @@
-<div class="field">
-  <%= f.hidden_field :_destroy %>
-</div>
-
-<h3 class="display-inline-block">Schedule | </h3>
-<%= link_to "Remove", "#" , id: "remove_application_schedule", class: "display-inline-block"%>
-
-<%= f.hidden_field :application_id %>
-
-<div class="field">
-  <%= f.label :application_run_group_restriction_id, "Application run group restriction*" %>
-  <%= f.select(:application_run_group_restriction_id,
-               ::Naf::ApplicationRunGroupRestriction.all.map { |a| [a.application_run_group_restriction_name, a.id] },
-               include_blank: true) %>
-</div>
-</br/>
-
-<div class="field">
-  <%= f.label :application_run_group_name %>
-  <%= select_tag(:run_group_name_type, options_for_select([["custom", "custom"],
-                                                           ["command", "command"],
-                                                           ["not set", "not set"]],
-                                                           @run_group_name_type)) %><br/>
-  <%= f.text_area :application_run_group_name, rows: 4, cols: 32, placeholder: "Please input Application Run Group Name" %>
-</div>
-</br/>
-
-<div class="field">
-  <%= f.label :run_start_minute, "Run Start Time (count of minutes after 12:00 am)" %>
-  <%= f.text_field :run_start_minute %>
-</div>
-</br/>
-
-<div class="field">
-  <%= f.label :run_interval, "Run Interval (minutes)" %>
-  <%= f.text_field :run_interval %>
-</div>
-</br/>
-
-<div class="field">
-  <%= f.label :priority %>
-  <%= f.text_field :priority %>
-</div>
-</br/>
-
-<div class="field">
-  <%= f.label :application_run_group_limit %>
-  <%= f.text_field :application_run_group_limit %>
-</div>
-</br/>
-
-<div class="field">
-  <%= f.label :enabled %>
-  <%= f.check_box :enabled %>
-</div>
-</br/>
-
-<div class="field">
-  <%= f.label :visible %>
-  <%= f.check_box :visible %>
-</div>
-<br/>
-
-<div class="field">
-  <%= f.label :enqueue_backlogs %>
-  <%= f.check_box :enqueue_backlogs %>
-</div>
-<br/>
-
-<% if @show_prerequisite %>
-  <%= f.fields_for :application_schedule_prerequisites do |builder| %>
-    <%= render "application_schedule_prerequisites", f: builder %>
-  <% end %>
-<% else %>
-  <% f.fields_for :application_schedule_prerequisites do |builder| %>
-    <%= render "application_schedule_prerequisites", f: builder %>
-  <% end %>
-<% end %>
-
-<%= naf_link_to_add_fields "Add Schedule Prerequisite", f, :application_schedule_prerequisites %>

data/spec/models/logical/naf/job_creator_spec.rb

@@ -1,102 +0,0 @@
-require 'spec_helper'
-
-module Logical
-  module Naf
-    describe JobCreator do
-
-      let!(:job_creator) { ::Logical::Naf::JobCreator.new }
-      let!(:historical_job) { FactoryGirl.create(:job) }
-      let(:application) { FactoryGirl.create(:scheduled_application) }
-
-      describe '#queue_application' do
-        it 'not queue an application if the group limit is less than number of queued/running jobs' do
-          historical_job.application_run_group_name = application.application_schedule.application_run_group_name
-          historical_job.command = application.command
-          historical_job.save!
-          job_creator.create_queue_job(historical_job)
-
-          job_creator.queue_application(application,
-                                        application.application_schedule.application_run_group_restriction,
-                                        application.application_schedule.application_run_group_name).should be_nil
-        end
-
-        it 'return a historical_job that has been queued' do
-          job_creator.queue_application(application,
-                                        application.application_schedule.application_run_group_restriction,
-                                        application.application_schedule.application_run_group_name).should be_instance_of(::Naf::HistoricalJob)
-        end
-
-        it 'create affinity tabs when affinities are present' do
-          job_creator.queue_application(application,
-                                        application.application_schedule.application_run_group_restriction,
-                                        application.application_schedule.application_run_group_name,
-                                        1,
-                                        0,
-                                        [::Naf::Affinity.first])
-          ::Naf::HistoricalJobAffinityTab.should have(1).records
-        end
-      end
-
-      describe '#retrieve_jobs' do
-        before do
-          FactoryGirl.create(:queued_job, application_run_group_name: 'Test',
-                                          application_run_group_limit: 1)
-        end
-
-        it 'return the correct records' do
-          job_creator.retrieve_jobs(::Naf::QueuedJob, '::Naf::QueuedJob.test hello world', 'Test').
-            count.to_i.should == 1
-        end
-      end
-
-      describe '#queue_application_schedule' do
-        it 'raise error if schedule has been queued' do
-          expect { job_creator.queue_application_schedule(application.application_schedule, [application.application_schedule.id]) }.
-            to raise_error(::Naf::HistoricalJob::JobPrerequisiteLoop)
-        end
-
-        it 'return a historical_job that has been queued' do
-          job_creator.queue_application_schedule(application.application_schedule).should be_instance_of(::Naf::HistoricalJob)
-        end
-      end
-
-      describe '#queue_rails_job' do
-        it 'create and return a historical_job' do
-          job = job_creator.queue_rails_job(:command)
-          job.should be_instance_of(::Naf::HistoricalJob)
-        end
-
-        it 'create affinity tabs when affinites are present' do
-          job_creator.queue_rails_job(:command,
-                                      ::Naf::ApplicationRunGroupRestriction.limited_per_all_machines,
-                                      :command,
-                                      1,
-                                      0,
-                                      [::Naf::Affinity.first])
-
-          ::Naf::HistoricalJobAffinityTab.should have(1).records
-        end
-      end
-
-      describe '#verify_and_create_prerequisites' do
-        before do
-          prereq_job = FactoryGirl.create(:job)
-          job_creator.verify_and_create_prerequisites(historical_job, [prereq_job])
-        end
-
-        it 'insert a row correctly into naf.historical_job_prerequisites' do
-          ::Naf::HistoricalJobPrerequisite.should have(1).records
-        end
-      end
-
-      describe '#create_queue_job' do
-        it 'insert a row correctly into naf.queued_jobs' do
-          job_creator.create_queue_job(historical_job)
-          ::Naf::QueuedJob.should have(1).records
-        end
-      end
-
-    end
-
-  end
-end