RubyGems - bolt - Versions diffs - 0.19.1 → 0.20.0 - Mend

bolt 0.19.1 → 0.20.0

Potentially problematic release.

This version of bolt might be problematic. Click here for more details.

Files changed (1261) hide show

data/vendored/puppet/lib/puppet/provider/selboolean/getsetsebool.rb DELETED

@@ -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], $!.backtrace
-    end
-    output
-  end
-end

data/vendored/puppet/lib/puppet/provider/selmodule/semodule.rb DELETED

@@ -1,140 +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}", detail.backtrace
-    end
-    :true
-  end
-  def destroy
-      execoutput("#{command(:semodule)} --remove #{@resource[:name]}")
-  rescue Puppet::ExecutionFailure => detail
-      raise Puppet::Error, "Could not remove policy module: #{detail}", detail.backtrace
-  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}", detail.backtrace
-  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], $!.backtrace
-    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('V')[0]
-    handle.read(len)
-  end
-  def selmodversion_file
-    magic = 0xF97CFF8F
-    v = nil
-    filename = selmod_name_to_filename
-    # Open a file handle and parse the bytes until version is found
-    Puppet::FileSystem.open(filename, nil, 'rb') do |mod|
-      (hdr, ver, numsec) = mod.read(12).unpack('VVV')
-      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)
-    end
-    self.debug "file version #{v}"
-    v
-  end
-  def selmodversion_loaded
-    selmod_output = []
-    selmodule_cmd = "#{command(:semodule)} --list"
-    begin
-      execpipe(selmodule_cmd) do |output|
-        output.each_line do |line|
-          line.chomp!
-          selmod_output << line
-          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: \"%{selmodule_command}\" failed with \"%{selmod_output}\"") % { selmodule_command: selmodule_cmd, selmod_output: selmod_output.join(' ') }
-    end
-    nil
-  end
-end

data/vendored/puppet/lib/puppet/provider/service/base.rb DELETED

@@ -1,134 +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 proper 'ps' invocation for the platform
-  # ported from the facter 2.x implementation, since facter 3.x
-  # is dropping the fact (for which this was the only use)
-  def getps
-    case Facter.value(:operatingsystem)
-    when 'OpenWrt'
-      'ps www'
-    when 'FreeBSD', 'NetBSD', 'OpenBSD', 'Darwin', 'DragonFly'
-      'ps auxwww'
-    else
-      'ps -ef'
-    end
-  end
-  private :getps
-  # 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]
-    regex = Regexp.new(@resource[:pattern])
-    ps = getps
-    self.debug "Executing '#{ps}'"
-    table = Puppet::Util::Execution.execute(ps)
-    # The output of the PS command can be a mashup of several different
-    # encodings depending on which processes are running and what
-    # arbitrary data has been used to set their name in the process table.
-    #
-    # First, try a polite conversion to in order to match the UTF-8 encoding
-    # of our regular expression.
-    table = Puppet::Util::CharacterEncoding.convert_to_utf_8(table)
-    # If that fails, force to UTF-8 and then scrub as most uses are scanning
-    # for ACII-compatible program names.
-    table.force_encoding(Encoding::UTF_8) unless table.encoding == Encoding::UTF_8
-    table = Puppet::Util::CharacterEncoding.scrub(table) unless table.valid_encoding?
-    table.each_line { |line|
-      if regex.match(line)
-        self.debug "Process matched: #{line}"
-        ary = line.sub(/^[[:space:]]+/u, '').split(/[[:space:]]+/u)
-        return ary[1]
-      end
-    }
-    nil
-  end
-  private :getpid
-  # 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)
-      # Explicitly calling exitstatus to facilitate testing
-      if $CHILD_STATUS.exitstatus == 0
-        return :running
-      else
-        return :stopped
-      end
-    elsif pid = 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 _("%{name} is not running") % { name: self.name }
-        return false
-      end
-      begin
-        output = kill pid
-      rescue Puppet::ExecutionFailure
-        @resource.fail Puppet::Error, "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/vendored/puppet/lib/puppet/provider/service/bsd.rb DELETED

@@ -1,51 +0,0 @@
-Puppet::Type.type(:service).provide :bsd, :parent => :init do
-  desc <<-EOT
-    Generic BSD form of `init`-style service management with `rc.d`.
-    Uses `rc.conf.d` for service enabling and disabling.
-  EOT
-  confine :operatingsystem => [:freebsd, :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, @resource[:name])
-    File.delete(rcfile) if Puppet::FileSystem.exist?(rcfile)
-  end
-  # if the service file exists in rc.conf.d then it's already enabled
-  def enabled?
-    rcfile = File.join(rcconf_dir, @resource[:name])
-    return :true if Puppet::FileSystem.exist?(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 Puppet::FileSystem.exist?(rcconf_dir)
-    rcfile = File.join(rcconf_dir, @resource[:name])
-    File.open(rcfile, File::WRONLY | File::APPEND | File::CREAT, 0644) { |f|
-      f << "%s_enable=\"YES\"\n" % @resource[:name]
-    }
-  end
-  # Override stop/start commands to use one<cmd>'s and the avoid race condition
-  # where provider tries to stop/start the service before it is enabled
-  def startcmd
-    [self.initscript, :onestart]
-  end
-  def stopcmd
-    [self.initscript, :onestop]
-  end
-end

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

@@ -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 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
-      unless @defpath
-        ["/var/lib/service", "/etc"].each do |path|
-          if Puppet::FileSystem.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 ! 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
-    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}", detail)
-    end
-    :stopped
-  end
-  def setupservice
-      if resource[:manifest]
-        Puppet.notice "Configuring #{resource[:name]}"
-        command = [ resource[:manifest], resource[:name] ]
-        #texecute("setupservice", command)
-        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