foreman-tasks 0.3.6 → 0.4.0

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

@@ -1,15 +1,9 @@
 module ForemanTasks
   module Concerns
-    module ActionSubject # TODO slit to two modules: auto planning, acting as action subject
+    module ActionSubject
 
       extend ActiveSupport::Concern
 
-      included do
-        after_create :plan_create_action
-        after_update :plan_update_action
-        after_destroy :plan_destroy_action
-      end
-
       module ClassMethods
         def available_locks
           [:read, :write]
@@ -49,115 +43,6 @@ module ForemanTasks
         mine + mine.reduce(Set.new) { |s, resource| s + get_all_related_resources.(resource) }
       end
 
-      # to make the triggered action synchronous
-      def sync_action!
-        @dynflow_sync_action = true
-      end
-
-      def sync_action_flag_reset!
-        @dynflow_sync_action = false
-      end
-
-      def create_action
-      end
-
-      def update_action
-      end
-
-      def destroy_action
-      end
-
-      def plan_create_action
-        plan_action(create_action, self) if create_action
-        return true
-      end
-
-      def plan_update_action
-        plan_action(update_action, self) if update_action
-        return true
-      end
-
-      def plan_destroy_action
-        plan_action(destroy_action, self) if destroy_action
-        return true
-      end
-
-      # Perform planning phase of the action tied with the model event.
-      # We do it separately from the execution phase, because the transaction
-      # of planning phase is expected to be commited when execution occurs. Also
-      # we want to be able to rollback the whole db operation when planning fails.
-      def plan_action(action_class, *args)
-        @execution_plan = ::ForemanTasks.dynflow.world.plan(action_class, *args)
-        raise @execution_plan.errors.first if @execution_plan.error?
-      end
-
-      def save(*)
-        dynflow_task_wrap(:save) { super }
-      end
-
-      def save!(*)
-        dynflow_task_wrap(:save) { super }
-      end
-
-      def destroy
-        dynflow_task_wrap(:destroy) { super }
-      end
-
-      # Makes sure the execution plan is executed AFTER the transaction is commited.
-      # We can't user after_commit filters because they don't allow to raise
-      # exceptions in there, so we would not be able to report that something
-      # went wrong when running a sync_task.:
-      #
-      #   http://guides.rubyonrails.org/v3.2.14/active_record_validations_callbacks.html#transaction-callbacks
-      #
-      # That's why we need to override save and destroy methods instead.
-      # Another reason why one should avoid callbacks for orchestration.
-      #
-      # Also, it makes sure the save is not run inside other transaction because
-      # we would start the execution phase inside this transaction which would lead
-      # to unexpected results.
-      def dynflow_task_wrap(method)
-        action = case method
-                 when :save
-                   self.new_record? ? create_action : update_action
-                 when :destroy
-                   destroy_action
-                 else
-                   raise 'unexpected method'
-                 end
-        if action
-          ensure_not_in_transaction!
-          yield.tap do |result|
-            execute_planned_action if result
-            sync_action_flag_reset!
-          end
-        else
-          yield
-        end
-      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"
-        end
-      end
-
-      # Execute the prepared execution plan after the db transaction was commited
-      def execute_planned_action
-        if @execution_plan
-          run = ::ForemanTasks.dynflow.world.execute(@execution_plan.id)
-          if @dynflow_sync_action
-            run.wait
-            if run.value.error?
-              task = ForemanTasks::Task::DynflowTask.find_by_external_id!(@execution_plan.id)
-              raise ForemanTasks::TaskError.new(task)
-            end
-          end
-        end
-        return true
-      end
     end
   end
 end

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

@@ -0,0 +1,129 @@
+module ForemanTasks
+  module Concerns
+    module ActionTriggering
+
+      extend ActiveSupport::Concern
+
+      included do
+        after_create :plan_create_action
+        after_update :plan_update_action
+        after_destroy :plan_destroy_action
+      end
+
+      # @override
+      def create_action
+      end
+
+      # @override
+      def update_action
+      end
+
+      # @override
+      def destroy_action
+      end
+
+      def save(*)
+        dynflow_task_wrap(:save) { super }
+      end
+
+      def save!(*)
+        dynflow_task_wrap(:save) { super }
+      end
+
+      def destroy
+        dynflow_task_wrap(:destroy) { super }
+      end
+
+      protected
+
+      def sync_action_flag_reset!
+        @dynflow_sync_action = false
+      end
+
+      # to make the triggered action synchronous
+      def sync_action!
+        @dynflow_sync_action = true
+      end
+
+      def plan_create_action
+        plan_action(create_action, self) if create_action
+        return true
+      end
+
+      def plan_update_action
+        plan_action(update_action, self) if update_action
+        return true
+      end
+
+      def plan_destroy_action
+        plan_action(destroy_action, self) if destroy_action
+        return true
+      end
+
+      # Perform planning phase of the action tied with the model event.
+      # We do it separately from the execution phase, because the transaction
+      # of planning phase is expected to be commited when execution occurs. Also
+      # we want to be able to rollback the whole db operation when planning fails.
+      def plan_action(action_class, *args)
+        @execution_plan = ::ForemanTasks.dynflow.world.plan(action_class, *args)
+        raise @execution_plan.errors.first if @execution_plan.error?
+      end
+
+      # Makes sure the execution plan is executed AFTER the transaction is commited.
+      # We can't user after_commit filters because they don't allow to raise
+      # exceptions in there, so we would not be able to report that something
+      # went wrong when running a sync_task.:
+      #
+      #   http://guides.rubyonrails.org/v3.2.14/active_record_validations_callbacks.html#transaction-callbacks
+      #
+      # That's why we need to override save and destroy methods instead.
+      # Another reason why one should avoid callbacks for orchestration.
+      #
+      # Also, it makes sure the save is not run inside other transaction because
+      # we would start the execution phase inside this transaction which would lead
+      # to unexpected results.
+      def dynflow_task_wrap(method)
+        action = case method
+                 when :save
+                   self.new_record? ? create_action : update_action
+                 when :destroy
+                   destroy_action
+                 else
+                   raise 'unexpected method'
+                 end
+        if action
+          ensure_not_in_transaction!
+          yield.tap do |result|
+            execute_planned_action if result
+            sync_action_flag_reset!
+          end
+        else
+          yield
+        end
+      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"
+        end
+      end
+
+      # Execute the prepared execution plan after the db transaction was commited
+      def execute_planned_action
+        if @execution_plan
+          run = ::ForemanTasks.dynflow.world.execute(@execution_plan.id)
+          if @dynflow_sync_action
+            run.wait
+            if run.value.error?
+              task = ForemanTasks::Task::DynflowTask.find_by_external_id!(@execution_plan.id)
+              raise ForemanTasks::TaskError.new(task)
+            end
+          end
+        end
+        return true
+      end
+    end
+  end
+end

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

@@ -3,6 +3,7 @@ module ForemanTasks
     module ArchitectureActionSubject
       extend ActiveSupport::Concern
       include ForemanTasks::Concerns::ActionSubject
+      include ForemanTasks::Concerns::ActionTriggering
 
       def create_action
         ::Actions::Foreman::Architecture::Create

data/app/views/foreman_tasks/tasks/show.html.erb

@@ -40,8 +40,13 @@
       <span class="param-name"><%= _("Progress") %>:</span>
       <span class="param-value">
         <div class="progress progress-striped">
-          <div class="bar" style="width: <%= 100 * @task.progress %>%;"></div>
+          <% progress = 100 * @task.progress %>
+          <div class="progress-bar" role="progressbar" aria-valuenow="<%= progress %>"
+               aria-valuemin="0" aria-valuemax="100" style="width: <%= progress %>%">
+            <span class="sr-only"><%= progress %>% Complete</span>
+          </div>
         </div>
+      </span>
     </div>
     <% if @task.cli_example %>
       <div>

data/lib/foreman_tasks/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foreman-tasks
 version: !ruby/object:Gem::Version
-  version: 0.3.6
+  version: 0.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-10 00:00:00.000000000 Z
+date: 2014-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -143,6 +143,7 @@ files:
 - app/controllers/foreman_tasks/tasks_controller.rb
 - app/controllers/foreman_tasks/concerns/hosts_controller_extension.rb
 - app/models/foreman_tasks/concerns/architecture_action_subject.rb
+- app/models/foreman_tasks/concerns/action_triggering.rb
 - app/models/foreman_tasks/concerns/host_action_subject.rb
 - app/models/foreman_tasks/concerns/action_subject.rb
 - app/models/foreman_tasks/task/dynflow_task.rb