puppet 5.5.22 → 6.0.0

data/lib/puppet/ssl/configuration.rb

@@ -1,61 +0,0 @@
-require 'puppet/ssl'
-require 'openssl'
-module Puppet
-module SSL
-  # Puppet::SSL::Configuration is intended to separate out the following concerns:
-  # * CA certificates that authenticate peers (ca_auth_file)
-  # * Who clients trust as distinct from who servers trust.  We should not
-  #   assume one single self signed CA cert for everyone.
-class Configuration
-  def initialize(localcacert, options={})
-    @localcacert = localcacert
-    @ca_auth_file = options[:ca_auth_file]
-  end
-
-  # @deprecated Use {#ca_auth_file} instead.
-  def ca_chain_file
-    ca_auth_file
-  end
-
-  # The ca_auth_file method is intended to return the PEM bundle of CA certs
-  # used to authenticate peer connections.
-  def ca_auth_file
-    @ca_auth_file || @localcacert
-  end
-
-  ##
-  # ca_auth_certificates returns an Array of OpenSSL::X509::Certificate
-  # instances intended to be used in the connection verify_callback.  This
-  # method loads and parses the {#ca_auth_file} from the filesystem.
-  #
-  # @api private
-  #
-  # @return [Array<OpenSSL::X509::Certificate>]
-  def ca_auth_certificates
-    @ca_auth_certificates ||= decode_cert_bundle(read_file(ca_auth_file))
-  end
-
-  ##
-  # Decode a string of concatenated certificates
-  #
-  # @return [Array<OpenSSL::X509::Certificate>]
-  def decode_cert_bundle(bundle_str)
-    re = /-----BEGIN CERTIFICATE-----.*?-----END CERTIFICATE-----/m
-    pem_ary = bundle_str.scan(re)
-    pem_ary.map do |pem_str|
-      OpenSSL::X509::Certificate.new(pem_str)
-    end
-  end
-  private :decode_cert_bundle
-
-  # read_file makes testing easier.
-  def read_file(path)
-    # https://www.ietf.org/rfc/rfc2459.txt defines the x509 V3 certificate format
-    # CA bundles are concatenated X509 certificates, but may also include
-    # comments, which could have UTF-8 characters
-    Puppet::FileSystem.read(path, :encoding => Encoding::UTF_8)
-  end
-  private :read_file
-end
-end
-end

data/lib/puppet/ssl/inventory.rb

@@ -1,55 +0,0 @@
-require 'puppet/ssl'
-require 'puppet/ssl/certificate'
-
-# Keep track of all of our known certificates.
-class Puppet::SSL::Inventory
-  attr_reader :path
-
-  # Add a certificate to our inventory.
-  def add(cert)
-    cert = cert.content if cert.is_a?(Puppet::SSL::Certificate)
-    # RFC 5280 says the cert subject may contain UTF8 - https://www.ietf.org/rfc/rfc5280.txt
-    # Note however that Puppet generated SSL files must only contain ASCII characters
-    # based on the validate_certname method of Puppet::SSL::Base
-    Puppet.settings.setting(:cert_inventory).open('a:UTF-8') do |f|
-      f.print format(cert)
-    end
-  end
-
-  # Format our certificate for output.
-  def format(cert)
-    iso = '%Y-%m-%dT%H:%M:%S%Z'
-    "0x%04x %s %s %s\n" % [cert.serial,  cert.not_before.strftime(iso), cert.not_after.strftime(iso), cert.subject]
-  end
-
-  def initialize
-    @path = Puppet[:cert_inventory]
-  end
-
-  # Rebuild the inventory from scratch.  This should happen if
-  # the file is entirely missing or if it's somehow corrupted.
-  def rebuild
-    Puppet.notice _("Rebuilding inventory file")
-
-    # RFC 5280 says the cert subject may contain UTF8 - https://www.ietf.org/rfc/rfc5280.txt
-    Puppet.settings.setting(:cert_inventory).open('w:UTF-8') do |f|
-      Puppet::SSL::Certificate.indirection.search("*").each do |cert|
-        f.print format(cert.content)
-      end
-    end
-  end
-
-  # Find all serial numbers for a given certificate. If none can be found, returns
-  # an empty array.
-  def serials(name)
-    return [] unless Puppet::FileSystem.exist?(@path)
-
-    # RFC 5280 says the cert subject may contain UTF8 - https://www.ietf.org/rfc/rfc5280.txt
-    # Note however that Puppet generated SSL files must only contain ASCII characters
-    # based on the validate_certname method of Puppet::SSL::Base
-    File.readlines(@path, :encoding => Encoding::UTF_8).collect do |line|
-      /^(\S+).+\/CN=#{name}$/.match(line)
-    end.compact.map { |m| Integer(m[1]) }
-  end
-
-end

data/lib/puppet/type/augeas.rb

@@ -1,211 +0,0 @@
-#
-#   Copyright 2011 Bryan Kearney <bkearney@redhat.com>
-#
-#   Licensed under the Apache License, Version 2.0 (the "License");
-#   you may not use this file except in compliance with the License.
-#   You may obtain a copy of the License at
-#
-#       https://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS,
-#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#   See the License for the specific language governing permissions and
-#   limitations under the License.
-
-require 'puppet/parameter/boolean'
-
-Puppet::Type.newtype(:augeas) do
-  include Puppet::Util
-
-  feature :parse_commands, "Parse the command string"
-  feature :need_to_run?, "If the command should run"
-  feature :execute_changes, "Actually make the changes"
-
-  @doc = <<-'EOT'
-    Apply a change or an array of changes to the filesystem
-    using the augeas tool.
-
-    Requires:
-
-    - [Augeas](http://www.augeas.net)
-    - The ruby-augeas bindings
-
-    Sample usage with a string:
-
-        augeas{"test1" :
-          context => "/files/etc/sysconfig/firstboot",
-          changes => "set RUN_FIRSTBOOT YES",
-          onlyif  => "match other_value size > 0",
-        }
-
-    Sample usage with an array and custom lenses:
-
-        augeas{"jboss_conf":
-          context   => "/files",
-          changes   => [
-              "set etc/jbossas/jbossas.conf/JBOSS_IP $ipaddress",
-              "set etc/jbossas/jbossas.conf/JAVA_HOME /usr",
-            ],
-          load_path => "$/usr/share/jbossas/lenses",
-        }
-
-  EOT
-
-  newparam (:name) do
-    desc "The name of this task. Used for uniqueness."
-    isnamevar
-  end
-
-  newparam (:context) do
-    desc "Optional context path. This value is prepended to the paths of all
-      changes if the path is relative. If the `incl` parameter is set,
-      defaults to `/files + incl`; otherwise, defaults to the empty string."
-    defaultto ""
-    munge do |value|
-      if value.empty? and resource[:incl]
-        "/files" + resource[:incl]
-      else
-        value
-      end
-    end
-  end
-
-  newparam (:onlyif) do
-    desc "Optional augeas command and comparisons to control the execution of this type.
-
-      Note: `values` is not an actual augeas API command. It calls `match` to retrieve an array of paths
-             in <MATCH_PATH> and then `get` to retrieve the values from each of the returned paths.
-
-      Supported onlyif syntax:
-
-      * `get <AUGEAS_PATH> <COMPARATOR> <STRING>`
-      * `values <MATCH_PATH> include <STRING>`
-      * `values <MATCH_PATH> not_include <STRING>`
-      * `values <MATCH_PATH> == <AN_ARRAY>`
-      * `values <MATCH_PATH> != <AN_ARRAY>`
-      * `match <MATCH_PATH> size <COMPARATOR> <INT>`
-      * `match <MATCH_PATH> include <STRING>`
-      * `match <MATCH_PATH> not_include <STRING>`
-      * `match <MATCH_PATH> == <AN_ARRAY>`
-      * `match <MATCH_PATH> != <AN_ARRAY>`
-
-      where:
-
-      * `AUGEAS_PATH` is a valid path scoped by the context
-      * `MATCH_PATH` is a valid match syntax scoped by the context
-      * `COMPARATOR` is one of `>, >=, !=, ==, <=,` or `<`
-      * `STRING` is a string
-      * `INT` is a number
-      * `AN_ARRAY` is in the form `['a string', 'another']`"
-    defaultto ""
-  end
-
-
-  newparam(:changes) do
-    desc "The changes which should be applied to the filesystem. This
-    can be a command or an array of commands. The following commands are supported:
-
-    * `set <PATH> <VALUE>` --- Sets the value `VALUE` at location `PATH`
-    * `setm <PATH> <SUB> <VALUE>` --- Sets multiple nodes (matching `SUB` relative to `PATH`) to `VALUE`
-    * `rm <PATH>` --- Removes the node at location `PATH`
-    * `remove <PATH>` --- Synonym for `rm`
-    * `clear <PATH>` --- Sets the node at `PATH` to `NULL`, creating it if needed
-    * `clearm <PATH> <SUB>` --- Sets multiple nodes (matching `SUB` relative to `PATH`) to `NULL`
-    * `touch <PATH>` --- Creates `PATH` with the value `NULL` if it does not exist
-    * `ins <LABEL> (before|after) <PATH>` --- Inserts an empty node `LABEL` either before or after `PATH`.
-    * `insert <LABEL> <WHERE> <PATH>` --- Synonym for `ins`
-    * `mv <PATH> <OTHER PATH>` --- Moves a node at `PATH` to the new location `OTHER PATH`
-    * `move <PATH> <OTHER PATH>` --- Synonym for `mv`
-    * `rename <PATH> <LABEL>` --- Rename a node at `PATH` to a new `LABEL`
-    * `defvar <NAME> <PATH>` --- Sets Augeas variable `$NAME` to `PATH`
-    * `defnode <NAME> <PATH> <VALUE>` --- Sets Augeas variable `$NAME` to `PATH`, creating it with `VALUE` if needed
-
-    If the `context` parameter is set, that value is prepended to any relative `PATH`s."
-  end
-
-
-  newparam(:root) do
-    desc "A file system path; all files loaded by Augeas are loaded underneath `root`."
-    defaultto "/"
-  end
-
-  newparam(:load_path) do
-    desc "Optional colon-separated list or array of directories; these directories are searched for schema definitions. The agent's `$libdir/augeas/lenses` path will always be added to support pluginsync."
-    defaultto ""
-  end
-
-  newparam(:force) do
-    desc "Optional command to force the augeas type to execute even if it thinks changes
-    will not be made. This does not override the `onlyif` parameter."
-
-    defaultto false
-  end
-
-  newparam(:type_check) do
-    desc "Whether augeas should perform typechecking."
-    newvalues(:true, :false)
-
-    defaultto :false
-  end
-
-  newparam(:lens) do
-    desc "Use a specific lens, such as `Hosts.lns`. When this parameter is set, you
-      must also set the `incl` parameter to indicate which file to load.
-      The Augeas documentation includes [a list of available lenses](http://augeas.net/stock_lenses.html)."
-  end
-
-  newparam(:incl) do
-    desc "Load only a specific file, such as `/etc/hosts`. This can greatly speed
-      up the execution the resource. When this parameter is set, you must also
-      set the `lens` parameter to indicate which lens to use."
-  end
-
-  validate do
-    has_lens = !self[:lens].nil?
-    has_incl = !self[:incl].nil?
-    self.fail _("You must specify both the lens and incl parameters, or neither.") if has_lens != has_incl
-  end
-
-  newparam(:show_diff, :boolean => true, :parent => Puppet::Parameter::Boolean) do
-    desc "Whether to display differences when the file changes, defaulting to
-        true.  This parameter is useful for files that may contain passwords or
-        other secret data, which might otherwise be included in Puppet reports or
-        other insecure outputs.  If the global `show_diff` setting
-        is false, then no diffs will be shown even if this parameter is true."
-
-    defaultto :true
-  end
-
-  # This is the actual meat of the code. It forces
-  # augeas to be run and fails or not based on the augeas return
-  # code.
-  newproperty(:returns) do |property|
-    include Puppet::Util
-    desc "The expected return code from the augeas command. Should not be set."
-
-    defaultto 0
-
-    # Make output a bit prettier
-    def change_to_s(currentvalue, newvalue)
-      _("executed successfully")
-    end
-
-    # if the onlyif resource is provided, then the value is parsed.
-    # a return value of 0 will stop execution because it matches the
-    # default value.
-    def retrieve
-      if @resource.provider.need_to_run?()
-        :need_to_run
-      else
-        0
-      end
-    end
-
-    # Actually execute the command.
-    def sync
-      @resource.provider.execute_changes
-    end
-  end
-
-end

data/lib/puppet/type/computer.rb

@@ -1,66 +0,0 @@
-Puppet::Type.newtype(:computer) do
-
-  @doc = "Computer object management using DirectoryService
-    on OS X.
-
-    Note that these are distinctly different kinds of objects to 'hosts',
-    as they require a MAC address and can have all sorts of policy attached to
-    them.
-
-    This provider only manages Computer objects in the local directory service
-    domain, not in remote directories.
-
-    If you wish to manage `/etc/hosts` file on Mac OS X, then simply use the host
-    type as per other platforms.
-
-    This type primarily exists to create localhost Computer objects that MCX
-    policy can then be attached to.
-
-    **Autorequires:** If Puppet is managing the plist file representing a
-    Computer object (located at `/var/db/dslocal/nodes/Default/computers/{name}.plist`),
-    the Computer resource will autorequire it."
-
-  # ensurable
-
-  # We autorequire the computer object in case it is being managed at the
-  # file level by Puppet.
-
-  autorequire(:file) do
-    if self[:name]
-      "/var/db/dslocal/nodes/Default/computers/#{self[:name]}.plist"
-    else
-      nil
-    end
-  end
-
-  newproperty(:ensure, :parent => Puppet::Property::Ensure) do
-    desc "Control the existences of this computer record. Set this attribute to
-      `present` to ensure the computer record exists.  Set it to `absent`
-      to delete any computer records with this name"
-    newvalue(:present) do
-      provider.create
-    end
-
-    newvalue(:absent) do
-      provider.delete
-    end
-  end
-
-  newparam(:name) do
-    desc "The authoritative 'short' name of the computer record."
-    isnamevar
-  end
-
-  newparam(:realname) do
-    desc "The 'long' name of the computer record."
-  end
-
-  newproperty(:en_address) do
-    desc "The MAC address of the primary network interface. Must match en0."
-  end
-
-  newproperty(:ip_address) do
-    desc "The IP Address of the Computer object."
-  end
-
-end

data/lib/puppet/type/cron.rb

@@ -1,480 +0,0 @@
-require 'etc'
-require 'facter'
-require 'puppet/util/filetype'
-
-Puppet::Type.newtype(:cron) do
-  @doc = <<-'EOT'
-    Installs and manages cron jobs.  Every cron resource created by Puppet
-    requires a command and at least one periodic attribute (hour, minute,
-    month, monthday, weekday, or special).  While the name of the cron job is
-    not part of the actual job, the name is stored in a comment beginning with
-    `# Puppet Name: `. These comments are used to match crontab entries created
-    by Puppet with cron resources.
-
-    If an existing crontab entry happens to match the scheduling and command of a
-    cron resource that has never been synced, Puppet will defer to the existing
-    crontab entry and will not create a new entry tagged with the `# Puppet Name: `
-    comment.
-
-    Example:
-
-        cron { 'logrotate':
-          command => '/usr/sbin/logrotate',
-          user    => 'root',
-          hour    => 2,
-          minute  => 0,
-        }
-
-    Note that all periodic attributes can be specified as an array of values:
-
-        cron { 'logrotate':
-          command => '/usr/sbin/logrotate',
-          user    => 'root',
-          hour    => [2, 4],
-        }
-
-    ...or using ranges or the step syntax `*/2` (although there's no guarantee
-    that your `cron` daemon supports these):
-
-        cron { 'logrotate':
-          command => '/usr/sbin/logrotate',
-          user    => 'root',
-          hour    => ['2-4'],
-          minute  => '*/10',
-        }
-
-    An important note: _the Cron type will not reset parameters that are
-    removed from a manifest_. For example, removing a `minute => 10` parameter
-    will not reset the minute component of the associated cronjob to `*`.
-    These changes must be expressed by setting the parameter to
-    `minute => absent` because Puppet only manages parameters that are out of
-    sync with manifest entries.
-
-    **Autorequires:** If Puppet is managing the user account specified by the
-    `user` property of a cron resource, then the cron resource will autorequire
-    that user.
-  EOT
-  ensurable
-
-  # A base class for all of the Cron parameters, since they all have
-  # similar argument checking going on.
-  class CronParam < Puppet::Property
-    class << self
-      attr_accessor :boundaries, :default
-    end
-
-    # We have to override the parent method, because we consume the entire
-    # "should" array
-    def insync?(is)
-      self.is_to_s(is) == self.should_to_s
-    end
-
-    # A method used to do parameter input handling.  Converts integers
-    # in string form to actual integers, and returns the value if it's
-    # an integer or false if it's just a normal string.
-    def numfix(num)
-      if num =~ /^\d+$/
-        return num.to_i
-      elsif num.is_a?(Integer)
-        return num
-      else
-        return false
-      end
-    end
-
-    # Verify that a number is within the specified limits.  Return the
-    # number if it is, or false if it is not.
-    def limitcheck(num, lower, upper)
-      (num >= lower and num <= upper) && num
-    end
-
-    # Verify that a value falls within the specified array.  Does case
-    # insensitive matching, and supports matching either the entire word
-    # or the first three letters of the word.
-    def alphacheck(value, ary)
-      tmp = value.downcase
-
-      # If they specified a shortened version of the name, then see
-      # if we can lengthen it (e.g., mon => monday).
-      if tmp.length == 3
-        ary.each_with_index { |name, index|
-          if tmp.casecmp(name[0..2]).zero?
-            return index
-          end
-        }
-      else
-        return ary.index(tmp) if ary.include?(tmp)
-      end
-
-      false
-    end
-
-    def should_to_s(value = @should)
-      if value
-        if value.is_a?(Array) && (name == :command || value[0].is_a?(Symbol))
-          value = value[0]
-        end
-        super(value)
-      else
-        nil
-      end
-    end
-
-    def is_to_s(value = @is)
-      if value
-        if value.is_a?(Array) && (name == :command || value[0].is_a?(Symbol))
-          value = value[0]
-        end
-        super(value)
-      else
-        nil
-      end
-    end
-
-    def should
-      if @should and @should[0] == :absent
-        :absent
-      else
-        @should
-      end
-    end
-
-    def should=(ary)
-      super
-      @should.flatten!
-    end
-
-    # The method that does all of the actual parameter value
-    # checking; called by all of the +param<name>=+ methods.
-    # Requires the value, type, and bounds, and optionally supports
-    # a boolean of whether to do alpha checking, and if so requires
-    # the ary against which to do the checking.
-    munge do |value|
-      # Support 'absent' as a value, so that they can remove
-      # a value
-      if value == "absent" or value == :absent
-        return :absent
-      end
-
-      # Allow the */2 syntax
-      if value =~ /^\*\/[0-9]+$/
-        return value
-      end
-
-      # Allow ranges
-      if value =~ /^[0-9]+-[0-9]+$/
-        return value
-      end
-
-      # Allow ranges + */2
-      if value =~ /^[0-9]+-[0-9]+\/[0-9]+$/
-        return value
-      end
-
-      if value == "*"
-        return :absent
-      end
-
-      return value unless self.class.boundaries
-      lower, upper = self.class.boundaries
-      retval = nil
-      if num = numfix(value)
-        retval = limitcheck(num, lower, upper)
-      elsif respond_to?(:alpha)
-        # If it has an alpha method defined, then we check
-        # to see if our value is in that list and if so we turn
-        # it into a number
-        retval = alphacheck(value, alpha)
-      end
-
-      if retval
-        return retval.to_s
-      else
-        self.fail _("%{value} is not a valid %{name}") % { value: value, name: self.class.name }
-      end
-    end
-  end
-
-  # Somewhat uniquely, this property does not actually change anything -- it
-  # just calls +@resource.sync+, which writes out the whole cron tab for
-  # the user in question.  There is no real way to change individual cron
-  # jobs without rewriting the entire cron file.
-  #
-  # Note that this means that managing many cron jobs for a given user
-  # could currently result in multiple write sessions for that user.
-  newproperty(:command, :parent => CronParam) do
-    desc "The command to execute in the cron job.  The environment
-      provided to the command varies by local system rules, and it is
-      best to always provide a fully qualified command.  The user's
-      profile is not sourced when the command is run, so if the
-      user's environment is desired it should be sourced manually.
-
-      All cron parameters support `absent` as a value; this will
-      remove any existing values for that field."
-
-    def retrieve
-      return_value = super
-      return_value = return_value[0] if return_value && return_value.is_a?(Array)
-
-      return_value
-    end
-
-    def should
-      if @should
-        if @should.is_a? Array
-          @should[0]
-        else
-          devfail "command is not an array"
-        end
-      else
-        nil
-      end
-    end
-
-    def munge(value)
-      value.strip
-    end
-  end
-
-  newproperty(:special) do
-    desc "A special value such as 'reboot' or 'annually'.
-       Only available on supported systems such as Vixie Cron.
-       Overrides more specific time of day/week settings.
-       Set to 'absent' to make puppet revert to a plain numeric schedule."
-
-    def specials
-      %w{reboot yearly annually monthly weekly daily midnight hourly absent} +
-        [ :absent ]
-    end
-
-    validate do |value|
-      raise ArgumentError, _("Invalid special schedule %{value}") % { value: value.inspect } unless specials.include?(value)
-    end
-
-    def munge(value)
-      # Support value absent so that a schedule can be
-      # forced to change to numeric.
-      if value == "absent" or value == :absent
-        return :absent
-      end
-      value
-    end
-  end
-
-  newproperty(:minute, :parent => CronParam) do
-    self.boundaries = [0, 59]
-    desc "The minute at which to run the cron job.
-      Optional; if specified, must be between 0 and 59, inclusive."
-  end
-
-  newproperty(:hour, :parent => CronParam) do
-    self.boundaries = [0, 23]
-    desc "The hour at which to run the cron job. Optional;
-      if specified, must be between 0 and 23, inclusive."
-  end
-
-  newproperty(:weekday, :parent => CronParam) do
-    def alpha
-      %w{sunday monday tuesday wednesday thursday friday saturday}
-    end
-    self.boundaries = [0, 7]
-    desc "The weekday on which to run the command. Optional; if specified,
-      must be either:
-
-      -   A number between 0 and 7, inclusive, with 0 or 7 being Sunday
-      -   The name of the day, such as 'Tuesday'."
-  end
-
-  newproperty(:month, :parent => CronParam) do
-    def alpha
-      # The ___placeholder accounts for the fact that month is unique among
-      # "nameable" crontab entries in that it does not use 0-based indexing.
-      # Padding the array with a placeholder introduces the appropriate shift
-      # in indices.
-      %w{___placeholder january february march april may june july
-        august september october november december}
-    end
-    self.boundaries = [1, 12]
-    desc "The month of the year. Optional; if specified,
-      must be either:
-
-      -   A number between 1 and 12, inclusive, with 1 being January
-      -   The name of the month, such as 'December'."
-  end
-
-  newproperty(:monthday, :parent => CronParam) do
-    self.boundaries = [1, 31]
-    desc "The day of the month on which to run the
-      command.  Optional; if specified, must be between 1 and 31."
-  end
-
-  newproperty(:environment) do
-    desc "Any environment settings associated with this cron job.  They
-      will be stored between the header and the job in the crontab.  There
-      can be no guarantees that other, earlier settings will not also
-      affect a given cron job.
-
-
-      Also, Puppet cannot automatically determine whether an existing,
-      unmanaged environment setting is associated with a given cron
-      job.  If you already have cron jobs with environment settings,
-      then Puppet will keep those settings in the same place in the file,
-      but will not associate them with a specific job.
-
-      Settings should be specified exactly as they should appear in
-      the crontab, like `PATH=/bin:/usr/bin:/usr/sbin`."
-
-    validate do |value|
-      unless value =~ /^\s*(\w+)\s*=\s*(.*)\s*$/ or value == :absent or value == "absent"
-        raise ArgumentError, _("Invalid environment setting %{value}") % { value: value.inspect }
-      end
-    end
-
-    def insync?(is)
-      if is.is_a? Array
-        return is.sort == @should.sort
-      else
-        return is == @should
-      end
-    end
-
-    def should
-      @should
-    end
-
-    def should_to_s(newvalue = @should)
-      if newvalue
-        newvalue.join(",")
-      else
-        nil
-      end
-    end
-  end
-
-  newparam(:name) do
-    desc "The symbolic name of the cron job.  This name
-      is used for human reference only and is generated automatically
-      for cron jobs found on the system.  This generally won't
-      matter, as Puppet will do its best to match existing cron jobs
-      against specified jobs (and Puppet adds a comment to cron jobs it adds),
-      but it is at least possible that converting from unmanaged jobs to
-      managed jobs might require manual intervention."
-
-    isnamevar
-  end
-
-  newproperty(:user) do
-    desc "The user who owns the cron job.  This user must
-      be allowed to run cron jobs, which is not currently checked by
-      Puppet.
-
-      This property defaults to the user running Puppet or `root`.
-
-      The default crontab provider executes the system `crontab` using
-      the user account specified by this property."
-
-    defaultto {
-      if not provider.is_a?(@resource.class.provider(:crontab))
-        struct = Etc.getpwuid(Process.uid)
-        struct.respond_to?(:name) && struct.name or 'root'
-      end
-    }
-  end
-
-  # Autorequire the owner of the crontab entry.
-  autorequire(:user) do
-    self[:user]
-  end
-
-  newproperty(:target) do
-    desc "The name of the crontab file in which the cron job should be stored.
-
-      This property defaults to the value of the `user` property if set, the
-      user running Puppet or `root`.
-
-      For the default crontab provider, this property is functionally
-      equivalent to the `user` property and should be avoided. In particular,
-      setting both `user` and `target` to different values will result in
-      undefined behavior."
-
-    defaultto {
-      if provider.is_a?(@resource.class.provider(:crontab))
-        if val = @resource.should(:user)
-          val
-        else
-          struct = Etc.getpwuid(Process.uid)
-          struct.respond_to?(:name) && struct.name or 'root'
-        end
-      elsif provider.class.ancestors.include?(Puppet::Provider::ParsedFile)
-        provider.class.default_target
-      else
-        nil
-      end
-    }
-  end
-
-  validate do
-    return true unless self[:special]
-    return true if self[:special] == :absent
-    # there is a special schedule in @should, so we don't want to see
-    # any numeric should values
-    [ :minute, :hour, :weekday, :monthday, :month ].each do |field|
-      next unless self[field]
-      next if self[field] == :absent
-      raise ArgumentError, _("%{cron} cannot specify both a special schedule and a value for %{field}") % { cron: self.ref, field: field }
-    end
-  end
-
-  # We have to reorder things so that :provide is before :target
-
-  attr_accessor :uid
-
-  # Marks the resource as "being purged".
-  #
-  # @api public
-  #
-  # @note This overrides the Puppet::Type method in order to handle
-  #   an edge case that has so far been observed during testing only.
-  #   Without forcing the should-value for the user property to be
-  #   identical to the original cron file, purging from a fixture
-  #   will not work, because the user property defaults to the user
-  #   running the test. It is not clear whether this scenario can apply
-  #   during normal operation.
-  #
-  # @note Also, when not forcing the should-value for the target
-  #   property, unpurged file content (such as comments) can end up
-  #   being written to the default target (i.e. the current login name).
-  def purging
-    self[:target] = provider.target
-    self[:user] = provider.target
-    super
-  end
-
-  def value(name)
-    name = name.intern
-    ret = nil
-    if obj = @parameters[name]
-      ret = obj.should
-
-      ret ||= obj.retrieve
-
-      if ret == :absent
-        ret = nil
-      end
-    end
-
-    unless ret
-      case name
-      when :command
-      when :special
-        # nothing
-      else
-        #ret = (self.class.validproperty?(name).default || "*").to_s
-        ret = "*"
-      end
-    end
-
-    ret
-  end
-end
-