chef 12.18.31 → 13.0.118

data/lib/chef/mixin/command/unix.rb

@@ -1,220 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@chef.io>)
-# Copyright:: Copyright 2008-2016, Chef Software Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-class Chef
-  module Mixin
-    module Command
-      module Unix
-        # This is taken directly from Ara T Howard's Open4 library, and then
-        # modified to suit the needs of Chef.  Any bugs here are most likely
-        # my own, and not Ara's.
-        #
-        # The original appears in external/open4.rb in its unmodified form.
-        #
-        # Thanks Ara!
-        def popen4(cmd, args = {}, &b)
-          # Ruby 1.8 suffers from intermittent segfaults believed to be due to GC while IO.select
-          # See CHEF-2916 / CHEF-1305
-          GC.disable
-
-          # Waitlast - this is magic.
-          #
-          # Do we wait for the child process to die before we yield
-          # to the block, or after?  That is the magic of waitlast.
-          #
-          # By default, we are waiting before we yield the block.
-          args[:waitlast] ||= false
-
-          args[:user] ||= nil
-          unless args[:user].kind_of?(Integer)
-            args[:user] = Etc.getpwnam(args[:user]).uid if args[:user]
-          end
-          args[:group] ||= nil
-          unless args[:group].kind_of?(Integer)
-            args[:group] = Etc.getgrnam(args[:group]).gid if args[:group]
-          end
-          args[:environment] ||= {}
-
-          # Default on C locale so parsing commands output can be done
-          # independently of the node's default locale.
-          # "LC_ALL" could be set to nil, in which case we also must ignore it.
-          unless args[:environment].has_key?("LC_ALL")
-            args[:environment]["LC_ALL"] = "C"
-          end
-
-          pw, pr, pe, ps = IO.pipe, IO.pipe, IO.pipe, IO.pipe
-
-          verbose = $VERBOSE
-          begin
-            $VERBOSE = nil
-            ps.last.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
-
-            cid = fork do
-              pw.last.close
-              STDIN.reopen pw.first
-              pw.first.close
-
-              pr.first.close
-              STDOUT.reopen pr.last
-              pr.last.close
-
-              pe.first.close
-              STDERR.reopen pe.last
-              pe.last.close
-
-              STDOUT.sync = STDERR.sync = true
-
-              if args[:group]
-                Process.egid = args[:group]
-                Process.gid = args[:group]
-              end
-
-              if args[:user]
-                Process.euid = args[:user]
-                Process.uid = args[:user]
-              end
-
-              args[:environment].each do |key, value|
-                ENV[key] = value
-              end
-
-              if args[:umask]
-                umask = ((args[:umask].respond_to?(:oct) ? args[:umask].oct : args[:umask].to_i) & 007777)
-                File.umask(umask)
-              end
-
-              begin
-                if cmd.kind_of?(Array)
-                  Kernel.exec(*cmd)
-                else
-                  Kernel.exec(cmd)
-                end
-                raise "forty-two"
-              rescue Exception => e
-                Marshal.dump(e, ps.last)
-                ps.last.flush
-              end
-              ps.last.close unless ps.last.closed?
-              exit!
-            end
-          ensure
-            $VERBOSE = verbose
-          end
-
-          [pw.first, pr.last, pe.last, ps.last].each { |fd| fd.close }
-
-          begin
-            e = Marshal.load ps.first
-            raise(Exception === e ? e : "unknown failure!")
-          rescue EOFError # If we get an EOF error, then the exec was successful
-            42
-          ensure
-            ps.first.close
-          end
-
-          pw.last.sync = true
-
-          pi = [pw.last, pr.first, pe.first]
-
-          if b
-            begin
-              if args[:waitlast]
-                b[cid, *pi]
-                # send EOF so that if the child process is reading from STDIN
-                # it will actually finish up and exit
-                pi[0].close_write
-                Process.waitpid2(cid).last
-              else
-                # This took some doing.
-                # The trick here is to close STDIN
-                # Then set our end of the childs pipes to be O_NONBLOCK
-                # Then wait for the child to die, which means any IO it
-                # wants to do must be done - it's dead.  If it isn't,
-                # it's because something totally skanky is happening,
-                # and we don't care.
-                o = StringIO.new
-                e = StringIO.new
-
-                pi[0].close
-
-                stdout = pi[1]
-                stderr = pi[2]
-
-                stdout.sync = true
-                stderr.sync = true
-
-                stdout.fcntl(Fcntl::F_SETFL, pi[1].fcntl(Fcntl::F_GETFL) | Fcntl::O_NONBLOCK)
-                stderr.fcntl(Fcntl::F_SETFL, pi[2].fcntl(Fcntl::F_GETFL) | Fcntl::O_NONBLOCK)
-
-                stdout_finished = false
-                stderr_finished = false
-
-                results = nil
-
-                while !stdout_finished || !stderr_finished
-                  begin
-                    channels_to_watch = []
-                    channels_to_watch << stdout if !stdout_finished
-                    channels_to_watch << stderr if !stderr_finished
-                    ready = IO.select(channels_to_watch, nil, nil, 1.0)
-                  rescue Errno::EAGAIN
-                  ensure
-                    results = Process.waitpid2(cid, Process::WNOHANG)
-                    if results
-                      stdout_finished = true
-                      stderr_finished = true
-                    end
-                  end
-
-                  if ready && ready.first.include?(stdout)
-                    line = results ? stdout.gets(nil) : stdout.gets
-                    if line
-                      o.write(line)
-                    else
-                      stdout_finished = true
-                    end
-                  end
-                  if ready && ready.first.include?(stderr)
-                    line = results ? stderr.gets(nil) : stderr.gets
-                    if line
-                      e.write(line)
-                    else
-                      stderr_finished = true
-                    end
-                  end
-                end
-                results = Process.waitpid2(cid) unless results
-                o.rewind
-                e.rewind
-                b[cid, pi[0], o, e]
-                results.last
-              end
-            ensure
-              pi.each { |fd| fd.close unless fd.closed? }
-            end
-          else
-            [cid, pw.last, pr.first, pe.first]
-          end
-        ensure
-          GC.enable
-        end
-
-      end
-    end
-  end
-end

data/lib/chef/mixin/command/windows.rb

@@ -1,71 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@chef.io>)
-# Copyright:: Copyright 2008-2016, Chef Software Inc.
-# Author:: Doug MacEachern (<dougm@vmware.com>)
-# Copyright:: Copyright 2010-2016, VMware, Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require "open3"
-
-class Chef
-  module Mixin
-    module Command
-      module Windows
-        def popen4(cmd, args = {}, &b)
-          # By default, we are waiting before we yield the block.
-          args[:waitlast] ||= false
-
-          #XXX :user, :group, :environment support?
-
-          Open3.popen3(cmd) do |stdin, stdout, stderr, cid|
-            if b
-              if args[:waitlast]
-                b[cid, stdin, stdout, stderr]
-                # send EOF so that if the child process is reading from STDIN
-                # it will actually finish up and exit
-                stdin.close_write
-              else
-                o = StringIO.new
-                e = StringIO.new
-
-                stdin.close
-
-                stdout.sync = true
-                stderr.sync = true
-
-                line = stdout.gets(nil)
-                if line
-                  o.write(line)
-                end
-                line = stderr.gets(nil)
-                if line
-                  e.write(line)
-                end
-                o.rewind
-                e.rewind
-                b[cid, stdin, o, e]
-              end
-            else
-              [cid, stdin, stdout, stderr]
-            end
-          end
-          $?
-        end
-
-      end
-    end
-  end
-end

data/lib/chef/mixin/command.rb

@@ -1,194 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@chef.io>)
-# Copyright:: Copyright 2008-2016, Chef Software Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require "chef/log"
-require "chef/exceptions"
-require "tmpdir"
-require "fcntl"
-require "etc"
-
-class Chef
-  module Mixin
-
-    #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-    # NOTE:
-    # The popen4 method upon which all the code here is based has a race
-    # condition where it may fail to read all of the data written to stdout and
-    # stderr after the child process exits. The tests for the code here
-    # occasionally fail because of this race condition, so they have been
-    # tagged "volatile".
-    #
-    # This code is considered deprecated, so it should not need to be modified
-    # frequently, if at all. HOWEVER, if you do modify the code here, you must
-    # explicitly enable volatile tests:
-    #
-    #   bundle exec rspec spec/unit/mixin/command_spec.rb -t volatile
-    #
-    # In addition, you should make a note that tests need to be run with
-    # volatile tests enabled on any pull request or bug report you submit with
-    # your patch.
-    #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-    module Command
-      extend self
-
-      # NOTE: run_command is deprecated in favor of using Chef::Shellout which now comes from the mixlib-shellout gem. NOTE #
-
-      if RUBY_PLATFORM =~ /mswin|mingw32|windows/
-        require "chef/mixin/command/windows"
-        include ::Chef::Mixin::Command::Windows
-        extend  ::Chef::Mixin::Command::Windows
-      else
-        require "chef/mixin/command/unix"
-        include ::Chef::Mixin::Command::Unix
-        extend  ::Chef::Mixin::Command::Unix
-      end
-
-      # === Parameters
-      # args<Hash>: A number of required and optional arguments
-      #   command<String>, <Array>: A complete command with options to execute or a command and options as an Array
-      #   creates<String>: The absolute path to a file that prevents the command from running if it exists
-      #   cwd<String>: Working directory to execute command in, defaults to Dir.tmpdir
-      #   timeout<String>: How many seconds to wait for the command to execute before timing out
-      #   returns<String>: The single exit value command is expected to return, otherwise causes an exception
-      #   ignore_failure<Boolean>: Whether to raise an exception on failure, or just return the status
-      #   output_on_failure<Boolean>: Return output in raised exception regardless of Log.level
-      #
-      #   user<String>: The UID or user name of the user to execute the command as
-      #   group<String>: The GID or group name of the group to execute the command as
-      #   environment<Hash>: Pairs of environment variable names and their values to set before execution
-      #
-      # === Returns
-      # Returns the exit status of args[:command]
-      def run_command(args = {})
-        status, stdout, stderr = run_command_and_return_stdout_stderr(args)
-
-        status
-      end
-
-      # works same as above, except that it returns stdout and stderr
-      # requirement => platforms like solaris 9,10 has weird issues where
-      # even in command failure the exit code is zero, so we need to lookup stderr.
-      def run_command_and_return_stdout_stderr(args = {})
-        command_output = ""
-
-        args[:ignore_failure] ||= false
-        args[:output_on_failure] ||= false
-
-        # TODO: This is the wrong place for this responsibility.
-        if args.has_key?(:creates)
-          if File.exists?(args[:creates])
-            Chef::Log.debug("Skipping #{args[:command]} - creates #{args[:creates]} exists.")
-            return false
-          end
-        end
-
-        status, stdout, stderr = output_of_command(args[:command], args)
-        command_output << "STDOUT: #{stdout}"
-        command_output << "STDERR: #{stderr}"
-        handle_command_failures(status, command_output, args)
-
-        return status, stdout, stderr
-      end
-
-      def output_of_command(command, args)
-        Chef.deprecated(:run_command, "Chef::Mixin::Command.run_command is deprecated, please use shell_out")
-        Chef::Log.debug("Executing #{command}")
-        stderr_string, stdout_string, status = "", "", nil
-
-        exec_processing_block = lambda do |pid, stdin, stdout, stderr|
-          stdout_string, stderr_string = stdout.string.chomp, stderr.string.chomp
-        end
-
-        args[:cwd] ||= Dir.tmpdir
-        unless ::File.directory?(args[:cwd])
-          raise Chef::Exceptions::Exec, "#{args[:cwd]} does not exist or is not a directory"
-        end
-
-        Dir.chdir(args[:cwd]) do
-          if args[:timeout]
-            begin
-              Timeout.timeout(args[:timeout]) do
-                status = popen4(command, args, &exec_processing_block)
-              end
-            rescue Timeout::Error => e
-              Chef::Log.error("#{command} exceeded timeout #{args[:timeout]}")
-              raise(e)
-            end
-          else
-            status = popen4(command, args, &exec_processing_block)
-          end
-
-          Chef::Log.debug("---- Begin output of #{command} ----")
-          Chef::Log.debug("STDOUT: #{stdout_string}")
-          Chef::Log.debug("STDERR: #{stderr_string}")
-          Chef::Log.debug("---- End output of #{command} ----")
-          Chef::Log.debug("Ran #{command} returned #{status.exitstatus}")
-        end
-
-        return status, stdout_string, stderr_string
-      end
-
-      def handle_command_failures(status, command_output, opts = {})
-        return if opts[:ignore_failure]
-        opts[:returns] ||= 0
-        return if Array(opts[:returns]).include?(status.exitstatus)
-
-        # if the log level is not debug, through output of command when we fail
-        output = ""
-        if Chef::Log.level == :debug || opts[:output_on_failure]
-          output << "\n---- Begin output of #{opts[:command]} ----\n"
-          output << command_output.to_s
-          output << "\n---- End output of #{opts[:command]} ----\n"
-        end
-        raise Chef::Exceptions::Exec, "#{opts[:command]} returned #{status.exitstatus}, expected #{opts[:returns]}#{output}"
-      end
-
-      # Call #run_command but set LC_ALL to the system's current environment so it doesn't get changed to C.
-      #
-      # === Parameters
-      # args<Hash>: A number of required and optional arguments that will be handed out to #run_command
-      #
-      # === Returns
-      # Returns the result of #run_command
-      def run_command_with_systems_locale(args = {})
-        args[:environment] ||= {}
-        args[:environment]["LC_ALL"] = ENV["LC_ALL"]
-        run_command args
-      end
-
-      # def popen4(cmd, args={}, &b)
-      #   @@os_handler.popen4(cmd, args, &b)
-      # end
-
-      # module_function :popen4
-
-      # FIXME: yard with @yield
-      def chdir_or_tmpdir(dir)
-        dir ||= Dir.tmpdir
-        unless File.directory?(dir)
-          raise Chef::Exceptions::Exec, "#{dir} does not exist or is not a directory"
-        end
-        Dir.chdir(dir) do
-          yield
-        end
-      end
-
-    end
-  end
-end

data/lib/chef/monkey_patches/net-ssh-multi.rb

@@ -1,141 +0,0 @@
-#
-# Author:: Serdar Sutay (<serdar@chef.io>)
-# Copyright:: Copyright 2012-2016, Chef Software Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-# == net-ssh-multi gem patch for concurrency
-# net-ssh-multi gem has 2 bugs associated with the use of
-# :concurrent_connections option.
-# 1-) There is a race condition while fetching the next_session when
-# :concurrent_connections are set. @open_connections is being
-# incremented by the connection thread and sometimes
-# realize_pending_connections!() method can create more than required
-# connection threads before the @open_connections is set by the
-# previously created threads.
-# 2-) When :concurrent_connections is set, server classes are setup
-# with PendingConnection objects that always return true to busy?
-# calls. If a connection fails when :concurrent_connections is set,
-# server ends up returning true to all busy? calls since the session
-# object is not replaced. Due to this, main event loop (process()
-# function) never gets terminated.
-#
-# See: https://github.com/net-ssh/net-ssh-multi/pull/4
-
-require "net/ssh/multi/version"
-
-if Net::SSH::Multi::Version::STRING == "1.1.0" || Net::SSH::Multi::Version::STRING == "1.2.0"
-
-  require "net/ssh/multi"
-
-  module Net
-    module SSH
-      module Multi
-        class Server
-
-          # Make sure that server returns false if the ssh connection
-          # has failed.
-          def busy?(include_invisible = false)
-            !failed? && session && session.busy?(include_invisible)
-          end
-
-        end
-
-        class Session
-          def next_session(server, force = false) #:nodoc:
-            # don't retry a failed attempt
-            return nil if server.failed?
-
-            @session_mutex.synchronize do
-              if !force && concurrent_connections && concurrent_connections <= open_connections
-                connection = PendingConnection.new(server)
-                @pending_sessions << connection
-                return connection
-              end
-
-              # ===== PATCH START
-              # Only increment the open_connections count if the connection
-              # is not being forced. Incase of a force, it will already be
-              # incremented.
-              if !force
-                @open_connections += 1
-              end
-              # ===== PATCH END
-            end
-
-            begin
-              server.new_session
-
-              # I don't understand why this should be necessary--StandardError is a
-              # subclass of Exception, after all--but without explicitly rescuing
-              # StandardError, things like Errno::* and SocketError don't get caught
-              # here!
-            rescue Exception, StandardError => e
-              server.fail!
-              @session_mutex.synchronize { @open_connections -= 1 }
-
-              case on_error
-              when :ignore then
-                # do nothing
-              when :warn then
-                warn("error connecting to #{server}: #{e.class} (#{e.message})")
-              when Proc then
-                go = catch(:go) { on_error.call(server); nil }
-                case go
-                when nil, :ignore then # nothing
-                when :retry then retry
-                when :raise then raise
-                else warn "unknown 'go' command: #{go.inspect}"
-                end
-              else
-                raise
-              end
-
-              return nil
-            end
-          end
-
-          def realize_pending_connections! #:nodoc:
-            return unless concurrent_connections
-
-            server_list.each do |server|
-              server.close if !server.busy?(true)
-              server.update_session!
-            end
-
-            @connect_threads.delete_if { |t| !t.alive? }
-
-            count = concurrent_connections ? (concurrent_connections - open_connections) : @pending_sessions.length
-            count.times do
-              session = @pending_sessions.pop
-              break unless session
-              # ===== PATCH START
-              # Increment the open_connections count here to prevent
-              # creation of connection thread again before that is
-              # incremented by the thread.
-              @session_mutex.synchronize { @open_connections += 1 }
-              # ===== PATCH END
-              @connect_threads << Thread.new do
-                session.replace_with(next_session(session.server, true))
-              end
-            end
-          end
-
-        end
-      end
-    end
-  end
-
-end