mixlib-shellout 2.2.7-universal-mingw32 → 2.3.0-universal-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fb04212922b107765ee2b1cca2075e89839e81aa
-  data.tar.gz: f288d3d4b96149359fa173f6eb4be591b9870e76
+  metadata.gz: a40ea886f43696d31f832a9c84c6d71a381e3657
+  data.tar.gz: ca25e83f24eed9d3271baf9c2e9c79c831a21781
 SHA512:
-  metadata.gz: 59f1799bed35a86f297121daf7f45d5f45241dafeb15db758265f14564e09dd66de3331f0a7f95535663d4d5b7a266f5638ce32be6767fbed1e83fea84360132
-  data.tar.gz: d112373309d2f7ccc90c5077c4b56900abe27891ca767ba7cef4bc67831c14163babdc730b7db8b8acca6e223bf78e8377757a124e4dc5ce762fdcc33c8fb22a
+  metadata.gz: 185e8d0875b6670c9b85c653262c0f9a082bd47cf0fd455c14a90210e45b229d352cd5b30449d0b4b3a25c6fccd310ca8751d2acb0d7734c6da728a0c9f0d32b
+  data.tar.gz: 998acc35a68b4953a162495d1ed24229b1e361c918b25a255527d9564d269980e52e5eacc1b4999f7d73ab6e9332f5115386c9cff3a702f845f69a109772b7a5

data/Gemfile

@@ -1,15 +1,15 @@
-source 'https://rubygems.org'
+source "https://rubygems.org"
 
 gemspec :name => "mixlib-shellout"
 
 group(:test) do
   gem "rspec_junit_formatter"
-  gem 'rake'
+  gem "rake"
 end
 
 group(:development) do
-  gem 'pry'
-  gem 'pry-byebug'
-  gem 'pry-stack_explorer'
-  gem 'rb-readline'
+  gem "pry"
+  gem "pry-byebug"
+  gem "pry-stack_explorer"
+  gem "rb-readline"
 end

data/README.md

@@ -65,9 +65,13 @@ Invoke "whoami.exe" to demonstrate running a command as another user:
 Mixlib::ShellOut does a standard fork/exec on Unix, and uses the Win32 API on Windows. There is not currently support for JRuby.
 
 ## See Also
-- `Process.spawn` in Ruby 1.9
+- `Process.spawn` in Ruby 1.9+
 - [https://github.com/rtomayko/posix-spawn](https://github.com/rtomayko/posix-spawn)
 
+## Contributing
+
+For information on contributing to this project see <https://github.com/chef/chef/blob/master/CONTRIBUTING.md>
+
 ## License
 - Copyright:: Copyright (c) 2011-2016 Chef Software, Inc.
 - License:: Apache License, Version 2.0

data/Rakefile

@@ -1,24 +1,16 @@
-require 'rspec/core/rake_task'
-require 'rubygems/package_task'
-require 'mixlib/shellout/version'
+require "bundler"
+require "rspec/core/rake_task"
 
-Dir[File.expand_path("../*gemspec", __FILE__)].reverse.each do |gemspec_path|
-  gemspec = eval(IO.read(gemspec_path))
-  Gem::PackageTask.new(gemspec).define
-end
+Bundler::GemHelper.install_tasks name: "mixlib-shellout"
+
+require "chefstyle"
+require "rubocop/rake_task"
+desc "Run Ruby style checks"
+RuboCop::RakeTask.new(:style)
 
 desc "Run all specs in spec directory"
 RSpec::Core::RakeTask.new(:spec) do |t|
-  t.pattern = FileList['spec/**/*_spec.rb']
-end
-
-desc "Build it and ship it"
-task ship: [:clobber_package, :gem] do
-#  sh("git tag #{Mixlib::ShellOut::VERSION}")
-  sh("git push opscode --tags")
-  Dir[File.expand_path("../pkg/*.gem", __FILE__)].reverse.each do |built_gem|
-    sh("gem push #{built_gem}")
-  end
+  t.pattern = FileList["spec/**/*_spec.rb"]
 end
 
-task default: :spec
+task default: [:spec, :style]

data/lib/mixlib/shellout.rb

@@ -16,10 +16,10 @@
 # limitations under the License.
 #
 
-require 'etc'
-require 'tmpdir'
-require 'fcntl'
-require 'mixlib/shellout/exceptions'
+require "etc"
+require "tmpdir"
+require "fcntl"
+require "mixlib/shellout/exceptions"
 
 module Mixlib
 
@@ -29,10 +29,10 @@ module Mixlib
     DEFAULT_READ_TIMEOUT = 600
 
     if RUBY_PLATFORM =~ /mswin|mingw32|windows/
-      require 'mixlib/shellout/windows'
+      require "mixlib/shellout/windows"
       include ShellOut::Windows
     else
-      require 'mixlib/shellout/unix'
+      require "mixlib/shellout/unix"
       include ShellOut::Unix
     end
 
@@ -109,6 +109,9 @@ module Mixlib
 
     attr_reader :stdin_pipe, :stdout_pipe, :stderr_pipe, :process_status_pipe
 
+    # Runs windows process with elevated privileges. Required for Powershell commands which need elevated privileges
+    attr_accessor :elevated
+
     # === Arguments:
     # Takes a single command, or a list of command fragments. These are used
     # as arguments to Kernel.exec. See the Kernel.exec documentation for more
@@ -133,7 +136,7 @@ module Mixlib
     # * +timeout+: a Numeric value for the number of seconds to wait on the
     #   child process before raising an Exception. This is calculated as the
     #   total amount of time that ShellOut waited on the child process without
-    #   receiving any output (i.e., IO.select returned nil). Default is 60
+    #   receiving any output (i.e., IO.select returned nil). Default is 600
     #   seconds. Note: the stdlib Timeout library is not used.
     # * +input+: A String of data to be passed to the subcommand. This is
     #   written to the child process' stdin stream before the process is
@@ -162,7 +165,7 @@ module Mixlib
     #   cmd = Mixlib::ShellOut.new("apachectl", "start", :user => 'www', :env => nil, :cwd => '/tmp')
     #   cmd.run_command # etc.
     def initialize(*command_args)
-      @stdout, @stderr, @process_status = '', '', ''
+      @stdout, @stderr, @process_status = "", "", ""
       @live_stdout = @live_stderr = nil
       @input = nil
       @log_level = :debug
@@ -172,6 +175,7 @@ module Mixlib
       @valid_exit_codes = [0]
       @terminate_reason = nil
       @timeout = nil
+      @elevated = false
 
       if command_args.last.is_a?(Hash)
         parse_options(command_args.pop)
@@ -212,7 +216,7 @@ module Mixlib
     def gid
       return group.kind_of?(Integer) ? group : Etc.getgrnam(group.to_s).gid if group
       return Etc.getpwuid(uid).gid if using_login?
-      return nil
+      nil
     end
 
     def timeout
@@ -253,7 +257,7 @@ module Mixlib
     #   within +timeout+ seconds (default: 600s)
     def run_command
       if logger
-        log_message = (log_tag.nil? ? "" : "#@log_tag ") << "sh(#@command)"
+        log_message = (log_tag.nil? ? "" : "#{@log_tag} ") << "sh(#{@command})"
         logger.send(log_level, log_message)
       end
       super
@@ -284,15 +288,15 @@ module Mixlib
     # is highly encouraged.
     # === Raises
     # ShellCommandFailed  always
-    def invalid!(msg=nil)
+    def invalid!(msg = nil)
       msg ||= "Command produced unexpected results"
       raise ShellCommandFailed, msg + "\n" + format_for_exception
     end
 
     def inspect
-      "<#{self.class.name}##{object_id}: command: '#@command' process_status: #{@status.inspect} " +
-      "stdout: '#{stdout.strip}' stderr: '#{stderr.strip}' child_pid: #{@child_pid.inspect} " +
-      "environment: #{@environment.inspect} timeout: #{timeout} user: #@user group: #@group working_dir: #@cwd >"
+      "<#{self.class.name}##{object_id}: command: '#{@command}' process_status: #{@status.inspect} " +
+        "stdout: '#{stdout.strip}' stderr: '#{stderr.strip}' child_pid: #{@child_pid.inspect} " +
+        "environment: #{@environment.inspect} timeout: #{timeout} user: #{@user} group: #{@group} working_dir: #{@cwd} >"
     end
 
     private
@@ -300,45 +304,47 @@ module Mixlib
     def parse_options(opts)
       opts.each do |option, setting|
         case option.to_s
-        when 'cwd'
+        when "cwd"
           self.cwd = setting
-        when 'domain'
+        when "domain"
           self.domain = setting
-        when 'password'
+        when "password"
           self.password = setting
-        when 'user'
+        when "user"
           self.user = setting
           self.with_logon = setting
-        when 'group'
+        when "group"
           self.group = setting
-        when 'umask'
+        when "umask"
           self.umask = setting
-        when 'timeout'
+        when "timeout"
           self.timeout = setting
-        when 'returns'
+        when "returns"
           self.valid_exit_codes = Array(setting)
-        when 'live_stream'
+        when "live_stream"
           self.live_stdout = self.live_stderr = setting
-        when 'live_stdout'
+        when "live_stdout"
           self.live_stdout = setting
-        when 'live_stderr'
+        when "live_stderr"
           self.live_stderr = setting
-        when 'input'
+        when "input"
           self.input = setting
-        when 'logger'
+        when "logger"
           self.logger = setting
-        when 'log_level'
+        when "log_level"
           self.log_level = setting
-        when 'log_tag'
+        when "log_tag"
           self.log_tag = setting
-        when 'environment', 'env'
+        when "environment", "env"
           if setting
-            self.environment = Hash[setting.map{|(k,v)| [k.to_s,v]}]
+            self.environment = Hash[setting.map { |(k, v)| [k.to_s, v] }]
           else
             self.environment = {}
           end
-        when 'login'
+        when "login"
           self.login = setting
+        when "elevated"
+          self.elevated = setting
         else
           raise InvalidCommandOption, "option '#{option.inspect}' is not a valid option for #{self.class.name}"
         end

data/lib/mixlib/shellout/exceptions.rb

@@ -1,7 +1,9 @@
 module Mixlib
   class ShellOut
-    class ShellCommandFailed < RuntimeError; end
-    class CommandTimeout < RuntimeError; end
-    class InvalidCommandOption < RuntimeError; end
+    class Error < RuntimeError; end
+    class ShellCommandFailed < Error; end
+    class CommandTimeout < Error; end
+    class InvalidCommandOption < Error; end
+    class EmptyWindowsCommand < Error; end
   end
 end

data/lib/mixlib/shellout/unix.rb

@@ -27,23 +27,25 @@ module Mixlib
 
       # Option validation that is unix specific
       def validate_options(opts)
-        # No options to validate, raise exceptions here if needed
+        if opts[:elevated]
+          raise InvalidCommandOption, "Option `elevated` is supported for Powershell commands only"
+        end
       end
 
       # Whether we're simulating a login shell
       def using_login?
-        return login && user
+        login && user
       end
 
       # Helper method for sgids
       def all_seconderies
         ret = []
         Etc.endgrent
-        while ( g = Etc.getgrent ) do
+        while ( g = Etc.getgrent )
           ret << g
         end
         Etc.endgrent
-        return ret
+        ret
       end
 
       # The secondary groups that the subprocess will switch to.
@@ -52,7 +54,7 @@ module Mixlib
       def sgids
         return nil unless using_login?
         user_name = Etc.getpwuid(uid).name
-        all_seconderies.select{|g| g.mem.include?(user_name)}.map{|g|g.gid}
+        all_seconderies.select { |g| g.mem.include?(user_name) }.map { |g| g.gid }
       end
 
       # The environment variables that are deduced from simulating logon
@@ -63,12 +65,12 @@ module Mixlib
         # According to `man su`, the set fields are:
         #  $HOME, $SHELL, $USER, $LOGNAME, $PATH, and $IFS
         # Values are copied from "shadow" package in Ubuntu 14.10
-        {'HOME'=>entry.dir, 'SHELL'=>entry.shell, 'USER'=>entry.name, 'LOGNAME'=>entry.name, 'PATH'=>'/sbin:/bin:/usr/sbin:/usr/bin', 'IFS'=>"\t\n"}
+        { "HOME" => entry.dir, "SHELL" => entry.shell, "USER" => entry.name, "LOGNAME" => entry.name, "PATH" => "/sbin:/bin:/usr/sbin:/usr/bin", "IFS" => "\t\n" }
       end
 
       # Merges the two environments for the process
       def process_environment
-        logon_environment.merge(self.environment)
+        logon_environment.merge(environment)
       end
 
       # Run the command, writing the command's standard out and standard error
@@ -170,7 +172,7 @@ module Mixlib
 
       def set_environment
         # user-set variables should override the login ones
-        process_environment.each do |env_var,value|
+        process_environment.each do |env_var, value|
           ENV[env_var] = value
         end
       end
@@ -335,14 +337,14 @@ module Mixlib
           set_cwd
 
           begin
-            command.kind_of?(Array) ? exec(*command, :close_others=>true) : exec(command, :close_others=>true)
+            command.kind_of?(Array) ? exec(*command, :close_others => true) : exec(command, :close_others => true)
 
-            raise 'forty-two' # Should never get here
+            raise "forty-two" # Should never get here
           rescue Exception => e
             Marshal.dump(e, process_status_pipe.last)
             process_status_pipe.last.flush
           end
-          process_status_pipe.last.close unless (process_status_pipe.last.closed?)
+          process_status_pipe.last.close unless process_status_pipe.last.closed?
           exit!
         end
       end
@@ -351,16 +353,14 @@ module Mixlib
       # If it's there, un-marshal it and raise. If it's not there,
       # assume everything went well.
       def propagate_pre_exec_failure
-        begin
-          attempt_buffer_read until child_process_status.eof?
-          e = Marshal.load(@process_status)
-          raise(Exception === e ? e : "unknown failure: #{e.inspect}")
-        rescue ArgumentError # If we get an ArgumentError error, then the exec was successful
-          true
-        ensure
-          child_process_status.close
-          open_pipes.delete(child_process_status)
-        end
+        attempt_buffer_read until child_process_status.eof?
+        e = Marshal.load(@process_status)
+        raise(Exception === e ? e : "unknown failure: #{e.inspect}")
+      rescue ArgumentError # If we get an ArgumentError error, then the exec was successful
+        true
+      ensure
+        child_process_status.close
+        open_pipes.delete(child_process_status)
       end
 
       def reap_errant_child

data/lib/mixlib/shellout/version.rb

@@ -1,5 +1,5 @@
 module Mixlib
   class ShellOut
-    VERSION = "2.2.7"
+    VERSION = "2.3.0"
   end
 end

data/lib/mixlib/shellout/windows.rb

@@ -18,8 +18,8 @@
 # limitations under the License.
 #
 
-require 'win32/process'
-require 'mixlib/shellout/windows/core_ext'
+require "win32/process"
+require "mixlib/shellout/windows/core_ext"
 
 module Mixlib
   class ShellOut
@@ -32,10 +32,12 @@ module Mixlib
 
       # Option validation that is windows specific
       def validate_options(opts)
-        if opts[:user]
-          unless opts[:password]
-            raise InvalidCommandOption, "You must supply both a username and password when supplying a user in windows"
-          end
+        if opts[:user] && !opts[:password]
+          raise InvalidCommandOption, "You must supply a password when supplying a user in windows"
+        end
+
+        if opts[:elevated] && opts[:elevated] != true && opts[:elevated] != false
+          raise InvalidCommandOption, "Invalid value passed for `elevated`. Please provide true/false."
         end
       end
 
@@ -56,29 +58,30 @@ module Mixlib
           #
           # Set cwd, environment, appname, etc.
           #
-          app_name, command_line = command_to_run(self.command)
+          app_name, command_line = command_to_run(command)
           create_process_args = {
             :app_name => app_name,
             :command_line => command_line,
             :startup_info => {
               :stdout => stdout_write,
               :stderr => stderr_write,
-              :stdin => stdin_read
+              :stdin => stdin_read,
             },
-            :environment => inherit_environment.map { |k,v| "#{k}=#{v}" },
-            :close_handles => false
+            :environment => inherit_environment.map { |k, v| "#{k}=#{v}" },
+            :close_handles => false,
           }
           create_process_args[:cwd] = cwd if cwd
           # default to local account database if domain is not specified
           create_process_args[:domain] = domain.nil? ? "." : domain
           create_process_args[:with_logon] = with_logon if with_logon
           create_process_args[:password] = password if password
+          create_process_args[:elevated] = elevated if elevated
 
           #
           # Start the process
           #
           process = Process.create(create_process_args)
-          logger.debug(Utils.format_process(process, app_name, command_line, timeout)) if logger
+          logger.debug(format_process(process, app_name, command_line, timeout)) if logger
           begin
             # Start pushing data into input
             stdin_write << input if input
@@ -90,26 +93,26 @@ module Mixlib
             # Wait for the process to finish, consuming output as we go
             #
             start_wait = Time.now
-            while true
+            loop do
               wait_status = WaitForSingleObject(process.process_handle, 0)
               case wait_status
               when WAIT_OBJECT_0
                 # Get process exit code
-                exit_code = [0].pack('l')
+                exit_code = [0].pack("l")
                 unless GetExitCodeProcess(process.process_handle, exit_code)
                   raise get_last_error
                 end
                 @status = ThingThatLooksSortOfLikeAProcessStatus.new
-                @status.exitstatus = exit_code.unpack('l').first
+                @status.exitstatus = exit_code.unpack("l").first
 
                 return self
               when WAIT_TIMEOUT
                 # Kill the process
                 if (Time.now - start_wait) > timeout
                   begin
-                    require 'wmi-lite/wmi'
+                    require "wmi-lite/wmi"
                     wmi = WmiLite::Wmi.new
-                    Utils.kill_process_tree(process.process_id, wmi, logger)
+                    kill_process_tree(process.process_id, wmi, logger)
                     Process.kill(:KILL, process.process_id)
                   rescue Errno::EIO, SystemCallError
                     logger.warn("Failed to kill timed out process #{process.process_id}") if logger
@@ -118,13 +121,13 @@ module Mixlib
                   raise Mixlib::ShellOut::CommandTimeout, [
                     "command timed out:",
                     format_for_exception,
-                    Utils.format_process(process, app_name, command_line, timeout)
+                    format_process(process, app_name, command_line, timeout),
                   ].join("\n")
                 end
 
                 consume_output(open_streams, stdout_read, stderr_read)
               else
-                raise "Unknown response from WaitForSingleObject(#{process.process_handle}, #{timeout*1000}): #{wait_status}"
+                raise "Unknown response from WaitForSingleObject(#{process.process_handle}, #{timeout * 1000}): #{wait_status}"
               end
 
             end
@@ -146,8 +149,6 @@ module Mixlib
         end
       end
 
-      private
-
       class ThingThatLooksSortOfLikeAProcessStatus
         attr_accessor :exitstatus
         def success?
@@ -155,6 +156,8 @@ module Mixlib
         end
       end
 
+      private
+
       def consume_output(open_streams, stdout_read, stderr_read)
         return false if open_streams.length == 0
         ready = IO.select(open_streams, nil, nil, READ_WAIT_TIME)
@@ -182,65 +185,59 @@ module Mixlib
           end
         end
 
-        return true
+        true
       end
 
-      IS_BATCH_FILE = /\.bat"?$|\.cmd"?$/i
-
       def command_to_run(command)
-        return _run_under_cmd(command) if Utils.should_run_under_cmd?(command)
+        return run_under_cmd(command) if should_run_under_cmd?(command)
 
         candidate = candidate_executable_for_command(command)
 
-        # Don't do searching for empty commands.  Let it fail when it runs.
-        return [ nil, command ] if candidate.length == 0
+        if candidate.length == 0
+          raise Mixlib::ShellOut::EmptyWindowsCommand, "could not parse script/executable out of command: `#{command}`"
+        end
 
         # Check if the exe exists directly.  Otherwise, search PATH.
-        exe = Utils.find_executable(candidate)
-        exe = Utils.which(unquoted_executable_path(command)) if exe.nil? && exe !~ /[\\\/]/
-
-        # Batch files MUST use cmd; and if we couldn't find the command we're looking for,
-        # we assume it must be a cmd builtin.
-        if exe.nil? || exe =~ IS_BATCH_FILE
-          _run_under_cmd(command)
+        exe = which(candidate)
+        if exe_needs_cmd?(exe)
+          run_under_cmd(command)
         else
-          _run_directly(command, exe)
+          [ exe, command ]
         end
       end
 
+      # Batch files MUST use cmd; and if we couldn't find the command we're looking for,
+      # we assume it must be a cmd builtin.
+      def exe_needs_cmd?(exe)
+        !exe || exe =~ /\.bat"?$|\.cmd"?$/i
+      end
+
       # cmd does not parse multiple quotes well unless the whole thing is wrapped up in quotes.
       # https://github.com/opscode/mixlib-shellout/pull/2#issuecomment-4837859
       # http://ss64.com/nt/syntax-esc.html
-      def _run_under_cmd(command)
-        [ ENV['COMSPEC'], "cmd /c \"#{command}\"" ]
-      end
-
-      def _run_directly(command, exe)
-        [ exe, command ]
-      end
-
-      def unquoted_executable_path(command)
-        command[0,command.index(/\s/) || command.length]
+      def run_under_cmd(command)
+        [ ENV["COMSPEC"], "cmd /c \"#{command}\"" ]
       end
 
+      # FIXME: this extracts ARGV[0] but is it correct?
       def candidate_executable_for_command(command)
         if command =~ /^\s*"(.*?)"/
           # If we have quotes, do an exact match
           $1
         else
           # Otherwise check everything up to the first space
-          unquoted_executable_path(command).strip
+          command[0, command.index(/\s/) || command.length].strip
         end
       end
 
       def inherit_environment
         result = {}
-        ENV.each_pair do |k,v|
+        ENV.each_pair do |k, v|
           result[k] = v
         end
 
-        environment.each_pair do |k,v|
-          if v == nil
+        environment.each_pair do |k, v|
+          if v.nil?
             result.delete(k)
           else
             result[k] = v
@@ -249,134 +246,134 @@ module Mixlib
         result
       end
 
-      module Utils
-        # api: semi-private
-        # If there are special characters parsable by cmd.exe (such as file redirection), then
-        # this method should return true.
-        #
-        # This parser is based on
-        # https://github.com/ruby/ruby/blob/9073db5cb1d3173aff62be5b48d00f0fb2890991/win32/win32.c#L1437
-        def self.should_run_under_cmd?(command)
-          return true if command =~ /^@/
-
-          quote = nil
-          env = false
-          env_first_char = false
-
-          command.dup.each_char do |c|
-            case c
-            when "'", '"'
-              if (!quote)
-                quote = c
-              elsif quote == c
-                quote = nil
-              end
-              next
-            when '>', '<', '|', '&', "\n"
-              return true unless quote
-            when '%'
-              return true if env
-              env = env_first_char = true
-              next
-            else
-              next unless env
-              if env_first_char
-                env_first_char = false
-                env = false and next if c !~ /[A-Za-z_]/
-              end
-              env = false if c !~ /[A-Za-z1-9_]/
+      # api: semi-private
+      # If there are special characters parsable by cmd.exe (such as file redirection), then
+      # this method should return true.
+      #
+      # This parser is based on
+      # https://github.com/ruby/ruby/blob/9073db5cb1d3173aff62be5b48d00f0fb2890991/win32/win32.c#L1437
+      def should_run_under_cmd?(command)
+        return true if command =~ /^@/
+
+        quote = nil
+        env = false
+        env_first_char = false
+
+        command.dup.each_char do |c|
+          case c
+          when "'", '"'
+            if !quote
+              quote = c
+            elsif quote == c
+              quote = nil
             end
+            next
+          when ">", "<", "|", "&", "\n"
+            return true unless quote
+          when "%"
+            return true if env
+            env = env_first_char = true
+            next
+          else
+            next unless env
+            if env_first_char
+              env_first_char = false
+              (env = false) && next if c !~ /[A-Za-z_]/
+            end
+            env = false if c !~ /[A-Za-z1-9_]/
           end
-          return false
-        end
-
-        def self.pathext
-          @pathext ||= ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') + [''] : ['']
         end
+        false
+      end
 
-        # which() mimicks the Unix which command
-        # FIXME: it is not working
-        def self.which(cmd)
-          ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
-            exe = find_executable("#{path}/#{cmd}")
-            return exe if exe
-          end
-          return nil
+      # FIXME: reduce code duplication with chef/chef
+      def which(cmd)
+        exts = ENV["PATHEXT"] ? ENV["PATHEXT"].split(";") + [""] : [""]
+        # windows always searches '.' first
+        exts.each do |ext|
+          filename = "#{cmd}#{ext}"
+          return filename if File.executable?(filename) && !File.directory?(filename)
         end
-
-        # Windows has a different notion of what "executable" means
-        # The OS will search through valid the extensions and look
-        # for a binary there.
-        def self.find_executable(path)
-          return path if executable? path
-
-          pathext.each do |ext|
-            exe = "#{path}#{ext}"
-            return exe if executable? exe
+        # only search through the path if the Filename does not contain separators
+        if File.basename(cmd) == cmd
+          paths = ENV["PATH"].split(File::PATH_SEPARATOR)
+          paths.each do |path|
+            exts.each do |ext|
+              filename = File.join(path, "#{cmd}#{ext}")
+              return filename if File.executable?(filename) && !File.directory?(filename)
+            end
           end
-          return nil
-        end
-
-        def self.executable?(path)
-          File.executable?(path) && !File.directory?(path)
         end
+        false
+      end
 
-        def self.system_required_processes
-          [
-            'System Idle Process',
-            'System',
-            'spoolsv.exe',
-            'lsass.exe',
-            'csrss.exe',
-            'smss.exe',
-            'svchost.exe'
-          ]
-        end
+      def system_required_processes
+        [
+          "System Idle Process",
+          "System",
+          "spoolsv.exe",
+          "lsass.exe",
+          "csrss.exe",
+          "smss.exe",
+          "svchost.exe",
+        ]
+      end
 
-        def self.unsafe_process?(name, logger)
-          return false unless system_required_processes.include? name
-          logger.debug(
-            "A request to kill a critical system process - #{name} - was received and skipped."
-          )
-          true
-        end
+      def unsafe_process?(name, logger)
+        return false unless system_required_processes.include? name
+        logger.debug(
+          "A request to kill a critical system process - #{name} - was received and skipped."
+        )
+        true
+      end
 
-        # recursively kills all child processes of given pid
-        # calls itself querying for children child procs until
-        # none remain. Important that a single WmiLite instance
-        # is passed in since each creates its own WMI rpc process
-        def self.kill_process_tree(pid, wmi, logger)
-          wmi.query("select * from Win32_Process where ParentProcessID=#{pid}").each do |instance|
-            next if unsafe_process?(instance.wmi_ole_object.name, logger)
-            child_pid = instance.wmi_ole_object.processid
-            kill_process_tree(child_pid, wmi, logger)
-            kill_process(instance, logger)
-          end
+      # recursively kills all child processes of given pid
+      # calls itself querying for children child procs until
+      # none remain. Important that a single WmiLite instance
+      # is passed in since each creates its own WMI rpc process
+      def kill_process_tree(pid, wmi, logger)
+        wmi.query("select * from Win32_Process where ParentProcessID=#{pid}").each do |instance|
+          next if unsafe_process?(instance.wmi_ole_object.name, logger)
+          child_pid = instance.wmi_ole_object.processid
+          kill_process_tree(child_pid, wmi, logger)
+          kill_process(instance, logger)
         end
+      end
 
-        def self.kill_process(instance, logger)
-          child_pid = instance.wmi_ole_object.processid
+      def kill_process(instance, logger)
+        child_pid = instance.wmi_ole_object.processid
+        if logger
           logger.debug([
             "killing child process #{child_pid}::",
-            "#{instance.wmi_ole_object.Name} of parent #{pid}"
-            ].join) if logger
-          Process.kill(:KILL, instance.wmi_ole_object.processid)
-        rescue Errno::EIO, SystemCallError
+            "#{instance.wmi_ole_object.Name} of parent #{pid}",
+          ].join)
+        end
+        Process.kill(:KILL, instance.wmi_ole_object.processid)
+      rescue Errno::EIO, SystemCallError
+        if logger
           logger.debug([
             "Failed to kill child process #{child_pid}::",
-            "#{instance.wmi_ole_object.Name} of parent #{pid}"
-          ].join) if logger
+            "#{instance.wmi_ole_object.Name} of parent #{pid}",
+          ].join)
         end
+      end
+
+      def format_process(process, app_name, command_line, timeout)
+        msg = []
+        msg << "ProcessId: #{process.process_id}"
+        msg << "app_name: #{app_name}"
+        msg << "command_line: #{command_line}"
+        msg << "timeout: #{timeout}"
+        msg.join("\n")
+      end
 
-        def self.format_process(process, app_name, command_line, timeout)
-          msg = []
-          msg << "ProcessId: #{process.process_id}"
-          msg << "app_name: #{app_name}"
-          msg << "command_line: #{command_line}"
-          msg << "timeout: #{timeout}"
-          msg.join("\n")
+      # DEPRECATED do not use
+      class Utils
+        include Mixlib::ShellOut::Windows
+        def self.should_run_under_cmd?(cmd)
+          Mixlib::ShellOut::Windows::Utils.new.send(:should_run_under_cmd?, cmd)
         end
       end
-    end # class
+    end
   end
 end