TrueCar-chef 0.10.0.beta.3

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

@@ -0,0 +1,133 @@
+#
+# 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("Checking zypper for #{@new_resource.package_name}")
+          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("zypper version=#{$1}")
+              when /^Installed: Yes$/
+                is_installed=true
+                Chef::Log.debug("zypper installed true")
+                
+              when /^Installed: No$/
+                is_installed=false
+                Chef::Log.debug("zypper installed false")
+              when /^Status: out-of-date \(version (.+) installed\)$/
+                is_out_of_date=true
+                oud_version=$1
+                Chef::Log.debug("zypper out of date version=#{$1}")
+              end
+            end
+          end
+
+          if is_installed==false
+            @candidate_version=version
+            @current_resource.version(nil)
+            Chef::Log.debug("dentro installed false");
+          end
+ 
+          if is_installed==true
+            if is_out_of_date==true
+              @current_resource.version(oud_version)
+              @candidate_version=version
+              Chef::Log.debug("dentro installed outofdate");
+            else 
+              @current_resource.version(version)
+              @candidate_version=version
+              Chef::Log.debug("dentro installed");
+            end
+          end
+
+
+          unless status.exitstatus == 0
+            raise Chef::Exceptions::Package, "zypper failed - #{status.inspect}!"
+          end
+
+          
+          Chef::Log.debug("zypper current resource      #{@current_resource}")
+          @current_resource
+        end
+
+        def install_package(name, version)
+          if 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 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 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/remote_directory.rb

@@ -0,0 +1,138 @@
+#
+# 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/platform'
+require 'uri'
+require 'tempfile'
+require 'net/https'
+require 'set'
+
+class Chef
+  class Provider
+    class RemoteDirectory < Chef::Provider::Directory
+
+      def action_create
+        super
+        Chef::Log.debug("Doing a remote recursive directory transfer for #{@new_resource}")
+          
+        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)
+          files_to_purge.delete(::File.dirname(::File.join(@new_resource.path, cookbook_file_relative_path)))
+          files_to_purge.delete(::File.join(@new_resource.path, cookbook_file_relative_path))
+        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|
+            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
+
+      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))
+        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
+        dir.mode(@new_resource.mode)
+        dir.group(@new_resource.group)
+        dir.owner(@new_resource.owner)
+        dir.recursive(true)
+        dir
+      end
+
+    end
+  end
+end

data/lib/chef/provider/remote_file.rb

@@ -0,0 +1,119 @@
+#
+# 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/rest'
+require 'uri'
+require 'tempfile'
+require 'net/https'
+
+class Chef
+  class Provider
+    class RemoteFile < Chef::Provider::File
+
+      def load_current_resource
+        super
+        @current_resource.checksum(checksum(@current_resource.path)) if ::File.exist?(@current_resource.path)
+      end
+
+      def action_create
+        assert_enclosing_directory_exists!
+
+        Chef::Log.debug("Checking #{@new_resource} for changes")
+
+        if current_resource_matches_target_checksum?
+          Chef::Log.debug("File #{@new_resource} checksum matches target checksum (#{@new_resource.checksum}), not updating")
+        else
+          Chef::REST.new(@new_resource.source, nil, nil).fetch(@new_resource.source) 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_by_last_action(true)
+            end
+          end
+        end
+        enforce_ownership_and_permissions
+
+        @new_resource.updated_by_last_action?
+      end
+
+      def action_create_if_missing
+        if ::File.exists?(@new_resource.path)
+          Chef::Log.debug("File #{@new_resource.path} exists, taking no action.")
+        else
+          action_create
+        end
+      end
+
+      def enforce_ownership_and_permissions
+        set_owner if @new_resource.owner
+        set_group if @new_resource.group
+        set_mode  if @new_resource.mode
+      end
+
+      def current_resource_matches_target_checksum?
+        @new_resource.checksum && @current_resource.checksum && @current_resource.checksum =~ /^#{Regexp.escape(@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 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
+
+      private
+
+      def absolute_uri?(source)
+        URI.parse(source).absolute?
+      rescue URI::InvalidURIError
+        false
+      end
+
+    end
+  end
+end

data/lib/chef/provider/route.rb

@@ -0,0 +1,195 @@
+#
+# Author:: Bryan McLellan (btm@loftninjas.org), Jesse Nelson (spheromak@gmail.com)
+# Copyright:: Copyright (c) 2009 Bryan McLellan
+# 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'
+require 'chef/mixin/command'
+require 'chef/provider'
+require 'ipaddr'
+
+class Chef::Provider::Route < Chef::Provider
+    include Chef::Mixin::Command
+
+    attr_accessor :is_running
+
+    MASK = {'0.0.0.0'          => '0',
+            '128.0.0.0'        => '1',
+            '192.0.0.0'        => '2',
+            '224.0.0.0'        => '3',
+            '240.0.0.0'        => '4',
+            '248.0.0.0'        => '5',
+            '252.0.0.0'        => '6',
+            '254.0.0.0'        => '7',
+            '255.0.0.0'        => '8',
+            '255.128.0.0'      => '9',
+            '255.192.0.0'      => '10',
+            '255.224.0.0'      => '11',
+            '255.240.0.0'      => '12',
+            '255.248.0.0'      => '13',
+            '255.252.0.0'      => '14',
+            '255.254.0.0'      => '15',
+            '255.255.0.0'      => '16',
+            '255.255.128.0'    => '17',
+            '255.255.192.0'    => '18',
+            '255.255.224.0'    => '19',
+            '255.255.240.0'    => '20',
+            '255.255.248.0'    => '21',
+            '255.255.252.0'    => '22',
+            '255.255.254.0'    => '23',
+            '255.255.255.0'    => '24',
+            '255.255.255.128'  => '25',
+            '255.255.255.192'  => '26',
+            '255.255.255.224'  => '27',
+            '255.255.255.240'  => '28',
+            '255.255.255.248'  => '29',
+            '255.255.255.252'  => '30',
+            '255.255.255.254'  => '31',
+            '255.255.255.255'  => '32' }
+
+    def load_current_resource
+      is_running = nil
+
+      Chef::Log.debug("Configuring Route #{@new_resource.name}")
+
+      # cidr or quad dot mask
+      if @new_resource.netmask
+        new_ip = IPAddr.new("#{@new_resource.target}/#{@new_resource.netmask}")
+      else
+        new_ip = IPAddr.new(@new_resource.target)
+      end
+
+      # pull routes from proc
+      if node[:os] == "linux"
+        route_file = ::File.open("/proc/net/route", "r")
+        while (line = route_file.gets)
+          # proc layout
+          iface,destination,gateway,flags,refcnt,use,metric,mask,mtu,window,irtt = line.split
+
+          # need to convert packed adresses int quad dot
+          #  the addrs are reversed hex packed decimal addrs. so this unwraps them. tho you could
+          #  do this without ipaddr using unpack. ipaddr has no htoa method.
+          #
+          destination = IPAddr.new(destination.scan(/../).reverse.to_s.hex, Socket::AF_INET).to_s
+          gateway = IPAddr.new(gateway.scan(/../).reverse.to_s.hex, Socket::AF_INET).to_s
+          mask = IPAddr.new(mask.scan(/../).reverse.to_s.hex, Socket::AF_INET).to_s
+          Chef::Log.debug( "System has route:  dest=#{destination} mask=#{mask} gw=#{gateway}")
+
+          # check if what were trying to configure is already there
+          # use an ipaddr object with ip/mask this way we can have
+          # a new resource be in cidr format (i don't feel like
+          # expanding bitmask by hand.
+          #
+          running_ip = IPAddr.new("#{destination}/#{mask}")
+          Chef::Log.debug( "new ip: #{new_ip.inspect} running ip: #{running_ip.inspect} ")
+          is_running = true if running_ip == new_ip
+        end
+      route_file.close
+      end
+    end
+
+    def action_add
+      # check to see if load_current_resource found the route
+      if  is_running
+        Chef::Log.debug("Route #{@new_resource.name} already active ")
+      else
+        command = generate_command(:add)
+
+        Chef::Log.info("Adding route: #{command} ")
+        run_command( :command => command )
+        @new_resource.updated_by_last_action(true)
+      end
+
+      #for now we always write the file (ugly but its what it is)
+      generate_config
+    end
+
+    def action_delete
+      if is_running
+        command = generate_command(:delete)
+
+        Chef::Log.info("Removing route: #{command}")
+        run_command( :command => command )
+        @new_resource.updated_by_last_action(true)
+      else
+        Chef::Log.debug("Route #{@new_resource.name} does not exist")
+      end
+    end
+
+    def generate_config
+      conf = Hash.new
+      case node[:platform]
+      when ("centos" || "redhat" || "fedora")
+        # walk the collection
+        run_context.resource_collection.each do |resource|
+          if resource.is_a? Chef::Resource::Route
+            # default to eth0
+            if resource.device
+              dev = resource.device
+            else
+              dev = "eth0"
+            end
+
+            conf[dev] = String.new if conf[dev].nil?
+            if resource.action == :add
+              conf[dev] = config_file_contents(:add, :target => resource.target, :netmask => resource.netmask, :gateway => resource.gateway)
+            else
+              # need to do this for the case when the last route on an int
+              # is removed
+              conf[dev] = config_file_contents(:delete)
+            end
+          end
+        end
+        conf.each do |k, v|
+          network_file = ::File.new("/etc/sysconfig/network-scripts/route-#{k}", "w")
+          network_file.puts(conf[k])
+          Chef::Log.debug("writing route.#{k}\n#{conf[k]}")
+          network_file.close
+        end
+      end
+    end
+
+    def generate_command(action)
+      common_route_items = ''
+      common_route_items << "/#{MASK[@new_resource.netmask.to_s]}" if @new_resource.netmask
+      common_route_items << " via #{@new_resource.gateway} " if @new_resource.gateway
+
+      case action
+      when :add
+        command = "ip route replace #{@new_resource.target}"
+        command << common_route_items
+        command << " dev #{@new_resource.device} " if @new_resource.device
+      when :delete
+        command = "ip route delete #{@new_resource.target}"
+        command << common_route_items
+      end
+
+      return command
+    end
+
+    def config_file_contents(action, options={})
+      content = ''
+      case action
+      when :add
+        content << "#{options[:target]}"
+        content << "/#{options[:netmask]}" if options[:netmask]
+        content << " via #{options[:gateway]}" if options[:gateway]
+        content << "\n"
+      end
+
+      return content
+    end
+end