giraffesoft-chef 0.7.15

data/lib/chef/cookbook_loader.rb

@@ -0,0 +1,180 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Christopher Walters (<cw@opscode.com>)
+# Author:: Daniel DeLeo (<dan@kallistec.com>)
+# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# 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 'chef/config'
+require 'chef/cookbook'
+require 'chef/cookbook/metadata'
+
+class Chef
+  class CookbookLoader
+    
+    attr_accessor :cookbook, :metadata
+    
+    include Enumerable
+    
+    def initialize()
+      @cookbook = Hash.new
+      @metadata = Hash.new
+      @ignore_regexes = Hash.new { |hsh, key| hsh[key] = Array.new }
+      load_cookbooks
+    end
+    
+    def load_cookbooks
+      cookbook_settings = Hash.new
+      [Chef::Config.cookbook_path].flatten.reverse.each do |cb_path|
+        Dir[File.join(cb_path, "*")].each do |cookbook|
+          next unless File.directory?(cookbook)          
+          cookbook_name = File.basename(cookbook).to_sym
+          unless cookbook_settings.has_key?(cookbook_name)
+            cookbook_settings[cookbook_name] = { 
+              :attribute_files  => Hash.new,
+              :definition_files => Hash.new,
+              :recipe_files     => Hash.new,
+              :template_files   => Hash.new,
+              :remote_files     => Hash.new,
+              :lib_files        => Hash.new,
+              :resource_files   => Hash.new,
+              :provider_files   => Hash.new,
+              :metadata_files   => Array.new
+            }
+          end
+          ignore_regexes = load_ignore_file(File.join(cookbook, "ignore"))
+          @ignore_regexes[cookbook_name].concat(ignore_regexes)
+          
+          load_files_unless_basename(
+            File.join(cookbook, "attributes", "*.rb"), 
+            cookbook_settings[cookbook_name][:attribute_files]
+          )
+          load_files_unless_basename(
+            File.join(cookbook, "definitions", "*.rb"), 
+            cookbook_settings[cookbook_name][:definition_files]
+          )
+          load_files_unless_basename(
+            File.join(cookbook, "recipes", "*.rb"), 
+            cookbook_settings[cookbook_name][:recipe_files]
+          )
+          load_files_unless_basename(
+            File.join(cookbook, "libraries", "*.rb"),               
+            cookbook_settings[cookbook_name][:lib_files]
+          )
+          load_cascading_files(
+            "*.erb",
+            File.join(cookbook, "templates"),
+            cookbook_settings[cookbook_name][:template_files]
+          )
+          load_cascading_files(
+            "*",
+            File.join(cookbook, "files"),
+            cookbook_settings[cookbook_name][:remote_files]
+          )
+          load_cascading_files(
+            "*.rb",
+            File.join(cookbook, "resources"),
+            cookbook_settings[cookbook_name][:resource_files]
+          )
+          load_cascading_files(
+            "*.rb",
+            File.join(cookbook, "providers"),
+            cookbook_settings[cookbook_name][:provider_files]
+          )
+
+          if File.exists?(File.join(cookbook, "metadata.json"))
+            cookbook_settings[cookbook_name][:metadata_files] << File.join(cookbook, "metadata.json")
+          end
+        end
+      end
+      remove_ignored_files_from(cookbook_settings)
+      
+      cookbook_settings.each_key do |cookbook|
+        @cookbook[cookbook] = Chef::Cookbook.new(cookbook)
+        @cookbook[cookbook].attribute_files = cookbook_settings[cookbook][:attribute_files].values
+        @cookbook[cookbook].definition_files = cookbook_settings[cookbook][:definition_files].values
+        @cookbook[cookbook].recipe_files = cookbook_settings[cookbook][:recipe_files].values
+        @cookbook[cookbook].template_files = cookbook_settings[cookbook][:template_files].values
+        @cookbook[cookbook].remote_files = cookbook_settings[cookbook][:remote_files].values
+        @cookbook[cookbook].lib_files = cookbook_settings[cookbook][:lib_files].values
+        @cookbook[cookbook].resource_files = cookbook_settings[cookbook][:resource_files].values
+        @cookbook[cookbook].provider_files = cookbook_settings[cookbook][:provider_files].values
+        @metadata[cookbook] = Chef::Cookbook::Metadata.new(@cookbook[cookbook])
+        cookbook_settings[cookbook][:metadata_files].each do |meta_json|
+          @metadata[cookbook].from_json(IO.read(meta_json))
+        end
+      end
+    end
+    
+    def [](cookbook)
+      if @cookbook.has_key?(cookbook.to_sym)
+        @cookbook[cookbook.to_sym]
+      else
+        raise ArgumentError, "Cannot find a cookbook named #{cookbook.to_s}; did you forget to add metadata to a cookbook? (http://wiki.opscode.com/display/chef/Metadata)"
+      end
+    end
+    
+    def each
+      @cookbook.each_value do |cobject|
+        yield cobject
+      end
+    end
+    
+    private
+    
+      def load_ignore_file(ignore_file)
+        results = Array.new
+        if File.exists?(ignore_file) && File.readable?(ignore_file)
+          IO.foreach(ignore_file) do |line|
+            next if line =~ /^#/
+            next if line =~ /^\w*$/
+            line.chomp!
+            results << Regexp.new(line)
+          end
+        end
+        results
+      end
+      
+      def remove_ignored_files_from(cookbook_settings)
+        file_types_to_inspect = [ :attribute_files, :definition_files, :recipe_files, :template_files, 
+                                  :remote_files, :lib_files, :resource_files, :provider_files]
+        
+        @ignore_regexes.each do |cookbook_name, regexes|
+          regexes.each do |regex|
+            settings = cookbook_settings[cookbook_name]
+            file_types_to_inspect.each do |file_type|
+              settings[file_type].delete_if { |uniqname, fullpath| fullpath.match(regex) }
+            end
+          end
+        end
+      end
+      
+      def load_cascading_files(file_glob, base_path, result_hash)
+        rm_base_path = /^#{base_path}\/(.+)$/
+        # To handle dotfiles like .ssh
+        Dir.glob(File.join(base_path, "**/#{file_glob}"), File::FNM_DOTMATCH).each do |file|
+          result_hash[rm_base_path.match(file)[1]] = file
+        end
+      end
+      
+      def load_files_unless_basename(file_glob, result_hash)
+        Dir[file_glob].each do |file|
+          result_hash[File.basename(file)] = file
+        end
+      end
+      
+  end
+end

data/lib/chef/couchdb.rb

@@ -0,0 +1,176 @@
+#
+# 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/config'
+require 'chef/rest'
+require 'chef/log'
+require 'digest/sha2'
+require 'json'
+
+class Chef
+  class CouchDB
+    include Chef::Mixin::ParamsValidate
+
+    def initialize(url=nil)
+      url ||= Chef::Config[:couchdb_url]
+      @rest = Chef::REST.new(url)
+    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)
+      end
+      Chef::Config[: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}")
+        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")
+      end
+      if to_update
+        @rest.put_rest("#{Chef::Config[:couchdb_database]}/_design%2F#{name}", data)
+      end
+      true
+    end
+
+    def store(obj_type, name, object)
+      validate(
+        {
+          :obj_type => obj_type,
+          :name => name,
+          :object => object,
+        },
+        {
+          :object => { :respond_to => :to_json },
+        }
+      )
+      @rest.put_rest("#{Chef::Config[:couchdb_database]}/#{obj_type}_#{safe_name(name)}", object)
+    end
+
+    def load(obj_type, name)
+      validate(
+        {
+          :obj_type => obj_type,
+          :name => name,
+        },
+        {
+          :obj_type => { :kind_of => String },
+          :name => { :kind_of => String },
+        }
+      )
+      @rest.get_rest("#{Chef::Config[:couchdb_database]}/#{obj_type}_#{safe_name(name)}")
+    end
+  
+    def delete(obj_type, name, rev=nil)
+      validate(
+        {
+          :obj_type => obj_type,
+          :name => name,
+        },
+        {
+          :obj_type => { :kind_of => String },
+          :name => { :kind_of => String },
+        }
+      )
+      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
+        else
+          rev = last_obj['_rev']
+        end
+      end
+      @rest.delete_rest("#{Chef::Config[:couchdb_database]}/#{obj_type}_#{safe_name(name)}?rev=#{rev}")
+    end
+  
+    def list(view, inflate=false)
+      validate(
+        { 
+          :view => view,
+        },
+        {
+          :view => { :kind_of => String }
+        }
+      )
+      if inflate
+        @rest.get_rest(view_uri(view, "all"))
+      else
+        @rest.get_rest(view_uri(view, "all_id"))
+      end
+    end
+  
+    def has_key?(obj_type, name)
+      validate(
+        {
+          :obj_type => obj_type,
+          :name => name,
+        },
+        {
+          :obj_type => { :kind_of => String },
+          :name => { :kind_of => String },
+        }
+      )
+      begin
+        @rest.get_rest("#{Chef::Config[:couchdb_database]}/#{obj_type}_#{safe_name(name)}")
+        true
+      rescue
+        false
+      end
+    end
+
+    def get_view(design, view, options={})
+      view_string = view_uri(design, view)
+      view_string << "?" if options.length != 0
+      first = true;
+      options.each { |k,v| view_string << "#{first ? '' : '&'}#{k}=#{URI.escape(v.to_json)}"; first = false }
+      @rest.get_rest(view_string)
+    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}"
+      else
+        "#{Chef::Config[:couchdb_database]}/_design/#{design}/_view/#{view}"
+      end
+    end
+    
+    private
+    
+      def safe_name(name)
+        name.gsub(/\./, "_")
+      end
+      
+  end
+end

data/lib/chef/daemon.rb

@@ -0,0 +1,170 @@
+#
+# 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}. Priveleges: #{Process.euid} #{Process.egid}")
+            File.umask 0000
+            $stdin.reopen("/dev/null")
+            $stdout.reopen("/dev/null", "a")
+            $stdout.reopen($stdout)
+            save_pid_file
+            at_exit { 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
+          File.open(file, "w") { |f| f.write(Process.pid.to_s) }
+        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
+        FileUtils.rm(pid_file) if File.exists?(pid_file)
+      end
+           
+      # Change process user/group to those specified in Chef::Config
+      #
+      def change_privilege
+        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