foreman-tasks 0.1.0

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

@@ -0,0 +1,77 @@
+<div class="task-details">
+  <%= form_for @task, :url => "#" do %>
+    <div>
+      <span class="param-name"><%= _("Id") %>:</span>
+      <span class="param-value"><%= @task.id %></span>
+    </div>
+    <div>
+      <span class="param-name"><%= _("Label") %>:</span>
+      <span class="param-value"><%= @task.label %></span>
+    </div>
+    <div>
+      <span class="param-name"><%= _("Name") %>:</span>
+      <span class="param-value"><%= @task.humanized[:action] %></span>
+    </div>
+    <div>
+      <span class="param-name"><%= _("Owner") %>:</span>
+      <span class="param-value"><%= @task.username %></span>
+    </div>
+    <div>
+      <span class="param-name"><%= _("Started at") %>:</span>
+      <span class="param-value"><%= @task.started_at %></span>
+    </div>
+    <div>
+      <span class="param-name"><%= _("Ended at") %>:</span>
+      <span class="param-value"><%= @task.ended_at %></span>
+    </div>
+    <div>
+      <span class="param-name"><%= _("State") %>:</span>
+      <span class="param-value"><%= @task.state %></span>
+    </div>
+    <div>
+      <span class="param-name"><%= _("Result") %>:</span>
+      <span class="param-value"><%= @task.result %></span>
+    </div>
+    <div>
+      <span class="param-name"><%= _("Params") %>:</span>
+      <span class="param-value"><%= format_task_input(@task) %></span>
+    </div>
+    <div>
+      <span class="param-name"><%= _("Progress") %>:</span>
+      <span class="param-value">
+        <div class="progress progress-striped">
+          <div class="bar" style="width: <%= 100 * @task.progress %>%;"></div>
+        </div>
+    </div>
+    <% if @task.cli_example %>
+      <div>
+        <span class="param-name"><%= _("CLI Example") %>:</span>
+        <span class="param-value">
+          <pre><%= @task.cli_example %></pre>
+        </span>
+      </div>
+    <% end %>
+    <div>
+      <span class="param-name"><%= _("Output") %>:</span>
+      <span class="param-value">
+        <pre><%= @task.humanized[:output] %></pre>
+      </span>
+    </div>
+    <div>
+      <span class="param-name"><%= _("Raw input") %>:</span>
+      <span class="param-value">
+        <pre><%= @task.input.pretty_inspect %></pre>
+      </span>
+    </div>
+    <div>
+      <span class="param-name"><%= _("Raw output") %>:</span>
+      <span class="param-value">
+        <pre><%= @task.output.pretty_inspect %></pre>
+      </span>
+    </div>
+    <div>
+      <span class="param-name"><%= _("External Id") %>:</span>
+      <span class="param-value"><%= @task.external_id %></span>
+    </div>
+  <% end %>
+</div>

data/bin/dynflow-executor

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+
+options = { foreman_root: Dir.pwd }
+
+opts = OptionParser.new do |opts|
+  opts.banner = <<BANNER
+Run Dynflow executor for Foreman tasks.
+
+Usage: #{File.basename($0)} [options] ACTION"
+
+ACTION can be one of:
+
+  * start   - start the executor on background. It creates these files
+              in tmp/pid directory:
+
+                * dynflow_executor_monitor.pid - pid of monitor ensuring
+                                                 the executor keeps running
+                * dynflow_executor.pid         - pid of the executor itself
+                * dynflow_executor.output      - stdout of the executor
+  * stop    - stops the running executor
+  * restart - restarts the running executor
+  * run     - run the executor in foreground
+
+BANNER
+
+  opts.on('-h', '--help', 'Show this message') do
+    puts opts
+    exit 1
+  end
+  opts.on('-f', '--foreman-root=PATH', "Path to Foreman Rails root path. By default '#{options[:foreman_root]}'") do |path|
+    options[:foreman_root] = path
+  end
+end
+
+args = opts.parse!(ARGV)
+command = args.first || 'run'
+
+app_file = File.expand_path('./config/application', options[:foreman_root])
+require app_file
+
+ForemanTasks::Dynflow::Daemon.new.run_background(command, options)

data/config/routes.rb

@@ -0,0 +1,20 @@
+Foreman::Application.routes.draw do
+  namespace :foreman_tasks do
+    resources :tasks, :only => [:index, :show] do
+      collection do
+        get 'auto_complete_search'
+      end
+    end
+
+    namespace :api do
+      resources :tasks, :only => [:show] do
+        post :bulk_search, :on => :collection
+      end
+    end
+
+    if ForemanTasks.dynflow.required?
+      require 'dynflow/web_console'
+      mount ForemanTasks.dynflow.web_console => "/dynflow"
+    end
+  end
+end

data/db/migrate/20131205204140_create_foreman_tasks.rb

@@ -0,0 +1,15 @@
+class CreateForemanTasks < ActiveRecord::Migration
+  def change
+    create_table :foreman_tasks_tasks, :id => false do |t|
+      t.string :id, primary_key: true
+      t.string :type, index: true, null: false
+      t.string :label, index: true
+      t.datetime :started_at, index: true
+      t.datetime :ended_at, index: true
+      t.string :state, index: true, null: false
+      t.string :result, index: true, null: false
+      t.decimal :progress, index: true, precision: 5, scale: 4
+      t.string :external_id, index: true
+    end
+  end
+end

data/db/migrate/20131209122644_create_foreman_tasks_locks.rb

@@ -0,0 +1,12 @@
+class CreateForemanTasksLocks < ActiveRecord::Migration
+  def change
+    create_table :foreman_tasks_locks do |t|
+      t.string :task_id, index: true, null: false
+      t.string :name, index: true, null: false
+      t.string :resource_type, index: true
+      t.integer :resource_id
+      t.boolean :exclusive, index: true
+    end
+    add_index :foreman_tasks_locks, [:resource_type, :resource_id]
+  end
+end

data/lib/foreman-tasks.rb

@@ -0,0 +1 @@
+require 'foreman_tasks'

data/lib/foreman_tasks.rb

@@ -0,0 +1,20 @@
+require 'foreman_tasks/version'
+require 'foreman_tasks/engine'
+require 'foreman_tasks/dynflow'
+
+module ForemanTasks
+
+  def self.dynflow
+    @dynflow ||= ForemanTasks::Dynflow.new
+  end
+
+  def self.trigger(action, *args, &block)
+    dynflow.world.trigger action, *args, &block
+  end
+
+  def self.async_task(action, *args, &block)
+    run = trigger(action, *args, &block)
+    ForemanTasks::Task::DynflowTask.find_by_external_id(run.id)
+  end
+
+end

data/lib/foreman_tasks/dynflow.rb

@@ -0,0 +1,101 @@
+require 'dynflow'
+
+module ForemanTasks
+  # Class for configuring and preparing the Dynflow runtime environment.
+  class Dynflow
+    require 'foreman_tasks/dynflow/configuration'
+    require 'foreman_tasks/dynflow/persistence'
+    require 'foreman_tasks/dynflow/daemon'
+
+    def initialize
+      @required = false
+    end
+
+    def config
+      @config ||= ForemanTasks::Dynflow::Configuration.new
+    end
+
+    # call this method if your engine uses Dynflow
+    def require!
+      @required = true
+    end
+
+    def required?
+      @required
+    end
+
+    def initialized?
+      !@world.nil?
+    end
+
+    def initialize!
+      return unless @required
+      return @world if @world
+      config.initialize_world.tap do |world|
+        @world = world
+
+        ActionDispatch::Reloader.to_prepare do
+          ForemanTasks.dynflow.eager_load_actions!
+          world.reload!
+        end
+
+        unless config.remote?
+          at_exit { world.terminate.wait }
+
+          # for now, we can check the consistency only when there
+          # is no remote executor. We should be able to check the consistency
+          # every time the new world is created when there is a register
+          # of executors
+          world.consistency_check
+        end
+      end
+    end
+
+    # Mark that the process is executor. This prevents the remote setting from
+    # applying. Needs to be set up before the world is being initialized
+    def executor!
+      @executor = true
+    end
+
+    def executor?
+      @executor
+    end
+
+    def reinitialize!
+      @world = nil
+      self.initialize!
+    end
+
+    def world
+      return @world if @world
+
+      initialize! if config.lazy_initialization
+      unless @world
+        raise 'The Dynflow world was not initialized yet. '\
+              'If your plugin uses it, make sure to call ForemanTasks.dynflow.require! '\
+              'in some initializer'
+      end
+
+      return @world
+    end
+
+    def web_console
+      ::Dynflow::WebConsole.setup do
+        before do
+          # TODO: propper authentication
+          User.current = User.first
+        end
+
+        set(:world) { ForemanTasks.dynflow.world }
+      end
+    end
+
+    def eager_load_actions!
+      config.eager_load_paths.each do |load_path|
+        Dir.glob("#{load_path}/**/*.rb").sort.each do |file|
+          require_dependency file
+        end
+      end
+    end
+  end
+end

data/lib/foreman_tasks/dynflow/configuration.rb

@@ -0,0 +1,86 @@
+module ForemanTasks
+  class Dynflow::Configuration
+
+    # for logging action related info (such as exceptions raised in side
+    # the actions' methods
+    attr_accessor :action_logger
+
+    # for logging dynflow related info about the progress of the execution etc.
+    attr_accessor :dynflow_logger
+
+    # the number of threads in the pool handling the execution
+    attr_accessor :pool_size
+
+    # set true if the executor runs externally (by default true in procution, othewise false)
+    attr_accessor :remote
+    alias_method :remote?, :remote
+
+    # if remote set to true, use this path for socket communication
+    # between this process and the external executor
+    attr_accessor :remote_socket_path
+
+    # what persistence adapater should be used, by default, it uses Sequlel
+    # adapter based on Rails app database.yml configuration
+    attr_accessor :persistence_adapter
+
+    # what transaction adapater should be used, by default, it uses the ActiveRecord
+    # based adapter, expecting ActiveRecord is used as ORM in the application
+    attr_accessor :transaction_adapter
+
+    attr_accessor :eager_load_paths
+
+    attr_accessor :lazy_initialization
+
+    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.persistence_adapter = default_persistence_adapter
+      self.transaction_adapter = ::Dynflow::TransactionAdapters::ActiveRecord.new
+      self.eager_load_paths    = []
+      self.lazy_initialization = !Rails.env.production?
+    end
+
+    def initialize_world(world_class = ::Dynflow::World)
+      world_class.new(world_options)
+    end
+
+    # No matter what config.remote says, when the process is marked as executor,
+    # it can't be remote
+    def remote?
+      !ForemanTasks.dynflow.executor? && @remote
+    end
+
+    protected
+
+    # generates the options hash consumable by the Dynflow's world
+    def world_options
+      { logger_adapter:      ::Dynflow::LoggerAdapters::Delegator.new(action_logger, dynflow_logger),
+        pool_size:           5,
+        persistence_adapter: persistence_adapter,
+        transaction_adapter: transaction_adapter,
+        executor:            -> world { initialize_executor world } }
+    end
+
+    def default_persistence_adapter
+      ForemanTasks::Dynflow::Persistence.new(default_sequel_adapter_options)
+    end
+
+    def default_sequel_adapter_options
+      db_config            = ActiveRecord::Base.configurations[Rails.env].dup
+      db_config['adapter'] = 'postgres' if db_config['adapter'] == 'postgresql'
+      db_config['adapter'] = 'sqlite' if db_config['adapter'] == 'sqlite3'
+      return db_config
+    end
+
+    def initialize_executor(world)
+      if self.remote?
+        ::Dynflow::Executors::RemoteViaSocket.new(world, self.remote_socket_path)
+      else
+        ::Dynflow::Executors::Parallel.new(world, self.pool_size)
+      end
+    end
+  end
+end

data/lib/foreman_tasks/dynflow/daemon.rb

@@ -0,0 +1,88 @@
+module ForemanTasks
+  class Dynflow::Daemon
+
+    # load the Rails environment and initialize the executor and listener
+    # in this thread.
+    def run(foreman_root = Dir.pwd)
+      STDERR.puts("Starting Rails environment")
+      foreman_env_file = File.expand_path("./config/environment.rb", foreman_root)
+      unless File.exists?(foreman_env_file)
+        raise "#{foreman_root} doesn't seem to be a foreman root directory"
+      end
+      ForemanTasks.dynflow.executor!
+      require foreman_env_file
+      STDERR.puts("Starting listener")
+      daemon = ::Dynflow::Daemon.new(listener, world, lock_file)
+      STDERR.puts("Everything ready")
+      daemon.run
+    end
+
+    # run the executor as a daemon
+    def run_background(command = "start", options = {})
+      default_options = { foreman_root: Dir.pwd,
+                          process_name: 'dynflow_executor',
+                          pid_dir: "#{Rails.root}/tmp/pids",
+                          wait_attempts: 300,
+                          wait_sleep: 1 }
+      options = default_options.merge(options)
+      begin
+        require 'daemons'
+      rescue LoadError
+        raise "You need to add gem 'daemons' to your Gemfile if you wish to use it."
+      end
+
+      unless %w[start stop restart run].include?(command)
+        raise "Command exptected to be 'start', 'stop', 'restart', 'run', was #{command.inspect}"
+      end
+
+      STDERR.puts("Dynflow Executor: #{command} in progress")
+
+      Daemons.run_proc(options[:process_name],
+                       :dir => options[:pid_dir],
+                       :dir_mode => :normal,
+                       :monitor => true,
+                       :log_output => true,
+                       :ARGV => [command]) do |*args|
+        begin
+          run(options[:foreman_root])
+        rescue => e
+          STDERR.puts e.message
+          Rails.logger.fatal e
+          exit 1
+        end
+      end
+      if command == "start" || command == "restart"
+        STDERR.puts('Waiting for the executor to be ready...')
+        options[:wait_attempts].times do |i|
+          STDERR.print('.')
+          if File.exists?(lock_file)
+            STDERR.puts('executor started successfully')
+            break
+          else
+            sleep options[:wait_sleep]
+          end
+        end
+      end
+    end
+
+    protected
+
+    def listener
+       ::Dynflow::Listeners::Socket.new(world, socket_path)
+    end
+
+    def socket_path
+      ForemanTasks.dynflow.config.remote_socket_path
+    end
+
+    def lock_file
+      File.join(Rails.root, 'tmp', 'dynflow_executor.lock')
+    end
+
+    def world
+       ForemanTasks.dynflow.world
+    end
+
+
+  end
+end