chef 16.17.51-universal-mingw32 → 17.0.242-universal-mingw32

data/lib/chef/knife/core/object_loader.rb

@@ -1,115 +0,0 @@
-#
-# Author:: Daniel DeLeo (<dan@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.
-#
-
-autoload :FFI_Yajl, "ffi_yajl"
-require_relative "../../util/path_helper"
-require_relative "../../data_bag_item"
-
-class Chef
-  class Knife
-    module Core
-      class ObjectLoader
-
-        attr_reader :ui
-        attr_reader :klass
-
-        class ObjectType
-          FILE = 1
-          FOLDER = 2
-        end
-
-        def initialize(klass, ui)
-          @klass = klass
-          @ui = ui
-        end
-
-        def load_from(repo_location, *components)
-          unless object_file = find_file(repo_location, *components)
-            ui.error "Could not find or open file '#{components.last}' in current directory or in '#{repo_location}/#{components.join("/")}'"
-            exit 1
-          end
-          object_from_file(object_file)
-        end
-
-        # When someone makes this awesome, please update the above error message.
-        def find_file(repo_location, *components)
-          if file_exists_and_is_readable?(File.expand_path( components.last ))
-            File.expand_path( components.last )
-          else
-            relative_path = File.join(Dir.pwd, repo_location, *components)
-            if file_exists_and_is_readable?(relative_path)
-              relative_path
-            else
-              nil
-            end
-          end
-        end
-
-        # Find all objects in the given location
-        # If the object type is File it will look for all *.{json,rb}
-        # files, otherwise it will lookup for folders only (useful for
-        # data_bags)
-        #
-        # @param [String] path - base look up location
-        #
-        # @return [Array<String>] basenames of the found objects
-        #
-        # @api public
-        def find_all_objects(path)
-          path = File.join(Chef::Util::PathHelper.escape_glob_dir(File.expand_path(path)), "*")
-          path << ".{json,rb}"
-          objects = Dir.glob(path)
-          objects.map { |o| File.basename(o) }
-        end
-
-        def find_all_object_dirs(path)
-          path = File.join(Chef::Util::PathHelper.escape_glob_dir(File.expand_path(path)), "*")
-          objects = Dir.glob(path)
-          objects.delete_if { |o| !File.directory?(o) }
-          objects.map { |o| File.basename(o) }
-        end
-
-        def object_from_file(filename)
-          case filename
-          when /\.(js|json)$/
-            r = FFI_Yajl::Parser.parse(IO.read(filename))
-
-            # Chef::DataBagItem doesn't work well with the json_create method
-            if @klass == Chef::DataBagItem
-              r
-            else
-              @klass.from_hash(r)
-            end
-          when /\.rb$/
-            r = klass.new
-            r.from_file(filename)
-            r
-          else
-            ui.fatal("File must end in .js, .json, or .rb")
-            exit 30
-          end
-        end
-
-        def file_exists_and_is_readable?(file)
-          File.exist?(file) && File.readable?(file)
-        end
-
-      end
-    end
-  end
-end

data/lib/chef/knife/core/status_presenter.rb

@@ -1,147 +0,0 @@
-#
-# Author:: Nicolas DUPEUX (<nicolas.dupeux@arkea.com>)
-# 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 "text_formatter"
-require_relative "generic_presenter"
-
-class Chef
-  class Knife
-    module Core
-
-      # A customized presenter for Chef::Node objects. Supports variable-length
-      # output formats for displaying node data
-      class StatusPresenter < GenericPresenter
-
-        def format(data)
-          if parse_format_option == :json
-            summarize_json(data)
-          else
-            super
-          end
-        end
-
-        def summarize_json(list)
-          result_list = []
-          list.each do |node|
-            result = {}
-
-            result["name"] = node["name"] || node.name
-            result["chef_environment"] = node["chef_environment"]
-            ip = (node["cloud"] && node["cloud"]["public_ipv4_addrs"]&.first) || node["ipaddress"]
-            fqdn = (node["cloud"] && node["cloud"]["public_hostname"]) || node["fqdn"]
-            result["ip"] = ip if ip
-            result["fqdn"] = fqdn if fqdn
-            result["run_list"] = node.run_list if config["run_list"]
-            result["ohai_time"] = node["ohai_time"]
-            result["platform"] = node["platform"] if node["platform"]
-            result["platform_version"] = node["platform_version"] if node["platform_version"]
-
-            if config[:long_output]
-              result["default"]   = node.default_attrs
-              result["override"]  = node.override_attrs
-              result["automatic"] = node.automatic_attrs
-            end
-            result_list << result
-          end
-
-          Chef::JSONCompat.to_json_pretty(result_list)
-        end
-
-        # Converts a Chef::Node object to a string suitable for output to a
-        # terminal. If config[:medium_output] or config[:long_output] are set
-        # the volume of output is adjusted accordingly. Uses colors if enabled
-        # in the ui object.
-        def summarize(list)
-          summarized = ""
-          list.each do |data|
-            node = data
-            # special case clouds with their split horizon thing.
-            ip = (node[:cloud] && node[:cloud][:public_ipv4_addrs] && node[:cloud][:public_ipv4_addrs].first) || node[:ipaddress]
-            fqdn = (node[:cloud] && node[:cloud][:public_hostname]) || node[:fqdn]
-            name = node["name"] || node.name
-
-            if config[:run_list]
-              if config[:long_output]
-                run_list = node.run_list.map { |rl| "#{rl.type}[#{rl.name}]" }
-              else
-                run_list = node["run_list"]
-              end
-            end
-
-            line_parts = []
-
-            if node["ohai_time"]
-              hours, minutes, seconds = time_difference_in_hms(node["ohai_time"])
-              hours_text = "#{hours} hour#{hours == 1 ? " " : "s"}"
-              minutes_text = "#{minutes} minute#{minutes == 1 ? " " : "s"}"
-              seconds_text = "#{seconds} second#{seconds == 1 ? " " : "s"}"
-              if hours > 24
-                color = :red
-                text = hours_text
-              elsif hours >= 1
-                color = :yellow
-                text = hours_text
-              elsif minutes >= 1
-                color = :green
-                text = minutes_text
-              else
-                color = :green
-                text = seconds_text
-              end
-              line_parts << @ui.color(text, color) + " ago" << name
-            else
-              line_parts << "Node #{name} has not yet converged"
-            end
-
-            line_parts << fqdn if fqdn
-            line_parts << ip if ip
-            line_parts << run_list.to_s if run_list
-
-            if node["platform"]
-              platform = node["platform"].dup
-              if node["platform_version"]
-                platform << " #{node["platform_version"]}"
-              end
-              line_parts << platform
-            end
-
-            summarized = summarized + line_parts.join(", ") + ".\n"
-          end
-          summarized
-        end
-
-        def key(key_text)
-          ui.color(key_text, :cyan)
-        end
-
-        # @private
-        # @todo this is duplicated from StatusHelper in the Webui. dedup.
-        def time_difference_in_hms(unix_time)
-          now = Time.now.to_i
-          difference = now - unix_time.to_i
-          hours = (difference / 3600).to_i
-          difference = difference % 3600
-          minutes = (difference / 60).to_i
-          seconds = (difference % 60)
-          [hours, minutes, seconds]
-        end
-
-      end
-    end
-  end
-end

data/lib/chef/knife/core/subcommand_loader.rb

@@ -1,203 +0,0 @@
-# Author:: Christopher Brown (<cb@chef.io>)
-# Author:: Daniel DeLeo (<dan@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 "../../version"
-require_relative "../../util/path_helper"
-require_relative "gem_glob_loader"
-require_relative "hashed_command_loader"
-
-class Chef
-  class Knife
-    #
-    # Public Methods of a Subcommand Loader
-    #
-    # load_commands            - loads all available subcommands
-    # load_command(args)       - loads subcommands for the given args
-    # list_commands(args)      - lists all available subcommands,
-    #                            optionally filtering by category
-    # subcommand_files         - returns an array of all subcommand files
-    #                            that could be loaded
-    # command_class_from(args) - returns the subcommand class for the
-    #                            user-requested command
-    #
-    class SubcommandLoader
-      attr_reader :chef_config_dir
-
-      # A small factory method.  Eventually, this is the only place
-      # where SubcommandLoader should know about its subclasses, but
-      # to maintain backwards compatibility many of the instance
-      # methods in this base class contain default implementations
-      # of the functions sub classes should otherwise provide
-      # or directly instantiate the appropriate subclass
-      def self.for_config(chef_config_dir)
-        if autogenerated_manifest?
-          Chef::Log.trace("Using autogenerated hashed command manifest #{plugin_manifest_path}")
-          Knife::SubcommandLoader::HashedCommandLoader.new(chef_config_dir, plugin_manifest)
-        else
-          Knife::SubcommandLoader::GemGlobLoader.new(chef_config_dir)
-        end
-      end
-
-      # There are certain situations where we want to shortcut the loader selection
-      # in self.for_config and force using the GemGlobLoader
-      def self.gem_glob_loader(chef_config_dir)
-        Knife::SubcommandLoader::GemGlobLoader.new(chef_config_dir)
-      end
-
-      def self.plugin_manifest?
-        plugin_manifest_path && File.exist?(plugin_manifest_path)
-      end
-
-      def self.autogenerated_manifest?
-        plugin_manifest? && plugin_manifest.key?(HashedCommandLoader::KEY)
-      end
-
-      def self.plugin_manifest
-        Chef::JSONCompat.from_json(File.read(plugin_manifest_path))
-      end
-
-      def self.plugin_manifest_path
-        Chef::Util::PathHelper.home(".chef", "plugin_manifest.json")
-      end
-
-      def self.generate_hash
-        output = if plugin_manifest?
-                   plugin_manifest
-                 else
-                   { Chef::Knife::SubcommandLoader::HashedCommandLoader::KEY => {} }
-                 end
-        output[Chef::Knife::SubcommandLoader::HashedCommandLoader::KEY]["plugins_paths"] = Chef::Knife.subcommand_files
-        output[Chef::Knife::SubcommandLoader::HashedCommandLoader::KEY]["plugins_by_category"] = Chef::Knife.subcommands_by_category
-        output
-      end
-
-      def self.write_hash(data)
-        plugin_manifest_dir = File.expand_path("..", plugin_manifest_path)
-        FileUtils.mkdir_p(plugin_manifest_dir) unless File.directory?(plugin_manifest_dir)
-        File.open(plugin_manifest_path, "w") do |f|
-          f.write(Chef::JSONCompat.to_json_pretty(data))
-        end
-      end
-
-      def initialize(chef_config_dir)
-        @chef_config_dir = chef_config_dir
-      end
-
-      # Load all the sub-commands
-      def load_commands
-        return true if @loaded
-
-        subcommand_files.each { |subcommand| Kernel.load subcommand }
-        @loaded = true
-      end
-
-      def force_load
-        @loaded = false
-        load_commands
-      end
-
-      def load_command(_command_args)
-        load_commands
-      end
-
-      def list_commands(pref_cat = nil)
-        load_commands
-        if pref_cat && Chef::Knife.subcommands_by_category.key?(pref_cat)
-          { pref_cat => Chef::Knife.subcommands_by_category[pref_cat] }
-        else
-          Chef::Knife.subcommands_by_category
-        end
-      end
-
-      def command_class_from(args)
-        cmd_words = positional_arguments(args)
-        load_command(cmd_words)
-        result = Chef::Knife.subcommands[find_longest_key(Chef::Knife.subcommands,
-          cmd_words, "_")]
-        result || Chef::Knife.subcommands[args.first.tr("-", "_")]
-      end
-
-      def guess_category(args)
-        category_words = positional_arguments(args)
-        category_words.map! { |w| w.split("-") }.flatten!
-        find_longest_key(Chef::Knife.subcommands_by_category,
-          category_words, " ")
-      end
-
-      #
-      # This is shared between the custom_manifest_loader and the gem_glob_loader
-      #
-      def find_subcommands_via_dirglob
-        # The "require paths" of the core knife subcommands bundled with chef
-        files = Dir[File.join(Chef::Util::PathHelper.escape_glob_dir(File.expand_path("../../knife", __dir__)), "*.rb")]
-        subcommand_files = {}
-        files.each do |knife_file|
-          rel_path = knife_file[/#{CHEF_ROOT}#{Regexp.escape(File::SEPARATOR)}(.*)\.rb/, 1]
-          subcommand_files[rel_path] = knife_file
-        end
-        subcommand_files
-      end
-
-      #
-      # Utility function for finding an element in a hash given an array
-      # of words and a separator.  We find the the longest key in the
-      # hash composed of the given words joined by the separator.
-      #
-      def find_longest_key(hash, words, sep = "_")
-        words = words.dup
-        match = nil
-        until match || words.empty?
-          candidate = words.join(sep).tr("-", "_")
-          if hash.key?(candidate)
-            match = candidate
-          else
-            words.pop
-          end
-        end
-        match
-      end
-
-      #
-      # The positional arguments from the argument list provided by the
-      # users. Used to search for subcommands and categories.
-      #
-      # @return [Array<String>]
-      #
-      def positional_arguments(args)
-        args.select { |arg| arg =~ /^(([[:alnum:]])[[:alnum:]\_\-]+)$/ }
-      end
-
-      # Returns an Array of paths to knife commands located in
-      # chef_config_dir/plugins/knife/ and ~/.chef/plugins/knife/
-      def site_subcommands
-        user_specific_files = []
-
-        if chef_config_dir
-          user_specific_files.concat Dir.glob(File.expand_path("plugins/knife/*.rb", Chef::Util::PathHelper.escape_glob_dir(chef_config_dir)))
-        end
-
-        # finally search ~/.chef/plugins/knife/*.rb
-        Chef::Util::PathHelper.home(".chef", "plugins", "knife") do |p|
-          user_specific_files.concat Dir.glob(File.join(Chef::Util::PathHelper.escape_glob_dir(p), "*.rb"))
-        end
-
-        user_specific_files
-      end
-    end
-  end
-end

data/lib/chef/knife/core/text_formatter.rb

@@ -1,85 +0,0 @@
-#
-# Author:: Daniel DeLeo (<dan@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.
-#
-
-class Chef
-  class Knife
-    module Core
-      class TextFormatter
-
-        attr_reader :data
-        attr_reader :ui
-
-        def initialize(data, ui)
-          @ui = ui
-          @data = if data.respond_to?(:display_hash)
-                    data.display_hash
-                  elsif data.is_a?(Array)
-                    data
-                  elsif data.respond_to?(:to_hash)
-                    data.to_hash
-                  else
-                    data
-                  end
-        end
-
-        def formatted_data
-          @formatted_data ||= text_format(data)
-        end
-
-        def text_format(data)
-          buffer = ""
-
-          if data.respond_to?(:keys)
-            justify_width = data.keys.map { |k| k.to_s.size }.max.to_i + 1
-            data.sort.each do |key, value|
-              # key: ['value'] should be printed as key: value
-              if value.is_a?(Array) && value.size == 1 && is_singleton(value[0])
-                value = value[0]
-              end
-              if is_singleton(value)
-                # Strings are printed as key: value.
-                justified_key = ui.color("#{key}:".ljust(justify_width), :cyan)
-                buffer << "#{justified_key} #{value}\n"
-              else
-                # Arrays and hashes get indented on their own lines.
-                buffer << ui.color("#{key}:\n", :cyan)
-                lines = text_format(value).split("\n")
-                lines.each { |line| buffer << "  #{line}\n" }
-              end
-            end
-          elsif data.is_a?(Array)
-            data.each_index do |index|
-              item = data[index]
-              buffer << text_format(data[index])
-              # Separate items with newlines if it's an array of hashes or an
-              # array of arrays
-              buffer << "\n" if !is_singleton(data[index]) && index != data.size - 1
-            end
-          else
-            buffer << "#{data}\n"
-          end
-          buffer
-        end
-
-        def is_singleton(value)
-          !(value.is_a?(Array) || value.respond_to?(:keys))
-        end
-      end
-    end
-  end
-end