TrueCar-chef 0.10.0.beta.3

data/lib/chef/run_list/run_list_item.rb

@@ -0,0 +1,92 @@
+#
+# 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.
+
+class Chef
+  class RunList
+    class RunListItem
+      QUALIFIED_RECIPE             = %r{^recipe\[([^\]@]+)(@([0-9]+(\.[0-9]+){1,2}))?\]$}
+      QUALIFIED_ROLE               = %r{^role\[([^\]]+)\]$}
+      VERSIONED_UNQUALIFIED_RECIPE = %r{^([^@]+)(@([0-9]+(\.[0-9]+){1,2}))$}
+
+      attr_reader :name, :type, :version
+
+
+      def initialize(item)
+        @version = nil
+        case item
+        when Hash
+          assert_hash_is_valid_run_list_item!(item)
+          @type = (item['type'] || item[:type]).to_sym
+          @name = item['name'] || item[:name]
+          if (item.has_key?('version') || item.has_key?(:version))
+            @version = item['version'] || item[:version]
+          end
+        when String
+          if match = QUALIFIED_RECIPE.match(item)
+            # recipe[recipe_name]
+            # recipe[recipe_name@1.0.0]
+            @type = :recipe
+            @name = match[1]
+            @version = match[3] if match[3]
+          elsif match = QUALIFIED_ROLE.match(item)
+            # role[role_name]
+            @type = :role
+            @name = match[1]
+          elsif match = VERSIONED_UNQUALIFIED_RECIPE.match(item)
+            # recipe_name@1.0.0
+            @type = :recipe
+            @name = match[1]
+            @version = match[3] if match[3]
+          else
+            # recipe_name
+            @type = :recipe
+            @name = item
+          end
+        else
+          raise ArgumentError, "Unable to create #{self.class} from #{item.class}:#{item.inspect}: must be a Hash or String"
+        end
+      end
+
+      def to_s
+        "#{@type}[#{@name}#{@version ? "@#{@version}" :""}]"
+      end
+
+      def role?
+        @type == :role
+      end
+
+      def recipe?
+        @type == :recipe
+      end
+
+      def ==(other)
+        if other.kind_of?(String)
+          self.to_s == other.to_s
+        else
+          other.respond_to?(:type) && other.respond_to?(:name) && other.respond_to?(:version) && other.type == @type && other.name == @name && other.version == @version
+        end
+      end
+
+      def assert_hash_is_valid_run_list_item!(item)
+        unless (item.key?('type')|| item.key?(:type)) && (item.key?('name') || item.key?(:name))
+          raise ArgumentError, "Initializing a #{self.class} from a hash requires that it have a 'type' and 'name' key"
+        end
+      end
+
+    end
+  end
+end

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_status.rb

@@ -0,0 +1,121 @@
+#
+# 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 :run_context
+
+  attr_writer :run_context
+
+  attr_reader :start_time
+
+  attr_reader :end_time
+
+  attr_reader :exception
+
+  attr_writer :exception
+
+  def initialize(node)
+    @node = node
+  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,99 @@
+#--
+# 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/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
+
+    # Determine the appropriate provider for the given resource, then
+    # execute it.
+    def run_action(resource, action)
+      resource.run_action(action)
+
+      # 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?
+        resource.immediate_notifications.each do |notification|
+          Chef::Log.info("#{resource} sending #{notification.action} action to #{notification.resource} (immediate)")
+          run_action(notification.resource, notification.action)
+        end
+
+        resource.delayed_notifications.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|
+        begin
+          Chef::Log.debug("Processing #{resource} on #{run_context.node.name}")
+
+          # Execute each of this resource's actions.
+          Array(resource.action).each {|action| run_action(resource, action)}
+        rescue => e
+          Chef::Log.error("#{resource} (#{resource.source_line}) had an error:\n#{e}\n#{e.backtrace.join("\n")}")
+          raise e unless resource.ignore_failure
+        end
+      end
+
+      # Run all our :delayed actions
+      delayed_actions.each do |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)
+      end
+
+      true
+    end
+  end
+end

data/lib/chef/sandbox.rb

@@ -0,0 +1,153 @@
+#
+# Author:: Tim Hinderliter (<tim@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.
+
+require 'chef/log'
+require 'uuidtools'
+
+class Chef
+  class Sandbox
+    attr_accessor :is_completed, :create_time
+    alias_method :is_completed?, :is_completed
+    attr_reader :guid
+    
+    alias :name :guid
+    
+    attr_accessor :couchdb, :couchdb_id, :couchdb_rev
+
+    # list of checksum ids
+    attr_accessor :checksums
+
+    DESIGN_DOCUMENT = {
+      "version" => 1,
+      "language" => "javascript",
+      "views" => {
+        "all" => {
+          "map" => <<-EOJS
+          function(doc) { 
+            if (doc.chef_type == "sandbox") {
+              emit(doc.guid, doc);
+            }
+          }
+          EOJS
+        },
+        "all_id" => {
+          "map" => <<-EOJS
+          function(doc) {
+            if (doc.chef_type == "sandbox") {
+              emit(doc.guid, doc.guid);
+            }
+          }
+          EOJS
+        },
+        "all_incomplete" => {
+          "map" => <<-EOJS
+          function(doc) {
+            if (doc.chef_type == "sandbox" && !doc.is_completed) {
+              emit(doc.guid, doc.guid);
+            }
+          }
+          EOJS
+        },
+        "all_completed" => {
+          "map" => <<-EOJS
+          function(doc) {
+            if (doc.chef_type == "sandbox" && doc.is_completed) {
+              emit(doc.guid, doc.guid);
+            }
+          }
+          EOJS
+        },
+      }
+    }
+    
+    # Creates a new Chef::Sandbox object.  
+    #
+    # === Returns
+    # object<Chef::Sandbox>:: Duh. :)
+    def initialize(guid=nil, couchdb=nil)
+      @guid = guid || UUIDTools::UUID.random_create.to_s.gsub(/\-/,'').downcase
+      @is_completed = false
+      @create_time = Time.now.iso8601
+      @checksums = Array.new
+    end
+
+    def include?(checksum)
+      @checksums.include?(checksum)
+    end
+
+    alias :member? :include?
+
+    def to_json(*a)
+      result = {
+        :guid => guid,
+        :name => name,   # same as guid, used for id_map
+        :checksums => checksums,
+        :create_time => create_time,
+        :is_completed => is_completed,
+        :json_class => self.class.name,
+        :chef_type => 'sandbox'
+      }
+      result["_rev"] = @couchdb_rev if @couchdb_rev
+      result.to_json(*a)
+    end
+
+    def self.json_create(o)
+      sandbox = new(o['guid'])
+      sandbox.checksums = o['checksums']
+      sandbox.create_time = o['create_time']
+      sandbox.is_completed = o['is_completed']
+      if o.has_key?('_rev')
+        sandbox.couchdb_rev = o["_rev"]
+        o.delete("_rev")
+      end
+      if o.has_key?("_id")
+        sandbox.couchdb_id = o["_id"]
+        #sandbox.index_id = sandbox.couchdb_id
+        o.delete("_id")
+      end
+      sandbox
+    end
+
+    ##
+    # Couchdb
+    ##
+    
+    def self.create_design_document(couchdb=nil)
+      (couchdb || Chef::CouchDB.new).create_design_document("sandboxes", DESIGN_DOCUMENT)
+    end
+    
+    def self.cdb_list(inflate=false, couchdb=nil)
+      rs = (couchdb || Chef::CouchDB.new).list("sandboxes", inflate)
+      lookup = (inflate ? "value" : "key")
+      rs["rows"].collect { |r| r[lookup] }            
+    end
+
+    def self.cdb_load(guid, couchdb=nil)
+      # Probably want to look for a view here at some point
+      (couchdb || Chef::CouchDB.new).load("sandbox", guid)
+    end
+
+    def cdb_destroy
+      (couchdb || Chef::CouchDB.new).delete("sandbox", guid, @couchdb_rev)
+    end
+
+    def cdb_save(couchdb=nil)
+      @couchdb_rev = (couchdb || Chef::CouchDB.new).store("sandbox", guid, self)["rev"]
+    end
+
+  end
+end