bolt 0.24.0 → 0.25.0

data/vendored/puppet/lib/puppet/type/service.rb

@@ -1,255 +0,0 @@
-# This is our main way of managing processes right now.
-#
-# a service is distinct from a process in that services
-# can only be managed through the interface of an init script
-# which is why they have a search path for initscripts and such
-
-
-module Puppet
-
-  Type.newtype(:service) do
-    @doc = "Manage running services.  Service support unfortunately varies
-      widely by platform --- some platforms have very little if any concept of a
-      running service, and some have a very codified and powerful concept.
-      Puppet's service support is usually capable of doing the right thing, but
-      the more information you can provide, the better behaviour you will get.
-
-      Puppet 2.7 and newer expect init scripts to have a working status command.
-      If this isn't the case for any of your services' init scripts, you will
-      need to set `hasstatus` to false and possibly specify a custom status
-      command in the `status` attribute. As a last resort, Puppet will attempt to
-      search the process table by calling whatever command is listed in the `ps`
-      fact. The default search pattern is the name of the service, but you can
-      specify it with the `pattern` attribute.
-
-      **Refresh:** `service` resources can respond to refresh events (via
-      `notify`, `subscribe`, or the `~>` arrow). If a `service` receives an
-      event from another resource, Puppet will restart the service it manages.
-      The actual command used to restart the service depends on the platform and
-      can be configured:
-
-      * If you set `hasrestart` to true, Puppet will use the init script's restart command.
-      * You can provide an explicit command for restarting with the `restart` attribute.
-      * If you do neither, the service's stop and start commands will be used."
-
-    feature :refreshable, "The provider can restart the service.",
-      :methods => [:restart]
-
-    feature :enableable, "The provider can enable and disable the service",
-      :methods => [:disable, :enable, :enabled?]
-
-    feature :controllable, "The provider uses a control variable."
-
-    feature :flaggable, "The provider can pass flags to the service."
-
-    feature :maskable, "The provider can 'mask' the service.",
-      :methods => [:mask]
-
-    newproperty(:enable, :required_features => :enableable) do
-      desc "Whether a service should be enabled to start at boot.
-        This property behaves quite differently depending on the platform;
-        wherever possible, it relies on local tools to enable or disable
-        a given service."
-
-      newvalue(:true, :event => :service_enabled) do
-        provider.enable
-      end
-
-      newvalue(:false, :event => :service_disabled) do
-        provider.disable
-      end
-
-      newvalue(:manual, :event => :service_manual_start) do
-        provider.manual_start
-      end
-
-      # This only makes sense on systemd systems. Otherwise, it just defaults
-      # to disable.
-      newvalue(:mask, :event => :service_disabled, :required_features => :maskable) do
-        provider.mask
-      end
-
-      def retrieve
-        provider.enabled?
-      end
-
-      # This only makes sense on systemd systems. Static services cannot be enabled
-      # or disabled manually.
-      def insync?(current)
-        if provider.respond_to?(:cached_enabled?) && provider.cached_enabled? == 'static'
-          Puppet.debug("Unable to enable or disable static service #{@resource[:name]}")
-          return true
-        end
-
-        super(current)
-      end
-
-      validate do |value|
-        if value == :manual && !Puppet::Util::Platform.windows?
-          raise Puppet::Error.new(_("Setting enable to manual is only supported on Microsoft Windows."))
-        end
-      end
-    end
-
-    # Handle whether the service should actually be running right now.
-    newproperty(:ensure) do
-      desc "Whether a service should be running."
-
-      newvalue(:stopped, :event => :service_stopped) do
-        provider.stop
-      end
-
-      newvalue(:running, :event => :service_started, :invalidate_refreshes => true) do
-        provider.start
-      end
-
-      aliasvalue(:false, :stopped)
-      aliasvalue(:true, :running)
-
-      def retrieve
-        provider.status
-      end
-
-      def sync
-        event = super()
-
-        if property = @resource.property(:enable)
-          val = property.retrieve
-          property.sync unless property.safe_insync?(val)
-        end
-
-        event
-      end
-    end
-
-    newproperty(:flags, :required_features => :flaggable) do
-      desc "Specify a string of flags to pass to the startup script."
-    end
-
-    newparam(:binary) do
-      desc "The path to the daemon.  This is only used for
-        systems that do not support init scripts.  This binary will be
-        used to start the service if no `start` parameter is
-        provided."
-    end
-
-    newparam(:hasstatus) do
-      desc "Declare whether the service's init script has a functional status
-        command. This attribute's default value changed in Puppet 2.7.0.
-
-        The init script's status command must return 0 if the service is
-        running and a nonzero value otherwise. Ideally, these exit codes
-        should conform to [the LSB's specification][lsb-exit-codes] for init
-        script status actions, but Puppet only considers the difference
-        between 0 and nonzero to be relevant.
-
-        If a service's init script does not support any kind of status command,
-        you should set `hasstatus` to false and either provide a specific
-        command using the `status` attribute or expect that Puppet will look for
-        the service name in the process table. Be aware that 'virtual' init
-        scripts (like 'network' under Red Hat systems) will respond poorly to
-        refresh events from other resources if you override the default behavior
-        without providing a status command."
-
-      newvalues(:true, :false)
-
-      defaultto :true
-    end
-    newparam(:name) do
-      desc <<-EOT
-        The name of the service to run.
-
-        This name is used to find the service; on platforms where services
-        have short system names and long display names, this should be the
-        short name. (To take an example from Windows, you would use "wuauserv"
-        rather than "Automatic Updates.")
-      EOT
-      isnamevar
-    end
-
-    newparam(:path) do
-      desc "The search path for finding init scripts.  Multiple values should
-        be separated by colons or provided as an array."
-
-      munge do |value|
-        value = [value] unless value.is_a?(Array)
-        value.flatten.collect { |p| p.split(File::PATH_SEPARATOR) }.flatten
-      end
-
-      defaultto { provider.class.defpath if provider.class.respond_to?(:defpath) }
-    end
-    newparam(:pattern) do
-      desc "The pattern to search for in the process table.
-        This is used for stopping services on platforms that do not
-        support init scripts, and is also used for determining service
-        status on those service whose init scripts do not include a status
-        command.
-
-        Defaults to the name of the service. The pattern can be a simple string
-        or any legal Ruby pattern, including regular expressions (which should
-        be quoted without enclosing slashes)."
-
-      defaultto { @resource[:binary] || @resource[:name] }
-    end
-    newparam(:restart) do
-      desc "Specify a *restart* command manually.  If left
-        unspecified, the service will be stopped and then started."
-    end
-    newparam(:start) do
-      desc "Specify a *start* command manually.  Most service subsystems
-        support a `start` command, so this will not need to be
-        specified."
-    end
-    newparam(:status) do
-      desc "Specify a *status* command manually.  This command must
-        return 0 if the service is running and a nonzero value otherwise.
-        Ideally, these exit codes should conform to [the LSB's
-        specification][lsb-exit-codes] for init script status actions, but
-        Puppet only considers the difference between 0 and nonzero to be
-        relevant.
-
-        If left unspecified, the status of the service will be determined
-        automatically, usually by looking for the service in the process
-        table.
-
-        [lsb-exit-codes]: http://refspecs.linuxfoundation.org/LSB_4.1.0/LSB-Core-generic/LSB-Core-generic/iniscrptact.html"
-    end
-
-    newparam(:stop) do
-      desc "Specify a *stop* command manually."
-    end
-
-    newparam(:control) do
-      desc "The control variable used to manage services (originally for HP-UX).
-        Defaults to the upcased service name plus `START` replacing dots with
-        underscores, for those providers that support the `controllable` feature."
-      defaultto { resource.name.gsub(".","_").upcase + "_START" if resource.provider.controllable? }
-    end
-
-    newparam :hasrestart do
-      desc "Specify that an init script has a `restart` command.  If this is
-        false and you do not specify a command in the `restart` attribute,
-        the init script's `stop` and `start` commands will be used."
-      newvalues(:true, :false)
-    end
-
-    newparam(:manifest) do
-      desc "Specify a command to config a service, or a path to a manifest to do so."
-    end
-
-    # Basically just a synonym for restarting.  Used to respond
-    # to events.
-    def refresh
-      # Only restart if we're actually running
-      if (@parameters[:ensure] || newattr(:ensure)).retrieve == :running
-        provider.restart
-      else
-        debug "Skipping restart; service is not running"
-      end
-    end
-
-    def self.needs_ensure_retrieved
-      false
-    end
-  end
-end

data/vendored/puppet/lib/puppet/type/stage.rb

@@ -1,27 +0,0 @@
-Puppet::Type.newtype(:stage) do
-  desc "A resource type for creating new run stages.  Once a stage is available,
-    classes can be assigned to it by declaring them with the resource-like syntax
-    and using
-    [the `stage` metaparameter](https://puppet.com/docs/puppet/latest/metaparameter.html#stage).
-
-    Note that new stages are not useful unless you also declare their order
-    in relation to the default `main` stage.
-
-    A complete run stage example:
-
-        stage { 'pre':
-          before => Stage['main'],
-        }
-
-        class { 'apt-updates':
-          stage => 'pre',
-        }
-
-    Individual resources cannot be assigned to run stages; you can only set stages
-    for classes."
-
-  newparam :name do
-    desc "The name of the stage. Use this as the value for the `stage` metaparameter
-      when assigning classes to this stage."
-  end
-end

data/vendored/puppet/lib/puppet/type/tidy.rb

@@ -1,349 +0,0 @@
-require 'puppet/parameter/boolean'
-
-Puppet::Type.newtype(:tidy) do
-  require 'puppet/file_serving/fileset'
-  require 'puppet/file_bucket/dipper'
-
-  @doc = "Remove unwanted files based on specific criteria.  Multiple
-    criteria are OR'd together, so a file that is too large but is not
-    old enough will still get tidied.
-
-    If you don't specify either `age` or `size`, then all files will
-    be removed.
-
-    This resource type works by generating a file resource for every file
-    that should be deleted and then letting that resource perform the
-    actual deletion.
-    "
-
-  # Tidy names are not isomorphic with the objects.
-  @isomorphic = false
-
-  newparam(:path) do
-    desc "The path to the file or directory to manage.  Must be fully
-      qualified."
-    isnamevar
-    munge do |value|
-      File.expand_path(value)
-    end
-  end
-
-  newparam(:recurse) do
-    desc "If target is a directory, recursively descend
-      into the directory looking for files to tidy."
-
-    newvalues(:true, :false, :inf, /^[0-9]+$/)
-
-    # Replace the validation so that we allow numbers in
-    # addition to string representations of them.
-    validate { |arg| }
-    munge do |value|
-      newval = super(value)
-      case newval
-      when :true, :inf; true
-      when :false; false
-      when Integer; value
-      when /^\d+$/; Integer(value)
-      else
-        raise ArgumentError, _("Invalid recurse value %{value}") % { value: value.inspect }
-      end
-    end
-  end
-
-  newparam(:matches) do
-    desc <<-'EOT'
-      One or more (shell type) file glob patterns, which restrict
-      the list of files to be tidied to those whose basenames match
-      at least one of the patterns specified. Multiple patterns can
-      be specified using an array.
-
-      Example:
-
-          tidy { '/tmp':
-            age     => '1w',
-            recurse => 1,
-            matches => [ '[0-9]pub*.tmp', '*.temp', 'tmpfile?' ],
-          }
-
-      This removes files from `/tmp` if they are one week old or older,
-      are not in a subdirectory and match one of the shell globs given.
-
-      Note that the patterns are matched against the basename of each
-      file -- that is, your glob patterns should not have any '/'
-      characters in them, since you are only specifying against the last
-      bit of the file.
-
-      Finally, note that you must now specify a non-zero/non-false value
-      for recurse if matches is used, as matches only apply to files found
-      by recursion (there's no reason to use static patterns match against
-      a statically determined path).  Requiring explicit recursion clears
-      up a common source of confusion.
-    EOT
-
-    # Make sure we convert to an array.
-    munge do |value|
-      fail _("Tidy can't use matches with recurse 0, false, or undef") if "#{@resource[:recurse]}" =~ /^(0|false|)$/
-      [value].flatten
-    end
-
-    # Does a given path match our glob patterns, if any?  Return true
-    # if no patterns have been provided.
-    def tidy?(path, stat)
-      basename = File.basename(path)
-      flags = File::FNM_DOTMATCH | File::FNM_PATHNAME
-      return(value.find {|pattern| File.fnmatch(pattern, basename, flags) } ? true : false)
-    end
-  end
-
-  newparam(:backup) do
-    desc "Whether tidied files should be backed up.  Any values are passed
-      directly to the file resources used for actual file deletion, so consult
-      the `file` type's backup documentation to determine valid values."
-  end
-
-  newparam(:age) do
-    desc "Tidy files whose age is equal to or greater than
-      the specified time.  You can choose seconds, minutes,
-      hours, days, or weeks by specifying the first letter of any
-      of those words (for example, '1w' represents one week).
-
-      Specifying 0 will remove all files."
-
-    AgeConvertors = {
-      :s => 1,
-      :m => 60,
-      :h => 60 * 60,
-      :d => 60 * 60 * 24,
-      :w => 60 * 60 * 24 * 7,
-    }
-
-    def convert(unit, multi)
-      if num = AgeConvertors[unit]
-        return num * multi
-      else
-        self.fail _("Invalid age unit '%{unit}'") % { unit: unit }
-      end
-    end
-
-    def tidy?(path, stat)
-      # If the file's older than we allow, we should get rid of it.
-      (Time.now.to_i - stat.send(resource[:type]).to_i) > value
-    end
-
-    munge do |age|
-      unit = multi = nil
-      case age
-      when /^([0-9]+)(\w)\w*$/
-        multi = Integer($1)
-        unit = $2.downcase.intern
-      when /^([0-9]+)$/
-        multi = Integer($1)
-        unit = :d
-      else
-        #TRANSLATORS tidy is the name of a program and should not be translated
-        self.fail _("Invalid tidy age %{age}") % { age: age }
-      end
-
-      convert(unit, multi)
-    end
-  end
-
-  newparam(:size) do
-    desc "Tidy files whose size is equal to or greater than
-      the specified size.  Unqualified values are in kilobytes, but
-      *b*, *k*, *m*, *g*, and *t* can be appended to specify *bytes*,
-      *kilobytes*, *megabytes*, *gigabytes*, and *terabytes*, respectively.
-      Only the first character is significant, so the full word can also
-      be used."
-
-    def convert(unit, multi)
-      if num = { :b => 0, :k => 1, :m => 2, :g => 3, :t => 4 }[unit]
-        result = multi
-        num.times do result *= 1024 end
-        return result
-      else
-        self.fail _("Invalid size unit '%{unit}'") % { unit: unit }
-      end
-    end
-
-    def tidy?(path, stat)
-      stat.size >= value
-    end
-
-    munge do |size|
-      case size
-      when /^([0-9]+)(\w)\w*$/
-        multi = Integer($1)
-        unit = $2.downcase.intern
-      when /^([0-9]+)$/
-        multi = Integer($1)
-        unit = :k
-      else
-        #TRANSLATORS tidy is the name of a program and should not be translated
-        self.fail _("Invalid tidy size %{age}") % { age: age }
-      end
-
-      convert(unit, multi)
-    end
-  end
-
-  newparam(:type) do
-    desc "Set the mechanism for determining age."
-
-    newvalues(:atime, :mtime, :ctime)
-
-    defaultto :atime
-  end
-
-  newparam(:rmdirs, :boolean => true, :parent => Puppet::Parameter::Boolean) do
-    desc "Tidy directories in addition to files; that is, remove
-      directories whose age is older than the specified criteria.
-      This will only remove empty directories, so all contained
-      files must also be tidied before a directory gets removed."
-  end
-
-  # Erase PFile's validate method
-  validate do
-  end
-
-  def self.instances
-    []
-  end
-
-  def depthfirst?
-    true
-  end
-
-  def initialize(hash)
-    super
-
-    # only allow backing up into filebuckets
-    self[:backup] = false unless self[:backup].is_a? Puppet::FileBucket::Dipper
-  end
-
-  # Make a file resource to remove a given file.
-  def mkfile(path)
-    # Force deletion, so directories actually get deleted.
-    parameters = {
-      :path => path, :backup => self[:backup],
-      :ensure => :absent, :force => true
-    }
-
-    parameters[:noop] = self[:noop] unless self[:noop].nil?
-
-    Puppet::Type.type(:file).new(parameters)
-  end
-
-  def retrieve
-    # Our ensure property knows how to retrieve everything for us.
-    if obj = @parameters[:ensure]
-      return obj.retrieve
-    else
-      return {}
-    end
-  end
-
-  # Hack things a bit so we only ever check the ensure property.
-  def properties
-    []
-  end
-
-  def generate
-    return [] unless stat(self[:path])
-
-    case self[:recurse]
-    when Integer, /^\d+$/
-      parameter = { :recurse => true, :recurselimit => self[:recurse] }
-    when true, :true, :inf
-      parameter = { :recurse => true }
-    end
-
-    if parameter
-      files = Puppet::FileServing::Fileset.new(self[:path], parameter).files.collect do |f|
-        f == "." ? self[:path] : ::File.join(self[:path], f)
-      end
-    else
-      files = [self[:path]]
-    end
-    found_files = files.find_all { |path| tidy?(path) }.collect { |path| mkfile(path) }
-    result = found_files.each { |file| debug "Tidying #{file.ref}" }.sort { |a,b| b[:path] <=> a[:path] }
-    if found_files.size > 0
-      #TRANSLATORS "Tidy" is a program name and should not be translated
-      notice _("Tidying %{count} files") % { count: found_files.size }
-    end
-
-    # No need to worry about relationships if we don't have rmdirs; there won't be
-    # any directories.
-    return result unless rmdirs?
-
-    # Now make sure that all directories require the files they contain, if all are available,
-    # so that a directory is emptied before we try to remove it.
-    files_by_name = result.inject({}) { |hash, file| hash[file[:path]] = file; hash }
-
-    files_by_name.keys.sort { |a,b| b <=> a }.each do |path|
-      dir = ::File.dirname(path)
-      next unless resource = files_by_name[dir]
-      if resource[:require]
-        resource[:require] << Puppet::Resource.new(:file, path)
-      else
-        resource[:require] = [Puppet::Resource.new(:file, path)]
-      end
-    end
-
-    result
-  end
-
-  # Does a given path match our glob patterns, if any?  Return true
-  # if no patterns have been provided.
-  def matches?(path)
-    return true unless self[:matches]
-
-    basename = File.basename(path)
-    flags = File::FNM_DOTMATCH | File::FNM_PATHNAME
-    if self[:matches].find {|pattern| File.fnmatch(pattern, basename, flags) }
-      return true
-    else
-      debug "No specified patterns match #{path}, not tidying"
-      return false
-    end
-  end
-
-  # Should we remove the specified file?
-  def tidy?(path)
-    # ignore files that are already managed, since we can't tidy
-    # those files anyway
-    return false if catalog.resource(:file, path)
-
-    return false unless stat = self.stat(path)
-
-    return false if stat.ftype == "directory" and ! rmdirs?
-
-    # The 'matches' parameter isn't OR'ed with the other tests --
-    # it's just used to reduce the list of files we can match.
-    return false if param = parameter(:matches) and ! param.tidy?(path, stat)
-
-    tested = false
-    [:age, :size].each do |name|
-      next unless param = parameter(name)
-      tested = true
-      return true if param.tidy?(path, stat)
-    end
-
-    # If they don't specify either, then the file should always be removed.
-    return true unless tested
-    false
-  end
-
-  def stat(path)
-    begin
-      Puppet::FileSystem.lstat(path)
-    rescue Errno::ENOENT
-      debug _("File does not exist")
-      return nil
-    rescue Errno::EACCES
-      #TRANSLATORS "stat" is a program name and should not be translated
-      warning _("Could not stat; permission denied")
-      return nil
-    end
-  end
-end