chef 16.18.30 → 17.10.163

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_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

data/lib/chef/knife/diff.rb

@@ -1,83 +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 Diff < Chef::ChefFS::Knife
-      banner "knife diff PATTERNS"
-
-      category "path-based"
-
-      deps do
-        require_relative "../chef_fs/command_line"
-      end
-
-      option :recurse,
-        long: "--[no-]recurse",
-        boolean: true,
-        default: true,
-        description: "List directories recursively."
-
-      option :name_only,
-        long: "--name-only",
-        boolean: true,
-        description: "Only show names of modified files."
-
-      option :name_status,
-        long: "--name-status",
-        boolean: true,
-        description: "Only show names and statuses of modified files: Added, Deleted, Modified, and Type Changed."
-
-      option :diff_filter,
-        long: "--diff-filter=[(A|D|M|T)...[*]]",
-        description: "Select only files that are Added (A), Deleted (D), Modified (M), or have their type (i.e. regular file, directory) changed (T). Any combination of the filter characters (including none) can be used. When * (All-or-none) is added to the combination, all paths are selected if there is any file that matches other criteria in the comparison; if there is no file that matches other criteria, nothing is selected."
-
-      option :cookbook_version,
-        long: "--cookbook-version VERSION",
-        description: "Version of cookbook to download (if there are multiple versions and cookbook_versions is false)."
-
-      def run
-        if config[:name_only]
-          output_mode = :name_only
-        end
-        if config[:name_status]
-          output_mode = :name_status
-        end
-        patterns = pattern_args_from(name_args.length > 0 ? name_args : [ "" ])
-
-        # Get the matches (recursively)
-        error = false
-        begin
-          patterns.each do |pattern|
-            found_error = Chef::ChefFS::CommandLine.diff_print(pattern, chef_fs, local_fs, config[:recurse] ? nil : 1, output_mode, proc { |entry| format_path(entry) }, config[:diff_filter], ui ) do |diff|
-              stdout.print diff
-            end
-            error = true if found_error
-          end
-        rescue Chef::ChefFS::FileSystem::OperationFailedError => e
-          ui.error "Failed on #{format_path(e.entry)} in #{e.operation}: #{e.message}"
-          error = true
-        end
-
-        if error
-          exit 1
-        end
-      end
-    end
-  end
-end