knife 18.2.7 → 18.3.0

data/lib/chef/knife/delete.rb

@@ -1,125 +1,125 @@
-#
-# 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 "chef/chef_fs/file_system" unless defined?(Chef::ChefFS::FileSystem)
-      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
+#
+# 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 "chef/chef_fs/file_system" unless defined?(Chef::ChefFS::FileSystem)
+      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 +1,156 @@
-#
-# 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" unless defined?(Chef::ChefFS::Knife)
-
-class Chef
-  class Knife
-    class Deps < Chef::ChefFS::Knife
-      banner "knife deps PATTERN1 [PATTERNn]"
-
-      category "path-based"
-
-      deps do
-        require "chef/chef_fs/file_system" unless defined?(Chef::ChefFS::FileSystem)
-        require "chef/run_list" unless defined?(Chef::RunList)
-      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
+#
+# 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" unless defined?(Chef::ChefFS::Knife)
+
+class Chef
+  class Knife
+    class Deps < Chef::ChefFS::Knife
+      banner "knife deps PATTERN1 [PATTERNn]"
+
+      category "path-based"
+
+      deps do
+        require "chef/chef_fs/file_system" unless defined?(Chef::ChefFS::FileSystem)
+        require "chef/run_list" unless defined?(Chef::RunList)
+      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