tecnh-chef 0.9.9.vpc

data/lib/chef/client.rb

@@ -0,0 +1,340 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Christopher Walters (<cw@opscode.com>)
+# Author:: Christopher Brown (<cb@opscode.com>)
+# Author:: Tim Hinderliter (<tim@opscode.com>)
+# Copyright:: Copyright (c) 2008-2010 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/config'
+require 'chef/mixin/params_validate'
+require 'chef/log'
+require 'chef/rest'
+require 'chef/platform'
+require 'chef/node'
+require 'chef/role'
+require 'chef/file_cache'
+require 'chef/run_context'
+require 'chef/runner'
+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
+  # == Chef::Client
+  # The main object in a Chef run. Preps a Chef::Node and Chef::RunContext,
+  # syncs cookbooks if necessary, and triggers convergence.
+  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_reader :json_attribs
+
+    # Creates a new Chef::Client.
+    def initialize(json_attribs=nil)
+      @json_attribs = json_attribs
+      @node = nil
+      @runner = nil
+      @ohai = Ohai::System.new
+    end
+    
+    # Do a full run for this Chef::Client.  Calls:
+    #
+    #  * run_ohai - Collect information about the system
+    #  * build_node - Get the last known state, merge with local changes
+    #  * register - If not in solo mode, make sure the server knows about this client
+    #  * sync_cookbooks - If not in solo mode, populate the local cache with the node's cookbooks
+    #  * converge - Bring this system up to date
+    #
+    # === Returns
+    # true:: Always returns true.
+    def run
+      run_context = nil
+
+      run_ohai
+      register unless Chef::Config[:solo]
+      build_node
+      
+      begin
+        run_status = Chef::RunStatus.new(node)
+        run_status.start_clock
+        Chef::Log.info("Starting Chef Run (Version #{Chef::VERSION})")
+        
+        if Chef::Config[:solo]
+          Chef::Cookbook::FileVendor.on_create { |manifest| Chef::Cookbook::FileSystemFileVendor.new(manifest) }
+          run_context = Chef::RunContext.new(node, Chef::CookbookCollection.new(Chef::CookbookLoader.new))
+          run_status.run_context = run_context
+          assert_cookbook_path_not_empty(run_context)
+          converge(run_context)
+        else
+          # Keep track of the filenames that we use in both eager cookbook
+          # downloading (during sync_cookbooks) and lazy (during the run
+          # itself, through FileVendor). After the run is over, clean up the
+          # cache.
+          valid_cache_entries = Hash.new
+          
+          # 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
+          # run_context.
+          Chef::Cookbook::FileVendor.on_create { |manifest| Chef::Cookbook::RemoteFileVendor.new(manifest, rest, valid_cache_entries) }
+          cookbook_hash = sync_cookbooks(valid_cache_entries)
+          run_context = Chef::RunContext.new(node, Chef::CookbookCollection.new(cookbook_hash))
+          run_status.run_context = run_context
+
+          assert_cookbook_path_not_empty(run_context)
+          
+          converge(run_context)
+          Chef::Log.debug("Saving the current state of node #{node_name}")
+          @node.save
+          
+          cleanup_file_cache(valid_cache_entries)
+        end
+        
+        run_status.stop_clock
+        Chef::Log.info("Chef Run complete in #{run_status.elapsed_time} seconds")
+        run_report_handlers(run_status)
+        true
+      rescue Exception => e
+        run_status.stop_clock
+        run_status.exception = e
+        run_exception_handlers(run_status)
+        Chef::Log.error("Re-raising exception: #{e.class} - #{e.message}\n#{e.backtrace.join("\n  ")}")
+        raise
+      ensure
+        run_status = nil
+      end
+    end
+
+    def run_report_handlers(run_status)
+      Chef::Log.info("Running report handlers")
+      Array(Chef::Config[:report_handlers]).each do |handler|
+        handler.run_report_safely(run_status)
+      end
+      Chef::Log.info("Report handlers complete")
+    end
+
+    def run_exception_handlers(run_status)
+      Chef::Log.error("Running exception handlers")
+      Array(Chef::Config[:exception_handlers]).each do |handler|
+        handler.run_report_safely(run_status)
+      end
+      Chef::Log.error("Exception handlers complete")
+    end
+    
+    def run_ohai
+      ohai.all_plugins
+    end
+
+    def node_name
+      name = Chef::Config[:node_name] || ohai[:fqdn] || ohai[:hostname]
+      Chef::Config[:node_name] = 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
+
+      name
+    end
+    
+    # Builds a new node object for this client.  Starts with querying for the FQDN of the current
+    # host (unless it is supplied), then merges in the facts from Ohai.
+    #
+    # === Returns
+    # node<Chef::Node>:: Returns the created node object, also stored in @node
+    def build_node
+      Chef::Log.debug("Building node object for #{@node_name}")
+
+      if Chef::Config[:solo]
+        @node = Chef::Node.build(node_name)
+      else
+        @node = Chef::Node.find_or_create(node_name)
+      end
+
+      @node.process_external_attrs(ohai.data, @json_attribs)
+      @node.save unless Chef::Config[:solo]
+      @node.reset_defaults_and_overrides
+
+      @node
+    end
+
+    # 
+    # === Returns
+    # rest<Chef::REST>:: returns Chef::REST connection object
+    def register
+      if File.exists?(Chef::Config[:client_key])
+        Chef::Log.debug("Client key #{Chef::Config[:client_key]} is present - skipping registration")
+      else
+        Chef::Log.info("Client key #{Chef::Config[:client_key]} is not present - registering")
+        Chef::REST.new(Chef::Config[:client_url], Chef::Config[:validation_client_name], Chef::Config[:validation_key]).register(node_name, Chef::Config[:client_key])
+      end
+      # We now have the client key, and should use it from now on.
+      self.rest = Chef::REST.new(Chef::Config[:chef_server_url], node_name, Chef::Config[:client_key])
+    end
+    
+    # Synchronizes all the cookbooks from the chef-server.
+    #
+    # === Returns
+    # true:: Always returns true
+    def sync_cookbooks(valid_cache_entries)
+      Chef::Log.debug("Synchronizing cookbooks")
+      cookbook_hash = rest.get_rest("nodes/#{node_name}/cookbooks")
+      Chef::Log.debug("Cookbooks to load: #{cookbook_hash.inspect}")
+      
+      # Remove all cookbooks no longer relevant to this node
+      Chef::FileCache.find(File.join(%w{cookbooks ** *})).each do |cache_file|
+        cache_file =~ /^cookbooks\/([^\/]+)\//
+        unless cookbook_hash.has_key?($1)
+          Chef::Log.info("Removing #{cache_file} from the cache; its cookbook is no longer needed on this client.")
+          Chef::FileCache.delete(cache_file) 
+        end
+      end
+
+      # Synchronize each of the node's cookbooks, and add to the
+      # valid_cache_entries hash.
+      cookbook_hash.values.each do |cookbook|
+        sync_cookbook_file_cache(cookbook, valid_cache_entries)
+      end
+
+      # register the file cache path in the cookbook path so that CookbookLoader actually picks up the synced cookbooks
+      Chef::Config[:cookbook_path] = File.join(Chef::Config[:file_cache_path], "cookbooks")
+      
+      cookbook_hash
+    end
+    
+    # Update the file caches for a given cache segment.  Takes a segment name
+    # and a hash that matches one of the cookbooks/_attribute_files style
+    # remote file listings.
+    #
+    # === Parameters
+    # cookbook<Chef::Cookbook>:: The cookbook to update
+    # valid_cache_entries<Hash>:: Out-param; Added to this hash are the files that 
+    # were referred to by this cookbook
+    def sync_cookbook_file_cache(cookbook, valid_cache_entries)
+      Chef::Log.debug("Synchronizing cookbook #{cookbook.name}")
+
+      # files and templates are lazily loaded, and will be done later.
+      eager_segments = Chef::CookbookVersion::COOKBOOK_SEGMENTS.dup
+      eager_segments.delete(:files)
+      eager_segments.delete(:templates)
+      
+      eager_segments.each do |segment|
+        segment_filenames = Array.new
+        cookbook.manifest[segment].each do |manifest_record|
+          # segment = cookbook segment
+          # remote_list = list of file hashes
+          #
+          # We need the list of known good attribute files, so we can delete any that are
+          # just laying about.
+        
+          cache_filename = File.join("cookbooks", cookbook.name, manifest_record['path'])
+          valid_cache_entries[cache_filename] = true
+
+          current_checksum = nil
+          if Chef::FileCache.has_key?(cache_filename)
+            current_checksum = Chef::CookbookVersion.checksum_cookbook_file(Chef::FileCache.load(cache_filename, false))
+          end
+          
+          # If the checksums are different between on-disk (current) and on-server
+          # (remote, per manifest), do the update. This will also execute if there
+          # is no current checksum.
+          if current_checksum != manifest_record['checksum']
+            raw_file = rest.get_rest(manifest_record[:url], true)
+            
+            Chef::Log.info("Storing updated #{cache_filename} in the cache.")
+            Chef::FileCache.move_to(raw_file.path, cache_filename)
+          else
+            Chef::Log.debug("Not storing #{cache_filename}, as the cache is up to date.")
+          end
+          
+          # make the segment filenames a full path.
+          full_path_cache_filename = Chef::FileCache.load(cache_filename, false)
+          segment_filenames << full_path_cache_filename
+        end
+        
+        # replace segment filenames with a full-path one.
+        if segment.to_sym == :recipes
+          cookbook.recipe_filenames = segment_filenames
+        elsif segment.to_sym == :attributes
+          cookbook.attribute_filenames = segment_filenames
+        else
+          cookbook.segment_filenames(segment).replace(segment_filenames)
+        end
+      end
+    end
+    
+    def cleanup_file_cache(valid_cache_entries)
+      # Delete each file in the cache that we didn't encounter in the
+      # manifest.
+      Chef::FileCache.find(File.join(%w{cookbooks ** *})).each do |cache_filename|
+        unless valid_cache_entries[cache_filename]
+          Chef::Log.info("Removing #{cache_filename} from the cache; it is no longer on the server.")
+          Chef::FileCache.delete(cache_filename)
+        end
+      end
+    end
+
+    # Converges the node.
+    #
+    # === Returns
+    # true:: Always returns true
+    def converge(run_context)
+      Chef::Log.debug("Converging node #{node_name}")
+      @runner = Chef::Runner.new(run_context)
+      runner.converge
+      true
+    end
+    
+    private
+    
+    def directory_not_empty?(path)
+      File.exists?(path) && (Dir.entries(path).size > 2)
+    end
+    
+    def is_last_element?(index, object)
+      object.kind_of?(Array) ? index == object.size - 1 : true 
+    end  
+    
+    def assert_cookbook_path_not_empty(run_context)
+      if Chef::Config[:solo]
+        # Check for cookbooks in the path given
+        # Chef::Config[:cookbook_path] can be a string or an array
+        # if it's an array, go through it and check each one, raise error at the last one if no files are found
+        Chef::Log.debug "loading from cookbook_path: #{Array(Chef::Config[:cookbook_path]).map { |path| File.expand_path(path) }.join(', ')}" 
+        Array(Chef::Config[:cookbook_path]).each_with_index do |cookbook_path, index|
+          if directory_not_empty?(cookbook_path)
+            break
+          else
+            msg = "No cookbook found in #{Chef::Config[:cookbook_path].inspect}, make sure cookboook_path is set correctly."
+            Chef::Log.fatal(msg)
+            raise Chef::Exceptions::CookbookNotFound, msg if is_last_element?(index, Chef::Config[:cookbook_path])
+          end
+        end
+      else
+        Chef::Log.warn("Node #{node_name} has an empty run list.") if run_context.node.run_list.empty?
+      end
+
+    end
+  end
+end
+

data/lib/chef/config.rb

@@ -0,0 +1,240 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Christopher Brown (<cb@opscode.com>)
+# Author:: AJ Christensen (<aj@opscode.com>)
+# Copyright:: Copyright (c) 2008 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/log'
+require 'mixlib/config'
+
+class Chef
+  class Config
+
+    extend Mixlib::Config
+
+    # Manages the chef secret session key
+    # === Returns
+    # <newkey>:: A new or retrieved session key
+    #
+    def self.manage_secret_key
+      newkey = nil
+      if Chef::FileCache.has_key?("chef_server_cookie_id")
+        newkey = Chef::FileCache.load("chef_server_cookie_id")
+      else
+        chars = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a
+        newkey = ""
+        40.times { |i| newkey << chars[rand(chars.size-1)] }
+        Chef::FileCache.store("chef_server_cookie_id", newkey)
+      end
+      newkey
+    end
+
+    def self.inspect
+      configuration.inspect
+    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,
+          :template_url,
+          :remotefile_url,
+          :search_url,
+          :chef_server_url,
+          :role_url ].each do |u|
+            c[u] = url
+        end
+      end
+      url
+    end
+
+    # 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
+    # properly.
+    config_attr_writer :daemonize do |v|
+      configure do |c|
+        c[:daemonize] = v
+      end
+    end
+
+    # Override the config dispatch to set the value of log_location configuration option
+    #
+    # === Parameters
+    # location<IO||String>:: Logging location as either an IO stream or string representing log file path
+    #
+    config_attr_writer :log_location do |location|
+      if location.respond_to? :sync=
+        location
+      elsif location.respond_to? :to_str
+        f = File.new(location.to_str, "a")
+        f.sync = true
+        f
+      end
+    end
+
+    # Override the config dispatch to set the value of authorized_openid_providers when openid_providers (deprecated) is used
+    #
+    # === Parameters
+    # providers<Array>:: An array of openid providers that are authorized to login to the chef server
+    #
+    config_attr_writer :openid_providers do |providers|
+      configure { |c| c[:authorized_openid_providers] = providers }
+      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" ]
+
+    # 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"
+
+    # 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
+    json_attribs nil
+    log_level :info
+    log_location STDOUT
+    verbose_logging nil
+    node_name nil
+    node_path "/var/chef/node"
+
+    pid_file nil
+
+    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"
+
+    rest_timeout 300
+    run_command_stderr_timeout 120
+    run_command_stdout_timeout 120
+    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
+
+
+    # Where should chef-solo look for role files?
+    role_path "/var/chef/roles"
+
+    # 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
+    # (persist across rabbitmq restarts)
+    amqp_consumer_id "default"
+
+    client_key "/etc/chef/client.pem"
+    validation_key "/etc/chef/validation.pem"
+    validation_client_name "chef-validator"
+    web_ui_client_name "chef-webui"
+    web_ui_key "/etc/chef/webui.pem"
+    web_ui_admin_user_name  "admin"
+    web_ui_admin_default_password "p@ssw0rd1"
+
+    # Server Signing CA
+    #
+    # In truth, these don't even have to change
+    signing_ca_cert "/var/chef/ca/cert.pem"
+    signing_ca_key "/var/chef/ca/key.pem"
+    signing_ca_user nil
+    signing_ca_group nil
+    signing_ca_country "US"
+    signing_ca_state "Washington"
+    signing_ca_location "Seattle"
+    signing_ca_org "Chef User"
+    signing_ca_domain "opensource.opscode.com"
+    signing_ca_email "opensource-cert@opscode.com"
+
+    # Report Handlers
+    report_handlers []
+
+    # Exception Handlers
+    exception_handlers []
+
+    # Checksum Cache
+    # Uses Moneta on the back-end
+    cache_type "BasicFile"
+    cache_options({ :path => "/var/chef/cache/checksums", :skip_expires => true })
+
+    # Arbitrary knife configuration data
+    knife Hash.new
+
+    # Those lists of regular expressions define what chef considers a
+    # valid user and group name
+    user_valid_regex [ /^([-a-zA-Z0-9_.]+)$/, /^\d+$/ ]
+    group_valid_regex [ /^([-a-zA-Z0-9_.]+)$/, /^\d+$/ ]
+  end
+end