chef 0.7.16 → 0.8.2

data/lib/chef/role.rb

@@ -1,5 +1,7 @@
 #
 # Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Nuo Yan (<nuo@opscode.com>)
+# Author:: Christopher Brown (<cb@opscode.com>)
 # Copyright:: Copyright (c) 2008 Opscode, Inc.
 # License:: Apache License, Version 2.0
 #
@@ -20,6 +22,8 @@ require 'chef/config'
 require 'chef/mixin/params_validate'
 require 'chef/mixin/from_file'
 require 'chef/couchdb'
+require 'chef/run_list'
+require 'chef/index_queue'
 require 'extlib'
 require 'json'
 
@@ -28,9 +32,10 @@ class Chef
     
     include Chef::Mixin::FromFile
     include Chef::Mixin::ParamsValidate
+    include Chef::IndexQueue::Indexable
     
     DESIGN_DOCUMENT = {
-      "version" => 3,
+      "version" => 6,
       "language" => "javascript",
       "views" => {
         "all" => {
@@ -50,21 +55,36 @@ class Chef
             }
           }
           EOJS
-        },
-      },
+        }
+      }
     }
 
-    attr_accessor :couchdb_rev
+    attr_accessor :couchdb_rev, :couchdb
+    attr_reader :couchdb_id
     
     # Create a new Chef::Role object.
-    def initialize()
+    def initialize(couchdb=nil)
       @name = '' 
       @description = '' 
       @default_attributes = Mash.new
       @override_attributes = Mash.new
-      @recipes = Array.new 
+      @run_list = Chef::RunList.new 
       @couchdb_rev = nil
-      @couchdb = Chef::CouchDB.new
+      @couchdb_id = nil
+      @couchdb = couchdb || Chef::CouchDB.new
+    end
+
+    def couchdb_id=(value)
+      @couchdb_id = value
+      self.index_id = value
+    end
+
+    def chef_server_rest
+      Chef::REST.new(Chef::Config[:chef_server_url])
+    end
+
+    def self.chef_server_rest
+      Chef::REST.new(Chef::Config[:chef_server_url])
     end
 
     def name(arg=nil) 
@@ -83,18 +103,17 @@ class Chef
       )
     end
 
-    def recipes(*arg) 
-      arg.flatten!
-      if arg.length == 0
-        @recipes
-      else
-        arg.each do |entry|
-          raise ArgumentError, 'Recipes must be strings!' unless entry.kind_of?(String)
-        end
-        @recipes = arg
-      end
+    def run_list(*args)
+      (args.length > 0) ? @run_list.reset!(args) : @run_list
     end
 
+    alias_method :recipes, :run_list
+
+#     def recipes(*args)
+#       Chef::Log.warn "Chef::Role#recipes method is deprecated.  Please use Chef::Role#run_list"
+#       run_list(*args)
+#     end
+        
     def default_attributes(arg=nil)
       set_or_return(
         :default_attributes,
@@ -119,9 +138,9 @@ class Chef
         "default_attributes" => @default_attributes,
         "override_attributes" => @override_attributes,
         "chef_type" => "role",
-        "recipes" => @recipes,
+        "run_list" => @run_list.run_list
       }
-      result["_rev"] = @couchdb_rev if @couchdb_rev
+      result["_rev"] = couchdb_rev if couchdb_rev
       result
     end
 
@@ -137,56 +156,113 @@ class Chef
       role.description(o["description"])
       role.default_attributes(o["default_attributes"])
       role.override_attributes(o["override_attributes"])
-      role.recipes(o["recipes"])
+      role.run_list(if o.has_key?("run_list")
+                      o["run_list"]
+                    else
+                      o["recipes"]
+                    end)
       role.couchdb_rev = o["_rev"] if o.has_key?("_rev")
+      role.index_id = role.couchdb_id
+      role.couchdb_id = o["_id"] if o.has_key?("_id")
       role 
     end
     
     # List all the Chef::Role objects in the CouchDB.  If inflate is set to true, you will get
     # the full list of all Roles, fully inflated.
+    def self.cdb_list(inflate=false, couchdb=nil)
+      rs = (couchdb || Chef::CouchDB.new).list("roles", inflate)
+      lookup = (inflate ? "value" : "key")
+      rs["rows"].collect { |r| r[lookup] }            
+    end
+
+    # Get the list of all roles from the API.
     def self.list(inflate=false)
-      rs = Chef::CouchDB.new.list("roles", inflate)
       if inflate
-        rs["rows"].collect { |r| r["value"] }
+        response = Hash.new
+        Chef::Search::Query.new.search(:role) do |n|
+          response[n.name] = n unless n.nil?
+        end
+        response
       else
-        rs["rows"].collect { |r| r["key"] }
+        chef_server_rest.get_rest("roles")
       end
     end
     
     # Load a role by name from CouchDB
+    def self.cdb_load(name, couchdb=nil)
+      (couchdb || Chef::CouchDB.new).load("role", name)
+    end
+    
+    # Load a role by name from the API
     def self.load(name)
-      Chef::CouchDB.new.load("role", name)
+      chef_server_rest.get_rest("roles/#{name}")
+    end
+
+    def self.exists?(rolename, couchdb)
+      begin
+        self.cdb_load(rolename, couchdb)
+      rescue Chef::Exceptions::CouchDBNotFound
+        nil
+      end
     end
     
     # Remove this role from the CouchDB
-    def destroy
-      @couchdb.delete("role", @name, @couchdb_rev)
+    def cdb_destroy
+      couchdb.delete("role", @name, couchdb_rev)
 
       if Chef::Config[:couchdb_version] == 0.9
-        rs = @couchdb.get_view("nodes", "by_run_list", :startkey => "role[#{@name}]", :endkey => "role[#{@name}]", :include_docs => true)
+        rs = couchdb.get_view("nodes", "by_run_list", :startkey => "role[#{@name}]", :endkey => "role[#{@name}]", :include_docs => true)
         rs["rows"].each do |row| 
           node = row["doc"]
           node.run_list.remove("role[#{@name}]")
-          node.save
+          node.cdb_save
         end
       else
-       Chef::Node.list.each do |node|
-         n = Chef::Node.load(node)
+       Chef::Node.cdb_list.each do |node|
+         n = Chef::Node.cdb_load(node)
          n.run_list.remove("role[#{@name}]")
-         n.save
+         n.cdb_save
        end
       end
     end
     
+    # Remove this role via the REST API
+    def destroy
+      chef_server_rest.delete_rest("roles/#{@name}")
+      
+      Chef::Node.list.each do |node|
+        n = Chef::Node.load(node[0])
+        n.run_list.remove("role[#{@name}]")
+        n.save
+      end
+      
+    end
+    
     # Save this role to the CouchDB
+    def cdb_save
+      self.couchdb_rev = couchdb.store("role", @name, self)["rev"]
+    end
+    
+    # Save this role via the REST API
     def save
-      results = @couchdb.store("role", @name, self)
-      @couchdb_rev = results["rev"]
+      begin
+        chef_server_rest.put_rest("roles/#{@name}", self)
+      rescue Net::HTTPServerException => e
+        raise e unless e.response.code == "404"
+        chef_server_rest.post_rest("roles", self)
+      end
+      self
     end
     
+    # Create the role via the REST API
+    def create
+      chef_server_rest.post_rest("roles", self)
+      self
+    end 
+    
     # Set up our CouchDB design document
-    def self.create_design_document
-      Chef::CouchDB.new.create_design_document("roles", DESIGN_DOCUMENT)
+    def self.create_design_document(couchdb=nil)
+      (couchdb || Chef::CouchDB.new).create_design_document("roles", DESIGN_DOCUMENT)
     end
     
     # As a string
@@ -217,13 +293,13 @@ class Chef
         Chef::Log.warn("Loading #{short_name}")
         r = Chef::Role.from_disk(short_name, "json")
         begin
-          couch_role = Chef::Role.load(short_name)
+          couch_role = Chef::Role.cdb_load(short_name)
           r.couchdb_rev = couch_role.couchdb_rev
           Chef::Log.debug("Replacing role #{short_name} with data from #{role_file}")
-        rescue Net::HTTPServerException
+        rescue Chef::Exceptions::CouchDBNotFound 
           Chef::Log.debug("Creating role #{short_name} with data from #{role_file}")
         end
-        r.save
+        r.cdb_save
       end
     end
 

data/lib/chef/run_list.rb

@@ -27,6 +27,7 @@ class Chef
       @run_list = Array.new
       @recipes = Array.new
       @roles = Array.new
+      @seen_roles = Array.new
     end
 
     def <<(item)
@@ -60,6 +61,10 @@ class Chef
       true
     end
 
+    def to_s
+      @run_list.join(", ")
+    end
+
     def empty?
       @run_list.length == 0 ? true : false
     end
@@ -86,7 +91,7 @@ class Chef
       @run_list.include?(fentry)
     end
 
-    def reset(*args)
+    def reset!(*args)
       @run_list = Array.new
       @recipes = Array.new
       @roles = Array.new
@@ -111,7 +116,8 @@ class Chef
       self
     end
 
-    def expand(from='server')
+    def expand(from='server', couchdb=nil)
+      couchdb = couchdb ? couchdb : Chef::CouchDB.new
       recipes = Array.new
       default_attrs = Mash.new
       override_attrs = Mash.new
@@ -123,6 +129,7 @@ class Chef
           recipes << name unless recipes.include?(name)
         when 'role'
           role = nil
+          next if @seen_roles.include?(name)
           if from == 'disk' || Chef::Config[:solo]
             # Load the role from disk
             role = Chef::Role.from_disk("#{name}")
@@ -132,11 +139,13 @@ class Chef
             role = r.get_rest("roles/#{name}")
           elsif from == 'couchdb'
             # Load the role from couchdb
-            role = Chef::Role.load(name)
+            role = Chef::Role.cdb_load(name, couchdb)
           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)
+          @seen_roles << name
+          rec, d, o = role.run_list.expand(from)
+          rec.each { |r| recipes <<  r unless recipes.include?(r) }
+          default_attrs = Chef::Mixin::DeepMerge.merge(default_attrs, Chef::Mixin::DeepMerge.merge(role.default_attributes,d))
+          override_attrs = Chef::Mixin::DeepMerge.merge(override_attrs, Chef::Mixin::DeepMerge.merge(role.override_attributes, o))
         end
       end
       return recipes, default_attrs, override_attrs

data/lib/chef/runner.rb

@@ -48,8 +48,7 @@ class Chef
     end
     
     def build_provider(resource)
-      provider_klass = resource.provider
-      provider_klass ||= Chef::Platform.find_provider_for_node(@node, 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.load_current_resource
@@ -71,7 +70,10 @@ class Chef
           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)
+              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)")
               } 
@@ -84,6 +86,7 @@ class Chef
     def converge
 
       @delayed_actions = Hash.new
+      @ordered_delayed_actions = []
       
       @collection.execute_each_resource do |resource|
         begin
@@ -91,7 +94,7 @@ class Chef
           
           # 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)
+            unless Chef::Mixin::Command.only_if(resource.only_if, resource.only_if_args)
               Chef::Log.debug("Skipping #{resource} due to only_if")
               next
             end
@@ -99,7 +102,7 @@ class Chef
           
           # 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)
+            unless Chef::Mixin::Command.not_if(resource.not_if, resource.not_if_args)
               Chef::Log.debug("Skipping #{resource} due to not_if")
               next
             end
@@ -111,17 +114,16 @@ class Chef
             run_action(resource, ra)
           end
         rescue => e
-          Chef::Log.error("#{resource} (#{resource.source_line}) had an error:\n#{e}\n#{e.backtrace}")
+          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 |resource, action_hash| 
-        action_hash.each do |action, log_array|
-          log_array.each { |l| l.call } # Call each log message
-          run_action(resource, action)
-        end
+      @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)
       end
 
       true

data/lib/chef/search/query.rb

@@ -0,0 +1,60 @@
+#
+# 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/config'
+require 'uri'
+
+class Chef
+  class Search
+    class Query 
+
+      attr_accessor :rest
+
+      def initialize(url=nil)
+        @rest = Chef::REST.new(url ||Chef::Config[:search_url])
+      end
+
+      # Search Solr for objects of a given type, for a given query. If you give
+      # it a block, it will handle the paging for you dynamically.
+      def search(type, query="*:*", sort=nil, start=0, rows=20, &block)
+        raise ArgumentError, "Type must be a string or a symbol!" unless (type.kind_of?(String) || type.kind_of?(Symbol))
+        
+        response = @rest.get_rest("search/#{type}?q=#{escape(query)}&sort=#{escape(sort)}&start=#{escape(start)}&rows=#{escape(rows)}")
+        if block
+          response["rows"].each { |o| block.call(o) unless o.nil?}
+          unless (response["start"] + response["rows"].length) >= response["total"]
+            nstart = response["start"] + rows
+            search(type, query, sort, nstart, rows, &block)
+          end
+          true
+        else
+          [ response["rows"], response["start"], response["total"] ]
+        end
+      end
+      
+      def list_indexes
+        response = @rest.get_rest("search")
+      end 
+
+      private
+        def escape(s)
+          s && URI.escape(s.to_s) 
+        end
+    end
+  end
+end

data/lib/chef/shef.rb

@@ -0,0 +1,220 @@
+# Author:: Daniel DeLeo (<dan@kallistec.com>)
+# Copyright:: Copyright (c) 2009 Daniel DeLeo
+# 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 "singleton"
+require "pp"
+require "etc"
+require "mixlib/cli"
+
+require "chef/client"
+require "chef/config"
+
+require "chef/shef/shef_session"
+require "chef/shef/ext"
+
+
+module Shef
+  LEADERS = Hash.new("")
+  LEADERS[Chef::Recipe] = ":recipe"
+  LEADERS[Chef::Node]   = ":attributes"
+  
+  class << self
+    attr_accessor :client_type, :options
+  end
+  
+  # Shef assumes it's running whenever it is defined
+  def self.running?
+    true
+  end
+  
+  # Set the irb_conf object to something other than IRB.conf
+  # usful for testing.
+  def self.irb_conf=(conf_hash)
+    @irb_conf = conf_hash
+  end
+  
+  def self.irb_conf
+    @irb_conf || IRB.conf
+  end
+  
+  def self.configure_irb
+    irb_conf[:HISTORY_FILE] = "~/.shef_history"
+    irb_conf[:SAVE_HISTORY] = 1000
+    
+    irb_conf[:IRB_RC] = lambda do |conf|
+      m = conf.main
+      leader = LEADERS[m.class]
+
+      def m.help
+        shef_help
+      end
+
+      conf.prompt_c       = "chef#{leader} > "
+      conf.return_format  = " => %s \n"
+      conf.prompt_i       = "chef#{leader} > "
+      conf.prompt_n       = "chef#{leader} ?> "
+      conf.prompt_s       = "chef#{leader}%l> "
+    end
+  end
+  
+  def self.session
+    client_type.instance.reset! unless client_type.instance.node_built?
+    client_type.instance
+  end
+  
+  def self.init
+    parse_json
+    configure_irb
+
+    session # trigger ohai run + session load
+    
+    session.node.consume_attributes(@json_attribs)
+
+    greeting = begin
+        " #{Etc.getlogin}@#{Shef.session.node.name}"
+      rescue NameError
+        ""
+      end
+
+    version
+    puts
+
+    puts "run `help' for help, `exit' or ^D to quit."
+    puts
+    puts "Ohai2u#{greeting}!"
+  end
+  
+  def self.parse_json
+    if Chef::Config[:json_attribs]
+      begin
+        json_io = open(Chef::Config[:json_attribs])
+      rescue SocketError => error
+        fatal!("I cannot connect to #{Chef::Config[:json_attribs]}", 2)
+      rescue Errno::ENOENT => error
+        fatal!("I cannot find #{Chef::Config[:json_attribs]}", 2)
+      rescue Errno::EACCES => error
+        fatal!("Permissions are incorrect on #{Chef::Config[:json_attribs]}. Please chmod a+r #{Chef::Config[:json_attribs]}", 2)
+      rescue Exception => error
+        fatal!("Got an unexpected error reading #{Chef::Config[:json_attribs]}: #{error.message}", 2)
+      end
+
+      begin
+        @json_attribs = JSON.parse(json_io.read)
+      rescue JSON::ParserError => error
+        fatal!("Could not parse the provided JSON file (#{Chef::Config[:json_attribs]})!: " + error.message, 2)
+      end
+    end
+  end
+  
+  def self.fatal!(message, exit_status)
+    Chef::Log.fatal(message)
+    exit exit_status
+  end
+  
+  def self.client_type
+    type = Shef::StandAloneSession
+    type = Shef::SoloSession   if Chef::Config[:solo]
+    type = Shef::ClientSession if Chef::Config[:client]
+    type
+  end
+  
+  def self.parse_opts
+    @options = Options.new
+    @options.parse_opts
+  end
+  
+  class Options
+    include Mixlib::CLI
+
+    option :config_file, 
+      :short => "-c CONFIG",
+      :long  => "--config CONFIG",
+      :description => "The configuration file to use"
+
+    option :help,
+      :short        => "-h",
+      :long         => "--help",
+      :description  => "Show this message",
+      :on           => :tail,
+      :boolean      => true,
+      :show_options => true,
+      :exit         => 0
+
+    option :standalone,
+      :short        => "-a",
+      :long         => "--standalone",
+      :description  => "standalone shef session",
+      :default      => true,
+      :boolean      => true
+
+    option :solo,
+      :short        => "-s",
+      :long         => "--solo",
+      :description  => "chef-solo shef session",
+      :boolean      => true
+
+    option :client,
+      :short        => "-z",
+      :long         => "--client",
+      :description  => "chef-client shef session",
+      :boolean      => true
+
+    option :json_attribs,
+      :short => "-j JSON_ATTRIBS",
+      :long => "--json-attributes JSON_ATTRIBS",
+      :description => "Load attributes from a JSON file or URL",
+      :proc => nil
+
+    option :chef_server_url,
+      :short => "-S CHEFSERVERURL",
+      :long => "--server CHEFSERVERURL",
+      :description => "The chef server URL",
+      :proc => nil
+
+    option :version,
+      :short        => "-v",
+      :long         => "--version",
+      :description  => "Show chef version",
+      :boolean      => true,
+      :proc         => lambda {|v| puts "Chef: #{::Chef::VERSION}"},
+      :exit         => 0
+
+    def self.setup!
+      self.new.parse_opts
+    end
+
+    def parse_opts
+      parse_options
+      config[:config_file] = config_file_for_shef_mode
+      config_msg = config[:config_file] || "none (standalone shef session)"
+      puts "loading configuration: #{config_msg}"
+      Chef::Config.from_file(config[:config_file]) if !config[:config_file].nil? && File.exists?(config[:config_file]) && File.readable?(config[:config_file])
+      Chef::Config.merge!(config)
+    end
+    
+    private
+    
+    def config_file_for_shef_mode
+      return config[:config_file] if config[:config_file]
+      return "/etc/chef/solo.rb" if config[:solo]
+      return "/etc/chef/client.rb" if config[:client]
+      nil
+    end
+
+  end
+  
+end