chef 0.9.6 → 0.9.8.beta.1

data/lib/chef/application.rb

@@ -66,14 +66,22 @@ class Chef::Application
   def configure_chef
     parse_options
 
-    unless config[:config_file] && File.file?(config[:config_file])
+    begin
+      case config[:config_file]
+      when /^(http|https):\/\//
+        Chef::REST.new("", nil, nil).fetch(config[:config_file]) { |f| apply_config(f.path) }
+      else
+        ::File::open(config[:config_file]) { |f| apply_config(f.path) }
+      end
+    rescue SocketError => error
+      Chef::Application.fatal!("Error getting config file #{Chef::Config[:config_file]}", 2)
+    rescue Exception => error
       Chef::Log.warn("*****************************************")
       Chef::Log.warn("Can not find config file: #{config[:config_file]}, using defaults.")
+      Chef::Log.warn("#{error.message}")
       Chef::Log.warn("*****************************************")
     end
 
-    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
 
   # Initialize and configure the logger
@@ -92,6 +100,14 @@ class Chef::Application
     raise Chef::Exceptions::Application, "#{self.to_s}: you must override run_application"
   end
 
+  private
+
+  def apply_config(config_file_path)
+    Chef::Config.from_file(config_file_path)
+    Chef::Config.merge!(config)
+  end
+
+
   class << self
     # Log a fatal error message to both STDERR and the Logger, exit the application
     def fatal!(msg, err = -1)

data/lib/chef/application/client.rb

@@ -181,17 +181,12 @@ class Chef::Application::Client < Chef::Application
 
   def configure_logging
     super
-    Mixlib::Authentication::Log.logger = Chef::Log.logger
+    Chef::Log.verbose = Chef::Config[:verbose_logging]
+    Mixlib::Authentication::Log.logger = Ohai::Log.logger = Chef::Log.logger
   end
   
-  # Setup an instance of the chef client
-  # Why is this so ugly? surely the client should just read out of chef::config instead of needing the values to be assigned like this..
   def setup_application
     Chef::Daemon.change_privilege
-
-    @chef_client = Chef::Client.new
-    @chef_client.json_attribs = @chef_client_json
-    @chef_client.node_name = Chef::Config[:node_name]   
   end
   
   # Run the chef client, optionally daemonizing or looping at intervals.
@@ -211,9 +206,11 @@ class Chef::Application::Client < Chef::Application
           Chef::Log.debug("Splay sleep #{splay} seconds")
           sleep splay
         end
+        @chef_client = Chef::Client.new(@chef_client_json)
+        @chef_client_json = nil
 
         @chef_client.run
-        
+        @chef_client = nil
         if Chef::Config[:interval]
           Chef::Log.debug("Sleeping for #{Chef::Config[:interval]} seconds")
           sleep Chef::Config[:interval]
@@ -232,6 +229,8 @@ class Chef::Application::Client < Chef::Application
         else
           raise
         end
+      ensure
+        GC.start
       end
     end
   end

data/lib/chef/application/knife.rb

@@ -111,8 +111,7 @@ class Chef::Application::Knife < Chef::Application
   # Run knife 
   def run
     validate_and_parse_options
-    knife = Chef::Knife.find_command(ARGV, self.class.options)
-    knife.run
+    Chef::Knife.run(ARGV, options)
     exit 0
   end
   
@@ -121,7 +120,10 @@ class Chef::Application::Knife < Chef::Application
   def validate_and_parse_options
     # Checking ARGV validity *before* parse_options because parse_options
     # mangles ARGV in some situations
-    print_help_and_exit(2, "Sorry, you need to pass a sub-command first!") if no_subcommand_given?
+    if no_subcommand_given?
+      print_help_and_exit if want_help?
+      print_help_and_exit(2, "Sorry, you need to pass a sub-command first!")
+    end
     print_help_and_exit if no_command_given?
   end
   
@@ -132,6 +134,10 @@ class Chef::Application::Knife < Chef::Application
   def no_command_given?
     ARGV.empty?
   end
+
+  def want_help?
+    ARGV[0] =~ /^(--help|-h)$/
+  end
   
   def print_help_and_exit(exitcode=1, fatal_message=nil)
     Chef::Log.fatal(fatal_message) if fatal_message

data/lib/chef/application/solo.rb

@@ -171,10 +171,6 @@ class Chef::Application::Solo < Chef::Application
   
   def setup_application
     Chef::Daemon.change_privilege
-    
-    @chef_solo = Chef::Client.new
-    @chef_solo.json_attribs = @chef_solo_json
-    @chef_solo.node_name = Chef::Config[:node_name]
   end
   
   def run_application
@@ -190,8 +186,10 @@ class Chef::Application::Solo < Chef::Application
           sleep splay
         end
 
+        @chef_solo = Chef::Client.new(@chef_solo_json)
+        @chef_solo_json = nil
         @chef_solo.run
-        
+        @chef_solo = nil
         if Chef::Config[:interval]
           Chef::Log.debug("Sleeping for #{Chef::Config[:interval]} seconds")
           sleep Chef::Config[:interval]
@@ -210,6 +208,8 @@ class Chef::Application::Solo < Chef::Application
         else
           raise
         end
+      ensure
+        GC.start
       end
     end
   end

data/lib/chef/cache/checksum.rb

@@ -26,7 +26,7 @@ class Chef
     class Checksum < Chef::Cache
       # singleton is inherited from Chef::Cache, but we like to be explicit.
       include ::Singleton
-    
+
       def self.checksum_for_file(*args)
         instance.checksum_for_file(*args)
       end
@@ -36,7 +36,7 @@ class Chef
         fstat = File.stat(file)
         lookup_checksum(key, fstat) || generate_checksum(key, file, fstat)
       end
-      
+
       def lookup_checksum(key, fstat)
         cached = @moneta.fetch(key)
         if cached && file_unchanged?(cached, fstat)

data/lib/chef/client.rb

@@ -32,26 +32,25 @@ require 'chef/cookbook/cookbook_collection'
 require 'chef/cookbook/file_vendor'
 require 'chef/cookbook/file_system_file_vendor'
 require 'chef/cookbook/remote_file_vendor'
+require 'chef/version'
 require 'ohai'
 
 class Chef
   class Client
+    attr_accessor :node
+    attr_accessor :ohai
+    attr_accessor :rest
+    attr_accessor :runner
+
     # TODO: timh/cw: 5-19-2010: json_attribs should be moved to RunContext?
-    attr_accessor :node, :registration, :json_attribs, :node_name, :ohai, :rest, :runner
-    attr_reader :node_exists
-    
+    attr_reader :json_attribs
+
     # Creates a new Chef::Client.
-    def initialize()
+    def initialize(json_attribs=nil)
+      @json_attribs = json_attribs
       @node = nil
-      @registration = nil
-      @json_attribs = nil
-      @node_name = nil
-      @node_exists = true
       @runner = nil
       @ohai = Ohai::System.new
-      Chef::Log.verbose = Chef::Config[:verbose_logging]
-      Mixlib::Authentication::Log.logger = Ohai::Log.logger = Chef::Log.logger
-      @ohai_has_run = false
     end
     
     # Do a full run for this Chef::Client.  Calls:
@@ -65,18 +64,16 @@ class Chef
     # === Returns
     # true:: Always returns true.
     def run
-      self.runner = nil
       run_context = nil
 
       run_ohai
-      determine_node_name
       register unless Chef::Config[:solo]
       build_node
       
       begin
         run_status = Chef::RunStatus.new(node)
         run_status.start_clock
-        Chef::Log.info("Starting Chef Run")
+        Chef::Log.info("Starting Chef Run (Version #{Chef::VERSION})")
         
         if Chef::Config[:solo]
           Chef::Cookbook::FileVendor.on_create { |manifest| Chef::Cookbook::FileSystemFileVendor.new(manifest) }
@@ -91,8 +88,6 @@ class Chef
           # cache.
           valid_cache_entries = Hash.new
           
-          save_node
-
           # Sync_cookbooks eagerly loads all files except files and templates.
           # It returns the cookbook_hash -- the return result from
           # /nodes/#{nodename}/cookbooks -- which we will use for our
@@ -103,10 +98,10 @@ class Chef
           run_status.run_context = run_context
 
           assert_cookbook_path_not_empty(run_context)
-          save_node
           
           converge(run_context)
-          save_node
+          Chef::Log.debug("Saving the current state of node #{node_name}")
+          @node.save
           
           cleanup_file_cache(valid_cache_entries)
         end
@@ -143,25 +138,19 @@ class Chef
     end
     
     def run_ohai
-      if ohai.keys
-        ohai.refresh_plugins
-      else
-        ohai.all_plugins
-      end
+      ohai.all_plugins
     end
 
-    def determine_node_name
-      unless node_name
-        if Chef::Config[:node_name]
-          @node_name = Chef::Config[:node_name]
-        else
-          @node_name = ohai[:fqdn] ? ohai[:fqdn] : ohai[:hostname]
-          Chef::Config[:node_name] = node_name
-        end
+    def node_name
+      name = Chef::Config[:node_name] || ohai[:fqdn] || ohai[:hostname]
+      Chef::Config[:node_name] = name
 
-        raise RuntimeError, "Unable to determine node name from ohai" unless node_name
+      unless name
+        msg = "Unable to determine node name: configure node_name or configure the system's hostname and fqdn"
+        raise Chef::Exceptions::CannotDetermineNodeName, msg
       end
-      node_name
+
+      name
     end
     
     # Builds a new node object for this client.  Starts with querying for the FQDN of the current
@@ -171,24 +160,16 @@ class Chef
     # node<Chef::Node>:: Returns the created node object, also stored in @node
     def build_node
       Chef::Log.debug("Building node object for #{@node_name}")
-      
-      unless Chef::Config[:solo]
-        begin
-          @node = rest.get_rest("nodes/#{@node_name}")
-        rescue Net::HTTPServerException => e
-          raise unless e.message =~ /^404/
-        end
-      end
-      
-      unless node
-        @node_exists = false
-        @node = Chef::Node.new
-        @node.name(node_name)
+
+      if Chef::Config[:solo]
+        @node = Chef::Node.build(node_name)
+      else
+        @node = Chef::Node.find_or_create(node_name)
       end
 
-      @node.prepare_for_run(ohai.data, @json_attribs)
-      # Need to nil-ify the json attribs so they are not applied on subsequent runs
-      @json_attribs = nil
+      @node.process_external_attrs(ohai.data, @json_attribs)
+      @node.save unless Chef::Config[:solo]
+      @node.reset_defaults_and_overrides
 
       @node
     end
@@ -309,21 +290,6 @@ class Chef
       end
     end
 
-    # Updates the current node configuration on the server.
-    #
-    # === Returns
-    # Chef::Node - the current node
-    def save_node
-      Chef::Log.debug("Saving the current state of node #{node_name}")
-      if node_exists
-        @node = @node.save
-      else
-        result = rest.post_rest("nodes", node)
-        @node_exists = true
-        @node = rest.get_rest(result['uri'])
-      end
-    end
-
     # Converges the node.
     #
     # === Returns

data/lib/chef/config.rb

@@ -47,28 +47,27 @@ class Chef
     end
 
     # Override the config dispatch to set the value of multiple server options simultaneously
-    # 
+    #
     # === Parameters
     # url<String>:: String to be set for all of the chef-server-api URL's
     #
     config_attr_writer :chef_server_url do |url|
       configure do |c|
         [ :registration_url,
-          :openid_url,
           :template_url,
           :remotefile_url,
           :search_url,
           :chef_server_url,
-          :role_url ].each do |u| 
+          :role_url ].each do |u|
             c[u] = url
         end
       end
       url
     end
 
-    # When you are using ActiveSupport, they monkey-patch 'daemonize' into Kernel.  
+    # When you are using ActiveSupport, they monkey-patch 'daemonize' into Kernel.
     # So while this is basically identical to what method_missing would do, we pull
-    # it up here and get a real method written so that things get dispatched 
+    # it up here and get a real method written so that things get dispatched
     # properly.
     config_attr_writer :daemonize do |v|
       configure do |c|
@@ -101,21 +100,43 @@ class Chef
       providers
     end
 
+    # Used when OpenID authentication is enabled in the Web UI
     authorized_openid_identifiers nil
     authorized_openid_providers nil
+    openid_cstore_couchdb false
+    openid_cstore_path "/var/chef/openid/cstore"
+
+    # The number of times the client should retry when registering with the server
     client_registration_retries 5
+
+    # Where the cookbooks are located. Meaning is somewhat context dependent between
+    # knife, chef-client, and chef-solo.
     cookbook_path [ "/var/chef/cookbooks", "/var/chef/site-cookbooks" ]
-    cookbook_tarball_path "/var/chef/cookbook-tarballs"
+
+    # Where files are stored temporarily during uploads
     sandbox_path "/var/chef/sandboxes"
+
+    # Where cookbook files are stored on the server (by content checksum)
     checksum_path "/var/chef/checksums"
+
+    # CouchDB database name to use
     couchdb_database "chef"
+
     couchdb_url "http://localhost:5984"
-    couchdb_version nil
-    delay 0
-    executable_path ENV['PATH'] ? ENV['PATH'].split(File::PATH_SEPARATOR) : []
+
+    # Where chef's cache files should be stored
     file_cache_path "/var/chef/cache"
+
+    # Where backups of chef-managed files should go
     file_backup_path "/var/chef/backup"
+
+    ## Daemonization Settings ##
+    # What user should Chef run as?
+    user nil
+    # What group should the chef-server, -solr, -solr-indexer run as
     group nil
+    umask 0022
+
     http_retry_count 5
     http_retry_delay 5
     interval nil
@@ -125,52 +146,53 @@ class Chef
     verbose_logging nil
     node_name nil
     node_path "/var/chef/node"
-    openid_cstore_couchdb false
-    openid_cstore_path "/var/chef/openid/cstore"    
-    openid_providers nil
-    openid_store_couchdb false
-    openid_store_path "/var/chef/openid/db"
-    openid_url "http://localhost:4001"
+
     pid_file nil
-    queue_host "localhost"
-    queue_password ""
-    queue_port 61613
-    queue_retry_count 5
-    queue_retry_delay 5
-    queue_user ""
-    chef_server_url "http://localhost:4000"
-    registration_url "http://localhost:4000"
+
+    chef_server_url   "http://localhost:4000"
+    registration_url  "http://localhost:4000"
+    template_url      "http://localhost:4000"
+    role_url          "http://localhost:4000"
+    remotefile_url    "http://localhost:4000"
+    search_url        "http://localhost:4000"
+
     client_url "http://localhost:4042"
-    remotefile_url "http://localhost:4000"
+
     rest_timeout 300
     run_command_stderr_timeout 120
     run_command_stdout_timeout 120
-    search_url "http://localhost:4000"
     solo  false
     splay nil
+
+    # Set these to enable SSL authentication / mutual-authentication
+    # with the server
     ssl_client_cert nil
     ssl_client_key nil
     ssl_verify_mode :verify_none
     ssl_ca_path nil
     ssl_ca_file nil
-    template_url "http://localhost:4000"
-    umask 0022
-    user nil
+
+
+    # Where should chef-solo look for role files?
     role_path "/var/chef/roles"
-    role_url "http://localhost:4000"
+
+    # Where should chef-solo download recipes from?
     recipe_url nil
+
     solr_url "http://localhost:8983"
     solr_jetty_path "/var/chef/solr-jetty"
     solr_data_path "/var/chef/solr/data"
     solr_home_path "/var/chef/solr"
     solr_heap_size "256M"
     solr_java_opts nil
+
+    # Parameters for connecting to RabbitMQ
     amqp_host '0.0.0.0'
     amqp_port '5672'
     amqp_user 'chef'
     amqp_pass 'testing'
     amqp_vhost '/chef'
-    # Setting this to a UUID string also makes the queue durable 
+    # Setting this to a UUID string also makes the queue durable
     # (persist across rabbitmq restarts)
     amqp_consumer_id "default"