microwave 0.1006.33 → 1.0.0

data/lib/chef/platform.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/config'
-require 'chef/log'
-require 'chef/mixin/params_validate'
-
-# Actually, this file depends on nearly every provider in chef, but actually
-# requiring them causes circular requires resulting in uninitialized constant
-# errors.
-require 'chef/provider'
-
-
-class Chef
-  class Platform
-
-    class << self
-      attr_writer :platforms
-
-      def platforms
-        @platforms ||= {
-          :default  => {
-            :file => Chef::Provider::File,
-            :directory => Chef::Provider::Directory,
-            :link => Chef::Provider::Link,
-            :template => Chef::Provider::Template,
-            :remote_directory => Chef::Provider::RemoteDirectory,
-            :execute => Chef::Provider::Execute
-          }
-        }
-      end
-
-      include Chef::Mixin::ParamsValidate
-
-      def find(name, version)
-        provider_map = platforms[:default].clone
-
-        name_sym = name
-        if name.kind_of?(String)
-          name.downcase!
-          name.gsub!(/\s/, "_")
-          name_sym = name.to_sym
-        end
-
-        if platforms.has_key?(name_sym)
-          if platforms[name_sym].has_key?(version)
-            Chef::Log.debug("Platform #{name.to_s} version #{version} found")
-            if platforms[name_sym].has_key?(:default)
-              provider_map.merge!(platforms[name_sym][:default])
-            end
-            provider_map.merge!(platforms[name_sym][version])
-          elsif platforms[name_sym].has_key?(:default)
-            provider_map.merge!(platforms[name_sym][:default])
-          end
-        else
-          Chef::Log.debug("Platform #{name} not found, using all defaults. (Unsupported platform?)")
-        end
-        provider_map
-      end
-
-      def find_platform_and_version(node)
-        platform = nil
-        version = nil
-
-        if node[:platform]
-          platform = node[:platform]
-        elsif node.attribute?("os")
-          platform = node[:os]
-        end
-
-        raise ArgumentError, "Cannot find a platform for #{node}" unless platform
-
-        if node[:platform_version]
-          version = node[:platform_version]
-        elsif node[:os_version]
-          version = node[:os_version]
-        elsif node[:os_release]
-          version = node[:os_release]
-        end
-
-        raise ArgumentError, "Cannot find a version for #{node}" unless version
-
-        return platform, version
-      end
-
-      def provider_for_resource(resource)
-        node = resource.run_context && resource.run_context.node
-        raise ArgumentError, "Cannot find the provider for a resource with no run context set" unless node
-        find_provider_for_node(node, resource).new(resource, resource.run_context)
-      end
-
-      def provider_for_node(node, resource_type)
-        raise NotImplementedError, "#{self.class.name} no longer supports #provider_for_node"
-        find_provider_for_node(node, resource_type).new(node, resource_type)
-      end
-
-      def find_provider_for_node(node, resource_type)
-        platform, version = find_platform_and_version(node)
-        provider = find_provider(platform, version, resource_type)
-      end
-
-      def set(args)
-        validate(
-          args,
-          {
-            :platform => {
-              :kind_of => Symbol,
-              :required => false,
-            },
-            :version => {
-              :kind_of => String,
-              :required => false,
-            },
-            :resource => {
-              :kind_of => Symbol,
-            },
-            :provider => {
-              :kind_of => [ String, Symbol, Class ],
-            }
-          }
-        )
-        if args.has_key?(:platform)
-          if args.has_key?(:version)
-            if platforms.has_key?(args[:platform])
-              if platforms[args[:platform]].has_key?(args[:version])
-                platforms[args[:platform]][args[:version]][args[:resource].to_sym] = args[:provider]
-              else
-                platforms[args[:platform]][args[:version]] = {
-                  args[:resource].to_sym => args[:provider]
-                }
-              end
-            else
-              platforms[args[:platform]] = {
-                args[:version] => {
-                  args[:resource].to_sym => args[:provider]
-                }
-              }
-            end
-          else
-            if platforms.has_key?(args[:platform])
-              if platforms[args[:platform]].has_key?(:default)
-                platforms[args[:platform]][:default][args[:resource].to_sym] = args[:provider]
-              else
-                platforms[args[:platform]] = { :default => { args[:resource].to_sym => args[:provider] } }
-              end
-            else
-              platforms[args[:platform]] = {
-                :default => {
-                  args[:resource].to_sym => args[:provider]
-                }
-              }
-            end
-          end
-        else
-          if platforms.has_key?(:default)
-            platforms[:default][args[:resource].to_sym] = args[:provider]
-          else
-            platforms[:default] = {
-              args[:resource].to_sym => args[:provider]
-            }
-          end
-        end
-      end
-
-      def find_provider(platform, version, resource_type)
-        pmap = Chef::Platform.find(platform, version)
-        provider_klass = explicit_provider(platform, version, resource_type) ||
-                         platform_provider(platform, version, resource_type) ||
-                         resource_matching_provider(platform, version, resource_type)
-
-        raise ArgumentError, "Cannot find a provider for #{resource_type} on #{platform} version #{version}" if provider_klass.nil?
-
-        provider_klass
-      end
-
-      private
-
-        def explicit_provider(platform, version, resource_type)
-          resource_type.kind_of?(Chef::Resource) ? resource_type.provider : nil
-        end
-
-        def platform_provider(platform, version, resource_type)
-          pmap = Chef::Platform.find(platform, version)
-          rtkey = resource_type.kind_of?(Chef::Resource) ? resource_type.resource_name.to_sym : resource_type
-          pmap.has_key?(rtkey) ? pmap[rtkey] : nil
-        end
-
-        def resource_matching_provider(platform, version, resource_type)
-          if resource_type.kind_of?(Chef::Resource)
-            begin
-              Chef::Provider.const_get(resource_type.class.to_s.split('::').last)
-            rescue NameError
-              nil
-            end
-          else
-            nil
-          end
-        end
-
-    end
-
-  end
-end

data/lib/chef/provider.rb

@@ -1,124 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@opscode.com>)
-# Author:: Christopher Walters (<cw@opscode.com>)
-# Copyright:: Copyright (c) 2008, 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/mixin/from_file'
-require 'chef/mixin/convert_to_class_name'
-require 'chef/mixin/recipe_definition_dsl_core'
-
-class Chef
-  class Provider
-    
-    include Chef::Mixin::RecipeDefinitionDSLCore
-    
-    attr_accessor :new_resource, :current_resource, :run_context
-    
-    def initialize(new_resource, run_context)
-      @new_resource = new_resource
-      @current_resource = nil
-      @run_context = run_context
-    end
-
-    def node
-      run_context && run_context.node
-    end
-
-    # Used by providers supporting embedded recipes
-    def resource_collection
-      run_context && run_context.resource_collection
-    end
-
-    def cookbook_name
-      new_resource.cookbook_name
-    end
-    
-    def load_current_resource
-      raise Chef::Exceptions::Override, "You must override load_current_resource in #{self.to_s}"
-    end
-    
-    def action_nothing
-      Chef::Log.debug("Doing nothing for #{@new_resource.to_s}")
-      true
-    end
-    
-    protected
-    
-    def recipe_eval(&block)
-      # This block has new resource definitions within it, which
-      # essentially makes it an in-line Chef run. Save our current
-      # run_context and create one anew, so the new Chef run only
-      # executes the embedded resources.
-      #
-      # TODO: timh,cw: 2010-5-14: This means that the resources within
-      # this block cannot interact with resources outside, e.g.,
-      # manipulating notifies.
-      saved_run_context = @run_context
-      @run_context = @run_context.dup
-      @run_context.resource_collection = Chef::ResourceCollection.new
-      instance_eval(&block)
-      Chef::Runner.new(@run_context).converge
-      
-      @run_context = saved_run_context
-    end
-    
-    public
-    
-    class << self
-      include Chef::Mixin::ConvertToClassName
-      
-      def build_from_file(cookbook_name, filename, run_context)
-        pname = filename_to_qualified_string(cookbook_name, filename)
-        
-        # Add log entry if we override an existing light-weight provider.
-        class_name = convert_to_class_name(pname)
-        overriding = Chef::Provider.const_defined?(class_name)
-        Chef::Log.info("#{class_name} light-weight provider already initialized -- overriding!") if overriding
-        
-        new_provider_class = Class.new self do |cls|
-          
-          def load_current_resource
-            # silence Chef::Exceptions::Override exception
-          end
-          
-          class << cls
-            include Chef::Mixin::FromFile
-            
-            # setup DSL's shortcut methods
-            def action(name, &block)
-              define_method("action_#{name.to_s}") do
-                instance_eval(&block)
-              end
-            end
-          end
-          
-          # load provider definition from file
-          cls.class_from_file(filename)
-        end
-        
-        # register new class as a Chef::Provider
-        pname = filename_to_qualified_string(cookbook_name, filename)
-        class_name = convert_to_class_name(pname)
-        Chef::Provider.const_set(class_name, new_provider_class)
-        Chef::Log.debug("Loaded contents of #{filename} into a provider named #{pname} defined in Chef::Provider::#{class_name}")
-        
-        new_provider_class
-      end
-    end
-
-  end
-end

data/lib/chef/provider/cookbook_file.rb

@@ -1,100 +0,0 @@
-#
-# Author:: Daniel DeLeo (<dan@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/file_access_control'
-require 'chef/provider/file'
-require 'tempfile'
-
-class Chef
-  class Provider
-    class CookbookFile < Chef::Provider::File
-
-      def load_current_resource
-        @current_resource = Chef::Resource::CookbookFile.new(@new_resource.name)
-        @new_resource.path.gsub!(/\\/, "/") # for Windows
-        @current_resource.path(@new_resource.path)
-        @current_resource
-      end
-
-      def action_create
-        assert_enclosing_directory_exists!
-        if file_cache_location && content_stale?
-          Chef::Log.debug("#{@new_resource} has new contents")
-          backup_new_resource
-          Tempfile.open(::File.basename(@new_resource.name)) do |staging_file|
-            Chef::Log.debug("#{@new_resource} staging #{file_cache_location} to #{staging_file.path}")
-            staging_file.close
-            stage_file_to_tmpdir(staging_file.path)
-            FileUtils.mv(staging_file.path, @new_resource.path)
-          end
-          Chef::Log.info("#{@new_resource} created file #{@new_resource.path}")
-          @new_resource.updated_by_last_action(true)
-        else
-          set_all_access_controls(@new_resource.path)
-        end
-        @new_resource.updated_by_last_action?
-      end
-
-      def action_create_if_missing
-        if ::File.exists?(@new_resource.path)
-          Chef::Log.debug("#{@new_resource} exists at #{@new_resource.path} taking no action.")
-        else
-          action_create
-        end
-      end
-
-      def file_cache_location
-        @file_cache_location ||= begin
-          cookbook = run_context.cookbook_collection[resource_cookbook]
-          cookbook.preferred_filename_on_disk_location(node, :files, @new_resource.source, @new_resource.path)
-        end
-      end
-
-      # Determine the cookbook to get the file from. If new resource sets an
-      # explicit cookbook, use it, otherwise fall back to the implicit cookbook
-      # i.e., the cookbook the resource was declared in.
-      def resource_cookbook
-        @new_resource.cookbook || @new_resource.cookbook_name
-      end
-
-      # Copy the file from the cookbook cache to a temporary location and then
-      # set its file access control settings.
-      def stage_file_to_tmpdir(staging_file_location)
-        FileUtils.cp(file_cache_location, staging_file_location)
-        set_all_access_controls(staging_file_location)
-      end
-
-      def set_all_access_controls(file)
-        access_controls = Chef::FileAccessControl.new(@new_resource, file)
-        access_controls.set_all
-        @new_resource.updated_by_last_action(access_controls.modified?)
-      end
-
-      def backup_new_resource
-        if ::File.exists?(@new_resource.path)
-          backup @new_resource.path
-        end
-      end
-
-      def content_stale?
-        ( ! ::File.exist?(@new_resource.path)) || ( ! compare_content)
-      end
-
-    end
-  end
-end

data/lib/chef/provider/directory.rb

@@ -1,72 +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/config'
-require 'chef/log'
-require 'chef/resource/directory'
-require 'chef/provider'
-require 'chef/provider/file'
-require 'fileutils'
-
-class Chef
-  class Provider
-    class Directory < Chef::Provider::File
-      def load_current_resource
-        @current_resource = Chef::Resource::Directory.new(@new_resource.name)
-        @current_resource.path(@new_resource.path)
-        if ::File.exist?(@current_resource.path) && ::File.directory?(@current_resource.path)
-          cstats = ::File.stat(@current_resource.path)
-          @current_resource.owner(cstats.uid)
-          @current_resource.group(cstats.gid)
-          @current_resource.mode("%o" % (cstats.mode & 007777))
-        end
-        @current_resource
-      end
-
-      def action_create
-        unless ::File.exists?(@new_resource.path)
-          if @new_resource.recursive == true
-            ::FileUtils.mkdir_p(@new_resource.path)
-          else
-            ::Dir.mkdir(@new_resource.path)
-          end
-          @new_resource.updated_by_last_action(true)
-          Chef::Log.info("#{@new_resource} created directory #{@new_resource.path}")
-        end
-        set_owner if @new_resource.owner != nil
-        set_group if @new_resource.group != nil
-        set_mode if @new_resource.mode != nil
-      end
-
-      def action_delete
-        if ::File.directory?(@new_resource.path) && ::File.writable?(@new_resource.path)
-          if @new_resource.recursive == true
-            FileUtils.rm_rf(@new_resource.path)
-            Chef::Log.info("#{@new_resource} deleted #{@new_resource.path} recursively")
-          else
-            ::Dir.delete(@new_resource.path)
-            Chef::Log.info("#{@new_resource} deleted #{@new_resource.path}")
-          end
-          @new_resource.updated_by_last_action(true)
-        else
-          raise RuntimeError, "Cannot delete #{@new_resource} at #{@new_resource_path}!" if ::File.exists?(@new_resource.path)
-        end
-      end
-    end
-  end
-end