chef 0.8.16 → 0.9.0.a3

data/lib/chef/run_list/run_list_expansion.rb

@@ -0,0 +1,156 @@
+#
+# 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.
+
+require 'extlib'
+
+require 'chef/mixin/deep_merge'
+
+require 'chef/role'
+require 'chef/couchdb'
+require 'chef/rest'
+
+class Chef
+  class RunList
+    # Abstract Base class for expanding a run list. Subclasses must handle
+    # fetching roles from a data source by defining +fetch_role+
+    class RunListExpansion
+
+      attr_reader :run_list_items
+
+      attr_reader :recipes
+
+      attr_reader :default_attrs
+
+      attr_reader :override_attrs
+
+      # The data source passed to the constructor. Not used in this class.
+      # In subclasses, this is a couchdb or Chef::REST object pre-configured
+      # to fetch roles from their correct location.
+      attr_reader :source
+
+      def initialize(run_list_items, source=nil)
+        @run_list_items = run_list_items.dup
+        @source = source
+
+        @default_attrs = Mash.new
+        @override_attrs = Mash.new
+
+        @recipes = []
+
+        @applied_roles = {}
+      end
+
+      # Iterates over the run list items, expanding roles. After this,
+      # +recipes+ will the fully expanded recipe list
+      def expand
+        @run_list_items.each_with_index do |entry, index|
+          case entry.type
+          when :recipe
+            recipes << entry.name unless recipes.include?(entry.name)
+          when :role
+            if role = inflate_role(entry.name)
+              apply_role_attributes(role)
+              @run_list_items.insert(index + 1, *role.run_list.run_list_items)
+            end
+          end
+        end
+      end
+
+      # Fetches and inflates a role
+      # === Returns
+      # Chef::Role  in most cases
+      # false       if the role has already been applied
+      # nil         if the role does not exist
+      def inflate_role(role_name)
+        return false if applied_role?(role_name) # Prevent infinite loops
+        applied_role(role_name)
+        fetch_role(role_name)
+      end
+
+      def apply_role_attributes(role)
+        @default_attrs = Chef::Mixin::DeepMerge.merge(@default_attrs, role.default_attributes)
+        @override_attrs = Chef::Mixin::DeepMerge.merge(@override_attrs, role.override_attributes)
+      end
+
+      def applied_role?(role_name)
+        @applied_roles.has_key?(role_name)
+      end
+
+      def applied_role(role_name)
+        @applied_roles[role_name] = true
+      end
+
+      # In subclasses, this method will fetch the role from the data source.
+      def fetch_role(name)
+        raise NotImplementedError
+      end
+
+      # When a role is not found, an error message should be logged, but no
+      # exception should be raised
+      # === Returns
+      # nil
+      def role_not_found(name)
+        Chef::Log.error("Role #{name} is in the runlist but does not exist. Skipping expand.")
+        nil
+      end
+    end
+
+    # Expand a run list from disk. Suitable for chef-solo
+    class RunListExpansionFromDisk < RunListExpansion
+
+      def fetch_role(name)
+        Chef::Role.from_disk(name)
+      rescue Chef::Exceptions::RoleNotFound
+        role_not_found(name)
+      end
+
+    end
+
+    # Expand a run list from the chef-server API.
+    class RunListExpansionFromAPI < RunListExpansion
+
+      def rest
+        @rest ||= (source || Chef::REST.new(Chef::Config[:role_url]))
+      end
+
+      def fetch_role(name)
+        rest.get_rest("roles/#{name}")
+      rescue Net::HTTPServerException => e
+        if e.message == '404 "Not Found"'
+          role_not_found(name)
+        else
+          raise
+        end
+      end
+    end
+
+    # Expand a run list from couchdb. Used in chef-server-api
+    class RunListExpansionFromCouchDB < RunListExpansion
+
+      def couchdb
+        source
+      end
+
+      def fetch_role(name)
+        Chef::Role.cdb_load(name, couchdb)
+      rescue Chef::Exceptions::CouchDBNotFound
+        role_not_found(name)
+      end
+
+    end
+  end
+end

data/lib/chef/run_list/run_list_item.rb

@@ -0,0 +1,71 @@
+#
+# 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\[([^\]]+)\]$}
+      QUALIFIED_ROLE   = %r{^role\[([^\]]+)\]$}
+
+      attr_reader :name
+
+      attr_reader :type
+
+      def initialize(item)
+        case item
+        when Hash
+          raise ArgumentError, "Initializing a #{self.class} from a hash requires that it have a 'type' and 'name' key" unless (item.has_key?('type')||item.has_key?(:type)) && (item.has_key?('name')||item.has_key?(:name))
+          @type = (item['type'] || item[:type]).to_sym
+          @name = item['name'] || item[:name]
+        when String
+          if match = QUALIFIED_RECIPE.match(item)
+            @type = :recipe
+            @name = match[1]
+          elsif match = QUALIFIED_ROLE.match(item)
+            @type = :role
+            @name = match[1]
+          else
+            @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}]"
+      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.type == @type && other.name == @name
+        end
+      end
+    end
+  end
+end

data/lib/chef/runner.rb

@@ -1,6 +1,8 @@
 #
 # Author:: Adam Jacob (<adam@opscode.com>)
-# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# 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");
@@ -21,78 +23,67 @@ require 'chef/node'
 require 'chef/resource_collection'
 require 'chef/platform'
 
+# This class is responsible for executing the steps in a Chef run.
 class Chef
   class Runner
     
-    include Chef::Mixin::ParamsValidate
+    attr_reader :run_context
     
-    def initialize(node, collection, definitions={}, cookbook_loader=nil)
-      validate(
-        {
-          :node => node,
-          :collection => collection,
-        },
-        {
-          :node => {
-            :kind_of => Chef::Node,
-          },
-          :collection => {
-            :kind_of => Chef::ResourceCollection,
-          },
-        }
-      )
-      @node = node
-      @collection = collection
-      @definitions = definitions
-      @cookbook_loader = cookbook_loader
+    include Chef::Mixin::ParamsValidate
+
+    def initialize(run_context)
+      @run_context = run_context
     end
     
     def build_provider(resource)
-      provider_klass = Chef::Platform.find_provider_for_node(@node, resource)
-      Chef::Log.debug("#{resource} using #{provider_klass.to_s}")
-      provider = provider_klass.new(@node, resource, @collection, @definitions, @cookbook_loader)
+      provider_class = Chef::Platform.find_provider_for_node(run_context.node, resource)
+      Chef::Log.debug("#{resource} using #{provider_class.to_s}")
+      provider = provider_class.new(resource, run_context)
       provider.load_current_resource
       provider
     end
-
-    def run_action(resource, ra)
+    
+    # Determine the appropriate provider for the given resource, then
+    # execute it.
+    def run_action(resource, action, delayed_actions)
       provider = build_provider(resource)
-      provider.send("action_#{ra}")
-
+      provider.send("action_#{action}")
+      
+      # Execute any immediate and queue up any delayed notifications
+      # associated with the resource.
       if resource.updated
-        resource.actions.each_key do |action|
-          if resource.actions[action].has_key?(:immediate)
-            resource.actions[action][:immediate].each do |r|
-              Chef::Log.info("#{resource} sending #{action} action to #{r} (immediate)")
-              run_action(r, action)
-            end
-          end
-          if resource.actions[action].has_key?(:delayed)
-            resource.actions[action][:delayed].each do |r|
-              @delayed_actions[r] = Hash.new unless @delayed_actions.has_key?(r)
-              unless @delayed_actions[r].has_key?(action)
-                @ordered_delayed_actions << [r, action]
-                @delayed_actions[r][action] = Array.new
-              end
-              @delayed_actions[r][action] << lambda {
-                Chef::Log.info("#{resource} sending #{action} action to #{r} (delayed)")
-              } 
-            end
+        resource.notifies_immediate.each do |notify|
+          Chef::Log.info("#{resource} sending #{notify.action} action to #{notify.resource} (immediate)")
+          run_action(notify.resource, notify.action, delayed_actions)
+        end
+        
+        resource.notifies_delayed.each do |notify|
+          unless delayed_actions.include?(notify)
+            delayed_actions << notify
+            delayed_actions << lambda {
+              Chef::Log.info("#{resource} sending #{notify.action} action to #{notify.resource} (delayed)")
+            }
+          else
+            delayed_actions << lambda {
+              Chef::Log.info("#{resource} not sending #{notify.action} action to #{notify.resource} (delayed), as it's already been queued")
+            }
           end
         end
       end
     end
-
+    
+    # Executes a Chef run.
     def converge
-
-      @delayed_actions = Hash.new
-      @ordered_delayed_actions = []
+      delayed_actions = Array.new
       
-      @collection.execute_each_resource do |resource|
+      # Execute each resource.
+      run_context.resource_collection.execute_each_resource do |resource|
         begin
-          Chef::Log.debug("Processing #{resource}")
+          Chef::Log.debug("Processing #{resource} on #{run_context.node.name}")
           
-          # Check if this resource has an only_if block - if it does, skip it.
+          # Check if this resource has an only_if block -- if it does,
+          # evaluate the only_if block and skip the resource if
+          # appropriate.
           if resource.only_if
             unless Chef::Mixin::Command.only_if(resource.only_if, resource.only_if_args)
               Chef::Log.debug("Skipping #{resource} due to only_if")
@@ -100,7 +91,9 @@ class Chef
             end
           end
           
-          # Check if this resource has a not_if block - if it does, skip it.
+          # Check if this resource has a not_if block -- if it does,
+          # evaluate the not_if block and skip the resource if
+          # appropriate.
           if resource.not_if
             unless Chef::Mixin::Command.not_if(resource.not_if, resource.not_if_args)
               Chef::Log.debug("Skipping #{resource} due to not_if")
@@ -108,10 +101,10 @@ class Chef
             end
           end
           
-          # Walk the actions for this resource, building the provider and running each.
+          # Execute each of this resource's actions.
           action_list = resource.action.kind_of?(Array) ? resource.action : [ resource.action ]
-          action_list.each do |ra|
-            run_action(resource, ra)
+          action_list.each do |action|
+            run_action(resource, action, delayed_actions)
           end
         rescue => e
           Chef::Log.error("#{resource} (#{resource.source_line}) had an error:\n#{e}\n#{e.backtrace.join("\n")}")
@@ -120,10 +113,14 @@ class Chef
       end
       
       # Run all our :delayed actions
-      @ordered_delayed_actions.each do |resource, action| 
-        log_array = @delayed_actions[resource][action]
-        log_array.each { |l| l.call } # Call each log message
-        run_action(resource, action)
+      delayed_actions.each do |notify_or_lambda|
+        if notify_or_lambda.is_a?(Proc)
+          # log message
+          notify_or_lambda.call
+        else
+          # OpenStruct of resource/action to call
+          run_action(notify_or_lambda.resource, notify_or_lambda.action, delayed_actions)
+        end
       end
 
       true

data/lib/chef/sandbox.rb

@@ -0,0 +1,147 @@
+#
+# 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 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