foreman-tasks 0.7.7 → 0.7.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 098fddc6fc2af891ed604780f543137d9e49e820
-  data.tar.gz: 9ae880cb667e08207995dd5e156c9960239f339e
+  metadata.gz: 28eae441ee8a39d7955e3d5a9fb33f87cea7b871
+  data.tar.gz: 21c37d4267f52e05e36ee008a33c38f3660f3fec
 SHA512:
-  metadata.gz: 71a4d2529300e104363a53dac9c534e3a682cac5f14fe722076c7d29df48429ef0ae9f777633135b7575b68288b725b9176a449018c0276d159becd5fb0ee4fe
-  data.tar.gz: 39364230aa8cd621e922c377685f85cb570af75dec61ccb5105942e82793e52d71bdd061ba544200227d17215b890ad9312109c51a5f4246826e21f7823a05c2
+  metadata.gz: 3ba85d54a8e1ee742a25b8c82299a377d685ab8628d9aee62af83009f6914d0b0e35e8cef029eacdd5bacc252c27e5b310e3b5fd5a495717112aa7e518189d35
+  data.tar.gz: 9278556260d43ff5f39c8269dc586e99ba6bb11205f3b680f7a5084d72fafe34d5611c046c18d4500e5c5617326ff6bf973e51ad40fa291b9ead4164c54dab57

data/app/controllers/foreman_tasks/api/tasks_controller.rb

@@ -29,7 +29,7 @@ module ForemanTasks
       class BadRequest < Apipie::ParamError
       end
 
-      before_filter :find_resource, :only => [:show]
+      before_filter :find_task, :only => [:show]
 
       api :GET, "/tasks/summary", "Show task summary"
       def summary
@@ -259,6 +259,10 @@ module ForemanTasks
 
       private
 
+      def find_task
+        @task = Task.find(params[:id])
+      end
+
       def resource_scope(options = {})
         @resource_scope ||= ForemanTasks::Task.authorized("#{action_permission}_foreman_tasks")
       end

data/app/controllers/foreman_tasks/tasks_controller.rb

@@ -5,7 +5,7 @@ module ForemanTasks
     before_filter :restrict_dangerous_actions, :only => [:unlock, :force_unlock]
 
     def show
-      @task = find_resource
+      @task = Task.find(params[:id])
     end
 
     def index
@@ -14,7 +14,7 @@ module ForemanTasks
     end
 
     def sub_tasks
-      task   = find_resource
+      task   = Task.find(params[:id])
       @tasks = filter(task.sub_tasks)
       render :index
     end

data/app/helpers/foreman_tasks/foreman_tasks_helper.rb

@@ -64,7 +64,7 @@ module ForemanTasks
     def future_mode_fieldset(f, triggering)
       tags = []
       tags << text_f(f, :start_at_raw, :label => _('Start at'), :placeholder => 'YYYY-mm-dd HH:MM')
-      tags << text_f(f, :start_before_raw, :label => _('Start before'), :placeholder => 'YYYY-mm-dd HH:MM')
+      tags << text_f(f, :start_before_raw, :label => _('Start before'), :placeholder => 'YYYY-mm-dd HH:MM', :help_inline => popover(_('Explanation'), _('Indicates that the action should be cancelled if it cannot be started before this time.')))
       content_tag(:fieldset, nil, :id => "trigger_mode_future", :class => "trigger_mode_form #{'hidden' unless triggering.future?}") do
         tags.join.html_safe
       end

data/app/lib/actions/base.rb

@@ -2,7 +2,7 @@ module Actions
   class Base < Dynflow::Action
 
     def task
-      @task ||= ::ForemanTasks::Task::DynflowTask.find_by_external_id!(execution_plan_id)
+      @task ||= ::ForemanTasks::Task::DynflowTask.where(:external_id => execution_plan_id).first!
     end
 
     # This method says what data form input gets into the task details in Rest API

data/app/models/foreman_tasks/concerns/action_triggering.rb

@@ -130,7 +130,7 @@ module ForemanTasks
           if @dynflow_sync_action
             run.wait
             if run.value.error?
-              task = ForemanTasks::Task::DynflowTask.find_by_external_id!(@execution_plan.id)
+              task = ForemanTasks::Task::DynflowTask.where(:external_id => @execution_plan.id).first!
               raise ForemanTasks::TaskError.new(task)
             end
           end

data/app/models/foreman_tasks/concerns/host_action_subject.rb

@@ -22,8 +22,8 @@ module ForemanTasks
           hostname.try(:downcase!)
           certname.try(:downcase!)
 
-          host = certname.present? ? Host.find_by_certname(certname) : nil
-          host ||= Host.find_by_name hostname
+          host = certname.present? ? Host.where(:certname => certname).first : nil
+          host ||= Host.where(:name => hostname).first
           host ||= Host.new(:name => hostname, :certname => certname) if Setting[:create_new_host_when_facts_are_uploaded]
           if host
             # if we were given a certname but found the Host by hostname we should update the certname

data/app/models/foreman_tasks/recurring_logic.rb

@@ -9,7 +9,11 @@ module ForemanTasks
     belongs_to :triggering
 
     has_many :tasks, :through => :task_group
-    has_many :task_groups, :through => :tasks, :uniq => true
+    if Rails::VERSION::MAJOR < 4
+      has_many :task_groups, :through => :tasks, :uniq => true
+    else
+      has_many :task_groups, -> { uniq }, :through => :tasks
+    end
 
     validates :cron_line, :presence => true
 
@@ -116,10 +120,9 @@ module ForemanTasks
 
     def self.cronline_hash(recurring_type, time_hash, days_of_week_hash)
       hash = Hash[[:years, :months, :days, :hours, :minutes].zip(time_hash.values)]
-      
       hash.update :days_of_week => days_of_week_hash
-                                  .select { |value, index| value == "1" }
-                                  .values.join(',')
+                                  .select { |key, value| value == "1" }
+                                  .keys.join(',')
       allowed_keys = case recurring_type
                      when :monthly
                        [:minutes, :hours, :days]

data/app/models/foreman_tasks/task.rb

@@ -15,12 +15,19 @@ module ForemanTasks
 
     has_many :task_group_members
     has_many :task_groups, :through => :task_group_members
-    has_many :recurring_logic_task_groups, :through => :task_group_members, :conditions => { :type => 'ForemanTasks::TaskGroups::RecurringLogicTaskGroup' }, :source => :task_group
+    if Rails::VERSION::MAJOR < 4
+      has_many :recurring_logic_task_groups, :through => :task_group_members, :conditions => { :type => 'ForemanTasks::TaskGroups::RecurringLogicTaskGroup' }, :source => :task_group
+      has_many :owners, :through => :locks, :source => :resource, :source_type => 'User',
+               :conditions => ["foreman_tasks_locks.name = ?", Lock::OWNER_LOCK_NAME]
+    else
+      has_many :recurring_logic_task_groups, -> { where :type => 'ForemanTasks::TaskGroups::RecurringLogicTaskGroup' },
+               :through => :task_group_members, :source => :task_group
+      # in fact, the task has only one owner but Rails don't let you to
+      # specify has_one relation though has_many relation
+      has_many :owners, lambda {where(["foreman_tasks_locks.name = ?", Lock::OWNER_LOCK_NAME])},
+               :through => :locks, :source => :resource, :source_type => 'User'
+    end
 
-    # in fact, the task has only one owner but Rails don't let you to
-    # specify has_one relation though has_many relation
-    has_many :owners, :through => :locks, :source => :resource, :source_type => 'User',
-        :conditions => ["foreman_tasks_locks.name = ?", Lock::OWNER_LOCK_NAME]
 
     scoped_search :on => :id, :complete_value => false
     scoped_search :on => :label, :complete_value => true

data/app/models/foreman_tasks/task/dynflow_task.rb

@@ -15,7 +15,7 @@ module ForemanTasks
       self.start_before   = data[:start_before] if data[:start_before]
       self.parent_task_id ||= begin
                                 if main_action.caller_execution_plan_id
-                                  DynflowTask.find_by_external_id!(main_action.caller_execution_plan_id).id
+                                  DynflowTask.where(:external_id => main_action.caller_execution_plan_id).first!.id
                                 end
                               end
       self.label          ||= main_action.class.name

data/app/models/foreman_tasks/triggering.rb

@@ -1,9 +1,10 @@
 module ForemanTasks
   class Triggering < ActiveRecord::Base
-
-    attr_accessor :start_at_raw, :start_before_raw, :max_iteration, :input_type,
-                  :cronline, :days, :days_of_week, :time, :end_time_limited,
-                  :end_time
+    PARAMS = [:start_at_raw, :start_before_raw, :max_iteration, :input_type,
+              :cronline, :days, :days_of_week, :time, :end_time_limited,
+              :end_time]
+    attr_accessor *PARAMS
+    attr_accessible *PARAMS
 
     before_save do
       if future?
@@ -39,11 +40,11 @@ module ForemanTasks
     validate :correct_cronline, :if => Proc.new { |t| t.recurring? && t.input_type == :cronline }
 
     def self.new_from_params(params = {})
-      self.new(params).tap do |targeting|
-        targeting.mode = params.fetch(:mode, :immediate).to_sym
-        targeting.input_type = params.fetch(:input_type, :cronline).to_sym
-        targeting.end_time_limited = params[:end_time_limited] == "true"
-        targeting.start_at_raw = Time.now.strftime(TIME_FORMAT)
+      self.new(params.except(:mode, :start_at, :start_before)).tap do |triggering|
+        triggering.mode = params.fetch(:mode, :immediate).to_sym
+        triggering.input_type = params.fetch(:input_type, :daily).to_sym
+        triggering.end_time_limited = params[:end_time_limited] == "true"
+        triggering.start_at_raw ||= Time.now.strftime(TIME_FORMAT)
       end
     end
 

data/db/seeds.d/60-dynflow_proxy_feature.rb

@@ -1,2 +1,2 @@
-f = Feature.find_or_create_by_name('Dynflow')
+f = Feature.where(:name => 'Dynflow').first_or_create
 raise "Unable to create proxy feature: #{format_errors f}" if f.nil? || f.errors.any?

data/db/seeds.d/61-foreman_tasks_bookmarks.rb

@@ -4,7 +4,7 @@ Bookmark.without_auditing do
     { :name => "failed", :query => "state = paused or result = error or result = warning" }
 
   ].each do |item|
-    next if Bookmark.find_by_name(item[:name])
+    next if Bookmark.where(:name => item[:name]).first
     next if audit_modified? Bookmark, item[:name]
     b = Bookmark.create({:controller => "foreman_tasks_tasks", :public => true}.merge(item))
     raise "Unable to create bookmark: #{format_errors b}" if b.nil? || b.errors.any?

data/lib/foreman_tasks.rb

@@ -27,7 +27,7 @@ module ForemanTasks
           end),
           (on ::Dynflow::World::Triggered.(execution_plan_id: ~any, future: ~any) do |id, finished|
             finished.wait if async == false
-            ForemanTasks::Task::DynflowTask.find_by_external_id!(id)
+            ForemanTasks::Task::DynflowTask.where(:external_id => id).first!
           end)
   end
 
@@ -43,6 +43,6 @@ module ForemanTasks
 
   def self.delay(action, delay_options, *args)
     result = dynflow.world.delay action, delay_options, *args
-    ForemanTasks::Task::DynflowTask.find_by_external_id!(result.id)
+    ForemanTasks::Task::DynflowTask.where(:external_id => result.id).first!
   end
 end

data/lib/foreman_tasks/dynflow/console_authorizer.rb

@@ -4,7 +4,7 @@ module ForemanTasks
     def initialize(env)
       @rack_request          = Rack::Request.new(env)
       @user_id, @expires_at = @rack_request.session.values_at('user', 'expires_at')
-      @user                 = User.find_by_id(@user_id) unless session_expired?
+      @user                 = User.where(:id => @user_id).first unless session_expired?
     end
 
     def allow?

data/lib/foreman_tasks/dynflow/persistence.rb

@@ -31,15 +31,15 @@ module ForemanTasks
         raise Foreman::Exception.new('Plan is delayed but the delay record is missing') if delayed_plan.nil?
         # TODO: Rework this
         delayed_plan = ::Dynflow::DelayedPlan.new_from_hash(ForemanTasks.dynflow.world, delayed_plan)
-        task = ::ForemanTasks::Task::DynflowTask.find_by_external_id(execution_plan_id)
+        task = ::ForemanTasks::Task::DynflowTask.where(:external_id => execution_plan_id).first
         task.update_from_dynflow(data.merge(:start_at => delayed_plan.start_at,
                                             :start_before => delayed_plan.start_before))
       when :planning
-        task = ::ForemanTasks::Task::DynflowTask.find_by_external_id(execution_plan_id)
+        task = ::ForemanTasks::Task::DynflowTask.where(:external_id => execution_plan_id).first
         task.update_from_dynflow(data)
         Lock.owner!(::User.current, task.id) if ::User.current
       else
-        if task = ::ForemanTasks::Task::DynflowTask.find_by_external_id(execution_plan_id)
+        if task = ::ForemanTasks::Task::DynflowTask.where(:external_id => execution_plan_id).first
           unless task.state.to_s == data[:state].to_s
             task.update_from_dynflow(data)
           end

data/lib/foreman_tasks/engine.rb

@@ -26,11 +26,11 @@ module ForemanTasks
           permission :edit_foreman_tasks, {:'foreman_tasks/tasks' => [:resume, :unlock, :force_unlock, :cancel_step, :cancel],
                                            :'foreman_tasks/api/tasks' => [:bulk_resume]}, :resource_type => ForemanTasks::Task.name
 
-          permission :create_recurring_logics, { }, :resource_type => ForemanTasks::RecurringLogic
+          permission :create_recurring_logics, { }, :resource_type => ForemanTasks::RecurringLogic.name
 
-          permission :view_recurring_logics, { :'foreman_tasks/recurring_logics' => [:index, :show] }, :resource_type => ForemanTasks::RecurringLogic
+          permission :view_recurring_logics, { :'foreman_tasks/recurring_logics' => [:index, :show] }, :resource_type => ForemanTasks::RecurringLogic.name
 
-          permission :edit_recurring_logics, { :'foreman_tasks/recurring_logics' => [:cancel] }, :resource_type => ForemanTasks::RecurringLogic
+          permission :edit_recurring_logics, { :'foreman_tasks/recurring_logics' => [:cancel] }, :resource_type => ForemanTasks::RecurringLogic.name
                                                                                                                                  
         end
 
@@ -70,7 +70,9 @@ module ForemanTasks
     end
 
     initializer "foreman_tasks.load_app_instance_data" do |app|
-      app.config.paths['db/migrate'] += ForemanTasks::Engine.paths['db/migrate'].existent
+      ForemanTasks::Engine.paths['db/migrate'].existent.each do |path|
+        app.config.paths['db/migrate'] << path
+      end
     end
 
     # to enable async Foreman operations using Dynflow

data/lib/foreman_tasks/version.rb

@@ -1,3 +1,3 @@
 module ForemanTasks
-  VERSION = "0.7.7"
+  VERSION = "0.7.8"
 end

data/test/controllers/api/tasks_controller_test.rb

@@ -29,7 +29,7 @@ module ForemanTasks
           triggered = ForemanTasks.trigger(Support::DummyProxyAction, Support::DummyProxyAction.proxy, 'foo' => 'bar')
           Support::DummyProxyAction.proxy.task_triggered.wait(5)
 
-          task = ForemanTasks::Task.find_by_external_id(triggered.id)
+          task = ForemanTasks::Task.where(:external_id => triggered.id).first
           task.state.must_equal 'running'
           task.result.must_equal 'pending'
 

data/test/unit/actions/action_with_sub_plans_test.rb

@@ -40,7 +40,7 @@ module ForemanTasks
         triggered = ForemanTasks.trigger(ParentAction, user)
         raise triggered.error if triggered.respond_to?(:error)
         triggered.finished.wait(2)
-        ForemanTasks::Task.find_by_external_id(triggered.id)
+        ForemanTasks::Task.where(:external_id => triggered.id).first
       end
 
       specify "the sub-plan stores the information about its parent" do

data/test/unit/recurring_logic_test.rb

@@ -36,6 +36,22 @@ class RecurringLogicsTest < ActiveSupport::TestCase
       parser.next_occurrence_time(reference_time).must_equal Time.new(year, month + 1, 5)
     end
 
+    it 'creates correct cronline hash' do
+      minutes = '52'
+      hours = '12'
+      days = '11'
+      days_of_week = { '1' => '1', '2' => '0', '3' => '0', '4' => '1', '5' => '0', '6' => '1', '7' => '0' }
+      time_hash = { '0' => '2015', '1' => '12', '2' => '11', '3' => hours, '4' => minutes }
+      expected_result_hourly  = { :minutes => minutes }
+      expected_result_daily   = { :minutes => minutes, :hours => hours }
+      expected_result_weekly  = { :minutes => minutes, :hours => hours, :days_of_week => '1,4,6' }
+      expected_result_monthly = { :minutes => minutes, :hours => hours, :days => days }
+      ForemanTasks::RecurringLogic.cronline_hash(:hourly,  time_hash, days_of_week).must_equal expected_result_hourly
+      ForemanTasks::RecurringLogic.cronline_hash(:daily,   time_hash, days_of_week).must_equal expected_result_daily
+      ForemanTasks::RecurringLogic.cronline_hash(:weekly,  time_hash, days_of_week).must_equal expected_result_weekly
+      ForemanTasks::RecurringLogic.cronline_hash(:monthly, time_hash, days_of_week).must_equal expected_result_monthly
+    end
+
     it 'can have limited number of repeats' do
       parser = ForemanTasks::RecurringLogic.new_from_cronline('* * * * *')
       parser.state = 'active'

data/test/unit/task_groups_test.rb

@@ -51,7 +51,7 @@ module ForemanTasks
           triggered = ForemanTasks.trigger(action_class, *args)
           raise triggered.error if triggered.respond_to?(:error)
           triggered.finished.wait
-          ForemanTasks::Task.find_by_external_id(triggered.id)
+          ForemanTasks::Task.where(:external_id => triggered.id).first
         end
       end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: foreman-tasks
 version: !ruby/object:Gem::Version
-  version: 0.7.7
+  version: 0.7.8
 platform: ruby
 authors:
 - Ivan Nečas
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-01 00:00:00.000000000 Z
+date: 2015-12-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dynflow