chef 0.9.8.beta.1 → 0.9.8.beta.2

data/lib/chef/knife.rb

@@ -200,15 +200,24 @@ class Chef
 
     def ask_question(question, opts={})
       question = question + "[#{opts[:default]}] " if opts[:default]
-        
-      stdout.print question
-      a = stdin.readline.strip
 
-      if opts[:default]
-        a.empty? ? opts[:default] : a
+      if opts[:default] and config[:defaults]
+
+        opts[:default]
+
       else
-        a
+
+        stdout.print question
+        a = stdin.readline.strip
+
+        if opts[:default]
+          a.empty? ? opts[:default] : a
+        else
+          a
+        end
+
       end
+
     end
 
     def configure_chef

data/lib/chef/knife/bootstrap.rb

@@ -58,13 +58,7 @@ class Chef
         :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
@@ -79,7 +73,7 @@ class Chef
         :long => "--run-list RUN_LIST",
         :description => "Comma separated list of roles/recipes to apply",
         :proc => lambda { |o| o.split(",") },
-        :default => nil
+        :default => []
 
       def h
         @highline ||= HighLine.new

data/lib/chef/knife/bootstrap/ubuntu10.04-apt.erb

@@ -0,0 +1,32 @@
+bash -c '
+if [ ! -f /usr/bin/chef-client ]; then
+  echo "chef	chef/chef_server_url	string	<%= Chef::Config[:chef_server_url] %>" | debconf-set-selections 
+  [ -f /etc/apt/sources.list.d/opscode.list ] || echo "deb http://apt.opscode.com lucid main" > /etc/apt/sources.list.d/opscode.list
+  wget -O- http://apt.opscode.com/packages@opscode.com.gpg.key | apt-key add -
+  apt-get update
+  apt-get install -y chef
+fi
+
+<% unless Chef::Config[:validation_client_name] == "chef-validator" -%>
+[  `grep -qx "validation_client_name \"<%= Chef::Config[:validation_client_name] %>\"" /etc/chef/client.rb` ] || echo "validation_client_name \"<%= Chef::Config[:validation_client_name] %>\"" >> /etc/chef/client.rb
+<% end -%>
+
+(
+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
+
+<% if @config[:chef_node_name] %>
+[ `grep -qx "node_name \"<%= @config[:chef_node_name] %>\"" /etc/chef/client.rb` ] || echo "node_name \"<%= @config[:chef_node_name] %>\"" >> /etc/chef/client.rb
+<% end -%> 
+
+(
+cat <<'EOP'
+<%= { "run_list" => @run_list }.to_json %>
+EOP
+) > /etc/chef/first-boot.json
+
+/usr/bin/chef-client -j /etc/chef/first-boot.json'

data/lib/chef/knife/cookbook_create.rb

@@ -26,35 +26,57 @@ class Chef
     class CookbookCreate < Knife
       include Chef::Mixin::ShellOut
 
-      banner "knife cookbook create COOKBOOK [COMPANY_NAME_FOR_COPYRIGHT] [EMAIL] [APACHE_LICENSE=false] (options)"
+      banner "knife cookbook create COOKBOOK (options)"
 
       option :cookbook_path,
         :short => "-o PATH",
         :long => "--cookbook-path PATH",
         :description => "The directory where the cookbook will be created"
 
+      option :readme_format,
+        :short => "-r FORMAT",
+        :long => "--readme-format FORMAT",
+        :description => "Format of the README file, supported formats are 'md' (markdown) and 'rdoc' (rdoc)",
+        :default => "rdoc"
+
+      option :cookbook_license,
+        :short => "-I LICENSE",
+        :long => "--license LICENSE",
+        :description => "License for cookbook, apachev2 or none"
+
+      option :cookbook_copyright,
+        :short => "-C COPYRIGHT",
+        :long => "--copyright COPYRIGHT",
+        :description => "Name of Copyright holder"
+
+      option :cookbook_email,
+        :short => "-E EMAIL",
+        :long => "--email EMAIL",
+        :description => "Email address of cookbook maintainer"
+
       def run
-         if @name_args.length < 1
-            show_usage
-            Chef::Log.fatal("You must specify a cookbook name")
-            exit 1
+        self.config = Chef::Config.merge!(config)
+        if @name_args.length < 1
+          show_usage
+          Chef::Log.fatal("You must specify a cookbook name")
+          exit 1
         end
 
-        if default_cookbook_path_empty? && given_cookbook_path_empty?
+        if default_cookbook_path_empty? && parameter_empty?(config[:cookbook_path])
           raise ArgumentError, "Default cookbook_path is not specified in the knife.rb config file, and a value to -o is not provided. Nowhere to write the new cookbook to."
         end
 
-        cookbook_path = given_cookbook_path_empty? ? Chef::Config[:cookbook_path].first : config[:cookbook_path]
+        cookbook_path = Array(config[:cookbook_path]).first
         cookbook_name = @name_args.first
-        company_name = @name_args[1].nil? || @name_args[1].empty? ? "YOUR_COMPANY_NAME" : @name_args[1]
-        email = @name_args[2].nil? || @name_args[2].empty? ? "YOUR_EMAIL" : @name_args[2]
-        license = (@name_args[3].nil? || @name_args[3].to_s.empty? || @name_args[3] == false || @name_args[3] == 'false') ? :none : :apachev2
-        create_cookbook(cookbook_path,cookbook_name, company_name, license)
+        copyright = config[:cookbook_copyright] || "YOUR_COMPANY_NAME"
+        email = config[:cookbook_email] || "YOUR_EMAIL"
+        license = ((config[:cookbook_license] != "false") && config[:cookbook_license]) || "none"
+        create_cookbook(cookbook_path,cookbook_name, copyright, license)
         create_readme(cookbook_path,cookbook_name)
-        create_metadata(cookbook_path,cookbook_name, company_name, email, license)
+        create_metadata(cookbook_path,cookbook_name, copyright, email, license)
     end
 
-    def create_cookbook(dir, cookbook_name, company_name, license)
+    def create_cookbook(dir, cookbook_name, copyright, license)
       msg("** Creating cookbook #{cookbook_name}")
       shell_out "mkdir -p #{File.join(dir, cookbook_name, "attributes")}"
       shell_out "mkdir -p #{File.join(dir, cookbook_name, "recipes")}"
@@ -71,11 +93,11 @@ class Chef
 # Cookbook Name:: #{cookbook_name}
 # Recipe:: default
 #
-# Copyright #{Time.now.year}, #{company_name}
+# Copyright #{Time.now.year}, #{copyright}
 #
 EOH
           case license
-          when :apachev2
+          when "apachev2"
             file.puts <<-EOH
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -90,7 +112,7 @@ EOH
 # limitations under the License.
 #
 EOH
-          when :none
+          when "none"
             file.puts <<-EOH
 # All rights reserved - Do Not Redistribute
 #
@@ -102,9 +124,11 @@ EOH
 
     def create_readme(dir, cookbook_name)
       msg("** Creating README for cookbook: #{cookbook_name}")
-      unless File.exists?(File.join(dir, cookbook_name, "README.rdoc"))
-        open(File.join(dir, cookbook_name, "README.rdoc"), "w") do |file|
-          file.puts <<-EOH
+      unless File.exists?(File.join(dir, cookbook_name, "README.#{config[:readme_format]}"))
+        open(File.join(dir, cookbook_name, "README.#{config[:readme_format]}"), "w") do |file|
+          case config[:readme_format]
+          when "rdoc"
+            file.puts <<-EOH
 = DESCRIPTION:
 
 = REQUIREMENTS:
@@ -114,27 +138,54 @@ EOH
 = USAGE:
 
 EOH
+          when "md","mkd","txt"
+            file.puts <<-EOH
+Description
+===========
+
+Requirements
+============
+
+Attributes
+==========
+
+Usage
+=====
+
+EOH
+          else
+            file.puts <<-EOH
+Description
+
+Requirements
+
+Attributes
+
+Usage
+
+EOH
+          end
         end
       end
     end
 
-    def create_metadata(dir, cookbook_name, company_name, email, license)
+    def create_metadata(dir, cookbook_name, copyright, email, license)
       msg("** Creating metadata for cookbook: #{cookbook_name}")
 
       license_name = case license
-                     when :apachev2
+                     when "apachev2"
                        "Apache 2.0"
-                     when :none
+                     when "none"
                        "All rights reserved"
                      end
 
       unless File.exists?(File.join(dir, cookbook_name, "metadata.rb"))
         open(File.join(dir, cookbook_name, "metadata.rb"), "w") do |file|
-          if File.exists?(File.join(dir, cookbook_name, 'README.rdoc'))
-            long_description = "long_description IO.read(File.join(File.dirname(__FILE__), 'README.rdoc'))"
+          if File.exists?(File.join(dir, cookbook_name, "README.#{config[:readme_format]}"))
+            long_description = "long_description IO.read(File.join(File.dirname(__FILE__), 'README.#{config[:readme_format]}'))"
           end
           file.puts <<-EOH
-maintainer       "#{company_name}"
+maintainer       "#{copyright}"
 maintainer_email "#{email}"
 license          "#{license_name}"
 description      "Installs/Configures #{cookbook_name}"
@@ -146,14 +197,13 @@ EOH
     end
 
     private
-    def default_cookbook_path_empty?
-      Chef::Config[:cookbook_path].nil? || Chef::Config[:cookbook_path].empty?
-    end
-
-    def given_cookbook_path_empty?
-      config[:cookbook_path].nil? || config[:cookbook_path].empty?
-    end
+      def default_cookbook_path_empty?
+        Chef::Config[:cookbook_path].nil? || Chef::Config[:cookbook_path].empty?
+      end
 
+      def parameter_empty?(parameter)
+        parameter.nil? || parameter.empty?
+      end
     end
   end
-end
+end

data/lib/chef/knife/ec2_server_create.rb

@@ -61,8 +61,13 @@ class Chef
         :description => "The ssh username",
         :default => "root" 
  
+      option :ssh_password,
+        :short => "-P PASSWORD",
+        :long => "--ssh-password PASSWORD",
+        :description => "The ssh password"
+
       option :identity_file,
-        :short => "-i IDENTITY_FILE",
+        :short => "-I IDENTITY_FILE",
         :long => "--identity-file IDENTITY_FILE",
         :description => "The SSH identity file used for authentication"
  
@@ -87,6 +92,17 @@ class Chef
         :description => "Your AWS region",
         :default => "us-east-1"
 
+      option :distro,
+        :short => "-d DISTRO",
+        :long => "--distro DISTRO",
+        :description => "Bootstrap a distro using a template",
+        :default => "ubuntu10.04-gems"
+
+      option :template_file,
+        :long => "--template-file TEMPLATE",
+        :description => "Full path to location of template to use",
+        :default => false
+
       def h
         @highline ||= HighLine.new
       end
@@ -124,8 +140,10 @@ class Chef
 
         # wait for it to be ready to do stuff
         server.wait_for { print "."; ready? }
+        puts "#{h.color("\nWaiting 10 seconds for SSH Host Key generation on", :magenta)}: #{server.dns_name}"
+        sleep 10
 
-        print "\n\n"
+        print "\n"
 
         puts "#{h.color("Public DNS Name", :cyan)}: #{server.dns_name}"
         puts "#{h.color("Public IP Address", :cyan)}: #{server.ip_address}"
@@ -134,11 +152,15 @@ class Chef
 
         begin
           bootstrap = Chef::Knife::Bootstrap.new
-          bootstrap.name_args = [ server.ip_address, @name_args ].flatten
+          bootstrap.name_args = server.dns_name
+          bootstrap.config[:run_list] = @name_args
           bootstrap.config[:ssh_user] = config[:ssh_user]
           bootstrap.config[:identity_file] = config[:identity_file]
           bootstrap.config[:chef_node_name] = server.id
           bootstrap.config[:prerelease] = config[:prerelease]
+          bootstrap.config[:distro] = config[:distro]
+          bootstrap.config[:use_sudo] = true
+          bootstrap.config[:template_file] = config[:template_file]
           bootstrap.run
         rescue Errno::ECONNREFUSED
           puts h.color("Connection refused on SSH, retrying - CTRL-C to abort")

data/lib/chef/mixin/language.rb

@@ -74,10 +74,18 @@ class Chef
         end
 
         def format_values(hash)
-          formatted_array = hash.map { |key, value| [key.to_s, value]}.flatten
+          formatted_array = flatten_one_level(hash.map { |key, value| [key.to_s, value]})
           Hash[*formatted_array]
         end
 
+        def flatten_one_level(array)
+          array.inject([]) do |flatter_array, values|
+            Array(values).each {|value| flatter_array << value }
+            flatter_array
+          end
+        end
+
+
         def assert_valid_platform_values!(platforms, value)
           unless value.kind_of?(Hash)
             msg = "platform dependent values must be specified in the format :platform => {:version => value} "

data/lib/chef/provider/file.rb

@@ -179,6 +179,7 @@ class Chef
           time = Time.now
           savetime = time.strftime("%Y%m%d%H%M%S")
           backup_filename = "#{@new_resource.path}.chef-#{savetime}"
+          backup_filename = backup_filename.sub(/^([A-Za-z]:)/, "") #strip drive letter on Windows
           # if :file_backup_path is nil, we fallback to the old behavior of
           # keeping the backup in the same directory. We also need to to_s it
           # so we don't get a type error around implicit to_str conversions.

data/lib/chef/provider/package/zypper.rb

@@ -100,11 +100,11 @@ class Chef
         def upgrade_package(name, version)
           if version
             run_command(
-              :command => "zypper -n --no-gpg-checks update -l  #{name}=#{version}"
+              :command => "zypper -n --no-gpg-checks install -l #{name}=#{version}"
             )
           else
             run_command(
-              :command => "zypper -n --no-gpg-checks update -l  #{name}"
+              :command => "zypper -n --no-gpg-checks install -l #{name}"
             )
           end
         end

data/lib/chef/resource/remote_file.rb

@@ -64,8 +64,8 @@ class Chef
         if absolute_uri?(source)
           Chef::Provider::RemoteFile
         else
-          # contentious...
           Chef::Log.warn("remote_file is deprecated for fetching files from cookbooks. Use cookbook_file instead")
+          Chef::Log.warn("From #{self.to_s} on #{source_line}")
           Chef::Provider::CookbookFile
         end
       end

data/lib/chef/shef.rb

@@ -5,9 +5,9 @@
 # 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.
@@ -20,6 +20,7 @@ require "pp"
 require "etc"
 require "mixlib/cli"
 
+require 'chef/version'
 require "chef/client"
 require "chef/config"
 
@@ -31,74 +32,121 @@ module Shef
   LEADERS = Hash.new("")
   LEADERS[Chef::Recipe] = ":recipe"
   LEADERS[Chef::Node]   = ":attributes"
-  
+
   class << self
-    attr_accessor :client_type, :options
+    attr_accessor :client_type
+    attr_accessor :options
+    attr_accessor :env
+    attr_writer   :editor
+  end
+
+  # Start the irb REPL with shef's customizations
+  def self.start
+    setup_logger
+    # FUGLY HACK: irb gives us no other choice.
+    irb_help = [:help, :irb_help, IRB::ExtendCommandBundle::NO_OVERRIDE]
+    IRB::ExtendCommandBundle.instance_variable_get(:@ALIASES).delete(irb_help)
+
+    parse_opts
+
+    # HACK: this duplicates the functions of IRB.start, but we have to do it
+    # to get access to the main object before irb starts.
+    ::IRB.setup(nil)
+
+    irb = IRB::Irb.new
+
+    init(irb.context.main)
+
+
+    irb_conf[:IRB_RC].call(irb.context) if irb_conf[:IRB_RC]
+    irb_conf[:MAIN_CONTEXT] = irb.context
+
+    trap("SIGINT") do
+      irb.signal_handle
+    end
+
+    catch(:IRB_EXIT) do
+      irb.eval_input
+    end
+  end
+
+  def self.setup_logger
+    Chef::Config[:log_level] ||= :warn
+    Chef::Log.init(STDERR)
+    Mixlib::Authentication::Log.logger = Ohai::Log.logger = Chef::Log.logger
+    Chef::Log.level = Chef::Config[:log_level] || :warn
   end
-  
+
   # Shef assumes it's running whenever it is defined
   def self.running?
     true
   end
-  
+
   # Set the irb_conf object to something other than IRB.conf
   # usful for testing.
   def self.irb_conf=(conf_hash)
     @irb_conf = conf_hash
   end
-  
+
   def self.irb_conf
     @irb_conf || IRB.conf
   end
-  
+
   def self.configure_irb
     irb_conf[:HISTORY_FILE] = "~/.shef_history"
     irb_conf[:SAVE_HISTORY] = 1000
-    
+
     irb_conf[:IRB_RC] = lambda do |conf|
       m = conf.main
-      leader = LEADERS[m.class]
-
-      def m.help
-        shef_help
-      end
 
-      conf.prompt_c       = "chef#{leader} > "
+      conf.prompt_c       = "chef#{leader(m)} > "
       conf.return_format  = " => %s \n"
-      conf.prompt_i       = "chef#{leader} > "
-      conf.prompt_n       = "chef#{leader} ?> "
-      conf.prompt_s       = "chef#{leader}%l> "
+      conf.prompt_i       = "chef#{leader(m)} > "
+      conf.prompt_n       = "chef#{leader(m)} ?> "
+      conf.prompt_s       = "chef#{leader(m)}%l> "
     end
   end
-  
+
+  def self.leader(main_object)
+    env_string = Shef.env ? " (#{Shef.env})" : ""
+    LEADERS[main_object.class] + env_string
+  end
+
   def self.session
-    client_type.instance.reset! unless client_type.instance.node_built?
+    unless client_type.instance.node_built?
+      puts "Session type: #{client_type.session_type}"
+      client_type.instance.reset!
+    end
     client_type.instance
   end
-  
-  def self.init
+
+  def self.init(main)
     parse_json
     configure_irb
 
     session # trigger ohai run + session load
-    
+
     session.node.consume_attributes(@json_attribs)
 
-    greeting = begin
-        " #{Etc.getlogin}@#{Shef.session.node.name}"
-      rescue NameError
-        ""
-      end
+    Extensions.extend_context_object(main)
 
-    version
+    main.version
     puts
 
     puts "run `help' for help, `exit' or ^D to quit."
     puts
     puts "Ohai2u#{greeting}!"
   end
-  
+
+  def self.greeting
+    " #{Etc.getlogin}@#{Shef.session.node.fqdn}"
+  rescue NameError
+    ""
+  end
+
   def self.parse_json
+    # HACK: copied verbatim from chef/application/client, because it's not
+    # reusable as written there :(
     if Chef::Config[:json_attribs]
       begin
         json_io = open(Chef::Config[:json_attribs])
@@ -119,28 +167,48 @@ module Shef
       end
     end
   end
-  
+
   def self.fatal!(message, exit_status)
     Chef::Log.fatal(message)
     exit exit_status
   end
-  
+
   def self.client_type
     type = Shef::StandAloneSession
     type = Shef::SoloSession   if Chef::Config[:shef_solo]
     type = Shef::ClientSession if Chef::Config[:client]
+    type = Shef::DoppelGangerSession if Chef::Config[:doppelganger]
     type
   end
-  
+
   def self.parse_opts
     @options = Options.new
     @options.parse_opts
   end
-  
+
+  def self.editor
+    @editor || Chef::Config[:editor] || ENV['EDITOR']
+  end
+
   class Options
     include Mixlib::CLI
 
-    option :config_file, 
+    def self.footer(text=nil)
+      @footer = text if text
+      @footer
+    end
+
+    banner("shef #{Chef::VERSION}\n\nUsage: shef [NAMED_CONF] (OPTIONS)")
+
+    footer(<<-FOOTER)
+When no CONFIG is specified, shef attempts to load a default configuration file:
+* If a NAMED_CONF is given, shef will load ~/.chef/NAMED_CONF/shef.rb
+* If no NAMED_CONF is given shef will load ~/.chef/shef.rb if it exists
+* Shef falls back to loading /etc/chef/client.rb or /etc/chef/solo.rb if -z or
+  -s options are given and no shef.rb can be found. 
+FOOTER
+
+    option :config_file,
       :short => "-c CONFIG",
       :long  => "--config CONFIG",
       :description => "The configuration file to use"
@@ -151,8 +219,13 @@ module Shef
       :description  => "Show this message",
       :on           => :tail,
       :boolean      => true,
-      :show_options => true,
-      :exit         => 0
+      :proc         => proc { print_help }
+
+    option :log_level,
+      :short  => "-l LOG_LEVEL",
+      :long   => '--log-level LOG_LEVEL',
+      :description => "Set the logging level",
+      :proc         => proc { |level| Chef::Log.level = level.to_sym }
 
     option :standalone,
       :short        => "-a",
@@ -194,31 +267,57 @@ module Shef
       :proc         => lambda {|v| puts "Chef: #{::Chef::VERSION}"},
       :exit         => 0
 
+    def self.print_help
+      instance = new
+      instance.parse_options([])
+      puts instance.opt_parser
+      puts
+      puts footer
+      puts
+      exit 1
+    end
+
     def self.setup!
       self.new.parse_opts
     end
 
     def parse_opts
-      parse_options
+      remainder = parse_options
+      environment = remainder.first
       # We have to nuke ARGV to make sure irb's option parser never sees it.
       # otherwise, IRB complains about command line switches it doesn't recognize.
       ARGV.clear
-      config[:config_file] = config_file_for_shef_mode
+      config[:config_file] = config_file_for_shef_mode(environment)
       config_msg = config[:config_file] || "none (standalone shef session)"
       puts "loading configuration: #{config_msg}"
       Chef::Config.from_file(config[:config_file]) if !config[:config_file].nil? && File.exists?(config[:config_file]) && File.readable?(config[:config_file])
       Chef::Config.merge!(config)
     end
-    
+
     private
-    
-    def config_file_for_shef_mode
-      return config[:config_file] if config[:config_file]
-      return "/etc/chef/solo.rb" if config[:solo]
-      return "/etc/chef/client.rb" if config[:client]
-      nil
+
+    def config_file_for_shef_mode(environment)
+      if config[:config_file]
+        config[:config_file]
+      elsif environment
+        Shef.env = environment
+        config_file_to_try = ::File.join(ENV['HOME'], '.chef', environment, 'shef.rb')
+        unless ::File.exist?(config_file_to_try)
+          puts "could not find shef config for environment #{environment} at #{config_file_to_try}"
+          exit 1
+        end
+        config_file_to_try
+      elsif ENV['HOME'] && ::File.exist?(File.join(ENV['HOME'], '.chef', 'shef.rb'))
+        File.join(ENV['HOME'], '.chef', 'shef.rb')
+      elsif config[:solo]
+        "/etc/chef/solo.rb"
+      elsif config[:client]
+        "/etc/chef/client.rb"
+      else
+        nil
+      end
     end
 
   end
-  
+
 end