chef 10.34.6-x86-mingw32 → 11.6.2-x86-mingw32

data/lib/chef/knife/node_show.rb

@@ -24,6 +24,7 @@ class Chef
     class NodeShow < Knife
 
       include Knife::Core::NodeFormattingOptions
+      include Knife::Core::MultiAttributeReturnOption
 
       deps do
         require 'chef/node'
@@ -32,13 +33,6 @@ class Chef
 
       banner "knife node show NODE (options)"
 
-      @attrs_to_show = []
-      option :attribute,
-        :short => "-a [ATTR]",
-        :long => "--attribute [ATTR]",
-        :proc => lambda {|val| @attrs_to_show << val},
-        :description => "Show one or more attributes"
-
       option :run_list,
         :short => "-r",
         :long => "--run-list",

data/lib/chef/knife/raw.rb

@@ -0,0 +1,64 @@
+require 'chef/knife'
+
+class Chef
+  class Knife
+    class Raw < Chef::Knife
+      banner "knife raw REQUEST_PATH"
+
+      deps do
+        require 'json'
+        require 'chef/rest'
+        require 'chef/config'
+        require 'chef/chef_fs/raw_request'
+      end
+
+      option :method,
+        :long => '--method METHOD',
+        :short => '-m METHOD',
+        :default => "GET",
+        :description => "Request method (GET, POST, PUT or DELETE).  Default: GET"
+
+      option :pretty,
+        :long => '--[no-]pretty',
+        :boolean => true,
+        :default => true,
+        :description => "Pretty-print JSON output.  Default: true"
+
+      option :input,
+        :long => '--input FILE',
+        :short => '-i FILE',
+        :description => "Name of file to use for PUT or POST"
+
+      def run
+        if name_args.length == 0
+          show_usage
+          ui.fatal("You must provide the path you want to hit on the server")
+          exit(1)
+        elsif name_args.length > 1
+          show_usage
+          ui.fatal("Only one path accepted for knife raw")
+          exit(1)
+        end
+
+        path = name_args[0]
+        data = false
+        if config[:input]
+          data = IO.read(config[:input])
+        end
+        chef_rest = Chef::REST.new(Chef::Config[:chef_server_url])
+        begin
+          output Chef::ChefFS::RawRequest.api_request(chef_rest, config[:method].to_sym, chef_rest.create_url(name_args[0]), {}, data)
+        rescue Timeout::Error => e
+          ui.error "Server timeout"
+          exit 1
+        rescue Net::HTTPServerException => e
+          ui.error "Server responded with error #{e.response.code} \"#{e.response.message}\""
+          ui.error "Error Body: #{e.response.body}" if e.response.body && e.response.body != ''
+          exit 1
+        end
+      end
+
+    end # class Raw
+  end
+end
+

data/lib/chef/knife/role_show.rb

@@ -22,6 +22,8 @@ class Chef
   class Knife
     class RoleShow < Knife
 
+      include Knife::Core::MultiAttributeReturnOption
+
       deps do
         require 'chef/node'
         require 'chef/json_compat'
@@ -29,10 +31,6 @@ class Chef
 
       banner "knife role show ROLE (options)"
 
-      option :attribute,
-        :short => "-a ATTR",
-        :long => "--attribute ATTR",
-        :description => "Show only one attribute"
 
       def run
         @role_name = @name_args[0]

data/lib/chef/knife/search.rb

@@ -23,6 +23,8 @@ class Chef
   class Knife
     class Search < Knife
 
+      include Knife::Core::MultiAttributeReturnOption
+
       deps do
         require 'chef/node'
         require 'chef/environment'
@@ -54,11 +56,6 @@ class Chef
         :default => 1000,
         :proc => lambda { |i| i.to_i }
 
-      option :attribute,
-        :short => "-a ATTR",
-        :long => "--attribute ATTR",
-        :description => "Show only one attribute"
-
       option :run_list,
         :short => "-r",
         :long => "--run-list",
@@ -75,30 +72,16 @@ class Chef
         :description => "The search query; useful to protect queries starting with -"
 
       def run
-        if config[:query] && @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
-        raw_query = config[:query] || @name_args[1]
-        if !raw_query || raw_query.empty?
-          ui.error "no query specified"
-          ui.msg opt_parser
-          exit 1
-        end
+        read_cli_args
+        fuzzify_query
 
-        if name_args[0].nil?
-          ui.error "you must specify an item type to search for"
-          exit 1
-        end
-
-        if name_args[0] == 'node'
+        if @type == 'node'
           ui.use_presenter Knife::Core::NodePresenter
         end
 
 
         q = Chef::Search::Query.new
-        query = URI.escape(raw_query,
+        escaped_query = URI.escape(@query,
                            Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
 
         result_items = []
@@ -107,11 +90,11 @@ class Chef
         rows = config[:rows]
         start = config[:start]
         begin
-          q.search(@name_args[0], query, config[:sort], start, rows) do |item|
+          q.search(@type, escaped_query, config[:sort], start, rows) do |item|
             formatted_item = format_for_display(item)
-            if formatted_item.respond_to?(:has_key?) && !formatted_item.has_key?('id')
-              formatted_item['id'] = item.has_key?('id') ? item['id'] : item.name
-            end
+            # if formatted_item.respond_to?(:has_key?) && !formatted_item.has_key?('id')
+            #   formatted_item['id'] = item.has_key?('id') ? item['id'] : item.name
+            # end
             result_items << formatted_item
             result_count += 1
           end
@@ -128,10 +111,44 @@ class Chef
           ui.msg("\n")
           result_items.each do |item|
             output(item)
-            ui.msg("\n")
+            unless config[:id_only]
+              ui.msg("\n")
+            end
           end
         end
       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
+
+      def fuzzify_query
+        if @query !~ /:/
+          @query = "tags:*#{@query}* OR roles:*#{@query}* OR fqdn:*#{@query}* OR addresses:*#{@query}*"
+        end
+      end
+
     end
   end
 end

data/lib/chef/knife/show.rb

@@ -0,0 +1,55 @@
+require 'chef/chef_fs/knife'
+
+class Chef
+  class Knife
+    class Show < Chef::ChefFS::Knife
+      banner "knife show [PATTERN1 ... PATTERNn]"
+
+      deps do
+        require 'chef/chef_fs/file_system'
+        require 'chef/chef_fs/file_system/not_found_error'
+      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, :flatten => true) 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
+        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
+

data/lib/chef/knife/ssh.rb

@@ -25,6 +25,7 @@ class Chef
       deps do
         require 'net/ssh'
         require 'net/ssh/multi'
+        require 'chef/monkey_patches/net-ssh-multi'
         require 'readline'
         require 'chef/exceptions'
         require 'chef/search/query'
@@ -80,6 +81,12 @@ class Chef
         :description => "The ssh gateway",
         :proc => Proc.new { |key| Chef::Config[:knife][:ssh_gateway] = key.strip }
 
+      option :forward_agent,
+        :short => "-A",
+        :long => "--forward-agent",
+        :description => "Enable SSH agent forwarding",
+        :boolean => true
+
       option :identity_file,
         :short => "-i IDENTITY_FILE",
         :long => "--identity-file IDENTITY_FILE",
@@ -146,9 +153,9 @@ class Chef
                    if !config[:override_attribute] && item[:cloud] and item[:cloud][:public_hostname]
                      i = item[:cloud][:public_hostname]
                    elsif config[:override_attribute]
-                     i = format_for_display(item)[config[:override_attribute]]
+                     i = extract_nested_value(item, config[:override_attribute])
                    else
-                     i = format_for_display(item)[config[:attribute]]
+                     i = extract_nested_value(item, config[:attribute])
                    end
                    # next if we couldn't find the specified attribute in the returned node object
                    next if i.nil?
@@ -182,6 +189,7 @@ class Chef
           session_opts[:keys] = File.expand_path(config[:identity_file]) if config[:identity_file]
           session_opts[:keys_only] = true if config[:identity_file]
           session_opts[:password] = config[:ssh_password] if config[:ssh_password]
+          session_opts[:forward_agent] = config[:forward_agent]
           session_opts[:port] = config[:ssh_port] || Chef::Config[:knife][:ssh_port] || ssh_config[:port]
           session_opts[:logger] = Chef::Log.logger if Chef::Log.level == :debug
 
@@ -415,6 +423,10 @@ class Chef
                              Chef::Config[:knife][:ssh_identity_file])
       end
 
+      def extract_nested_value(data_structure, path_spec)
+        ui.presenter.extract_nested_value(data_structure, path_spec)
+      end
+
       def run
         extend Chef::Mixin::Command
 

data/lib/chef/knife/upload.rb

@@ -0,0 +1,69 @@
+require 'chef/chef_fs/knife'
+
+class Chef
+  class Knife
+    class Upload < Chef::ChefFS::Knife
+      banner "knife upload PATTERNS"
+
+      deps do
+        require 'chef/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 upload of files even if they match (quicker for many files).  Will overwrite frozen cookbooks."
+
+      option :freeze,
+        :long => '--[no-]freeze',
+        :boolean => true,
+        :default => false,
+        :description => "Freeze cookbooks that get uploaded."
+
+      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 uploading existing files; only new (and possibly deleted) files with --no-diff'
+
+      def run
+        if name_args.length == 0
+          show_usage
+          ui.fatal("Must specify at least one argument.  If you want to upload everything in this directory, type \"knife upload .\"")
+          exit 1
+        end
+
+        error = false
+        pattern_args.each do |pattern|
+          if Chef::ChefFS::FileSystem.copy_to(pattern, local_fs, chef_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
+

data/lib/chef/knife/user_create.rb

@@ -0,0 +1,93 @@
+#
+# Author:: Steven Danna (<steve@opscode.com>)
+# Copyright:: Copyright (c) 2012 Opscode, 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 'chef/knife'
+
+class Chef
+  class Knife
+    class UserCreate < Knife
+
+      deps do
+        require 'chef/user'
+        require 'chef/json_compat'
+      end
+
+      option :file,
+        :short => "-f FILE",
+        :long  => "--file FILE",
+        :description => "Write the private key to a file"
+
+      option :admin,
+        :short => "-a",
+        :long  => "--admin",
+        :description => "Create the user as an admin",
+        :boolean => true
+
+      option :user_password,
+        :short => "-p PASSWORD",
+        :long => "--password PASSWORD",
+        :description => "Password for newly created user",
+        :default => ""
+
+      option :user_key,
+        :long => "--user-key FILENAME",
+        :description => "Public key for newly created user.  By default a key will be created for you."
+
+      banner "knife user create USER (options)"
+
+      def run
+        @user_name = @name_args[0]
+
+        if @user_name.nil?
+          show_usage
+          ui.fatal("You must specify a user name")
+          exit 1
+        end
+
+        if config[:user_password].length == 0
+          show_usage
+          ui.fatal("You must specify a non-blank password")
+          exit 1
+        end
+
+        user = Chef::User.new
+        user.name(@user_name)
+        user.admin(config[:admin])
+        user.password config[:user_password]
+
+        if config[:user_key]
+          user.public_key File.read(File.expand_path(config[:user_key]))
+        end
+
+        output = edit_data(user)
+        user = Chef::User.from_hash(output).create
+
+        ui.info("Created #{user}")
+        if user.private_key
+          if config[:file]
+            File.open(config[:file], "w") do |f|
+              f.print(user.private_key)
+            end
+          else
+            puts user.private_key
+          end
+        end
+      end
+    end
+  end
+end