foreman-tasks 0.1.0

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

@@ -0,0 +1,20 @@
+module ForemanTasks
+  module Concerns
+    module ArchitectureActionSubject
+      extend ActiveSupport::Concern
+      include ForemanTasks::Concerns::ActionSubject
+
+      def create_action
+        ::Actions::Foreman::Architecture::Create
+      end
+
+      def update_action
+        ::Actions::Foreman::Architecture::Update
+      end
+
+      def destroy_action
+        ::Actions::Foreman::Architecture::Destroy
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module ForemanTasks
+  module Concerns
+    module HostActionSubject
+      extend ActiveSupport::Concern
+      include ForemanTasks::Concerns::ActionSubject
+
+      def action_input_key
+        "host"
+      end
+
+      def available_locks
+        [:read, :write, :import_facts]
+      end
+
+      module ClassMethods
+        # TODO: This should get into the Foreman core, extracting the
+        # +importHostAndFacts+ method into two
+        def importHost(hostname, certname, proxy_id = nil)
+          raise(::Foreman::Exception.new("Invalid Hostname, must be a String")) unless hostname.is_a?(String)
+
+          # downcase everything
+          hostname.try(:downcase!)
+          certname.try(:downcase!)
+
+          host = certname.present? ? Host.find_by_certname(certname) : nil
+          host ||= Host.find_by_name hostname
+          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
+            host.certname = certname if certname.present?
+            # if proxy authentication is enabled and we have no puppet proxy set, use it.
+            host.puppet_proxy_id ||= proxy_id
+            host.save(:validate => false)
+            return host
+          else
+            return
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/foreman_tasks/lock.rb

@@ -0,0 +1,176 @@
+module ForemanTasks
+  class Lock < ActiveRecord::Base
+
+    LINK_LOCK_NAME = :link_resource
+    OWNER_LOCK_NAME = :task_owner
+
+    # not really intedet to be created in database, but it's used for
+    # explicitly stating that the all the locks for resource should be used
+    ALL_LOCK_NAME = :all
+
+    RESERVED_LOCK_NAMES = [LINK_LOCK_NAME, OWNER_LOCK_NAME, ALL_LOCK_NAME]
+
+    class LockConflict < StandardError
+      attr_reader :required_lock, :conflicting_locks
+      def initialize(required_lock, conflicting_locks)
+        super()
+        @required_lock     = required_lock
+        @conflicting_locks = conflicting_locks
+      end
+    end
+
+    belongs_to :task
+
+    belongs_to :resource, polymorphic: true
+
+    scope :active, -> do
+      joins(:task).where('foreman_tasks_tasks.state != ?', :stopped)
+    end
+
+    validates :task_id, :name, :resource_id, :resource_type, presence: true
+
+    validate do
+      unless available?
+        raise LockConflict.new(self, coliding_locks)
+      end
+    end
+
+    # returns true if it's possible to aquire this kind of lock
+    def available?
+      return true unless coliding_locks.any?
+    end
+
+    # returns a scope of the locks coliding with this one
+    def coliding_locks
+      coliding_locks_scope = Lock.active.where('foreman_tasks_locks.task_id != ?', task_id)
+      coliding_locks_scope = coliding_locks_scope.where(name:          name,
+                                                        resource_id:  resource_id,
+                                                        resource_type: resource_type)
+      unless self.exclusive?
+        coliding_locks_scope = coliding_locks_scope.where(:exclusive => true)
+      end
+      return coliding_locks_scope
+    end
+
+    class << self
+
+      # Locks the resource so that no other task can lock it while running.
+      # No other task related to the resource is not allowed (even not-locking ones)
+      # A typical usecase is resource deletion, where it's good idea to make sure
+      # nothing else related to the resource is really running.
+      def exclusive!(resource, uuid)
+        build_exclusive_locks(resource, uuid).each(&:save!)
+      end
+
+      def exclusive?(resource)
+        build_exclusive_locks(resource).all?(:available?)
+      end
+
+
+      # Locks the resource so that no other task can lock it while running.
+      # Other not-locking tasks are tolerated.
+      #
+      # The lock names allow to specify what locks should be activated. It has to
+      # be a subset of names defined in model's class available_locks method
+      #
+      # When no lock name is specified, the resource is locked against all the available
+      # locks.
+      #
+      # It also looks at +related_resources+ method of the resource to calcuate all
+      # the related resources (recursively) and links the task to them as well.
+      def lock!(resource, uuid, *lock_names)
+        build_locks(resource, lock_names, uuid).each(&:save!)
+      end
+
+      def lock?(resource, uuid, *lock_names)
+        build_locks(resource, lock_names, uuid).all?(&:available?)
+      end
+
+      # Assigns the resource to the task to easily track the task in context of
+      # the resource. This doesn't prevent other actions to lock the resource
+      # and should be used only for actions that tolerate other actions to be
+      # performed on the resource. Usually, this shouldn't needed to be done
+      # through the action directly, because the lock should assign it's parrent
+      # objects to the action srecursively (using +related_resources+ method in model
+      # objects)
+      def link!(resource, uuid)
+        build_link(resource, uuid).save!
+      end
+
+      def link?(resource, uuid)
+        build_link(resource, uuid).available?
+      end
+
+      # Records the information about the user that triggered the task
+      def owner!(user, uuid)
+        build_owner(user, uuid).save!
+      end
+
+      private
+
+      def all_lock_names(resource, include_links = false)
+        lock_names = []
+        if resource.class.respond_to?(:available_locks) &&
+              resource.class.available_locks.any?
+          lock_names.concat(resource.class.available_locks)
+        else
+          raise "The resource #{resource.class.name} doesn't define any available lock"
+        end
+        if lock_names.any? { |lock_name| RESERVED_LOCK_NAMES.include?(lock_name) }
+          raise "Lock name #{lock_name} is reserved"
+        end
+        lock_names.concat([LINK_LOCK_NAME, OWNER_LOCK_NAME]) if include_links
+        return lock_names
+      end
+
+      def build_exclusive_locks(resource, uuid = nil)
+        build_locks(resource, all_lock_names(resource, true), uuid)
+      end
+
+      def build_locks(resource, lock_names, uuid = nil)
+        locks = []
+        if lock_names.empty? || lock_names == [:all]
+          lock_names = all_lock_names(resource)
+        end
+        lock_names.map do |lock_name|
+          locks << build(uuid, resource, lock_name, true)
+        end
+        locks.concat(build_links(resource, uuid))
+        return locks
+      end
+
+      def build_links(resource, uuid = nil)
+        related_resources(resource).map do |related_resource|
+          build_link(related_resource, uuid)
+        end
+      end
+
+      def build_link(resource, uuid = nil)
+        build(uuid, resource, LINK_LOCK_NAME, false)
+      end
+
+      def build_owner(user, uuid = nil)
+        build(uuid, user, OWNER_LOCK_NAME, false)
+      end
+
+      def build(uuid, resource, lock_name, exclusive)
+        self.new(task_id:       uuid,
+                 name:          lock_name,
+                 resource_type: resource.class.name,
+                 resource_id:   resource.id,
+                 exclusive:     !!exclusive)
+      end
+
+      # recursively search for related resources of the resource (using
+      # the +related_resources+ method, avoiding the cycles
+      def related_resources(resource)
+        if resource.respond_to?(:related_resources_recursive)
+          return resource.related_resources_recursive
+        else
+          return []
+        end
+      end
+    end
+
+  end
+end

data/app/models/foreman_tasks/task.rb

@@ -0,0 +1,86 @@
+require 'uuidtools'
+
+module ForemanTasks
+  class Task < ActiveRecord::Base
+
+    self.primary_key = :id
+    before_create :generate_id
+
+    has_many :locks
+
+    # 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'
+
+    scoped_search :on => :id, :complete_value => false
+    scoped_search :on => :label, :complete_value => true
+    scoped_search :on => :state, :complete_value => true
+    scoped_search :on => :result, :complete_value => true
+    scoped_search :on => :started_at, :complete_value => false
+    scoped_search :in => :locks,  :on => :resource_type, :complete_value => true, :rename => "resource_type", :ext_method => :search_by_generic_resource
+    scoped_search :in => :locks,  :on => :resource_id, :complete_value => false, :rename => "resource_id", :ext_method => :search_by_generic_resource
+    scoped_search :in => :owners,  :on => :login, :complete_value => true, :rename => "owner.login", :ext_method => :search_by_owner
+    scoped_search :in => :owners,  :on => :firstname, :complete_value => true, :rename => "owner.firstname", :ext_method => :search_by_owner
+
+
+    scope :active, -> {  where('state != ?', :stopped) }
+
+    def input
+      {}
+    end
+
+    def output
+      {}
+    end
+
+    def owner
+      self.owners.first
+    end
+
+    def username
+      self.owner.try(:login)
+    end
+
+    def humanized
+      { action: label,
+        input:  "",
+        output: "" }
+    end
+
+    def cli_example
+      ""
+    end
+
+    # returns true if the task is running or waiting to be run
+    def pending
+      self.state != 'stopped'
+    end
+
+    def self.search_by_generic_resource(key, operator, value)
+      key_name = self.connection.quote_column_name(key.sub(/^.*\./,''))
+      condition = sanitize_sql_for_conditions(["foreman_tasks_locks.#{key_name} #{operator} ?", value])
+
+      return {:conditions => condition, :joins => :locks }
+    end
+
+    def self.search_by_owner(key, operator, value)
+      key_name = self.connection.quote_column_name(key.sub(/^.*\./,''))
+      joins = <<-JOINS
+      INNER JOIN foreman_tasks_locks AS foreman_tasks_locks_owner
+                 ON (foreman_tasks_locks_owner.task_id = foreman_tasks_tasks.id AND
+                     foreman_tasks_locks_owner.resource_type = 'User' AND
+                     foreman_tasks_locks_owner.name = '#{Lock::OWNER_LOCK_NAME}')
+      INNER JOIN users
+                 ON (users.id = foreman_tasks_locks_owner.resource_id)
+      JOINS
+      condition = sanitize_sql_for_conditions(["users.#{key_name} #{operator} ?", value])
+      return {:conditions => condition, :joins => joins }
+    end
+
+    protected
+
+    def generate_id
+      self.id ||= UUIDTools::UUID.random_create.to_s
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+module ForemanTasks
+  class Task::DynflowTask < ForemanTasks::Task
+
+    def update_from_dynflow(data, planned)
+      self.external_id = data[:id]
+      self.started_at  = data[:started_at]
+      self.ended_at    = data[:ended_at]
+      self.state       = data[:state].to_s
+      self.result      = data[:result].to_s
+
+      if planned
+        # for now, this part needs to laod the execution_plan to
+        # load extra data, there is place for optimization on Dynflow side
+        # if needed (getting more keys into the data value)
+        unless self.label
+          self.label = main_action.action_class.name
+        end
+        update_progress
+      end
+      self.save!
+    end
+
+    def update_progress
+      self.progress = execution_plan.progress
+    end
+
+    def execution_plan
+      @execution_plan ||= ForemanTasks.dynflow.world.persistence.load_execution_plan(external_id)
+    end
+
+    def main_action
+      return @main_action if @main_action
+      main_action_id = execution_plan.root_plan_step.action_id
+      @main_action = execution_plan.actions.find { |action| action.id == main_action_id }
+    end
+
+    def input
+      main_action.respond_to?(:task_input) && main_action.task_input
+    end
+
+    def output
+      main_action.respond_to?(:task_output) && main_action.task_output
+    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 }
+    end
+
+    def cli_example
+      if main_action.respond_to?(:cli_example)
+        main_action.cli_example
+      end
+    end
+
+    protected
+
+    def main_action
+      return @main_action if @main_action
+      main_action_id = execution_plan.root_plan_step.action_id
+      @main_action = execution_plan.actions.find { |action| action.id == main_action_id }
+    end
+  end
+end

data/app/views/foreman_tasks/api/tasks/show.json.rabl

@@ -0,0 +1,5 @@
+object @task if @task
+
+attributes :id, :label, :pending
+attributes :username, :started_at, :ended_at, :state, :result, :progress
+attributes :input, :output, :humanized, :cli_example

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

@@ -0,0 +1,51 @@
+<% title _("Tasks") %>
+<% title_actions help_path%>
+
+<style>
+  .task-id {
+    white-space: nowrap;
+  }
+  .param-name {
+    display: inline-block;
+    width: 10em;
+  }
+
+  .task-details pre {
+    white-space: pre;
+    word-break: normal;
+  }
+</style>
+
+<script>
+$(document).on('click', ".table-two-pane td.two-pane-link", function(e) {
+  var item = $(this).find("a");
+  if(item.length){
+    e.preventDefault();
+    two_pane_open(item);
+  }
+});
+
+</script>
+<table class="table table-bordered table-striped table-two-pane">
+  <tr>
+    <th><%= _("Action") %></th>
+    <th><%= _("State") %></th>
+    <th><%= _("Result") %></th>
+    <th><%= sort :started_at, :as => _("Started at") %></th>
+    <th><%= _("User") %></th>
+  </tr>
+  <% for task in @tasks %>
+    <tr>
+      <td class="task-id two-pane-link">
+        <%= link_to_if_authorized(format_task_input(task, true),
+        hash_for_foreman_tasks_task_path(:id => task)) %>
+      </td>
+      <td><%= task.state %></td>
+      <td><%= task.result %></td>
+      <td><%= task.started_at %></td>
+      <td><%= task.username %></td>
+    </tr>
+  <% end %>
+</table>
+<%= page_entries_info @tasks %>
+<%= will_paginate @tasks %>