chef 0.9.6 → 0.9.8.beta.1

data/lib/chef/couchdb.rb

@@ -232,17 +232,7 @@ class Chef
     end
     
     def view_uri(design, view)
-      Chef::Config[:couchdb_version] ||= @rest.run_request(:GET,
-                                                           URI.parse(@rest.url + "/"),
-                                                           {},
-                                                           10,
-                                                           false)["version"].gsub(/-.+/,"").to_f
-      case Chef::Config[:couchdb_version]
-      when 0.8
-        "#{couchdb_database}/_view/#{design}/#{view}"
-      else
-        "#{couchdb_database}/_design/#{design}/_view/#{view}"
-      end
+      "#{couchdb_database}/_design/#{design}/_view/#{view}"
     end
     
   end

data/lib/chef/exceptions.rb

@@ -30,6 +30,7 @@ class Chef
     class UnsupportedAction < RuntimeError; end
     class MissingLibrary < RuntimeError; end
     class MissingRole < RuntimeError; end
+    class CannotDetermineNodeName < RuntimeError; end
     class User < RuntimeError; end
     class Group < RuntimeError; end
     class Link < RuntimeError; end

data/lib/chef/file_access_control.rb

@@ -25,7 +25,7 @@ class Chef
   # the values specified by a value object, usually a Chef::Resource.
   class FileAccessControl
     UINT = (1 << 32)
-    UID_MAX = (1 << 30)
+    UID_MAX = (1 << 31)
   
     attr_reader :resource
   

data/lib/chef/index_queue/amqp_client.rb

@@ -68,17 +68,24 @@ class Chef
       end
       
       def disconnected!
+        Chef::Log.error("Disconnected from the AMQP Broker (RabbitMQ)")
         @amqp_client = nil
         reset!
       end
 
       def send_action(action, data)
+        retries = 0
         begin
           exchange.publish({"action" => action.to_s, "payload" => data}.to_json)
-        rescue Bunny::ServerDownError, Bunny::ConnectionError, Errno::ECONNRESET => e
-          Chef::Log.error("Disconnected from the AMQP Broker, cannot queue data to the indexer")
+        rescue Bunny::ServerDownError, Bunny::ConnectionError, Errno::ECONNRESET
           disconnected!
-          raise e
+          if (retries += 1) < 2
+            Chef::Log.info("Attempting to reconnect to the AMQP broker")
+            retry
+          else
+            Chef::Log.fatal("Could not re-connect to the AMQP broker, giving up")
+            raise
+          end
         end
       end
 

data/lib/chef/knife.rb

@@ -17,6 +17,7 @@
 # limitations under the License.
 #
 
+require 'chef/version'
 require 'mixlib/cli'
 require 'chef/mixin/convert_to_class_name'
 
@@ -27,75 +28,166 @@ class Chef
     include Mixlib::CLI
     extend Chef::Mixin::ConvertToClassName
 
+    # The "require paths" of the core knife subcommands bundled with chef
+    DEFAULT_SUBCOMMAND_FILES = Dir[File.expand_path(File.join(File.dirname(__FILE__), 'knife', '*.rb'))]
+    DEFAULT_SUBCOMMAND_FILES.map! { |knife_file| knife_file[/#{CHEF_ROOT}#{Regexp.escape(File::SEPARATOR)}(.*)\.rb/,1] }
+
     attr_accessor :name_args
 
-    # Load all the sub-commands
-    def self.load_commands
-      @sub_classes = Hash.new
-      Dir[
-        File.expand_path(File.join(File.dirname(__FILE__), 'knife', '*.rb'))
-      ].each do |knife_file|
-        require knife_file
-        snake_case_file_name = File.basename(knife_file).sub(/\.rb$/, '')
-        @sub_classes[snake_case_file_name] = convert_to_class_name(snake_case_file_name)
+    def self.msg(msg="")
+      puts msg
+    end
+
+    def self.inherited(subclass)
+      unless subclass.unnamed?
+        subcommands[subclass.snake_case_name] = subclass
       end
-      @sub_classes
     end
 
-    def self.list_commands
-      load_commands
-      @sub_classes.keys.sort.each do |snake_case|
-        klass_instance = build_sub_class(snake_case) 
-        klass_instance.parse_options([])
-        puts klass_instance.opt_parser
-        puts
+    # Explicitly set the category for the current command to +new_category+
+    # The category is normally determined from the first word of the command
+    # name, but some commands make more sense using two or more words
+    # ===Arguments
+    # new_category::: A String to set the category to (see examples)
+    # ===Examples:
+    # Data bag commands would be in the 'data' category by default. To put them
+    # in the 'data bag' category:
+    #   category('data bag')
+    def self.category(new_category)
+      @category = new_category
+    end
+
+    def self.subcommand_category
+      @category || snake_case_name.split('_').first unless unnamed?
+    end
+
+    def self.snake_case_name
+      convert_to_snake_case(name.split('::').last) unless unnamed?
+    end
+
+    # Does this class have a name? (Classes created via Class.new don't)
+    def self.unnamed?
+      name.nil? || name.empty?
+    end
+
+    def self.subcommands
+      @@subcommands ||= {}
+    end
+
+    def self.subcommands_by_category
+      unless @subcommands_by_category
+        @subcommands_by_category = Hash.new { |hash, key| hash[key] = [] }
+        subcommands.each do |snake_cased, klass|
+          @subcommands_by_category[klass.subcommand_category] << snake_cased
+        end
       end
+      @subcommands_by_category
     end
 
-    def self.build_sub_class(snake_case, merge_opts=nil)
-      klass = Chef::Knife.const_get(@sub_classes[snake_case])
-      klass.options.merge!(merge_opts) if merge_opts 
-      klass.new
+    # Load all the sub-commands
+    def self.load_commands
+      DEFAULT_SUBCOMMAND_FILES.each { |subcommand| require subcommand }
+      subcommands
     end
 
-    def self.find_command(args=ARGV, merge_opts={})
+    # Print the list of subcommands knife knows about. If +preferred_category+
+    # is given, only subcommands in that category are shown
+    def self.list_commands(preferred_category=nil)
       load_commands
+      category_desc = preferred_category ? preferred_category + " " : ''
+      msg "Available #{category_desc}subcommands: (for details, knife SUB-COMMAND --help)\n\n"
 
-      non_dash_args = Array.new
-      args.each do |arg|
-        non_dash_args << arg if arg =~ /^([[:alnum:]]|_)+$/
+      if preferred_category && subcommands_by_category.key?(preferred_category)
+        commands_to_show = {preferred_category => subcommands_by_category[preferred_category]}
+      else
+        commands_to_show = subcommands_by_category
       end
 
-      to_try = non_dash_args.length 
-      klass_instance = nil
-      cli_bits = nil 
+      commands_to_show.sort.each do |category, commands|
+        msg "** #{category.upcase} COMMANDS **"
+        commands.each do |command|
+          msg subcommands[command].banner if subcommands[command]
+        end
+        msg
+      end
+    end
 
-      while(to_try >= 0)
-        cli_bits = non_dash_args[0..to_try]
-        snake_case_class_name = cli_bits.join("_")
+    # Run knife for the given +args+ (ARGV), adding +options+ to the list of
+    # CLI options that the subcommand knows how to handle.
+    # ===Arguments
+    # args::: usually ARGV
+    # options::: A Mixlib::CLI option parser hash. These +options+ are how
+    # subcommands know about global knife CLI options
+    def self.run(args, options={})
+      load_commands
+      subcommand_class = subcommand_class_from(args)
+      subcommand_class.options.merge!(options)
+      instance = subcommand_class.new(args)
+      instance.configure_chef
+      instance.run
+    end
 
-        if @sub_classes.has_key?(snake_case_class_name)
-          klass_instance = build_sub_class(snake_case_class_name, merge_opts)
-          break
-        end
+    def self.guess_category(args)
+      category_words = args.select {|arg| arg =~ /^([[:alnum:]]|_)+$/ }
+      matching_category = nil
+      while (!matching_category) && (!category_words.empty?)
+        candidate_category = category_words.join(' ')
+        matching_category = candidate_category if subcommands_by_category.key?(candidate_category)
+        matching_category || category_words.pop
+      end
+      matching_category
+    end
 
-        to_try = to_try - 1
+    def self.subcommand_class_from(args)
+      command_words = args.select {|arg| arg =~ /^([[:alnum:]]|_)+$/ }
+      subcommand_class = nil
+
+      while ( !subcommand_class ) && ( !command_words.empty? )
+        snake_case_class_name = command_words.join("_")
+        unless subcommand_class = subcommands[snake_case_class_name]
+          command_words.pop
+        end
       end
+      subcommand_class || subcommand_not_found!(args)
+    end
 
-      unless klass_instance
-        Chef::Log.fatal("Cannot find sub command for: #{args.join(' ')}")
-        Chef::Knife.list_commands
-        exit 10
+    private
+
+    # :nodoc:
+    # Error out and print usage. probably becuase the arguments given by the
+    # user could not be resolved to a subcommand.
+    def self.subcommand_not_found!(args)
+      unless want_help?(args)
+        Chef::Log.fatal("Cannot find sub command for: '#{args.join(' ')}'")
       end
+      Chef::Knife.list_commands(guess_category(args))
+      exit 10
+    end
 
-      extra = klass_instance.parse_options(args)
-      if klass_instance.config[:help]
-        puts klass_instance.opt_parser
+    # :nodoc:
+    # TODO: duplicated with chef/application/knife
+    # all logic should be removed from that and Chef::Knife should own it.
+    def self.want_help?(args)
+      (args.any? { |arg| arg =~ /^(:?(:?\-\-)?help|\-h)$/})
+    end
+
+    public
+
+    # Create a new instance of the current class configured for the given
+    # arguments and options
+    def initialize(argv=[])
+      super() # having to call super in initialize is the most annoying anti-pattern :(
+
+      command_name_words = self.class.snake_case_name.split('_')
+
+      # Mixlib::CLI ignores the embedded name_args
+      @name_args = parse_options(argv)
+      @name_args.reject! { |name_arg| command_name_words.delete(name_arg) }
+
+      if config[:help]
+        msg opt_parser
         exit 1
       end
-      klass_instance.name_args = extra.inject([]) { |c, i| cli_bits.include?(i) ? cli_bits.delete(i) : c << i; c } 
-      klass_instance.configure_chef
-      klass_instance
     end
 
     def parse_options(args)
@@ -141,7 +233,7 @@ class Chef
         Chef::Config.from_file(config[:config_file])
       else
         # ...but do log a message if no config was found.
-        Chef::Log.info("No knife configuration file found")
+        self.msg("No knife configuration file found")
       end
 
       Chef::Config[:log_level] = config[:log_level] if config[:log_level]
@@ -201,7 +293,7 @@ class Chef
             data = data.send(attr.to_sym)
           end
         end
-        { config[:attribute] => data.kind_of?(Chef::Node::Attribute) ? data.to_hash: data }
+        { config[:attribute] => data.kind_of?(Chef::Node::Attribute) ? data.to_hash : data }
       elsif config[:run_list]
         data = data.run_list.run_list
         { "run_list" => data }
@@ -237,19 +329,19 @@ class Chef
     def confirm(question, append_instructions=true)
       return true if config[:yes]
 
-      print question
-      print "? (Y/N) " if append_instructions
+      stdout.print question
+      stdout.print "? (Y/N) " if append_instructions
       answer = stdin.readline
       answer.chomp!
       case answer
       when "Y", "y"
         true
       when "N", "n"
-        Chef::Log.info("You said no, so I'm done here.")
+        self.msg("You said no, so I'm done here.")
         exit 3 
       else
-        Chef::Log.error("I have no idea what to do with #{answer}")
-        Chef::Log.error("Just say Y or N, please.")
+        self.msg("I have no idea what to do with #{answer}")
+        self.msg("Just say Y or N, please.")
         confirm(question)
       end
     end
@@ -304,7 +396,7 @@ class Chef
       
       output.save
 
-      Chef::Log.info("Saved #{output}")
+      self.msg("Saved #{output}")
 
       output(format_for_display(object)) if config[:print_after]
     end
@@ -320,7 +412,7 @@ class Chef
 
       pretty_name ||= output
 
-      Chef::Log.info("Created (or updated) #{pretty_name}")
+      self.msg("Created (or updated) #{pretty_name}")
       
       output(output) if config[:print_after]
     end
@@ -338,7 +430,7 @@ class Chef
       output(format_for_display(object)) if config[:print_after]
 
       obj_name = delete_name ? "#{delete_name}[#{name}]" : object
-      Chef::Log.warn("Deleted #{obj_name}!")
+      self.msg("Deleted #{obj_name}!")
     end
 
     def bulk_delete(klass, fancy_name, delete_name=nil, list=nil, regex=nil, &block)
@@ -365,10 +457,14 @@ class Chef
           object.destroy
         end
         output(format_for_display(object)) if config[:print_after]
-        Chef::Log.warn("Deleted #{fancy_name} #{name}")
+        self.msg("Deleted #{fancy_name} #{name}")
       end
     end
-    
+
+    def msg(message)
+      stdout.puts message
+    end
+
     def stdout
       STDOUT
     end

data/lib/chef/knife/bootstrap.rb

@@ -19,12 +19,13 @@
 require 'chef/knife'
 require 'json'
 require 'tempfile'
+require 'erubis'
 
 class Chef
   class Knife
     class Bootstrap < Knife
 
-      banner "Sub-Command: knife bootstrap FQDN [RUN LIST...] (options)"
+      banner "knife bootstrap FQDN [RUN LIST...] (options)"
 
       option :ssh_user,
         :short => "-x USERNAME",
@@ -37,6 +38,11 @@ class Chef
         :long => "--ssh-password PASSWORD",
         :description => "The ssh password"
 
+      option :identity_file,
+        :short => "-i IDENTITY_FILE",
+        :long => "--identity-file IDENTITY_FILE",
+        :description => "The SSH identity file used for authentication"
+
       option :chef_node_name,
         :short => "-N NAME",
         :long => "--node-name NAME",
@@ -46,67 +52,97 @@ class Chef
         :long => "--prerelease",
         :description => "Install the pre-release chef gems"
 
+      option :distro,
+        :short => "-d DISTRO",
+        :long => "--distro DISTRO",
+        :description => "Bootstrap a distro using a template",
+        :default => "ubuntu10.04-gems"
+
+      option :identity_file,
+        :short => "-i IDENTITY_FILE",
+        :long => "--identity-file IDENTITY_FILE",
+        :description => "The SSH identity file used for authentication"
+
+      option :use_sudo,
+        :short => "-s",
+        :long => "--sudo",
+        :description => "Execute the bootstrap via sudo",
+        :boolean => true
+
+      option :template_file,
+        :long => "--template-file TEMPLATE",
+        :description => "Full path to location of template to use",
+        :default => false
+
+      option :run_list,
+        :short => "-r RUN_LIST",
+        :long => "--run-list RUN_LIST",
+        :description => "Comma separated list of roles/recipes to apply",
+        :proc => lambda { |o| o.split(",") },
+        :default => nil
 
       def h
         @highline ||= HighLine.new
       end
 
+      def load_template(template=nil)
+        # Are we bootstrapping using an already shipped template?
+        if config[:template_file]
+          bootstrap_files = config[:template_file]
+        else
+          bootstrap_files = []
+          bootstrap_files << File.join(File.dirname(__FILE__), 'bootstrap', "#{config[:distro]}.erb")
+          bootstrap_files << File.join(Dir.pwd, ".chef", "bootstrap", "#{config[:distro]}.erb")
+          bootstrap_files << File.join(ENV['HOME'], '.chef', 'bootstrap', "#{config[:distro]}.erb")
+        end
+
+        template = Array(bootstrap_files).find do |bootstrap_template|
+          Chef::Log.debug("Looking for bootstrap template in #{File.dirname(bootstrap_template)}")
+          File.exists?(bootstrap_template)
+        end
+
+        unless template
+          Chef::Log.info("Can not find bootstrap definition for #{config[:distro]}")
+          raise Errno::ENOENT
+        end
+
+        Chef::Log.debug("Found bootstrap template in #{File.dirname(template)}")
+        
+        IO.read(template).chomp
+      end
+
+      def render_template(template=nil)
+        context = {}
+        context[:run_list] = config[:run_list]
+        context[:config] = config
+        command = Erubis::Eruby.new(template).evaluate(context)
+      end
+
       def run 
         require 'highline'
 
-        server_name = @name_args[0]
+        if @name_args.first == nil
+          Chef::Log.error("Must pass a node name/ip to bootstrap")
+          exit 1
+        end
 
-        puts "Bootstrapping Chef on #{h.color(server_name, :bold)}"
+        config[:server_name] = @name_args.first
 
         $stdout.sync = true
 
-        command =  <<EOH
-bash -c '
-if [ ! -f /usr/bin/chef-client ]; then
-  apt-get update
-  apt-get install -y ruby ruby1.8-dev build-essential wget libruby-extras libruby1.8-extras
-  cd /tmp
-  wget http://rubyforge.org/frs/download.php/69365/rubygems-1.3.6.tgz
-  tar xvf rubygems-1.3.6.tgz
-  cd rubygems-1.3.6
-  ruby setup.rb
-  cp /usr/bin/gem1.8 /usr/bin/gem
-  gem install ohai chef --no-rdoc --no-ri --verbose #{"--prerelease" if config[:prerelease]}
-fi
-
-mkdir -p /etc/chef
-
-(
-cat <<'EOP'
-#{IO.read(Chef::Config[:validation_key])}
-EOP
-) > /tmp/validation.pem
-awk NF /tmp/validation.pem > /etc/chef/validation.pem
-rm /tmp/validation.pem
-
-(
-cat <<'EOP'
-log_level        :info
-log_location     STDOUT
-chef_server_url  "#{Chef::Config[:chef_server_url]}" 
-validation_client_name "#{Chef::Config[:validation_client_name]}"
-#{config[:chef_node_name] == nil ? "# Using default node name" : "node_name \"#{config[:chef_node_name]}\""} 
-EOP
-) > /etc/chef/client.rb
-
-(
-cat <<'EOP'
-#{{ "run_list" => @name_args[1..-1] }.to_json}
-EOP
-) > /etc/chef/first-boot.json
-
-/usr/bin/chef-client -j /etc/chef/first-boot.json'
-EOH
+        command = render_template(load_template(config[:bootstrap_template]))
+
+        if config[:use_sudo]
+          command = "sudo #{command}"
+        end
+
+        Chef::Log.info("Bootstrapping Chef on #{h.color(config[:server_name], :bold)}")
 
         ssh = Chef::Knife::Ssh.new
-        ssh.name_args = [ server_name, "sudo #{command}" ]
+        ssh.name_args = [ config[:server_name], command ]
         ssh.config[:ssh_user] = config[:ssh_user] 
         ssh.config[:password] = config[:ssh_password]
+        ssh.config[:identity_file] = config[:identity_file]
         ssh.config[:manual] = true
 
         begin
@@ -115,15 +151,15 @@ EOH
           unless config[:ssh_password]
             puts "Failed to authenticate #{config[:ssh_user]} - trying password auth"
             ssh = Chef::Knife::Ssh.new
-            ssh.name_args = [ server_name, "sudo #{command}" ]
+            ssh.name_args = [ config[:server_name], command ]
             ssh.config[:ssh_user] = config[:ssh_user] 
             ssh.config[:manual] = true
             ssh.config[:password] = ssh.get_password
             ssh.run
           end
         end
-
       end
+
     end
   end
 end