chef 0.7.16 → 0.8.2

data/lib/chef/cookbook_loader.rb

@@ -38,7 +38,7 @@ class Chef
     
     def load_cookbooks
       cookbook_settings = Hash.new
-      [Chef::Config.cookbook_path].flatten.reverse.each do |cb_path|
+      [Chef::Config.cookbook_path].flatten.each do |cb_path|
         Dir[File.join(cb_path, "*")].each do |cookbook|
           next unless File.directory?(cookbook)          
           cookbook_name = File.basename(cookbook).to_sym
@@ -128,11 +128,11 @@ class Chef
     end
     
     def each
-      @cookbook.each_value do |cobject|
-        yield cobject
+      @cookbook.keys.sort { |a,b| a.to_s <=> b.to_s }.each do |cname|
+        yield @cookbook[cname]
       end
     end
-    
+
     private
     
       def load_ignore_file(ignore_file)

data/lib/chef/couchdb.rb

@@ -1,5 +1,6 @@
 #
 # Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Christopher Brown (<cb@opscode.com>)
 # Copyright:: Copyright (c) 2008 Opscode, Inc.
 # License:: Apache License, Version 2.0
 #
@@ -22,39 +23,76 @@ require 'chef/log'
 require 'digest/sha2'
 require 'json'
 
+# We want to fail on create if uuidtools isn't installed
+begin
+  require 'uuidtools'
+rescue LoadError
+end
+
 class Chef
   class CouchDB
     include Chef::Mixin::ParamsValidate
 
-    def initialize(url=nil)
+    def initialize(url=nil, db=Chef::Config[:couchdb_database])
       url ||= Chef::Config[:couchdb_url]
-      @rest = Chef::REST.new(url)
+      @db = db
+      @rest = Chef::REST.new(url, nil, nil)
     end
-    
+
+    def couchdb_database(args=nil)
+      @db = args || @db
+    end
+
+    def create_id_map
+      create_design_document(
+        "id_map", 
+        {
+          "version" => 1,
+          "language" => "javascript",
+          "views" => {
+            "name_to_id" => {
+              "map" => <<-EOJS
+                function(doc) {
+                  emit([ doc.chef_type, doc.name], doc._id);
+                }
+              EOJS
+            },
+            "id_to_name" => {
+              "map" => <<-EOJS
+                function(doc) { 
+                  emit(doc._id, [ doc.chef_type, doc.name ]);
+                }
+              EOJS
+            }
+          }
+        }
+      )
+    end
+
     def create_db
       @database_list = @rest.get_rest("_all_dbs")
-      unless @database_list.detect { |db| db == Chef::Config[:couchdb_database] }
-        response = @rest.put_rest(Chef::Config[:couchdb_database], Hash.new)
+      unless @database_list.detect { |db| db == couchdb_database }
+        response = @rest.put_rest(couchdb_database, Hash.new)
       end
-      Chef::Config[:couchdb_database]
+      couchdb_database
     end
     
     def create_design_document(name, data)
       create_db
       to_update = true
       begin
-        old_doc = @rest.get_rest("#{Chef::Config[:couchdb_database]}/_design%2F#{name}")
+        old_doc = @rest.get_rest("#{couchdb_database}/_design/#{name}")
         if data["version"] != old_doc["version"]
           data["_rev"] = old_doc["_rev"]
           Chef::Log.debug("Updating #{name} views")
         else
           to_update = false
         end
-      rescue
-        Chef::Log.debug("Creating #{name} views for the first time")
+      rescue 
+        Chef::Log.debug("Creating #{name} views for the first time because: #{$!}")
       end
       if to_update
-        @rest.put_rest("#{Chef::Config[:couchdb_database]}/_design%2F#{name}", data)
+        @rest.put_rest("#{couchdb_database}/_design%2F#{name}", data)
       end
       true
     end
@@ -70,7 +108,15 @@ class Chef
           :object => { :respond_to => :to_json },
         }
       )
-      @rest.put_rest("#{Chef::Config[:couchdb_database]}/#{obj_type}_#{safe_name(name)}", object)
+      rows = get_view("id_map", "name_to_id", :key => [ obj_type, name ])["rows"]
+      uuid    = rows.empty? ? UUIDTools::UUID.random_create.to_s : rows.first.fetch("id")
+      
+      db_put_response = @rest.put_rest("#{couchdb_database}/#{uuid}", object)
+      
+      Chef::Log.info("Sending #{obj_type}(#{uuid}) to the index queue for addition.")
+      object.add_to_index(:database => couchdb_database, :id => uuid, :type => obj_type)
+      
+      db_put_response
     end
 
     def load(obj_type, name)
@@ -83,8 +129,10 @@ class Chef
           :obj_type => { :kind_of => String },
           :name => { :kind_of => String },
         }
-      )
-      @rest.get_rest("#{Chef::Config[:couchdb_database]}/#{obj_type}_#{safe_name(name)}")
+               )
+      doc = find_by_name(obj_type, name)
+      doc.couchdb = self if doc.respond_to?(:couchdb)
+      doc 
     end
   
     def delete(obj_type, name, rev=nil)
@@ -98,15 +146,22 @@ class Chef
           :name => { :kind_of => String },
         }
       )
+      del_id = nil 
+      object, uuid = find_by_name(obj_type, name, true)
       unless rev
-        last_obj = @rest.get_rest("#{Chef::Config[:couchdb_database]}/#{obj_type}_#{safe_name(name)}")
-        if last_obj.respond_to?(:couchdb_rev)
-          rev = last_obj.couchdb_rev
+        if object.respond_to?(:couchdb_rev)
+          rev = object.couchdb_rev
         else
-          rev = last_obj['_rev']
+          rev = object['_rev']
         end
       end
-      @rest.delete_rest("#{Chef::Config[:couchdb_database]}/#{obj_type}_#{safe_name(name)}?rev=#{rev}")
+      response = @rest.delete_rest("#{couchdb_database}/#{uuid}?rev=#{rev}")
+      response.couchdb = self if response.respond_to?(:couchdb=)
+      Chef::Log.info("Sending #{obj_type}(#{uuid}) to the index queue for deletion..")
+      
+      object.delete_from_index(:database => couchdb_database, :id => uuid, :type => obj_type)
+
+      response
     end
   
     def list(view, inflate=false)
@@ -119,10 +174,13 @@ class Chef
         }
       )
       if inflate
-        @rest.get_rest(view_uri(view, "all"))
+        r = @rest.get_rest(view_uri(view, "all"))
+        r["rows"].each { |i| i["value"].couchdb = self if i["value"].respond_to?(:couchdb=) }
+        r
       else
-        @rest.get_rest(view_uri(view, "all_id"))
+        r = @rest.get_rest(view_uri(view, "all_id"))
       end
+      r
     end
   
     def has_key?(obj_type, name)
@@ -137,13 +195,25 @@ class Chef
         }
       )
       begin
-        @rest.get_rest("#{Chef::Config[:couchdb_database]}/#{obj_type}_#{safe_name(name)}")
+        find_by_name(obj_type, name)
         true
       rescue
         false
       end
     end
 
+    def find_by_name(obj_type, name, with_id=false)
+      r = get_view("id_map", "name_to_id", :key => [ obj_type, name ], :include_docs => true)
+      if r["rows"].length == 0
+        raise Chef::Exceptions::CouchDBNotFound, "Cannot find #{obj_type} #{name} in CouchDB!"
+      end
+      if with_id
+        [ r["rows"][0]["doc"], r["rows"][0]["id"] ]
+      else
+        r["rows"][0]["doc"] 
+      end
+    end
+
     def get_view(design, view, options={})
       view_string = view_uri(design, view)
       view_string << "?" if options.length != 0
@@ -151,26 +221,25 @@ class Chef
       options.each { |k,v| view_string << "#{first ? '' : '&'}#{k}=#{URI.escape(v.to_json)}"; first = false }
       @rest.get_rest(view_string)
     end
+
+    def bulk_get(*to_fetch)
+      response = @rest.post_rest("#{couchdb_database}/_all_docs?include_docs=true", { "keys" => to_fetch.flatten })
+      response["rows"].collect { |r| r["doc"] }
+    end
     
     def view_uri(design, view)
       Chef::Config[:couchdb_version] ||= @rest.run_request(:GET,
                                                            URI.parse(@rest.url + "/"),
-                                                           false,
+                                                           {},
                                                            10,
                                                            false)["version"].gsub(/-.+/,"").to_f
       case Chef::Config[:couchdb_version]
       when 0.8
-        "#{Chef::Config[:couchdb_database]}/_view/#{design}/#{view}"
+        "#{couchdb_database}/_view/#{design}/#{view}"
       else
-        "#{Chef::Config[:couchdb_database]}/_design/#{design}/_view/#{view}"
+        "#{couchdb_database}/_design/#{design}/_view/#{view}"
       end
     end
     
-    private
-    
-      def safe_name(name)
-        name.gsub(/\./, "_")
-      end
-      
   end
 end

data/lib/chef/daemon.rb

@@ -44,7 +44,7 @@ class Chef
             File.umask Chef::Config[:umask]
             $stdin.reopen("/dev/null")
             $stdout.reopen("/dev/null", "a")
-            $stdout.reopen($stdout)
+            $stderr.reopen($stdout)
             save_pid_file
             at_exit { remove_pid_file }
           rescue NotImplementedError => e

data/lib/chef/data_bag.rb

@@ -0,0 +1,215 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Nuo Yan (<nuo@opscode.com>)
+# Author:: Christopher Brown (<cb@opscode.com>)
+# Copyright:: Copyright (c) 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/config'
+require 'chef/mixin/params_validate'
+require 'chef/mixin/from_file'
+require 'chef/couchdb'
+require 'chef/data_bag_item'
+require 'chef/index_queue'
+require 'extlib'
+require 'json'
+
+class Chef
+  class DataBag 
+    
+    include Chef::Mixin::FromFile
+    include Chef::Mixin::ParamsValidate
+    include Chef::IndexQueue::Indexable
+    
+    DESIGN_DOCUMENT = {
+      "version" => 2,
+      "language" => "javascript",
+      "views" => {
+        "all" => {
+          "map" => <<-EOJS
+          function(doc) { 
+            if (doc.chef_type == "data_bag") {
+              emit(doc.name, doc);
+            }
+          }
+          EOJS
+        },
+        "all_id" => {
+          "map" => <<-EOJS
+          function(doc) { 
+            if (doc.chef_type == "data_bag") {
+              emit(doc.name, doc.name);
+            }
+          }
+          EOJS
+        },
+        "entries" => {
+          "map" => <<-EOJS
+          function(doc) {
+            if (doc.chef_type == "data_bag_item") {
+              emit(doc.data_bag, doc.raw_data.id);
+            }
+          }
+          EOJS
+        }
+      }
+    }
+
+    attr_accessor :couchdb_rev, :couchdb_id, :couchdb
+    
+    # Create a new Chef::DataBag
+    def initialize(couchdb=nil)
+      @name = '' 
+      @couchdb_rev = nil
+      @couchdb_id = nil
+      @couchdb = (couchdb || Chef::CouchDB.new)
+    end
+
+    def name(arg=nil) 
+      set_or_return(
+        :name,
+        arg,
+        :regex => /^[\-[:alnum:]_]+$/
+      )
+    end
+
+    def to_hash
+      result = {
+        "name" => @name,
+        'json_class' => self.class.name,
+        "chef_type" => "data_bag",
+      }
+      result["_rev"] = @couchdb_rev if @couchdb_rev
+      result
+    end
+
+    # Serialize this object as a hash 
+    def to_json(*a)
+      to_hash.to_json(*a)
+    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
+    
+    # Create a Chef::Role from JSON
+    def self.json_create(o)
+      bag = new
+      bag.name(o["name"])
+      bag.couchdb_rev = o["_rev"] if o.has_key?("_rev")
+      bag.couchdb_id = o["_id"] if o.has_key?("_id")
+      bag.index_id = bag.couchdb_id
+      bag
+    end
+    
+    # List all the Chef::DataBag 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("data_bags", inflate)
+      lookup = (inflate ? "value" : "key")
+      rs["rows"].collect { |r| r[lookup] }
+    end
+    
+    def self.list(inflate=false)
+      if inflate
+        response = Hash.new
+        Chef::Search::Query.new.search(:data) do |n|
+          response[n.name] = n
+        end
+        response
+      else
+        Chef::REST.new(Chef::Config[:chef_server_url]).get_rest("data")
+      end
+    end
+    
+    # Load a Data Bag by name from CouchDB
+    def self.cdb_load(name, couchdb=nil)
+      (couchdb || Chef::CouchDB.new).load("data_bag", name)
+    end
+    
+    # Load a Data Bag by name via the RESTful API
+    def self.load(name)
+      Chef::REST.new(Chef::Config[:chef_server_url]).get_rest("data/#{name}")
+    end
+    
+    # Remove this Data Bag from CouchDB
+    def cdb_destroy
+      removed = @couchdb.delete("data_bag", @name, @couchdb_rev)
+      rs = @couchdb.get_view("data_bags", "entries", :include_docs => true, :startkey => @name, :endkey => @name)
+      rs["rows"].each do |row|
+        row["doc"].couchdb = couchdb
+        row["doc"].cdb_destroy
+      end
+      removed
+    end
+    
+    def destroy
+      chef_server_rest.delete_rest("data/#{@name}")
+    end
+    
+    # Save this Data Bag to the CouchDB
+    def cdb_save
+      results = @couchdb.store("data_bag", @name, self)
+      @couchdb_rev = results["rev"]
+    end
+    
+    # Save the Data Bag via RESTful API
+    def save
+      begin
+        chef_server_rest.put_rest("data/#{@name}", self)
+      rescue Net::HTTPServerException => e
+        raise e unless e.response.code == "404"
+        chef_server_rest.post_rest("data", self)
+      end
+      self
+    end
+    
+    #create a data bag via RESTful API
+    def create
+      chef_server_rest.post_rest("data", self)
+      self
+    end
+
+    # List all the items in this Bag from CouchDB
+    # The self.load method does this through the REST API
+    def list(inflate=false)
+      rs = nil 
+      if inflate
+        rs = @couchdb.get_view("data_bags", "entries", :include_docs => true, :startkey => @name, :endkey => @name)
+        rs["rows"].collect { |r| r["doc"] }
+      else
+        rs = @couchdb.get_view("data_bags", "entries", :startkey => @name, :endkey => @name)
+        rs["rows"].collect { |r| r["value"] }
+      end
+    end
+    
+    # Set up our CouchDB design document
+    def self.create_design_document(couchdb=nil)
+      (couchdb || Chef::CouchDB.new).create_design_document("data_bags", DESIGN_DOCUMENT)
+    end
+    
+    # As a string
+    def to_s
+      "data_bag[#{@name}]"
+    end
+
+  end
+end
+