smart_proxy_salt 2.1.9 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 85ca85442234e6c70fe35cf796b48921c051f2ac11696ad79b475cf326e3415a
-  data.tar.gz: f7fe7ba6d9028def717e0e0f6250d2d50cac55c8512ed7481d9a58733cb754f2
+  metadata.gz: 978fe04cd0b2ee65be99fc84f20599f295d51498b8aa1ba0541cc9569f56ee9a
+  data.tar.gz: 732c3b575790b37ec8570816f76d10af534b10cf3fb7ea217b7378f645c951f9
 SHA512:
-  metadata.gz: 68630d6978885cfbacc7651ea230b2596d915c85ff1373d0be8f4db2e3cb984479c2ddadeb1f43b604b769c154cfd77d7186247dbd8ac8f77d560f17edd2c12a
-  data.tar.gz: ae6a97eccbe59f9c33a0d49724ab3b58c09190752cfe39223a0afb0089631084148b9a5674198cefc3cfb96fb8370479dc8967385260aaacc31fed19f6ec74c3
+  metadata.gz: d291974d5e815bb0a8d84f46d8f4e8509d0c70dc8dc76fa9d35d0f836ff7e55f3fe7f67c3cd0d5fc1452d2747b528ccca05c0de7d881042468b652a30824dd5e
+  data.tar.gz: e41c156691bb2c1c86381658104a4fb54fb4d6a22a8e1778b7dc6ce9f39d40183d649699c49b8c835815c16b073886d68d0988bf0a019c79d8fbb001cdc7133c

data/bin/foreman-node

@@ -1,12 +1,14 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
+
 # This is the external nodes script to allow Salt to retrieve info about a host
 # from Foreman.  It also uploads a node's grains to Foreman, if the setting is
 # enabled.
 
 require 'yaml'
 
-$settings_file = '/etc/salt/foreman.yaml'
-SETTINGS = YAML.load_file($settings_file)
+settings_file = '/etc/salt/foreman.yaml'
+SETTINGS = YAML.load_file(settings_file)
 
 require 'net/http'
 require 'net/https'
@@ -19,9 +21,13 @@ 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
+    begin
+      require 'rubygems'
+    rescue Exception
+      nil
+    end
     require 'json'
-  rescue LoadError => e
+  rescue LoadError
     puts 'You need the `json` gem to use the Foreman ENC script'
     # code 1 is already used below
     exit 2
@@ -37,20 +43,18 @@ def valid_hostname?(hostname)
 end
 
 def get_grains(minion)
-  begin
-    grains = {
-      :name  => minion,
-      :facts => plain_grains(minion).merge({:_timestamp => Time.now, :_type => 'foreman_salt'})
-    }
-
-    grains[:facts][:operatingsystem] = grains[:facts]['os']
-    grains[:facts][:operatingsystemrelease] = grains[:facts]['osrelease']
-
-    JSON.pretty_generate(grains)
-  rescue => e
-    puts "Could not get grains: #{e}"
-    exit 1
-  end
+  grains = {
+    :name  => minion,
+    :facts => plain_grains(minion).merge(:_timestamp => Time.now, :_type => 'foreman_salt')
+  }
+
+  grains[:facts][:operatingsystem] = grains[:facts]['os']
+  grains[:facts][:operatingsystemrelease] = grains[:facts]['osrelease']
+
+  JSON.pretty_generate(grains)
+rescue Exception => e
+  puts "Could not get grains: #{e}"
+  exit 1
 end
 
 def plain_grains(minion)
@@ -61,7 +65,7 @@ def plain_grains(minion)
   # so we have resort to python to extract the grains.
   # Based on https://github.com/saltstack/salt/issues/9444
 
-script = <<-EOF
+  script = <<-EOF
 #!/usr/bin/env python
 import json
 import os
@@ -73,30 +77,28 @@ import salt.runner
 if __name__ == '__main__':
     __opts__ = salt.config.master_config(
             os.environ.get('SALT_MASTER_CONFIG', '/etc/salt/master'))
-    runner = salt.runner.Runner(__opts__)  
-   
+    runner = salt.runner.Runner(__opts__)
+
     stdout_bak = sys.stdout
     with open(os.devnull, 'wb') as f:
-        sys.stdout = f  
+        sys.stdout = f
         ret = runner.cmd('cache.grains', ['#{minion}'])
     sys.stdout = stdout_bak
 
     print json.dumps(ret)
 EOF
 
-  result = IO.popen('python 2>/dev/null', mode='r+') do |python|
+  result = IO.popen('python 2>/dev/null', 'r+') do |python|
     python.write script
     python.close_write
     result = python.read
   end
 
-  grains = JSON.load(result)
+  grains = JSON.parse(result)
 
-  if grains
-    plainify(grains[minion]).flatten.inject(&:merge)
-  else
-    raise 'No grains received from Salt master'
-  end
+  raise 'No grains received from Salt master' unless grains
+
+  plainify(grains[minion]).flatten.inject(&:merge)
 end
 
 def plainify(hash, prefix = nil)
@@ -126,33 +128,31 @@ def get_key(key, prefix)
 end
 
 def upload_grains(minion)
-  begin
-    grains = get_grains(minion)
-    uri = URI.parse("#{foreman_url}/api/hosts/facts")
-    req = Net::HTTP::Post.new(uri.request_uri)
-    req.add_field('Accept', 'application/json,version=2' )
-    req.content_type = 'application/json'
-    req.body         = grains 
-    res              = Net::HTTP.new(uri.host, uri.port)
-    res.use_ssl      = uri.scheme == 'https'
-    if res.use_ssl?
-      if SETTINGS[:ssl_ca] && !SETTINGS[:ssl_ca].empty?
-        res.ca_file = SETTINGS[:ssl_ca]
-        res.verify_mode = OpenSSL::SSL::VERIFY_PEER
-      else
-        res.verify_mode = OpenSSL::SSL::VERIFY_NONE
-      end
-      if SETTINGS[:ssl_cert] && !SETTINGS[:ssl_cert].empty? && SETTINGS[:ssl_key] && !SETTINGS[:ssl_key].empty?
-        res.cert = OpenSSL::X509::Certificate.new(File.read(SETTINGS[:ssl_cert]))
-        res.key  = OpenSSL::PKey::RSA.new(File.read(SETTINGS[:ssl_key]), nil)
-      end
-    elsif SETTINGS[:username] && SETTINGS[:password]
-      req.basic_auth(SETTINGS[:username], SETTINGS[:password])
+  grains = get_grains(minion)
+  uri = URI.parse("#{foreman_url}/api/hosts/facts")
+  req = Net::HTTP::Post.new(uri.request_uri)
+  req.add_field('Accept', 'application/json,version=2')
+  req.content_type = 'application/json'
+  req.body         = grains
+  res              = Net::HTTP.new(uri.host, uri.port)
+  res.use_ssl      = uri.scheme == 'https'
+  if res.use_ssl?
+    if SETTINGS[:ssl_ca] && !SETTINGS[:ssl_ca].empty?
+      res.ca_file = SETTINGS[:ssl_ca]
+      res.verify_mode = OpenSSL::SSL::VERIFY_PEER
+    else
+      res.verify_mode = OpenSSL::SSL::VERIFY_NONE
     end
-    res.start { |http| http.request(req) }
-  rescue => e
-    raise "Could not send facts to Foreman: #{e}"
+    if SETTINGS[:ssl_cert] && !SETTINGS[:ssl_cert].empty? && SETTINGS[:ssl_key] && !SETTINGS[:ssl_key].empty?
+      res.cert = OpenSSL::X509::Certificate.new(File.read(SETTINGS[:ssl_cert]))
+      res.key  = OpenSSL::PKey::RSA.new(File.read(SETTINGS[:ssl_key]), nil)
+    end
+  elsif SETTINGS[:username] && SETTINGS[:password]
+    req.basic_auth(SETTINGS[:username], SETTINGS[:password])
   end
+  res.start { |http| http.request(req) }
+rescue Exception => e
+  raise "Could not send facts to Foreman: #{e}"
 end
 
 def enc(minion)
@@ -176,7 +176,7 @@ def enc(minion)
     req.basic_auth(SETTINGS[:username], SETTINGS[:password])
   end
 
-  res = http.start { |http| http.request(req) }
+  res = http.start { |conn| conn.request(req) }
 
   raise "Error retrieving node #{minion}: #{res.class}\nCheck Foreman's /var/log/foreman/production.log for more information." unless res.code == '200'
   res.body
@@ -198,7 +198,7 @@ begin
     result = enc(minion)
   end
   puts result
-rescue => e
+rescue Exception => e
   puts "Couldn't retrieve ENC data: #{e}"
   exit 1
 end

data/bundler.d/salt.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 gem 'smart_proxy_salt'

data/lib/smart_proxy_salt/api_request.rb

@@ -1,44 +1,49 @@
+# frozen_string_literal: true
+
 require 'json'
 require 'net/http'
 require 'net/https'
 require 'uri'
 
-module Proxy::Salt
-  class ApiError < RuntimeError; end
-
-  class ApiRequest
-    attr_reader :url, :username, :password, :auth
-
-    def initialize
-      @url = Proxy::Salt::Plugin.settings.api_url
-      @auth = Proxy::Salt::Plugin.settings.api_auth
-      @username = Proxy::Salt::Plugin.settings.api_username
-      @password = Proxy::Salt::Plugin.settings.api_password
-
-      begin
-        URI.parse(url)
-      rescue URI::InvalidURIError => e
-        raise ConfigurationError.new("Invalid Salt api_url setting: #{e}")
+module Proxy
+  module Salt
+    class ApiError < RuntimeError; end
+    class ConfigurationError < RuntimeError; end
+
+    # SaltStack's Rest API
+    class ApiRequest
+      attr_reader :url, :username, :password, :auth
+
+      def initialize
+        @url = Proxy::Salt::Plugin.settings.api_url
+        @auth = Proxy::Salt::Plugin.settings.api_auth
+        @username = Proxy::Salt::Plugin.settings.api_username
+        @password = Proxy::Salt::Plugin.settings.api_password
+
+        begin
+          URI.parse(url)
+        rescue URI::InvalidURIError => e
+          raise ConfigurationError.new("Invalid Salt api_url setting: #{e}")
+        end
       end
-    end
 
-    def post(path, options = {})
-      uri              = URI.parse(url)
-      http             = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl     = uri.scheme == 'https'
-      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-      path = [uri.path, path].join('/') unless uri.path.empty?
+      def post(path, options = {})
+        uri              = URI.parse(url)
+        http             = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl     = uri.scheme == 'https'
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        path = [uri.path, path].join unless uri.path.empty?
+
+        request = Net::HTTP::Post.new(URI.join(uri.to_s, path).path)
+        request.add_field('Accept', 'application/json')
+        request.set_form_data(options.merge(:username => username, :password => password, :eauth => auth))
 
-      request = Net::HTTP::Post.new(URI.join(uri.to_s, path).path)
-      request.add_field('Accept', 'application/json')
-      request.set_form_data(options.merge(:username => username, :password => password, :eauth => auth))
+        response = http.request(request)
 
-      response = http.request(request)
+        raise NotFound.new("Received 404 from Salt API: #{response.body}") if response.is_a?(Net::HTTPNotFound)
+        raise ApiError.new("Failed to query Salt API (#{response.code}): #{response.body}") unless response.is_a?(Net::HTTPOK)
 
-      if response.is_a? Net::HTTPOK
-        JSON.load(response.body)
-      else
-        raise ApiError.new("Failed to query Salt API (#{response.code}): #{response.body}")
+        JSON.parse(response.body)
       end
     end
   end

data/lib/smart_proxy_salt/cli.rb

@@ -1,163 +1,168 @@
-module Proxy::Salt::CLI
-  extend ::Proxy::Log
-  extend ::Proxy::Util
+# frozen_string_literal: true
 
-  class << self
-    def autosign_file
-      Proxy::Salt::Plugin.settings.autosign_file
-    end
+require 'English'
 
-    def autosign_create(host)
-      FileUtils.touch(autosign_file) unless File.exist?(autosign_file)
+module Proxy
+  module Salt
+    # CLI methods
+    module CLI
+      extend ::Proxy::Log
+      extend ::Proxy::Util
 
-      autosign = open(autosign_file, File::RDWR)
+      class << self
+        def autosign_file
+          Proxy::Salt::Plugin.settings.autosign_file
+        end
 
-      found = false
-      autosign.each_line { |line| found = true if line.chomp == host }
-      autosign.puts host unless found
-      autosign.close
+        def autosign_create(host)
+          FileUtils.touch(autosign_file) unless File.exist?(autosign_file)
 
-      result = {:message => "Added #{host} to autosign"}
-      logger.info result[:message]
-      result
-    end
+          autosign = open(autosign_file, File::RDWR)
 
-    def autosign_remove(host)
-      raise "No such file #{autosign_file}" unless File.exists?(autosign_file)
+          found = false
+          autosign.each_line { |line| found = true if line.chomp == host }
+          autosign.puts host unless found
+          autosign.close
 
-      found = false
-      entries = open(autosign_file, File::RDONLY).readlines.collect do |l|
-        if l.chomp != host
-          l
-        else
-          found = true
-          nil
+          result = { :message => "Added #{host} to autosign" }
+          logger.info result[:message]
+          result
         end
-      end.uniq.compact
-      if found
-        autosign = open(autosign_file, File::TRUNC|File::RDWR)
-        autosign.write entries.join("\n")
-        autosign.write "\n"
-        autosign.close
-        result = {:message => "Removed #{host} from autosign"}
-        logger.info result[:message]
-        result
-      else
-        logger.info "Attempt to remove nonexistant client autosign for #{host}"
-        raise Proxy::Salt::NotFound, "Attempt to remove nonexistant client autosign for #{host}"
-      end
-    end
-
-    def autosign_list
-      return [] unless File.exist?(autosign_file)
-      File.read(autosign_file).split("\n").reject { |v|
-        v =~ /^\s*#.*|^$/ ## Remove comments and empty lines
-      }.map { |v|
-        v.chomp ## Strip trailing spaces
-      }
-    end
 
-    def highstate(host)
-      find_salt_binaries
-      cmd = [@sudo, '-u', Proxy::Salt::Plugin.settings.salt_command_user, @salt, '--async', escape_for_shell(host), 'state.highstate']
-      logger.info "Will run state.highstate for #{host}. Full command: #{cmd.join(' ')}"
-      shell_command(cmd)
-    end
-
-    def key_delete(host)
-      find_salt_binaries
-      cmd = [@sudo, '-u', Proxy::Salt::Plugin.settings.salt_command_user, @salt_key, '--yes', '-d', escape_for_shell(host)]
-      shell_command(cmd)
-    end
-
-    def key_reject(host)
-      find_salt_binaries
-      cmd = [@sudo, '-u', Proxy::Salt::Plugin.settings.salt_command_user, @salt_key, '--include-accepted', '--yes', '-r', escape_for_shell(host)]
-      shell_command(cmd)
-    end
+        def autosign_remove(host)
+          raise "No such file #{autosign_file}" unless File.exist?(autosign_file)
+
+          found = false
+          entries = open(autosign_file, File::RDONLY).readlines.collect do |l|
+            if l.chomp != host
+              l
+            else
+              found = true
+              nil
+            end
+          end.uniq.compact
+          if found
+            autosign = open(autosign_file, File::TRUNC | File::RDWR)
+            autosign.write entries.join("\n")
+            autosign.write "\n"
+            autosign.close
+            result = { :message => "Removed #{host} from autosign" }
+            logger.info result[:message]
+            result
+          else
+            logger.info "Attempt to remove nonexistant client autosign for #{host}"
+            raise Proxy::Salt::NotFound.new("Attempt to remove nonexistant client autosign for #{host}")
+          end
+        end
 
-    def key_accept(host)
-      find_salt_binaries
-      cmd = [@sudo, '-u', Proxy::Salt::Plugin.settings.salt_command_user, @salt_key, '--include-rejected', '--yes', '-a', escape_for_shell(host)]
-      shell_command(cmd)
-    end
+        def autosign_list
+          return [] unless File.exist?(autosign_file)
+          File.read(autosign_file).split("\n").reject do |v|
+            v =~ /^\s*#.*|^$/ ## Remove comments and empty lines
+          end.map(&:chomp)
+        end
 
-    def key_list
+        def highstate(host)
+          find_salt_binaries
+          cmd = [@sudo, '-u', Proxy::Salt::Plugin.settings.salt_command_user, @salt, '--async', escape_for_shell(host), 'state.highstate']
+          logger.info "Will run state.highstate for #{host}. Full command: #{cmd.join(' ')}"
+          shell_command(cmd)
+        end
 
-      find_salt_binaries
-      command = "#{@sudo} -u #{Proxy::Salt::Plugin.settings.salt_command_user} #{@salt_key} --finger-all --output=json"
-      logger.debug "Executing #{command}"
-      response = `#{command}`
-      unless $? == 0
-        logger.warn "Failed to run salt-key: #{response}"
-        raise 'Execution of salt-key failed, check log files'
-      end
+        def key_delete(host)
+          find_salt_binaries
+          cmd = [@sudo, '-u', Proxy::Salt::Plugin.settings.salt_command_user, @salt_key, '--yes', '-d', escape_for_shell(host)]
+          shell_command(cmd)
+        end
 
-      keys_hash = {}
+        def key_reject(host)
+          find_salt_binaries
+          cmd = [@sudo, '-u', Proxy::Salt::Plugin.settings.salt_command_user, @salt_key, '--include-accepted', '--yes', '-r', escape_for_shell(host)]
+          shell_command(cmd)
+        end
 
-      sk_hash = JSON.parse(response)
+        def key_accept(host)
+          find_salt_binaries
+          cmd = [@sudo, '-u', Proxy::Salt::Plugin.settings.salt_command_user, @salt_key, '--include-rejected', '--yes', '-a', escape_for_shell(host)]
+          shell_command(cmd)
+        end
 
-      accepted_minions = sk_hash['minions']
-      accepted_minions.keys.each { | accepted_minion | keys_hash[accepted_minion] = { 'state' => 'accepted', 'fingerprint' => accepted_minions[accepted_minion]} } if sk_hash.key? 'minions'
+        def key_list
+          find_salt_binaries
+          command = "#{@sudo} -u #{Proxy::Salt::Plugin.settings.salt_command_user} #{@salt_key} --finger-all --output=json"
+          logger.debug "Executing #{command}"
+          response = `#{command}`
+          unless $CHILD_STATUS == 0
+            logger.warn "Failed to run salt-key: #{response}"
+            raise 'Execution of salt-key failed, check log files'
+          end
 
-      rejected_minions = sk_hash['minions_rejected']
-      rejected_minions.keys.each { | rejected_minion | keys_hash[rejected_minion] = { 'state' => 'rejected', 'fingerprint' => rejected_minions[rejected_minion] } } if sk_hash.key? 'minions_rejected'
+          keys_hash = {}
 
-      unaccepted_minions = sk_hash['minions_pre']
-      unaccepted_minions.keys.each { | unaccepted_minion | keys_hash[unaccepted_minion] = { 'state' => 'unaccepted', 'fingerprint' => unaccepted_minions[unaccepted_minion] } } if sk_hash.key? 'minions_pre'
+          sk_hash = JSON.parse(response)
 
-      keys_hash
+          accepted_minions = sk_hash['minions']
+          accepted_minions.each_key { |accepted_minion| keys_hash[accepted_minion] = { 'state' => 'accepted', 'fingerprint' => accepted_minions[accepted_minion] } } if sk_hash.key? 'minions'
 
-    end
+          rejected_minions = sk_hash['minions_rejected']
+          rejected_minions.each_key { |rejected_minion| keys_hash[rejected_minion] = { 'state' => 'rejected', 'fingerprint' => rejected_minions[rejected_minion] } } if sk_hash.key? 'minions_rejected'
 
-    private
+          unaccepted_minions = sk_hash['minions_pre']
+          unaccepted_minions.each_key { |unaccepted_minion| keys_hash[unaccepted_minion] = { 'state' => 'unaccepted', 'fingerprint' => unaccepted_minions[unaccepted_minion] } } if sk_hash.key? 'minions_pre'
 
-    def shell_command(cmd, wait = true)
-      begin
-        c = popen(cmd)
-        unless wait
-          Process.detach(c.pid)
-          return 0
+          keys_hash
         end
-        Process.wait(c.pid)
-        logger.info("Result: #{c.read}")
-      rescue Exception => e
-        logger.error("Exception '#{e}' when executing '#{cmd}'")
-        return false
-      end
-      logger.warn("Non-null exit code when executing '#{cmd}'") if $?.exitstatus != 0
-      $?.exitstatus == 0
-    end
 
-    def popen(cmd)
-      # 1.8.7 note: this assumes that cli options are space-separated
-      cmd = cmd.join(' ') unless RUBY_VERSION > '1.8.7'
-      logger.debug("about to execute: #{cmd}")
-      IO.popen(cmd)
-    end
-
-    def find_salt_binaries
-      @salt_key = which('salt-key')
-      unless File.exists?("#{@salt_key}")
-        logger.warn 'unable to find salt-key binary'
-        raise 'unable to find salt-key'
-      end
-      logger.debug "Found salt-key at #{@salt_key}"
+        private
+
+        def shell_command(cmd, wait = true)
+          begin
+            c = popen(cmd)
+            unless wait
+              Process.detach(c.pid)
+              return 0
+            end
+            Process.wait(c.pid)
+            logger.info("Result: #{c.read}")
+          rescue Exception => e
+            logger.error("Exception '#{e}' when executing '#{cmd}'")
+            return false
+          end
+          logger.warn("Non-null exit code when executing '#{cmd}'") unless $CHILD_STATUS.success?
+          $CHILD_STATUS.success?
+        end
 
-      @salt = which('salt')
-      unless File.exists?("#{@salt}")
-        logger.warn 'unable to find salt binary'
-        raise 'unable to find salt'
-      end
-      logger.debug "Found salt at #{@salt}"
+        def popen(cmd)
+          # 1.8.7 note: this assumes that cli options are space-separated
+          cmd = cmd.join(' ') unless RUBY_VERSION > '1.8.7'
+          logger.debug("about to execute: #{cmd}")
+          IO.popen(cmd)
+        end
 
-      @sudo = which('sudo')
-      unless File.exists?(@sudo)
-        logger.warn 'unable to find sudo binary'
-        raise 'Unable to find sudo'
+        def find_salt_binaries
+          @salt_key = which('salt-key')
+          unless File.exist?(@salt_key.to_s)
+            logger.warn 'unable to find salt-key binary'
+            raise 'unable to find salt-key'
+          end
+          logger.debug "Found salt-key at #{@salt_key}"
+
+          @salt = which('salt')
+          unless File.exist?(@salt.to_s)
+            logger.warn 'unable to find salt binary'
+            raise 'unable to find salt'
+          end
+          logger.debug "Found salt at #{@salt}"
+
+          @sudo = which('sudo')
+          unless File.exist?(@sudo)
+            logger.warn 'unable to find sudo binary'
+            raise 'Unable to find sudo'
+          end
+          logger.debug "Found sudo at #{@sudo}"
+          @sudo = @sudo.to_s
+        end
       end
-      logger.debug "Found sudo at #{@sudo}"
-      @sudo = "#{@sudo}"
     end
   end
 end

data/lib/smart_proxy_salt/rest.rb

@@ -1,31 +1,34 @@
+# frozen_string_literal: true
+
 require 'json'
 require 'smart_proxy_salt/api_request'
 
-module Proxy::Salt::Rest
-  extend ::Proxy::Log
-  extend ::Proxy::Util
+module Proxy
+  module Salt
+    # Rest Salt API methods
+    module Rest
+      extend ::Proxy::Log
+      extend ::Proxy::Util
 
-  class << self
-    def environments_list
-      JSON.dump(Proxy::Salt::ApiRequest.new.post('/run', :fun => 'fileserver.envs', :client => 'runner')['return'][0])
-    end
+      class << self
+        def environments_list
+          JSON.dump(Proxy::Salt::ApiRequest.new.post('/run', :fun => 'fileserver.envs', :client => 'runner')['return'][0])
+        end
 
-    def states_list(environment)
-      states = []
-      files = Proxy::Salt::ApiRequest.new.post('/run', :fun => 'fileserver.file_list',
-                                   :saltenv => environment,
-                                   :client => 'runner')['return'][0]
+        def states_list(environment)
+          states = []
+          files = Proxy::Salt::ApiRequest.new.post('/run', :fun => 'fileserver.file_list',
+                                                           :saltenv => environment,
+                                                           :client => 'runner')['return'][0]
 
-      files.each do |file|
-        if file =~ /\.sls\Z/ && file != "top.sls"
-          states << file.gsub('.sls', '').
-                         gsub('/init', '').
-                         chomp('/').
-                         gsub('/', '.')
+          files.each do |file|
+            next unless file =~ /\.sls\Z/ && file != 'top.sls'
+            states << file.gsub('.sls', '').gsub('/init', '').chomp('/').tr('/', '.')
+          end
+
+          JSON.dump(states)
         end
       end
-
-      JSON.dump(states)
     end
   end
 end

data/lib/smart_proxy_salt/salt.rb

@@ -1,31 +1,37 @@
+# frozen_string_literal: true
+
 require 'smart_proxy_salt/cli'
 require 'smart_proxy_salt/rest'
 
-module Proxy::Salt
-  class NotFound < RuntimeError; end
+module Proxy
+  # SmartProxy Salt
+  module Salt
+    class NotFound < RuntimeError; end
 
-  class Plugin < ::Proxy::Plugin
-    plugin 'salt', Proxy::Salt::VERSION
+    # Implement a SmartProxy plugin
+    class Plugin < ::Proxy::Plugin
+      plugin 'salt', Proxy::Salt::VERSION
 
-    default_settings :autosign_file      => '/etc/salt/autosign.conf',
-                     :salt_command_user  => 'root',
-                     :use_api            => false
+      default_settings :autosign_file      => '/etc/salt/autosign.conf',
+                       :salt_command_user  => 'root',
+                       :use_api            => false
 
-    http_rackup_path File.expand_path('salt_http_config.ru', File.expand_path('../', __FILE__))
-    https_rackup_path File.expand_path('salt_http_config.ru', File.expand_path('../', __FILE__))
-  end
+      http_rackup_path File.expand_path('salt_http_config.ru', File.expand_path('../', __FILE__))
+      https_rackup_path File.expand_path('salt_http_config.ru', File.expand_path('../', __FILE__))
+    end
 
-  class << self
-    def method_missing(m, *args, &block)
-      # Use API, if it supports it, otherwise fallback to the CLI
-      if Proxy::Salt::Plugin.settings.use_api && Proxy::Salt::Rest.respond_to?(m)
-        Proxy::Salt::Rest.send(m, *args, &block)
-      elsif Proxy::Salt::CLI.respond_to?(m)
-        Proxy::Salt::CLI.send(m, *args, &block)
-      elsif !Proxy::Salt::Plugin.settings.use_api && Proxy::Salt::Rest.respond_to?(m)
-        raise NotImplementedError, 'You must enable the Salt API to use this feature.'
-      else
-        super
+    class << self
+      def method_missing(m, *args, &block)
+        # Use API, if it supports it, otherwise fallback to the CLI
+        if Proxy::Salt::Plugin.settings.use_api && Proxy::Salt::Rest.respond_to?(m)
+          Proxy::Salt::Rest.send(m, *args, &block)
+        elsif Proxy::Salt::CLI.respond_to?(m)
+          Proxy::Salt::CLI.send(m, *args, &block)
+        elsif !Proxy::Salt::Plugin.settings.use_api && Proxy::Salt::Rest.respond_to?(m)
+          raise NotImplementedError.new('You must enable the Salt API to use this feature.')
+        else
+          super
+        end
       end
     end
   end

data/lib/smart_proxy_salt/salt_api.rb

@@ -1,104 +1,109 @@
+# frozen_string_literal: true
+
 require 'sinatra'
 require 'smart_proxy_salt/salt'
 
-module Proxy::Salt
-  class Api < ::Sinatra::Base
-    include ::Proxy::Log
-    helpers ::Proxy::Helpers
-    authorize_with_ssl_client
+module Proxy
+  module Salt
+    # Implement the SmartProxy API
+    class Api < ::Sinatra::Base
+      include ::Proxy::Log
+      helpers ::Proxy::Helpers
+      authorize_with_ssl_client
 
-    post '/autosign/:host' do
-      content_type :json
-      begin
-        Proxy::Salt.autosign_create(params[:host]).to_json
-      rescue => e
-        log_halt 406, "Failed to create autosign for #{params[:host]}: #{e}"
+      post '/autosign/:host' do
+        content_type :json
+        begin
+          Proxy::Salt.autosign_create(params[:host]).to_json
+        rescue Exception => e
+          log_halt 406, "Failed to create autosign for #{params[:host]}: #{e}"
+        end
       end
-    end
 
-    delete '/autosign/:host' do
-      content_type :json
-      begin
-        Proxy::Salt.autosign_remove(params[:host]).to_json
-      rescue Proxy::Salt::NotFound => e
-        log_halt 404, "#{e}"
-      rescue => e
-        log_halt 406, "Failed to remove autosign for #{params[:host]}: #{e}"
+      delete '/autosign/:host' do
+        content_type :json
+        begin
+          Proxy::Salt.autosign_remove(params[:host]).to_json
+        rescue Proxy::Salt::NotFound => e
+          log_halt 404, e.to_s
+        rescue Exception => e
+          log_halt 406, "Failed to remove autosign for #{params[:host]}: #{e}"
+        end
       end
-    end
 
-    get '/autosign' do
-      content_type :json
-      begin
-        Proxy::Salt::autosign_list.to_json
-      rescue => e
-        log_halt 406, "Failed to list autosign entries: #{e}"
+      get '/autosign' do
+        content_type :json
+        begin
+          Proxy::Salt.autosign_list.to_json
+        rescue Exception => e
+          log_halt 406, "Failed to list autosign entries: #{e}"
+        end
       end
-    end
 
-    get '/environments' do
-      content_type :json
-      begin
-        Proxy::Salt::environments_list
-      rescue => e
-        log_halt 406, "Failed to list environments: #{e}"
+      get '/environments' do
+        content_type :json
+        begin
+          Proxy::Salt.environments_list
+        rescue Exception => e
+          log_halt 406, "Failed to list environments: #{e}"
+        end
       end
-    end
 
-    get '/environments/:environment' do
-      content_type :json
-      begin
-        Proxy::Salt::states_list params[:environment]
-      rescue Proxy::Salt::NotFound => e
-        log_halt 404, "#{e}"
-      rescue => e
-        log_halt 406, "Failed to list states for #{params[:host]}: #{e}"
+      get '/environments/:environment' do
+        content_type :json
+        begin
+          Proxy::Salt.states_list params[:environment]
+        rescue Proxy::Salt::NotFound => e
+          log_halt 404, e.to_s
+        rescue Exception => e
+          log_halt 406, "Failed to list states for #{params[:host]}: #{e}"
+        end
       end
-    end
 
-    post '/highstate/:host' do
-      content_type :json
-      begin
-        log_halt 500, "Failed salt run for #{params[:host]}: Check Log files" unless (result = Proxy::Salt.highstate(params[:host]))
-        result
-      rescue => e
-        log_halt 406, "Failed salt run for #{params[:host]}: #{e}"
+      post '/highstate/:host' do
+        content_type :json
+        begin
+          log_halt 500, "Failed salt run for #{params[:host]}: Check Log files" unless (result = Proxy::Salt.highstate(params[:host]))
+          result
+        rescue Exception => e
+          log_halt 406, "Failed salt run for #{params[:host]}: #{e}"
+        end
       end
-    end
 
-    delete '/key/:host' do
-      content_type :json
-      begin
-        Proxy::Salt.key_delete(params[:host])
-      rescue => e
-        log_halt 406, "Failed delete salt key for #{params[:host]}: #{e}"
+      delete '/key/:host' do
+        content_type :json
+        begin
+          Proxy::Salt.key_delete(params[:host])
+        rescue Exception => e
+          log_halt 406, "Failed delete salt key for #{params[:host]}: #{e}"
+        end
       end
-    end
 
-    post '/key/:host' do
-      content_type :json
-      begin
-        Proxy::Salt::key_accept(params[:host])
-      rescue => e
-        log_halt 406, "Failed to accept salt key for #{params[:host]}: #{e}"
+      post '/key/:host' do
+        content_type :json
+        begin
+          Proxy::Salt.key_accept(params[:host])
+        rescue Exception => e
+          log_halt 406, "Failed to accept salt key for #{params[:host]}: #{e}"
+        end
       end
-    end
 
-    delete '/key/reject/:host' do
-      content_type :json
-      begin
-        Proxy::Salt::key_reject(params[:host])
-      rescue => e
-        log_halt 406, "Failed to reject salt key for #{params[:host]}: #{e}"
+      delete '/key/reject/:host' do
+        content_type :json
+        begin
+          Proxy::Salt.key_reject(params[:host])
+        rescue Exception => e
+          log_halt 406, "Failed to reject salt key for #{params[:host]}: #{e}"
+        end
       end
-    end
 
-    get '/key' do
-      content_type :json
-      begin
-        Proxy::Salt::key_list.to_json
-      rescue => e
-        log_halt 406, "Failed to list keys: #{e}"
+      get '/key' do
+        content_type :json
+        begin
+          Proxy::Salt.key_list.to_json
+        rescue Exception => e
+          log_halt 406, "Failed to list keys: #{e}"
+        end
       end
     end
   end

data/lib/smart_proxy_salt/salt_http_config.ru

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'smart_proxy_salt/salt_api'
 map '/salt' do
   run Proxy::Salt::Api

data/lib/smart_proxy_salt/version.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 module Proxy
+  # Salt module
   module Salt
-    VERSION = '2.1.9'
+    VERSION = '3.0.0'
   end
 end

data/lib/smart_proxy_salt.rb

@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 require 'smart_proxy_salt/version'
 require 'smart_proxy_salt/salt'

data/lib/smart_proxy_salt_core/salt_runner.rb

@@ -0,0 +1,51 @@
+require 'foreman_tasks_core/runner/command_runner'
+
+module SmartProxySaltCore
+  class SaltRunner < ForemanTasksCore::Runner::CommandRunner
+    DEFAULT_REFRESH_INTERVAL = 1
+
+    attr_reader :jid
+
+    def initialize(options, suspended_action:)
+      super(options, :suspended_action => suspended_action)
+      @options = options
+    end
+
+    def start
+      command = generate_command
+      logger.debug("Running command '#{command.join(' ')}'")
+      initialize_command(*command)
+    end
+
+    def kill
+      publish_data('== TASK ABORTED BY USER ==', 'stdout')
+      publish_exit_status(1)
+      ::Process.kill('SIGTERM', @command_pid)
+    end
+
+    def publish_data(data, type)
+      if @jid.nil? && (match = data.match(/jid: ([0-9]+)/))
+        @jid = match[1]
+      end
+      super
+    end
+
+    def publish_exit_status(status)
+      # If there was no salt job associated with this run, mark the job as failed
+      status = 1 if @jid.nil?
+      super status
+    end
+
+    private
+
+    def generate_command
+      saltfile_path = SmartProxySaltCore.settings[:saltfile]
+      command = %w(salt --show-jid)
+      command << "--saltfile=#{saltfile_path}" if File.file?(saltfile_path)
+      command << @options['name']
+      command << 'state.template_str'
+      command << @options['script']
+      command
+    end
+  end
+end

data/lib/smart_proxy_salt_core/salt_task_launcher.rb

@@ -0,0 +1,21 @@
+module SmartProxySaltCore
+  class SaltTaskLauncher < ForemanTasksCore::TaskLauncher::Batch
+    class SaltRunnerAction < ForemanTasksCore::Runner::Action
+      def initiate_runner
+        additional_options = {
+          :step_id => run_step_id,
+          :uuid => execution_plan_id
+        }
+        ::SmartProxySaltCore::SaltRunner.new(
+          input.merge(additional_options),
+          :suspended_action => suspended_action
+        )
+      end
+    end
+
+    def child_launcher(parent)
+      ForemanTasksCore::TaskLauncher::Single.new(world, callback, :parent => parent,
+        :action_class_override => SaltRunnerAction)
+    end
+  end
+end

data/lib/smart_proxy_salt_core/version.rb

@@ -0,0 +1,3 @@
+module SmartProxySaltCore
+  VERSION = '0.0.1'.freeze
+end

data/lib/smart_proxy_salt_core.rb

@@ -0,0 +1,17 @@
+require 'foreman_tasks_core'
+require 'foreman_remote_execution_core'
+
+module SmartProxySaltCore
+  extend ForemanTasksCore::SettingsLoader
+  register_settings(:salt,
+                    :saltfile => '/etc/foreman-proxy/settings.d/salt.saltfile')
+
+  if ForemanTasksCore.dynflow_present?
+    require 'smart_proxy_salt_core/salt_runner'
+    require 'smart_proxy_salt_core/salt_task_launcher'
+
+    if defined?(SmartProxyDynflowCore)
+      SmartProxyDynflowCore::TaskLauncherRegistry.register('salt', SaltTaskLauncher)
+    end
+  end
+end

data/settings.d/salt.saltfile.example

@@ -0,0 +1,3 @@
+salt:
+  log_file: /var/log/foreman-proxy/salt.log
+  log_level_logfile: debug

data/settings.d/salt.yml.example

@@ -9,3 +9,4 @@
 :api_auth: pam
 :api_username: saltuser
 :api_password: password
+# :saltfile: '/etc/foreman-proxy/settings.d/salt.saltfile'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: smart_proxy_salt
 version: !ruby/object:Gem::Version
-  version: 2.1.9
+  version: 3.0.0
 platform: ruby
 authors:
 - Michael Moll
@@ -9,8 +9,148 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-06 00:00:00.000000000 Z
-dependencies: []
+date: 2019-08-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  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
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  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: 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: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.32.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.32.1
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
 description: SaltStack Plug-In for Foreman's Smart Proxy
 email: foreman-dev@googlegroups.com
 executables:
@@ -34,11 +174,16 @@ files:
 - lib/smart_proxy_salt/salt_api.rb
 - lib/smart_proxy_salt/salt_http_config.ru
 - lib/smart_proxy_salt/version.rb
+- lib/smart_proxy_salt_core.rb
+- lib/smart_proxy_salt_core/salt_runner.rb
+- lib/smart_proxy_salt_core/salt_task_launcher.rb
+- lib/smart_proxy_salt_core/version.rb
 - sbin/upload-salt-reports
+- settings.d/salt.saltfile.example
 - settings.d/salt.yml.example
 homepage: https://github.com/theforeman/smart_proxy_salt
 licenses:
-- GPLv3
+- GPL-3.0
 metadata: {}
 post_install_message: 
 rdoc_options: []