foreman-tasks 0.4.0 → 0.5.0

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

@@ -14,6 +14,12 @@ module ForemanTasks
   module Api
     class TasksController < ::Api::V2::BaseController
 
+      resource_description do
+        resource_id 'foreman_tasks'
+        api_version 'v2'
+        api_base_url "/foreman_tasks/api"
+      end
+
       # Foreman right now doesn't have mechanism to
       # cause general BadRequest handling, resuing the Apipie::ParamError
       # for now http://projects.theforeman.org/issues/3957
@@ -22,6 +28,8 @@ module ForemanTasks
 
       before_filter :find_task, :only => [:show]
 
+      api :GET, "/tasks/:id", "Show task details"
+      param :id, :identifier, desc: "UUID of the task"
       def show
       end
 

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

@@ -3,18 +3,6 @@ module Actions
 
     class Humanizer
 
-      PARTS_ORDER = [:user,
-                     :repository,
-                     :product,
-                     :system,
-                     :organization]
-      # Just to get the trings into pot file
-      PARTS_TRANSLATIONS = [N_('user'),
-                            N_('repository'),
-                            N_('product'),
-                            N_('system'),
-                            N_('organization')]
-
       def initialize(action)
         @action = action
         @input  = action.respond_to?(:task_input) ? action.task_input : action.input
@@ -23,12 +11,34 @@ module Actions
         @output ||= {}
       end
 
+      def self.resource_classes_order
+        @resource_classes_order ||= []
+      end
+
+      def self.resource(name)
+        resource_classes_order.map(&:new).find { |resource| resource.name == name }
+      end
+
+      def self.default_parts
+        self.resource_classes_order.map { |klass| klass.new.name }
+      end
+
+      # Registers the resource class to the humanizer. Usually, this
+      # happens when the resource class is defined. The order of resources
+      # in the humanized input is determined by the registration order.
+      # The `register_resource` can be run more times for the same class,
+      # effectively moving the resource to the end of the humanized form.
+      def self.register_resource(resource_class)
+        self.resource_classes_order.delete_if { |klass| klass.name == resource_class.name }
+        self.resource_classes_order << resource_class
+      end
+
       def input(*parts)
         if parts.empty?
-          parts = PARTS_ORDER
+          parts = self.class.default_parts
         end
         included_parts(parts, @input).map do |part|
-          [part, humanize_resource(part, @input[part], @input)]
+          [part, humanize_resource(part, @input)]
         end
       end
 
@@ -36,30 +46,150 @@ module Actions
         parts.select { |part| data.has_key?(part) }
       end
 
-      def humanize_resource(type, data, other_data)
-        humanized_type = _(type)
-        humanized_value = data[:name] || data[:label] || data[:id]
-        { text: "#{humanized_type} '#{humanized_value}'",
-         link: link_to_resource(type, data, other_data) }
+      def humanize_resource(name, data)
+        if resource = self.class.resource(name)
+          { text: "#{resource.humanized_name} '#{resource.humanized_value(data)}'",
+            link: resource.link(data) }
+        end
       end
 
-      # TODO: this probably is not the best place for this logic, find
-      # out where to put this
-      def link_to_resource(type, data, other_data)
-        case type
-        when :product
-          "#/products/#{data[:id]}/info" if data[:id]
-        when :repository
-          if other_data[:product] && other_data[:product][:id] && data[:id]
-            "#/products/#{other_data[:product][:id]}/repositories/#{data[:id]}"
+      class Resource
+        def name
+          raise NotImplementedError
+        end
+
+        def humanized_name
+          name
+        end
+
+        def link(data)
+        end
+
+        def humanized_value(data)
+          fetch_data(data, name, :name) ||
+              fetch_data(data, name, :label) ||
+              fetch_data(data, name, :id)
+        end
+
+        def self.inherited(klass)
+          Humanizer.register_resource(klass)
+        end
+
+        private
+
+        def fetch_data(data, *subkeys)
+          if subkeys.empty?
+            return data
+          else
+            head, *tail = subkeys
+            if data.is_a?(Hash) && data.has_key?(head)
+              return fetch_data(data[head], *tail)
+            else
+              return nil
+            end
           end
-        when :system
-          if data[:uuid]
-            "#/systems/#{data[:uuid]}/info"
+        end
+      end
+
+      class UserResource < Resource
+        def name
+          :user
+        end
+
+        def humanized_name
+          _('user')
+        end
+      end
+
+      # TODO: remove after getting the definitions into Katello
+      class RepositoryResource < Resource
+        def name
+          :repository
+        end
+
+        def humanized_name
+          _('repository')
+        end
+
+        def link(data)
+          product_id = fetch_data(data, :product, :id)
+          repo_id = fetch_data(data, :repo, :id)
+          if product_id && repo_id
+            "#/products/#{product_id}/repositories/#{repo_id}"
           end
-        when :organization
-          if data[:label]
-            "/organizations/#{data[:id]}/edit"
+        end
+      end
+
+      class ContentViewVersionResource < Resource
+        def name
+          :content_view_version
+        end
+
+        def humanized_name
+          _('content view version')
+        end
+      end
+
+      class ContentViewResource < Resource
+        def name
+          :content_view
+        end
+
+        def humanized_name
+          _('content view')
+        end
+
+        def link(data)
+          if content_view_id = fetch_data(data, :content_view, :id)
+            "#/content_views/#{content_view_id}/versions"
+          end
+        end
+      end
+
+      class ProductResource < Resource
+        def name
+          :product
+        end
+
+        def humanized_name
+          _('product')
+        end
+
+        def link(data)
+          if product_id = fetch_data(data, :product, :id)
+            "#/products/#{product_id}/info"
+          end
+        end
+      end
+
+      class SystemResource < Resource
+        def name
+          :system
+        end
+
+        def humanized_name
+          _('system')
+        end
+
+        def link(data)
+          if system_uuid = fetch_data(data, :system, :uuid)
+            "#/systems/#{system_uuid}/info"
+          end
+        end
+      end
+
+      class OrganizationResource < Resource
+        def name
+          :organization
+        end
+
+        def humanized_name
+          _('organization')
+        end
+
+        def link(data)
+          if org_id = fetch_data(data, :organization, :id)
+            "/organizations/#{org_id}/edit"
           end
         end
       end

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

@@ -22,18 +22,26 @@ module ForemanTasks
       def destroy_action
       end
 
-      def save(*)
-        dynflow_task_wrap(:save) { super }
+      def save(*args)
+        dynflow_task_wrap(:save) { super(*args) }
       end
 
-      def save!(*)
-        dynflow_task_wrap(:save) { super }
+      def save!(*args)
+        dynflow_task_wrap(:save) { super(*args) }
       end
 
       def destroy
         dynflow_task_wrap(:destroy) { super }
       end
 
+      def update_attributes(*args)
+        dynflow_task_wrap(:save) { super(*args) }
+      end
+
+      def update_attributes!(*args)
+        dynflow_task_wrap(:save) { super(*args) }
+      end
+
       protected
 
       def sync_action_flag_reset!
@@ -83,6 +91,9 @@ module ForemanTasks
       # we would start the execution phase inside this transaction which would lead
       # to unexpected results.
       def dynflow_task_wrap(method)
+        return yield if @_dynflow_task_wrapped
+        @_dynflow_task_wrapped = true
+
         action = case method
                  when :save
                    self.new_record? ? create_action : update_action
@@ -100,13 +111,15 @@ module ForemanTasks
         else
           yield
         end
+      ensure
+        @_dynflow_task_wrapped = false
       end
 
       # we don't want to start executing the task calling to external services
       # when inside some other transaction. Might lead to unexpected results
       def ensure_not_in_transaction!
         if self.class.connection.open_transactions > 0
-          raise "Executing dynflow action inside a transaction is not a good idea"
+          raise 'Executing dynflow action inside a transaction is not a good idea'
         end
       end
 

data/app/models/foreman_tasks/lock.rb

@@ -13,7 +13,7 @@ module ForemanTasks
     class LockConflict < StandardError
       attr_reader :required_lock, :conflicting_locks
       def initialize(required_lock, conflicting_locks)
-        super()
+        super("required lock: #{required_lock} conflicts wiht #{conflicting_locks.inspect}")
         @required_lock     = required_lock
         @conflicting_locks = conflicting_locks
       end

data/app/models/foreman_tasks/task.rb

@@ -81,6 +81,17 @@ module ForemanTasks
       return {:conditions => condition, :joins => joins }
     end
 
+    def progress
+      case self.state.to_s
+      when "running", "paused"
+        0.5
+      when "stopped"
+        1
+      else
+        0
+      end
+    end
+
     protected
 
     def generate_id

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

@@ -1,6 +1,8 @@
 module ForemanTasks
   class Task::DynflowTask < ForemanTasks::Task
 
+    include Algebrick::TypeCheck
+
     scope :for_action, ->(action_class) { where(label: action_class.name) }
 
     def update_from_dynflow(data, planned)
@@ -17,13 +19,12 @@ module ForemanTasks
         unless self.label
           self.label = main_action.class.name
         end
-        update_progress
       end
       self.save!
     end
 
-    def update_progress
-      self.progress = execution_plan.progress
+    def progress
+      execution_plan.progress
     end
 
     def execution_plan
@@ -39,9 +40,9 @@ module ForemanTasks
     end
 
     def humanized
-      { action: main_action.respond_to?(:humanized_name) && main_action.humanized_name,
-        input:  main_action.respond_to?(:humanized_input) && main_action.humanized_input,
-        output: main_action.respond_to?(:humanized_output) && main_action.humanized_output }
+      { action: get_humanized(:humanized_name),
+        input:  get_humanized(:humanized_input),
+        output: get_humanized(:humanized_output) }
     end
 
     def cli_example
@@ -54,5 +55,16 @@ module ForemanTasks
       return @main_action if @main_action
       execution_plan.root_plan_step.action execution_plan
     end
+
+    def get_humanized(method)
+      Match! method, :humanized_name, :humanized_input, :humanized_output
+      if main_action.respond_to? method
+        begin
+          main_action.send method
+        rescue => error
+          "#{error.message} (#{error.class})\n#{error.backtrace.join "\n"}"
+        end
+      end
+    end
   end
 end

data/db/migrate/20140324104010_remove_foreman_tasks_progress.rb

@@ -0,0 +1,5 @@
+class RemoveForemanTasksProgress < ActiveRecord::Migration
+  def change
+    remove_column :foreman_tasks_tasks, :progress
+  end
+end

data/lib/foreman_tasks/dynflow/configuration.rb

@@ -27,15 +27,19 @@ module ForemanTasks
 
     attr_accessor :lazy_initialization
 
+    # what rake tasks should run their own executor, not depending on the external one
+    attr_accessor :rake_tasks_with_executor
+
     def initialize
-      self.action_logger       = Rails.logger
-      self.dynflow_logger      = Rails.logger
-      self.pool_size           = 5
-      self.remote              = Rails.env.production?
-      self.remote_socket_path  = File.join(Rails.root, "tmp", "sockets", "dynflow_socket")
-      self.transaction_adapter = ::Dynflow::TransactionAdapters::ActiveRecord.new
-      self.eager_load_paths    = []
-      self.lazy_initialization = !Rails.env.production?
+      self.action_logger            = Rails.logger
+      self.dynflow_logger           = Rails.logger
+      self.pool_size                = 5
+      self.remote                   = Rails.env.production?
+      self.remote_socket_path       = File.join(Rails.root, "tmp", "sockets", "dynflow_socket")
+      self.transaction_adapter      = ::Dynflow::TransactionAdapters::ActiveRecord.new
+      self.eager_load_paths         = []
+      self.lazy_initialization      = !Rails.env.production?
+      self.rake_tasks_with_executor = %w[db:migrate db:seed]
     end
 
     def initialize_world(world_class = ::Dynflow::World)
@@ -45,7 +49,15 @@ module ForemanTasks
     # No matter what config.remote says, when the process is marked as executor,
     # it can't be remote
     def remote?
-      !ForemanTasks.dynflow.executor? && @remote
+      !ForemanTasks.dynflow.executor? &&
+          !rake_task_with_executor? &&
+          @remote
+    end
+
+    def rake_task_with_executor?
+      Rake.application.top_level_tasks.any? do |rake_task|
+        rake_tasks_with_executor.include?(rake_task)
+      end
     end
 
     protected

data/lib/foreman_tasks/dynflow/persistence.rb

@@ -27,7 +27,9 @@ module ForemanTasks
         Lock.owner!(::User.current, task.id) if ::User.current
       elsif data[:state] != :planning
         if task = ::ForemanTasks::Task::DynflowTask.find_by_external_id(execution_plan_id)
-          task.update_from_dynflow(data, true)
+	  unless task.state.to_s == data[:state].to_s
+            task.update_from_dynflow(data, true)
+	  end
         end
       end
     end

data/lib/foreman_tasks/engine.rb

@@ -18,6 +18,15 @@ module ForemanTasks
       ActiveRecord::SchemaDumper.ignore_tables << /^dynflow_.*$/
     end
 
+    initializer "foreman_tasks.apipie" do
+      # this condition is here for compatibility reason to work with Foreman 1.4.x
+      if Apipie.configuration.api_controllers_matcher.is_a?(Array) &&
+            Apipie.configuration.respond_to?(:checksum_path)
+        Apipie.configuration.api_controllers_matcher << "#{ForemanTasks::Engine.root}/app/controllers/foreman_tasks/api/*.rb"
+        Apipie.configuration.checksum_path += ['/foreman_tasks/api/']
+      end
+    end
+
     initializer "foreman_tasks.register_paths" do |app|
       ForemanTasks.dynflow.config.eager_load_paths.concat(%W[#{ForemanTasks::Engine.root}/app/lib/actions])
     end
@@ -59,8 +68,6 @@ module ForemanTasks
     end
 
     rake_tasks do
-      # enforce local executor in rake tasks
-      ForemanTasks.dynflow.executor!
       load File.expand_path('../tasks/dynflow.rake', __FILE__)
     end
   end

data/lib/foreman_tasks/version.rb

@@ -1,3 +1,3 @@
 module ForemanTasks
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/lib/tasks/gettext.rake

@@ -1,16 +1,21 @@
-namespace :gettext do
-  task :store_action_names => :environment do
-    storage_file = "#{locale_path}/action_names.rb"
-    puts "writing action translations to: #{storage_file}"
+gettext_find_task = Rake::Task['gettext:find'] rescue nil
 
-    File.write storage_file,
-               "# Autogenerated!\n" +
-                   Actions::EntryAction.
-                       all_action_names.
-                       uniq.
-                       map { |n| %[_("#{n}")] }.
-                       join("\n")
+if gettext_find_task
+  namespace :gettext do
+    task :store_action_names => :environment do
+      storage_file = "#{locale_path}/action_names.rb"
+      puts "writing action translations to: #{storage_file}"
+
+      File.write storage_file,
+                 "# Autogenerated!\n" +
+                     Actions::EntryAction.
+                         all_action_names.
+                         uniq.
+                         map { |n| %[_("#{n}")] }.
+                         join("\n")
+    end
   end
+
+  gettext_find_task.enhance ['gettext:store_action_names']
 end
 
-Rake::Task['gettext:find'].enhance ['gettext:store_action_names']

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foreman-tasks
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-12 00:00:00.000000000 Z
+date: 2014-03-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -50,7 +50,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.6.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -58,7 +58,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.6.0
 - !ruby/object:Gem::Dependency
   name: sequel
   requirement: !ruby/object:Gem::Requirement
@@ -153,6 +153,7 @@ files:
 - config/routes.rb
 - db/migrate/20131209122644_create_foreman_tasks_locks.rb
 - db/migrate/20131205204140_create_foreman_tasks.rb
+- db/migrate/20140324104010_remove_foreman_tasks_progress.rb
 - lib/tasks/gettext.rake
 - lib/foreman_tasks/tasks/dynflow.rake
 - lib/foreman_tasks/engine.rb