smart_proxy_dynflow_core 0.2.6 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 84ea792e8e6d9f6ddcd145428485d5faadf92da27acd184fa42956fa4873e7fd
-  data.tar.gz: 07adc8b3c623462086d0797455afaf822e27212bcdcda345a950df7e49296814
+  metadata.gz: 3226e9b143ecf53b28e97a765c2e760d42dc030ea3809736f5e7733b2db96cfe
+  data.tar.gz: eb70345b228d35506d36faa0a3fe59e09c8b1787d438f73d6554699736a70d3a
 SHA512:
-  metadata.gz: 989f9619b041039a3897de03cac1edc5ce1415a19792b3a5b2e907b174b97472b3a56f19cd5cab9977c26e5d5c83c38636afe8c49186dbd2bfce1c7e3dbfcc84
-  data.tar.gz: 7caa3ee4ddce3560970bd8f7a7b8e2b99dd96f1fae456e78475673ec98478e0c608e5feb29442b7046e4eed07e61f0d9a009dade6646e534f6ef6f033192f572
+  metadata.gz: cf3292bd295765e51968781f4a0a3678a5825977da06b56ddf86e073a232665f92f90cd5df25e0a6332304b4c3c15784404f2aae8d25f050cc77405d7520e57f
+  data.tar.gz: 1bdaaebb6e5b59fcf25250c4ba7695dadda3313854c8db343199bb8ec61529ed21deff5e948ac0545f6fde0eab6cde7bde73067b96943061e5bd013a22faa9db

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

@@ -1,18 +1,13 @@
-raise LoadError, 'Ruby >= 2.1 is required' unless RUBY_VERSION >= '2.1'
+# Whatever is here is just a compatibility layer
+# Once all the _core have been migrated, this can be dropped.
 
-require 'dynflow'
+require 'smart_proxy_dynflow'
+
+# REX core explicitly requires this file, otherwise we could use the trick we
+# use with callback
 require 'smart_proxy_dynflow_core/task_launcher_registry'
-require 'foreman_tasks_core'
-require 'smart_proxy_dynflow_core/log'
-require 'smart_proxy_dynflow_core/settings'
-require 'smart_proxy_dynflow_core/core'
-require 'smart_proxy_dynflow_core/helpers'
-require 'smart_proxy_dynflow_core/callback'
-require 'smart_proxy_dynflow_core/api'
 
 module SmartProxyDynflowCore
-  Core.after_initialize do |dynflow_core|
-    ForemanTasksCore.dynflow_setup(dynflow_core.world)
-  end
-  Core.register_silencer_matchers ForemanTasksCore.silent_dead_letter_matchers
+  Callback = Proxy::Dynflow::Callback
+  Log = Proxy::Dynflow::Log
 end

data/lib/smart_proxy_dynflow_core/task_launcher_registry.rb

@@ -1,31 +1,3 @@
 module SmartProxyDynflowCore
-  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
+  TaskLauncherRegistry = Proxy::Dynflow::TaskLauncherRegistry
 end

data/lib/smart_proxy_dynflow_core/version.rb

@@ -1,3 +1,3 @@
 module SmartProxyDynflowCore
-  VERSION = '0.2.6'.freeze
+  VERSION = '0.4.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
@@ -14,14 +13,14 @@ Gem::Specification.new do |gem|
     Use the Dynflow inside Foreman smart proxy
   EOS
 
-  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',
-                          'bin/smart_proxy_dynflow_core', 'deploy/*', 'smart_proxy_dynflow_core.gemspec']
+  gem.files         = Dir['lib/smart_proxy_dynflow_core.rb', 'lib/smart_proxy_dynflow_core/**/*',
+                          'LICENSE', 'Gemfile', '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.required_ruby_version = '~> 2.5'
+
   gem.add_development_dependency "bundler", ">= 1.7"
   gem.add_development_dependency('minitest')
   gem.add_development_dependency('mocha', '~> 1')
@@ -31,10 +30,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,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: smart_proxy_dynflow_core
 version: !ruby/object:Gem::Version
-  version: 0.2.6
+  version: 0.4.0
 platform: ruby
 authors:
 - Ivan Nečas
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-06-19 00:00:00.000000000 Z
+date: 2021-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -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
@@ -195,52 +223,37 @@ dependencies:
 description: "    Use the Dynflow inside Foreman smart proxy\n"
 email:
 - inecas@redhat.com
-executables:
-- smart_proxy_dynflow_core
+executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - Gemfile
 - LICENSE
-- bin/smart_proxy_dynflow_core
-- config/settings.yml.example
-- deploy/smart_proxy_dynflow_core.init
-- deploy/smart_proxy_dynflow_core.service
 - lib/smart_proxy_dynflow_core.rb
-- lib/smart_proxy_dynflow_core/api.rb
-- lib/smart_proxy_dynflow_core/bundler_helper.rb
-- lib/smart_proxy_dynflow_core/callback.rb
-- lib/smart_proxy_dynflow_core/core.rb
-- 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/sd_notify.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
 - 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/bin/smart_proxy_dynflow_core

@@ -1,32 +0,0 @@
-#!/usr/bin/env ruby
-require 'dynflow'
-require 'rack'
-require 'smart_proxy_dynflow_core/launcher'
-require 'yaml'
-require 'optparse'
-
-options = {}
-OptionParser.new do |opts|
-  opts.on('-c', '--config-dir CONFIG_DIR', String, 'Directory to load settings from') do |value|
-    options[:config_dir] = value
-  end
-
-  opts.on('-1', '--one-config', 'Do not load more than 1 config') do |value|
-    options[:one_config] = true
-  end
-
-  opts.on('-d', '--[no-]daemonize', 'Fork to background after start') do |value|
-    options[:daemonize] = value
-  end
-
-  opts.on('-p', '--pid-file PID_FILE', String, 'Write pid to this file') do |value|
-    options[:pid_file] = value
-  end
-
-  opts.on_tail('-h', '--help', 'Show usage help') do
-    puts opts
-    exit
-  end
-end.parse!
-
-SmartProxyDynflowCore::Launcher.launch! options

data/config/settings.yml.example

@@ -1,50 +0,0 @@
----
-# Path to dynflow database, leave blank for in-memory non-persistent database
-:database:
-
-# URL of the foreman, used for reporting back
-:foreman_url: 'http://localhost:3000'
-
-# SSL settings for client authentication against Foreman
-# :foreman_ssl_ca: ssl/foreman_ca.pem
-# :foreman_ssl_key: ssl/foreman_key.pem
-# :foreman_ssl_cert: ssl/foreman_cert.pem
-
-:console_auth: false
-
-# Set to true to make the core fork to background after start
-# :daemonize: false
-# :pid_file: /var/run/foreman-proxy/smart_proxy_dynflow_core.pid
-
-# Listen on address
-:listen: 127.0.0.1
-
-# Listen on port
-:port: 8008
-
-# SSL settings for running core as https service
-# :use_https: false
-# :ssl_ca_file: ssl/ca.pem
-# :ssl_private_key: ssl/localhost.pem
-# :ssl_certificate: ssl/certs/localhost.pem
-
-# Use this option only if you need to disable certain cipher suites.
-# Note: we use the OpenSSL suite name, take a look at:
-# https://www.openssl.org/docs/manmaster/apps/ciphers.html#CIPHER-SUITE-NAMES
-# for more information.
-#:ssl_disabled_ciphers: [CIPHER-SUITE-1, CIPHER-SUITE-2]
-
-# Use this option only if you need to strictly specify TLS versions to be
-# disabled. SSLv3 and TLS v1.0 are always disabled and cannot be configured.
-# 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
-
-# Log level, one of UNKNOWN, FATAL, ERROR, WARN, INFO, DEBUG
-# :log_level: ERROR
-
-# 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

data/deploy/smart_proxy_dynflow_core.init

@@ -1,92 +0,0 @@
-#!/bin/bash
-#
-# Init script for foreman smart proxy dynflow core service
-#
-# chkconfig: - 85 15
-# description: Init script for foreman proxy dynflow core service
-
-# Source function library.
-. /etc/rc.d/init.d/functions
-
-prog=smart_proxy_dynflow_core
-RETVAL=0
-SMART_PROXY_DYNFLOW_CORE_PID=/var/run/foreman-proxy/$prog.pid
-SMART_PROXY_DYNFLOW_CORE_USER=${SMART_PROXY_DYNFLOW_CORE_USER:-foreman-proxy}
-
-start() {
-    echo -n $"Starting $prog: "
-    ulimit -n 65536
-    daemon --user ${SMART_PROXY_DYNFLOW_CORE_USER} /usr/bin/smart_proxy_dynflow_core -d -p $SMART_PROXY_DYNFLOW_CORE_PID > /dev/null
-    RETVAL=$?
-    if [ $RETVAL = 0 ]
-    then
-        echo_success
-    else
-        echo_failure
-    fi
-
-    echo
-    return $RETVAL
-}
-
-stop() {
-    echo -n $"Stopping $prog: "
-    if [ -f ${SMART_PROXY_DYNFLOW_CORE_PID} ]; then
-        killproc -p ${SMART_PROXY_DYNFLOW_CORE_PID}
-        RETVAL=$?
-    else
-        echo -n $"$prog was not running.";
-        failure $"$prog was not running.";
-        echo
-        return 1
-    fi
-    echo
-    [ $RETVAL -eq 0 ] && rm -f ${SMART_PROXY_DYNFLOW_CORE_PID}
-    return $RETVAL
-}
-
-logrotate() {
-    echo -n $"Rotating logs for $prog: "
-    if [ -f ${SMART_PROXY_DYNFLOW_CORE_PID} ]; then
-        killproc -p ${SMART_PROXY_DYNFLOW_CORE_PID} $prog -USR1
-        RETVAL=$?
-        echo
-    else
-        echo -n $"$prog was not running.";
-        failure $"$prog was not running.";
-        echo
-        return 1
-    fi
-    return $RETVAL
-}
-
-# See how we were called.
-case "$1" in
-    start)
-        start
-    ;;
-    stop)
-        stop
-    ;;
-    status)
-        echo -n "$prog"
-        status -p $SMART_PROXY_DYNFLOW_CORE_PID
-        RETVAL=$?
-    ;;
-    restart)
-        stop
-        start
-    ;;
-    condrestart)
-        stop
-        [ $? -eq 0 ] && start
-    ;;
-    logrotate)
-        logrotate
-    ;;
-    *)
-        echo $"Usage: $prog {start|stop|restart|condrestart|logrotate}"
-        exit 1
-esac
-
-exit $RETVAL

data/deploy/smart_proxy_dynflow_core.service

@@ -1,13 +0,0 @@
-[Unit]
-Description=Foreman smart proxy dynflow core service
-Documentation=https://github.com/theforeman/smart_proxy_dynflow
-After=network.target remote-fs.target nss-lookup.target
-
-[Service]
-Type=notify
-User=foreman-proxy
-ExecStart=/usr/bin/smart_proxy_dynflow_core --no-daemonize
-EnvironmentFile=-/etc/sysconfig/smart_proxy_dynflow_core
-
-[Install]
-WantedBy=multi-user.target

data/lib/smart_proxy_dynflow_core/api.rb

@@ -1,81 +0,0 @@
-require 'sinatra/base'
-require 'multi_json'
-
-module SmartProxyDynflowCore
-  class Api < ::Sinatra::Base
-    TASK_UPDATE_REGEXP_PATH = %r{/tasks/(\S+)/(update|done)}
-    helpers Helpers
-
-    before do
-      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
-
-    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
-
-    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
-
-    get "/tasks/:task_id/status" do |task_id|
-      task_status(task_id).to_json
-    end
-
-    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_core/bundler_helper.rb

@@ -1,31 +0,0 @@
-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
-        # gem which parses this file and loads all dependencies from the system
-        # rathern then trying to download them from rubygems.org. It always
-        # loads all gemfile groups.
-        begin
-          require 'bundler_ext' unless defined?(BundlerExt)
-        rescue LoadError
-          # Debian packaging guidelines state to avoid needing rubygems, so
-          # we only try to load it if the first require fails (for RPMs)
-          begin
-            require 'rubygems' rescue nil
-            require 'bundler_ext'
-          rescue LoadError
-            puts "`bundler_ext` gem is required to run smart_proxy"
-            exit 1
-          end
-        end
-        BundlerExt.system_require(File.expand_path('../../../Gemfile.in', __FILE__), *groups)
-      else
-        require 'bundler' unless defined?(Bundler)
-        Bundler.require(*groups)
-      end
-    end
-    # rubocop:enable Metrics/PerceivedComplexity
-  end
-end

data/lib/smart_proxy_dynflow_core/callback.rb

@@ -1,86 +0,0 @@
-require 'rest-client'
-
-# rubocop:disable Lint/HandleExceptions
-begin
-  require 'smart_proxy_dynflow/callback'
-rescue LoadError
-end
-# rubocop:enable Lint/HandleExceptions
-
-module SmartProxyDynflowCore
-  module Callback
-    class Request
-      class << self
-        def send_to_foreman_tasks(callback_info, data)
-          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 = {}
-          settings = Settings.instance
-          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
-
-        private
-
-        def prepare_payload(callback, data)
-          { :callback => callback, :data => data }.to_json
-        end
-      end
-
-      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(Settings.instance.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
-end

data/lib/smart_proxy_dynflow_core/core.rb

@@ -1,122 +0,0 @@
-module SmartProxyDynflowCore
-  class Core
-    attr_accessor :world, :accepted_cert_serial
-
-    def initialize
-      @world = create_world
-      cert_file = Settings.instance.foreman_ssl_cert || Settings.instance.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)
-      ::Dynflow::World.new(config)
-    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
-      if Settings.instance.standalone
-        Log::ProxyAdapter.new(Log.instance, Log.instance.level)
-      else
-        Log::ProxyAdapter.new(Proxy::LogBuffer::Decorator.instance, Log.instance.level)
-      end
-    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
-
-          before 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_core/helpers.rb

@@ -1,73 +0,0 @@
-module SmartProxyDynflowCore
-  module Helpers
-    def world
-      SmartProxyDynflowCore::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 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.instance.error "No client SSL certificate supplied"
-          halt 403, MultiJson.dump(:error => "No client SSL certificate supplied")
-        else
-          client_cert = OpenSSL::X509::Certificate.new(request.env['SSL_CLIENT_CERT'])
-          unless SmartProxyDynflowCore::Core.instance.accepted_cert_serial == client_cert.serial
-            Log.instance.error "SSL certificate with unexpected serial supplied"
-            halt 403, MultiJson.dump(:error => "SSL certificate with unexpected serial supplied")
-          end
-        end
-      else
-        Log.instance.debug 'require_ssl_client_verification: skipping, non-HTTPS request'
-      end
-    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_core/launcher.rb

@@ -1,167 +0,0 @@
-require 'webrick/https'
-require 'smart_proxy_dynflow_core/bundler_helper'
-require 'smart_proxy_dynflow_core/settings'
-require 'smart_proxy_dynflow_core/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
-      install_usr1_trap
-      Rack::Server.new(rack_settings).start do |_server|
-        SmartProxyDynflowCore::Core.ensure_initialized
-        SmartProxyDynflowCore::SdNotify.new.tap { |sd| sd.ready if sd.active? }
-      end
-    end
-
-    def load_settings!(options = {})
-      config_dir, one_config = options.values_at(:config_dir, :one_config)
-      possible_config_dirs = [
-        '/etc/smart_proxy_dynflow_core',
-        File.expand_path('~/.config/smart_proxy_dynflow_core'),
-        File.join(File.dirname(__FILE__), '..', '..', 'config'),
-      ]
-      possible_config_dirs << config_dir if config_dir
-      BundlerHelper.require_groups(:default)
-      possible_config_dirs.reverse! if one_config
-      possible_config_dirs.select { |config_dir| File.directory? config_dir }.each do |config_dir|
-        break if load_config_dir(config_dir) && one_config
-      end
-      Settings.instance.daemonize = options[:daemonize] if options.key?(:daemonize)
-      Settings.instance.pid_file = options[:pid_file] if options.key?(:pid_file)
-      Settings.loaded!
-    end
-
-    def self.route_mapping(rack_builder)
-      rack_builder.map '/console' do
-        run Core.web_console
-      end
-
-      rack_builder.map '/' do
-        run Api
-      end
-    end
-
-    def install_usr1_trap
-      trap(:USR1) do
-        Log.instance.roll_log
-      end
-    end
-
-    private
-
-    def rack_settings
-      settings = if https_enabled?
-                   Log.instance.debug "Using HTTPS"
-                   https_app
-                 else
-                   Log.instance.debug "Using HTTP"
-                   {}
-                 end
-      settings.merge(base_settings)
-    end
-
-    def app
-      Rack::Builder.new do
-        SmartProxyDynflowCore::Launcher.route_mapping(self)
-      end
-    end
-
-    def base_settings
-      {
-        :app => app,
-        :Host => Settings.instance.listen,
-        :Port => Settings.instance.port,
-        :AccessLog => [[Log.instance, WEBrick::AccessLog::COMMON_LOG_FORMAT]],
-        :Logger => Log.instance,
-        :daemonize => Settings.instance.daemonize,
-        :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)
-      # This is required to disable SSLv3 on Ruby 1.8.7
-      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
-
-          if constant
-            Log.instance.info "TLSv#{version} will be disabled."
-            ssl_options |= constant
-          else
-            Log.instance.warn "TLSv#{version} was not found."
-          end
-        end
-      end
-
-      {
-        :SSLEnable => true,
-        :SSLVerifyClient => OpenSSL::SSL::VERIFY_PEER,
-        :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
-    # rubocop:enable Metrics/PerceivedComplexity
-
-    def https_enabled?
-      Settings.instance.use_https
-    end
-
-    def ssl_private_key
-      OpenSSL::PKey::RSA.new(File.read(Settings.instance.ssl_private_key))
-    rescue Exception => e
-      Log.instance.fatal "Unable to load private SSL key. Are the values "\
-                         "correct in settings.yml and do permissions allow reading?: #{e}"
-      raise e
-    end
-
-    def ssl_certificate
-      OpenSSL::X509::Certificate.new(File.read(Settings.instance.ssl_certificate))
-    rescue Exception => e
-      Log.instance.fatal "Unable to load SSL certificate. Are the values " \
-                         "correct in settings.yml and do permissions allow reading?: #{e}"
-      raise e
-    end
-
-    def load_config_dir(dir)
-      settings_yml = File.join(dir, 'settings.yml')
-      if File.exist? settings_yml
-        Log.instance.debug "Loading settings from #{dir}"
-        Settings.load_global_settings settings_yml
-        Dir[File.join(dir, 'settings.d', '*.yml')].each { |path| Settings.load_plugin_settings(path) }
-        true
-      end
-      ForemanTasksCore::SettingsLoader.settings_registry.each_key do |settings_keys|
-        settings = settings_keys.inject({}) do |h, settings_key|
-          if SETTINGS.plugins.key?(settings_key.to_s)
-            h.merge(SETTINGS.plugins[settings_key.to_s].to_h)
-          else
-            h
-          end
-        end
-        ForemanTasksCore::SettingsLoader.setup_settings(settings_keys.first, settings)
-      end
-    end
-  end
-end

data/lib/smart_proxy_dynflow_core/log.rb

@@ -1,86 +0,0 @@
-require 'logger'
-
-module SmartProxyDynflowCore
-  class Log < ::Logger
-    alias_method :write, :debug
-
-    class << self
-      def instance
-        if @logger.nil?
-          @logger = self.new log_file
-          @logger.level = log_level
-        end
-        @logger
-      end
-
-      def instance=(logger)
-        @logger = logger
-      end
-
-      def reload!
-        @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
-        end
-      end
-
-      def log_file
-        if Settings.instance.loaded && Settings.instance.log_file
-          Settings.instance.log_file
-        else
-          $stdout
-        end
-      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 roll_log
-      unless @file.is_a? IO
-        @fd.reopen @file, 'a'
-        @fd.sync = true
-      end
-    end
-
-    class ProxyStructuredFormater < ::Dynflow::LoggerAdapters::Formatters::Abstract
-      def call(_severity, _datetime, _prog_name, 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
-          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])
-      end
-    end
-  end
-end

data/lib/smart_proxy_dynflow_core/sd_notify.rb

@@ -1,33 +0,0 @@
-# Shamelessly taken from theforeman/smart-proxy @ 99e9e5b
-# kudos to domcleal
-
-require 'socket'
-
-# Implementation of libsystemd's sd_notify API, sends current state via socket
-module SmartProxyDynflowCore
-  class SdNotify
-    def active?
-      !ENV['NOTIFY_SOCKET'].nil?
-    end
-
-    def notify(message)
-      create_socket.tap do |socket|
-        socket.sendmsg(message.chomp + "\n") # ensure trailing \n
-        socket.close
-      end
-    end
-
-    def ready(state = 1)
-      notify("READY=#{state}")
-    end
-
-    private
-
-    def create_socket
-      raise 'Missing NOTIFY_SOCKET environment variable, is this process running under systemd?' unless active?
-      Socket.new(Socket::AF_UNIX, Socket::SOCK_DGRAM, 0).tap do |socket|
-        socket.connect(Socket.pack_sockaddr_un(ENV['NOTIFY_SOCKET']))
-      end
-    end
-  end
-end

data/lib/smart_proxy_dynflow_core/settings.rb

@@ -1,104 +0,0 @@
-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 = {
-      :database => '/var/lib/foreman-proxy/dynflow/dynflow.sqlite',
-      :foreman_url => 'https://127.0.0.1:3000',
-      :console_auth => true,
-      :listen => '127.0.0.1',
-      :port => '8008',
-      :use_https => false,
-      :ssl_ca_file => nil,
-      :ssl_private_key => nil,
-      :ssl_certificate => nil,
-      :ssl_disabled_ciphers => [],
-      :tls_disabled_versions => [],
-      :foreman_ssl_ca => nil,
-      :foreman_ssl_key => nil,
-      :foreman_ssl_cert => nil,
-      :standalone => false,
-      :log_file => '/var/log/foreman-proxy/smart_proxy_dynflow_core.log',
-      :log_level => :ERROR,
-      :plugins => {},
-      :pid_file => '/var/run/foreman-proxy/smart_proxy_dynflow_core.pid',
-      :daemonize => false,
-      :execution_plan_cleaner_age => 60 * 60 * 24,
-      :loaded => false
-    }.freeze
-
-    PROXY_SETTINGS = %i[ssl_ca_file ssl_certificate ssl_private_key foreman_url
-                        foreman_ssl_ca foreman_ssl_cert foreman_ssl_key
-                        log_file log_level ssl_disabled_ciphers].freeze
-    PLUGIN_SETTINGS = %i[database core_url console_auth
-                         execution_plan_cleaner_age].freeze
-
-    def initialize(settings = {})
-      super(DEFAULT_SETTINGS.merge(settings))
-    end
-
-    def self.instance
-      SmartProxyDynflowCore::SETTINGS
-    end
-
-    def self.load_global_settings(path)
-      if File.exist? File.join(path)
-        YAML.load_file(path).each do |key, value|
-          SETTINGS[key] = value
-        end
-      end
-    end
-
-    def self.loaded!
-      Settings.instance.loaded = true
-      Log.instance.info 'Settings loaded, reloading logger'
-      Log.reload!
-    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
-      PROXY_SETTINGS.each do |key|
-        SETTINGS[key] = Proxy::SETTINGS[key]
-      end
-      PLUGIN_SETTINGS.each do |key|
-        SETTINGS[key] = settings[key] if settings.key?(key)
-      end
-      SETTINGS.plugins.values.each(&:load_settings_from_proxy)
-      Settings.loaded!
-    end
-
-    def self.load_plugin_settings(path)
-      settings = YAML.load_file(path)
-      name = File.basename(path).gsub(/\.yml$/, '')
-      if SETTINGS.plugins.key? name
-        settings = SETTINGS.plugins[name].to_h.merge(settings)
-      end
-      SETTINGS.plugins[name] = OpenStruct.new settings
-    end
-  end
-end
-
-SmartProxyDynflowCore::SETTINGS = SmartProxyDynflowCore::Settings.new

data/lib/smart_proxy_dynflow_core/testing.rb

@@ -1,28 +0,0 @@
-require 'dynflow/testing'
-
-unless defined? DYNFLOW_TESTING_LOG_LEVEL
-  DYNFLOW_TESTING_LOG_LEVEL = 4
-end
-
-module SmartProxyDynflowCore
-  class 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
-end
-
-Concurrent.disable_at_exit_handlers!