foreman-tasks 4.0.0 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bded348bac199b96bf0c1bf458c0785cdc233892acc1a5d06a940a8c5b28309b
-  data.tar.gz: f90eaf365ebfb191b45ab12b4693c7253d829ffcf0c57192e8bb4c1fa3e51986
+  metadata.gz: 3e48966ae6049eb85b3051151b7d15d48beb91a55b3580525fe114a3e045ad0f
+  data.tar.gz: 93da446f348f1a27600a79223ba4daab0e5e83417db711919392cfab2eedf57a
 SHA512:
-  metadata.gz: 41d60c3a188d66c0f7f3e9982c72de16f323d458529e2b90a16e8c023733acaedcf94a09ae30e94e54a66f4303f0b904a06d54c33b6db2af3acf49669c8b8b0f
-  data.tar.gz: b0ec169bf37128b471263c189b839416d8ae572a69732d3a9d4dcb64d4e2cdf2aef53d423cb2a7eef1c5f50f0756d332066dc9a244788f2b8c05643e1ca73b0f
+  metadata.gz: 740ff700f75e43154068d3838611dc7c7306d7f5da91e3d2d41a6fce5ea0ccde84bd5f027545f24874b8fb112d9848505ae2a535386ee2f356852695dacd61a2
+  data.tar.gz: 8f61c3c868af4b7c3d3173b728858537c72ccf695e60b63971ec19f8a675a6ad9c19ecdd3dedb2549e2eb27b7cde62a2be67ead4d737bb43b774301abb303228

data/.github/workflows/ruby_tests.yml

@@ -12,7 +12,7 @@ jobs:
       - name: Setup Ruby
         uses: ruby/setup-ruby@v1
         with:
-          ruby-version: 2.6
+          ruby-version: 2.7
       - name: Setup
         run: |
           gem install bundler
@@ -31,7 +31,7 @@ jobs:
       fail-fast: false
       matrix:
         foreman-core-branch: [develop]
-        ruby-version: [2.5, 2.6]
+        ruby-version: [2.5, 2.6, 2.7]
         node-version: [12]
     steps:
       - run: sudo apt-get update
@@ -60,6 +60,7 @@ jobs:
       - name: Setup Bundler
         run: |
           echo "gem 'foreman-tasks', path: './foreman-tasks'" > bundler.d/foreman-tasks.local.rb
+          echo "gem 'sqlite3'" >> bundler.d/foreman-tasks.local.rb
           gem install bundler
           bundle config set without journald development console libvirt
           bundle config set path vendor/bundle
@@ -70,5 +71,5 @@ jobs:
           bundle exec rake db:migrate
       - name: Run plugin tests
         run: |
-          bundle exec rake test:foreman-tasks
+          bundle exec rake test:foreman_tasks
           bundle exec rake test TEST="test/unit/foreman/access_permissions_test.rb"

data/app/controllers/concerns/foreman_tasks/find_tasks_common.rb

@@ -0,0 +1,14 @@
+module ForemanTasks
+  module FindTasksCommon
+    def search_query
+      [current_taxonomy_search, params[:search]].select(&:present?).join(' AND ')
+    end
+
+    def current_taxonomy_search
+      conditions = []
+      conditions << "organization_id = #{Organization.current.id}" if Organization.current
+      conditions << "location_id = #{Location.current.id}" if Location.current
+      conditions.empty? ? '' : "(#{conditions.join(' AND ')})"
+    end
+  end
+end

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

@@ -1,6 +1,7 @@
 module ForemanTasks
   module Api
     class TasksController < ::Api::V2::BaseController
+      include ForemanTasks::FindTasksCommon
       include ::Foreman::Controller::SmartProxyAuth
       add_smart_proxy_filters :callback, :features => 'Dynflow'
 
@@ -51,7 +52,7 @@ module ForemanTasks
           In case :type = 'resource', what resource id we're searching the tasks for
         DESC
         param :action_types, [String], :desc => <<-DESC
-          Return just tasks of given action type, e.g. ["Actions::Katello::Repository::Synchronize"]
+          Return just tasks of given action type, e.g. `["Actions::Katello::Repository::Synchronize"]`
         DESC
         param :active_only, :bool
         param :page, String
@@ -195,7 +196,7 @@ module ForemanTasks
       end
 
       def search_options
-        [params[:search], {}]
+        [search_query, {}]
       end
 
       def_param_group :callback_target do
@@ -253,10 +254,7 @@ module ForemanTasks
           if search_params[:user_id].blank?
             raise BadRequest, _('User search_params requires user_id to be specified')
           end
-          scope.joins(:locks).where(foreman_tasks_locks:
-                                        { name:          ::ForemanTasks::Lock::OWNER_LOCK_NAME,
-                                          resource_type: 'User',
-                                          resource_id:   search_params[:user_id] })
+          scope.search_for("user_id = #{search_params[:user_id]}")
         when 'resource'
           if search_params[:resource_type].blank? || search_params[:resource_id].blank?
             raise BadRequest,

data/app/controllers/foreman_tasks/tasks_controller.rb

@@ -2,6 +2,7 @@ module ForemanTasks
   class TasksController < ::ApplicationController
     include Foreman::Controller::AutoCompleteSearch
     include Foreman::Controller::CsvResponder
+    include ForemanTasks::FindTasksCommon
 
     def show
       @task = resource_base.find(params[:id])
@@ -126,19 +127,10 @@ module ForemanTasks
     end
 
     def filter(scope, paginate: true)
-      search = current_taxonomy_search
-      search = [search, params[:search]].select(&:present?).join(' AND ')
       scope = DashboardTableFilter.new(scope, params).scope
-      scope = scope.search_for(search, :order => params[:order])
-      scope = scope.paginate(:page => params[:page], :per_page => params[:per_page]) if paginate
+      scope = scope.search_for(search_query, order: params[:order])
+      scope = scope.paginate(page: params[:page], per_page: params[:per_page]) if paginate
       scope.distinct
     end
-
-    def current_taxonomy_search
-      conditions = []
-      conditions << "organization_id = #{Organization.current.id}" if Organization.current
-      conditions << "location_id = #{Location.current.id}" if Location.current
-      conditions.empty? ? '' : "(#{conditions.join(' AND ')})"
-    end
   end
 end

data/app/graphql/types/recurring_logic.rb

@@ -0,0 +1,18 @@
+module Types
+  class RecurringLogic < Types::BaseObject
+    description 'A Recurring Logic'
+    model_class ::ForemanTasks::RecurringLogic
+
+    global_id_field :id
+    field :cron_line, String
+    field :end_time, GraphQL::Types::ISO8601DateTime
+    field :max_iteration, Integer
+    field :iteration, Integer
+    field :state, String
+    belongs_to :triggering, Types::Triggering
+
+    def self.graphql_definition
+      super.tap { |type| type.instance_variable_set(:@name, 'ForemanTasks::RecurringLogic') }
+    end
+  end
+end

data/app/graphql/types/task.rb

@@ -0,0 +1,25 @@
+module Types
+  class Task < Types::BaseObject
+    description 'A Task'
+    model_class ::ForemanTasks::Task
+
+    global_id_field :id
+    field :type, String
+    field :label, String
+    field :started_at, GraphQL::Types::ISO8601DateTime
+    field :ended_at, GraphQL::Types::ISO8601DateTime
+    field :state, String
+    field :result, String
+    field :external_id, String
+    field :parent_task_id, String
+    field :start_at, GraphQL::Types::ISO8601DateTime
+    field :start_before, GraphQL::Types::ISO8601DateTime
+    field :action, String
+    field :user_id, Integer
+    field :state_updated_at, GraphQL::Types::ISO8601DateTime
+
+    def self.graphql_definition
+      super.tap { |type| type.instance_variable_set(:@name, 'ForemanTasks::Task') }
+    end
+  end
+end

data/app/graphql/types/triggering.rb

@@ -0,0 +1,16 @@
+module Types
+  class Triggering < Types::BaseObject
+    description 'A Task Triggering'
+    model_class ::ForemanTasks::Triggering
+
+    global_id_field :id
+    field :mode, String
+    field :start_at, GraphQL::Types::ISO8601DateTime
+    field :start_before, GraphQL::Types::ISO8601DateTime
+    field :recurring_logic, Types::RecurringLogic
+
+    def self.graphql_definition
+      super.tap { |type| type.instance_variable_set(:@name, 'ForemanTasks::Triggering') }
+    end
+  end
+end

data/app/lib/actions/helpers/with_continuous_output.rb

@@ -8,7 +8,7 @@ module Actions
       end
 
       def continuous_output
-        continuous_output = ::ForemanTasksCore::ContinuousOutput.new
+        continuous_output = ::ForemanTasks::ContinuousOutput.new
         continuous_output_providers.each do |continous_output_provider|
           continous_output_provider.fill_continuous_output(continuous_output)
         end

data/app/lib/actions/middleware/load_setting_values.rb

@@ -0,0 +1,35 @@
+module Actions
+  module Middleware
+    class LoadSettingValues < ::Dynflow::Middleware
+      # ::Actions::Middleware::LoadSettingValues
+      #
+      # A middleware to ensure we load current setting values
+
+      def delay(*args)
+        reload_setting_values
+        pass(*args)
+      end
+
+      def plan(*args)
+        reload_setting_values
+        pass(*args)
+      end
+
+      def run(*args)
+        reload_setting_values
+        pass(*args)
+      end
+
+      def finalize(*args)
+        reload_setting_values
+        pass(*args)
+      end
+
+      private
+
+      def reload_setting_values
+        ::Foreman.settings.load_values
+      end
+    end
+  end
+end

data/app/lib/actions/observable_action.rb

@@ -70,7 +70,7 @@ module Actions
     apipie :class, "An common ancestor action for observable actions" do
       name 'Actions::ObservableAction'
       refs 'Actions::ObservableAction'
-      sections only: %w[webhooks]
+      sections only: %w[all webhooks]
       property :task, object_of: 'Task', desc: 'Returns the task to which this action belongs'
     end
     class Jail < Safemode::Jail

data/app/lib/actions/proxy_action.rb

@@ -218,10 +218,8 @@ module Actions
     end
 
     def get_proxy_data(response)
-      proxy_data = response['actions'].detect do |action|
-        action['class'] == proxy_action_name || action.fetch('input', {})['proxy_operation_name'] == proxy_operation_name
-      end
-      proxy_data.fetch('output', {})
+      response['actions'].detect { |action| action.fetch('input', {})['task_id'] == task.id }
+                         .try(:fetch, 'output', {}) || {}
     end
 
     def proxy_version(proxy)

data/app/models/foreman_tasks/recurring_logic.rb

@@ -4,6 +4,8 @@ module ForemanTasks
   class RecurringLogic < ApplicationRecord
     include Authorizable
 
+    graphql_type '::Types::RecurringLogic'
+
     belongs_to :task_group
     belongs_to :triggering
 

data/app/models/foreman_tasks/task.rb

@@ -5,6 +5,8 @@ module ForemanTasks
     include Authorizable
     extend Search
 
+    graphql_type '::Types::Task'
+
     def check_permissions_after_save
       # there's no create_tasks permission, tasks are created as a result of internal actions, in such case we
       # don't do authorization, that should have been performed on wrapping action level
@@ -89,7 +91,7 @@ module ForemanTasks
       property :ended_at, ActiveSupport::TimeWithZone, desc: 'Returns date with time the task ended at'
     end
     class Jail < Safemode::Jail
-      allow :started_at, :ended_at, :result, :state, :label, :main_action, :action_output
+      allow :started_at, :ended_at, :result, :state, :label, :main_action, :action_continuous_output
     end
 
     def input
@@ -249,12 +251,38 @@ module ForemanTasks
       parts.join(' ').strip
     end
 
-    def action_output
+    def action_continuous_output
       return unless main_action.is_a?(Actions::Helpers::WithContinuousOutput)
       main_action.continuous_output.sort!
       main_action.continuous_output.raw_outputs
     end
 
+    def self.latest_tasks_by_resource_ids(label, resource_type, resource_ids)
+      tasks = arel_table
+      links = ForemanTasks::Link.arel_table
+      started_at = tasks[:started_at]
+      resource_id = links[:resource_id]
+
+      base_combined_table = tasks
+                            .join(links).on(tasks[:id].eq(links[:task_id]))
+                            .where(tasks[:label].eq(label)
+                                                .and(links[:resource_type].eq(resource_type))
+                                                .and(links[:resource_id].in(resource_ids)))
+
+      grouped = base_combined_table.project(
+        started_at.maximum.as('started_at_max'),
+        resource_id
+      ).group(resource_id).order(resource_id).as('grouped')
+
+      max_per_resource_id = tasks
+                            .join(links).on(tasks[:id].eq(links[:task_id]))
+                            .join(grouped).on(grouped[:started_at_max].eq(started_at).and(grouped[:resource_id].eq(resource_id)))
+                            .distinct
+                            .project(tasks[Arel.star], grouped[:resource_id])
+
+      find_by_sql(max_per_resource_id.to_sql).index_by(&:resource_id)
+    end
+
     protected
 
     def generate_id

data/app/models/foreman_tasks/triggering.rb

@@ -5,6 +5,8 @@ module ForemanTasks
               :end_time].freeze
     attr_accessor(*PARAMS)
 
+    graphql_type '::Types::Triggering'
+
     before_save do
       if future?
         parse_start_at!

data/db/migrate/20180927120509_add_user_id.foreman_tasks.rb

@@ -1,4 +1,6 @@
 class AddUserId < ActiveRecord::Migration[5.0]
+  OWNER_LOCK_NAME = :task_owner
+
   def up
     add_reference :foreman_tasks_tasks, :user, :foreign_key => true
 
@@ -29,7 +31,7 @@ class AddUserId < ActiveRecord::Migration[5.0]
   private
 
   def create_lock(user_id, task)
-    ForemanTasks::Lock.new(:name          => ForemanTasks::Lock::OWNER_LOCK_NAME,
+    ForemanTasks::Lock.new(:name          => OWNER_LOCK_NAME,
                            :resource_type => User.name,
                            :resource_id   => user_id,
                            :task_id       => task.id,
@@ -37,6 +39,6 @@ class AddUserId < ActiveRecord::Migration[5.0]
   end
 
   def user_locks
-    ForemanTasks::Lock.where(:name => ForemanTasks::Lock::OWNER_LOCK_NAME)
+    ForemanTasks::Lock.where(:name => OWNER_LOCK_NAME)
   end
 end

data/foreman-tasks.gemspec

@@ -29,7 +29,6 @@ same resource. It also optionally provides Dynflow infrastructure for using it f
   s.extra_rdoc_files = Dir['README*', 'LICENSE']
 
   s.add_dependency "dynflow", '>= 1.2.3'
-  s.add_dependency "foreman-tasks-core"
   s.add_dependency "get_process_mem" # for memory polling
   s.add_dependency "parse-cron", '~> 0.1.4'
   s.add_dependency "sinatra" # for Dynflow web console

data/lib/foreman_tasks.rb

@@ -6,17 +6,14 @@ require 'foreman_tasks/dynflow/configuration'
 require 'foreman_tasks/triggers'
 require 'foreman_tasks/authorizer_ext'
 require 'foreman_tasks/cleaner'
+require 'foreman_tasks/continuous_output'
 
 module ForemanTasks
   extend Algebrick::TypeCheck
   extend Algebrick::Matching
 
   def self.dynflow
-    @dynflow ||= begin
-                   world = ForemanTasks::Dynflow.new(nil, ForemanTasks::Dynflow::Configuration.new)
-                   ForemanTasksCore.dynflow_setup(world) if defined?(ForemanTasksCore)
-                   world
-                 end
+    @dynflow ||= ForemanTasks::Dynflow.new(nil, ForemanTasks::Dynflow::Configuration.new)
   end
 
   def self.trigger(action, *args, &block)

data/lib/foreman_tasks/continuous_output.rb

@@ -0,0 +1,50 @@
+module ForemanTasks
+  class ContinuousOutput
+    attr_accessor :raw_outputs
+
+    def initialize(raw_outputs = [])
+      @raw_outputs = []
+      raw_outputs.each { |raw_output| add_raw_output(raw_output) }
+    end
+
+    def add_raw_output(raw_output)
+      missing_args = %w[output_type output timestamp] - raw_output.keys
+      unless missing_args.empty?
+        raise ArgumentError, "Missing args for raw output: #{missing_args.inspect}"
+      end
+      @raw_outputs << raw_output
+    end
+
+    def empty?
+      @raw_outputs.empty?
+    end
+
+    def last_timestamp
+      return if @raw_outputs.empty?
+      @raw_outputs.last.fetch('timestamp')
+    end
+
+    def sort!
+      @raw_outputs.sort_by! { |record| record['timestamp'].to_f }
+    end
+
+    def humanize
+      sort!
+      raw_outputs.map { |output| output['output'] }.join("\n")
+    end
+
+    def add_exception(context, exception, timestamp = Time.now.getlocal)
+      add_output(context + ": #{exception.class} - #{exception.message}", 'debug', timestamp)
+    end
+
+    def add_output(*args)
+      add_raw_output(self.class.format_output(*args))
+    end
+
+    def self.format_output(message, type = 'debug', timestamp = Time.now.getlocal)
+      { 'output_type' => type,
+        'output' => message,
+        'timestamp' => timestamp.to_f }
+    end
+  end
+end