puppet-retrospec 1.5.0 → 1.6.0

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

@@ -0,0 +1,74 @@
+# 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 <<-EOT
+    Debian's form of `init`-style management.
+
+    The only differences from `init` are support for enabling and disabling
+    services via `update-rc.d` and the ability to determine enabled status via
+    `invoke-rc.d`.
+
+  EOT
+
+  commands :update_rc => "/usr/sbin/update-rc.d"
+  # note this isn't being used as a command until
+  # https://projects.puppetlabs.com/issues/2538
+  # is resolved.
+  commands :invoke_rc => "/usr/sbin/invoke-rc.d"
+  commands :service => "/usr/sbin/service"
+
+  defaultfor :operatingsystem => :cumuluslinux, :operatingsystemmajrelease => ['1','2']
+  defaultfor :operatingsystem => :debian, :operatingsystemmajrelease => ['5','6','7']
+
+  # Remove the symlinks
+  def disable
+    if `dpkg --compare-versions $(dpkg-query -W --showformat '${Version}' sysv-rc) ge 2.88 ; echo $?`.to_i == 0
+      update_rc @resource[:name], "disable"
+    else
+      update_rc "-f", @resource[:name], "remove"
+      update_rc @resource[:name], "stop", "00", "1", "2", "3", "4", "5", "6", "."
+    end
+  end
+
+  def enabled?
+    # TODO: Replace system call when Puppet::Util::Execution.execute gives us a way
+    # to determine exit status.  https://projects.puppetlabs.com/issues/2538
+    system("/usr/sbin/invoke-rc.d", "--quiet", "--query", @resource[:name], "start")
+
+    # 104 is the exit status when you query start an enabled service.
+    # 106 is the exit status when the policy layer supplies a fallback action
+    # See x-man-page://invoke-rc.d
+    if [104, 106].include?($CHILD_STATUS.exitstatus)
+      return :true
+    elsif [101, 105].include?($CHILD_STATUS.exitstatus)
+      # 101 is action not allowed, which means we have to do the check manually.
+      # 105 is unknown, which generally means the initscript does not support query
+      # The debian policy states that the initscript should support methods of query
+      # For those that do not, perform the checks manually
+      # http://www.debian.org/doc/debian-policy/ch-opersys.html
+      if get_start_link_count >= 4
+        return :true
+      else
+        return :false
+      end
+    else
+      return :false
+    end
+  end
+
+  def get_start_link_count
+    Dir.glob("/etc/rc*.d/S??#{@resource[:name]}").length
+  end
+
+  def enable
+    update_rc "-f", @resource[:name], "remove"
+    update_rc @resource[:name], "defaults"
+  end
+
+  def statuscmd
+      # /usr/sbin/service provides an abstraction layer which is able to query services
+      # independent of the init system used.
+      # See https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=775795
+    (@resource[:hasstatus] == :true) && [command(:service), @resource[:name], "status"]
+  end
+end

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

@@ -0,0 +1,193 @@
+# 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", "DragonFly"
+      ["/etc/rc.d", "/usr/local/etc/rc.d"]
+    when "HP-UX"
+      "/sbin/init.d"
+    when "Archlinux"
+      "/etc/rc.d"
+    when "AIX"
+      "/etc/rc.d/init.d"
+    else
+      "/etc/init.d"
+    end
+  end
+
+  # Debian and Ubuntu should use the Debian provider.
+  # RedHat systems should use the RedHat provider.
+  confine :true => begin
+      os = Facter.value(:operatingsystem).downcase
+      family = Facter.value(:osfamily).downcase
+      !(os == 'debian' || os == 'ubuntu' || family == 'redhat')
+  end
+
+  # We can't confine this here, because the init path can be overridden.
+  #confine :exists => defpath
+
+  # some init scripts are not safe to execute, e.g. we do not want
+  # to suddenly run /etc/init.d/reboot.sh status and reboot our system. The
+  # exclude list could be platform agnostic but I assume an invalid init script
+  # on system A will never be a valid init script on system B
+  def self.excludes
+    excludes = []
+    # these exclude list was found with grep -L '\/sbin\/runscript' /etc/init.d/* on gentoo
+    excludes += %w{functions.sh reboot.sh shutdown.sh}
+    # this exclude list is all from /sbin/service (5.x), but I did not exclude kudzu
+    excludes += %w{functions halt killall single linuxconf reboot boot}
+    # 'wait-for-state' and 'portmap-wait' are excluded from instances here
+    # because they take parameters that have unclear meaning. It looks like
+    # 'wait-for-state' is a generic waiter mainly used internally for other
+    # upstart services as a 'sleep until something happens'
+    # (http://lists.debian.org/debian-devel/2012/02/msg01139.html), while
+    # 'portmap-wait' is a specific instance of a waiter. There is an open
+    # launchpad bug
+    # (https://bugs.launchpad.net/ubuntu/+source/upstart/+bug/962047) that may
+    # eventually explain how to use the wait-for-state service or perhaps why
+    # it should remain excluded. When that bug is addressed this should be
+    # reexamined.
+    excludes += %w{wait-for-state portmap-wait}
+    # these excludes were found with grep -r -L start /etc/init.d
+    excludes += %w{rcS module-init-tools}
+    # Prevent puppet failing on unsafe scripts from Yocto Linux
+    if Facter.value(:osfamily) == "cisco-wrlinux"
+      excludes += %w{banner.sh bootmisc.sh checkroot.sh devpts.sh dmesg.sh
+                   hostname.sh mountall.sh mountnfs.sh populate-volatile.sh
+                   rmnologin.sh save-rtc.sh sendsigs sysfs.sh umountfs
+                   umountnfs.sh}
+    end
+    # Prevent puppet failing to get status of the new service introduced
+    # by the fix for this (bug https://bugs.launchpad.net/ubuntu/+source/lightdm/+bug/982889)
+    # due to puppet's inability to deal with upstart services with instances.
+    excludes += %w{plymouth-ready}
+    # Prevent puppet failing to get status of these services, which need parameters
+    # passed in (see https://bugs.launchpad.net/ubuntu/+source/puppet/+bug/1276766).
+    excludes += %w{idmapd-mounting startpar-bridge}
+    # Prevent puppet failing to get status of these services, additional upstart
+    # service with instances
+    excludes += %w{cryptdisks-udev}
+    excludes += %w{statd-mounting}
+    excludes += %w{gssd-mounting}
+  end
+
+  # List all services of this type.
+  def self.instances
+    get_services(self.defpath)
+  end
+
+  def self.get_services(defpath, exclude = self.excludes)
+    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 Puppet::FileSystem.exist?(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 do |path|
+      fqname = File.join(path,name)
+      if Puppet::FileSystem.exist? fqname
+        return fqname
+      else
+        self.debug("Could not find #{name} in #{path}")
+      end
+    end
+
+    paths.each do |path|
+      fqname_sh = File.join(path,"#{name}.sh")
+      if Puppet::FileSystem.exist? fqname_sh
+        return fqname_sh
+      else
+        self.debug("Could not find #{name}.sh in #{path}")
+      end
+    end
+    raise Puppet::Error, "Could not find init script for '#{name}'"
+  end
+
+  # The start command is just the init script with '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
+
+  def texecute(type, command, fof = true, squelch = false, combine = true)
+    if type == :start && Facter.value(:osfamily) == "Solaris"
+        command =  ["/usr/bin/ctrun -l none", command].flatten.join(" ")
+    end
+    super(type, command, fof, squelch, combine)
+  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 = Puppet::FileSystem.pathname(script)
+    !Puppet::FileSystem.symlink?(file) || Puppet::FileSystem.readlink(file) != "/lib/init/upstart-job"
+  end
+end
+

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

@@ -0,0 +1,346 @@
+require 'puppet/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:
+
+    * <https://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'
+
+  EOT
+
+  include Puppet::Util::Warnings
+
+  commands :launchctl => "/bin/launchctl"
+
+  defaultfor :operatingsystem => :darwin
+  confine :operatingsystem    => :darwin
+  confine :feature            => :cfpropertylist
+
+  has_feature :enableable
+  has_feature :refreshable
+  mk_resource_methods
+
+  # These are the paths in OS X where a launchd service plist could
+  # exist. This is a helper method, versus a constant, for easy testing
+  # and mocking
+  #
+  # @api private
+  def self.launchd_paths
+    [
+      "/Library/LaunchAgents",
+      "/Library/LaunchDaemons",
+      "/System/Library/LaunchAgents",
+      "/System/Library/LaunchDaemons"
+    ]
+  end
+
+  # Gets the current Darwin version, example 10.6 returns 9 and 10.10 returns 14
+  # See https://en.wikipedia.org/wiki/Darwin_(operating_system)#Release_history
+  # for more information.
+  #
+  # @api private
+  def self.get_os_version
+    @os_version ||= Facter.value(:operatingsystemmajrelease).to_i
+  end
+
+  # Defines the path to the overrides plist file where service enabling
+  # behavior is defined in 10.6 and greater.
+  #
+  # With the rewrite of launchd in 10.10+, this moves and slightly changes format.
+  #
+  # @api private
+  def self.launchd_overrides
+    if self.get_os_version < 14
+      "/var/db/launchd.db/com.apple.launchd/overrides.plist"
+    else
+      "/var/db/com.apple.xpc.launchd/disabled.plist"
+    end
+  end
+
+  # 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
+
+  # This method will return a list of files in the passed directory. This method
+  # does not go recursively down the tree and does not return directories
+  #
+  # @param path [String] The directory to glob
+  #
+  # @api private
+  #
+  # @return [Array] of String instances modeling file paths
+  def self.return_globbed_list_of_file_paths(path)
+    array_of_files = Dir.glob(File.join(path, '*')).collect do |filepath|
+      File.file?(filepath) ? filepath : nil
+    end
+    array_of_files.compact
+  end
+
+  # Get a hash of all launchd plists, keyed by label.  This value is cached, but
+  # the cache will be refreshed if refresh is true.
+  #
+  # @api private
+  def self.make_label_to_path_map(refresh=false)
+    return @label_to_path_map if @label_to_path_map and not refresh
+    @label_to_path_map = {}
+    launchd_paths.each do |path|
+      return_globbed_list_of_file_paths(path).each do |filepath|
+        Puppet.debug("Reading launchd plist #{filepath}")
+        job = read_plist(filepath)
+        next if job.nil?
+        if job.has_key?("Label")
+          @label_to_path_map[job["Label"]] = filepath
+        else
+          Puppet.warning("The #{filepath} plist does not contain a 'label' key; " +
+                       "Puppet is skipping it")
+          next
+        end
+      end
+    end
+    @label_to_path_map
+  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)
+    by_label = make_label_to_path_map
+
+    if label
+      if by_label.has_key? label
+        return { label => by_label[label] }
+      else
+        # try refreshing the map, in case a plist has been added in the interim
+        by_label = make_label_to_path_map(true)
+        if by_label.has_key? label
+          return { label => by_label[label] }
+        else
+          raise Puppet::Error, "Unable to find launchd plist for job: #{label}"
+        end
+      end
+    else
+      # caller wants the whole map
+      by_label
+    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
+
+  # Read a plist, whether its format is XML or in Apple's "binary1"
+  # format.
+  def self.read_plist(path)
+    Puppet::Util::Plist.read_plist_file(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
+
+  # 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
+
+  # when a service includes hasstatus=>false, we override the launchctl
+  # status mechanism and fall back to the base provider status method.
+  def status
+    if @resource && ((@resource[:hasstatus] == :false) || (@resource[:status]))
+      return super
+    else
+      if @property_hash[:status].nil?
+        :absent
+      else
+        @property_hash[:status]
+      end
+    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
+    return ucommand(:start) if resource[:start]
+    job_path, job_plist = plist_from_label(resource[:name])
+    did_enable_job = false
+    cmds = []
+    cmds << :launchctl << :load
+    # always add -w so it always starts the job, it is a noop if it is not needed, this means we do
+    # not have to rescan all launchd plists.
+    cmds << "-w"
+    if self.enabled? == :false  || self.status == :stopped # launchctl won't load disabled jobs
+      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
+
+  def restart
+    Puppet.debug("A restart has been triggered for the #{resource[:name]} service")
+    Puppet.debug("Stopping the #{resource[:name]} service")
+    self.stop
+    Puppet.debug("Starting the #{resource[:name]} service")
+    self.start
+  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 FileTest.file?(self.class.launchd_overrides) and overrides = self.class.read_plist(self.class.launchd_overrides)
+      if overrides.has_key?(resource[:name])
+        if self.class.get_os_version < 14
+          overrides_disabled = overrides[resource[:name]]["Disabled"] if overrides[resource[:name]].has_key?("Disabled")
+        else
+          overrides_disabled = overrides[resource[:name]]
+        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.
+  def enable
+    overrides = self.class.read_plist(self.class.launchd_overrides)
+    if self.class.get_os_version < 14
+      overrides[resource[:name]] = { "Disabled" => false }
+    else
+      overrides[resource[:name]] = false
+    end
+    Puppet::Util::Plist.write_plist_file(overrides, self.class.launchd_overrides)
+  end
+
+  def disable
+    overrides = self.class.read_plist(self.class.launchd_overrides)
+    if self.class.get_os_version < 14
+      overrides[resource[:name]] = { "Disabled" => true }
+    else
+      overrides[resource[:name]] = true
+    end
+    Puppet::Util::Plist.write_plist_file(overrides, self.class.launchd_overrides)
+  end
+end