smart_proxy_dynflow 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ed31ab888b7a2f5fbc4891fe60a0332f5a43347a15175f12f96a3215c0e73447
-  data.tar.gz: 534c395d634b227cd5570687e83e3e6d227a8f1898b6fed76a7760c6c66a33e2
+  metadata.gz: b3c381a5358391ea92bacf8c59c3a279b49a50a49369bd962c0ff94e7c4d459e
+  data.tar.gz: 3d83db86f0ce2a76b5d1e1f4ca5afd57eb82a5b327ba1ad2f561c77217e4ae0f
 SHA512:
-  metadata.gz: a1836fa6ab0f19b43b7321d133d69632bb248ceec3e113a46952c5fc0e5f5170f29fcec0cfd52ade22db7755dcc727c03bb8f1184215787de9e37beaffc3c901
-  data.tar.gz: 3a20420452784df395b61cb3f75bba8ef88e8627fd984d17894e9a7003262d74b9beda70ab41eff0843e6816e8c74dc798f89b4b97b4f93d80e1dc7436ac5763
+  metadata.gz: da9ce875255e93fcc491fc438eb6cbe3fb0b803b6524539a71575f47b29e0a65bcffb1378a6bacc3eee85e4c5194a3d0e3a9f77faff3fe5a82211f4242f671ea
+  data.tar.gz: 55b4f92fdf94ca2b0cde9282f02be12d167674bd358729bd26a766d320a45de0dcc2f8535d94dc31b164963691e076b6b3740c60f385b4f9ca18b2d06c8abf82

data/Gemfile

@@ -15,7 +15,7 @@ group :test do
   gem 'rubocop', '~> 0.52.1'
 end
 
-gem 'logging-journald', '~> 2.0', :platforms => [:ruby]
+gem 'logging-journald', '~> 2.0', :platforms => [:ruby], :require => false
 gem 'rack', '>= 1.1'
 gem 'sinatra'
 

data/lib/smart_proxy_dynflow.rb

@@ -1,5 +1,25 @@
+require 'dynflow'
+
+require 'smart_proxy_dynflow/task_launcher_registry'
+require 'smart_proxy_dynflow/middleware/keep_current_request_id'
+
+require 'foreman_tasks_core'
+
+require 'smart_proxy_dynflow/log'
+require 'smart_proxy_dynflow/settings'
+require 'smart_proxy_dynflow/core'
+require 'smart_proxy_dynflow/callback'
+
 require 'smart_proxy_dynflow/version'
 require 'smart_proxy_dynflow/plugin'
-require 'smart_proxy_dynflow/callback'
 require 'smart_proxy_dynflow/helpers'
 require 'smart_proxy_dynflow/api'
+
+module Proxy
+  class Dynflow
+    Core.after_initialize do |dynflow_core|
+      ForemanTasksCore.dynflow_setup(dynflow_core.world)
+    end
+    Core.register_silencer_matchers ForemanTasksCore.silent_dead_letter_matchers
+  end
+end

data/lib/smart_proxy_dynflow/api.rb

@@ -9,57 +9,80 @@ module Proxy
       helpers ::Proxy::Log
       helpers ::Proxy::Dynflow::Helpers
 
+      include ::Sinatra::Authorization::Helpers
+
+      TASK_UPDATE_REGEXP_PATH = %r{/tasks/(\S+)/(update|done)}
+
       before do
-        content_type :json
-        if request.env['HTTP_AUTHORIZATION'] && request.path_info =~ %r{/tasks/.*/(update|done)}
-          # Halt running before callbacks if a token is provided and the request is notifying about task being done
-          return
+        if match = request.path_info.match(TASK_UPDATE_REGEXP_PATH)
+          task_id = match[1]
+          action = match[2]
+          authorize_with_token(task_id: task_id, clear: action == 'done')
         else
-          do_authorize_with_ssl_client
-          do_authorize_with_trusted_hosts
+          do_authorize_any
         end
+        content_type :json
       end
 
-      # TODO: move this to foreman-proxy to reduce code duplicities
-      def do_authorize_with_trusted_hosts
-        # When :trusted_hosts is given, we check the client against the list
-        # HTTPS: test the certificate CN
-        # HTTP: test the reverse DNS entry of the remote IP
-        trusted_hosts = Proxy::SETTINGS.trusted_hosts
-        if trusted_hosts
-          if ['yes', 'on', 1].include? request.env['HTTPS'].to_s
-            fqdn = https_cert_cn
-            source = 'SSL_CLIENT_CERT'
-          else
-            fqdn = remote_fqdn(Proxy::SETTINGS.forward_verify)
-            source = 'REMOTE_ADDR'
-          end
-          fqdn = fqdn.downcase
-          logger.debug "verifying remote client #{fqdn} (based on #{source}) against trusted_hosts #{trusted_hosts}"
-
-          unless Proxy::SETTINGS.trusted_hosts.include?(fqdn)
-            log_halt 403, "Untrusted client #{fqdn} attempted " \
-                          "to access #{request.path_info}. Check :trusted_hosts: in settings.yml"
-          end
+      post "/tasks/status" do
+        params = MultiJson.load(request.body.read)
+        ids = params.fetch('task_ids', [])
+        result = world.persistence
+                      .find_execution_plans(:filters => { :uuid => ids }).reduce({}) do |acc, plan|
+          acc.update(plan.id => { 'state' => plan.state, 'result' => plan.result })
         end
+        MultiJson.dump(result)
       end
 
-      def do_authorize_with_ssl_client
-        if %w[yes on 1].include? request.env['HTTPS'].to_s
-          if request.env['SSL_CLIENT_CERT'].to_s.empty?
-            log_halt 403, "No client SSL certificate supplied"
-          end
-        else
-          logger.debug('require_ssl_client_verification: skipping, non-HTTPS request')
-        end
+      post "/tasks/launch/?" do
+        params = MultiJson.load(request.body.read)
+        launcher = launcher_class(params).new(world, callback_host(params, request), params.fetch('options', {}))
+        launcher.launch!(params['input'])
+        launcher.results.to_json
+      end
+
+      post "/tasks/?" do
+        params = MultiJson.load(request.body.read)
+        trigger_task(::Dynflow::Utils.constantize(params['action_name']),
+                     params['action_input'].merge(:callback_host => callback_host(params, request))).to_json
+      end
+
+      post "/tasks/:task_id/cancel" do |task_id|
+        cancel_task(task_id).to_json
       end
 
-      post "/*" do
-        relay_request
+      get "/tasks/:task_id/status" do |task_id|
+        task_status(task_id).to_json
       end
 
-      get "/*" do
-        relay_request
+      get "/tasks/count" do
+        tasks_count(params['state']).to_json
+      end
+
+      # capturing post "/tasks/:task_id/(update|done)"
+      post TASK_UPDATE_REGEXP_PATH do |task_id, _action|
+        data = MultiJson.load(request.body.read)
+        dispatch_external_event(task_id, data)
+      end
+
+      get "/tasks/operations" do
+        TaskLauncherRegistry.operations.to_json
+      end
+
+      private
+
+      def callback_host(params, request)
+        params.fetch('action_input', {})['proxy_url'] ||
+          request.env.values_at('HTTP_X_FORWARDED_FOR', 'HTTP_HOST').compact.first
+      end
+
+      def launcher_class(params)
+        operation = params.fetch('operation')
+        if TaskLauncherRegistry.key?(operation)
+          TaskLauncherRegistry.fetch(operation)
+        else
+          halt 404, MultiJson.dump(:error => "Unknown operation '#{operation}' requested.")
+        end
       end
     end
   end

data/lib/smart_proxy_dynflow/callback.rb

@@ -1,34 +1,77 @@
-require 'proxy/request'
-
-module Proxy
-  class Dynflow
-    module Callback
-      class Core < Proxy::HttpRequest::ForemanRequest
-        def uri
-          @uri ||= URI.parse Proxy::Dynflow::Plugin.settings.core_url
+require 'rest-client'
+
+class Proxy::Dynflow
+  module Callback
+    class Request
+      class << self
+        def send_to_foreman_tasks(callback_info, data)
+          self.new.callback(prepare_payload(callback_info, data))
+        end
+
+        def ssl_options
+          return @ssl_options if defined? @ssl_options
+          @ssl_options = {}
+          settings = Proxy::SETTINGS
+          return @ssl_options unless URI.parse(settings.foreman_url).scheme == 'https'
+
+          @ssl_options[:verify_ssl] = OpenSSL::SSL::VERIFY_PEER
+
+          private_key_file = settings.foreman_ssl_key || settings.ssl_private_key
+          if private_key_file
+            private_key = File.read(private_key_file)
+            @ssl_options[:ssl_client_key] = OpenSSL::PKey::RSA.new(private_key)
+          end
+          certificate_file = settings.foreman_ssl_cert || settings.ssl_certificate
+          if certificate_file
+            certificate = File.read(certificate_file)
+            @ssl_options[:ssl_client_cert] = OpenSSL::X509::Certificate.new(certificate)
+          end
+          ca_file = settings.foreman_ssl_ca || settings.ssl_ca_file
+          @ssl_options[:ssl_ca_file] = ca_file if ca_file
+          @ssl_options
         end
+        # rubocop:enable Metrics/PerceivedComplexity
 
-        def relay(request, from, to)
-          path = request.path.gsub(from, to)
-          message = "Proxy request from #{request.host_with_port}#{request.path} to #{uri}#{path}"
-          Proxy::LogBuffer::Decorator.instance.debug message
-          req = case request.env['REQUEST_METHOD']
-                when 'GET'
-                  request_factory.create_get path, request.env['rack.request.query_hash']
-                when 'POST'
-                  request_factory.create_post path, request.body.read
-                end
-          req['X-Forwarded-For'] = request.env['HTTP_HOST']
-          req['AUTHORIZATION'] = request.env['HTTP_AUTHORIZATION']
-          req['X-Request-Id'] = ::Logging.mdc['request']
-          response = send_request req
-          Proxy::LogBuffer::Decorator.instance.debug "Proxy request status #{response.code} - #{response}"
-          response
+        private
+
+        def prepare_payload(callback, data)
+          { :callback => callback, :data => data }.to_json
         end
+      end
 
-        def self.relay(request, from, to)
-          self.new.relay request, from, to
+      def callback(payload)
+        response = callback_resource.post(payload, :content_type => :json)
+        if response.code.to_s != "200"
+          raise "Failed performing callback to Foreman server: #{response.code} #{response.body}"
         end
+        response
+      end
+
+      private
+
+      def callback_resource
+        @resource ||= RestClient::Resource.new(Proxy::SETTINGS.foreman_url + '/foreman_tasks/api/tasks/callback',
+                                               self.class.ssl_options)
+      end
+    end
+
+    class Action < ::Dynflow::Action
+      def plan(callback, data)
+        plan_self(:callback => callback, :data => data)
+      end
+
+      def run
+        Callback::Request.send_to_foreman_tasks(input[:callback], input[:data])
+      end
+    end
+
+    module PlanHelper
+      def plan_with_callback(input)
+        input = input.dup
+        callback = input.delete('callback')
+
+        planned_action = plan_self(input)
+        plan_action(Callback::Action, callback, planned_action.output) if callback
       end
     end
   end

data/lib/smart_proxy_dynflow/core.rb

@@ -0,0 +1,121 @@
+class Proxy::Dynflow
+  class Core
+    attr_accessor :world, :accepted_cert_serial
+
+    def initialize
+      @world = create_world
+      cert_file = Proxy::SETTINGS.foreman_ssl_cert || Proxy::SETTINGS.ssl_certificate
+      if cert_file
+        client_cert = File.read(cert_file)
+        # we trust only requests using the same certificate as we are
+        # (in other words the local proxy only)
+        @accepted_cert_serial = OpenSSL::X509::Certificate.new(client_cert).serial
+      end
+    end
+
+    def create_world(&block)
+      config = default_world_config(&block)
+      world = ::Dynflow::World.new(config)
+      world.middleware.use ::Actions::Middleware::KeepCurrentRequestID
+      world
+    end
+
+    def persistence_conn_string
+      return ENV['DYNFLOW_DB_CONN_STRING'] if ENV.key? 'DYNFLOW_DB_CONN_STRING'
+      db_conn_string = 'sqlite:/'
+
+      db_file = Settings.instance.database
+      if db_file.nil? || db_file.empty?
+        Log.instance.warn "Could not open DB for dynflow at '#{db_file}', " \
+                          "will keep data in memory. Restart will drop all dynflow data."
+      else
+        db_conn_string += "/#{db_file}"
+      end
+
+      db_conn_string
+    end
+
+    def persistence_adapter
+      ::Dynflow::PersistenceAdapters::Sequel.new persistence_conn_string
+    end
+
+    def default_world_config
+      ::Dynflow::Config.new.tap do |config|
+        config.auto_rescue = true
+        config.logger_adapter = logger_adapter
+        config.persistence_adapter = persistence_adapter
+        config.execution_plan_cleaner = execution_plan_cleaner
+        # TODO: There has to be a better way
+        matchers = config.silent_dead_letter_matchers.call.concat(self.class.silencer_matchers)
+        config.silent_dead_letter_matchers = matchers
+        yield config if block_given?
+      end
+    end
+
+    def logger_adapter
+      Log::ProxyAdapter.new(Proxy::LogBuffer::Decorator.instance, Log.instance.level)
+    end
+
+    def execution_plan_cleaner
+      proc do |world|
+        age = Settings.instance.execution_plan_cleaner_age
+        options = { :poll_interval => age, :max_age => age }
+        ::Dynflow::Actors::ExecutionPlanCleaner.new(world, options)
+      end
+    end
+
+    class << self
+      attr_reader :instance
+
+      def ensure_initialized
+        return @instance if @instance
+        @instance = Core.new
+        after_initialize_blocks.each { |block| block.call(@instance) }
+        @instance
+      end
+
+      def silencer_matchers
+        @matchers ||= []
+      end
+
+      def register_silencer_matchers(matchers)
+        silencer_matchers.concat matchers
+      end
+
+      def web_console
+        require 'dynflow/web'
+        dynflow_console = ::Dynflow::Web.setup do
+          # we can't use the proxy's after_activation hook, as
+          # it happens before the Daemon forks the process (including
+          # closing opened file descriptors)
+          # TODO: extend smart proxy to enable hooks that happen after
+          # the forking
+          helpers Helpers
+          include ::Sinatra::Authorization::Helpers
+
+          before do
+            do_authorize_with_ssl_client if Settings.instance.console_auth
+          end
+
+          Core.ensure_initialized
+          set :world, Core.world
+        end
+        dynflow_console
+      end
+
+      def world
+        instance.world
+      end
+
+      def after_initialize(&block)
+        after_initialize_blocks << block
+      end
+
+      private
+
+      def after_initialize_blocks
+        @after_initialize_blocks ||= []
+      end
+    end
+  end
+end

data/lib/smart_proxy_dynflow/helpers.rb

@@ -1,11 +1,57 @@
 module Proxy
   class Dynflow
     module Helpers
-      def relay_request(from = %r{^/dynflow}, to = '')
-        response = Proxy::Dynflow::Callback::Core.relay(request, from, to)
-        content_type response.content_type
-        status response.code
-        body response.body
+      def world
+        Proxy::Dynflow::Core.world
+      end
+
+      def authorize_with_token(task_id:, clear: true)
+        if request.env.key? 'HTTP_AUTHORIZATION'
+          if defined?(::ForemanTasksCore)
+            auth = request.env['HTTP_AUTHORIZATION']
+            basic_prefix = /\ABasic /
+            if !auth.to_s.empty? && auth =~ basic_prefix &&
+               ForemanTasksCore::OtpManager.authenticate(auth.gsub(basic_prefix, ''),
+                                                         expected_user: task_id, clear: clear)
+              Log.instance.debug('authorized with token')
+              return true
+            end
+          end
+          halt 403, MultiJson.dump(:error => 'Invalid username or password supplied')
+        end
+        false
+      end
+
+      def trigger_task(*args)
+        triggered = world.trigger(*args)
+        { :task_id => triggered.id }
+      end
+
+      def cancel_task(task_id)
+        execution_plan = world.persistence.load_execution_plan(task_id)
+        cancel_events = execution_plan.cancel
+        { :task_id => task_id, :canceled_steps_count => cancel_events.size }
+      end
+
+      def task_status(task_id)
+        ep = world.persistence.load_execution_plan(task_id)
+        ep.to_hash.merge(:actions => ep.actions.map(&:to_hash))
+      rescue KeyError => _e
+        status 404
+        {}
+      end
+
+      def tasks_count(state)
+        state ||= 'all'
+        filter = state != 'all' ? { :filters => { :state => [state] } } : {}
+        tasks = world.persistence.find_execution_plans(filter)
+        { :count => tasks.count, :state => state }
+      end
+
+      def dispatch_external_event(task_id, params)
+        world.event(task_id,
+                    params['step_id'].to_i,
+                    ::ForemanTasksCore::Runner::ExternalEvent.new(params))
       end
     end
   end

data/lib/smart_proxy_dynflow/http_config.ru

@@ -1,21 +1,11 @@
-# Internal core will be used if external core is either disabled or unset
-# and the core gem can be loaded
+require 'smart_proxy_dynflow/api'
 
-if !::Proxy::Dynflow::Plugin.settings.external_core && Proxy::Dynflow::Plugin.internal_core_available?
-  require 'smart_proxy_dynflow_core/api'
-  require 'smart_proxy_dynflow_core/launcher'
-
-  SmartProxyDynflowCore::Settings.load_from_proxy(p)
-
-  map "/dynflow" do
-    SmartProxyDynflowCore::Launcher.route_mapping(self)
+map "/dynflow" do
+  map '/console' do
+    run Proxy::Dynflow::Core.web_console
   end
-else
-  require 'smart_proxy_dynflow/api'
 
-  map "/dynflow" do
-    map '/' do
-      run Proxy::Dynflow::Api
-    end
+  map '/' do
+    run Proxy::Dynflow::Api
   end
 end

data/lib/smart_proxy_dynflow/log.rb

@@ -0,0 +1,52 @@
+require 'logging'
+
+class Proxy::Dynflow
+  class Log
+    LOGGER_NAME = 'dynflow-core'.freeze
+
+    begin
+      require 'syslog/logger'
+      @syslog_available = true
+    rescue LoadError
+      @syslog_available = false
+    end
+
+    class << self
+      def reload!
+        Logging.logger[LOGGER_NAME].appenders.each(&:close)
+        Logging.logger[LOGGER_NAME].clear_appenders
+        @logger = nil
+        instance
+      end
+
+      def instance
+        ::Proxy::LogBuffer::Decorator.instance
+      end
+    end
+
+    class ProxyStructuredFormater < ::Dynflow::LoggerAdapters::Formatters::Abstract
+      def format(message)
+        if message.is_a?(Exception)
+          subject = "#{message.message} (#{message.class})"
+          if @base.respond_to?(:exception)
+            @base.exception("Error details", message)
+            subject
+          else
+            "#{subject}\n#{message.backtrace.join("\n")}"
+          end
+        else
+          @original_formatter.call(severity, datetime, prog_name, message)
+        end
+      end
+    end
+
+    class ProxyAdapter < ::Dynflow::LoggerAdapters::Simple
+      def initialize(logger, level = Logger::DEBUG, _formatters = [])
+        @logger           = logger
+        @logger.level     = level
+        @action_logger    = apply_formatters(ProgNameWrapper.new(@logger, ' action'), [])
+        @dynflow_logger   = apply_formatters(ProgNameWrapper.new(@logger, 'dynflow'), [])
+      end
+    end
+  end
+end

data/lib/smart_proxy_dynflow/middleware/keep_current_request_id.rb

@@ -0,0 +1,59 @@
+module Actions
+  module Middleware
+    class KeepCurrentRequestID < Dynflow::Middleware
+      def delay(*args)
+        pass(*args).tap { store_current_request_id }
+      end
+
+      def plan(*args)
+        with_current_request_id do
+          pass(*args).tap { store_current_request_id }
+        end
+      end
+
+      def run(*args)
+        restore_current_request_id { pass(*args) }
+      end
+
+      def finalize
+        restore_current_request_id { pass }
+      end
+
+      # Run all execution plan lifecycle hooks as the original request_id
+      def hook(*args)
+        restore_current_request_id { pass(*args) }
+      end
+
+      private
+
+      def with_current_request_id
+        if action.input[:current_request_id].nil?
+          yield
+        else
+          restore_current_request_id { yield }
+        end
+      end
+
+      def store_current_request_id
+        action.input[:current_request_id] = ::Logging.mdc['request']
+      end
+
+      def restore_current_request_id
+        unless (restored_id = action.input[:current_request_id]).nil?
+          old_id = ::Logging.mdc['request']
+          if !old_id.nil? && old_id != restored_id
+            action.action_logger.warn('Changing request id %{request_id} to saved id %{saved_id}' % { :saved_id => restored_id, :request_id => old_id })
+          end
+          ::Logging.mdc['request'] = restored_id
+        end
+        yield
+      ensure
+        # Reset to original request id only when not nil
+        # Otherwise, keep the id until it's cleaned in  Dynflow's run_user_code block
+        # so that it will stay valid for the rest of the processing of the current step
+        # (even outside of the middleware lifecycle)
+        ::Logging.mdc['request'] = old_id unless old_id.nil?
+      end
+    end
+  end
+end

data/lib/smart_proxy_dynflow/plugin.rb

@@ -10,22 +10,12 @@ class Proxy::Dynflow
 
     settings_file "dynflow.yml"
     requires :foreman_proxy, ">= 1.16.0"
-    default_settings :core_url => 'http://localhost:8008'
+    default_settings :console_auth => true,
+                     :execution_plan_cleaner_age => 60 * 60 * 24
     plugin :dynflow, Proxy::Dynflow::VERSION
 
     after_activation do
-      # Ensure the core gem is loaded, if configure NOT to use the external core
-      if Proxy::Dynflow::Plugin.settings.external_core == false && !internal_core_available?
-        raise "'smart_proxy_dynflow_core' gem is required, but not available"
-      end
-    end
-
-    def self.internal_core_available?
-      @core_available ||= begin
-                            require 'smart_proxy_dynflow_core'
-                            true
-                          rescue LoadError # rubocop:disable Lint/HandleExceptions
-                          end
+      Proxy::Dynflow::Core.ensure_initialized
     end
   end
 end

data/lib/smart_proxy_dynflow/settings.rb

@@ -0,0 +1,9 @@
+# require 'ostruct'
+
+class Proxy::Dynflow
+  class Settings
+    def self.instance
+      Proxy::Dynflow::Plugin.settings
+    end
+  end
+end

data/lib/smart_proxy_dynflow/task_launcher_registry.rb

@@ -0,0 +1,31 @@
+class Proxy::Dynflow
+  class TaskLauncherRegistry
+    class << self
+      def register(name, launcher)
+        registry[name] = launcher
+      end
+
+      def fetch(name, default = nil)
+        if default.nil?
+          registry.fetch(name)
+        else
+          registry.fetch(name, default)
+        end
+      end
+
+      def key?(name)
+        registry.key?(name)
+      end
+
+      def operations
+        registry.keys
+      end
+
+      private
+
+      def registry
+        @registry ||= {}
+      end
+    end
+  end
+end

data/lib/smart_proxy_dynflow/testing.rb

@@ -0,0 +1,24 @@
+require 'dynflow/testing'
+
+unless defined? DYNFLOW_TESTING_LOG_LEVEL
+  DYNFLOW_TESTING_LOG_LEVEL = 4
+end
+
+class Proxy::Dynflow
+  # Helper for usage in other dependent plugins that need Dynflow
+  # related things, such as testing instance of world etc.
+  module Testing
+    class << self
+      def create_world(&block)
+        Core.ensure_initialized
+        Core.instance.create_world do |config|
+          config.exit_on_terminate = false
+          config.auto_terminate    = false
+          config.logger_adapter    = ::Dynflow::LoggerAdapters::Simple.new $stderr, DYNFLOW_TESTING_LOG_LEVEL
+          config.execution_plan_cleaner = nil
+          yield(config) if block
+        end
+      end
+    end
+  end
+end

data/lib/smart_proxy_dynflow/version.rb

@@ -1,5 +1,5 @@
 module Proxy
   class Dynflow
-    VERSION = '0.3.0'.freeze
+    VERSION = '0.4.0'.freeze
   end
 end

data/settings.d/dynflow.yml.example

@@ -1,9 +1,10 @@
 ---
 :enabled: true
 :database: /var/lib/foreman-proxy/dynflow/dynflow.sqlite
-:core_url: 'http://127.0.0.1:8008'
 
-# If true, external core will be used even if the core gem is available
-# If false, the feature will be disabled if the core gem is not available
-# If unset, the process will fallback to external core if the core gem is not available
-# :external_core: true
+# Require a valid cert to access Dynflow console
+# :console_auth: true
+
+# Maximum age of execution plans to keep before having them cleaned
+# by the execution plan cleaner (in seconds), defaults to 24 hours
+# :execution_plan_cleaner_age: 86400

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: smart_proxy_dynflow
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Ivan Nečas
 autorequire:
 bindir: bin
 cert_chain: []
-date: 1980-01-01 00:00:00.000000000 Z
+date: 2021-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logging
@@ -121,10 +121,16 @@ files:
 - lib/smart_proxy_dynflow.rb
 - lib/smart_proxy_dynflow/api.rb
 - lib/smart_proxy_dynflow/callback.rb
+- lib/smart_proxy_dynflow/core.rb
 - lib/smart_proxy_dynflow/helpers.rb
 - lib/smart_proxy_dynflow/http_config.ru
+- lib/smart_proxy_dynflow/log.rb
+- lib/smart_proxy_dynflow/middleware/keep_current_request_id.rb
 - lib/smart_proxy_dynflow/plugin.rb
 - lib/smart_proxy_dynflow/proxy_adapter.rb
+- lib/smart_proxy_dynflow/settings.rb
+- lib/smart_proxy_dynflow/task_launcher_registry.rb
+- lib/smart_proxy_dynflow/testing.rb
 - lib/smart_proxy_dynflow/version.rb
 - settings.d/dynflow.yml.example
 homepage: https://github.com/theforeman/smart_proxy_dynflow