microwave 11.400.3 → 11.400.4

data/lib/chef/provider/remote_file.rb

@@ -0,0 +1,141 @@
+#
+# 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
+
+      include Chef::Mixin::EnforceOwnershipAndPermissions
+
+      def load_current_resource
+        @current_resource = Chef::Resource::RemoteFile.new(@new_resource.name)
+        super
+      end
+
+      def action_create
+        Chef::Log.debug("#{@new_resource} checking for changes")
+
+        if current_resource_matches_target_checksum?
+          Chef::Log.debug("#{@new_resource} checksum matches target checksum (#{@new_resource.checksum}) - not updating")
+        else
+          sources = @new_resource.source
+          source = sources.shift
+          begin
+            rest = Chef::REST.new(source, nil, nil, http_client_opts(source))
+            raw_file = rest.streaming_request(rest.create_url(source), {})
+          rescue SocketError, Errno::ECONNREFUSED, Timeout::Error, Net::HTTPFatalError => e
+            Chef::Log.debug("#{@new_resource} cannot be downloaded from #{source}")
+            if source = sources.shift
+              Chef::Log.debug("#{@new_resource} trying to download from another mirror")
+              retry
+            else
+              raise e
+            end
+          end
+          if matches_current_checksum?(raw_file)
+            Chef::Log.debug "#{@new_resource} target and source checksums are the same - not updating"
+          else
+            description = [] 
+            description << "copy file downloaded from #{@new_resource.source} into #{@new_resource.path}"
+            description << diff_current(raw_file.path)
+            converge_by(description) do
+              backup_new_resource
+              FileUtils.cp raw_file.path, @new_resource.path
+              Chef::Log.info "#{@new_resource} updated"
+              raw_file.close!
+            end
+            # whyrun mode cleanup - the temp file will never be used,
+            # so close/unlink it here. 
+            if whyrun_mode?
+              raw_file.close!
+            end
+          end
+        end
+        set_all_access_controls
+        update_new_file_state
+      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.debug "#{@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}"
+          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
+
+      def http_client_opts(source)
+        opts={}
+        # CHEF-3140
+        # 1. If it's already compressed, trying to compress it more will
+        # probably be counter-productive.
+        # 2. Some servers are misconfigured so that you GET $URL/file.tgz but
+        # they respond with content type of tar and content encoding of gzip,
+        # which tricks Chef::REST into decompressing the response body. In this
+        # case you'd end up with a tar archive (no gzip) named, e.g., foo.tgz,
+        # which is not what you wanted.
+        if @new_resource.path =~ /gz$/ or source =~ /gz$/
+          opts[:disable_gzip] = true
+        end
+        opts
+      end
+
+      private
+
+      def absolute_uri?(source)
+        URI.parse(source).absolute?
+      rescue URI::InvalidURIError
+        false
+      end
+
+    end
+  end
+end

data/lib/chef/provider/resource_update.rb

@@ -0,0 +1,55 @@
+
+class Chef
+  class Provider
+
+    # {
+    #    "run_id" : "1000",
+    #    "resource" : { 
+    #         "type" : "file",
+    #         "name" : "/etc/passwd", 
+    #         "start_time" : "2012-01-09T08:15:30-05:00",
+    #         "end_time" : "2012-01-09T08:15:30-05:00",
+    #         "status" : "modified",
+    #         "initial_state" : "exists", 
+    #         "final_state" : "modified", 
+    #         "before" : { 
+    #              "group" : "root", 
+    #              "owner" : "root",
+    #              "checksum" : "xyz"
+    #         },
+    #         "after" : { 
+    #              "group" : "root", 
+    #              "owner" : "root",
+    #              "checksum" : "abc"
+    #         },
+    #         "delta" : "escaped delta goes here"
+    #    },
+    #    "event_data" : "" 
+    # }
+
+    class ResourceUpdate
+
+      attr_accessor :type
+      attr_accessor :name
+      attr_accessor :duration #ms
+      attr_accessor :status
+      attr_accessor :initial_state
+      attr_accessor :final_state
+      attr_accessor :initial_properties
+      attr_accessor :final_properties
+      attr_accessor :event_data # e.g., a diff.
+
+      def initial_state_from_resource(resource)
+        @initial_properties = resource.to_hash
+      end
+
+      def updated_state_from_resource(resource)
+        @final_properties = resource.to_hash
+      end
+
+    end
+  end
+end
+
+
+

data/lib/chef/provider/route.rb

@@ -0,0 +1,223 @@
+#
+# 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 hex2ip(hex_data)
+      # Cleanup hex data
+      hex_ip = hex_data.to_s.downcase.gsub(/[^0-9a-f]/, '')
+
+      # Check hex data format (IP is a 32bit integer, so should be 8 chars long)
+      return nil if hex_ip.length != hex_data.length || hex_ip.length != 8
+
+      # Extract octets from hex data
+      octets = hex_ip.scan(/../).reverse.collect { |octet| [octet].pack('H2').unpack("C").first }
+
+      # Validate IP
+      ip = octets.join('.')
+      begin
+        IPAddr.new(ip, Socket::AF_INET).to_s
+      rescue ArgumentError
+        Chef::Log.debug("Invalid IP address data: hex=#{hex_ip}, ip=#{ip}")
+        return nil
+      end
+    end
+
+    def whyrun_supported?
+      true
+    end
+
+    def load_current_resource
+      self.is_running = false
+
+      # 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
+
+      # For linux, we use /proc/net/route file to read proc table info
+      if node[:os] == "linux"
+        route_file = ::File.open("/proc/net/route", "r")
+
+        # Read all routes
+        while (line = route_file.gets)
+          # Get all the fields for a route
+          iface,destination,gateway,flags,refcnt,use,metric,mask,mtu,window,irtt = line.split
+
+          # Convert hex-encoded values to quad-dotted notation (e.g. 0064A8C0 => 192.168.100.0)
+          destination = hex2ip(destination)
+          gateway = hex2ip(gateway)
+          mask = hex2ip(mask)
+
+          # Skip formatting lines (header, etc)
+          next unless destination && gateway && mask
+          Chef::Log.debug("#{@new_resource} 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_resource} new ip: #{new_ip.inspect} running ip: #{running_ip.inspect}")
+          self.is_running = true if running_ip == new_ip && gateway == @new_resource.gateway
+        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("#{@new_resource} route already active - nothing to do")
+      else
+        command = generate_command(:add)
+        converge_by ("run #{ command } to add route") do
+          run_command( :command => command )
+          Chef::Log.info("#{@new_resource} added")
+        end
+      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)
+        converge_by ("run #{ command } to delete route ") do
+          run_command( :command => command )
+          Chef::Log.info("#{@new_resource} removed")
+        end
+      else
+        Chef::Log.debug("#{@new_resource} route does not exist - nothing to do")
+      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_name = "/etc/sysconfig/network-scripts/route-#{k}"
+          converge_by ("write route route.#{k}\n#{conf[k]} to #{ network_file_name }") do
+            network_file = ::File.new(network_file_name, "w")
+            network_file.puts(conf[k])
+            Chef::Log.debug("#{@new_resource} writing route.#{k}\n#{conf[k]}")
+            network_file.close
+          end
+        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

data/lib/chef/provider/ruby_block.rb

@@ -0,0 +1,42 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: AJ Christensen (<aj@opscode.com>)
+# Copyright:: Copyright (c) 2009 Opscode
+# 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.
+#
+
+class Chef
+  class Provider
+    class RubyBlock < Chef::Provider
+      def whyrun_supported?
+        true
+      end
+
+      def load_current_resource
+        true
+      end
+
+      def action_run
+        converge_by("execute the ruby block #{@new_resource.name}") do 
+          @new_resource.block.call
+          Chef::Log.info("#{@new_resource} called")
+        end
+      end
+
+      alias :action_create :action_run
+
+    end
+  end
+end