puppet 0.25.5 → 2.6.0

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

@@ -1,56 +1,136 @@
-# 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 "Provider for FreeBSD. Makes use of rcvar argument of init scripts and parses/edits rc files."
 
-"
+  confine :operatingsystem => [:freebsd]
+  defaultfor :operatingsystem => [:freebsd]
 
-    confine :operatingsystem => [:freebsd, :netbsd, :openbsd]
+  @@rcconf = '/etc/rc.conf'
+  @@rcconf_local = '/etc/rc.conf.local'
+  @@rcconf_dir = '/etc/rc.conf.d'
 
-    defaultfor :operatingsystem => :freebsd
+  def self.defpath
+    superclass.defpath
+  end
 
-    @@rcconf_dir = '/etc/rc.conf.d'
+  # Executing an init script with the 'rcvar' argument returns
+  # the service name, rcvar name and whether it's enabled/disabled
+  def rcvar
+    rcvar = execute([self.initscript, :rcvar], :failonfail => true, :squelch => false)
+    rcvar = rcvar.split("\n")
+  end
 
-    def self.defpath
-        superclass.defpath
-    end
+  # Extract service name
+  def service_name
+    name = self.rcvar[0]
+    self.error("No service name found in rcvar") if name.nil?
+    name = name.gsub!(/# (.*)/, '\1')
+    self.error("Service name is empty") if name.nil?
+    self.debug("Service name is #{name}")
+    name
+  end
 
-    # remove service file from rc.conf.d to disable it
-    def disable
-        rcfile = File.join(@@rcconf_dir, @model[:name])
-        if File.exists?(rcfile)
-            File.delete(rcfile)
-        end
-    end
+  # Extract rcvar name
+  def rcvar_name
+    name = self.rcvar[1]
+    self.error("No rcvar name found in rcvar") if name.nil?
+    name = name.gsub!(/(.*)_enable=(.*)/, '\1')
+    self.error("rcvar name is empty") if name.nil?
+    self.debug("rcvar name is #{name}")
+    name
+  end
 
-    # if the service file exists in rc.conf.d then it's already enabled
-    def enabled?
-        rcfile = File.join(@@rcconf_dir, @model[:name])
-        if File.exists?(rcfile)
-            return :true
-        end
+  # Extract rcvar value
+  def rcvar_value
+    value = self.rcvar[1]
+    self.error("No rcvar value found in rcvar") if value.nil?
+    value = value.gsub!(/(.*)_enable=\"?(.*)\"?/, '\2')
+    self.error("rcvar value is empty") if value.nil?
+    self.debug("rcvar value is #{value}")
+    value
+  end
 
-        return :false
-    end
+  # Edit rc files and set the service to yes/no
+  def rc_edit(yesno)
+    service = self.service_name
+    rcvar = self.rcvar_name
+    self.debug("Editing rc files: setting #{rcvar} to #{yesno} for #{service}")
+    self.rc_add(service, rcvar, yesno) if not self.rc_replace(service, rcvar, yesno)
+  end
 
-    # enable service by creating a service file under rc.conf.d with the
-    # proper contents
-    def enable
-        if not File.exists?(@@rcconf_dir)
-            Dir.mkdir(@@rcconf_dir)
+  # Try to find an existing setting in the rc files
+  # and replace the value
+  def rc_replace(service, rcvar, yesno)
+    success = false
+    # Replace in all files, not just in the first found with a match
+    [@@rcconf, @@rcconf_local, @@rcconf_dir + "/#{service}"].each do |filename|
+      if File.exists?(filename)
+        s = File.read(filename)
+        if s.gsub!(/(#{rcvar}_enable)=\"?(YES|NO)\"?/, "\\1=\"#{yesno}\"")
+          File.open(filename, File::WRONLY) { |f| f << s }
+          self.debug("Replaced in #{filename}")
+          success = true
         end
-        rcfile = File.join(@@rcconf_dir, @model[:name])
-        open(rcfile, 'w') { |f| f << "%s_enable=\"YES\"\n" % @model[:name] }
+      end
     end
+    success
+  end
 
-    # Override stop/start commands to use one<cmd>'s and the avoid race condition
-    # where provider trys to stop/start the service before it is enabled
-    def startcmd
-        [self.initscript, :onestart]
+  # Add a new setting to the rc files
+  def rc_add(service, rcvar, yesno)
+    append = "\n\# Added by Puppet\n#{rcvar}_enable=\"#{yesno}\""
+    # First, try the one-file-per-service style
+    if File.exists?(@@rcconf_dir)
+      File.open(@@rcconf_dir + "/#{service}", File::WRONLY | File::APPEND | File::CREAT, 0644) {
+        |f| f << append
+        self.debug("Appended to #{f.path}")
+      }
+    else
+      # Else, check the local rc file first, but don't create it
+      if File.exists?(@@rcconf_local)
+        File.open(@@rcconf_local, File::WRONLY | File::APPEND) {
+          |f| f << append
+          self.debug("Appended to #{f.path}")
+        }
+      else
+        # At last use the standard rc.conf file
+        File.open(@@rcconf, File::WRONLY | File::APPEND | File::CREAT, 0644) {
+          |f| f << append
+          self.debug("Appended to #{f.path}")
+        }
+      end
     end
+  end
 
-    def stopcmd
-        [self.initscript, :onestop]
+  def enabled?
+    if /YES$/ =~ self.rcvar_value
+      self.debug("Is enabled")
+      return :true
     end
+    self.debug("Is disabled")
+    :false
+  end
+
+  def enable
+    self.debug("Enabling")
+    self.rc_edit("YES")
+  end
+
+  def disable
+    self.debug("Disabling")
+    self.rc_edit("NO")
+  end
+
+  def startcmd
+    [self.initscript, :onestart]
+  end
+
+  def stopcmd
+    [self.initscript, :onestop]
+  end
+
+  def statuscmd
+    [self.initscript, :onestatus]
+  end
+
 end

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

@@ -1,58 +1,52 @@
 # 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.
+  desc "Gentoo's form of ``init``-style service management.
 
-    Uses ``rc-update`` for service enabling and disabling.
+  Uses ``rc-update`` for service enabling and disabling.
 
-    "
+  "
 
-    commands :update => "/sbin/rc-update"
+  commands :update => "/sbin/rc-update"
 
-    confine :operatingsystem => :gentoo
+  confine :operatingsystem => :gentoo
 
-    defaultfor :operatingsystem => :gentoo
+  defaultfor :operatingsystem => :gentoo
 
-    def self.defpath
-        superclass.defpath
-    end
+  def self.defpath
+    superclass.defpath
+  end
 
-    def disable
-        begin
-            output = update :del, @resource[:name], :default
-        rescue Puppet::ExecutionFailure
-            raise Puppet::Error, "Could not disable %s: %s" %
-                [self.name, output]
-        end
-    end
+  def disable
+      output = update :del, @resource[:name], :default
+  rescue Puppet::ExecutionFailure
+      raise Puppet::Error, "Could not disable #{self.name}: #{output}"
+  end
 
-    def enabled?
-        begin
-            output = update :show
-        rescue Puppet::ExecutionFailure
-            return :false
-        end
+  def enabled?
+    begin
+      output = update :show
+    rescue Puppet::ExecutionFailure
+      return :false
+    end
 
-        line = output.split(/\n/).find { |l| l.include?(@resource[:name]) }
+    line = output.split(/\n/).find { |l| l.include?(@resource[:name]) }
 
-        return :false unless line
+    return :false unless line
 
-        # If it's enabled then it will print output showing service | runlevel
-        if output =~ /^\s*#{@resource[:name]}\s*\|\s*(boot|default)/
-            return :true
-        else
-            return :false
-        end
+    # If it's enabled then it will print output showing service | runlevel
+    if output =~ /^\s*#{@resource[:name]}\s*\|\s*(boot|default)/
+      return :true
+    else
+      return :false
     end
+  end
 
-    def enable
-        begin
-            output = update :add, @resource[:name], :default
-        rescue Puppet::ExecutionFailure
-            raise Puppet::Error, "Could not enable %s: %s" %
-                [self.name, output]
-        end
-    end
+  def enable
+      output = update :add, @resource[:name], :default
+  rescue Puppet::ExecutionFailure
+      raise Puppet::Error, "Could not enable #{self.name}: #{output}"
+  end
 end
 
 # $Id $

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

@@ -1,141 +1,141 @@
 # 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.
+  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.
+  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
+  class << self
+    attr_accessor :defpath
+  end
+
+  case Facter["operatingsystem"].value
+  when "FreeBSD"
+    @defpath = ["/etc/rc.d", "/usr/local/etc/rc.d"]
+  when "HP-UX"
+    @defpath = "/sbin/init.d"
+  else
+    @defpath = "/etc/init.d"
+  end
+
+  # We can't confine this here, because the init path can be overridden.
+  #confine :exists => @defpath
+
+  # List all services of this type.
+  def self.instances
+    get_services(self.defpath)
+  end
+
+  def self.get_services(defpath, exclude=[])
+    defpath = [defpath] unless defpath.is_a? Array
+    instances = []
+    defpath.each do |path|
+      unless FileTest.directory?(path)
+        Puppet.debug "Service path #{path} does not exist"
+        next
+      end
+
+      check = [:ensure]
+
+      check << :enable if public_method_defined? :enabled?
+
+      Dir.entries(path).each do |name|
+        fullpath = File.join(path, name)
+        next if name =~ /^\./
+        next if exclude.include? name
+        next if not FileTest.executable?(fullpath)
+        instances << new(:name => name, :path => path, :hasstatus => true)
+      end
     end
-
-    case Facter["operatingsystem"].value
-    when "FreeBSD"
-        @defpath = ["/etc/rc.d", "/usr/local/etc/rc.d"]
-    when "HP-UX"
-        @defpath = "/sbin/init.d"
+    instances
+  end
+
+  # Mark that our init script supports 'status' commands.
+  def hasstatus=(value)
+    case value
+    when true, "true"; @parameters[:hasstatus] = true
+    when false, "false"; @parameters[:hasstatus] = false
     else
-        @defpath = "/etc/init.d"
+      raise Puppet::Error, "Invalid 'hasstatus' value #{value.inspect}"
     end
-
-    # We can't confine this here, because the init path can be overridden.
-    #confine :exists => @defpath
-
-    # List all services of this type.
-    def self.instances
-        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.
-    def hasstatus=(value)
-        case value
-        when true, "true"; @parameters[:hasstatus] = true
-        when false, "false"; @parameters[:hasstatus] = false
+  end
+
+  # Where is our init script?
+  def initscript
+    @initscript ||= self.search(@resource[:name])
+  end
+
+  def paths
+    @paths ||= @resource[:path].find_all do |path|
+      if File.directory?(path)
+        true
+      else
+        if File.exist?(path) and ! File.directory?(path)
+          self.debug "Search path #{path} is not a directory"
         else
-            raise Puppet::Error, "Invalid 'hasstatus' value %s" %
-                value.inspect
-        end
-    end
-
-    # Where is our init script?
-    def initscript
-        @initscript ||= self.search(@resource[:name])
-    end
-
-    def paths
-        @paths ||= @resource[:path].find_all do |path|
-            if File.directory?(path)
-                true
-            else
-                if File.exist?(path) and ! File.directory?(path)
-                    self.debug "Search path #{path} is not a directory"
-                else
-                    self.debug "Search path #{path} does not exist"
-                end
-                false
-            end
+          self.debug "Search path #{path} does not exist"
         end
+        false
+      end
     end
-
-    def search(name)
-        paths.each { |path|
-            fqname = File.join(path,name)
-            begin
-                stat = File.stat(fqname)
-            rescue
-                # should probably rescue specific errors...
-                self.debug("Could not find %s in %s" % [name,path])
-                next
-            end
-
-            # if we've gotten this far, we found a valid script
-            return fqname
-        }
-
-        paths.each { |path|
-            fqname_sh = File.join(path,"#{name}.sh")
-            begin
-                stat = File.stat(fqname_sh)
-            rescue
-                # should probably rescue specific errors...
-                self.debug("Could not find %s.sh in %s" % [name,path])
-                next
-            end
-
-            # if we've gotten this far, we found a valid script
-            return fqname_sh
-        }
-        raise Puppet::Error, "Could not find init script for '%s'" % name
-    end
-
-    # The start command is just the init scriptwith 'start'.
-    def startcmd
-        [initscript, :start]
-    end
-
-    # The stop command is just the init script with 'stop'.
-    def stopcmd
-        [initscript, :stop]
-    end
-
-    def restartcmd
-        (@resource[:hasrestart] == :true) && [initscript, :restart]
-    end
-
-    # If it was specified that the init script has a 'status' command, then
-    # we just return that; otherwise, we return false, which causes it to
-    # fallback to other mechanisms.
-    def statuscmd
-        (@resource[:hasstatus] == :true) && [initscript, :status]
-    end
+  end
+
+  def search(name)
+    paths.each { |path|
+      fqname = File.join(path,name)
+      begin
+        stat = File.stat(fqname)
+      rescue
+        # should probably rescue specific errors...
+        self.debug("Could not find #{name} in #{path}")
+        next
+      end
+
+      # if we've gotten this far, we found a valid script
+      return fqname
+    }
+
+    paths.each { |path|
+      fqname_sh = File.join(path,"#{name}.sh")
+      begin
+        stat = File.stat(fqname_sh)
+      rescue
+        # should probably rescue specific errors...
+        self.debug("Could not find #{name}.sh in #{path}")
+        next
+      end
+
+      # if we've gotten this far, we found a valid script
+      return fqname_sh
+    }
+    raise Puppet::Error, "Could not find init script for '#{name}'"
+  end
+
+  # The start command is just the init scriptwith 'start'.
+  def startcmd
+    [initscript, :start]
+  end
+
+  # The stop command is just the init script with 'stop'.
+  def stopcmd
+    [initscript, :stop]
+  end
+
+  def restartcmd
+    (@resource[:hasrestart] == :true) && [initscript, :restart]
+  end
+
+  # If it was specified that the init script has a 'status' command, then
+  # we just return that; otherwise, we return false, which causes it to
+  # fallback to other mechanisms.
+  def statuscmd
+    (@resource[:hasstatus] == :true) && [initscript, :status]
+  end
 
 end