chef 16.10.8-universal-mingw32 → 17.0.242-universal-mingw32

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

data/lib/chef/knife/download.rb

@@ -1,84 +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 Download < Chef::ChefFS::Knife
-      banner "knife download 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 :purge,
-        long: "--[no-]purge",
-        boolean: true,
-        default: false,
-        description: "Delete matching local files and directories that do not exist remotely."
-
-      option :force,
-        long: "--[no-]force",
-        boolean: true,
-        default: false,
-        description: "Force download of files even if they match (quicker and harmless, but doesn't print out what it changed)."
-
-      option :dry_run,
-        long: "--dry-run",
-        short: "-n",
-        boolean: true,
-        default: false,
-        description: "Don't take action, only print what would happen."
-
-      option :diff,
-        long: "--[no-]diff",
-        boolean: true,
-        default: true,
-        description: "Turn off to avoid downloading existing files; only new (and possibly deleted) files with --no-diff."
-
-      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 name_args.length == 0
-          show_usage
-          ui.fatal("You must specify at least one argument. If you want to download everything in this directory, run \"knife download .\"")
-          exit 1
-        end
-
-        error = false
-        pattern_args.each do |pattern|
-          if Chef::ChefFS::FileSystem.copy_to(pattern, chef_fs, local_fs, config[:recurse] ? nil : 1, config, ui, proc { |entry| format_path(entry) })
-            error = true
-          end
-        end
-        if error
-          exit 1
-        end
-      end
-    end
-  end
-end