puppet-parse 0.0.1 → 0.0.2

data/lib/vendor/puppet/provider/selmodule/semodule.rb

@@ -0,0 +1,134 @@
+Puppet::Type.type(:selmodule).provide(:semodule) do
+  desc "Manage SELinux policy modules using the semodule binary."
+
+  commands :semodule => "/usr/sbin/semodule"
+
+  def create
+    begin
+      execoutput("#{command(:semodule)} --install #{selmod_name_to_filename}")
+    rescue Puppet::ExecutionFailure => detail
+      raise Puppet::Error, "Could not load policy module: #{detail}";
+    end
+    :true
+  end
+
+  def destroy
+      execoutput("#{command(:semodule)} --remove #{@resource[:name]}")
+  rescue Puppet::ExecutionFailure => detail
+      raise Puppet::Error, "Could not remove policy module: #{detail}";
+  end
+
+  def exists?
+    self.debug "Checking for module #{@resource[:name]}"
+    execpipe("#{command(:semodule)} --list") do |out|
+      out.each_line do |line|
+        if line =~ /#{@resource[:name]}\b/
+          return :true
+        end
+      end
+    end
+    nil
+  end
+
+  def syncversion
+    self.debug "Checking syncversion on #{@resource[:name]}"
+
+    loadver = selmodversion_loaded
+
+    if(loadver) then
+      filever = selmodversion_file
+      if (filever == loadver)
+        return :true
+      end
+    end
+    :false
+  end
+
+  def syncversion= (dosync)
+      execoutput("#{command(:semodule)} --upgrade #{selmod_name_to_filename}")
+  rescue Puppet::ExecutionFailure => detail
+      raise Puppet::Error, "Could not upgrade policy module: #{detail}";
+  end
+
+  # Helper functions
+
+  def execoutput (cmd)
+    output = ''
+    begin
+      execpipe(cmd) do |out|
+        output = out.readlines.join('').chomp!
+      end
+    rescue Puppet::ExecutionFailure
+      raise Puppet::ExecutionFailure, output.split("\n")[0]
+    end
+    output
+  end
+
+  def selmod_name_to_filename
+    if @resource[:selmodulepath]
+      return @resource[:selmodulepath]
+    else
+      return "#{@resource[:selmoduledir]}/#{@resource[:name]}.pp"
+    end
+  end
+
+  def selmod_readnext (handle)
+    len = handle.read(4).unpack('L')[0]
+    handle.read(len)
+  end
+
+  def selmodversion_file
+    magic = 0xF97CFF8F
+
+    filename = selmod_name_to_filename
+    mod = File.new(filename, "r")
+
+    (hdr, ver, numsec) = mod.read(12).unpack('LLL')
+
+    raise Puppet::Error, "Found #{hdr} instead of magic #{magic} in #{filename}" if hdr != magic
+
+    raise Puppet::Error, "Unknown policy file version #{ver} in #{filename}" if ver != 1
+
+    # Read through (and throw away) the file section offsets, and also
+    # the magic header for the first section.
+
+    mod.read((numsec + 1) * 4)
+
+    ## Section 1 should be "SE Linux Module"
+
+    selmod_readnext(mod)
+    selmod_readnext(mod)
+
+    # Skip past the section headers
+    mod.read(14)
+
+    # Module name
+    selmod_readnext(mod)
+
+    # At last!  the version
+
+    v = selmod_readnext(mod)
+
+    self.debug "file version #{v}"
+    v
+  end
+
+  def selmodversion_loaded
+    lines = ()
+    begin
+      execpipe("#{command(:semodule)} --list") do |output|
+        output.each_line do |line|
+          line.chomp!
+          bits = line.split
+          if bits[0] == @resource[:name]
+            self.debug "load version #{bits[1]}"
+            return bits[1]
+          end
+        end
+      end
+    rescue Puppet::ExecutionFailure
+      raise Puppet::ExecutionFailure, "Could not list policy modules: #{lines.join(' ').chomp!}"
+    end
+    nil
+  end
+end

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

@@ -0,0 +1,105 @@
+Puppet::Type.type(:service).provide :base, :parent => :service do
+  desc "The simplest form of Unix 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.  As with `init`-style services, it is preferable to specify start,
+  stop, and status commands.
+
+  "
+
+  commands :kill => "kill"
+
+  # Get the process ID for a running process. Requires the 'pattern'
+  # parameter.
+  def getpid
+    @resource.fail "Either stop/status commands or a pattern must be specified" unless @resource[:pattern]
+    ps = Facter["ps"].value
+    @resource.fail "You must upgrade Facter to a version that includes 'ps'" unless ps and ps != ""
+    regex = Regexp.new(@resource[:pattern])
+    self.debug "Executing '#{ps}'"
+    IO.popen(ps) { |table|
+      table.each_line { |line|
+        if regex.match(line)
+          ary = line.sub(/^\s+/, '').split(/\s+/)
+          return ary[1]
+        end
+      }
+    }
+
+    nil
+  end
+
+  # Check if the process is running.  Prefer the 'status' parameter,
+  # then 'statuscmd' method, then look in the process table.  We give
+  # the object the option to not return a status command, which might
+  # happen if, for instance, it has an init script (and thus responds to
+  # 'statuscmd') but does not have 'hasstatus' enabled.
+  def status
+    if @resource[:status] or statuscmd
+      # Don't fail when the exit status is not 0.
+      ucommand(:status, false)
+
+      # Expicitly calling exitstatus to facilitate testing
+      if $CHILD_STATUS.exitstatus == 0
+        return :running
+      else
+        return :stopped
+      end
+    elsif pid = self.getpid
+      self.debug "PID is #{pid}"
+      return :running
+    else
+      return :stopped
+    end
+  end
+
+  # There is no default command, which causes other methods to be used
+  def statuscmd
+  end
+
+  # Run the 'start' parameter command, or the specified 'startcmd'.
+  def start
+    ucommand(:start)
+  end
+
+  # The command used to start.  Generated if the 'binary' argument
+  # is passed.
+  def startcmd
+    if @resource[:binary]
+      return @resource[:binary]
+    else
+      raise Puppet::Error,
+        "Services must specify a start command or a binary"
+    end
+  end
+
+  # Stop the service.  If a 'stop' parameter is specified, it
+  # takes precedence; otherwise checks if the object responds to
+  # a 'stopcmd' method, and if so runs that; otherwise, looks
+  # for the process in the process table.
+  # This method will generally not be overridden by submodules.
+  def stop
+    if @resource[:stop] or stopcmd
+      ucommand(:stop)
+    else
+      pid = getpid
+      unless pid
+        self.info "#{self.name} is not running"
+        return false
+      end
+      begin
+        output = kill pid
+      rescue Puppet::ExecutionFailure => detail
+        @resource.fail "Could not kill #{self.name}, PID #{pid}: #{output}"
+      end
+      return true
+    end
+  end
+
+  # There is no default command, which causes other methods to be used
+  def stopcmd
+  end
+end
+

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

@@ -0,0 +1,49 @@
+# Manage FreeBSD services.
+Puppet::Type.type(:service).provide :bsd, :parent => :init do
+  desc <<-EOT
+    FreeBSD's (and probably NetBSD's?) form of `init`-style service management.
+
+    Uses `rc.conf.d` for service enabling and disabling.
+
+  EOT
+
+  confine :operatingsystem => [:freebsd, :netbsd, :openbsd]
+
+  @@rcconf_dir = '/etc/rc.conf.d'
+
+  def self.defpath
+    superclass.defpath
+  end
+
+  # remove service file from rc.conf.d to disable it
+  def disable
+    rcfile = File.join(@@rcconf_dir, @model[:name])
+    File.delete(rcfile) if File.exists?(rcfile)
+  end
+
+  # if the service file exists in rc.conf.d then it's already enabled
+  def enabled?
+    rcfile = File.join(@@rcconf_dir, @model[:name])
+    return :true if File.exists?(rcfile)
+
+    :false
+  end
+
+  # enable service by creating a service file under rc.conf.d with the
+  # proper contents
+  def enable
+    Dir.mkdir(@@rcconf_dir) if not File.exists?(@@rcconf_dir)
+    rcfile = File.join(@@rcconf_dir, @model[:name])
+    open(rcfile, 'w') { |f| f << "%s_enable=\"YES\"\n" % @model[:name] }
+  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]
+  end
+
+  def stopcmd
+    [self.initscript, :onestop]
+  end
+end

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

@@ -0,0 +1,194 @@
+# 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 overriden 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(dummy_argument=:work_arround_for_ruby_GC_bug)
+      unless @defpath
+        ["/var/lib/service", "/etc"].each do |path|
+          if FileTest.exist?(path)
+            @defpath = path
+            break
+          end
+        end
+        raise "Could not find the daemon directory (tested [/var/lib/service,/etc])" unless @defpath
+      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 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 ! FileTest.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 FileTest.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 overriden in the resource
+  # definition
+  def daemon
+    File.join(resource[: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}" )
+    end
+    :stopped
+  end
+
+  def setupservice
+      if resource[:manifest]
+        Puppet.notice "Configuring #{resource[:name]}"
+        command = [ resource[:manifest], resource[:name] ]
+        #texecute("setupservice", command)
+        rv = system("#{command}")
+      end
+  rescue Puppet::ExecutionFailure => detail
+      raise Puppet::Error.new( "Cannot config #{self.service} to enable it: #{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 FileTest.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 ! FileTest.symlink?(self.service)
+          Puppet.notice "Enabling #{self.service}: linking #{self.daemon} -> #{self.service}"
+          File.symlink(self.daemon, self.service)
+        end
+      end
+  rescue Puppet::ExecutionFailure => detail
+      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 FileTest.symlink?(self.service)
+          Puppet.notice "Disabling #{self.service}: removing link #{self.daemon} -> #{self.service}"
+          File.unlink(self.service)
+        end
+      end
+    rescue Puppet::ExecutionFailure => detail
+      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/vendor/puppet/provider/service/debian.rb

@@ -0,0 +1,68 @@
+# 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
+  # http://projects.reductivelabs.com/issues/2538
+  # is resolved.
+  commands :invoke_rc => "/usr/sbin/invoke-rc.d"
+
+  defaultfor :operatingsystem => [:debian, :ubuntu]
+
+  def self.defpath
+    superclass.defpath
+  end
+
+  # 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.execute gives us a way
+    # to determine exit status.  http://projects.reductivelabs.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 [105].include?($CHILD_STATUS.exitstatus)
+      # 105 is unknown, which generally means the the iniscript does not support query
+      # The debian policy states that the initscript should support methods of query
+      # For those that do not, peform 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
+end

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

@@ -0,0 +1,139 @@
+Puppet::Type.type(:service).provide :freebsd, :parent => :init do
+
+  desc "Provider for FreeBSD. Uses the `rcvar` argument of init scripts and parses/edits rc files."
+
+  confine :operatingsystem => [:freebsd]
+  defaultfor :operatingsystem => [:freebsd]
+
+  @@rcconf = '/etc/rc.conf'
+  @@rcconf_local = '/etc/rc.conf.local'
+  @@rcconf_dir = '/etc/rc.conf.d'
+
+  def self.defpath
+    superclass.defpath
+  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, :squelch => false)
+    rcvar = rcvar.split("\n")
+    rcvar.delete_if {|str| str =~ /^#\s*$/}
+    rcvar[1] = rcvar[1].gsub(/^\$/, '')
+    rcvar
+  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
+
+  # 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
+
+  # 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+)"?/, '\2')
+    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 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
+      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 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 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