chef 16.16.13 → 17.0.242

data/lib/chef/application/windows_service_manager.rb

@@ -1,205 +0,0 @@
-#
-# Author:: Seth Chisamore (<schisamo@chef.io>)
-# Copyright:: Copyright (c) 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.
-#
-
-if RUBY_PLATFORM.match?(/mswin|mingw32|windows/)
-  require "win32/service"
-end
-require_relative "../config"
-require "mixlib/cli" unless defined?(Mixlib::CLI)
-require "chef-utils/dist" unless defined?(ChefUtils::Dist)
-
-class Chef
-  class Application
-    #
-    # This class is used to create and manage a windows service.
-    # Service should be created using Daemon class from
-    # win32/service gem.
-    # For an example see: Chef::Application::WindowsService
-    #
-    # Outside programs are expected to use this class to manage
-    # windows services.
-    #
-    class WindowsServiceManager
-      include Mixlib::CLI
-
-      option :action,
-        short: "-a ACTION",
-        long: "--action ACTION",
-        default: "status",
-        description: "Action to carry out on #{ChefUtils::Dist::Infra::SHORT}-service (install, uninstall, status, start, stop, pause, or resume)."
-
-      option :config_file,
-        short: "-c CONFIG",
-        long: "--config CONFIG",
-        default: "#{ChefConfig::Config.c_chef_dir}/client.rb",
-        description: "The configuration file to use for #{ChefUtils::Dist::Infra::PRODUCT} runs."
-
-      option :log_location,
-        short: "-L LOGLOCATION",
-        long: "--logfile LOGLOCATION",
-        description: "Set the log file location for #{ChefUtils::Dist::Infra::SHORT}-service."
-
-      option :help,
-        short: "-h",
-        long: "--help",
-        description: "Show this help message.",
-        on: :tail,
-        boolean: true,
-        show_options: true,
-        exit: 0
-
-      option :version,
-        short: "-v",
-        long: "--version",
-        description: "Show #{ChefUtils::Dist::Infra::PRODUCT} version.",
-        boolean: true,
-        proc: lambda { |v| puts "#{ChefUtils::Dist::Infra::PRODUCT}: #{::Chef::VERSION}" },
-        exit: 0
-
-      def initialize(service_options)
-        # having to call super in initialize is the most annoying
-        # anti-pattern :(
-        super()
-
-        raise ArgumentError, "Service definition is not provided" if service_options.nil?
-
-        required_options = %i{service_name service_display_name service_description service_file_path}
-
-        required_options.each do |req_option|
-          unless service_options.key?(req_option)
-            raise ArgumentError, "Service definition doesn't contain required option #{req_option}"
-          end
-        end
-
-        @service_name = service_options[:service_name]
-        @service_display_name = service_options[:service_display_name]
-        @service_description = service_options[:service_description]
-        @service_file_path = service_options[:service_file_path]
-        @service_start_name = service_options[:run_as_user]
-        @password = service_options[:run_as_password]
-        @delayed_start = service_options[:delayed_start]
-        @dependencies = service_options[:dependencies]
-      end
-
-      def run(params = ARGV)
-        parse_options(params)
-
-        case config[:action]
-        when "install"
-          if service_exists?
-            puts "Service #{@service_name} already exists on the system."
-          else
-            ruby = File.join(RbConfig::CONFIG["bindir"], "ruby")
-
-            opts = ""
-            opts << " -c #{config[:config_file]}" if config[:config_file]
-            opts << " -L #{config[:log_location]}" if config[:log_location]
-
-            # Quote the full paths to deal with possible spaces in the path name.
-            # Also ensure all forward slashes are backslashes
-            cmd = "\"#{ruby}\" \"#{@service_file_path}\" #{opts}".gsub(File::SEPARATOR, File::ALT_SEPARATOR)
-
-            ::Win32::Service.new(
-              service_name: @service_name,
-              display_name: @service_display_name,
-              description: @service_description,
-              # Prior to 0.8.5, win32-service creates interactive services by default,
-              # and we don't want that, so we need to override the service type.
-              service_type: ::Win32::Service::SERVICE_WIN32_OWN_PROCESS,
-              start_type: ::Win32::Service::SERVICE_AUTO_START,
-              binary_path_name: cmd,
-              service_start_name: @service_start_name,
-              password: @password,
-              dependencies: @dependencies
-            )
-            unless @delayed_start.nil?
-              ::Win32::Service.configure(
-                service_name: @service_name,
-                delayed_start: @delayed_start
-              )
-            end
-            puts "Service '#{@service_name}' has successfully been installed."
-          end
-        when "status"
-          if !service_exists?
-            puts "Service #{@service_name} doesn't exist on the system."
-          else
-            puts "State of #{@service_name} service is: #{current_state}"
-          end
-        when "start"
-          # TODO: allow override of startup parameters here?
-          take_action("start", RUNNING)
-        when "stop"
-          take_action("stop", STOPPED)
-        when "uninstall", "delete"
-          take_action("stop", STOPPED)
-          unless service_exists?
-            puts "Service #{@service_name} doesn't exist on the system."
-          else
-            ::Win32::Service.delete(@service_name)
-            puts "Service #{@service_name} deleted"
-          end
-        when "pause"
-          take_action("pause", PAUSED)
-        when "resume"
-          take_action("resume", RUNNING)
-        end
-      end
-
-      private
-
-      # Just some state constants
-      STOPPED = "stopped".freeze
-      RUNNING = "running".freeze
-      PAUSED = "paused".freeze
-
-      def service_exists?
-        ::Win32::Service.exists?(@service_name)
-      end
-
-      def take_action(action = nil, desired_state = nil)
-        if service_exists?
-          if current_state != desired_state
-            ::Win32::Service.send(action, @service_name)
-            wait_for_state(desired_state)
-            puts "Service '#{@service_name}' is now '#{current_state}'."
-          else
-            puts "Service '#{@service_name}' is already '#{desired_state}'."
-          end
-        else
-          puts "Cannot '#{action}' service '#{@service_name}'"
-          puts "Service #{@service_name} doesn't exist on the system."
-        end
-      end
-
-      def current_state
-        ::Win32::Service.status(@service_name).current_state
-      end
-
-      # Helper method that waits for a status to change its state since state
-      # changes aren't usually instantaneous.
-      def wait_for_state(desired_state)
-        while current_state != desired_state
-          puts "One moment... #{current_state}"
-          sleep 1
-        end
-      end
-
-    end
-  end
-end

data/lib/chef/chef_fs/knife.rb

@@ -1,160 +0,0 @@
-#
-# Author:: John Keiser (<jkeiser@chef.io>)
-# Copyright:: Copyright (c) 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_relative "../knife"
-require "pathname" unless defined?(Pathname)
-require "chef-utils/dist" unless defined?(ChefUtils::Dist)
-
-class Chef
-  module ChefFS
-    class Knife < Chef::Knife
-      # Workaround for CHEF-3932
-      def self.deps
-        super do
-          require_relative "../config"
-          require_relative "parallelizer"
-          require_relative "config"
-          require_relative "file_pattern"
-          require_relative "path_utils"
-          yield
-        end
-      end
-
-      def self.inherited(c)
-        super
-
-        # Ensure we always get to do our includes, whether subclass calls deps or not
-        c.deps do
-        end
-      end
-
-      option :repo_mode,
-        long: "--repo-mode MODE",
-        description: "Specifies the local repository layout.  Values: static, everything, hosted_everything.  Default: everything/hosted_everything"
-
-      option :chef_repo_path,
-        long: "--chef-repo-path PATH",
-        description: "Overrides the location of #{ChefUtils::Dist::Infra::PRODUCT} repo. Default is specified by chef_repo_path in the config"
-
-      option :concurrency,
-        long: "--concurrency THREADS",
-        description: "Maximum number of simultaneous requests to send (default: 10)"
-
-      def configure_chef
-        super
-        Chef::Config[:repo_mode] = config[:repo_mode] if config[:repo_mode]
-        Chef::Config[:concurrency] = config[:concurrency].to_i if config[:concurrency]
-
-        # --chef-repo-path forcibly overrides all other paths
-        if config[:chef_repo_path]
-          Chef::Config[:chef_repo_path] = config[:chef_repo_path]
-          Chef::ChefFS::Config::INFLECTIONS.each_value do |variable_name|
-            Chef::Config.delete("#{variable_name}_path".to_sym)
-          end
-        end
-
-        @chef_fs_config = Chef::ChefFS::Config.new(Chef::Config, Dir.pwd, config, ui)
-
-        Chef::ChefFS::Parallelizer.threads = (Chef::Config[:concurrency] || 10) - 1
-      end
-
-      def chef_fs
-        @chef_fs_config.chef_fs
-      end
-
-      def create_chef_fs
-        @chef_fs_config.create_chef_fs
-      end
-
-      def local_fs
-        @chef_fs_config.local_fs
-      end
-
-      def create_local_fs
-        @chef_fs_config.create_local_fs
-      end
-
-      def pattern_args
-        @pattern_args ||= pattern_args_from(name_args)
-      end
-
-      def pattern_args_from(args)
-        args.map { |arg| pattern_arg_from(arg) }
-      end
-
-      def pattern_arg_from(arg)
-        inferred_path = nil
-        if Chef::ChefFS::PathUtils.is_absolute?(arg)
-          # We should be able to use this as-is - but the user might have incorrectly provided
-          # us with a path that is based off of the OS root path instead of the Chef-FS root.
-          # Do a quick and dirty sanity check.
-          if possible_server_path = @chef_fs_config.server_path(arg)
-            ui.warn("The absolute path provided is suspicious: #{arg}")
-            ui.warn("If you wish to refer to a file location, please provide a path that is rooted at the chef-repo.")
-            ui.warn("Consider writing '#{possible_server_path}' instead of '#{arg}'")
-          end
-          # Use the original path because we can't be sure.
-          inferred_path = arg
-        elsif arg[0, 1] == "~"
-          # Let's be nice and fix it if possible - but warn the user.
-          ui.warn("A path relative to a user home directory has been provided: #{arg}")
-          ui.warn("Paths provided need to be rooted at the chef-repo being considered or be relative paths.")
-          inferred_path = @chef_fs_config.server_path(arg)
-          ui.warn("Using '#{inferred_path}' as the path instead of '#{arg}'.")
-        elsif Pathname.new(arg).absolute?
-          # It is definitely a system absolute path (such as C:\ or \\foo\bar) but it cannot be
-          # interpreted as a Chef-FS absolute path.  Again attempt to be nice but warn the user.
-          ui.warn("An absolute file system path that isn't a server path was provided: #{arg}")
-          ui.warn("Paths provided need to be rooted at the chef-repo being considered or be relative paths.")
-          inferred_path = @chef_fs_config.server_path(arg)
-          ui.warn("Using '#{inferred_path}' as the path instead of '#{arg}'.")
-        elsif @chef_fs_config.base_path.nil?
-          # These are all relative paths.  We can't resolve and root paths unless we are in the
-          # chef repo.
-          ui.error("Attempt to use relative path '#{arg}' when current directory is outside the repository path.")
-          ui.error("Current working directory is '#{@chef_fs_config.cwd}'.")
-          exit(1)
-        else
-          inferred_path = Chef::ChefFS::PathUtils.join(@chef_fs_config.base_path, arg)
-        end
-        Chef::ChefFS::FilePattern.new(inferred_path)
-      end
-
-      def format_path(entry)
-        @chef_fs_config.format_path(entry)
-      end
-
-      def parallelize(inputs, options = {}, &block)
-        Chef::ChefFS::Parallelizer.parallelize(inputs, options, &block)
-      end
-
-      def discover_repo_dir(dir)
-        %w{.chef cookbooks data_bags environments roles}.each do |subdir|
-          return dir if File.directory?(File.join(dir, subdir))
-        end
-        # If this isn't it, check the parent
-        parent = File.dirname(dir)
-        if parent && parent != dir
-          discover_repo_dir(parent)
-        else
-          nil
-        end
-      end
-    end
-  end
-end

data/lib/chef/chef_fs/parallelizer/flatten_enumerable.rb

@@ -1,35 +0,0 @@
-class Chef
-  module ChefFS
-    class Parallelizer
-      class FlattenEnumerable
-        include Enumerable
-
-        def initialize(enum, levels = nil)
-          @enum = enum
-          @levels = levels
-        end
-
-        attr_reader :enum
-        attr_reader :levels
-
-        def each(&block)
-          enum.each do |value|
-            flatten(value, levels, &block)
-          end
-        end
-
-        private
-
-        def flatten(value, levels, &block)
-          if levels != 0 && value.respond_to?(:each) && !value.is_a?(String)
-            value.each do |child|
-              flatten(child, levels.nil? ? levels : levels - 1, &block)
-            end
-          else
-            yield(value)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/chef/chef_fs/parallelizer/parallel_enumerable.rb

@@ -1,278 +0,0 @@
-require_relative "flatten_enumerable"
-
-class Chef
-  module ChefFS
-    class Parallelizer
-      class ParallelEnumerable
-        include Enumerable
-
-        # options:
-        # :ordered [true|false] - whether the output should stay in the same order
-        #   as the input (even though it may not actually be processed in that
-        #   order). Default: true
-        # :stop_on_exception [true|false] - if true, when an exception occurs in either
-        #   input or output, we wait for any outstanding processing to complete,
-        #   but will not process any new inputs. Default: false
-        # :main_thread_processing [true|false] - whether the main thread pulling
-        #   on each() is allowed to process inputs. Default: true
-        #   NOTE: If you set this to false, parallelizer.kill will stop each()
-        #   in its tracks, so you need to know for sure that won't happen.
-        def initialize(parent_task_queue, input_enumerable, options = {}, &block)
-          @parent_task_queue = parent_task_queue
-          @input_enumerable = input_enumerable
-          @options = options
-          @block = block
-
-          @unconsumed_input = Queue.new
-          @in_process = {}
-          @unconsumed_output = Queue.new
-        end
-
-        attr_reader :parent_task_queue
-        attr_reader :input_enumerable
-        attr_reader :options
-        attr_reader :block
-
-        def each
-          each_with_input do |output, index, input, type|
-            yield output
-          end
-        end
-
-        def each_with_index
-          each_with_input do |output, index, input|
-            yield output, index
-          end
-        end
-
-        def each_with_input
-          exception = nil
-          each_with_exceptions do |output, index, input, type|
-            if type == :exception
-              if @options[:ordered] == false
-                exception ||= output
-              else
-                raise output
-              end
-            else
-              yield output, index, input
-            end
-          end
-          raise exception if exception
-        end
-
-        def each_with_exceptions(&block)
-          if @options[:ordered] == false
-            each_with_exceptions_unordered(&block)
-          else
-            each_with_exceptions_ordered(&block)
-          end
-        end
-
-        def wait
-          exception = nil
-          each_with_exceptions_unordered do |output, index, input, type|
-            exception ||= output if type == :exception
-          end
-          raise exception if exception
-        end
-
-        # Enumerable methods
-        def restricted_copy(enumerable)
-          ParallelEnumerable.new(@parent_task_queue, enumerable, @options, &@block)
-        end
-
-        alias :original_count :count
-
-        def count(*args, &block)
-          if args.size == 0 && block.nil?
-            @input_enumerable.count
-          else
-            original_count(*args, &block)
-          end
-        end
-
-        def first(n = nil)
-          if n
-            restricted_copy(@input_enumerable.first(n)).to_a
-          else
-            first(1)[0]
-          end
-        end
-
-        def drop(n)
-          restricted_copy(@input_enumerable.drop(n)).to_a
-        end
-
-        def flatten(levels = nil)
-          FlattenEnumerable.new(self, levels)
-        end
-
-        def take(n)
-          restricted_copy(@input_enumerable.take(n)).to_a
-        end
-
-        if Enumerable.method_defined?(:lazy)
-          class RestrictedLazy
-            def initialize(parallel_enumerable, actual_lazy)
-              @parallel_enumerable = parallel_enumerable
-              @actual_lazy = actual_lazy
-            end
-
-            def drop(*args, &block)
-              input = @parallel_enumerable.input_enumerable.lazy.drop(*args, &block)
-              @parallel_enumerable.restricted_copy(input)
-            end
-
-            def take(*args, &block)
-              input = @parallel_enumerable.input_enumerable.lazy.take(*args, &block)
-              @parallel_enumerable.restricted_copy(input)
-            end
-
-            def method_missing(method, *args, &block)
-              @actual_lazy.send(:method, *args, &block)
-            end
-          end
-
-          alias :original_lazy :lazy
-
-          def lazy
-            RestrictedLazy.new(self, original_lazy)
-          end
-        end
-
-        private
-
-        def each_with_exceptions_unordered
-          if @each_running
-            raise "each() called on parallel enumerable twice simultaneously! Bad mojo"
-          end
-
-          @each_running = true
-          begin
-            # Grab all the inputs, yielding any responses during enumeration
-            # in case the enumeration itself takes time
-            begin
-              @input_enumerable.each_with_index do |input, index|
-                @unconsumed_input.push([ input, index ])
-                @parent_task_queue.push(method(:process_one))
-
-                stop_processing_input = false
-                until @unconsumed_output.empty?
-                  output, index, input, type = @unconsumed_output.pop
-                  yield output, index, input, type
-                  if type == :exception && @options[:stop_on_exception]
-                    stop_processing_input = true
-                    break
-                  end
-                end
-
-                if stop_processing_input
-                  break
-                end
-              end
-            rescue
-              # We still want to wait for the rest of the outputs to process
-              @unconsumed_output.push([$!, nil, nil, :exception])
-              if @options[:stop_on_exception]
-                @unconsumed_input.clear
-              end
-            end
-
-            until finished?
-              # yield thread to others (for 1.8.7)
-              if @unconsumed_output.empty?
-                sleep(0.01)
-              end
-
-              yield @unconsumed_output.pop until @unconsumed_output.empty?
-
-              # If no one is working on our tasks and we're allowed to
-              # work on them in the main thread, process an input to
-              # move things forward.
-              if @in_process.size == 0 && !(@options[:main_thread_processing] == false)
-                process_one
-              end
-            end
-          rescue
-            # If we exited early, perhaps due to any? finding a result, we want
-            # to make sure and throw away any extra results (gracefully) so that
-            # the next enumerator can start over.
-            unless finished?
-              stop
-            end
-            raise
-          ensure
-            @each_running = false
-          end
-        end
-
-        def each_with_exceptions_ordered
-          next_to_yield = 0
-          unconsumed = {}
-          each_with_exceptions_unordered do |output, index, input, type|
-            unconsumed[index] = [ output, input, type ]
-            while unconsumed[next_to_yield]
-              input_output = unconsumed.delete(next_to_yield)
-              yield input_output[0], next_to_yield, input_output[1], input_output[2]
-              next_to_yield += 1
-            end
-          end
-          input_exception = unconsumed.delete(nil)
-          if input_exception
-            yield input_exception[0], next_to_yield, input_exception[1], input_exception[2]
-          end
-        end
-
-        def stop
-          @unconsumed_input.clear
-          sleep(0.05) while @in_process.size > 0
-          @unconsumed_output.clear
-        end
-
-        #
-        # This is thread safe only if called from the main thread pulling on each().
-        # The order of these checks is important, as well, to be thread safe.
-        # 1. If @unconsumed_input.empty? is true, then we will never have any more
-        # work legitimately picked up.
-        # 2. If @in_process == 0, then there is no work in process, and because of when unconsumed_input is empty, it will never go back up, because
-        # this is called after the input enumerator is finished.  Note that switching #2 and #1
-        # could cause a race, because in_process is incremented *before* consuming input.
-        # 3. If @unconsumed_output.empty? is true, then we are done with outputs.
-        # Thus, 1+2 means no more output will ever show up, and 3 means we've passed all
-        # existing outputs to the user.
-        #
-        def finished?
-          @unconsumed_input.empty? && @in_process.size == 0 && @unconsumed_output.empty?
-        end
-
-        def process_one
-          @in_process[Thread.current] = true
-          begin
-            begin
-              input, index = @unconsumed_input.pop(true)
-              process_input(input, index)
-            rescue ThreadError
-            end
-          ensure
-            @in_process.delete(Thread.current)
-          end
-        end
-
-        def process_input(input, index)
-          begin
-            output = @block.call(input)
-            @unconsumed_output.push([ output, index, input, :result ])
-          rescue StandardError, ScriptError
-            if @options[:stop_on_exception]
-              @unconsumed_input.clear
-            end
-            @unconsumed_output.push([ $!, index, input, :exception ])
-          end
-
-          index
-        end
-      end
-    end
-  end
-end