microwave 0.1006.33 → 1.0.0

data/lib/chef/file_access_control.rb

@@ -1,144 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@opscode.com>)
-# Author:: Daniel DeLeo (<dan@opscode.com>)
-# Copyright:: Copyright (c) 2008, 2010 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/log'
-
-class Chef
-
-  # == Chef::FileAccessControl
-  # FileAccessControl objects set the owner, group and mode of +file+ to
-  # the values specified by a value object, usually a Chef::Resource.
-  class FileAccessControl
-    UINT = (1 << 32)
-    UID_MAX = (1 << 32) - 10
-  
-    attr_reader :resource
-  
-    attr_reader :file
-  
-    # FileAccessControl objects set the owner, group and mode of +file+ to
-    # the values specified by +resource+. +file+ is completely independent
-    # of any file or path attribute on +resource+, so it is possible to set
-    # access control settings on a tempfile (for example).
-    # === Arguments:
-    # resource:   probably a Chef::Resource::File object (or subclass), but
-    #             this is not required. Must respond to +owner+, +group+,
-    #             and +mode+
-    # file:       The file whose access control settings you wish to modify,
-    #             given as a String.
-    def initialize(resource, file)
-      @resource, @file = resource, file
-      @modified = false
-    end
-  
-    def modified?
-      @modified
-    end
-  
-    def set_all
-      set_owner
-      set_group
-      set_mode
-    end
-  
-    # Workaround the fact that Ruby's Etc module doesn't believe in negative
-    # uids, so negative uids show up as the diminished radix complement of
-    # a uint. For example, a uid of -2 is reported as 4294967294
-    def diminished_radix_complement(int)
-      if int > UID_MAX
-        int - UINT
-      else
-        int
-      end
-    end
-  
-    def target_uid
-      return nil if resource.owner.nil?
-      if resource.owner.kind_of?(String)
-        diminished_radix_complement( Etc.getpwnam(resource.owner).uid )
-      elsif resource.owner.kind_of?(Integer)
-        resource.owner
-      else
-        Chef::Log.error("The `owner` parameter of the #@resource resource is set to an invalid value (#{resource.owner.inspect})")
-        raise ArgumentError, "cannot resolve #{resource.owner.inspect} to uid, owner must be a string or integer"
-      end
-    rescue ArgumentError
-      raise Chef::Exceptions::UserIDNotFound, "cannot determine user id for '#{resource.owner}', does the user exist on this system?"
-    end
-  
-    def set_owner
-      if (uid = target_uid) && (uid != stat.uid)
-        File.chown(uid, nil, file)
-        Chef::Log.info("#{log_string} owner changed to #{uid}")
-        modified
-      end
-    end
-  
-    def target_gid
-      return nil if resource.group.nil?
-      if resource.group.kind_of?(String)
-        diminished_radix_complement( Etc.getgrnam(resource.group).gid )
-      elsif resource.group.kind_of?(Integer)
-        resource.group
-      else
-        Chef::Log.error("The `group` parameter of the #@resource resource is set to an invalid value (#{resource.owner.inspect})")
-        raise ArgumentError, "cannot resolve #{resource.group.inspect} to gid, group must be a string or integer"
-      end
-    rescue ArgumentError
-      raise Chef::Exceptions::GroupIDNotFound, "cannot determine group id for '#{resource.group}', does the group exist on this system?"
-    end
-  
-    def set_group
-      if (gid = target_gid) && (gid != stat.gid)
-        File.chown(nil, gid, file)
-        Chef::Log.info("#{log_string} group changed to #{gid}")
-        modified
-      end
-    end
-
-    def target_mode
-      return nil if resource.mode.nil?
-      (resource.mode.respond_to?(:oct) ? resource.mode.oct : resource.mode.to_i) & 007777
-    end
-
-    def set_mode
-      if (mode = target_mode) && (mode != (stat.mode & 007777))
-        File.chmod(target_mode, file)
-        Chef::Log.info("#{log_string} mode changed to #{mode.to_s(8)}")
-        modified
-      end
-    end
-  
-
-    def stat
-      @stat ||= ::File.stat(file)
-    end
-  
-    private
-  
-    def modified
-      @modified = true
-    end
-
-    def log_string
-      @resource || @file
-    end
-  
-  end
-end

data/lib/chef/file_cache.rb

@@ -1,218 +0,0 @@
-#
-# 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/mixin/create_path'
-require 'chef/exceptions'
-require 'chef/json_compat'
-require 'fileutils'
-
-class Chef
-  class FileCache
-    class << self
-      include Chef::Mixin::ParamsValidate
-      include Chef::Mixin::CreatePath
-
-      # Write a file to the File Cache.
-      #
-      # === Parameters
-      # path<String>:: The path to the file you want to put in the cache - should
-      #   be relative to file_cache_path
-      # contents<String>:: A string with the contents you want written to the file
-      #
-      # === Returns
-      # true
-      def store(path, contents)
-        validate(
-          {
-            :path => path,
-            :contents => contents
-          },
-          {
-            :path => { :kind_of => String },
-            :contents => { :kind_of => String },
-          }
-        )
-
-        file_path_array = File.split(path)
-        file_name = file_path_array.pop
-        cache_path = create_cache_path(File.join(file_path_array))
-        File.open(File.join(cache_path, file_name), "w") do |io|
-          io.print(contents)
-        end
-        true
-      end
-
-      # Move a file into the cache.  Useful with the REST raw file output.
-      #
-      # === Parameters
-      # file<String>:: The path to the file you want in the cache
-      # path<String>:: The relative name you want the new file to use
-      def move_to(file, path)
-        validate(
-          {
-            :file => file,
-            :path => path
-          },
-          {
-            :file => { :kind_of => String },
-            :path => { :kind_of => String },
-          }
-        )
-
-        file_path_array = File.split(path)
-        file_name = file_path_array.pop
-        if File.exists?(file) && File.writable?(file)
-          FileUtils.mv(
-            file,
-            File.join(create_cache_path(File.join(file_path_array), true), file_name)
-          )
-        else
-          raise RuntimeError, "Cannot move #{file} to #{path}!"
-        end
-      end
-
-      # Read a file from the File Cache
-      #
-      # === Parameters
-      # path<String>:: The path to the file you want to load - should
-      #   be relative to file_cache_path
-      # read<True/False>:: Whether to return the file contents, or the path.
-      #   Defaults to true.
-      #
-      # === Returns
-      # String:: A string with the file contents, or the path to the file.
-      #
-      # === Raises
-      # Chef::Exceptions::FileNotFound:: If it cannot find the file in the cache
-      def load(path, read=true)
-        validate(
-          {
-            :path => path
-          },
-          {
-            :path => { :kind_of => String }
-          }
-        )
-        cache_path = create_cache_path(path, false)
-        raise Chef::Exceptions::FileNotFound, "Cannot find #{cache_path} for #{path}!" unless File.exists?(cache_path)
-        if read
-          File.read(cache_path)
-        else
-          cache_path
-        end
-      end
-
-      # Delete a file from the File Cache
-      #
-      # === Parameters
-      # path<String>:: The path to the file you want to delete - should
-      #   be relative to file_cache_path
-      #
-      # === Returns
-      # true
-      def delete(path)
-        validate(
-          {
-            :path => path
-          },
-          {
-            :path => { :kind_of => String },
-          }
-        )
-        cache_path = create_cache_path(path, false)
-        if File.exists?(cache_path)
-          File.unlink(cache_path)
-        end
-        true
-      end
-
-      # List all the files in the Cache
-      #
-      # === Returns
-      # Array:: An array of files in the cache, suitable for use with load, delete and store
-      def list
-        find("**#{File::Separator}*")
-      end
-
-      ##
-      # Find files in the cache by +glob_pattern+
-      # === Returns
-      # [String] - An array of file cache keys matching the glob
-      def find(glob_pattern)
-        keys = Array.new
-        Dir[File.join(file_cache_path, glob_pattern)].each do |f|
-          if File.file?(f)
-            keys << f[/^#{Regexp.escape(Dir[file_cache_path].first) + File::Separator}(.+)/, 1]
-          end
-        end
-        keys
-      end
-
-      # Whether or not this file exists in the Cache
-      #
-      # === Parameters
-      # path:: The path to the file you want to check - is relative
-      #   to file_cache_path
-      #
-      # === Returns
-      # True:: If the file exists
-      # False:: If it does not
-      def has_key?(path)
-        validate(
-          {
-            :path => path
-          },
-          {
-            :path => { :kind_of => String },
-          }
-        )
-        full_path = create_cache_path(path, false)
-        if File.exists?(full_path)
-          true
-        else
-          false
-        end
-      end
-
-      # Create a full path to a given file in the cache. By default,
-      # also creates the path if it does not exist.
-      #
-      # === Parameters
-      # path:: The path to create, relative to file_cache_path
-      # create_if_missing:: True by default - whether to create the path if it does not exist
-      #
-      # === Returns
-      # String:: The fully expanded path
-      def create_cache_path(path, create_if_missing=true)
-        cache_dir = File.expand_path(File.join(file_cache_path, path))
-        if create_if_missing
-          create_path(cache_dir)
-        else
-          cache_dir
-        end
-      end
-
-      private
-
-      def file_cache_path
-        Chef::Config[:file_cache_path]
-      end
-
-    end
-  end
-end

data/lib/chef/handler.rb

@@ -1,227 +0,0 @@
-#--
-# Author:: Adam Jacob (<adam@opscode.com>)
-# Copyright:: Copyright (c) 2010 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/client'
-require 'forwardable'
-
-class Chef
-  # == Chef::Handler
-  # The base class for an Exception or Notification Handler. Create your own
-  # handler by subclassing Chef::Handler. When a Chef run fails with an
-  # uncaught Exception, Chef will set the +run_status+ on your handler and call
-  # +report+
-  #
-  # ===Example:
-  #
-  #   require 'net/smtp'
-  #
-  #   module MyOrg
-  #     class OhNoes < Chef::Handler
-  #
-  #       def report
-  #         # Create the email message
-  #         message  = "From: Your Name <your@mail.address>\n"
-  #         message << "To: Destination Address <someone@example.com>\n"
-  #         message << "Subject: Chef Run Failure\n"
-  #         message << "Date: #{Time.now.rfc2822}\n\n"
-  #
-  #         # The Node is available as +node+
-  #         message << "Chef run failed on #{node.name}\n"
-  #         # +run_status+ is a value object with all of the run status data
-  #         message << "#{run_status.formatted_exception}\n"
-  #         # Join the backtrace lines. Coerce to an array just in case.
-  #         message << Array(backtrace).join("\n")
-  #
-  #         # Send the email
-  #         Net::SMTP.start('your.smtp.server', 25) do |smtp|
-  #           smtp.send_message message, 'from@address', 'to@address'
-  #         end
-  #       end
-  #
-  #     end
-  #   end
-  #
-  class Handler
-
-    # The list of currently configured start handlers
-    def self.start_handlers
-      Array(Chef::Config[:start_handlers])
-    end
-
-    # Run the start handlers. This will usually be called by a notification
-    # from Chef::Client
-    def self.run_start_handlers(run_status)
-      Chef::Log.info("Running start handlers") unless Chef::Config[:quiet_logging]
-      start_handlers.each do |handler|
-        handler.run_report_safely(run_status)
-      end
-      Chef::Log.info("Start handlers complete.") unless Chef::Config[:quiet_logging]
-    end
-
-    # Wire up a notification to run the start handlers when the chef run
-    # starts.
-    Chef::Client.when_run_starts do |run_status|
-      run_start_handlers(run_status)
-    end
-
-    # The list of currently configured report handlers
-    def self.report_handlers
-      Array(Chef::Config[:report_handlers])
-    end
-
-    # Run the report handlers. This will usually be called by a notification
-    # from Chef::Client
-    def self.run_report_handlers(run_status)
-      Chef::Log.info("Running report handlers") unless Chef::Config[:quiet_logging]
-      report_handlers.each do |handler|
-        handler.run_report_safely(run_status)
-      end
-      Chef::Log.info("Report handlers complete") unless Chef::Config[:quiet_logging]
-    end
-
-    # Wire up a notification to run the report handlers if the chef run
-    # succeeds.
-    Chef::Client.when_run_completes_successfully do |run_status|
-      run_report_handlers(run_status)
-    end
-
-    # The list of currently configured exception handlers
-    def self.exception_handlers
-      Array(Chef::Config[:exception_handlers])
-    end
-
-    # Run the exception handlers. Usually will be called by a notification
-    # from Chef::Client when the run fails.
-    def self.run_exception_handlers(run_status)
-      Chef::Log.error("Running exception handlers")
-      exception_handlers.each do |handler|
-        handler.run_report_safely(run_status)
-      end
-      Chef::Log.error("Exception handlers complete")
-    end
-
-    # Wire up a notification to run the exception handlers if the chef run fails.
-    Chef::Client.when_run_fails do |run_status|
-      run_exception_handlers(run_status)
-    end
-
-    extend Forwardable
-
-    # The Chef::RunStatus object containing data about the Chef run.
-    attr_reader :run_status
-
-    ##
-    # :method: start_time
-    #
-    # The time the chef run started
-    def_delegator :@run_status, :start_time
-
-    ##
-    # :method: end_time
-    #
-    # The time the chef run ended
-    def_delegator :@run_status, :end_time
-
-    ##
-    # :method: elapsed_time
-    #
-    # The time elapsed between the start and finish of the chef run
-    def_delegator :@run_status, :elapsed_time
-
-    ##
-    # :method: run_context
-    #
-    # The Chef::RunContext object used by the chef run
-    def_delegator :@run_status, :run_context
-
-    ##
-    # :method: exception
-    #
-    # The uncaught Exception that terminated the chef run, or nil if the run
-    # completed successfully
-    def_delegator :@run_status, :exception
-
-    ##
-    # :method: backtrace
-    #
-    # The backtrace captured by the uncaught exception that terminated the chef
-    # run, or nil if the run completed successfully
-    def_delegator :@run_status, :backtrace
-
-    ##
-    # :method: node
-    #
-    # The Chef::Node for this client run
-    def_delegator :@run_status, :node
-
-    ##
-    # :method: all_resources
-    #
-    # An Array containing all resources in the chef run's resource_collection
-    def_delegator :@run_status, :all_resources
-
-    ##
-    # :method: updated_resources
-    #
-    # An Array containing all resources that were updated during the chef run
-    def_delegator :@run_status, :updated_resources
-
-    ##
-    # :method: success?
-    #
-    # Was the chef run successful? True if the chef run did not raise an
-    # uncaught exception
-    def_delegator :@run_status, :success?
-
-    ##
-    # :method: failed?
-    #
-    # Did the chef run fail? True if the chef run raised an uncaught exception
-    def_delegator :@run_status, :failed?
-
-    # The main entry point for report handling. Subclasses should override this
-    # method with their own report handling logic.
-    def report
-    end
-
-    # Runs the report handler, rescuing and logging any errors it may cause.
-    # This ensures that all handlers get a chance to run even if one fails.
-    # This method should not be overridden by subclasses unless you know what
-    # you're doing.
-    def run_report_safely(run_status)
-      run_report_unsafe(run_status)
-    rescue Exception => e
-      Chef::Log.error("Report handler #{self.class.name} raised #{e.inspect}")
-      Array(e.backtrace).each { |line| Chef::Log.error(line) }
-    ensure
-      @run_status = nil
-    end
-
-    # Runs the report handler without any error handling. This method should
-    # not be used directly except in testing.
-    def run_report_unsafe(run_status)
-      @run_status = run_status
-      report
-    end
-
-    # Return the Hash representation of the run_status
-    def data
-      @run_status.to_hash
-    end
-
-  end
-end