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

data/lib/chef/knife/data_bag_from_file.rb

@@ -1,113 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@chef.io>)
-# Author:: Seth Falcon (<seth@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_relative "data_bag_secret_options"
-
-class Chef
-  class Knife
-    class DataBagFromFile < Knife
-      include DataBagSecretOptions
-
-      deps do
-        require_relative "../util/path_helper"
-        require_relative "../data_bag"
-        require_relative "../data_bag_item"
-        require_relative "core/object_loader"
-        require_relative "../encrypted_data_bag_item"
-      end
-
-      banner "knife data bag from file BAG FILE|FOLDER [FILE|FOLDER..] (options)"
-      category "data bag"
-
-      option :all,
-        short: "-a",
-        long: "--all",
-        description: "Upload all data bags or all items for specified data bags."
-
-      def loader
-        @loader ||= Knife::Core::ObjectLoader.new(DataBagItem, ui)
-      end
-
-      def run
-        if config[:all] == true
-          load_all_data_bags(@name_args)
-        else
-          if @name_args.size < 2
-            ui.msg(opt_parser)
-            exit(1)
-          end
-          @data_bag = @name_args.shift
-          load_data_bag_items(@data_bag, @name_args)
-        end
-      end
-
-      private
-
-      def data_bags_path
-        @data_bag_path ||= "data_bags"
-      end
-
-      def find_all_data_bags
-        loader.find_all_object_dirs("./#{data_bags_path}")
-      end
-
-      def find_all_data_bag_items(data_bag)
-        loader.find_all_objects("./#{data_bags_path}/#{data_bag}")
-      end
-
-      def load_all_data_bags(args)
-        data_bags = args.empty? ? find_all_data_bags : [args.shift]
-        data_bags.each do |data_bag|
-          load_data_bag_items(data_bag)
-        end
-      end
-
-      def load_data_bag_items(data_bag, items = nil)
-        items ||= find_all_data_bag_items(data_bag)
-        item_paths = normalize_item_paths(items)
-        item_paths.each do |item_path|
-          item = loader.load_from((data_bags_path).to_s, data_bag, item_path)
-          item = if encryption_secret_provided?
-                   Chef::EncryptedDataBagItem.encrypt_data_bag_item(item, read_secret)
-                 else
-                   item
-                 end
-          dbag = Chef::DataBagItem.new
-          dbag.data_bag(data_bag)
-          dbag.raw_data = item
-          dbag.save
-          ui.info("Updated data_bag_item[#{dbag.data_bag}::#{dbag.id}]")
-        end
-      end
-
-      def normalize_item_paths(args)
-        paths = []
-        args.each do |path|
-          if File.directory?(path)
-            paths.concat(Dir.glob(File.join(Chef::Util::PathHelper.escape_glob_dir(path), "*.json")))
-          else
-            paths << path
-          end
-        end
-        paths
-      end
-    end
-  end
-end

data/lib/chef/knife/data_bag_list.rb

@@ -1,42 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@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"
-
-class Chef
-  class Knife
-    class DataBagList < Knife
-
-      deps do
-        require_relative "../data_bag"
-      end
-
-      banner "knife data bag list (options)"
-      category "data bag"
-
-      option :with_uri,
-        short: "-w",
-        long: "--with-uri",
-        description: "Show corresponding URIs."
-
-      def run
-        output(format_list_for_display(Chef::DataBag.list))
-      end
-    end
-  end
-end

data/lib/chef/knife/data_bag_secret_options.rb

@@ -1,122 +0,0 @@
-#
-# Author:: Tyler Ball (<tball@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 "mixlib/cli" unless defined?(Mixlib::CLI)
-require_relative "../config"
-require_relative "../encrypted_data_bag_item/check_encrypted"
-
-class Chef
-  class Knife
-    module DataBagSecretOptions
-      include Mixlib::CLI
-      include Chef::EncryptedDataBagItem::CheckEncrypted
-
-      # The config object is populated by knife#merge_configs with knife.rb `knife[:*]` config values, but they do
-      # not overwrite the command line properties.  It does mean, however, that `knife[:secret]` and `--secret-file`
-      # passed at the same time populate both `config[:secret]` and `config[:secret_file]`.  We cannot differentiate
-      # the valid case (`knife[:secret]` in config file and `--secret-file` on CL) and the invalid case (`--secret`
-      # and `--secret-file` on the CL) - thats why I'm storing the CL options in a different config key if they
-      # are provided.
-
-      def self.included(base)
-        base.option :cl_secret,
-          long: "--secret SECRET",
-          description: "The secret key to use to encrypt data bag item values. Can also be defaulted in your config with the key 'secret'."
-
-        base.option :cl_secret_file,
-          long: "--secret-file SECRET_FILE",
-          description: "A file containing the secret key to use to encrypt data bag item values. Can also be defaulted in your config with the key 'secret_file'."
-
-        base.option :encrypt,
-          long: "--encrypt",
-          description: "If 'secret' or 'secret_file' is present in your config, then encrypt data bags using it.",
-          boolean: true,
-          default: false
-      end
-
-      def encryption_secret_provided?
-        base_encryption_secret_provided?
-      end
-
-      def encryption_secret_provided_ignore_encrypt_flag?
-        base_encryption_secret_provided?(false)
-      end
-
-      def read_secret
-        # Moving the non 'compile-time' requires into here to speed up knife command loading
-        # IE, if we are not running 'knife data bag *' we don't need to load 'chef/encrypted_data_bag_item'
-        require_relative "../encrypted_data_bag_item"
-
-        if config[:cl_secret]
-          config[:cl_secret]
-        elsif config[:cl_secret_file]
-          Chef::EncryptedDataBagItem.load_secret(config[:cl_secret_file])
-        elsif secret = config[:secret]
-          secret
-        else
-          secret_file = config[:secret_file]
-          Chef::EncryptedDataBagItem.load_secret(secret_file)
-        end
-      end
-
-      def validate_secrets
-        if config[:cl_secret] && config[:cl_secret_file]
-          ui.fatal("Please specify only one of --secret, --secret-file")
-          exit(1)
-        end
-
-        if config[:secret] && config[:secret_file]
-          ui.fatal("Please specify only one of 'secret' or 'secret_file' in your config file")
-          exit(1)
-        end
-      end
-
-      private
-
-      ##
-      # Determine if the user has specified an appropriate secret for encrypting data bag items.
-      # @return boolean
-      def base_encryption_secret_provided?(need_encrypt_flag = true)
-        validate_secrets
-
-        return true if config[:cl_secret] || config[:cl_secret_file]
-
-        if need_encrypt_flag
-          if config[:encrypt]
-            unless config[:secret] || config[:secret_file]
-              ui.fatal("No secret or secret_file specified in config, unable to encrypt item.")
-              exit(1)
-            end
-            return true
-          end
-          return false
-        elsif config[:secret] || config[:secret_file]
-          # Certain situations (show and bootstrap) don't need a --encrypt flag to use the config file secret
-          return true
-        end
-        false
-      end
-
-      def knife_config
-        Chef.deprecated(:knife_bootstrap_apis, "The `knife_config` bootstrap helper has been deprecated, use the properly merged `config` helper instead")
-        Chef::Config.key?(:knife) ? Chef::Config[:knife] : {}
-      end
-
-    end
-  end
-end

data/lib/chef/knife/data_bag_show.rb

@@ -1,69 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@chef.io>)
-# Author:: Seth Falcon (<seth@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_relative "data_bag_secret_options"
-
-class Chef
-  class Knife
-    class DataBagShow < Knife
-      include DataBagSecretOptions
-
-      deps do
-        require_relative "../data_bag"
-        require_relative "../encrypted_data_bag_item"
-      end
-
-      banner "knife data bag show BAG [ITEM] (options)"
-      category "data bag"
-
-      def run
-        display = case @name_args.length
-                  when 2 # Bag and Item names provided
-                    secret = encryption_secret_provided_ignore_encrypt_flag? ? read_secret : nil
-                    raw_data = Chef::DataBagItem.load(@name_args[0], @name_args[1]).raw_data
-                    encrypted = encrypted?(raw_data)
-
-                    if encrypted && secret
-                      # Users do not need to pass --encrypt to read data, we simply try to use the provided secret
-                      ui.info("Encrypted data bag detected, decrypting with provided secret.")
-                      raw = Chef::EncryptedDataBagItem.load(@name_args[0],
-                        @name_args[1],
-                        secret)
-                      format_for_display(raw.to_h)
-                    elsif encrypted && !secret
-                      ui.warn("Encrypted data bag detected, but no secret provided for decoding. Displaying encrypted data.")
-                      format_for_display(raw_data)
-                    else
-                      ui.warn("Unencrypted data bag detected, ignoring any provided secret options.") if secret
-                      format_for_display(raw_data)
-                    end
-
-                  when 1 # Only Bag name provided
-                    format_list_for_display(Chef::DataBag.load(@name_args[0]))
-                  else
-                    stdout.puts opt_parser
-                    exit(1)
-                  end
-        output(display)
-      end
-
-    end
-  end
-end

data/lib/chef/knife/delete.rb

@@ -1,125 +0,0 @@
-#
-# 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 "../chef_fs/knife"
-
-class Chef
-  class Knife
-    class Delete < Chef::ChefFS::Knife
-      banner "knife delete [PATTERN1 ... PATTERNn]"
-
-      category "path-based"
-
-      deps do
-        require_relative "../chef_fs/file_system"
-      end
-
-      option :recurse,
-        short: "-r",
-        long: "--[no-]recurse",
-        boolean: true,
-        default: false,
-        description: "Delete directories recursively."
-
-      option :both,
-        long: "--both",
-        boolean: true,
-        default: false,
-        description: "Delete both the local and remote copies."
-
-      option :local,
-        long: "--local",
-        boolean: true,
-        default: false,
-        description: "Delete the local copy (leave the remote copy)."
-
-      def run
-        if name_args.length == 0
-          show_usage
-          ui.fatal("You must specify at least one argument. If you want to delete everything in this directory, run \"knife delete --recurse .\"")
-          exit 1
-        end
-
-        # Get the matches (recursively)
-        error = false
-        if config[:local]
-          pattern_args.each do |pattern|
-            Chef::ChefFS::FileSystem.list(local_fs, pattern).each do |result|
-              if delete_result(result)
-                error = true
-              end
-            end
-          end
-        elsif config[:both]
-          pattern_args.each do |pattern|
-            Chef::ChefFS::FileSystem.list_pairs(pattern, chef_fs, local_fs).each do |chef_result, local_result|
-              if delete_result(chef_result, local_result)
-                error = true
-              end
-            end
-          end
-        else # Remote only
-          pattern_args.each do |pattern|
-            Chef::ChefFS::FileSystem.list(chef_fs, pattern).each do |result|
-              if delete_result(result)
-                error = true
-              end
-            end
-          end
-        end
-
-        if error
-          exit 1
-        end
-      end
-
-      def format_path_with_root(entry)
-        root = entry.root == chef_fs ? " (remote)" : " (local)"
-        "#{format_path(entry)}#{root}"
-      end
-
-      def delete_result(*results)
-        deleted_any = false
-        found_any = false
-        error = false
-        results.each do |result|
-
-          result.delete(config[:recurse])
-          deleted_any = true
-          found_any = true
-        rescue Chef::ChefFS::FileSystem::NotFoundError
-          # This is not an error unless *all* of them were not found
-        rescue Chef::ChefFS::FileSystem::MustDeleteRecursivelyError => e
-          ui.error "#{format_path_with_root(e.entry)} must be deleted recursively!  Pass -r to knife delete."
-          found_any = true
-          error = true
-        rescue Chef::ChefFS::FileSystem::OperationNotAllowedError => e
-          ui.error "#{format_path_with_root(e.entry)} #{e.reason}."
-          found_any = true
-          error = true
-
-        end
-        if deleted_any
-          output("Deleted #{format_path(results[0])}")
-        elsif !found_any
-          ui.error "#{format_path(results[0])}: No such file or directory"
-          error = true
-        end
-        error
-      end
-    end
-  end
-end

data/lib/chef/knife/deps.rb

@@ -1,156 +0,0 @@
-#
-# 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 "../chef_fs/knife"
-
-class Chef
-  class Knife
-    class Deps < Chef::ChefFS::Knife
-      banner "knife deps PATTERN1 [PATTERNn]"
-
-      category "path-based"
-
-      deps do
-        require_relative "../chef_fs/file_system"
-        require_relative "../run_list"
-      end
-
-      option :recurse,
-        long: "--[no-]recurse",
-        boolean: true,
-        description: "List dependencies recursively (default: true). Only works with --tree."
-
-      option :tree,
-        long: "--tree",
-        boolean: true,
-        description: "Show dependencies in a visual tree. May show duplicates."
-
-      option :remote,
-        long: "--remote",
-        boolean: true,
-        description: "List dependencies on the server instead of the local filesystem."
-
-      attr_accessor :exit_code
-
-      def run
-        if config[:recurse] == false && !config[:tree]
-          ui.error "--no-recurse requires --tree"
-          exit(1)
-        end
-        config[:recurse] = true if config[:recurse].nil?
-
-        @root = config[:remote] ? chef_fs : local_fs
-        dependencies = {}
-        pattern_args.each do |pattern|
-          Chef::ChefFS::FileSystem.list(@root, pattern).each do |entry|
-            if config[:tree]
-              print_dependencies_tree(entry, dependencies)
-            else
-              print_flattened_dependencies(entry, dependencies)
-            end
-          end
-        end
-        exit exit_code if exit_code
-      end
-
-      def print_flattened_dependencies(entry, dependencies)
-        unless dependencies[entry.path]
-          dependencies[entry.path] = get_dependencies(entry)
-          dependencies[entry.path].each do |child|
-            child_entry = Chef::ChefFS::FileSystem.resolve_path(@root, child)
-            print_flattened_dependencies(child_entry, dependencies)
-          end
-          output format_path(entry)
-        end
-      end
-
-      def print_dependencies_tree(entry, dependencies, printed = {}, depth = 0)
-        dependencies[entry.path] = get_dependencies(entry) unless dependencies[entry.path]
-        output "#{"  " * depth}#{format_path(entry)}"
-        if !printed[entry.path] && (config[:recurse] || depth == 0)
-          printed[entry.path] = true
-          dependencies[entry.path].each do |child|
-            child_entry = Chef::ChefFS::FileSystem.resolve_path(@root, child)
-            print_dependencies_tree(child_entry, dependencies, printed, depth + 1)
-          end
-        end
-      end
-
-      def get_dependencies(entry)
-        if entry.parent && entry.parent.path == "/cookbooks"
-          entry.chef_object.metadata.dependencies.keys.map { |cookbook| "/cookbooks/#{cookbook}" }
-
-        elsif entry.parent && entry.parent.path == "/nodes"
-          node = Chef::JSONCompat.parse(entry.read)
-          result = []
-          if node["chef_environment"] && node["chef_environment"] != "_default"
-            result << "/environments/#{node["chef_environment"]}.json"
-          end
-          if node["run_list"]
-            result += dependencies_from_runlist(node["run_list"])
-          end
-          result
-
-        elsif entry.parent && entry.parent.path == "/roles"
-          role = Chef::JSONCompat.parse(entry.read)
-          result = []
-          if role["run_list"]
-            dependencies_from_runlist(role["run_list"]).each do |dependency|
-              result << dependency unless result.include?(dependency)
-            end
-          end
-          if role["env_run_lists"]
-            role["env_run_lists"].each_pair do |env, run_list|
-              dependencies_from_runlist(run_list).each do |dependency|
-                result << dependency unless result.include?(dependency)
-              end
-            end
-          end
-          result
-
-        elsif !entry.exists?
-          raise Chef::ChefFS::FileSystem::NotFoundError.new(entry)
-
-        else
-          []
-        end
-      rescue Chef::ChefFS::FileSystem::NotFoundError => e
-        ui.error "#{format_path(e.entry)}: No such file or directory"
-        self.exit_code = 2
-        []
-      end
-
-      def dependencies_from_runlist(run_list)
-        chef_run_list = Chef::RunList.new
-        chef_run_list.reset!(run_list)
-        chef_run_list.map do |run_list_item|
-          case run_list_item.type
-          when :role
-            "/roles/#{run_list_item.name}.json"
-          when :recipe
-            if run_list_item.name =~ /(.+)::[^:]*/
-              "/cookbooks/#{$1}"
-            else
-              "/cookbooks/#{run_list_item.name}"
-            end
-          else
-            raise "Unknown run list item type #{run_list_item.type}"
-          end
-        end
-      end
-    end
-  end
-end