foreman-tasks 0.10.0 → 0.10.1

data/deploy/foreman-tasks.service

@@ -1,16 +0,0 @@
-[Unit]
-Description=Foreman jobs daemon
-Documentation=https://github.com/theforeman/foreman-tasks
-After=network.target remote-fs.target nss-lookup.target
-
-[Service]
-Type=forking
-User=foreman
-TimeoutSec=600
-WorkingDirectory=/usr/share/foreman
-ExecStart=/usr/bin/foreman-tasks start 
-ExecStop=/usr/bin/foreman-tasks stop
-EnvironmentFile=-/etc/sysconfig/foreman-tasks
-
-[Install]
-WantedBy=multi-user.target

data/deploy/foreman-tasks.sysconfig

@@ -1,26 +0,0 @@
-FOREMAN_USER=foreman
-BUNDLER_EXT_HOME=/usr/share/foreman
-RAILS_RELATIVE_URL_ROOT=$FOREMAN_PREFIX
-RAILS_ENV=production
-FOREMAN_LOGGING=warn
-FOREMAN_LOGGING_SQL=warn
-FOREMAN_TASK_PARAMS="-p foreman"
-FOREMAN_LOG_DIR=/var/log/foreman
-
-RUBY_GC_MALLOC_LIMIT=4000100
-RUBY_GC_MALLOC_LIMIT_MAX=16000100
-RUBY_GC_MALLOC_LIMIT_GROWTH_FACTOR=1.1
-RUBY_GC_OLDMALLOC_LIMIT=16000100
-RUBY_GC_OLDMALLOC_LIMIT_MAX=16000100
-
-#Set the number of executors you want to run
-#EXECUTORS_COUNT=1
-
-#Set memory limit for executor process, before it's restarted automatically
-#EXECUTOR_MEMORY_LIMIT=2gb
-
-#Set delay before first memory polling to let executor initialize (in sec)
-#EXECUTOR_MEMORY_MONITOR_DELAY=7200 #default: 2 hours
-
-#Set memory polling interval, process memory will be checked every N seconds.
-#EXECUTOR_MEMORY_MONITOR_INTERVAL=60

data/lib/foreman_tasks/dynflow/daemon.rb

@@ -1,143 +0,0 @@
-require 'fileutils'
-require 'daemons'
-require 'get_process_mem'
-require 'dynflow/watchers/memory_consumption_watcher'
-
-module ForemanTasks
-  class Dynflow::Daemon
-    attr_reader :dynflow_memory_watcher_class,
-                :daemons_class
-
-    # make Daemon dependency injection ready for testing purposes
-    def initialize(
-      dynflow_memory_watcher_class = ::Dynflow::Watchers::MemoryConsumptionWatcher,
-      daemons_class = ::Daemons
-    )
-      @dynflow_memory_watcher_class = dynflow_memory_watcher_class
-      @daemons_class = daemons_class
-    end
-
-    # load the Rails environment and initialize the executor
-    # in this thread.
-    def run(foreman_root = Dir.pwd, options = {})
-      STDERR.puts('Starting Rails environment')
-      foreman_env_file = File.expand_path('./config/environment.rb', foreman_root)
-      unless File.exist?(foreman_env_file)
-        raise "#{foreman_root} doesn't seem to be a foreman root directory"
-      end
-
-      STDERR.puts("Starting dynflow with the following options: #{options}")
-
-      ForemanTasks.dynflow.executor!
-
-      if options[:memory_limit] > 0
-        ForemanTasks.dynflow.config.on_init do |world|
-          memory_watcher = initialize_memory_watcher(world, options[:memory_limit], options)
-          world.terminated.on_completion do
-            STDERR.puts("World has been terminated")
-            memory_watcher = nil # the object can be disposed
-          end
-        end
-      end
-
-      require foreman_env_file
-      STDERR.puts("Everything ready for world: #{(ForemanTasks.dynflow.initialized? ? ForemanTasks.dynflow.world.id : nil)}")
-      sleep
-    ensure
-      STDERR.puts('Exiting')
-    end
-
-    # run the executor as a daemon
-    def run_background(command = 'start', options = {})
-      options = default_options.merge(options)
-      FileUtils.mkdir_p(options[:pid_dir])
-      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")
-
-      options[:executors_count].times do
-        daemons_class.run_proc(
-          options[:process_name],
-          daemons_options(command, options)
-        ) do |*_args|
-          begin
-            ::Logging.reopen
-            run(options[:foreman_root], options)
-          rescue => e
-            STDERR.puts e.message
-            Foreman::Logging.exception('Failed running foreman-tasks daemon', e)
-            exit 1
-          end
-        end
-      end
-    end
-
-    protected
-
-    def world
-      ForemanTasks.dynflow.world
-    end
-
-    private
-
-    def daemons_options(command, options)
-      {
-        :multiple => true,
-        :dir => options[:pid_dir],
-        :log_dir => options[:log_dir],
-        :dir_mode => :normal,
-        :monitor => true,
-        :log_output => true,
-        :log_output_syslog => true,
-        :monitor_interval => [options[:memory_polling_interval] / 2, 30].min,
-        :ARGV => [command]
-      }
-    end
-
-    def default_options
-      {
-        foreman_root: Dir.pwd,
-        process_name: 'dynflow_executor',
-        pid_dir: "#{Rails.root}/tmp/pids",
-        log_dir: File.join(Rails.root, 'log'),
-        wait_attempts: 300,
-        wait_sleep: 1,
-        executors_count: (ENV['EXECUTORS_COUNT'] || 1).to_i,
-        memory_limit: begin
-                        (ENV['EXECUTOR_MEMORY_LIMIT'] || '').to_gb.gigabytes
-                      rescue RuntimeError
-                        ENV['EXECUTOR_MEMORY_LIMIT'].to_i
-                      end,
-        memory_init_delay: (ENV['EXECUTOR_MEMORY_MONITOR_DELAY'] || 7200).to_i, # 2 hours
-        memory_polling_interval: (ENV['EXECUTOR_MEMORY_MONITOR_INTERVAL'] || 60).to_i
-      }
-    end
-
-    def initialize_memory_watcher(world, memory_limit, options)
-      watcher_options = {}
-      watcher_options[:polling_interval] = options[:memory_polling_interval]
-      watcher_options[:initial_wait] = options[:memory_init_delay]
-      watcher_options[:memory_checked_callback] = ->(current_memory, memory_limit) { log_memory_within_limit(current_memory, memory_limit) }
-      watcher_options[:memory_limit_exceeded_callback] = ->(current_memory, memory_limit) { log_memory_limit_exceeded(current_memory, memory_limit) }
-      dynflow_memory_watcher_class.new(world, memory_limit, watcher_options)
-    end
-
-    def log_memory_limit_exceeded(current_memory, memory_limit)
-      message = "Memory level exceeded, registered #{current_memory} bytes, which is greater than #{memory_limit} limit."
-      Foreman::Logging.logger('foreman-tasks').error(message)
-    end
-
-    def log_memory_within_limit(current_memory, memory_limit)
-      message = "Memory level OK, registered #{current_memory} bytes, which is less than #{memory_limit} limit."
-      Foreman::Logging.logger('foreman-tasks').debug(message)
-    end
-  end
-end

data/lib/foreman_tasks/tasks/dynflow.rake

@@ -1,7 +0,0 @@
-namespace :foreman_tasks do
-  namespace :dynflow do
-    task :executor do
-      ForemanTasks::Dynflow::Daemon.new.run
-    end
-  end
-end

data/test/unit/daemon_test.rb

@@ -1,86 +0,0 @@
-require 'test_helper'
-
-class DaemonTest < ActiveSupport::TestCase
-  setup do
-    @dynflow_memory_watcher = mock('memory_watcher')
-    @daemons = mock('daemons')
-    @daemon = ForemanTasks::Dynflow::Daemon.new(
-      @dynflow_memory_watcher,
-      @daemons
-    )
-    @world_class = mock('dummy world factory')
-    @dummy_world = Dynflow::Testing::DummyWorld.new
-    @dummy_world.stubs(:auto_execute)
-    @dummy_world.stubs(:terminated).returns(Concurrent.event)
-    @world_class.stubs(:new).returns(@dummy_world)
-    @dynflow = ForemanTasks::Dynflow.new(@world_class)
-    ForemanTasks.stubs(:dynflow).returns(@dynflow)
-    @dynflow.require!
-  end
-
-  test 'run command creates a watcher if memory_limit option specified' do
-    current_folder = File.expand_path('../', __FILE__)
-
-    @dynflow_memory_watcher.expects(:new).with do |_world, memory_limit, _watcher_options|
-      memory_limit == 1000
-    end
-    @daemon.stubs(:sleep).returns(true) # don't pause the execution
-
-    @daemon.run(current_folder, memory_limit: 1000)
-    # initialization should be performed inside the foreman environment,
-    # which is mocked here
-    @dynflow.initialize!
-  end
-
-  test 'run command sets parameters to watcher' do
-    current_folder = File.expand_path('../', __FILE__)
-
-    @dynflow_memory_watcher.expects(:new).with do |_world, memory_limit, watcher_options|
-      memory_limit == 1000 &&
-        watcher_options[:polling_interval] == 100 &&
-        watcher_options[:initial_wait] == 200
-    end
-    @daemon.stubs(:sleep).returns(true) # don't pause the execution
-
-    @daemon.run(
-      current_folder,
-      memory_limit: 1000,
-      memory_polling_interval: 100,
-      memory_init_delay: 200
-    )
-    # initialization should be performed inside the foreman environment,
-    # which is mocked here
-    @dynflow.initialize!
-  end
-
-  test 'run_background command executes run with all params set as a daemon' do
-    @daemon.expects(:run).twice.with do |_folder, options|
-      options[:memory_limit] == 1000 &&
-        options[:memory_init_delay] == 100 &&
-        options[:memory_polling_interval] == 200
-    end
-    @daemons.expects(:run_proc).twice.yields
-
-    @daemon.run_background(
-      'start',
-      executors_count: 2,
-      memory_limit: 1000,
-      memory_init_delay: 100,
-      memory_polling_interval: 200
-    )
-  end
-
-  test 'default options read values from ENV' do
-    ENV['EXECUTORS_COUNT'] = '2'
-    ENV['EXECUTOR_MEMORY_LIMIT'] = '1gb'
-    ENV['EXECUTOR_MEMORY_MONITOR_DELAY'] = '3'
-    ENV['EXECUTOR_MEMORY_MONITOR_INTERVAL'] = '4'
-
-    actual = @daemon.send(:default_options)
-
-    assert_equal 2, actual[:executors_count]
-    assert_equal 1.gigabytes, actual[:memory_limit]
-    assert_equal 3, actual[:memory_init_delay]
-    assert_equal 4, actual[:memory_polling_interval]
-  end
-end