puppet-parse 0.0.1 → 0.0.2

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

@@ -0,0 +1,54 @@
+# 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 <<-EOT
+    Gentoo's form of `init`-style service management.
+
+    Uses `rc-update` for service enabling and disabling.
+
+  EOT
+
+  commands :update => "/sbin/rc-update"
+
+  confine :operatingsystem => :gentoo
+
+  def self.defpath
+    superclass.defpath
+  end
+
+  def self.instances
+    # this exclude list was found with grep -L '\/sbin\/runscript' /etc/init.d/*
+    self.get_services(self.defpath, ['functions.sh', 'reboot.sh', 'shutdown.sh'])
+  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
+
+    line = output.split(/\n/).find { |l| l.include?(@resource[:name]) }
+
+    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
+  end
+
+  def enable
+      output = update :add, @resource[:name], :default
+  rescue Puppet::ExecutionFailure
+      raise Puppet::Error, "Could not enable #{self.name}: #{output}"
+  end
+end

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

@@ -0,0 +1,140 @@
+# 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`-style service management."
+
+  def self.defpath
+    case Facter.value(:operatingsystem)
+    when "FreeBSD"
+      ["/etc/rc.d", "/usr/local/etc/rc.d"]
+    when "HP-UX"
+      "/sbin/init.d"
+    when "Archlinux"
+      "/etc/rc.d"
+    else
+      "/etc/init.d"
+    end
+  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)
+        next if not is_init?(fullpath)
+        instances << new(:name => name, :path => path, :hasstatus => true)
+      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
+    else
+      raise Puppet::Error, "Invalid 'hasstatus' value #{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
+    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
+
+private
+
+  def self.is_init?(script = initscript)
+    !File.symlink?(script) || File.readlink(script) != "/lib/init/upstart-job"
+  end
+end
+

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

@@ -0,0 +1,303 @@
+require 'facter/util/plist'
+Puppet::Type.type(:service).provide :launchd, :parent => :base do
+  desc <<-'EOT'
+    This provider manages jobs with `launchd`, which is the default service
+    framework for Mac OS X (and may be available for use on other platforms).
+
+    For `launchd` documentation, 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 plist's "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".
+
+    Note that this provider does not support overriding 'restart' or 'status'.
+
+  EOT
+
+  include Puppet::Util::Warnings
+
+  commands :launchctl => "/bin/launchctl"
+  commands :sw_vers   => "/usr/bin/sw_vers"
+  commands :plutil    => "/usr/bin/plutil"
+
+  defaultfor :operatingsystem => :darwin
+  confine :operatingsystem    => :darwin
+
+  has_feature :enableable
+  mk_resource_methods
+
+  Launchd_Paths = [ "/Library/LaunchAgents",
+                    "/Library/LaunchDaemons",
+                    "/System/Library/LaunchAgents",
+                    "/System/Library/LaunchDaemons"]
+
+  Launchd_Overrides = "/var/db/launchd.db/com.apple.launchd/overrides.plist"
+  
+  # Caching is enabled through the following three methods. Self.prefetch will
+  # call self.instances to create an instance for each service. Self.flush will
+  # clear out our cache when we're done.
+  def self.prefetch(resources)
+    instances.each do |prov|
+      if resource = resources[prov.name]
+        resource.provider = prov
+      end
+    end
+  end
+
+  # Self.instances will return an array with each element being a hash
+  # containing the name, provider, path, and status of each service on the
+  # system.
+  def self.instances
+    jobs = self.jobsearch
+    @job_list ||= self.job_list
+    jobs.keys.collect do |job|
+      job_status = @job_list.has_key?(job) ? :running : :stopped
+      new(:name => job, :provider => :launchd, :path => jobs[job], :status => job_status)
+    end
+  end
+
+  # Sets a class instance variable with a hash of all launchd plist files that
+  # are found on the system. The key of the hash is the job id and the value
+  # is the path to the file. If a label is passed, we return the job id and
+  # path for that specific job.
+  def self.jobsearch(label=nil)
+    @label_to_path_map ||= {}
+    if @label_to_path_map.empty?
+      Launchd_Paths.each do |path|
+        Dir.glob(File.join(path,'*')).each do |filepath|
+          next if ! File.file?(filepath)
+          job = read_plist(filepath)
+          if job.has_key?("Label") and job["Label"] == label
+            return { label => filepath }
+          else
+            @label_to_path_map[job["Label"]] = filepath
+          end
+        end
+      end
+    end
+
+    if label
+      if @label_to_path_map.has_key? label
+        return { label => @label_to_path_map[label] }
+      else
+        raise Puppet::Error.new("Unable to find launchd plist for job: #{label}")
+      end
+    else
+      @label_to_path_map
+    end
+  end
+
+  # This status method lists out all currently running services.
+  # This hash is returned at the end of the method.
+  def self.job_list
+    @job_list = Hash.new
+    begin
+      output = launchctl :list
+      raise Puppet::Error.new("launchctl list failed to return any data.") if output.nil?
+      output.split("\n").each do |line|
+        @job_list[line.split(/\s/).last] = :running
+      end
+    rescue Puppet::ExecutionFailure
+      raise Puppet::Error.new("Unable to determine status of #{resource[:name]}")
+    end
+    @job_list
+  end
+
+  # Launchd implemented plist overrides in version 10.6.
+  # This method checks the major_version of OS X and returns true if 
+  # it is 10.6 or greater. This allows us to implement different plist
+  # behavior for versions >= 10.6
+  def has_macosx_plist_overrides?
+    @product_version ||= self.class.get_macosx_version_major
+    return true unless /^10\.[0-5]/.match(@product_version)
+    return false
+  end
+
+  # Read a plist, whether its format is XML or in Apple's "binary1"
+  # format.
+  def self.read_plist(path)
+    Plist::parse_xml(plutil('-convert', 'xml1', '-o', '/dev/stdout', path))
+  end
+
+  # Clean out the @property_hash variable containing the cached list of services
+  def flush
+    @property_hash.clear
+  end
+
+  def exists?
+    Puppet.debug("Puppet::Provider::Launchd:Ensure for #{@property_hash[:name]}: #{@property_hash[:ensure]}")
+    @property_hash[:ensure] != :absent
+  end
+
+  def self.get_macosx_version_major
+    return @macosx_version_major if @macosx_version_major
+    begin
+      # Make sure we've loaded all of the facts
+      Facter.loadfacts
+      if Facter.value(:macosx_productversion_major)
+        product_version_major = Facter.value(:macosx_productversion_major)
+      else
+        # TODO: remove this code chunk once we require Facter 1.5.5 or higher.
+        warnonce("DEPRECATION WARNING: Future versions of the launchd provider will require Facter 1.5.5 or newer.")
+        product_version = Facter.value(:macosx_productversion)
+        fail("Could not determine OS X version from Facter") if product_version.nil?
+        product_version_major = product_version.scan(/(\d+)\.(\d+)./).join(".")
+      end
+      fail("#{product_version_major} is not supported by the launchd provider") if %w{10.0 10.1 10.2 10.3}.include?(product_version_major)
+      @macosx_version_major = product_version_major
+      return @macosx_version_major
+    rescue Puppet::ExecutionFailure => detail
+      fail("Could not determine OS X version: #{detail}")
+    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]
+    if FileTest.file?(job_path)
+      job_plist = self.class.read_plist(job_path)
+    else
+      raise Puppet::Error.new("Unable to parse launchd plist at path: #{job_path}")
+    end
+    [job_path, job_plist]
+  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
+    return ucommand(:start) if resource[:start]
+    job_path, job_plist = plist_from_label(resource[:name])
+    did_enable_job = false
+    cmds = []
+    cmds << :launchctl << :load
+    if self.enabled? == :false  || self.status == :stopped # 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: #{resource[:name]} at path: #{job_path}")
+    end
+    # As load -w clears the Disabled flag, we need to add it in after
+    self.disable if did_enable_job and resource[:enable] == :false
+  end
+
+
+  def stop
+    return ucommand(:stop) if resource[: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: #{resource[:name]} at path: #{job_path}")
+    end
+    # As unload -w sets the Disabled flag, we need to add it in after
+    self.enable if did_disable_job and resource[:enable] == :true
+  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.
+  # Starting in 10.6, the Disabled key in the job plist is consulted, but only 
+  # if there is no entry in the global overrides plist.
+  # We need to draw a distinction between undefined, true and false for both
+  # locations where the Disabled flag can be defined.
+  def enabled?
+    job_plist_disabled = nil
+    overrides_disabled = nil
+
+    job_path, job_plist = plist_from_label(resource[:name])
+    job_plist_disabled = job_plist["Disabled"] if job_plist.has_key?("Disabled")
+
+    if has_macosx_plist_overrides?
+      if FileTest.file?(Launchd_Overrides) and overrides = self.class.read_plist(Launchd_Overrides)
+        if overrides.has_key?(resource[:name])
+          overrides_disabled = overrides[resource[:name]]["Disabled"] if overrides[resource[:name]].has_key?("Disabled")
+        end
+      end
+    end
+
+    if overrides_disabled.nil?
+      if job_plist_disabled.nil? or job_plist_disabled == false
+        return :true
+      end
+    elsif overrides_disabled == false
+      return :true
+    end
+    :false
+  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.
+  # Starting in 10.6 we need to write out a disabled key to the global 
+  # overrides plist, in earlier versions this is stored in the job plist itself.
+  def enable
+    if has_macosx_plist_overrides?
+      overrides = self.class.read_plist(Launchd_Overrides)
+      overrides[resource[:name]] = { "Disabled" => false }
+      Plist::Emit.save_plist(overrides, Launchd_Overrides)
+    else
+      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
+  end
+
+
+  def disable
+    if has_macosx_plist_overrides?
+      overrides = self.class.read_plist(Launchd_Overrides)
+      overrides[resource[:name]] = { "Disabled" => true }
+      Plist::Emit.save_plist(overrides, Launchd_Overrides)
+    else
+      job_path, job_plist = plist_from_label(resource[:name])
+      job_plist["Disabled"] = true
+      Plist::Emit.save_plist(job_plist, job_path)
+    end
+  end
+
+
+end

data/lib/vendor/puppet/provider/service/openrc.rb

@@ -0,0 +1,69 @@
+# Gentoo OpenRC
+Puppet::Type.type(:service).provide :openrc, :parent => :base do
+  desc <<-EOT
+    Support for Gentoo's OpenRC initskripts
+
+    Uses rc-update, rc-status and rc-service to manage services.
+
+  EOT
+
+  defaultfor :operatingsystem => :gentoo
+  defaultfor :operatingsystem => :funtoo
+
+  commands :rcservice => '/sbin/rc-service'
+  commands :rcstatus  => '/bin/rc-status'
+  commands :rcupdate  => '/sbin/rc-update'
+
+  self::STATUSLINE = /^\s+(.*?)\s*\[\s*(.*)\s*\]$/
+
+  def enable
+    rcupdate('-C', :add, @resource[:name])
+  end
+
+  def disable
+    rcupdate('-C', :del, @resource[:name])
+  end
+
+  # rc-status -a shows all runlevels and dynamic runlevels which
+  # are not considered as enabled. We have to find out under which
+  # runlevel our service is listed
+  def enabled?
+    enabled = :false
+    rcstatus('-C', '-a').each_line do |line|
+      case line.chomp
+      when /^Runlevel: /
+        enabled = :true
+      when /^\S+/ # caption of a dynamic runlevel
+        enabled = :false
+      when self.class::STATUSLINE
+        return enabled if @resource[:name] == $1
+      end
+    end
+    :false
+  end
+
+  def self.instances
+    instances = []
+    rcservice('-C', '--list').each_line do |line|
+      instances << new(:name => line.chomp)
+    end
+    instances
+  end
+
+  def restartcmd
+    (@resource[:hasrestart] == :true) && [command(:rcservice), @resource[:name], :restart]
+  end
+
+  def startcmd
+    [command(:rcservice), @resource[:name], :start ]
+  end
+
+  def stopcmd
+    [command(:rcservice), @resource[:name], :stop]
+  end
+
+  def statuscmd
+    ((@resource.provider.get(:hasstatus) == true) || (@resource[:hasstatus] == :true)) && [command(:rcservice), @resource[:name], :status]
+  end
+
+end

data/lib/vendor/puppet/provider/service/redhat.rb

@@ -0,0 +1,76 @@
+# Manage Red Hat services.  Start/stop uses /sbin/service and enable/disable uses chkconfig
+
+Puppet::Type.type(:service).provide :redhat, :parent => :init, :source => :init do
+  desc "Red Hat's (and probably many others') form of `init`-style service
+    management. Uses `chkconfig` for service enabling and disabling.
+
+  "
+
+  commands :chkconfig => "/sbin/chkconfig", :service => "/sbin/service"
+
+  defaultfor :operatingsystem => [:redhat, :fedora, :suse, :centos, :sles, :oel, :ovm]
+
+  def self.instances
+    # this exclude list is all from /sbin/service (5.x), but I did not exclude kudzu
+    self.get_services(['/etc/init.d'], ['functions', 'halt', 'killall', 'single', 'linuxconf', 'reboot', 'boot'])
+  end
+
+  def self.defpath
+    superclass.defpath
+  end
+
+  # Remove the symlinks
+  def disable
+    # The off method operates on run levels 2,3,4 and 5 by default We ensure
+    # all run levels are turned off because the reset method may turn on the
+    # service in run levels 0, 1 and/or 6
+    output = chkconfig("--level", "0123456", @resource[:name], :off)
+  rescue Puppet::ExecutionFailure
+    raise Puppet::Error, "Could not disable #{self.name}: #{output}"
+  end
+
+  def enabled?
+    begin
+      output = chkconfig(@resource[:name])
+    rescue Puppet::ExecutionFailure
+      return :false
+    end
+
+    # If it's disabled on SuSE, then it will print output showing "off"
+    # at the end
+    if output =~ /.* off$/
+      return :false
+    end
+
+    :true
+  end
+
+  # Don't support them specifying runlevels; always use the runlevels
+  # in the init scripts.
+  def enable
+      output = chkconfig(@resource[:name], :on)
+  rescue Puppet::ExecutionFailure => detail
+    raise Puppet::Error, "Could not enable #{self.name}: #{detail}"
+  end
+
+  def initscript
+    raise Puppet::Error, "Do not directly call the init script for '#{@resource[:name]}'; use 'service' instead"
+  end
+
+  # use hasstatus=>true when its set for the provider.
+  def statuscmd
+    ((@resource.provider.get(:hasstatus) == true) || (@resource[:hasstatus] == :true)) && [command(:service), @resource[:name], "status"]
+  end
+
+  def restartcmd
+    (@resource[:hasrestart] == :true) && [command(:service), @resource[:name], "restart"]
+  end
+
+  def startcmd
+    [command(:service), @resource[:name], "start"]
+  end
+
+  def stopcmd
+    [command(:service), @resource[:name], "stop"]
+  end
+end