smart_proxy_dynflow_core 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: c2aa6a1c4c6ccf4382d03834690a695627f66d10
-  data.tar.gz: 6aedf16460fbc6924fac95e1dd4be0ead1b4fc37
+SHA256:
+  metadata.gz: 467f03a2c2c0ad4e3b168039abdb8e9a465a46b8ecf44aade57c5a09bbeafbfc
+  data.tar.gz: e966e14e4a95f42af61b5bcf47595ad6afa241271656b6724e5000b3e2cd354d
 SHA512:
-  metadata.gz: 5aac4b464edb1a3171bb52a6599823e336f532d0dec0dff6a9ffda3343bfea7900ae23e45eba36070f16a34f8fbffd6be97fd53e7af1c81a360a3bcc50a23714
-  data.tar.gz: fcee792dcf9c2494a1437799f4c57bf67cbe5dd6de6debb41ce406edc48cff00948158fe74d70fb180f72c0ae2e08476512f82a38461d303cac1bea1b54a7c7b
+  metadata.gz: e6a3b2b7b4dc313c1b6cc215c2de6cda4f49ad9f901bc7ab949b0ed4a16521e021b9c39a0fc371091e54172610787f968a2bb8577f68086ef15308bd805fc970
+  data.tar.gz: 7cbfc949016d5d824ebbb421093c8ef687c24d33c6699e7ef0c875145e035e8233317ff64c7757597bd0e76c9186566dec4e407397e32803b6d42ea26602fb6f

data/Gemfile

@@ -10,29 +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'
-    gem 'rubocop', '< 0.51.0'
-  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]
+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,4 +1,7 @@
 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

@@ -3,10 +3,25 @@ require 'multi_json'
 
 module SmartProxyDynflowCore
   class Api < ::Sinatra::Base
+    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
-      authorize_with_token || authorize_with_ssl_client
+      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
+        authorize_with_ssl_client
+      end
       content_type :json
     end
 
@@ -45,9 +60,10 @@ module SmartProxyDynflowCore
       tasks_count(params['state']).to_json
     end
 
-    post "/tasks/:task_id/done" do |task_id|
+    # capturing post "/tasks/:task_id/(update|done)"
+    post TASK_UPDATE_REGEXP_PATH do |task_id, _action|
       data = MultiJson.load(request.body.read)
-      complete_task(task_id, data)
+      dispatch_external_event(task_id, data)
     end
 
     get "/tasks/operations" do

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/helpers.rb

@@ -4,13 +4,14 @@ module SmartProxyDynflowCore
       SmartProxyDynflowCore::Core.world
     end
 
-    def authorize_with_token
+    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, ''))
+             ForemanTasksCore::OtpManager.authenticate(auth.gsub(basic_prefix, ''),
+                                                       expected_user: task_id, clear: clear)
             Log.instance.debug('authorized with token')
             return true
           end
@@ -63,7 +64,7 @@ module SmartProxyDynflowCore
       { :count => tasks.count, :state => state }
     end
 
-    def complete_task(task_id, params)
+    def dispatch_external_event(task_id, params)
       world.event(task_id,
                   params['step_id'].to_i,
                   ::ForemanTasksCore::Runner::ExternalEvent.new(params))

data/lib/smart_proxy_dynflow_core/launcher.rb

@@ -1,20 +1,28 @@
 require 'webrick/https'
 require 'smart_proxy_dynflow_core/bundler_helper'
 require 'smart_proxy_dynflow_core/settings'
-require 'smart_proxy_dynflow_core/webrick-patch'
+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 = {})
@@ -47,7 +55,7 @@ module SmartProxyDynflowCore
 
     def install_usr1_trap
       trap(:USR1) do
-        Log.instance.roll_log
+        Log.reopen
       end
     end
 
@@ -75,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)
@@ -91,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
 
@@ -111,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 ::Exception === message
+      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 = [])
+      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/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/task_launcher_registry.rb

@@ -1,7 +1,6 @@
 module SmartProxyDynflowCore
   class TaskLauncherRegistry
     class << self
-
       def register(name, launcher)
         registry[name] = launcher
       end

data/lib/smart_proxy_dynflow_core/version.rb

@@ -1,3 +1,3 @@
 module SmartProxyDynflowCore
-  VERSION = '0.2.2'.freeze
+  VERSION = '0.3.0'.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
@@ -22,20 +21,22 @@ Gem::Specification.new do |gem|
   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')
   gem.add_development_dependency "rake", "~> 10.0"
-  gem.add_development_dependency('rubocop', '~> 0.52.1')
   gem.add_development_dependency('webmock', '~> 1')
 
   gem.add_runtime_dependency('dynflow', "~> 1.1")
-  gem.add_runtime_dependency('foreman-tasks-core', '>= 0.1.7')
+  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.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Ivan Nečas
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-01-08 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
@@ -81,61 +81,61 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '10.0'
 - !ruby/object:Gem::Dependency
-  name: rubocop
+  name: webmock
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.52.1
+        version: '1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.52.1
+        version: '1'
 - !ruby/object:Gem::Dependency
-  name: webmock
+  name: dynflow
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1'
-  type: :development
+        version: '1.1'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1'
+        version: '1.1'
 - !ruby/object:Gem::Dependency
-  name: dynflow
+  name: foreman-tasks-core
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: 0.3.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: 0.3.3
 - !ruby/object:Gem::Dependency
-  name: foreman-tasks-core
+  name: logging
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.7
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.7
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rack
   requirement: !ruby/object:Gem::Requirement
@@ -164,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
@@ -228,34 +242,34 @@ 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/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: []
-rubyforge_project: 
-rubygems_version: 2.6.12
-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,39 +0,0 @@
-require 'webrick/https'
-
-CIPHERS = ['ECDHE-RSA-AES128-GCM-SHA256', 'ECDHE-RSA-AES256-GCM-SHA384',
-           'ECDHE-RSA-AES128-CBC-SHA', 'ECDHE-RSA-AES256-CBC-SHA',
-           '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