chef 10.28.2-x86-mingw32

data/lib/chef/cookbook_version_selector.rb

@@ -0,0 +1,168 @@
+#
+# Author:: Tim Hinderliter (<tim@opscode.com>)
+# Copyright:: Copyright (c) 2011 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 'dep_selector'
+
+class Chef
+  module CookbookVersionSelector
+    # This method replaces verbiage from DepSelector messages with
+    # Chef-domain-specific verbiage, such as replacing package with
+    # cookbook.
+    #
+    # TODO [cw, 2011/2/25]: this is a near-term hack. In the long run,
+    # we'll do this better.
+    def self.filter_dep_selector_message(message)
+      m = message
+      m.gsub!("Package", "Cookbook")
+      m.gsub!("package", "cookbook")
+      m.gsub!("Solution constraint", "Run list item")
+      m.gsub!("solution constraint", "run list item")
+      m
+    end
+
+    # all_cookbooks - a hash mapping cookbook names to an array of
+    # available CookbookVersions.
+    #
+    # Creates a DependencyGraph from CookbookVersion objects
+    def self.create_dependency_graph_from_cookbooks(all_cookbooks)
+      dep_graph = DepSelector::DependencyGraph.new
+
+      all_cookbooks.each do |cb_name, cb_versions|
+        cb_versions.each do |cb_version|
+          cb_version_deps = cb_version.metadata.dependencies
+          # TODO [cw. 2011/2/10]: CookbookVersion#version returns a
+          # String even though we're storing as a DepSelector::Version
+          # object underneath. This should be changed so that we
+          # return the object and handle proper serialization and
+          # de-serialization. For now, I'm just going to create a
+          # Version object from the String representation.
+          pv = dep_graph.package(cb_name).add_version(Chef::Version.new(cb_version.version))
+          cb_version_deps.each_pair do |dep_name, constraint_str|
+            # if the dependency is specified as cookbook::recipe,
+            # extract the cookbook component
+            dep_cb_name = dep_name.split("::").first
+            constraint = Chef::VersionConstraint.new(constraint_str)
+            pv.dependencies << DepSelector::Dependency.new(dep_graph.package(dep_cb_name), constraint)
+          end
+        end
+      end
+
+      dep_graph
+    end
+
+    # Return a hash mapping cookbook names to a CookbookVersion
+    # object. If there is no solution that satisfies the constraints,
+    # the first run list item that caused unsatisfiability is
+    # returned.
+    #
+    # This is the final version-resolved list of cookbooks for the
+    # RunList.
+    #
+    # all_cookbooks - a hash mapping cookbook names to an array of
+    # available CookbookVersions.
+    #
+    # recipe_constraints - an array of hashes describing the expanded
+    # run list.  Each element is a hash containing keys :name and
+    # :version_constraint. The :name component is either the
+    # fully-qualified recipe name (e.g. "cookbook1::non_default_recipe")
+    # or just a cookbook name, indicating the default recipe is to be
+    # run (e.g. "cookbook1").
+    def self.constrain(all_cookbooks, recipe_constraints)
+      dep_graph = create_dependency_graph_from_cookbooks(all_cookbooks)
+
+      # extract cookbook names from (possibly) fully-qualified recipe names
+      cookbook_constraints = recipe_constraints.map do |recipe_spec|
+        cookbook_name = (recipe_spec[:name][/^(.+)::/, 1] || recipe_spec[:name])
+        DepSelector::SolutionConstraint.new(dep_graph.package(cookbook_name),
+                                            recipe_spec[:version_constraint])
+      end
+
+      # Pass in the list of all available cookbooks (packages) so that
+      # DepSelector can distinguish between "no version available for
+      # cookbook X" and "no such cookbook X" when an environment
+      # filters out all versions for a given cookbook.
+      all_packages = all_cookbooks.inject([]) do |acc, (cookbook_name, cookbook_versions)|
+        acc << dep_graph.package(cookbook_name)
+        acc
+      end
+
+      # find a valid assignment of CoookbookVersions. If no valid
+      # assignment exists, indicate which run_list_item causes the
+      # unsatisfiability and try to hint at what might be wrong.
+      soln =
+        begin
+          DepSelector::Selector.new(dep_graph).find_solution(cookbook_constraints, all_packages)
+        rescue DepSelector::Exceptions::InvalidSolutionConstraints => e
+          non_existent_cookbooks = e.non_existent_packages.map {|constraint| constraint.package.name}
+          cookbooks_with_no_matching_versions = e.constrained_to_no_versions.map {|constraint| constraint.package.name}
+
+          # Spend a whole lot of effort for pluralizing and
+          # prettifying the message.
+          message = ""
+          if non_existent_cookbooks.length > 0
+            message += "no such " + (non_existent_cookbooks.length > 1 ? "cookbooks" : "cookbook")
+            message += " #{non_existent_cookbooks.join(", ")}"
+          end
+
+          if cookbooks_with_no_matching_versions.length > 0
+            if message.length > 0
+              message += "; "
+            end
+
+            message += "no versions match the constraints on " + (cookbooks_with_no_matching_versions.length > 1 ? "cookbooks" : "cookbook")
+            message += " #{cookbooks_with_no_matching_versions.join(", ")}"
+          end
+
+          message = "Run list contains invalid items: #{message}."
+
+          raise Chef::Exceptions::CookbookVersionSelection::InvalidRunListItems.new(message, non_existent_cookbooks, cookbooks_with_no_matching_versions)
+        rescue DepSelector::Exceptions::NoSolutionExists => e
+          raise Chef::Exceptions::CookbookVersionSelection::UnsatisfiableRunListItem.new(filter_dep_selector_message(e.message), e.unsatisfiable_solution_constraint, e.disabled_non_existent_packages, e.disabled_most_constrained_packages)
+        end
+
+
+      # map assignment back to CookbookVersion objects
+      selected_cookbooks = {}
+      soln.each_pair do |cb_name, cb_version|
+        # TODO [cw, 2011/2/10]: related to the TODO in
+        # create_dependency_graph_from_cookbooks, cbv.version
+        # currently returns a String, so we must compare to
+        # cb_version.to_s, since it's a for-real Version object.
+        selected_cookbooks[cb_name] = all_cookbooks[cb_name].find{|cbv| cbv.version == cb_version.to_s}
+      end
+      selected_cookbooks
+    end
+
+    # Expands the run_list, constrained to the environment's CookbookVersion
+    # constraints.
+    #
+    # Returns:
+    #   Hash of: name to CookbookVersion
+    def self.expand_to_cookbook_versions(run_list, environment, couchdb=nil)
+      # expand any roles in this run_list.
+      expanded_run_list = run_list.expand(environment, 'couchdb', :couchdb => couchdb).recipes.with_version_constraints
+
+      cookbooks_for_environment = Chef::Environment.cdb_minimal_filtered_versions(environment, couchdb)
+      cookbook_collection = constrain(cookbooks_for_environment, expanded_run_list)
+      full_cookbooks = Chef::MinimalCookbookVersion.load_full_versions_of(cookbook_collection.values, couchdb)
+      full_cookbooks.inject({}) do |cb_map, cookbook_version|
+        cb_map[cookbook_version.name] = cookbook_version
+        cb_map
+      end
+    end
+  end
+end

data/lib/chef/couchdb.rb

@@ -0,0 +1,246 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Christopher Brown (<cb@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/config'
+require 'chef/rest'
+require 'chef/log'
+require 'digest/sha2'
+require 'chef/json_compat'
+
+# 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, db=Chef::Config[:couchdb_database])
+      url ||= Chef::Config[:couchdb_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(check_for_existing=true)
+      @database_list = @rest.get_rest("_all_dbs")
+      if !check_for_existing || !@database_list.any? { |db| db == couchdb_database }
+        response = @rest.put_rest(couchdb_database, Hash.new)
+      end
+      couchdb_database
+    end
+
+    def create_design_document(name, data)
+      to_update = true
+      begin
+        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 because: #{$!}")
+      end
+      if to_update
+        @rest.put_rest("#{couchdb_database}/_design%2F#{name}", data)
+      end
+      true
+    end
+
+    # Save the object to Couch. Add to index if the object supports it.
+    def store(obj_type, name, object)
+      validate(
+        {
+          :obj_type => obj_type,
+          :name => name,
+          :object => object,
+        },
+        {
+          :object => { :respond_to => :to_json },
+        }
+      )
+      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)
+
+      if object.respond_to?(:add_to_index)
+        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)
+      end
+
+      db_put_response
+    end
+
+    def load(obj_type, name)
+      validate(
+        {
+          :obj_type => obj_type,
+          :name => name,
+        },
+        {
+          :obj_type => { :kind_of => String },
+          :name => { :kind_of => String },
+        }
+               )
+      doc = find_by_name(obj_type, name)
+      doc.couchdb = self if doc.respond_to?(:couchdb)
+      doc
+    end
+
+    def delete(obj_type, name, rev=nil)
+      validate(
+        {
+          :obj_type => obj_type,
+          :name => name,
+        },
+        {
+          :obj_type => { :kind_of => String },
+          :name => { :kind_of => String },
+        }
+      )
+      del_id = nil
+      object, uuid = find_by_name(obj_type, name, true)
+      unless rev
+        if object.respond_to?(:couchdb_rev)
+          rev = object.couchdb_rev
+        else
+          rev = object['_rev']
+        end
+      end
+      response = @rest.delete_rest("#{couchdb_database}/#{uuid}?rev=#{rev}")
+      response.couchdb = self if response.respond_to?(:couchdb=)
+
+      if object.respond_to?(:delete_from_index)
+        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)
+      end
+
+      response
+    end
+
+    def list(view, inflate=false)
+      validate(
+        {
+          :view => view,
+        },
+        {
+          :view => { :kind_of => String }
+        }
+      )
+      if inflate
+        r = @rest.get_rest(view_uri(view, "all"))
+        r["rows"].each { |i| i["value"].couchdb = self if i["value"].respond_to?(:couchdb=) }
+        r
+      else
+        r = @rest.get_rest(view_uri(view, "all_id"))
+      end
+      r
+    end
+
+    def has_key?(obj_type, name)
+      validate(
+        {
+          :obj_type => obj_type,
+          :name => name,
+        },
+        {
+          :obj_type => { :kind_of => String },
+          :name => { :kind_of => String },
+        }
+      )
+      begin
+        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
+      view_string << options.map { |k,v| "#{k}=#{URI.escape(v.to_json)}"}.join('&')
+      @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)
+      "#{couchdb_database}/_design/#{design}/_view/#{view}"
+    end
+
+    def server_stats
+      @rest.get_rest('/')
+    end
+
+    def db_stats
+      @rest.get_rest("/#{@db}")
+    end
+
+  end
+end

data/lib/chef/daemon.rb

@@ -0,0 +1,187 @@
+#
+# Author:: AJ Christensen (<aj@junglist.gen.nz>)
+# 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.
+
+# I love you Merb (lib/merb-core/server.rb)
+
+require 'chef/config'
+require 'etc'
+
+class Chef
+  class Daemon
+    class << self
+      attr_accessor :name
+
+      # Daemonize the current process, managing pidfiles and process uid/gid
+      #
+      # === Parameters
+      # name<String>:: The name to be used for the pid file
+      #
+      def daemonize(name)
+        @name = name
+        pid = pid_from_file
+        unless running?
+          remove_pid_file()
+          Chef::Log.info("Daemonizing..")
+          begin
+            exit if fork
+            Process.setsid
+            exit if fork
+            Chef::Log.info("Forked, in #{Process.pid}. Privileges: #{Process.euid} #{Process.egid}")
+            File.umask Chef::Config[:umask]
+            $stdin.reopen("/dev/null")
+            $stdout.reopen("/dev/null", "a")
+            $stderr.reopen($stdout)
+            save_pid_file
+            at_exit {
+              Chef::Log.debug("daemon pid #{Process.pid} in at_exit handler")
+              remove_pid_file
+            }
+          rescue NotImplementedError => e
+            Chef::Application.fatal!("There is no fork: #{e.message}")
+          end
+        else
+          Chef::Application.fatal!("Chef is already running pid #{pid}")
+        end
+      end
+  
+      # Check if Chef is running based on the pid_file
+      # ==== Returns
+      # Boolean::
+      # True if Chef is running
+      # False if Chef is not running
+      #
+      def running?
+        if pid_from_file.nil?
+          false
+        else
+          Process.kill(0, pid_from_file)
+          true
+        end
+      rescue Errno::ESRCH, Errno::ENOENT
+        false
+      rescue Errno::EACCES => e
+        Chef::Application.fatal!("You don't have access to the PID file at #{pid_file}: #{e.message}")
+      end
+      
+      # Gets the pid file for @name
+      # ==== Returns
+      # String::
+      #   Location of the pid file for @name
+      def pid_file
+         Chef::Config[:pid_file] or "/tmp/#{@name}.pid"
+      end
+      
+      # Suck the pid out of pid_file
+      # ==== Returns
+      # Integer::
+      #   The PID from pid_file
+      # nil::
+      #   Returned if the pid_file does not exist.
+      #
+      def pid_from_file
+        File.read(pid_file).chomp.to_i
+      rescue Errno::ENOENT, Errno::EACCES
+        nil
+      end
+    
+      # Store the PID on the filesystem
+      # This uses the Chef::Config[:pid_file] option, or "/tmp/name.pid" otherwise
+      #
+      def save_pid_file
+        file = pid_file
+        begin
+          FileUtils.mkdir_p(File.dirname(file))
+        rescue Errno::EACCES => e
+          Chef::Application.fatal!("Failed store pid in #{File.dirname(file)}, permission denied: #{e.message}")
+        end
+      
+        begin
+          pid = Process.pid.to_s
+          File.open(file, "w") { |f| f.write(pid) }
+          Chef::Log.debug("Wrote #{pid} to #{file}")
+        rescue Errno::EACCES => e
+          Chef::Application.fatal!("Couldn't write to pidfile #{file}, permission denied: #{e.message}")
+        end
+      end
+    
+      # Delete the PID from the filesystem
+      def remove_pid_file
+        return unless File.exists?(pid_file)
+
+        daemon_pid = pid_from_file
+        my_pid = Process.pid
+        if daemon_pid != my_pid
+          Chef::Log.debug("My pid is #{my_pid}; not removing #{pid_file} which contains #{daemon_pid}")
+          return
+        end
+
+        FileUtils.rm(pid_file)
+        Chef::Log.debug("Removed #{pid_file}")
+      end
+           
+      # Change process user/group to those specified in Chef::Config
+      #
+      def change_privilege
+        Dir.chdir("/")
+
+        if Chef::Config[:user] and Chef::Config[:group]
+          Chef::Log.info("About to change privilege to #{Chef::Config[:user]}:#{Chef::Config[:group]}")
+          _change_privilege(Chef::Config[:user], Chef::Config[:group])
+        elsif Chef::Config[:user]
+          Chef::Log.info("About to change privilege to #{Chef::Config[:user]}")
+          _change_privilege(Chef::Config[:user])
+        end
+      end
+    
+      # Change privileges of the process to be the specified user and group
+      #
+      # ==== Parameters
+      # user<String>:: The user to change the process to.
+      # group<String>:: The group to change the process to.
+      #
+      # ==== Alternatives
+      # If group is left out, the user will be used (changing to user:user)
+      #
+      def _change_privilege(user, group=user)
+        uid, gid = Process.euid, Process.egid
+
+        begin
+          target_uid = Etc.getpwnam(user).uid
+        rescue ArgumentError => e
+          Chef::Application.fatal!("Failed to get UID for user #{user}, does it exist? #{e.message}")
+          return false
+        end
+   
+        begin
+          target_gid = Etc.getgrnam(group).gid
+        rescue ArgumentError => e
+          Chef::Application.fatal!("Failed to get GID for group #{group}, does it exist? #{e.message}")
+          return false
+        end
+      
+        if (uid != target_uid) or (gid != target_gid)
+          Process.initgroups(user, target_gid)
+          Process::GID.change_privilege(target_gid)
+          Process::UID.change_privilege(target_uid)
+        end
+        true
+      rescue Errno::EPERM => e
+        Chef::Application.fatal!("Permission denied when trying to change #{uid}:#{gid} to #{target_uid}:#{target_gid}. #{e.message}")
+      end
+    end
+  end
+end