librarian-puppet 0.9.9 → 0.9.10

data/vendor/gems/ruby/1.9.1/gems/puppet-3.1.0/lib/puppet/provider/selboolean/getsetsebool.rb

@@ -1,47 +0,0 @@
-Puppet::Type.type(:selboolean).provide(:getsetsebool) do
-  desc "Manage SELinux booleans using the getsebool and setsebool binaries."
-
-  commands :getsebool => "/usr/sbin/getsebool"
-  commands :setsebool => "/usr/sbin/setsebool"
-
-  def value
-    self.debug "Retrieving value of selboolean #{@resource[:name]}"
-
-    status = getsebool(@resource[:name])
-
-    if status =~ / off$/
-      return :off
-    elsif status =~ / on$/ then
-      return :on
-    else
-      status.chomp!
-      raise Puppet::Error, "Invalid response '#{status}' returned from getsebool"
-    end
-  end
-
-  def value=(new)
-    persist = ""
-    if @resource[:persistent] == :true
-      self.debug "Enabling persistence"
-      persist = "-P"
-    end
-    execoutput("#{command(:setsebool)} #{persist} #{@resource[:name]} #{new}")
-    :file_changed
-  end
-
-  # Required workaround, since SELinux policy prevents setsebool
-  # from writing to any files, even tmp, preventing the standard
-  # 'setsebool("...")' construct from working.
-
-  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
-end

data/vendor/gems/ruby/1.9.1/gems/puppet-3.1.0/lib/puppet/provider/selmodule/semodule.rb

@@ -1,134 +0,0 @@
-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/vendor/gems/ruby/1.9.1/gems/puppet-3.1.0/lib/puppet/provider/service/base.rb

@@ -1,106 +0,0 @@
-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)
-          self.debug "Process matched: #{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/vendor/gems/ruby/1.9.1/gems/puppet-3.1.0/lib/puppet/provider/service/bsd.rb

@@ -1,51 +0,0 @@
-# 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, :dragonfly]
-
-  def rcconf_dir
-    '/etc/rc.conf.d'
-  end
-
-  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/vendor/gems/ruby/1.9.1/gems/puppet-3.1.0/lib/puppet/provider/service/daemontools.rb

@@ -1,194 +0,0 @@
-# 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