puppet 0.24.6 → 0.24.7

data/lib/puppet/provider/nameservice/netinfo.rb

@@ -1,5 +1,7 @@
-# Manage NetInfo POSIX objects.  Probably only used on OS X, but I suppose
-# it could be used elsewhere.
+# Manage NetInfo POSIX objects.
+#
+# This provider has been deprecated. You should be using the directoryservice
+# nameservice provider instead.
 
 require 'puppet'
 require 'puppet/provider/nameservice'
@@ -46,6 +48,7 @@ class NetInfo < Puppet::Provider::NameService
     end
     
     def self.instances
+        warnonce "The NetInfo provider is deprecated; use directoryservice instead"
         report(@resource_type.validproperties).collect do |hash|
             self.new(hash)
         end
@@ -131,6 +134,7 @@ class NetInfo < Puppet::Provider::NameService
     end
 
     def ensure=(arg)
+        warnonce "The NetInfo provider is deprecated; use directoryservice instead"
         super
 
         # Because our stupid type can't create the whole thing at once,
@@ -202,6 +206,7 @@ class NetInfo < Puppet::Provider::NameService
     
     # Get a report for a single resource, not the whole table
     def single_report(*properties)
+        warnonce "The NetInfo provider is deprecated; use directoryservice instead"
         self.class.report(*properties).find do |hash| hash[:name] == self.name end
     end
 

data/lib/puppet/provider/package/appdmg.rb

@@ -12,9 +12,6 @@
 # As a result, we store installed .app.dmg file names
 # in /var/db/.puppet_appdmg_installed_<name>
 
-# require 'ruby-debug'
-# Debugger.start
-
 require 'puppet/provider/package'
 Puppet::Type.type(:package).provide(:appdmg, :parent => Puppet::Provider::Package) do
     desc "Package management which copies application bundles to a target."

data/lib/puppet/provider/package/apt.rb

@@ -99,10 +99,16 @@ Puppet::Type.type(:package).provide :apt, :parent => :dpkg, :source => :dpkg do
     end
 
     def uninstall
+        if @resource[:responsefile]
+            self.run_preseed
+        end
         aptget "-y", "-q", :remove, @resource[:name]
     end
 
     def purge
+        if @resource[:responsefile]
+            self.run_preseed
+        end
         aptget '-y', '-q', :remove, '--purge', @resource[:name]
         # workaround a "bug" in apt, that already removed packages are not purged
         super

data/lib/puppet/provider/package/rpm.rb

@@ -4,6 +4,8 @@ Puppet::Type.type(:package).provide :rpm, :source => :rpm, :parent => Puppet::Pr
     desc "RPM packaging support; should work anywhere with a working ``rpm``
         binary."
 
+    has_feature :versionable
+
     # The query format by which we identify installed packages
     NEVRAFORMAT = "%{NAME} %|EPOCH?{%{EPOCH}}:{0}| %{VERSION} %{RELEASE} %{ARCH}"
     NEVRA_FIELDS = [:name, :epoch, :version, :release, :arch]

data/lib/puppet/provider/package/yum.rb

@@ -100,5 +100,9 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
         # Install in yum can be used for update, too
         self.install
     end
-end
+     
+    def purge
+        yum "-y", :erase, @resource[:name]
+    end
+ end
 

data/lib/puppet/provider/package/yumhelper.py

@@ -39,6 +39,15 @@ def pkg_lists(my):
 
     my.doTsSetup()
     my.doRpmDBSetup()
+
+    # Yum 2.2/2.3 python libraries require a couple of extra function calls to setup package sacks.
+    # They also don't have a __version__ attribute
+    try:
+	yumver = yum.__version__
+    except AttributeError:
+        my.doRepoSetup()
+        my.doSackSetup()
+
     return my.doPackageLists('updates')
 
 def shell_out():

data/lib/puppet/provider/service/base.rb

@@ -1,10 +1,13 @@
 Puppet::Type.type(:service).provide :base do
-    desc "The simplest form of service support.  You have to specify
-        enough about your service for this to work; the minimum you can specify
-        is a binary for starting the process, and this same binary will be 
-        searched for in the process table to stop the service.  It is 
-        preferable to specify start, stop, and status commands, akin to how you
-        would do so using ``init``."
+    desc "The simplest form of service support.
+
+    You have to specify enough about your service for this to work; the
+    minimum you can specify is a binary for starting the process, and this
+    same binary will be searched for in the process table to stop the
+    service.  It is preferable to specify start, stop, and status commands,
+    akin to how you would do so using ``init``.
+
+  "
 
     commands :kill => "kill"
 

data/lib/puppet/provider/service/daemontools.rb

@@ -2,27 +2,37 @@
 #
 # author Brice Figureau <brice-puppet@daysofwonder.com>
 Puppet::Type.type(:service).provide :daemontools, :parent => :base do
-    desc "Daemontools service management.
+    desc """Daemontools service management.
+
     This provider manages daemons running supervised by D.J.Bernstein daemontools.
     It tries to detect the service directory, with by order of preference:
-     * /service
-     * /etc/service
-     * /var/lib/svscan
+
+    * /service
+    * /etc/service
+    * /var/lib/svscan
+
     The daemon directory should be placed in a directory that can be 
     by default in:
-     * /var/lib/service
-     * /etc
-    or this can be overriden in the service resource parameters:
-    service {
-     \"myservice\":
-       provider => \"daemontools\", path => \"/path/to/daemons\";
-    }
+
+    * /var/lib/service
+    * /etc
+
+    or this can be overriden in the service resource parameters::
+
+      service {
+       \"myservice\":
+         provider => \"daemontools\", path => \"/path/to/daemons\";
+      }
 
     This provider supports out of the box:
-     * start/stop (mapped to enable/disable)
-     * enable/disable
-     * restart
-     * status"
+
+    * start/stop (mapped to enable/disable)
+    * enable/disable
+    * restart
+    * status
+
+
+  """
 
     commands :svc  => "/usr/bin/svc"
     commands :svstat => "/usr/bin/svstat"

data/lib/puppet/provider/service/debian.rb

@@ -1,8 +1,12 @@
 # Manage debian services.  Start/stop is the same as InitSvc, but enable/disable
 # is special.
 Puppet::Type.type(:service).provide :debian, :parent => :init do
-    desc "Debian's form of ``init``-style management.  The only difference
-        is that this supports service enabling and disabling via ``update-rc.d``."
+    desc "Debian's form of ``init``-style management.
+
+    The only difference is that this supports service enabling and disabling
+    via ``update-rc.d``.
+
+  "
 
     commands :update => "/usr/sbin/update-rc.d"
     defaultfor :operatingsystem => [:debian, :ubuntu]

data/lib/puppet/provider/service/freebsd.rb

@@ -1,7 +1,10 @@
 # Manage FreeBSD services.
 Puppet::Type.type(:service).provide :freebsd, :parent => :init do
-    desc "FreeBSD's (and probably NetBSD?) form of ``init``-style service
-        management; uses ``rc.conf.d`` for service enabling and disabling."
+    desc "FreeBSD's (and probably NetBSD?) form of ``init``-style service management.
+
+    Uses ``rc.conf.d`` for service enabling and disabling.
+
+"
  
     confine :operatingsystem => [:freebsd, :netbsd, :openbsd]
 

data/lib/puppet/provider/service/gentoo.rb

@@ -1,8 +1,11 @@
 # Manage gentoo services.  Start/stop is the same as InitSvc, but enable/disable
 # is special.
 Puppet::Type.type(:service).provide :gentoo, :parent => :init do
-    desc "Gentoo's form of ``init``-style service
-        management; uses ``rc-update`` for service enabling and disabling."
+    desc "Gentoo's form of ``init``-style service management.
+
+    Uses ``rc-update`` for service enabling and disabling.
+
+  "
 
     commands :update => "/sbin/rc-update"
 
@@ -35,7 +38,7 @@ Puppet::Type.type(:service).provide :gentoo, :parent => :init do
         return :false unless line
 
         # If it's enabled then it will print output showing service | runlevel
-        if output =~ /#{@resource[:name]}\s*|\s*default/
+        if output =~ /#{@resource[:name]}\s*\|\s*default/
             return :true
         else
             return :false

data/lib/puppet/provider/service/init.rb

@@ -1,10 +1,14 @@
 # The standard init-based service type.  Many other service types are
 # customizations of this module.
 Puppet::Type.type(:service).provide :init, :parent => :base do
-    desc "Standard init service management.  This provider assumes that the
-        init script has no ``status`` command, because so few scripts do,
-        so you need to either provide a status command or specify via 
-        ``hasstatus`` that one already exists in the init script."
+    desc "Standard init service management.
+
+    This provider assumes that the init script has no ``status`` command,
+    because so few scripts do, so you need to either provide a status
+    command or specify via ``hasstatus`` that one already exists in the
+    init script.
+
+"
 
     class << self
         attr_accessor :defpath
@@ -24,24 +28,30 @@ Puppet::Type.type(:service).provide :init, :parent => :base do
 
     # List all services of this type.
     def self.instances
-        path = self.defpath
-        unless FileTest.directory?(path)
-            Puppet.notice "Service path %s does not exist" % path
-            next
-        end
-
-        check = [:ensure]
-
-        if public_method_defined? :enabled?
-            check << :enable
-        end
-
-        Dir.entries(path).reject { |e|
-            fullpath = File.join(path, e)
-            e =~ /^\./ or ! FileTest.executable?(fullpath)
-        }.collect do |name|
-            new(:name => name, :path => path)
+        self.defpath = [self.defpath] unless self.defpath.is_a? Array
+        
+        instances = []
+        
+        self.defpath.each do |path|
+            unless FileTest.directory?(path)
+                Puppet.debug "Service path %s does not exist" % path
+                next
+            end
+        
+            check = [:ensure]
+        
+            if public_method_defined? :enabled?
+                check << :enable
+            end
+            
+            Dir.entries(path).each do |name|
+                fullpath = File.join(path, name)
+                next if name =~ /^\./
+                next if not FileTest.executable?(fullpath)
+                instances << new(:name => name, :path => path)
+            end
         end
+        instances
     end
 
     # Mark that our init script supports 'status' commands.

data/lib/puppet/provider/service/launchd.rb

@@ -0,0 +1,195 @@
+require 'facter/util/plist'
+
+Puppet::Type.type(:service).provide :launchd, :parent => :base do
+    desc "launchd service management framework.
+    
+    This provider manages launchd jobs, the default service framework for
+    Mac OS X, that has also been open sourced by Apple for possible use on
+    other platforms.
+    
+    See:
+     * http://developer.apple.com/macosx/launchd.html
+     * http://launchd.macosforge.org/
+     
+    This provider reads plists out of the following directories:
+     * /System/Library/LaunchDaemons
+     * /System/Library/LaunchAgents
+     * /Library/LaunchDaemons
+     * /Library/LaunchAgents
+     
+    and builds up a list of services based upon each plists \"Label\" entry.
+     
+    This provider supports:
+     * ensure => running/stopped,
+     * enable => true/false
+     * status
+     * restart
+    
+    Here is how the Puppet states correspond to launchd states:
+     * stopped => job unloaded
+     * started => job loaded
+     * enabled => 'Disable' removed from job plist file
+     * disabled => 'Disable' added to job plist file
+
+    Note that this allows you to do something launchctl can't do, which is to
+    be in a state of \"stopped/enabled\ or \"running/disabled\".
+
+  "
+
+    commands :launchctl => "/bin/launchctl"
+    
+    defaultfor :operatingsystem => :darwin
+    confine :operatingsystem => :darwin
+    
+    has_feature :enableable
+    
+    Launchd_Paths = ["/Library/LaunchAgents",
+                     "/Library/LaunchDaemons",
+                     "/System/Library/LaunchAgents",
+                     "/System/Library/LaunchDaemons",]
+
+
+    # returns a label => path map for either all jobs, or just a single
+    # job if the label is specified
+    def self.jobsearch(label=nil)
+       label_to_path_map = {}
+       Launchd_Paths.each do |path|
+           if FileTest.exists?(path)
+               Dir.entries(path).each do |f|
+                   next if f =~ /^\..*$/
+                   next if FileTest.directory?(f)
+                   fullpath = File.join(path, f)
+                   job = Plist::parse_xml(fullpath)
+                   if job and job.has_key?("Label")
+                       if job["Label"] == label
+                           return { label => fullpath }
+                       else
+                           label_to_path_map[job["Label"]] = fullpath
+                       end
+                   end
+               end
+           end
+       end
+       
+       # if we didn't find the job above and we should have, error.
+       if label
+           raise Puppet::Error.new("Unable to find launchd plist for job: #{label}")
+       end
+       # if returning all jobs
+       label_to_path_map
+    end
+
+
+    def self.instances
+        jobs = self.jobsearch
+        jobs.keys.collect do |job|
+            new(:name => job, :provider => :launchd, :path => jobs[job])
+        end
+    end
+
+
+    # finds the path for a given label and returns the path and parsed plist
+    # as an array of [path, plist]. Note plist is really a Hash here.
+    def plist_from_label(label)
+        job = self.class.jobsearch(label)
+        job_path = job[label]
+        job_plist = Plist::parse_xml(job_path)
+        if not job_plist
+            raise Puppet::Error.new("Unable to parse launchd plist at path: #{job_path}")
+        end
+        [job_path, job_plist]
+    end
+
+
+    def status
+        # launchctl list <jobname> exits zero if the job is loaded
+        # and non-zero if it isn't. Simple way to check...
+        begin
+            launchctl :list, resource[:name]           
+            return :running
+        rescue Puppet::ExecutionFailure
+            return :stopped
+        end
+    end
+
+
+    # start the service. To get to a state of running/enabled, we need to
+    # conditionally enable at load, then disable by modifying the plist file
+    # directly.
+    def start
+        job_path, job_plist = plist_from_label(resource[:name])
+        did_enable_job = false
+        cmds = []
+        cmds << :launchctl << :load 
+        if self.enabled? == :false  # launchctl won't load disabled jobs
+            cmds << "-w"
+            did_enable_job = true
+        end
+        cmds << job_path
+        begin
+            execute(cmds)
+        rescue Puppet::ExecutionFailure
+            raise Puppet::Error.new("Unable to start service: %s at path: %s" % [resource[:name], job_path])
+        end
+        # As load -w clears the Disabled flag, we need to add it in after
+        if did_enable_job and resource[:enable] == :false
+            self.disable
+        end 
+    end
+
+
+    def stop
+        job_path, job_plist = plist_from_label(resource[:name])
+        did_disable_job = false
+        cmds = []
+        cmds << :launchctl << :unload 
+        if self.enabled? == :true # keepalive jobs can't be stopped without disabling
+            cmds << "-w"
+            did_disable_job = true
+        end
+        cmds << job_path
+        begin
+            execute(cmds)
+        rescue Puppet::ExecutionFailure
+            raise Puppet::Error.new("Unable to stop service: %s at path: %s" % [resource[:name], job_path])
+        end
+        # As unload -w sets the Disabled flag, we need to add it in after
+        if did_disable_job and resource[:enable] == :true
+            self.enable
+        end
+    end
+
+
+    # launchd jobs are enabled by default. They are only disabled if the key
+    # "Disabled" is set to true, but it can also be set to false to enable it.
+    def enabled?
+        job_path, job_plist = plist_from_label(resource[:name])
+        if job_plist.has_key?("Disabled")
+            if job_plist["Disabled"]  # inverse of disabled is enabled
+                return :false
+            end
+        end
+        return :true
+    end
+
+
+    # enable and disable are a bit hacky. We write out the plist with the appropriate value
+    # rather than dealing with launchctl as it is unable to change the Disabled flag
+    # without actually loading/unloading the job.
+    def enable
+        job_path, job_plist = plist_from_label(resource[:name])
+        if self.enabled? == :false
+            job_plist.delete("Disabled")
+            Plist::Emit.save_plist(job_plist, job_path)
+        end
+    end
+
+
+    def disable
+        job_path, job_plist = plist_from_label(resource[:name])
+        job_plist["Disabled"] = true
+        Plist::Emit.save_plist(job_plist, job_path)
+    end
+
+
+end