chef 0.7.10

data/lib/chef/run_list.rb

@@ -0,0 +1,156 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Copyright:: Copyright (c) 2008, 2009 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/deep_merge'
+
+class Chef
+  class RunList
+    include Enumerable
+
+    attr_reader :recipes, :roles, :run_list
+
+    def initialize
+      @run_list = Array.new
+      @recipes = Array.new
+      @roles = Array.new
+    end
+
+    def <<(item)
+      type, entry, fentry = parse_entry(item)
+      case type
+      when 'recipe'
+        @recipes << entry unless @recipes.include?(entry)
+      when 'role'
+        @roles << entry unless @roles.include?(entry)
+      end
+      @run_list << fentry unless @run_list.include?(fentry)
+      self
+    end
+
+    def ==(*isequal)
+      check_array = nil
+      if isequal[0].kind_of?(Chef::RunList)
+        check_array = isequal[0].run_list
+      else
+        check_array = isequal.flatten
+      end
+      
+      return false if check_array.length != @run_list.length
+
+      check_array.each_index do |i|
+        to_check = check_array[i]
+        type, name, fname = parse_entry(to_check)
+        return false if @run_list[i] != fname
+      end
+
+      true
+    end
+
+    def empty?
+      @run_list.length == 0 ? true : false
+    end
+
+    def [](pos)
+      @run_list[pos]
+    end
+
+    def []=(pos, item)
+      type, entry, fentry = parse_entry(item)
+      @run_list[pos] = fentry 
+    end
+
+    def each(&block)
+      @run_list.each { |i| block.call(i) }
+    end
+
+    def each_index(&block)
+      @run_list.each_index { |i| block.call(i) }
+    end
+
+    def include?(item)
+      type, entry, fentry = parse_entry(item)
+      @run_list.include?(fentry)
+    end
+
+    def reset(*args)
+      @run_list = Array.new
+      @recipes = Array.new
+      @roles = Array.new
+      args.flatten.each do |item|
+        if item.kind_of?(Chef::RunList)
+          item.each { |r| self << r }
+        else
+          self << item
+        end
+      end
+      self
+    end
+
+    def remove(item)
+      type, entry, fentry = parse_entry(item)
+      @run_list.delete_if { |i| i == fentry }
+      if type == "recipe"
+        @recipes.delete_if { |i| i == entry }
+      elsif type == "role"
+        @roles.delete_if { |i| i == entry }
+      end
+      self
+    end
+
+    def expand(from='server')
+      recipes = Array.new
+      default_attrs = Mash.new
+      override_attrs = Mash.new
+      
+      @run_list.each do |entry|
+        type, name, fname = parse_entry(entry)
+        case type
+        when 'recipe'
+          recipes << name unless recipes.include?(name)
+        when 'role'
+          role = nil
+          if from == 'disk' || Chef::Config[:solo]
+            # Load the role from disk
+            role = Chef::Role.from_disk("#{name}")
+          elsif from == 'server'
+            # Load the role from the server
+            r = Chef::REST.new(Chef::Config[:role_url])
+            role = r.get_rest("roles/#{name}")
+          elsif from == 'couchdb'
+            # Load the role from couchdb
+            role = Chef::Role.load(name)
+          end
+          role.recipes.each { |r| recipes <<  r unless recipes.include?(r) }
+          default_attrs = Chef::Mixin::DeepMerge.merge(default_attrs, role.default_attributes)
+          override_attrs = Chef::Mixin::DeepMerge.merge(override_attrs, role.override_attributes)
+        end
+      end
+      return recipes, default_attrs, override_attrs
+    end
+
+    def parse_entry(entry)
+      case entry 
+      when /^(.+)\[(.+)\]$/
+        [ $1, $2, entry ]
+      else
+        [ 'recipe', entry, "recipe[#{entry}]" ]
+      end
+    end
+
+  end
+end
+

data/lib/chef/runner.rb

@@ -0,0 +1,123 @@
+#
+# Author:: Adam Jacob (<adam@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/mixin/params_validate'
+require 'chef/node'
+require 'chef/resource_collection'
+require 'chef/platform'
+
+class Chef
+  class Runner
+    
+    include Chef::Mixin::ParamsValidate
+    
+    def initialize(node, collection)
+      validate(
+        {
+          :node => node,
+          :collection => collection,
+        },
+        {
+          :node => {
+            :kind_of => Chef::Node,
+          },
+          :collection => {
+            :kind_of => Chef::ResourceCollection,
+          },
+        }
+      )
+      @node = node
+      @collection = collection
+    end
+    
+    def build_provider(resource)
+      provider_klass = resource.provider
+      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)
+      provider.load_current_resource
+      provider
+    end
+    
+    def converge
+
+      delayed_actions = Hash.new
+      
+      @collection.each do |resource|
+        begin
+          Chef::Log.debug("Processing #{resource}")
+          
+          # Check if this resource has an only_if block - if it does, skip it.
+          if resource.only_if
+            unless Chef::Mixin::Command.only_if(resource.only_if)
+              Chef::Log.debug("Skipping #{resource} due to only_if")
+              next
+            end
+          end
+          
+          # Check if this resource has a not_if block - if it does, skip it.
+          if resource.not_if
+            unless Chef::Mixin::Command.not_if(resource.not_if)
+              Chef::Log.debug("Skipping #{resource} due to not_if")
+              next
+            end
+          end
+          
+          # Walk the actions for this resource, building the provider and running each.
+          action_list = resource.action.kind_of?(Array) ? resource.action : [ resource.action ]
+          action_list.each do |ra|
+            provider = build_provider(resource)
+            provider.send("action_#{ra}")
+            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)")
+                    build_provider(r).send("action_#{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)
+                    delayed_actions[r][action] = Array.new unless delayed_actions[r].has_key?(action)
+                    delayed_actions[r][action] << lambda {
+                      Chef::Log.info("#{resource} sending #{action} action to #{r} (delayed)")
+                    } 
+                  end
+                end
+              end
+            end
+          end
+        rescue => e
+          Chef::Log.error("#{resource} (#{resource.source_line}) had an error:\n#{e}\n#{e.backtrace}")
+          raise e unless resource.ignore_failure
+        end
+      end
+      
+      # Run all our :delayed actions
+      delayed_actions.each do |resource, action_hash| 
+        action_hash.each do |action, log_array|
+          log_array.each { |l| l.call } # Call each log message
+          build_provider(resource).send("action_#{action}") 
+        end
+      end
+
+      true
+    end
+  end
+end

data/lib/chef/search.rb

@@ -0,0 +1,88 @@
+#
+# Author:: Adam Jacob (<adam@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/search/result'
+require 'ferret'
+
+class Chef
+  class Search
+    
+    attr_reader :index
+    
+    def initialize
+      @index = Ferret::Index::Index.new(:path => Chef::Config[:search_index_path])
+    end
+    
+    def search(type, query="*", attributes=[], &block)
+      search_query = build_search_query(type, query)
+      start_time = Time.now
+      results = []
+      block ||= lambda { |b| b }
+      
+      @index.search_each(search_query, :limit => :all) do |id, score|
+        results << block.call(build_hash(@index.doc(id)))
+      end
+      
+      Chef::Log.debug("Search #{search_query} complete in #{Time.now - start_time} seconds")
+      
+      attributes.empty? ? results : filter_by_attributes(results,attributes)
+    end
+    
+    def filter_by_attributes(results, attributes)
+      results.collect do |r|
+        nr = Hash.new
+        nr[:index_name] = r[:index_name]
+        nr[:id] = r[:id]
+        attributes.each do |attrib|
+          if r.has_key?(attrib)
+            nr[attrib] = r[attrib]
+          end
+        end
+        nr
+      end
+    end
+    
+    private :filter_by_attributes
+    
+    def list_indexes
+      indexes = Hash.new
+      @index.search_each("index_name:*", :limit => :all) do |id, score|
+        indexes[@index.doc(id)["index_name"]] = true
+      end
+      indexes.keys
+    end
+    
+    def has_index?(index)
+      list_indexes.detect { |i| i == index }
+    end
+    
+    private
+      def build_search_query(type, query)
+        query = "id:*" if query == '*'
+        "index_name:#{type} AND (#{query})"
+      end
+    
+      def build_hash(doc)
+        result = Chef::Search::Result.new
+        doc.fields.each do |f|
+          result[f] = doc[f]
+        end
+        result
+      end
+  end
+end

data/lib/chef/search/result.rb

@@ -0,0 +1,64 @@
+#
+# Author:: Adam Jacob (<adam@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 'extlib'
+
+class Chef
+  class Search
+    class Result
+
+      def initialize
+        proc = lambda do |h,k| 
+            newhash = Mash.new(&proc)
+            h.each do |pk, pv| 
+              rx = /^#{k.to_s}_/ 
+              if pk =~ rx 
+                newhash[ pk.gsub(rx,'') ] = pv 
+              end 
+            end 
+            newhash 
+          end 
+        @internal = Mash.new(&proc) 
+      end
+
+      def method_missing(symbol, *args, &block)
+        @internal.send(symbol, *args, &block)
+      end
+
+      # Serialize this object as a hash 
+      def to_json(*a)
+        result = {
+          'json_class' => self.class.name,
+          'results' => @internal
+        }
+        result.to_json(*a)
+      end
+      
+      # Create a Chef::Search::Result from JSON
+      def self.json_create(o)
+        result = self.new
+        o['results'].each do |k,v|
+          result[k] = v
+        end
+        result
+      end
+    end
+  end
+end
+
+

data/lib/chef/search_index.rb

@@ -0,0 +1,77 @@
+#
+# Author:: Adam Jacob (<adam@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 'ferret'
+
+class Chef
+  class SearchIndex
+    
+    attr_reader :index
+    
+    def initialize
+      @index = Ferret::Index::Index.new(
+        :path => Chef::Config[:search_index_path],
+        :key => [ :id ]
+      )
+    end
+    
+    def add(new_object)
+      index_hash = create_index_object(new_object)
+      Chef::Log.debug("Indexing #{index_hash[:index_name]} with #{index_hash.inspect}")
+      @index.add_document(index_hash)
+    end
+    
+    def create_index_object(new_object)
+      index_hash = nil
+      
+      if new_object.respond_to?(:to_index)
+        index_hash = new_object.to_index
+      elsif new_object.kind_of?(Hash)
+        index_hash = new_object
+      else
+        raise Chef::Exceptions::SearchIndex, "Cannot transform argument to a Hash!" 
+      end
+      
+      unless index_hash.has_key?(:index_name) || index_hash.has_key?("index_name")
+        raise Chef::Exceptions::SearchIndex, "Cannot index without an index_name key: #{index_hash.inspect}"
+      end
+      
+      unless index_hash.has_key?(:id) || index_hash.has_key?("id")
+        raise Chef::Exceptions::SearchIndex, "Cannot index without an id key: #{index_hash.inspect}"
+      end
+     
+      sanitized_hash = Hash.new
+      index_hash.each do |k,v|
+        sanitized_hash[k.to_sym] = v
+      end
+    
+      sanitized_hash
+    end
+        
+    def delete(index_obj)
+      to_delete = create_index_object(index_obj)
+      Chef::Log.debug("Removing #{to_delete.inspect} from the #{to_delete[:index_name]} index")
+      @index.delete(to_delete[:id])
+    end
+    
+    def commit
+      @index.commit
+    end
+    
+  end
+end