chef 0.8.10 → 0.8.14

data/lib/chef/provider/package/rubygems.rb

@@ -27,9 +27,8 @@ class Chef
       
         def gem_list_parse(line)
           installed_versions = Array.new
-          if line.match("^#{@new_resource.package_name} \\((.+?)\\)$")
-            installed_versions = $1.split(/, /)
-            installed_versions
+          if md = line.match(/^#{@new_resource.package_name} \((.+?)(?: [^\)\.]+)?\)$/)
+            md.captures.first.split(/, /)
           else
             nil
           end
@@ -47,9 +46,8 @@ class Chef
         
           # First, we need to look up whether we have the local gem installed or not
           status = popen4("#{gem_binary_path} list --local #{@new_resource.package_name}") do |pid, stdin, stdout, stderr|
-            stdout.each do |line|
-              installed_versions = gem_list_parse(line)
-              next unless installed_versions
+            stdout.each_line do |line|
+              next unless installed_versions = gem_list_parse(line)
               # If the version we are asking for is installed, make that our current
               # version.  Otherwise, go ahead and use the highest one, which
               # happens to come first in the array.
@@ -75,9 +73,8 @@ class Chef
           return @candidate_version if @candidate_version
 
           status = popen4("#{gem_binary_path} list --remote #{@new_resource.package_name}#{' --source=' + @new_resource.source if @new_resource.source}") do |pid, stdin, stdout, stderr|
-            stdout.each do |line|
-              installed_versions = gem_list_parse(line)
-              next unless installed_versions
+            stdout.each_line do |line|
+              next unless installed_versions = gem_list_parse(line)
               Chef::Log.debug("candidate_version: remote rubygem(s) available: #{installed_versions.inspect}")
               
               unless installed_versions.empty?
@@ -97,7 +94,7 @@ class Chef
         def install_package(name, version)
           src = nil
           if @new_resource.source
-            src = "  --source=#{@new_resource.source} --source=http://gems.rubyforge.org"
+            src = "  --source=#{@new_resource.source} --source=http://rubygems.org"
           end  
           run_command_with_systems_locale(
             :command => "#{gem_binary_path} install #{name} -q --no-rdoc --no-ri -v \"#{version}\"#{src}#{opts}"

data/lib/chef/provider/remote_directory.rb

@@ -26,6 +26,7 @@ require 'chef/platform'
 require 'uri'
 require 'tempfile'
 require 'net/https'
+require 'set'
 
 class Chef
   class Provider
@@ -47,8 +48,22 @@ class Chef
           Chef::Log.debug("Doing a remote recursive directory transfer for #{@new_resource}")
         end
           
+        existing_files = Set.new Dir[::File.join(@new_resource.path, '**', '*')]
+
         files_to_transfer.each do |remote_file_source|
           fetch_remote_file(remote_file_source)
+          existing_files.delete(::File.join(@new_resource.path, remote_file_source))
+        end
+        if @new_resource.purge
+          existing_files.sort { |a,b| b <=> a }.each do |f|
+            if ::File.directory?(f)
+              Chef::Log.debug("Removing directory #{f}")
+              Dir::rmdir(f)
+            else
+              Chef::Log.debug("Deleting file #{f}")
+              ::File.delete(f)
+            end
+          end
         end
       end
       

data/lib/chef/provider/remote_file.rb

@@ -45,42 +45,20 @@ class Chef
       def do_remote_file(source, path)
         retval = true
 
-        if(@new_resource.checksum && @current_resource.checksum && @current_resource.checksum =~ /^#{@new_resource.checksum}/)
-          Chef::Log.debug("File #{@new_resource} checksum matches, not updating")
+        if current_resource_matches_target_checksum?
+          Chef::Log.debug("File #{@new_resource} checksum matches target checksum (#{@new_resource.checksum}), not updating")
         else
           begin
-            # The remote filehandle
-            raw_file = get_from_uri(source)    ||
-                       get_from_server(source, @current_resource.checksum) ||
-                       get_from_local_cookbook(source)
-
-            # If the file exists
-            Chef::Log.debug "#{@new_resource}: Checking for file existence of #{@new_resource.path}"
-            if ::File.exists?(@new_resource.path)
-              # And it matches the checksum of the raw file
-              @new_resource.checksum(self.checksum(raw_file.path))
-              Chef::Log.debug "#{@new_resource}: File exists at #{@new_resource.path}"
-              Chef::Log.debug "#{@new_resource}: Target checksum: #{@current_resource.checksum}"
-              Chef::Log.debug "#{@new_resource}: Source checksum: #{@new_resource.checksum}"
-              if @new_resource.checksum != @current_resource.checksum
-                # Updating target file, let's perform a backup!
-                Chef::Log.debug "#{@new_resource}: checksum changed from #{@current_resource.checksum} to #{@new_resource.checksum}"
-                Chef::Log.info "#{@new_resource}: Updating #{@new_resource.path}"
-                backup @new_resource.path
+            source_file(source, @current_resource.checksum) do |raw_file|
+              if matches_current_checksum?(raw_file)
+                Chef::Log.debug "#{@new_resource}: Target and Source checksums are the same, taking no action"
+              else
+                backup_new_resource
+                Chef::Log.debug "copying remote file from origin #{raw_file.path} to destination #{@new_resource.path}"
                 FileUtils.cp raw_file.path, @new_resource.path
                 @new_resource.updated = true
-              else
-                Chef::Log.debug "#{@new_resource}: Target and Source checksums are the same, taking no action"
               end
-            else
-              # We're creating a new file
-              Chef::Log.info "#{@new_resource}: Creating #{@new_resource.path}"
-              FileUtils.cp raw_file.path, @new_resource.path
-              @new_resource.updated = true
             end
-
-            # We're done with the file, so make sure to close it if it was open.
-            raw_file.close unless raw_file.closed?
           rescue Net::HTTPRetriableError => e
             if e.response.kind_of?(Net::HTTPNotModified)
               Chef::Log.debug("File #{path} is unchanged")
@@ -89,38 +67,78 @@ class Chef
               raise e
             end
           end
+
+          Chef::Log.debug "#{@new_resource} completed"
+          retval
         end
-        
+        enforce_ownership_and_permissions
+
+        retval
+      end
+
+      def enforce_ownership_and_permissions
         set_owner if @new_resource.owner
         set_group if @new_resource.group
         set_mode  if @new_resource.mode
 
-        retval
       end
 
-      def get_from_uri(source)
-        begin
-          uri = URI.parse(source)
-          if uri.absolute
-            r = Chef::REST.new(source, nil, nil)
-            Chef::Log.debug("Downloading from absolute URI: #{source}")
-            r.get_rest(source, true).open
-          end
-        rescue URI::InvalidURIError
-          nil
+      def current_resource_matches_target_checksum?
+        @new_resource.checksum && @current_resource.checksum && @current_resource.checksum =~ /^#{@new_resource.checksum}/
+      end
+
+      def matches_current_checksum?(candidate_file)
+        Chef::Log.debug "#{@new_resource}: Checking for file existence of #{@new_resource.path}"
+        if ::File.exists?(@new_resource.path)
+          Chef::Log.debug "#{@new_resource}: File exists at #{@new_resource.path}"
+          @new_resource.checksum(checksum(candidate_file.path))
+          Chef::Log.debug "#{@new_resource}: Target checksum: #{@current_resource.checksum}"
+          Chef::Log.debug "#{@new_resource}: Source checksum: #{@new_resource.checksum}"
+          @new_resource.checksum == @current_resource.checksum
+        else
+          Chef::Log.info "#{@new_resource}: Creating #{@new_resource.path}"
+          false
+        end
+      end
+
+      def backup_new_resource
+        if ::File.exists?(@new_resource.path)
+          Chef::Log.debug "#{@new_resource}: checksum changed from #{@current_resource.checksum} to #{@new_resource.checksum}"
+          Chef::Log.info "#{@new_resource}: Updating #{@new_resource.path}"
+          backup @new_resource.path
         end
       end
 
-      def get_from_server(source, current_checksum)
-        unless Chef::Config[:solo]
-          r = Chef::REST.new(Chef::Config[:remotefile_url])
-          url = generate_url(source, "files", :checksum => current_checksum)
-          Chef::Log.debug("Downloading from server: #{url}")
-          r.get_rest(url, true).open
+      def source_file(source, current_checksum, &block)
+        if absolute_uri?(source)
+          fetch_from_uri(source, &block)
+        elsif !Chef::Config[:solo]
+          fetch_from_chef_server(source, current_checksum, &block)
+        else
+          fetch_from_local_cookbook(source, &block)
         end
       end
 
-      def get_from_local_cookbook(source)
+      private
+
+      def absolute_uri?(source)
+        URI.parse(source).absolute?
+      rescue URI::InvalidURIError
+        false
+      end
+
+      def fetch_from_uri(source)
+        Chef::Log.debug("Downloading from absolute URI: #{source}")
+        Chef::REST.new(source, nil, nil).fetch(source) { |tmp_file| yield tmp_file  }
+      end
+
+      def fetch_from_chef_server(source, current_checksum)
+        url = generate_url(source, "files", :checksum => current_checksum)
+        Chef::Log.debug("Downloading #{@new_resource} from server: #{url}")
+        Chef::REST.new(Chef::Config[:remotefile_url]).fetch(url) { |tmp_file| yield tmp_file  }
+      end
+
+      def fetch_from_local_cookbook(source)
         if Chef::Config[:solo]
           cookbook_name = @new_resource.cookbook || @new_resource.cookbook_name
           filename = find_preferred_file(
@@ -132,7 +150,12 @@ class Chef
             @node[:platform_version]
           )
           Chef::Log.debug("Using local file for remote_file:#{filename}")
-          ::File.open(filename)
+          begin
+            file = ::File.open(filename)
+            yield file
+          ensure
+            file.close
+          end
         end
       end
 

data/lib/chef/provider/script.rb

@@ -6,9 +6,9 @@
 # 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.
@@ -22,21 +22,23 @@ require 'chef/provider/execute'
 class Chef
   class Provider
     class Script < Chef::Provider::Execute
-      
-      def action_run  
+
+      def action_run
         tf = Tempfile.new("chef-script")
         tf.puts(@new_resource.code)
         tf.close
-        
+
         fr = Chef::Resource::File.new(tf.path, nil, @node)
         fr.owner(@new_resource.user)
         fr.group(@new_resource.group)
         fr.run_action(:create)
-        
-        @new_resource.command("#{@new_resource.interpreter} #{tf.path}") 
+
+        @new_resource.command("#{@new_resource.interpreter} #{tf.path}")
         super
+      ensure
+        tf && tf.close!
       end
-      
+
     end
   end
 end

data/lib/chef/provider/service/windows.rb

@@ -0,0 +1,129 @@
+#
+# Author:: Nuo Yan <nuo@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/provider/service/init'
+
+class Chef::Provider::Service::Windows < Chef::Provider::Service::Init
+
+  def initialize(node, new_resource, collection=nil, definitions=nil, cookbook_loader=nil)
+    super(node, new_resource, collection, definitions, cookbook_loader)
+    @init_command = "sc"
+  end
+
+  def load_current_resource
+    @current_resource = Chef::Resource::Service.new(@new_resource.name)
+    @current_resource.service_name(@new_resource.service_name)
+    status = IO.popen("#{@init_command} query #{@new_resource.service_name}").entries
+    raise Chef::Exceptions::Exec, "Service #{@new_resource.service_name} does not exist.\n#{status.join}\n" if status[0].include?("FAILED 1060")
+
+    begin
+      started = status[3].include?("4")
+      @current_resource.running started
+
+      start_type = IO.popen("#{@init_command} qc #{@new_resource.service_name}").entries[4]
+      @current_resource.enabled(start_type.include?('2') || start_type.include?('3') ? true : false)
+
+      Chef::Log.debug "#{@new_resource}: running: #{@current_resource.running}"
+    rescue StandardError
+      raise Chef::Exceptions::Exec
+    rescue Chef::Exceptions::Exec
+      Chef::Log.debug "Failed to determine the current status of the service, assuming it is not running"
+      @current_resource.running false
+      nil
+    end
+    @current_resource
+  end
+
+  def start_service
+    begin
+      result = if @new_resource.start_command
+                 Chef::Log.debug "starting service using the given start_command"
+                 IO.popen(@new_resource.start_command).readlines
+               else
+                 IO.popen("#{@init_command} start #{@new_resource.service_name}").readlines
+               end
+      Chef::Log.debug result.join
+      result[3].include?('4') || result.include?('2') ? true : false
+    rescue
+      Chef::Log.debug "Failed to start service #{@new_resource.service_name}"
+      false
+    end
+  end
+
+  def stop_service
+    begin
+      Chef::Log.debug "stopping service using the given stop_command"
+      result = if @new_resource.stop_command
+                 IO.popen(@new_resource.stop_command).readlines
+               else
+                 IO.popen("#{@init_command} stop #{@new_resource.service_name}").readlines
+               end
+      Chef::Log.debug result.join
+      result[3].include?('1')
+    rescue
+      Chef::Log.debug "Failed to stop service #{@new_resource.service_name}"
+      false
+    end
+  end
+
+  def restart_service
+    begin
+      if @new_resource.restart_command
+        Chef::Log.debug "restarting service using the given restart_command"
+        result = IO.popen(@new_resource.restart_command).readlines
+        Chef::Log.debug result.join
+      else
+        Chef::Log.debug IO.popen("#{@init_command} stop #{@new_resource.service_name}").readlines.join
+        sleep 1
+        result = IO.popen("#{@init_command} start #{@new_resource.service_name}").readlines
+        Chef::Log.debug result.join
+      end
+      result[3].include?('4') || result.include?('2')
+    rescue
+      Chef::Log.debug "Failed to restart service #{@new_resource.service_name}"
+      false
+    end
+  end
+
+  def enable_service()
+    begin
+      Chef::Log.debug result = IO.popen("#{@init_command} config #{@new_resource.service_name} start= #{determine_startup_type}").readlines.join
+      result.include?('SUCCESS')
+    rescue
+      Chef::Log.debug "Failed to enable service #{@new_resource.service_name}"
+      false
+    end
+  end
+
+  def disable_service()
+    begin
+      Chef::Log.debug result = IO.popen("#{@init_command} config #{@new_resource.service_name} start= disabled").readlines.join
+      result.include?('SUCCESS')
+    rescue
+      Chef::Log.debug "Failed to disable service #{@new_resource.service_name}"
+      false
+    end
+  end
+
+  private
+
+  def determine_startup_type
+    {:automatic => 'auto', :mannual => 'demand'}[@new_resource.startup_type]
+  end
+
+end

data/lib/chef/provider/subversion.rb

@@ -86,7 +86,7 @@ class Chef
           if @new_resource.revision =~ /^\d+$/
             @new_resource.revision
           else
-            command = scm(:info, @new_resource.repository, authentication, "-r#{@new_resource.revision}")
+            command = scm(:info, @new_resource.repository, @new_resource.svn_info_args, authentication, "-r#{@new_resource.revision}")
             status, svn_info, error_message = output_of_command(command, run_options)
             handle_command_failures(status, "STDOUT: #{svn_info}\nSTDERR: #{error_message}")
             extract_revision_info(svn_info)

data/lib/chef/provider/template.rb

@@ -6,9 +6,9 @@
 # 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.
@@ -27,63 +27,64 @@ require 'tempfile'
 
 class Chef
   class Provider
-    
+
     class Template < Chef::Provider::File
-      
+
       include Chef::Mixin::Checksum
       include Chef::Mixin::Template
       include Chef::Mixin::FindPreferredFile
-      
+
       def action_create
         raw_template_file = nil
-        
+
         Chef::Log.debug("looking for template #{@new_resource.source} in cookbook #{cookbook_name.inspect}")
-        
+
         cache_file_name = "cookbooks/#{cookbook_name}/templates/default/#{@new_resource.source}"
         template_cache_name = "#{cookbook_name}_#{@new_resource.source}"
-        
+
         if @new_resource.local
           cache_file_name = @new_resource.source
         elsif Chef::Config[:solo]
           cache_file_name = solo_cache_file_name
         else
           raw_template_file = fetch_template_via_rest(cache_file_name, template_cache_name)
-        end  
-        
+        end
+
         if template_updated?
           Chef::Log.debug("Updating template for #{@new_resource} in the cache")
           Chef::FileCache.move_to(raw_template_file.path, cache_file_name)
         end
 
-        template_file = render_with_context(cache_file_name)
+        render_with_context(cache_file_name) do |template_file|
 
-        update = false
-      
-        if ::File.exists?(@new_resource.path)
-          @new_resource.checksum(self.checksum(template_file.path))
-          if @new_resource.checksum != @current_resource.checksum
-            Chef::Log.debug("#{@new_resource} changed from #{@current_resource.checksum} to #{@new_resource.checksum}")
-            Chef::Log.info("Updating #{@new_resource} at #{@new_resource.path}")
+          update = false
+
+          if ::File.exists?(@new_resource.path)
+            @new_resource.checksum(checksum(template_file.path))
+            if @new_resource.checksum != @current_resource.checksum
+              Chef::Log.debug("#{@new_resource} changed from #{@current_resource.checksum} to #{@new_resource.checksum}")
+              Chef::Log.info("Updating #{@new_resource} at #{@new_resource.path}")
+              update = true
+            end
+          else
+            Chef::Log.info("Creating #{@new_resource} at #{@new_resource.path}")
             update = true
           end
-        else
-          Chef::Log.info("Creating #{@new_resource} at #{@new_resource.path}")
-          update = true
-        end
-      
-        if update
-          backup
-          FileUtils.cp(template_file.path, @new_resource.path)
-          @new_resource.updated = true
-        else
-          Chef::Log.debug("#{@new_resource} is unchanged")
+
+          if update
+            backup
+            FileUtils.mv(template_file.path, @new_resource.path)
+            @new_resource.updated = true
+          else
+            Chef::Log.debug("#{@new_resource} is unchanged")
+          end
         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_create_if_missing
         if ::File.exists?(@new_resource.path)
           Chef::Log.debug("Template #{@new_resource} exists, taking no action.")
@@ -91,32 +92,32 @@ class Chef
           action_create
         end
       end
-      
+
       private
-      
+
       def template_updated
         @template_updated = true
       end
-      
+
       def template_not_updated
         @template_updated = false
       end
-      
+
       def template_updated?
         @template_updated
       end
-      
+
       def cookbook_name
         @cookbook_name = (@new_resource.cookbook || @new_resource.cookbook_name)
       end
-      
-      def render_with_context(cache_file_name)
+
+      def render_with_context(cache_file_name, &block)
         context = {}
         context.merge!(@new_resource.variables)
         context[:node] = @node
-        render_template(Chef::FileCache.load(cache_file_name), context)
+        render_template(Chef::FileCache.load(cache_file_name), context, &block)
       end
-      
+
       def solo_cache_file_name
         filename = find_preferred_file(
           cookbook_name,
@@ -129,32 +130,32 @@ class Chef
         Chef::Log.debug("Using local file for template:#{filename}")
         Pathname.new(filename).relative_path_from(Pathname.new(Chef::Config[:file_cache_path])).to_s
       end
-      
+
       def fetch_template_via_rest(cache_file_name, template_cache_name)
         if @node.run_state[:template_cache].has_key?(template_cache_name)
           Chef::Log.debug("I have already fetched the template for #{@new_resource} once this run, not checking again.")
           template_not_updated
           return false
         end
-          
+
         r = Chef::REST.new(Chef::Config[:template_url])
-        
+
         current_checksum = nil
-        
+
         if Chef::FileCache.has_key?(cache_file_name)
           current_checksum = self.checksum(Chef::FileCache.load(cache_file_name, false))
         else
           Chef::Log.debug("Template #{@new_resource} is not in the template cache")
         end
-        
+
         template_url = generate_url(
-          @new_resource.source, 
+          @new_resource.source,
           "templates",
           {
             :checksum => current_checksum
           }
         )
-        
+
         begin
           raw_template_file = r.get_rest(template_url, true)
           template_updated
@@ -165,13 +166,13 @@ class Chef
             raise e
           end
         end
-        
+
         # We have checked the cache for this template this run
         @node.run_state[:template_cache][template_cache_name] = true
-        
+
         raw_template_file
       end
-      
+
     end
   end
 end