openvox 7.37.1

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

@@ -0,0 +1,193 @@
+# Daemontools service management
+#
+# author Brice Figureau <brice-puppet@daysofwonder.com>
+Puppet::Type.type(:service).provide :daemontools, :parent => :base do
+  desc <<-'EOT'
+    Daemontools service management.
+
+    This provider manages daemons supervised by D.J. Bernstein daemontools.
+    When detecting the service directory it will check, in order of preference:
+
+    * `/service`
+    * `/etc/service`
+    * `/var/lib/svscan`
+
+    The daemon directory should be in one of the following locations:
+
+    * `/var/lib/service`
+    * `/etc`
+
+    ...or this can be overridden in the resource's attributes:
+
+        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
+
+    If a service has `ensure => "running"`, it will link /path/to/daemon to
+    /path/to/service, which will automatically enable the service.
+
+    If a service has `ensure => "stopped"`, it will only shut down the service, not
+    remove the `/path/to/service` link.
+
+  EOT
+
+  commands :svc  => "/usr/bin/svc", :svstat => "/usr/bin/svstat"
+
+  class << self
+    attr_writer :defpath
+
+    # Determine the daemon path.
+    def defpath
+      @defpath ||= ["/var/lib/service", "/etc"].find do |path|
+        Puppet::FileSystem.exist?(path) && FileTest.directory?(path)
+      end
+      @defpath
+    end
+  end
+
+  attr_writer :servicedir
+
+  # returns all providers for all existing services in @defpath
+  # ie enabled or not
+  def self.instances
+    path = self.defpath
+    unless path
+      Puppet.info("#{self.name} is unsuitable because service directory is nil")
+      return
+    end
+    unless FileTest.directory?(path)
+      Puppet.notice "Service path #{path} does not exist"
+      return
+    end
+
+    # reject entries that aren't either a directory
+    # or don't contain a run file
+    Dir.entries(path).reject { |e|
+      fullpath = File.join(path, e)
+      e =~ /^\./ or ! FileTest.directory?(fullpath) or ! Puppet::FileSystem.exist?(File.join(fullpath,"run"))
+    }.collect do |name|
+      new(:name => name, :path => path)
+    end
+  end
+
+  # returns the daemon dir on this node
+  def self.daemondir
+    self.defpath
+  end
+
+  # find the service dir on this node
+  def servicedir
+    unless @servicedir
+      ["/service", "/etc/service","/var/lib/svscan"].each do |path|
+        if Puppet::FileSystem.exist?(path)
+          @servicedir = path
+          break
+        end
+      end
+      raise "Could not find service directory" unless @servicedir
+    end
+    @servicedir
+  end
+
+  # returns the full path of this service when enabled
+  # (ie in the service directory)
+  def service
+    File.join(self.servicedir, resource[:name])
+  end
+
+  # returns the full path to the current daemon directory
+  # note that this path can be overridden in the resource
+  # definition
+  def daemon
+    path = resource[:path]
+    raise Puppet::Error.new("#{self.class.name} must specify a path for daemon directory") unless path
+    File.join(path, resource[:name])
+  end
+
+  def status
+    begin
+      output = svstat self.service
+      if output =~ /:\s+up \(/
+        return :running
+      end
+    rescue Puppet::ExecutionFailure => detail
+      raise Puppet::Error.new( "Could not get status for service #{resource.ref}: #{detail}", detail)
+    end
+    :stopped
+  end
+
+  def setupservice
+      if resource[:manifest]
+        Puppet.notice "Configuring #{resource[:name]}"
+        command = [ resource[:manifest], resource[:name] ]
+        system("#{command}")
+      end
+  rescue Puppet::ExecutionFailure => detail
+      raise Puppet::Error.new( "Cannot config #{self.service} to enable it: #{detail}", detail)
+  end
+
+  def enabled?
+    case self.status
+    when :running
+      # obviously if the daemon is running then it is enabled
+      return :true
+    else
+      # the service is enabled if it is linked
+      return Puppet::FileSystem.symlink?(self.service) ? :true : :false
+    end
+  end
+
+  def enable
+    if ! FileTest.directory?(self.daemon)
+      Puppet.notice "No daemon dir, calling setupservice for #{resource[:name]}"
+      self.setupservice
+    end
+    if self.daemon
+      if ! Puppet::FileSystem.symlink?(self.service)
+        Puppet.notice "Enabling #{self.service}: linking #{self.daemon} -> #{self.service}"
+        Puppet::FileSystem.symlink(self.daemon, self.service)
+      end
+    end
+rescue Puppet::ExecutionFailure
+    raise Puppet::Error.new( "No daemon directory found for #{self.service}", $!)
+  end
+
+  def disable
+    begin
+      if ! FileTest.directory?(self.daemon)
+        Puppet.notice "No daemon dir, calling setupservice for #{resource[:name]}"
+        self.setupservice
+      end
+      if self.daemon
+        if Puppet::FileSystem.symlink?(self.service)
+          Puppet.notice "Disabling #{self.service}: removing link #{self.daemon} -> #{self.service}"
+          Puppet::FileSystem.unlink(self.service)
+        end
+      end
+    rescue Puppet::ExecutionFailure
+      raise Puppet::Error.new( "No daemon directory found for #{self.service}", $!)
+    end
+    self.stop
+  end
+
+  def restart
+    svc "-t", self.service
+  end
+
+  def start
+    enable unless enabled? == :true
+    svc "-u", self.service
+  end
+
+  def stop
+    svc "-d", self.service
+  end
+end

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

@@ -0,0 +1,75 @@
+# 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"
+
+  confine :false => Puppet::FileSystem.exist?('/proc/1/comm') && Puppet::FileSystem.read('/proc/1/comm').include?('systemd')
+
+  defaultfor :operatingsystem => :cumuluslinux, :operatingsystemmajrelease => ['1','2']
+  defaultfor :operatingsystem => :debian, :operatingsystemmajrelease => ['5','6','7']
+  defaultfor :operatingsystem => :devuan
+
+  # 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?
+    status = execute(["/usr/sbin/invoke-rc.d", "--quiet", "--query", @resource[:name], "start"], :failonfail => false)
+
+    # 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?(status.exitstatus)
+      return :true
+    elsif [101, 105].include?(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/lib/puppet/provider/service/freebsd.rb

@@ -0,0 +1,143 @@
+Puppet::Type.type(:service).provide :freebsd, :parent => :init do
+
+  desc "Provider for FreeBSD and DragonFly BSD. Uses the `rcvar` argument of init scripts and parses/edits rc files."
+
+  confine :operatingsystem => [:freebsd, :dragonfly]
+  defaultfor :operatingsystem => [:freebsd, :dragonfly]
+
+  def rcconf()        '/etc/rc.conf' end
+  def rcconf_local()  '/etc/rc.conf.local' end
+  def rcconf_dir()    '/etc/rc.conf.d' end
+
+  def self.defpath
+    superclass.defpath
+  end
+
+  def error(msg)
+    raise Puppet::Error, msg
+  end
+
+  # 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, :combine => false, :squelch => false)
+    rcvar = rcvar.split("\n")
+    rcvar.delete_if {|str| str =~ /^#\s*$/}
+    rcvar[1] = rcvar[1].gsub(/^\$/, '')
+    rcvar
+  end
+
+  # Extract value name from service or rcvar
+  def extract_value_name(name, rc_index, regex, regex_index)
+    value_name = self.rcvar[rc_index]
+    self.error("No #{name} name found in rcvar") if value_name.nil?
+    value_name = value_name.gsub!(regex, regex_index)
+    self.error("#{name} name is empty") if value_name.nil?
+    self.debug("#{name} name is #{value_name}")
+    value_name
+  end
+
+  # Extract service name
+  def service_name
+    extract_value_name('service', 0, /# (\S+).*/, '\1')
+  end
+
+  # Extract rcvar name
+  def rcvar_name
+    extract_value_name('rcvar', 1, /(.*?)(_enable)?=(.*)/, '\1')
+  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)?="?(\w+)"?/, '\3')
+    self.error("rcvar value is empty") if value.nil?
+    self.debug("rcvar value is #{value}")
+    value
+  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
+
+  # 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 Puppet::FileSystem.exist?(filename)
+        s = File.read(filename)
+        if s.gsub!(/^(#{rcvar}(_enable)?)=\"?(YES|NO)\"?/, "\\1=\"#{yesno}\"")
+          Puppet::FileSystem.replace_file(filename) { |f| f << s  }
+          self.debug("Replaced in #{filename}")
+          success = true
+        end
+      end
+    end
+    success
+  end
+
+  # Add a new setting to the rc files
+  def rc_add(service, rcvar, yesno)
+    append = "\# Added by Puppet\n#{rcvar}_enable=\"#{yesno}\"\n"
+    # First, try the one-file-per-service style
+    if Puppet::FileSystem.exist?(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 Puppet::FileSystem.exist?(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 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

@@ -0,0 +1,45 @@
+# 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 disable
+      output = update :del, @resource[:name], :default
+  rescue Puppet::ExecutionFailure
+      raise Puppet::Error, "Could not disable #{self.name}: #{output}", $!.backtrace
+  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}", $!.backtrace
+  end
+end

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

@@ -0,0 +1,192 @@
+# 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 Puppet.runtime[: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.
+  confine :false => ['Debian', 'Ubuntu'].include?(Puppet.runtime[:facter].value('operatingsystem'))
+  # RedHat systems should use the RedHat provider.
+  confine :false => Puppet.runtime[:facter].value('osfamily') == 'RedHat'
+
+  # 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 Puppet.runtime[: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}
+    excludes
+  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 Puppet::FileSystem.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 Puppet::FileSystem.directory?(fullpath)
+        next unless Puppet::FileSystem.executable?(fullpath)
+        next unless 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 Puppet::FileSystem.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 service_execute(type, command, fof = true, squelch = false, combine = true)
+    if type == :start && Puppet.runtime[:facter].value(:osfamily) == "Solaris"
+        command =  ["/usr/bin/ctrun -l child", 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
+