microwave 11.400.3 → 11.400.4

data/lib/chef/run_list/versioned_recipe_list.rb

@@ -0,0 +1,68 @@
+#
+# Author:: Stephen Delano (<stephen@opscode.com>)
+# Author:: Seth Falcon (<seth@opscode.com>)
+# Copyright:: Copyright 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/version_class'
+require 'chef/version_constraint'
+
+# Why does this class exist?
+# Why did we not just modify RunList/RunListItem?
+class Chef
+  class RunList
+    class VersionedRecipeList < Array
+
+      def initialize
+        super
+        @versions = Hash.new
+      end
+
+      def add_recipe(name, version=nil)
+        if version && @versions.has_key?(name)
+          unless Chef::Version.new(@versions[name]) == Chef::Version.new(version)
+            raise Chef::Exceptions::CookbookVersionConflict, "Run list requires #{name} at versions #{@versions[name]} and #{version}"
+          end
+        end
+        @versions[name] = version if version
+        self << name unless self.include?(name)
+      end
+
+      def with_versions
+        self.map {|recipe_name| {:name => recipe_name, :version => @versions[recipe_name]}}
+      end
+
+      # Return an Array of Hashes, each of the form:
+      #  {:name => RECIPE_NAME, :version_constraint => Chef::VersionConstraint }
+      def with_version_constraints
+        self.map do |recipe_name|
+          constraint = Chef::VersionConstraint.new(@versions[recipe_name])
+          { :name => recipe_name, :version_constraint => constraint }
+        end
+      end
+
+      # Return an Array of Strings, each of the form:
+      #  "NAME@VERSION"
+      def with_version_constraints_strings
+        self.map do |recipe_name|
+          if @versions[recipe_name]
+            "#{recipe_name}@#{@versions[recipe_name]}"
+          else
+            recipe_name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chef/run_lock.rb

@@ -0,0 +1,90 @@
+#
+# Author:: Daniel DeLeo (<dan@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/mixin/create_path'
+
+class Chef
+
+  # == Chef::RunLock
+  # Provides an interface for acquiring and releasing a system-wide exclusive
+  # lock.
+  #
+  # Used by Chef::Client to ensure only one instance of chef-client (or solo)
+  # is modifying the system at a time.
+  class RunLock
+    include Chef::Mixin::CreatePath
+
+    attr_reader :runlock
+    attr_reader :runlock_file
+
+    # Create a new instance of RunLock
+    # === Arguments
+    # * config::: This will generally be the `Chef::Config`, but any Hash-like
+    #   object with Symbol keys will work. See 'Parameters' section.
+    # === Parameters/Config
+    # * :lockfile::: if set, this will be used as the full path to the lockfile.
+    # * :file_cache_path::: if `:lockfile` is not set, the lock file will be
+    #   named "chef-client-running.pid" and be placed in the directory given by
+    #   `:file_cache_path`
+    def initialize(config)
+      @runlock_file = config[:lockfile] || "#{config[:file_cache_path]}/chef-client-running.pid"
+      @runlock = nil
+    end
+
+    # Acquire the system-wide lock. Will block indefinitely if another process
+    # already has the lock.
+    #
+    # Each call to acquire should have a corresponding call to #release.
+    #
+    # The implementation is based on File#flock (see also: flock(2)).
+    def acquire
+      # ensure the runlock_file path exists
+      create_path(File.dirname(runlock_file))
+      @runlock = File.open(runlock_file,'w+')
+      unless runlock.flock(File::LOCK_EX|File::LOCK_NB)
+        # Another chef client running...
+        runpid = runlock.read.strip.chomp
+        Chef::Log.info("Chef client #{runpid} is running, will wait for it to finish and then run.")
+        runlock.flock(File::LOCK_EX)
+      end
+      # We grabbed the run lock.  Save the pid.
+      runlock.truncate(0)
+      runlock.rewind # truncate doesn't reset position to 0.
+      runlock.write(Process.pid.to_s)
+    end
+
+    # Release the system-wide lock.
+    def release
+      if runlock
+        runlock.flock(File::LOCK_UN)
+        runlock.close
+        # Don't unlink the pid file, if another chef-client was waiting, it
+        # won't be recreated. Better to leave a "dead" pid file than not have
+        # it available if you need to break the lock.
+        reset
+      end
+    end
+
+    private
+
+    def reset
+      @runlock = nil
+    end
+
+  end
+end
+

data/lib/chef/run_status.rb

@@ -0,0 +1,124 @@
+#
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 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.
+#
+
+# == Chef::RunStatus
+# Tracks various aspects of a Chef run, including the Node and RunContext,
+# start and end time, and any Exception that stops the run. RunStatus objects
+# are passed to any notification or exception handlers at the completion of a
+# Chef run.
+class Chef::RunStatus
+
+  attr_reader :events
+
+  attr_reader :run_context
+
+  attr_writer :run_context
+
+  attr_reader :start_time
+
+  attr_reader :end_time
+
+  attr_reader :exception
+
+  attr_writer :exception
+
+  def initialize(node, events)
+    @node = node
+    @events = events
+  end
+
+  def node
+    @node
+  end
+
+  # sets +start_time+ to the current time.
+  def start_clock
+    @start_time = Time.now
+  end
+
+  # sets +end_time+ to the current time
+  def stop_clock
+    @end_time = Time.now
+  end
+
+  # The elapsed time between +start_time+ and +end_time+. Returns +nil+ if
+  # either value is not set.
+  def elapsed_time
+    if @start_time && @end_time
+      @end_time - @start_time
+    else
+      nil
+    end
+  end
+
+  # The list of all resources in the current run context's +resource_collection+
+  def all_resources
+    @run_context && @run_context.resource_collection.all_resources
+  end
+
+  # The list of all resources in the current run context's +resource_collection+
+  # that are marked as updated
+  def updated_resources
+    @run_context && @run_context.resource_collection.select { |r| r.updated }
+  end
+
+  # The backtrace from +exception+, if any
+  def backtrace
+    @exception && @exception.backtrace
+  end
+
+  # Did the Chef run fail?
+  def failed?
+    !success?
+  end
+
+  # Did the chef run succeed? returns +true+ if no exception has been set.
+  def success?
+    @exception.nil?
+  end
+
+  # A Hash representation of the RunStatus, with the following (Symbol) keys:
+  # * :node
+  # * :success
+  # * :start_time
+  # * :end_time
+  # * :elapsed_time
+  # * :all_resources
+  # * :updated_resources
+  # * :exception
+  # * :backtrace
+  def to_hash
+    # use a flat hash here so we can't errors from intermediate values being nil
+    { :node => node,
+      :success => success?,
+      :start_time => start_time,
+      :end_time => end_time,
+      :elapsed_time => elapsed_time,
+      :all_resources => all_resources,
+      :updated_resources => updated_resources,
+      :exception => formatted_exception,
+      :backtrace => backtrace}
+  end
+
+  # Returns a string of the format "ExceptionClass: message" or +nil+ if no
+  # +exception+ is set.
+  def formatted_exception
+    @exception && "#{@exception.class.name}: #{@exception.message}"
+  end
+
+end

data/lib/chef/runner.rb

@@ -0,0 +1,118 @@
+#--
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Christopher Walters (<cw@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/exceptions'
+require 'chef/mixin/params_validate'
+require 'chef/node'
+require 'chef/resource_collection'
+require 'chef/platform'
+
+class Chef
+  # == Chef::Runner
+  # This class is responsible for executing the steps in a Chef run.
+  class Runner
+
+    attr_reader :run_context
+
+    attr_reader :delayed_actions
+
+    include Chef::Mixin::ParamsValidate
+
+    def initialize(run_context)
+      @run_context      = run_context
+      @delayed_actions  = []
+    end
+
+    def events
+      @run_context.events
+    end
+
+    # Determine the appropriate provider for the given resource, then
+    # execute it.
+    def run_action(resource, action, notification_type=nil, notifying_resource=nil)
+      resource.run_action(action, notification_type, notifying_resource)
+
+      # Execute any immediate and queue up any delayed notifications
+      # associated with the resource, but only if it was updated *this time*
+      # we ran an action on it.
+      if resource.updated_by_last_action?
+        run_context.immediate_notifications(resource).each do |notification|
+          Chef::Log.info("#{resource} sending #{notification.action} action to #{notification.resource} (immediate)")
+          run_action(notification.resource, notification.action, :immediate, resource)
+        end
+
+        run_context.delayed_notifications(resource).each do |notification|
+          if delayed_actions.any? { |existing_notification| existing_notification.duplicates?(notification) }
+            Chef::Log.info( "#{resource} not queuing delayed action #{notification.action} on #{notification.resource}"\
+                            " (delayed), as it's already been queued")
+          else
+            delayed_actions << notification
+          end
+        end
+      end
+    end
+
+    # Iterates over the +resource_collection+ in the +run_context+ calling
+    # +run_action+ for each resource in turn.
+    def converge
+      # Resolve all lazy/forward references in notifications
+      run_context.resource_collection.each do |resource|
+        resource.resolve_notification_references
+      end
+
+      # Execute each resource.
+      run_context.resource_collection.execute_each_resource do |resource|
+        Array(resource.action).each {|action| run_action(resource, action)}
+      end
+
+    rescue Exception => e
+      Chef::Log.info "Running queued delayed notifications before re-raising exception"
+      run_delayed_notifications(e)
+    else
+      run_delayed_notifications(nil)
+      true
+    end
+
+    private
+
+    # Run all our :delayed actions
+    def run_delayed_notifications(error=nil)
+      collected_failures = Exceptions::MultipleFailures.new
+      collected_failures.client_run_failure(error) unless error.nil?
+      delayed_actions.each do |notification|
+        result = run_delayed_notification(notification)
+        if result.kind_of?(Exception)
+          collected_failures.notification_failure(result)
+        end
+      end
+      collected_failures.raise!
+    end
+
+    def run_delayed_notification(notification)
+      Chef::Log.info( "#{notification.notifying_resource} sending #{notification.action}"\
+                      " action to #{notification.resource} (delayed)")
+      # Struct of resource/action to call
+      run_action(notification.resource, notification.action, :delayed)
+      true
+    rescue Exception => e
+      e
+    end
+  end
+end

data/lib/chef/sandbox.rb

@@ -0,0 +1,20 @@
+class Chef
+  class Sandbox
+    # I DO NOTHING!!
+
+    # So, the reason we have a completely empty class here is so that
+    # Chef 11 clients do not choke when interacting with Chef 10
+    # servers.  The original Chef::Sandbox class (that actually did
+    # things) has been removed since its functionality is no longer
+    # needed for Chef 11.  However, since we still use the JSON gem
+    # and make use of its "auto-inflation" of classes (driven by the
+    # contents of the 'json_class' key in all of our JSON), any
+    # sandbox responses from a Chef 10 server to a Chef 11 client
+    # would cause knife to crash.  The JSON gem would attempt to
+    # auto-inflate based on a "json_class": "Chef::Sandbox" hash
+    # entry, but would not be able to find a Chef::Sandbox class!
+    #
+    # This is a workaround until such time as we can completely remove
+    # the reliance on the "json_class" field.
+  end
+end

data/lib/chef/scan_access_control.rb

@@ -0,0 +1,133 @@
+#--
+# Author:: Daniel DeLeo (<dan@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.
+#
+
+class Chef
+  # == ScanAccessControl
+  # Reads Access Control Settings on a file and writes them out to a resource
+  # (should be the current_resource), attempting to match the style used by the
+  # new resource, that is, if users are specified with usernames in
+  # new_resource, then the uids from stat will be looked up and usernames will
+  # be added to current_resource.
+  #
+  # === Why?
+  # FileAccessControl objects may operate on a temporary file, in which case we
+  # won't know if the access control settings changed (ex: rendering a template
+  # with both a change in content and ownership). For auditing purposes, we
+  # need to record the current state of a file system entity.
+  #--
+  # Not yet sure if this is the optimal way to solve the problem. But it's
+  # progress towards the end goal.
+  #
+  # TODO: figure out if all this works with OS X's negative uids
+  # TODO: windows
+  class ScanAccessControl
+
+    attr_reader :new_resource
+    attr_reader :current_resource
+
+    def initialize(new_resource, current_resource)
+      @new_resource, @current_resource = new_resource, current_resource
+    end
+
+    # Modifies @current_resource, setting the current access control state.
+    def set_all!
+      if ::File.exist?(new_resource.path)
+        set_owner
+        set_group
+        set_mode
+      else
+        # leave the values as nil.
+      end
+    end
+
+    # Set the owner attribute of +current_resource+ to whatever the current
+    # state is. Attempts to match the format given in new_resource: if the
+    # new_resource specifies the owner as a string, the username for the uid
+    # will be looked up and owner will be set to the username, and vice versa.
+    def set_owner
+      @current_resource.owner(current_owner)
+    end
+
+    def current_owner
+      case new_resource.owner
+      when String, nil
+        lookup_uid
+      when Integer
+        stat.uid
+      else
+        Chef::Log.error("The `owner` parameter of the #@new_resource resource is set to an invalid value (#{new_resource.owner.inspect})")
+        raise ArgumentError, "cannot resolve #{new_resource.owner.inspect} to uid, owner must be a string or integer"
+      end
+    end
+
+    def lookup_uid
+      unless (pwent = Etc.getpwuid(stat.uid)).nil?
+        pwent.name
+      else
+        stat.uid
+      end
+    rescue ArgumentError
+      stat.uid
+    end
+
+    # Set the group attribute of +current_resource+ to whatever the current state is.
+    def set_group
+      @current_resource.group(current_group)
+    end
+
+    def current_group
+      case new_resource.group
+      when String, nil
+        lookup_gid
+      when Integer
+        stat.gid
+      else
+        Chef::Log.error("The `group` parameter of the #@new_resource resource is set to an invalid value (#{new_resource.owner.inspect})")
+        raise ArgumentError, "cannot resolve #{new_resource.group.inspect} to gid, group must be a string or integer"
+      end
+    end
+
+    def lookup_gid
+      unless (pwent = Etc.getgrgid(stat.gid)).nil?
+        pwent.name
+      else
+        stat.gid
+      end
+    rescue ArgumentError
+      stat.gid
+    end
+
+    def set_mode
+      @current_resource.mode(current_mode)
+    end
+
+    def current_mode
+      case new_resource.mode
+      when String, Integer, nil
+        "0#{(stat.mode & 07777).to_s(8)}"
+      else
+        Chef::Log.error("The `mode` parameter of the #@new_resource resource is set to an invalid value (#{new_resource.mode.inspect})")
+        raise ArgumentError, "Invalid value #{new_resource.mode.inspect} for `mode` on resource #@new_resource"
+      end
+    end
+
+    def stat
+      @stat ||= @new_resource.instance_of?(Chef::Resource::Link) ? ::File.lstat(@new_resource.path) : ::File.stat(@new_resource.path)
+    end
+  end
+end