chef 0.7.16 → 0.8.2

data/lib/chef/provider/remote_directory.rb

@@ -35,8 +35,6 @@ class Chef
       
       def action_create
         super
-
-        @remote_file_list = Hash.new
         do_recursive
       end
     
@@ -45,81 +43,92 @@ class Chef
       def do_recursive
         if Chef::Config[:solo]
           Chef::Log.debug("Doing a local recursive directory copy for #{@new_resource}")
-          files_to_transfer = files_for_directory(@new_resource.source)
         else
           Chef::Log.debug("Doing a remote recursive directory transfer for #{@new_resource}")
-          r = Chef::REST.new(Chef::Config[:remotefile_url])
-          files_to_transfer = r.get_rest(generate_url(@new_resource.source, "files", { :recursive => "true" }))
-        end        
-
+        end
+          
         files_to_transfer.each do |remote_file_source|
           fetch_remote_file(remote_file_source)
         end
       end
       
+      def files_to_transfer
+        file_list = Chef::Config[:solo] ? generate_solo_file_list : generate_client_file_list
+        Chef::Log.debug("Generated file manifest for #{@new_resource}:\n#{file_list.join("\n")}")
+        file_list
+      end
+      
+      def generate_solo_file_list
+        # Pulled from chef-server-slice files controller
+        directory = find_preferred_file(
+          @new_resource.cookbook_name, 
+          :remote_file, 
+          @new_resource.source, 
+          @node[:fqdn],
+          @node[:platform],
+          @node[:platform_version]
+        )
+
+        unless (directory && ::File.directory?(directory))
+          raise NotFound, "Cannot find a suitable directory"
+        end
+
+        Dir[::File.join(directory, '**', '*')].sort.reverse.select do |file|
+          file[/^#{directory}\/(.+)$/, 1] unless ::File.directory?(file)
+        end
+      end
+      
+      def generate_client_file_list
+        r = Chef::REST.new(Chef::Config[:remotefile_url])
+        r.get_rest(generate_url(@new_resource.source, "files", { :recursive => "true" }))
+      end
+      
       def fetch_remote_file(remote_file_source)
         full_path = ::File.join(@new_resource.path, remote_file_source)
-        full_dir = ::File.dirname(full_path)
         
-        if !::File.directory?(full_dir)
-          create_directory(full_dir)
-        end
-
-        remote_file = Chef::Resource::RemoteFile.new(full_path, nil, @node)
-        remote_file.cookbook_name = @new_resource.cookbook || @new_resource.cookbook_name           
-        remote_file.source(::File.join(@new_resource.source, remote_file_source))
+        ensure_directory_exists(::File.dirname(full_path))
+        
+        file_to_fetch = provider_for_remote_file(full_path, remote_file_source)
+        file_to_fetch.load_current_resource
+        file_to_fetch.action_create
+        @new_resource.updated = true if file_to_fetch.new_resource.updated        
+      end
+      
+      def provider_for_remote_file(path, source)
+        remote_file = Chef::Resource::RemoteFile.new(path, nil, @node)
+        remote_file.cookbook_name = @new_resource.cookbook || @new_resource.cookbook_name
+        remote_file.source(::File.join(@new_resource.source, source))
         remote_file.mode(@new_resource.files_mode) if @new_resource.files_mode
         remote_file.group(@new_resource.files_group) if @new_resource.files_group
         remote_file.owner(@new_resource.files_owner) if @new_resource.files_owner
         remote_file.backup(@new_resource.files_backup) if @new_resource.files_backup
         
-        rf_provider = Chef::Platform.provider_for_node(@node, remote_file)
-        rf_provider.load_current_resource
-        rf_provider.action_create
-        @new_resource.updated = true if rf_provider.new_resource.updated        
+        Chef::Platform.provider_for_node(@node, remote_file)
       end
       
-      def create_directory(full_dir)
-        new_dir = Chef::Resource::Directory.new(full_dir, nil, @node)
+      def ensure_directory_exists(path)
+        unless ::File.directory?(path)
+          directory_to_create = provider_for_directory(path)
+          directory_to_create.load_current_resource
+          directory_to_create.action_create
+          @new_resource.updated = true if directory_to_create.new_resource.updated  
+        end
+      end
+      
+      def provider_for_directory(path)
+        new_dir = Chef::Resource::Directory.new(path, nil, @node)
         new_dir.cookbook_name = @new_resource.cookbook || @new_resource.cookbook_name            
         new_dir.mode(@new_resource.mode)
         new_dir.group(@new_resource.group)
         new_dir.owner(@new_resource.owner)
         new_dir.recursive(true)
         
-        d_provider = Chef::Platform.provider_for_node(@node, new_dir)
-        d_provider.load_current_resource
-        d_provider.action_create
-        @new_resource.updated = true if d_provider.new_resource.updated  
+        Chef::Platform.provider_for_node(@node, new_dir)
       end
             
       def action_create_if_missing
         raise Chef::Exceptions::UnsupportedAction, "Remote Directories do not support create_if_missing."
       end
-      # Pulled from chef-server-slice files controller
-
-      def files_for_directory(path)
-        directory = find_preferred_file(
-          @new_resource.cookbook_name, 
-          :remote_file, 
-          path, 
-          @node[:fqdn],
-          @node[:platform],
-          @node[:platform_version]
-        )
-
-        unless (directory && ::File.directory?(directory))
-          raise NotFound, "Cannot find a suitable directory"
-        end
-
-        directory_listing = Array.new
-        Dir[::File.join(directory, '**', '*')].sort { |a,b| b <=> a }.each do |file|
-          next if ::File.directory?(file)
-          file =~ /^#{directory}\/(.+)$/
-          directory_listing << $1
-        end
-        directory_listing
-      end
 
     end
   end

data/lib/chef/provider/remote_file.rb

@@ -102,7 +102,7 @@ class Chef
         begin
           uri = URI.parse(source)
           if uri.absolute
-            r = Chef::REST.new(source)
+            r = Chef::REST.new(source, nil, nil)
             Chef::Log.debug("Downloading from absolute URI: #{source}")
             r.get_rest(source, true).open
           end

data/lib/chef/provider/route.rb

@@ -1,5 +1,5 @@
 #
-# Author:: Bryan McLellan (btm@loftninjas.org)
+# Author:: Bryan McLellan (btm@loftninjas.org), Jesse Nelson (spheromak@gmail.com)
 # Copyright:: Copyright (c) 2009 Bryan McLellan
 # License:: Apache License, Version 2.0
 #
@@ -19,100 +19,156 @@
 require 'chef/log'
 require 'chef/mixin/command'
 require 'chef/provider'
-require 'erb'
+require 'ipaddr'
 
-class Chef
-  class Provider
-    class Route < Chef::Provider
-      include Chef::Mixin::Command
+class Chef::Provider::Route < Chef::Provider
+    include Chef::Mixin::Command
 
-      def load_current_resource
-        @current_resource = Chef::Resource::Route.new(@new_resource.name)
+    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' 
+    } 
 
-        Chef::Log.debug("Checking routes for #{@current_resource.target}")
-        status = popen4("route -n") do |pid, stdin, stdout, stderr|
-          stdout.each do |line|
-            case line
-            # Destination     Gateway         Genmask         Flags Metric Ref    Use Iface
-            when /^#{@new_resource.target}\s+([\d.]+)\s+([\d.]+)\s+(.+)\s+(\d+)\s+(.+)\s+(.+)\s+(\w+)$/
-              @current_resource.target(@new_resource.target)
-              @current_resource.gateway($1)
-              @current_resource.netmask($2)
-              @current_resource.metric($4.to_i)
-              @current_resource.device($7)
-              Chef::Log.debug("Found route ip:#{@current_resource.target} gw:#{@current_resource.gateway} nm:#{@current_resource.netmask} " +
-                  "metric:#{@current_resource.metric} dev:#{@current_resource.device}")
-            end
-          end
-        end
+    def load_current_resource
+        is_running = nil
+        
+        Chef::Log.debug("Configuring Route #{@new_resource.name}")
 
-        unless status.exitstatus == 0
-          raise Chef::Exception::Route, "route failed - #{status.inspect}!"
-        end
+        # 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 
 
-        @current_resource
-      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
+    def action_add
         # check to see if load_current_resource found the route
-        unless @current_resource.gateway
-          if @new_resource.route_type == :net
-            command = "route add -net #{@new_resource.target}"
-          else
-            command = "route add #{@new_resource.target}"
-          end
-          command << " netmask #{@new_resource.netmask}" if @new_resource.netmask
-          command << " gw #{@new_resource.gateway}" if @new_resource.gateway
-          command << " metric #{@new_resource.metric}" if @new_resource.metric
-          command << " dev #{@new_resource.device}" if @new_resource.device
-  
-          run_command(
-            :command => command
-          )
-          @new_resource.updated = true
+        if  is_running
+            Chef::Log.debug("Route #{@new_resource.name} already active ")
         else
-          Chef::Log.debug("Route #{@current_resource} already exists")
+            command =  "ip route replace #{@new_resource.target}"
+            command << "/#{MASK[@new_resource.netmask.to_s]}" if @new_resource.netmask 
+            command << " via #{@new_resource.gateway} "
+            command << " dev #{@new_resource.device} " if @new_resource.device
+            
+            Chef::Log.info("Adding route: #{command} ")  
+            run_command( :command => command )
+            @new_resource.updated = true
         end
-        # Write out the config files
+        
+        #for now we always write the file (ugly but its what it is)
         generate_config
-      end
 
-      def action_delete
-        # check to see if load_current_resource found the route
-        if @current_resource.gateway 
-          command = "route del #{@new_resource.target}"
-          command << " netmask #{@new_resource.netmask}" if @new_resource.netmask
-          command << " gw #{@new_resource.gateway}" if @new_resource.gateway
-          command << " metric #{@new_resource.metric}" if @new_resource.metric
-          command << " dev #{@new_resource.device}" if @new_resource.device
-  
-          run_command(
-            :command => command
-          )
-          @new_resource.updated = true
+    end
+
+    def action_delete
+        if is_running
+            command = "ip route delete #{@new_resource.target}"
+            command << "/#{MASK[@new_resource.netmask.to_s]}" if @new_resource.netmask 
+            command << " via #{@new_resource.gateway} " 
+            
+            Chef::Log.info("Removing route: #{command}")  
+            run_command( :command => command )
+            @new_resource.updated = true
         else
-          Chef::Log.debug("Route #{@current_resource} does not exist")
+            Chef::Log.debug("Route #{@new_resource.name} does not exist")
         end
-      end
+    end
 
-      def generate_config
-        b = binding
+    def generate_config
+        conf = Hash.new
         case node[:platform]
         when ("centos" || "redhat" || "fedora")
-          content = %{
-<% if @new_resource.networking %>NETWORKING=<%= @new_resource.networking %><% end %>
-<% if @new_resource.networking_ipv6 %>NETWORKING_IPV6=<%= @new_resource.networking_ipv6 %><% end %>
-<% if @new_resource.hostname %>HOSTNAME=<%= @new_resource.hostname %><% end %>
-<% if @new_resource.name %>GATEWAY=<%= @new_resource.name %><% end %>
-<% if @new_resource.domainname %>DOMAINNAME=<%= @new_resource.domainname %><% end %>
-<% if @new_resource.domainname %>DOMAIN=<%= @new_resource.domainname %><% end %>
-          }
-          template = ::ERB.new(content)
-          network_file = ::File.new("/etc/sysconfig/network", "w")
-          network_file.puts(template.result(b))
-          network_file.close
+            # walk the collection 
+            @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] << "#{resource.target}"
+                        conf[dev] << "/#{resource.netmask}" if resource.netmask
+                        conf[dev] << " via #{resource.gateway}\n" 
+                    else 
+                        # need to do this for the case when the last route on an int
+                        # is removed
+                        conf[dev] = ""
+                    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    
-    end
-  end
+    end    
 end

data/lib/chef/provider/ruby_block.rb

@@ -1,9 +1,26 @@
+#
+# 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 load_current_resource
-        Chef::Log.debug(@new_resource.inspect)
         true
       end
 

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

@@ -0,0 +1,109 @@
+#
+# Author:: Jan Zimmek (<jan.zimmek@web.de>)
+# Copyright:: Copyright (c) 2010 Jan Zimmek
+# 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'
+require 'chef/mixin/command'
+
+class Chef::Provider::Service::Arch < 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 = "/etc/rc.d/#{@new_resource.service_name}"
+  end
+  
+  def load_current_resource
+  
+    raise Chef::Exceptions::Service unless ::File.exists?("/etc/rc.conf")
+    raise Chef::Exceptions::Service unless ::File.read("/etc/rc.conf").match(/DAEMONS=\((.*)\)/)
+
+    super
+
+    @current_resource.enabled(daemons.include?(@current_resource.service_name))
+
+    @current_resource
+  end
+
+  def daemons
+    entries = []
+    if ::File.read("/etc/rc.conf").match(/DAEMONS=\((.*)\)/)
+      entries += $1.split(" ") if $1.length > 0
+    end
+    
+    yield(entries) if block_given?
+    
+    entries
+  end
+  
+  def update_daemons(entries)
+    content = ::File.read("/etc/rc.conf").gsub(/DAEMONS=\((.*)\)/, "DAEMONS=(#{entries.join(' ')})")
+    ::File.open("/etc/rc.conf", "w") do |f|
+      f.write(content)
+    end
+  end
+  
+  def enable_service()
+    new_daemons = []
+    entries = daemons
+    
+    if entries.include?(new_resource.service_name)
+      # exists and already enabled
+      new_daemons += entries
+    else
+      if entries.include?("!#{new_resource.service_name}")
+        # exists but disabled
+        entries.each do |daemon|
+          if daemon == "!#{new_resource.service_name}"  
+            new_daemons << new_resource.service_name
+          else                                          
+            new_daemons << daemon
+          end
+        end
+      else
+        # does not exist
+        new_daemons += entries
+        new_daemons << new_resource.service_name
+      end
+    end
+    
+    update_daemons(new_daemons)
+  end
+  
+  def disable_service()
+    new_daemons = []
+    entries = daemons
+    
+    if entries.include?("!#{new_resource.service_name}")
+      # exists and disabled
+      new_daemons += entries
+    else
+      if entries.include?(new_resource.service_name)
+        # exists but enabled
+        entries.each do |daemon|
+          if daemon == new_resource.service_name  
+            new_daemons << "!#{new_resource.service_name}"
+          else                                    
+            new_daemons << daemon
+          end
+        end
+      end
+    end
+    
+    update_daemons(new_daemons)
+  end
+
+end