microwave 11.400.3 → 11.400.4

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

@@ -0,0 +1,144 @@
+#
+# 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/provider/package'
+require 'chef/mixin/command'
+require 'chef/resource/package'
+require 'singleton'
+
+class Chef
+  class Provider
+    class Package
+      class Zypper < Chef::Provider::Package  
+      
+ 
+        def load_current_resource
+          @current_resource = Chef::Resource::Package.new(@new_resource.name)
+          @current_resource.package_name(@new_resource.package_name)
+
+          is_installed=false
+          is_out_of_date=false
+          version=''
+          oud_version=''
+          Chef::Log.debug("#{@new_resource} checking zypper")
+          status = popen4("zypper info #{@new_resource.package_name}") do |pid, stdin, stdout, stderr|
+            stdout.each do |line|
+              case line
+              when /^Version: (.+)$/
+                version = $1
+                Chef::Log.debug("#{@new_resource} version #{$1}")
+              when /^Installed: Yes$/
+                is_installed=true
+                Chef::Log.debug("#{@new_resource} is installed")
+                
+              when /^Installed: No$/
+                is_installed=false
+                Chef::Log.debug("#{@new_resource} is not installed")
+              when /^Status: out-of-date \(version (.+) installed\)$/
+                is_out_of_date=true
+                oud_version=$1
+                Chef::Log.debug("#{@new_resource} out of date version #{$1}")
+              end
+            end
+          end
+
+          if is_installed==false
+            @candidate_version=version
+            @current_resource.version(nil)
+          end
+ 
+          if is_installed==true
+            if is_out_of_date==true
+              @current_resource.version(oud_version)
+              @candidate_version=version
+            else 
+              @current_resource.version(version)
+              @candidate_version=version
+            end
+          end
+
+          unless status.exitstatus == 0
+            raise Chef::Exceptions::Package, "zypper failed - #{status.inspect}!"
+          end
+          
+          @current_resource
+        end
+        
+        #Gets the zypper Version from command output (Returns Floating Point number)
+        def zypper_version()
+          `zypper -V 2>&1`.scan(/\d+/).join(".").to_f
+        end
+
+        def install_package(name, version)
+          if zypper_version < 1.0
+            run_command(
+              :command => "zypper install -y #{name}"
+            )
+          elsif version
+            run_command(
+              :command => "zypper -n --no-gpg-checks install -l  #{name}=#{version}"
+            )
+          else
+            run_command(
+              :command => "zypper -n --no-gpg-checks install -l  #{name}"
+            )
+          end
+        end
+
+        def upgrade_package(name, version)
+          if zypper_version < 1.0
+            run_command(
+              :command => "zypper install -y #{name}"
+            )
+          elsif version
+            run_command(
+              :command => "zypper -n --no-gpg-checks install -l #{name}=#{version}"
+            )
+          else
+            run_command(
+              :command => "zypper -n --no-gpg-checks install -l #{name}"
+            )
+          end
+        end
+
+        def remove_package(name, version)
+          if zypper_version < 1.0
+            run_command(
+              :command => "zypper remove -y #{name}"
+            )
+          elsif version
+            run_command(
+              :command => "zypper -n --no-gpg-checks remove  #{name}=#{version}"
+            )
+          else
+            run_command(
+              :command => "zypper -n --no-gpg-checks remove  #{name}"
+            )
+          end
+            
+         
+        end
+      
+        def purge_package(name, version)
+          remove_package(name, version)
+        end
+      
+      end
+    end
+  end
+end

data/lib/chef/provider/registry_key.rb

@@ -0,0 +1,156 @@
+#
+# Author:: Prajakta Purohit (<prajakta@opscode.com>)
+# Author:: Lamont Granquist (<lamont@opscode.com>)
+#
+# Copyright:: 2011, Opscode, Inc.
+#
+# 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/file'
+require 'chef/mixin/checksum'
+require 'chef/provider'
+require 'etc'
+require 'fileutils'
+require 'chef/scan_access_control'
+require 'chef/mixin/shell_out'
+require 'chef/win32/registry'
+
+class Chef
+
+  class Provider
+    class RegistryKey < Chef::Provider
+      include Chef::Mixin::Checksum
+      include Chef::Mixin::ShellOut
+
+      def whyrun_supported?
+        true
+      end
+
+      def running_on_windows!
+        unless Chef::Platform.windows?
+          raise Chef::Exceptions::Win32NotWindows, "Attempt to manipulate the windows registry on a non-windows node"
+        end
+      end
+
+      def load_current_resource
+        running_on_windows!
+        @current_resource ||= Chef::Resource::RegistryKey.new(@new_resource.key, run_context)
+        @current_resource.key(@new_resource.key)
+        @current_resource.architecture(@new_resource.architecture)
+        @current_resource.recursive(@new_resource.recursive)
+        if registry.key_exists?(@new_resource.key)
+          @current_resource.values(registry.get_values(@new_resource.key))
+        end
+        values_to_hash(@current_resource.values)
+        @current_resource
+      end
+
+      def registry
+        @registry ||= Chef::Win32::Registry.new(@run_context, @new_resource.architecture)
+      end
+
+     def values_to_hash(values)
+        if values
+         @name_hash = Hash[values.map { |val| [val[:name], val] }]
+        else
+          @name_hash = {}
+        end
+      end
+
+      def define_resource_requirements
+        requirements.assert(:create, :create_if_missing, :delete, :delete_key) do |a|
+          a.assertion{ registry.hive_exists?(@new_resource.key) }
+          a.failure_message(Chef::Exceptions::Win32RegHiveMissing, "Hive #{@new_resource.key.split("\\").shift} does not exist")
+        end
+        requirements.assert(:create) do |a|
+          a.assertion{ registry.key_exists?(@new_resource.key) }
+          a.whyrun("Key #{@new_resource.key} does not exist. Unless it would have been created before, attempt to modify its values would fail.")
+        end
+        requirements.assert(:create, :create_if_missing) do |a|
+          #If keys missing in the path and recursive == false
+          a.assertion{ !registry.keys_missing?(@current_resource.key) || @new_resource.recursive }
+          a.failure_message(Chef::Exceptions::Win32RegNoRecursive, "Intermediate keys missing but recursive is set to false")
+          a.whyrun("Intermediate keys in #{@new_resource.key} go not exist. Unless they would have been created earlier, attempt to modify them would fail.")
+        end
+        requirements.assert(:delete_key) do |a|
+          #If key to be deleted has subkeys but recurssive == false
+          a.assertion{ !registry.key_exists?(@new_resource.key) || !registry.has_subkeys?(@new_resource.key) || @new_resource.recursive }
+          a.failure_message(Chef::Exceptions::Win32RegNoRecursive, "#{@new_resource.key} has subkeys but recursive is set to false.")
+          a.whyrun("#{@current_resource.key} has subkeys, but recursive is set to false. attempt to delete would fails unless subkeys were deleted prior to this action.")
+        end
+      end
+
+      def action_create
+        unless registry.key_exists?(@current_resource.key)
+          converge_by("create key #{@new_resource.key}") do
+            registry.create_key(@new_resource.key, @new_resource.recursive)
+          end
+        end
+        @new_resource.values.each do |value|
+          if @name_hash.has_key?(value[:name])
+            current_value = @name_hash[value[:name]]
+            unless current_value[:type] == value[:type] && current_value[:data] == value[:data]
+              converge_by("set value #{value}") do
+                registry.set_value(@new_resource.key, value)
+              end
+            end
+          else
+            converge_by("set value #{value}") do
+              registry.set_value(@new_resource.key, value)
+            end
+          end
+        end
+      end
+
+      def action_create_if_missing
+        unless registry.key_exists?(@new_resource.key)
+          converge_by("create key #{@new_resource.key}") do
+            registry.create_key(@new_resource.key, @new_resource.recursive)
+          end
+        end
+        @new_resource.values.each do |value|
+          unless @name_hash.has_key?(value[:name])
+            converge_by("create value #{value}") do
+              registry.set_value(@new_resource.key, value)
+            end
+          end
+        end
+      end
+
+      def action_delete
+        if registry.key_exists?(@new_resource.key)
+          @new_resource.values.each do |value|
+            if @name_hash.has_key?(value[:name])
+              converge_by("delete value #{value}") do
+                registry.delete_value(@new_resource.key, value)
+              end
+            end
+          end
+        end
+      end
+
+      def action_delete_key
+        if registry.key_exists?(@new_resource.key)
+          converge_by("delete key #{@new_resource.key}") do
+            registry.delete_key(@new_resource.key, @new_resource.recursive)
+          end
+        end
+      end
+
+    end
+  end
+end
+

data/lib/chef/provider/remote_directory.rb

@@ -0,0 +1,180 @@
+#
+# 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/provider/file'
+require 'chef/provider/directory'
+require 'chef/resource/directory'
+require 'chef/resource/remote_file'
+require 'chef/mixin/file_class'
+require 'chef/platform'
+require 'uri'
+require 'tempfile'
+require 'net/https'
+require 'set'
+
+class Chef
+  class Provider
+    class RemoteDirectory < Chef::Provider::Directory
+
+      include Chef::Mixin::EnforceOwnershipAndPermissions
+      include Chef::Mixin::FileClass
+
+      def action_create
+        super
+        files_to_purge = Set.new(Dir.glob(::File.join(@new_resource.path, '**', '*'),
+                                          ::File::FNM_DOTMATCH).select do |name|
+                                   name !~ /(?:^|#{Regexp.escape(::File::SEPARATOR)})\.\.?$/
+                                 end)
+
+
+        files_to_transfer.each do |cookbook_file_relative_path|
+          create_cookbook_file(cookbook_file_relative_path)
+          # the file is removed from the purge list
+          files_to_purge.delete(::File.join(@new_resource.path, cookbook_file_relative_path))
+          # parent directories are also removed from the purge list
+          directories=::File.dirname(::File.join(@new_resource.path, cookbook_file_relative_path)).split(::File::SEPARATOR)
+          for i in 0..directories.length-1
+            files_to_purge.delete(::File.join(directories[0..i]))
+          end
+        end
+        purge_unmanaged_files(files_to_purge)
+      end
+
+      def action_create_if_missing
+        # if this action is called, ignore the existing overwrite flag
+        @new_resource.overwrite(false)
+        action_create
+      end
+
+      protected
+
+      def purge_unmanaged_files(unmanaged_files)
+        if @new_resource.purge
+          unmanaged_files.sort.reverse.each do |f|
+            # file_class comes from Chef::Mixin::FileClass
+            if ::File.directory?(f) && !Chef::Platform.windows? && !file_class.symlink?(f.dup) 
+              # Linux treats directory symlinks as files
+              # Remove a directory as a directory when not on windows if it is not a symlink
+              purge_directory(f)
+            elsif ::File.directory?(f) && Chef::Platform.windows?
+              # Windows treats directory symlinks as directories so we delete them here
+              purge_directory(f)
+            else
+              converge_by("delete unmanaged file #{f}") do
+                ::File.delete(f)
+                Chef::Log.debug("#{@new_resource} deleted file #{f}")
+              end
+            end
+          end
+        end
+      end
+
+      def purge_directory(dir)
+        converge_by("delete unmanaged directory #{dir}") do
+          Dir::rmdir(dir)
+          Chef::Log.debug("#{@new_resource} removed directory #{dir}")
+        end
+      end
+
+      def files_to_transfer
+        cookbook = run_context.cookbook_collection[resource_cookbook]
+        files = cookbook.relative_filenames_in_preferred_directory(node, :files, @new_resource.source)
+        files.sort.reverse
+      end
+
+      def directory_root_in_cookbook_cache
+        @directory_root_in_cookbook_cache ||= 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
+
+      def create_cookbook_file(cookbook_file_relative_path)
+        full_path = ::File.join(@new_resource.path, cookbook_file_relative_path)
+
+        ensure_directory_exists(::File.dirname(full_path))
+
+        file_to_fetch = cookbook_file_resource(full_path, cookbook_file_relative_path)
+        if @new_resource.overwrite
+          file_to_fetch.run_action(:create)
+        else
+          file_to_fetch.run_action(:create_if_missing)
+        end
+        @new_resource.updated_by_last_action(true) if file_to_fetch.updated?
+      end
+
+      def cookbook_file_resource(target_path, relative_source_path)
+        cookbook_file = Chef::Resource::CookbookFile.new(target_path, run_context)
+        cookbook_file.cookbook_name = @new_resource.cookbook || @new_resource.cookbook_name
+        cookbook_file.source(::File.join(@new_resource.source, relative_source_path))
+        if Chef::Platform.windows? && @new_resource.files_rights
+          @new_resource.files_rights.each_pair do |permission, *args|
+            cookbook_file.rights(permission, *args)
+          end
+        end
+        cookbook_file.mode(@new_resource.files_mode)    if @new_resource.files_mode
+        cookbook_file.group(@new_resource.files_group)  if @new_resource.files_group
+        cookbook_file.owner(@new_resource.files_owner)  if @new_resource.files_owner
+        cookbook_file.backup(@new_resource.files_backup) if @new_resource.files_backup
+
+        cookbook_file
+      end
+
+      def ensure_directory_exists(path)
+        unless ::File.directory?(path)
+          directory_to_create = resource_for_directory(path)
+          directory_to_create.run_action(:create)
+          @new_resource.updated_by_last_action(true) if directory_to_create.updated?
+        end
+      end
+
+      def resource_for_directory(path)
+        dir = Chef::Resource::Directory.new(path, run_context)
+        dir.cookbook_name = @new_resource.cookbook || @new_resource.cookbook_name
+        if Chef::Platform.windows? && @new_resource.rights
+          # rights are only meant to be applied to the toppest-level directory;
+          # Windows will handle inheritance.
+          if path == @new_resource.path
+            @new_resource.rights.each do |rights| #rights is a hash
+              permissions = rights.delete(:permissions) #delete will return the value or nil if not found
+              principals = rights.delete(:principals)
+              dir.rights(permissions, principals, rights)
+            end
+          end
+        end
+        dir.mode(@new_resource.mode) if @new_resource.mode
+        dir.group(@new_resource.group)
+        dir.owner(@new_resource.owner)
+        dir.recursive(true)
+        dir
+      end
+
+      def whyrun_supported?
+        true
+      end
+
+    end
+  end
+end