openvox 7.37.1

data/lib/puppet/type/service.rb

@@ -0,0 +1,309 @@
+# 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 :delayed_startable, "The provider can set service to delayed start",
+      :methods => [:delayed_start]
+
+    feature :manual_startable, "The provider can set service to manual start",
+      :methods => [:manual_start]
+
+    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]
+
+    feature :configurable_timeout, "The provider can specify a minumum timeout for syncing service properties"
+
+    feature :manages_logon_credentials, "The provider can specify the logon credentials used for a service"
+
+    newproperty(:enable, :required_features => :enableable) do
+      desc "Whether a service should be enabled to start at boot.
+        This property behaves differently depending on the platform;
+        wherever possible, it relies on local tools to enable or disable
+        a given service. Default values depend on the platform.
+        
+        If you don't specify a value for the `enable` attribute, Puppet leaves
+        that aspect of the service alone and your operating system determines 
+        the behavior."
+
+      newvalue(:true, :event => :service_enabled) do
+        provider.enable
+      end
+
+      newvalue(:false, :event => :service_disabled) do
+        provider.disable
+      end
+
+      newvalue(:manual, :event => :service_manual_start, :required_features => :manual_startable) 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
+
+      newvalue(:delayed, :event => :service_delayed_start, :required_features => :delayed_startable) do
+        provider.delayed_start
+      end
+
+      def insync?(current)
+        return provider.enabled_insync?(current) if provider.respond_to?(:enabled_insync?)
+        super(current)
+      end
+    end
+
+    # Handle whether the service should actually be running right now.
+    newproperty(:ensure) do
+      desc "Whether a service should be running. Default values depend on the platform."
+
+      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
+        property = @resource.property(:logonaccount)
+        if property
+          val = property.retrieve
+          property.sync unless property.safe_insync?(val)
+        end
+
+        event = super()
+
+        property = @resource.property(:enable)
+        if property
+          val = property.retrieve
+          property.sync unless property.safe_insync?(val)
+        end
+
+        event
+      end
+    end
+
+    newproperty(:logonaccount, :required_features => :manages_logon_credentials) do
+      desc "Specify an account for service logon"
+
+      def insync?(current)
+        return provider.logonaccount_insync?(current) if provider.respond_to?(:logonaccount_insync?)
+        super(current)
+      end
+    end
+
+    newparam(:logonpassword, :required_features => :manages_logon_credentials) do
+      desc "Specify a password for service logon. Default value is an empty string (when logonaccount is specified)."
+
+      validate do |value|
+        raise ArgumentError, _("Passwords cannot include ':'") if value.is_a?(String) && value.include?(":")
+      end
+
+      sensitive true
+      defaultto { @resource[:logonaccount] ? "" : nil }
+    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.tr(".","_").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
+
+    newparam(:timeout, :required_features => :configurable_timeout) do
+      desc "Specify an optional minimum timeout (in seconds) for puppet to wait when syncing service properties"
+      defaultto { provider.respond_to?(:default_timeout) ? provider.default_timeout : 10 }
+
+      munge do |value|
+        begin
+          value = value.to_i
+          raise if value < 1
+          value
+        rescue
+          raise Puppet::Error.new(_("\"%{value}\" is not a positive integer: the timeout parameter must be specified as a positive integer") % { value: value })
+        end
+      end
+    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
+
+    validate do
+      if @parameters[:logonpassword] && @parameters[:logonaccount].nil?
+        raise Puppet::Error.new(_"The 'logonaccount' parameter is mandatory when setting 'logonpassword'.")
+      end
+    end
+  end
+end

data/lib/puppet/type/stage.rb

@@ -0,0 +1,27 @@
+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/lib/puppet/type/tidy.rb

@@ -0,0 +1,376 @@
+require_relative '../../puppet/parameter/boolean'
+
+Puppet::Type.newtype(:tidy) do
+  require_relative '../../puppet/file_serving/fileset'
+  require_relative '../../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. Ignores managed resources.
+
+    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(:max_files) do
+    desc "In case the resource is a directory and the recursion is enabled, puppet will
+      generate a new resource for each file file found, possible leading to
+      an excessive number of resources generated without any control.
+
+      Setting `max_files` will check the number of file resources that
+      will eventually be created and will raise a resource argument error if the
+      limit will be exceeded.
+
+      Use value `0` to disable the check. In this case, a warning is logged if
+      the number of files exceeds 1000."
+
+    defaultto 0
+    newvalues(/^[0-9]+$/)
+  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)
+      num = AgeConvertors[unit]
+      if num
+        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)
+      num = { :b => 0, :k => 1, :m => 2, :g => 3, :t => 4 }[unit]
+      if num
+        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
+    }
+
+    new_file = Puppet::Type.type(:file).new(parameters)
+    new_file.copy_metaparams(@parameters)
+
+    new_file
+  end
+
+  def retrieve
+    # Our ensure property knows how to retrieve everything for us.
+    obj = @parameters[:ensure]
+    if obj
+      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 = { :max_files => self[:max_files],
+                    :recurse => true,
+                    :recurselimit => self[:recurse] }
+    when true, :true, :inf
+      parameter = { :max_files => self[:max_files],
+                    :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)
+      resource = files_by_name[dir]
+      next unless resource
+      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)
+
+    stat = self.stat(path)
+    return false unless stat
+
+    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.
+    param = parameter(:matches)
+    return false if param && ! param.tidy?(path, stat)
+
+    tested = false
+    [:age, :size].each do |name|
+      param = parameter(name)
+      next unless param
+      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