smart_proxy_dynflow_core 0.2.4 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 360ced6b9efefcab091ac6870ce28c0c7a1d4282a97bad433c60662180470e94
-  data.tar.gz: da8dcce85083a3db1afe73bbf14e0cbbe9af2b203909b3e6f64ca3dec6578e63
+  metadata.gz: ae61c912ffbb4027b1445e41995bbe66a97089c6f498c612b180da1ac91b248b
+  data.tar.gz: 7ce93f5bde709fab044af950c9b6b8664e60f2d173b3147a1beabd3da694fa32
 SHA512:
-  metadata.gz: 76dc5c88f56a0c16a93e474b46480033d7a23177a5c6d7d0fe8630caaebdca8882179314638e9246573f17a657d79c2abbca48a02b759d5b2deccb7686f8a828
-  data.tar.gz: 4378d3f1c210e996f67dff3c49176838246cbfa97512c18b8ea307fb1c5de34099ce7bc5675c46c90a1886c677015820ae835411993ed12e20f2fb7cf60280f3
+  metadata.gz: 40f546771cd25e48148fe50041544f663799f757d2aedf0635cc41de0a8b540228d8e116fa81b1d5cfe24913d2e75ac5a9912e9bac2813b8b2506ff894458d54
+  data.tar.gz: 00167adcc5eb1f24f65efa798fa00875bf0db221ba8aa1515d512a168e2c67c407391237f0a6770a1747b3519c5e632cbbb746d0eb1e797e65b967642e4a19d5

data/Gemfile

@@ -10,28 +10,14 @@ group :test do
   gem 'smart_proxy', :git => "https://github.com/theforeman/smart-proxy", :branch => "develop"
   gem 'smart_proxy_dynflow', :path => '.'
 
-  if RUBY_VERSION < '2.1'
-    gem 'public_suffix', '< 3'
-    gem 'rainbow', '< 3'
-  else
-    gem 'public_suffix'
-    gem 'rubocop', '~> 0.52.1'
-  end
-
-  if RUBY_VERSION < '2.2'
-    gem 'rack-test', '< 0.8'
-  else
-    gem 'rack-test'
-  end
+  gem 'public_suffix'
+  gem 'rack-test'
+  gem 'rubocop', '~> 0.52.1'
 end
 
-if RUBY_VERSION < '2.2'
-  gem 'rack', '>= 1.1', '< 2.0.0'
-  gem 'sinatra', '< 2'
-else
-  gem 'rack', '>= 1.1'
-  gem 'sinatra'
-end
+gem 'logging-journald', '~> 2.0', :platforms => [:ruby], :require => false
+gem 'rack', '>= 1.1'
+gem 'sinatra'
 
 # load bundler.d
 Dir["#{File.dirname(__FILE__)}/bundler.d/*.rb"].each do |bundle|

data/config/settings.yml.example

@@ -39,11 +39,27 @@
 # Specify versions like: '1.1', or '1.2'
 #:tls_disabled_versions: []
 
-# File to log to, leave empty for logging to STDOUT
-# :log_file: /var/log/foreman-proxy/smart_proxy_dynflow_core.log
+# File to log to, leave empty for stdout or use STDOUT, STDERR, SYSLOG or JOURNAL
+#:log_file: /var/log/foreman-proxy/smart_proxy_dynflow_core.log
 
 # Log level, one of UNKNOWN, FATAL, ERROR, WARN, INFO, DEBUG
-# :log_level: ERROR
+#:log_level: ERROR
+
+# The maximum size of a log file before it's rolled (in MiB) or zero to disable file rolling
+# and rely on logrotate or similar tool
+#:file_rolling_size: 0
+
+# The maximum age of a log file before it's rolled (in seconds). Also accepts 'daily', 'weekly', or 'monthly'.
+#:file_rolling_age: weekly
+
+# Number of log files to keep
+#:file_rolling_keep: 6
+
+# Logging pattern for file-based loging
+#:file_logging_pattern: '%d %.8X{request} [%.1l] %m'
+
+# Logging pattern for syslog or journal loging
+#:system_logging_pattern: '%.8X{request} [%.1l] %m'
 
 # Maximum age of execution plans to keep before having them cleaned
 # by the execution plan cleaner (in seconds), defaults to 24 hours

data/deploy/smart_proxy_dynflow_core.service

@@ -4,10 +4,9 @@ Documentation=https://github.com/theforeman/smart_proxy_dynflow
 After=network.target remote-fs.target nss-lookup.target
 
 [Service]
-Type=forking
+Type=notify
 User=foreman-proxy
-PIDFile=/var/run/foreman-proxy/smart_proxy_dynflow_core.pid
-ExecStart=/usr/bin/smart_proxy_dynflow_core -d -p /var/run/foreman-proxy/smart_proxy_dynflow_core.pid
+ExecStart=/usr/bin/smart_proxy_dynflow_core --no-daemonize
 EnvironmentFile=-/etc/sysconfig/smart_proxy_dynflow_core
 
 [Install]

data/lib/smart_proxy_dynflow_core.rb

@@ -1,6 +1,7 @@
-raise LoadError, 'Ruby >= 2.1 is required' unless RUBY_VERSION >= '2.1'
-
 require 'dynflow'
+require 'smart_proxy_dynflow_core/request_id_middleware'
+require 'smart_proxy_dynflow_core/logger_middleware'
+require 'smart_proxy_dynflow_core/middleware/keep_current_request_id'
 require 'smart_proxy_dynflow_core/task_launcher_registry'
 require 'foreman_tasks_core'
 require 'smart_proxy_dynflow_core/log'

data/lib/smart_proxy_dynflow_core/api.rb

@@ -6,6 +6,14 @@ module SmartProxyDynflowCore
     TASK_UPDATE_REGEXP_PATH = %r{/tasks/(\S+)/(update|done)}
     helpers Helpers
 
+    configure do
+      if Settings.instance.standalone
+        ::Sinatra::Base.set :logging, false
+        ::Sinatra::Base.use ::SmartProxyDynflowCore::RequestIdMiddleware
+        ::Sinatra::Base.use ::SmartProxyDynflowCore::LoggerMiddleware
+      end
+    end
+
     before do
       if match = request.path_info.match(TASK_UPDATE_REGEXP_PATH)
         task_id = match[1]

data/lib/smart_proxy_dynflow_core/bundler_helper.rb

@@ -1,6 +1,5 @@
 module SmartProxyDynflowCore
   class BundlerHelper
-    # rubocop:disable Metrics/PerceivedComplexity
     def self.require_groups(*groups)
       if File.exist?(File.expand_path('../../../Gemfile.in', __FILE__))
         # If there is a Gemfile.in file, we will not use Bundler but BundlerExt

data/lib/smart_proxy_dynflow_core/callback.rb

@@ -15,7 +15,6 @@ module SmartProxyDynflowCore
           self.new.callback(prepare_payload(callback_info, data))
         end
 
-        # rubocop:disable Metrics/PerceivedComplexity
         def ssl_options
           return @ssl_options if defined? @ssl_options
           @ssl_options = {}

data/lib/smart_proxy_dynflow_core/core.rb

@@ -15,7 +15,9 @@ module SmartProxyDynflowCore
 
     def create_world(&block)
       config = default_world_config(&block)
-      ::Dynflow::World.new(config)
+      world = ::Dynflow::World.new(config)
+      world.middleware.use ::Actions::Middleware::KeepCurrentRequestID
+      world
     end
 
     def persistence_conn_string

data/lib/smart_proxy_dynflow_core/launcher.rb

@@ -1,22 +1,28 @@
 require 'webrick/https'
 require 'smart_proxy_dynflow_core/bundler_helper'
 require 'smart_proxy_dynflow_core/settings'
-# mute Ruby redefinition warnings when running embedded
-require 'smart_proxy_dynflow_core/webrick-patch' unless defined?(::Proxy::Launcher)
+require 'sd_notify'
 
 module SmartProxyDynflowCore
   class Launcher
+    CIPHERS = ['ECDHE-RSA-AES128-GCM-SHA256', 'ECDHE-RSA-AES256-GCM-SHA384',
+               'AES128-GCM-SHA256', 'AES256-GCM-SHA384', 'AES128-SHA256',
+               'AES256-SHA256', 'AES128-SHA', 'AES256-SHA'].freeze
+
     def self.launch!(options)
       self.new.start options
     end
 
     def start(options)
-      load_settings!(options)
       Settings.instance.standalone = true
+      load_settings!(options)
       install_usr1_trap
       Rack::Server.new(rack_settings).start do |_server|
         SmartProxyDynflowCore::Core.ensure_initialized
+        ::SdNotify.ready
       end
+      Log.instance.info "Finished shutting down"
+      Logging.shutdown
     end
 
     def load_settings!(options = {})
@@ -49,7 +55,7 @@ module SmartProxyDynflowCore
 
     def install_usr1_trap
       trap(:USR1) do
-        Log.instance.roll_log
+        Log.reopen
       end
     end
 
@@ -77,15 +83,14 @@ module SmartProxyDynflowCore
         :app => app,
         :Host => Settings.instance.listen,
         :Port => Settings.instance.port,
-        :AccessLog => [[Log.instance, WEBrick::AccessLog::COMMON_LOG_FORMAT]],
+        :AccessLog => [],
         :Logger => Log.instance,
         :daemonize => Settings.instance.daemonize,
-        :pid => Settings.instance.pid_file,
+        :pid => Settings.instance.daemonize && Settings.instance.pid_file,
         :server => :webrick
       }
     end
 
-    # rubocop:disable Metrics/PerceivedComplexity
     def https_app
       ssl_options  = OpenSSL::SSL::SSLContext::DEFAULT_PARAMS[:options]
       ssl_options |= OpenSSL::SSL::OP_CIPHER_SERVER_PREFERENCE if defined?(OpenSSL::SSL::OP_CIPHER_SERVER_PREFERENCE)
@@ -93,17 +98,16 @@ module SmartProxyDynflowCore
       ssl_options |= OpenSSL::SSL::OP_NO_SSLv2 if defined?(OpenSSL::SSL::OP_NO_SSLv2)
       ssl_options |= OpenSSL::SSL::OP_NO_SSLv3 if defined?(OpenSSL::SSL::OP_NO_SSLv3)
       ssl_options |= OpenSSL::SSL::OP_NO_TLSv1 if defined?(OpenSSL::SSL::OP_NO_TLSv1)
+      ssl_options |= OpenSSL::SSL::OP_NO_TLSv1_1 if defined?(OpenSSL::SSL::OP_NO_TLSv1_1)
 
-      if Settings.instance.tls_disabled_versions
-        Settings.instance.tls_disabled_versions.each do |version|
-          constant = OpenSSL::SSL.const_get("OP_NO_TLSv#{version.to_s.tr('.', '_')}") rescue nil
+      Settings.instance.tls_disabled_versions&.each do |version|
+        constant = OpenSSL::SSL.const_get("OP_NO_TLSv#{version.to_s.tr('.', '_')}") rescue nil
 
-          if constant
-            Log.instance.info "TLSv#{version} will be disabled."
-            ssl_options |= constant
-          else
-            Log.instance.warn "TLSv#{version} was not found."
-          end
+        if constant
+          Log.instance.info "TLSv#{version} will be disabled."
+          ssl_options |= constant
+        else
+          Log.instance.warn "TLSv#{version} was not found."
         end
       end
 
@@ -113,6 +117,7 @@ module SmartProxyDynflowCore
         :SSLPrivateKey => ssl_private_key,
         :SSLCertificate => ssl_certificate,
         :SSLCACertificateFile => Settings.instance.ssl_ca_file,
+        :SSLCiphers => CIPHERS - SmartProxyDynflowCore::Settings.instance.ssl_disabled_ciphers,
         :SSLOptions => ssl_options
       }
     end

data/lib/smart_proxy_dynflow_core/log.rb

@@ -1,61 +1,126 @@
-require 'logger'
+require 'logging'
 
 module SmartProxyDynflowCore
-  class Log < ::Logger
-    alias_method :write, :debug
+  class ReopenAppender < ::Logging::Appender
+    def initialize(name, logger, opts = {})
+      @reopen = false
+      @logger = logger
+      super(name, opts)
+    end
 
-    class << self
-      def instance
-        if @logger.nil?
-          @logger = self.new log_file
-          @logger.level = log_level
-        end
-        @logger
-      end
+    def set(status = true)
+      @reopen = status
+    end
 
-      def instance=(logger)
-        @logger = logger
+    def append(_event)
+      if @reopen
+        Logging.reopen
+        @reopen = false
       end
+    end
+  end
+
+  class Log
+    BASE_LOG_SIZE = 1024 * 1024 # 1 MiB
+    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 log_level
-        if Settings.instance.loaded && Settings.instance.log_level
-          ::Logger.const_get(Settings.instance.log_level.upcase)
-        else
-          Logger::WARN
+      def reopen
+        return if @logger.nil? || @reopen.nil?
+        if Settings.instance.log_file !~ /^(STDOUT|SYSLOG|JOURNALD?)$/i
+          @reopen.set
         end
       end
 
-      def log_file
-        if Settings.instance.loaded && Settings.instance.log_file
-          Settings.instance.log_file
+      def instance
+        return ::Proxy::LogBuffer::Decorator.instance unless Settings.instance.standalone
+        return @logger if @logger
+        layout = Logging::Layouts.pattern(pattern: Settings.instance.file_logging_pattern + "\n")
+        notime_layout = Logging::Layouts.pattern(pattern: Settings.instance.system_logging_pattern + "\n")
+        log_file = Settings.instance.log_file || ''
+        @logger = Logging.logger[LOGGER_NAME]
+        @reopen = ReopenAppender.new("Reopen dummy appender", @logger)
+        @logger.add_appenders(@reopen)
+        if !Settings.instance.loaded || log_file.casecmp('STDOUT').zero?
+          @logger.add_appenders(Logging.appenders.stdout(LOGGER_NAME, layout: layout))
+        elsif log_file.casecmp('SYSLOG').zero?
+          unless @syslog_available
+            puts "Syslog is not supported on this platform, use STDOUT or a file"
+            exit(1)
+          end
+          @logger.add_appenders(Logging.appenders.syslog(LOGGER_NAME, layout: notime_layout, facility: ::Syslog::Constants::LOG_LOCAL5))
+        elsif log_file.casecmp('JOURNAL').zero? || log_file.casecmp('JOURNALD').zero?
+          begin
+            @logger.add_appenders(Logging.appenders.journald(LOGGER_NAME, LOGGER_NAME: :proxy_logger, layout: notime_layout, facility: ::Syslog::Constants::LOG_LOCAL5))
+          rescue NoMethodError
+            @logger.add_appenders(Logging.appenders.stdout(LOGGER_NAME, layout: layout))
+            @logger.warn "Journald is not available on this platform. Falling back to STDOUT."
+          end
         else
-          $stdout
+          begin
+            keep = Settings.instance.file_rolling_keep
+            size = BASE_LOG_SIZE * Settings.instance.file_rolling_size
+            age = Settings.instance.file_rolling_age
+            if size.positive?
+              @logger.add_appenders(Logging.appenders.rolling_file(LOGGER_NAME, layout: layout, filename: log_file, keep: keep, size: size, age: age, roll_by: 'number'))
+            else
+              @logger.add_appenders(Logging.appenders.file(LOGGER_NAME, layout: layout, filename: log_file))
+            end
+          rescue ArgumentError => ae
+            @logger.add_appenders(Logging.appenders.stdout(LOGGER_NAME, layout: layout))
+            @logger.warn "Log file #{log_file} cannot be opened. Falling back to STDOUT: #{ae}"
+          end
         end
+        @logger.level = ::Logging.level_num(Settings.instance.log_level)
+        @logger
       end
-    end
 
-    def initialize(file, *rest)
-      @file = file
-      @fd = @file.is_a?(IO) ? @file : File.open(@file, 'a')
-      @fd.sync = true
-      super(@fd, rest)
-    end
+      def with_fields(fields = {})
+        ::Logging.ndc.push(fields) do
+          yield
+        end
+      end
 
-    def roll_log
-      unless @file.is_a? IO
-        @fd.reopen @file, 'a'
-        @fd.sync = true
+      # Standard way for logging exceptions to get the most data in the log. By default
+      # it logs via warn level, this can be changed via options[:level]
+      def exception(context_message, exception, options = {})
+        level = options[:level] || :warn
+        unless ::Logging::LEVELS.keys.include?(level.to_s)
+          raise "Unexpected log level #{level}, expected one of #{::Logging::LEVELS.keys}"
+        end
+        # send class, message and stack as structured fields in addition to message string
+        backtrace = exception.backtrace ? exception.backtrace : []
+        extra_fields = {
+          exception_class: exception.class.name,
+          exception_message: exception.message,
+          exception_backtrace: backtrace
+        }
+        extra_fields[:foreman_code] = exception.code if exception.respond_to?(:code)
+        with_fields(extra_fields) do
+          @logger.public_send(level) do
+            ([context_message, "#{exception.class}: #{exception.message}"] + backtrace).join("\n")
+          end
+        end
       end
     end
 
     class ProxyStructuredFormater < ::Dynflow::LoggerAdapters::Formatters::Abstract
-      def call(_severity, _datetime, _prog_name, message)
-        if message.is_a?(::Exception)
+      def format(message)
+        if message.is_a?(Exception)
           subject = "#{message.message} (#{message.class})"
           if @base.respond_to?(:exception)
             @base.exception("Error details", message)
@@ -64,22 +129,17 @@ module SmartProxyDynflowCore
             "#{subject}\n#{message.backtrace.join("\n")}"
           end
         else
-          message
+          @original_formatter.call(severity, datetime, prog_name, message)
         end
       end
-
-      def format(message)
-        call(nil, nil, nil, message)
-      end
     end
 
     class ProxyAdapter < ::Dynflow::LoggerAdapters::Simple
       def initialize(logger, level = Logger::DEBUG, _formatters = [])
         @logger           = logger
         @logger.level     = level
-        @logger.formatter = ProxyStructuredFormater.new(@logger)
-        @action_logger    = apply_formatters(ProgNameWrapper.new(@logger, ' action'), [ProxyStructuredFormater])
-        @dynflow_logger   = apply_formatters(ProgNameWrapper.new(@logger, 'dynflow'), [ProxyStructuredFormater])
+        @action_logger    = apply_formatters(ProgNameWrapper.new(@logger, ' action'), [])
+        @dynflow_logger   = apply_formatters(ProgNameWrapper.new(@logger, 'dynflow'), [])
       end
     end
   end

data/lib/smart_proxy_dynflow_core/logger_middleware.rb

@@ -0,0 +1,31 @@
+module SmartProxyDynflowCore
+  class LoggerMiddleware
+    def initialize(app)
+      @logger = SmartProxyDynflowCore::Log.instance
+      @app = app
+    end
+
+    def call(env)
+      before = Time.now.to_f
+      status = 500
+      env['rack.logger'] = @logger
+      @logger.info { "Started #{env['REQUEST_METHOD']} #{env['PATH_INFO']} #{env['QUERY_STRING']}" }
+      @logger.debug { 'Headers: ' + env.select { |k, v| k.start_with? 'HTTP_' }.inspect }
+      if @logger.debug? && env['rack.input']
+        body = env['rack.input'].read
+        @logger.debug('Body: ' + body) unless body.empty?
+        env['rack.input'].rewind
+      end
+      status, = @app.call(env)
+    rescue Exception => e
+      Log.exception "Error processing request '#{::Logging.mdc['request']}", e
+      raise e
+    ensure
+      @logger.info do
+        after = Time.now.to_f
+        duration = (after - before) * 1000
+        "Finished #{env['REQUEST_METHOD']} #{env['PATH_INFO']} with #{status} (#{duration.round(2)} ms)"
+      end
+    end
+  end
+end

data/lib/smart_proxy_dynflow_core/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_core/request_id_middleware.rb

@@ -0,0 +1,18 @@
+module SmartProxyDynflowCore
+  class RequestIdMiddleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      ::Logging.mdc['remote_ip'] = env['REMOTE_ADDR']
+      if env.has_key?('HTTP_X_REQUEST_ID')
+        ::Logging.mdc['request'] = env['HTTP_X_REQUEST_ID']
+      else
+        ::Logging.mdc['request'] = SecureRandom.uuid
+      end
+      status, header, body = @app.call(env)
+      [status, header, ::Rack::BodyProxy.new(body) { ::Logging.mdc.clear }]
+    end
+  end
+end

data/lib/smart_proxy_dynflow_core/settings.rb

@@ -1,22 +1,5 @@
 require 'ostruct'
 
-# Implement hash-like access for 1.9.3 and older
-if RUBY_VERSION.split('.').first.to_i < 2
-  class OpenStruct
-    def [](key)
-      self.send key
-    end
-
-    def []=(key, value)
-      self.send "#{key}=", value
-    end
-
-    def to_h
-      marshal_dump
-    end
-  end
-end
-
 module SmartProxyDynflowCore
   class Settings < OpenStruct
     DEFAULT_SETTINGS = {
@@ -41,7 +24,12 @@ module SmartProxyDynflowCore
       :pid_file => '/var/run/foreman-proxy/smart_proxy_dynflow_core.pid',
       :daemonize => false,
       :execution_plan_cleaner_age => 60 * 60 * 24,
-      :loaded => false
+      :loaded => false,
+      :file_logging_pattern => '%d %.8X{request} [%.1l] %m',
+      :system_logging_pattern => '%.8X{request} [%.1l] %m',
+      :file_rolling_keep => 6,
+      :file_rolling_size => 0,
+      :file_rolling_age => 'weekly'
     }.freeze
 
     PROXY_SETTINGS = %i[ssl_ca_file ssl_certificate ssl_private_key foreman_url
@@ -73,13 +61,7 @@ module SmartProxyDynflowCore
     end
 
     def self.load_from_proxy(plugin)
-      plugin_class = if Proxy::VERSION >= '1.16.0'
-                       plugin
-                     else
-                       # DEPRECATION: Remove this branch when dropping support for smart-proxy < 1.16
-                       plugin[:class]
-                     end
-      settings = plugin_class.settings.to_h
+      settings = plugin.settings.to_h
       PROXY_SETTINGS.each do |key|
         SETTINGS[key] = Proxy::SETTINGS[key]
       end

data/lib/smart_proxy_dynflow_core/version.rb

@@ -1,3 +1,3 @@
 module SmartProxyDynflowCore
-  VERSION = '0.2.4'.freeze
+  VERSION = '0.3.2'.freeze
 end

data/smart_proxy_dynflow_core.gemspec

@@ -2,7 +2,6 @@ lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'smart_proxy_dynflow_core/version'
 
-# rubocop:disable Metrics/BlockLength
 Gem::Specification.new do |gem|
   gem.name          = "smart_proxy_dynflow_core"
   gem.version       = SmartProxyDynflowCore::VERSION
@@ -16,13 +15,15 @@ Gem::Specification.new do |gem|
 
   gem.executables   = ['smart_proxy_dynflow_core']
   gem.files         = Dir['lib/smart_proxy_dynflow_core.rb', 'config/settings.yml.example',
-                          'lib/smart_proxy_dynflow_core/*', 'LICENSE', 'Gemfile',
+                          'lib/smart_proxy_dynflow_core/**/*', 'LICENSE', 'Gemfile',
                           'bin/smart_proxy_dynflow_core', 'deploy/*', 'smart_proxy_dynflow_core.gemspec']
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
   gem.license = 'GPL-3.0'
 
-  gem.add_development_dependency "bundler", "~> 1.7"
+  gem.required_ruby_version = '~> 2.5'
+
+  gem.add_development_dependency "bundler", ">= 1.7"
   gem.add_development_dependency('minitest')
   gem.add_development_dependency('mocha', '~> 1')
   gem.add_development_dependency('rack-test', '~> 0')
@@ -31,10 +32,11 @@ Gem::Specification.new do |gem|
 
   gem.add_runtime_dependency('dynflow', "~> 1.1")
   gem.add_runtime_dependency('foreman-tasks-core', '>= 0.3.3')
+  gem.add_runtime_dependency('logging')
   gem.add_runtime_dependency('rack')
   gem.add_runtime_dependency('rest-client')
+  gem.add_runtime_dependency('sd_notify', '~> 0.1')
   gem.add_runtime_dependency('sequel')
   gem.add_runtime_dependency('sinatra')
   gem.add_runtime_dependency('sqlite3')
 end
-# rubocop:enable Metrics/BlockLength

metadata

@@ -1,27 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: smart_proxy_dynflow_core
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.3.2
 platform: ruby
 authors:
 - Ivan Nečas
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-11-15 00:00:00.000000000 Z
+date: 1980-01-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.7'
 - !ruby/object:Gem::Dependency
@@ -122,6 +122,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.3.3
+- !ruby/object:Gem::Dependency
+  name: logging
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rack
   requirement: !ruby/object:Gem::Requirement
@@ -150,6 +164,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: sd_notify
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
 - !ruby/object:Gem::Dependency
   name: sequel
   requirement: !ruby/object:Gem::Requirement
@@ -214,33 +242,35 @@ files:
 - lib/smart_proxy_dynflow_core/helpers.rb
 - lib/smart_proxy_dynflow_core/launcher.rb
 - lib/smart_proxy_dynflow_core/log.rb
+- lib/smart_proxy_dynflow_core/logger_middleware.rb
+- lib/smart_proxy_dynflow_core/middleware/keep_current_request_id.rb
+- lib/smart_proxy_dynflow_core/request_id_middleware.rb
 - lib/smart_proxy_dynflow_core/settings.rb
 - lib/smart_proxy_dynflow_core/task_launcher_registry.rb
 - lib/smart_proxy_dynflow_core/testing.rb
 - lib/smart_proxy_dynflow_core/version.rb
-- lib/smart_proxy_dynflow_core/webrick-patch.rb
 - smart_proxy_dynflow_core.gemspec
 homepage: https://github.com/theforeman/smart_proxy_dynflow
 licenses:
 - GPL-3.0
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - "~>"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
 summary: Dynflow runtime for Foreman smart proxy
 test_files: []

data/lib/smart_proxy_dynflow_core/webrick-patch.rb

@@ -1,38 +0,0 @@
-require 'webrick/https'
-
-CIPHERS = ['ECDHE-RSA-AES128-GCM-SHA256', 'ECDHE-RSA-AES256-GCM-SHA384',
-           'AES128-GCM-SHA256', 'AES256-GCM-SHA384', 'AES128-SHA256',
-           'AES256-SHA256', 'AES128-SHA', 'AES256-SHA'].freeze
-
-module WEBrick
-  class GenericServer
-    # rubocop:disable Metrics/AbcSize
-    def setup_ssl_context(config) # :nodoc:
-      unless config[:SSLCertificate]
-        cn = config[:SSLCertName]
-        comment = config[:SSLCertComment]
-        cert, key = Utils.create_self_signed_cert(1024, cn, comment)
-        config[:SSLCertificate] = cert
-        config[:SSLPrivateKey] = key
-      end
-      ctx = OpenSSL::SSL::SSLContext.new
-      ctx.set_params
-      ctx.ciphers = (CIPHERS - SmartProxyDynflowCore::Settings.instance.ssl_disabled_ciphers).join(':')
-      ctx.key = config[:SSLPrivateKey]
-      ctx.cert = config[:SSLCertificate]
-      ctx.client_ca = config[:SSLClientCA]
-      ctx.extra_chain_cert = config[:SSLExtraChainCert]
-      ctx.ca_file = config[:SSLCACertificateFile]
-      ctx.ca_path = config[:SSLCACertificatePath]
-      ctx.cert_store = config[:SSLCertificateStore]
-      ctx.tmp_dh_callback = config[:SSLTmpDhCallback]
-      ctx.verify_mode = config[:SSLVerifyClient]
-      ctx.verify_depth = config[:SSLVerifyDepth]
-      ctx.verify_callback = config[:SSLVerifyCallback]
-      ctx.timeout = config[:SSLTimeout]
-      ctx.options |= config[:SSLOptions] unless config[:SSLOptions].nil?
-      ctx
-    end
-    # rubocop:enable Metrics/AbcSize
-  end
-end