knife 18.0.185 → 18.1.0

data/lib/chef/knife/search.rb

@@ -1,194 +1,194 @@
-#
-# 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"
-require_relative "core/node_presenter"
-require_relative "core/formatting_options"
-
-class Chef
-  class Knife
-    class Search < Knife
-
-      include Knife::Core::MultiAttributeReturnOption
-
-      deps do
-        require "chef/node" unless defined?(Chef::Node)
-        require "chef/environment" unless defined?(Chef::Environment)
-        require "chef/api_client"  unless defined?(Chef::APIClient)
-        require "chef/search/query" unless defined?(Chef::Search::Query)
-      end
-
-      include Knife::Core::FormattingOptions
-
-      banner "knife search INDEX QUERY (options)"
-
-      option :start,
-        short: "-b ROW",
-        long: "--start ROW",
-        description: "The row to start returning results at.",
-        default: 0,
-        proc: lambda { |i| i.to_i }
-
-      option :rows,
-        short: "-R INT",
-        long: "--rows INT",
-        description: "The number of rows to return.",
-        default: nil,
-        proc: lambda { |i| i.to_i }
-
-      option :run_list,
-        short: "-r",
-        long: "--run-list",
-        description: "Show only the run list."
-
-      option :id_only,
-        short: "-i",
-        long: "--id-only",
-        description: "Show only the ID of matching objects."
-
-      option :query,
-        short: "-q QUERY",
-        long: "--query QUERY",
-        description: "The search query; useful to protect queries starting with -."
-
-      option :filter_result,
-        short: "-f FILTER",
-        long: "--filter-result FILTER",
-        description: "Only return specific attributes of the matching objects; for example: \"ServerName=name, Kernel=kernel.version\"."
-
-      def run
-        read_cli_args
-
-        if @type == "node"
-          ui.use_presenter Knife::Core::NodePresenter
-        end
-
-        q = Chef::Search::Query.new
-
-        result_items = []
-        result_count = 0
-
-        search_args = {}
-        search_args[:fuzz] = true
-        search_args[:start] = config[:start] if config[:start]
-        search_args[:rows] = config[:rows] if config[:rows]
-        if config[:filter_result]
-          search_args[:filter_result] = create_result_filter(config[:filter_result])
-        elsif (not ui.config[:attribute].nil?) && (not ui.config[:attribute].empty?)
-          search_args[:filter_result] = create_result_filter_from_attributes(ui.config[:attribute])
-        elsif config[:id_only]
-          search_args[:filter_result] = create_result_filter_from_attributes([])
-        end
-
-        begin
-          q.search(@type, @query, search_args) do |item|
-            formatted_item = {}
-            if config[:id_only]
-              formatted_item = format_for_display({ "id" => item["__display_name"] })
-            elsif item.is_a?(Hash)
-              # doing a little magic here to set the correct name
-              formatted_item[item["__display_name"]] = item.reject { |k| k == "__display_name" }
-            else
-              formatted_item = format_for_display(item)
-            end
-            result_items << formatted_item
-            result_count += 1
-          end
-        rescue Net::HTTPClientException => e
-          msg = Chef::JSONCompat.from_json(e.response.body)["error"].first
-          ui.error("knife search failed: #{msg}")
-          exit 99
-        end
-
-        if ui.interchange?
-          output({ results: result_count, rows: result_items })
-        else
-          ui.log "#{result_count} items found"
-          ui.log("\n")
-          result_items.each do |item|
-            output(item)
-            unless config[:id_only]
-              ui.msg("\n")
-            end
-          end
-        end
-
-        # return a "failure" code to the shell so that knife search can be used in pipes similar to grep
-        exit 1 if result_count == 0
-      end
-
-      def read_cli_args
-        if config[:query]
-          if @name_args[1]
-            ui.error "Please specify query as an argument or an option via -q, not both"
-            ui.msg opt_parser
-            exit 1
-          end
-          @type = name_args[0]
-          @query = config[:query]
-        else
-          case name_args.size
-          when 0
-            ui.error "No query specified"
-            ui.msg opt_parser
-            exit 1
-          when 1
-            @type = "node"
-            @query = name_args[0]
-          when 2
-            @type = name_args[0]
-            @query = name_args[1]
-          end
-        end
-      end
-
-      # This method turns a set of key value pairs in a string into the appropriate data structure that the
-      # chef-server search api is expecting.
-      # expected input is in the form of:
-      # -f "return_var1=path.to.attribute, return_var2=shorter.path"
-      #
-      # a more concrete example might be:
-      # -f "env=chef_environment, ruby_platform=languages.ruby.platform"
-      #
-      # The end result is a hash where the key is a symbol in the hash (the return variable)
-      # and the path is an array with the path elements as strings (in order)
-      # See lib/chef/search/query.rb for more examples of this.
-      def create_result_filter(filter_string)
-        final_filter = {}
-        filter_string.delete!(" ")
-        filters = filter_string.split(",")
-        filters.each do |f|
-          return_id, attr_path = f.split("=")
-          final_filter[return_id.to_sym] = attr_path.split(".")
-        end
-        final_filter
-      end
-
-      def create_result_filter_from_attributes(filter_array)
-        final_filter = {}
-        filter_array.each do |f|
-          final_filter[f] = f.split(".")
-        end
-        # adding magic filter so we can actually pull the name as before
-        final_filter["__display_name"] = [ "name" ]
-        final_filter
-      end
-
-    end
-  end
-end
+#
+# 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"
+require_relative "core/node_presenter"
+require_relative "core/formatting_options"
+
+class Chef
+  class Knife
+    class Search < Knife
+
+      include Knife::Core::MultiAttributeReturnOption
+
+      deps do
+        require "chef/node" unless defined?(Chef::Node)
+        require "chef/environment" unless defined?(Chef::Environment)
+        require "chef/api_client"  unless defined?(Chef::APIClient)
+        require "chef/search/query" unless defined?(Chef::Search::Query)
+      end
+
+      include Knife::Core::FormattingOptions
+
+      banner "knife search INDEX QUERY (options)"
+
+      option :start,
+        short: "-b ROW",
+        long: "--start ROW",
+        description: "The row to start returning results at.",
+        default: 0,
+        proc: lambda { |i| i.to_i }
+
+      option :rows,
+        short: "-R INT",
+        long: "--rows INT",
+        description: "The number of rows to return.",
+        default: nil,
+        proc: lambda { |i| i.to_i }
+
+      option :run_list,
+        short: "-r",
+        long: "--run-list",
+        description: "Show only the run list."
+
+      option :id_only,
+        short: "-i",
+        long: "--id-only",
+        description: "Show only the ID of matching objects."
+
+      option :query,
+        short: "-q QUERY",
+        long: "--query QUERY",
+        description: "The search query; useful to protect queries starting with -."
+
+      option :filter_result,
+        short: "-f FILTER",
+        long: "--filter-result FILTER",
+        description: "Only return specific attributes of the matching objects; for example: \"ServerName=name, Kernel=kernel.version\"."
+
+      def run
+        read_cli_args
+
+        if @type == "node"
+          ui.use_presenter Knife::Core::NodePresenter
+        end
+
+        q = Chef::Search::Query.new
+
+        result_items = []
+        result_count = 0
+
+        search_args = {}
+        search_args[:fuzz] = true
+        search_args[:start] = config[:start] if config[:start]
+        search_args[:rows] = config[:rows] if config[:rows]
+        if config[:filter_result]
+          search_args[:filter_result] = create_result_filter(config[:filter_result])
+        elsif (not ui.config[:attribute].nil?) && (not ui.config[:attribute].empty?)
+          search_args[:filter_result] = create_result_filter_from_attributes(ui.config[:attribute])
+        elsif config[:id_only]
+          search_args[:filter_result] = create_result_filter_from_attributes([])
+        end
+
+        begin
+          q.search(@type, @query, search_args) do |item|
+            formatted_item = {}
+            if config[:id_only]
+              formatted_item = format_for_display({ "id" => item["__display_name"] })
+            elsif item.is_a?(Hash)
+              # doing a little magic here to set the correct name
+              formatted_item[item["__display_name"]] = item.reject { |k| k == "__display_name" }
+            else
+              formatted_item = format_for_display(item)
+            end
+            result_items << formatted_item
+            result_count += 1
+          end
+        rescue Net::HTTPClientException => e
+          msg = Chef::JSONCompat.from_json(e.response.body)["error"].first
+          ui.error("knife search failed: #{msg}")
+          exit 99
+        end
+
+        if ui.interchange?
+          output({ results: result_count, rows: result_items })
+        else
+          ui.log "#{result_count} items found"
+          ui.log("\n")
+          result_items.each do |item|
+            output(item)
+            unless config[:id_only]
+              ui.msg("\n")
+            end
+          end
+        end
+
+        # return a "failure" code to the shell so that knife search can be used in pipes similar to grep
+        exit 1 if result_count == 0
+      end
+
+      def read_cli_args
+        if config[:query]
+          if @name_args[1]
+            ui.error "Please specify query as an argument or an option via -q, not both"
+            ui.msg opt_parser
+            exit 1
+          end
+          @type = name_args[0]
+          @query = config[:query]
+        else
+          case name_args.size
+          when 0
+            ui.error "No query specified"
+            ui.msg opt_parser
+            exit 1
+          when 1
+            @type = "node"
+            @query = name_args[0]
+          when 2
+            @type = name_args[0]
+            @query = name_args[1]
+          end
+        end
+      end
+
+      # This method turns a set of key value pairs in a string into the appropriate data structure that the
+      # chef-server search api is expecting.
+      # expected input is in the form of:
+      # -f "return_var1=path.to.attribute, return_var2=shorter.path"
+      #
+      # a more concrete example might be:
+      # -f "env=chef_environment, ruby_platform=languages.ruby.platform"
+      #
+      # The end result is a hash where the key is a symbol in the hash (the return variable)
+      # and the path is an array with the path elements as strings (in order)
+      # See lib/chef/search/query.rb for more examples of this.
+      def create_result_filter(filter_string)
+        final_filter = {}
+        filter_string.delete!(" ")
+        filters = filter_string.split(",")
+        filters.each do |f|
+          return_id, attr_path = f.split("=")
+          final_filter[return_id.to_sym] = attr_path.split(".")
+        end
+        final_filter
+      end
+
+      def create_result_filter_from_attributes(filter_array)
+        final_filter = {}
+        filter_array.each do |f|
+          final_filter[f] = f.split(".")
+        end
+        # adding magic filter so we can actually pull the name as before
+        final_filter["__display_name"] = [ "name" ]
+        final_filter
+      end
+
+    end
+  end
+end

data/lib/chef/knife/serve.rb

@@ -1,65 +1,65 @@
-#
-# 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 "local_mode" unless defined?(Chef::LocalMode)
-require "chef-utils/dist" unless defined?(ChefUtils::Dist)
-
-class Chef
-  class Knife
-    class Serve < Knife
-
-      banner "knife serve (options)"
-
-      option :repo_mode,
-        long: "--repo-mode MODE",
-        description: "Specifies the local repository layout. Values: static (only environments/roles/data_bags/cookbooks), everything (includes nodes/clients/users), hosted_everything (includes acls/groups/etc. for Enterprise/Hosted Chef). Default: everything/hosted_everything."
-
-      option :chef_repo_path,
-        long: "--chef-repo-path PATH",
-        description: "Overrides the location of #{ChefUtils::Dist::Infra::PRODUCT} repo. Default is specified by chef_repo_path in the config."
-
-      option :chef_zero_host,
-        long: "--chef-zero-host IP",
-        description: "Overrides the host upon which #{ChefUtils::Dist::Zero::PRODUCT} listens. Default is 127.0.0.1."
-
-      def configure_chef
-        super
-        Chef::Config.local_mode = true
-        Chef::Config[:repo_mode] = config[:repo_mode] if config[:repo_mode]
-
-        # --chef-repo-path forcibly overrides all other paths
-        if config[:chef_repo_path]
-          Chef::Config.chef_repo_path = config[:chef_repo_path]
-          %w{acl client cookbook container data_bag environment group node role user}.each do |variable_name|
-            Chef::Config.delete("#{variable_name}_path".to_sym)
-          end
-        end
-      end
-
-      def run
-        server = Chef::LocalMode.chef_zero_server
-        begin
-          output "Serving files from:\n#{Chef::LocalMode.chef_fs.fs_description}"
-          server.stop
-          server.start(stdout) # to print header
-        ensure
-          server.stop
-        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 "../knife"
+require "local_mode" unless defined?(Chef::LocalMode)
+require "chef-utils/dist" unless defined?(ChefUtils::Dist)
+
+class Chef
+  class Knife
+    class Serve < Knife
+
+      banner "knife serve (options)"
+
+      option :repo_mode,
+        long: "--repo-mode MODE",
+        description: "Specifies the local repository layout. Values: static (only environments/roles/data_bags/cookbooks), everything (includes nodes/clients/users), hosted_everything (includes acls/groups/etc. for Enterprise/Hosted Chef). Default: everything/hosted_everything."
+
+      option :chef_repo_path,
+        long: "--chef-repo-path PATH",
+        description: "Overrides the location of #{ChefUtils::Dist::Infra::PRODUCT} repo. Default is specified by chef_repo_path in the config."
+
+      option :chef_zero_host,
+        long: "--chef-zero-host IP",
+        description: "Overrides the host upon which #{ChefUtils::Dist::Zero::PRODUCT} listens. Default is 127.0.0.1."
+
+      def configure_chef
+        super
+        Chef::Config.local_mode = true
+        Chef::Config[:repo_mode] = config[:repo_mode] if config[:repo_mode]
+
+        # --chef-repo-path forcibly overrides all other paths
+        if config[:chef_repo_path]
+          Chef::Config.chef_repo_path = config[:chef_repo_path]
+          %w{acl client cookbook container data_bag environment group node role user}.each do |variable_name|
+            Chef::Config.delete("#{variable_name}_path".to_sym)
+          end
+        end
+      end
+
+      def run
+        server = Chef::LocalMode.chef_zero_server
+        begin
+          output "Serving files from:\n#{Chef::LocalMode.chef_fs.fs_description}"
+          server.stop
+          server.start(stdout) # to print header
+        ensure
+          server.stop
+        end
+      end
+    end
+  end
+end

data/lib/chef/knife/show.rb

@@ -1,72 +1,72 @@
-#
-# 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 Show < Chef::ChefFS::Knife
-      banner "knife show [PATTERN1 ... PATTERNn] (options)"
-
-      category "path-based"
-
-      deps do
-        require "chef/chef_fs/file_system" unless defined?(Chef::ChefFS::FileSystem)
-        require "chef/chef_fs/file_system/exceptions" unless defined?(Chef::ChefFS::FileSystem::Exceptions)
-      end
-
-      option :local,
-        long: "--local",
-        boolean: true,
-        description: "Show local files instead of remote."
-
-      def run
-        # Get the matches (recursively)
-        error = false
-        entry_values = parallelize(pattern_args) do |pattern|
-          parallelize(Chef::ChefFS::FileSystem.list(config[:local] ? local_fs : chef_fs, pattern)) do |entry|
-            if entry.dir?
-              ui.error "#{format_path(entry)}: is a directory" if pattern.exact_path
-              error = true
-              nil
-            else
-              begin
-                [entry, entry.read]
-              rescue Chef::ChefFS::FileSystem::OperationNotAllowedError => e
-                ui.error "#{format_path(e.entry)}: #{e.reason}."
-                error = true
-                nil
-              rescue Chef::ChefFS::FileSystem::NotFoundError => e
-                ui.error "#{format_path(e.entry)}: No such file or directory"
-                error = true
-                nil
-              end
-            end
-          end
-        end.flatten(1)
-        entry_values.each do |entry, value|
-          if entry
-            output "#{format_path(entry)}:"
-            output(format_for_display(value))
-          end
-        end
-        if error
-          exit 1
-        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"
+
+class Chef
+  class Knife
+    class Show < Chef::ChefFS::Knife
+      banner "knife show [PATTERN1 ... PATTERNn] (options)"
+
+      category "path-based"
+
+      deps do
+        require "chef/chef_fs/file_system" unless defined?(Chef::ChefFS::FileSystem)
+        require "chef/chef_fs/file_system/exceptions" unless defined?(Chef::ChefFS::FileSystem::Exceptions)
+      end
+
+      option :local,
+        long: "--local",
+        boolean: true,
+        description: "Show local files instead of remote."
+
+      def run
+        # Get the matches (recursively)
+        error = false
+        entry_values = parallelize(pattern_args) do |pattern|
+          parallelize(Chef::ChefFS::FileSystem.list(config[:local] ? local_fs : chef_fs, pattern)) do |entry|
+            if entry.dir?
+              ui.error "#{format_path(entry)}: is a directory" if pattern.exact_path
+              error = true
+              nil
+            else
+              begin
+                [entry, entry.read]
+              rescue Chef::ChefFS::FileSystem::OperationNotAllowedError => e
+                ui.error "#{format_path(e.entry)}: #{e.reason}."
+                error = true
+                nil
+              rescue Chef::ChefFS::FileSystem::NotFoundError => e
+                ui.error "#{format_path(e.entry)}: No such file or directory"
+                error = true
+                nil
+              end
+            end
+          end
+        end.flatten(1)
+        entry_values.each do |entry, value|
+          if entry
+            output "#{format_path(entry)}:"
+            output(format_for_display(value))
+          end
+        end
+        if error
+          exit 1
+        end
+      end
+    end
+  end
+end