puppet 0.25.5 → 2.6.0

data/lib/puppet/type/port.rb

@@ -29,7 +29,7 @@
 #            # We actually want to return the whole array here, not just the first
 #            # value.
 #            def should
-#                if defined? @should
+#                if defined?(@should)
 #                    if @should[0] == :absent
 #                        return :absent
 #                    else
@@ -44,7 +44,7 @@
 #                valids = ["udp", "tcp", "ddp", :absent]
 #                unless valids.include? value
 #                    raise Puppet::Error,
-#                        "Protocols can be either 'udp' or 'tcp', not %s" % value
+#                        "Protocols can be either 'udp' or 'tcp', not #{value}"
 #                end
 #            end
 #        end
@@ -61,13 +61,13 @@
 #            desc 'Any aliases the port might have.  Multiple values must be
 #                specified as an array.  Note that this property is not the same as
 #                the "alias" metaparam; use this property to add aliases to a port
-#                in the services file, and "alias" to aliases for use in your Puppet 
+#                in the services file, and "alias" to aliases for use in your Puppet
 #                scripts.'
 #
 #            # We actually want to return the whole array here, not just the first
 #            # value.
 #            def should
-#                if defined? @should
+#                if defined?(@should)
 #                    if @should[0] == :absent
 #                        return :absent
 #                    else

data/lib/puppet/type/resources.rb

@@ -4,148 +4,132 @@
 require 'puppet'
 
 Puppet::Type.newtype(:resources) do
-    @doc = "This is a metatype that can manage other resource types.  Any
-        metaparams specified here will be passed on to any generated resources,
-        so you can purge umanaged resources but set ``noop`` to true so the
-        purging is only logged and does not actually happen."
+  @doc = "This is a metatype that can manage other resource types.  Any
+    metaparams specified here will be passed on to any generated resources,
+    so you can purge umanaged resources but set ``noop`` to true so the
+    purging is only logged and does not actually happen."
 
 
-    newparam(:name) do
-        desc "The name of the type to be managed."
+  newparam(:name) do
+    desc "The name of the type to be managed."
 
-        validate do |name|
-            unless Puppet::Type.type(name)
-                raise ArgumentError, "Could not find resource type '%s'" % name
-            end
-        end
-
-        munge { |v| v.to_s }
+    validate do |name|
+      raise ArgumentError, "Could not find resource type '#{name}'" unless Puppet::Type.type(name)
     end
 
-    newparam(:purge, :boolean => true) do
-        desc "Purge unmanaged resources.  This will delete any resource
-            that is not specified in your configuration
-            and is not required by any specified resources."
-
-        newvalues(:true, :false)
-
-        validate do |value|
-            if [:true, true, "true"].include?(value)
-                unless @resource.resource_type.respond_to?(:instances)
-                    raise ArgumentError, "Purging resources of type %s is not supported, since they cannot be queried from the system" % @resource[:name]
-                end
-                unless @resource.resource_type.validproperty?(:ensure)
-                    raise ArgumentError, "Purging is only supported on types that accept 'ensure'"
-                end
-            end
-        end
-    end
+    munge { |v| v.to_s }
+  end
 
-    newparam(:unless_system_user) do
-        desc "This keeps system users from being purged.  By default, it
-            does not purge users whose UIDs are less than or equal to 500, but you can specify
-            a different UID as the inclusive limit."
-
-        newvalues(:true, :false, /^\d+$/)
-
-        munge do |value|
-            case value
-            when /^\d+/
-                Integer(value)
-            when :true, true
-                500
-            when :false, false
-                false
-            when Integer; value
-            else
-                raise ArgumentError, "Invalid value %s" % value.inspect
-            end
-        end
+  newparam(:purge, :boolean => true) do
+    desc "Purge unmanaged resources.  This will delete any resource
+      that is not specified in your configuration
+      and is not required by any specified resources."
 
-        defaultto {
-            if @resource[:name] == "user"
-                500
-            else
-                nil
-            end
-        }
-    end
+    newvalues(:true, :false)
 
-    def check(resource)
-        unless defined? @checkmethod
-            @checkmethod = "%s_check" % self[:name]
-        end
-        unless defined? @hascheck
-            @hascheck = respond_to?(@checkmethod)
-        end
-        if @hascheck
-            return send(@checkmethod, resource)
-        else
-            return true
+    validate do |value|
+      if [:true, true, "true"].include?(value)
+        unless @resource.resource_type.respond_to?(:instances)
+          raise ArgumentError, "Purging resources of type #{@resource[:name]} is not supported, since they cannot be queried from the system"
         end
+        raise ArgumentError, "Purging is only supported on types that accept 'ensure'" unless @resource.resource_type.validproperty?(:ensure)
+      end
     end
-
-    def able_to_ensure_absent?(resource)
-        begin
-            resource[:ensure] = :absent
-        rescue ArgumentError, Puppet::Error => detail
-            err "The 'ensure' attribute on #{self[:name]} resources does not accept 'absent' as a value"
-            false
-        end
+  end
+
+  newparam(:unless_system_user) do
+    desc "This keeps system users from being purged.  By default, it
+      does not purge users whose UIDs are less than or equal to 500, but you can specify
+      a different UID as the inclusive limit."
+
+    newvalues(:true, :false, /^\d+$/)
+
+    munge do |value|
+      case value
+      when /^\d+/
+        Integer(value)
+      when :true, true
+        500
+      when :false, false
+        false
+      when Integer; value
+      else
+        raise ArgumentError, "Invalid value #{value.inspect}"
+      end
     end
 
-    # Generate any new resources we need to manage.  This is pretty hackish
-    # right now, because it only supports purging.
-    def generate
-        return [] unless self.purge?
-        resource_type.instances.
-            reject { |r| catalog.resources.include? r.ref }.
-            select { |r| check(r) }.
-            select { |r| r.class.validproperty?(:ensure) }.
-            select { |r| able_to_ensure_absent?(r) }.
-            each { |resource|
-              @parameters.each do |name, param|
-                  resource[name] = param.value if param.metaparam?
-              end
-
-              # Mark that we're purging, so transactions can handle relationships
-              # correctly
-              resource.purging
-          }
+    defaultto {
+      if @resource[:name] == "user"
+        500
+      else
+        nil
+      end
+    }
+  end
+
+  def check(resource)
+    @checkmethod ||= "#{self[:name]}_check"
+    @hascheck ||= respond_to?(@checkmethod)
+    if @hascheck
+      return send(@checkmethod, resource)
+    else
+      return true
     end
-
-    def resource_type
-        unless defined? @resource_type
-            unless type = Puppet::Type.type(self[:name])
-                raise Puppet::DevError, "Could not find resource type"
-            end
-            @resource_type = type
+  end
+
+  def able_to_ensure_absent?(resource)
+      resource[:ensure] = :absent
+  rescue ArgumentError, Puppet::Error => detail
+      err "The 'ensure' attribute on #{self[:name]} resources does not accept 'absent' as a value"
+      false
+  end
+
+  # Generate any new resources we need to manage.  This is pretty hackish
+  # right now, because it only supports purging.
+  def generate
+    return [] unless self.purge?
+    resource_type.instances.
+      reject { |r| catalog.resource_refs.include? r.ref }.
+      select { |r| check(r) }.
+      select { |r| r.class.validproperty?(:ensure) }.
+      select { |r| able_to_ensure_absent?(r) }.
+      each { |resource|
+        @parameters.each do |name, param|
+          resource[name] = param.value if param.metaparam?
         end
-        @resource_type
+
+        # Mark that we're purging, so transactions can handle relationships
+        # correctly
+        resource.purging
+      }
+  end
+
+  def resource_type
+    unless defined?(@resource_type)
+      unless type = Puppet::Type.type(self[:name])
+        raise Puppet::DevError, "Could not find resource type"
+      end
+      @resource_type = type
     end
+    @resource_type
+  end
 
-    # Make sure we don't purge users below a certain uid, if the check
-    # is enabled.
-    def user_check(resource)
-        return true unless self[:name] == "user"
-        return true unless self[:unless_system_user]
+  # Make sure we don't purge users below a certain uid, if the check
+  # is enabled.
+  def user_check(resource)
+    return true unless self[:name] == "user"
+    return true unless self[:unless_system_user]
 
-        resource[:check] = :uid
-        current_values = resource.retrieve
+    resource[:audit] = :uid
+    current_values = resource.retrieve_resource
 
-        if system_users().include?(resource[:name])
-            return false
-        end
+    return false if system_users.include?(resource[:name])
 
-        if current_values[resource.property(:uid)] <= self[:unless_system_user]
-            return false
-        else
-            return true
-        end
-    end
+    current_values[resource.property(:uid)] > self[:unless_system_user]
+  end
 
-    def system_users
-        %w{root nobody bin noaccess daemon sys}
-    end
+  def system_users
+    %w{root nobody bin noaccess daemon sys}
+  end
 end
 

data/lib/puppet/type/schedule.rb

@@ -1,361 +1,352 @@
 module Puppet
-    newtype(:schedule) do
-        @doc = "Defined schedules for Puppet.  The important thing to understand
-            about how schedules are currently implemented in Puppet is that they
-            can only be used to stop a resource from being applied, they never
-            guarantee that it is applied.
-
-            Every time Puppet applies its configuration, it will collect the
-            list of resources whose schedule does not eliminate them from
-            running right then, but there is currently no system in place to
-            guarantee that a given resource runs at a given time.  If you
-            specify a very  restrictive schedule and Puppet happens to run at a
-            time within that schedule, then the resources will get applied;
-            otherwise, that work may never get done.
-
-            Thus, it behooves you to use wider scheduling (e.g., over a couple of
-            hours) combined with periods and repetitions.  For instance, if you
-            wanted to restrict certain resources to only running once, between
-            the hours of two and 4 AM, then you would use this schedule::
-
-                schedule { maint:
-                    range => \"2 - 4\",
-                    period => daily,
-                    repeat => 1
-                }
-
-            With this schedule, the first time that Puppet runs between 2 and 4 AM,
-            all resources with this schedule will get applied, but they won't
-            get applied again between 2 and 4 because they will have already
-            run once that day, and they won't get applied outside that schedule
-            because they will be outside the scheduled range.
-
-            Puppet automatically creates a schedule for each valid period with the
-            same name as that period (e.g., hourly and daily).  Additionally,
-            a schedule named *puppet* is created and used as the default,
-            with the following attributes::
-
-                schedule { puppet:
-                    period => hourly,
-                    repeat => 2
-                }
-
-            This will cause resources to be applied every 30 minutes by default.
-            "
-
-        newparam(:name) do
-            desc "The name of the schedule.  This name is used to retrieve the
-                schedule when assigning it to an object::
-
-                    schedule { daily:
-                        period => daily,
-                        range => [2, 4]
-                    }
-
-                    exec { \"/usr/bin/apt-get update\":
-                        schedule => daily
-                    }
-
-                "
-            isnamevar
-        end
+  newtype(:schedule) do
+    @doc = "Defined schedules for Puppet.  The important thing to understand
+      about how schedules are currently implemented in Puppet is that they
+      can only be used to stop a resource from being applied, they never
+      guarantee that it is applied.
+
+      Every time Puppet applies its configuration, it will collect the
+      list of resources whose schedule does not eliminate them from
+      running right then, but there is currently no system in place to
+      guarantee that a given resource runs at a given time.  If you
+      specify a very  restrictive schedule and Puppet happens to run at a
+      time within that schedule, then the resources will get applied;
+      otherwise, that work may never get done.
+
+      Thus, it behooves you to use wider scheduling (e.g., over a couple of
+      hours) combined with periods and repetitions.  For instance, if you
+      wanted to restrict certain resources to only running once, between
+      the hours of two and 4 AM, then you would use this schedule::
+
+        schedule { maint:
+          range => \"2 - 4\",
+          period => daily,
+          repeat => 1
+        }
+
+      With this schedule, the first time that Puppet runs between 2 and 4 AM,
+      all resources with this schedule will get applied, but they won't
+      get applied again between 2 and 4 because they will have already
+      run once that day, and they won't get applied outside that schedule
+      because they will be outside the scheduled range.
+
+      Puppet automatically creates a schedule for each valid period with the
+      same name as that period (e.g., hourly and daily).  Additionally,
+      a schedule named *puppet* is created and used as the default,
+      with the following attributes::
+
+        schedule { puppet:
+          period => hourly,
+          repeat => 2
+        }
+
+      This will cause resources to be applied every 30 minutes by default.
+      "
+
+    newparam(:name) do
+      desc "The name of the schedule.  This name is used to retrieve the
+        schedule when assigning it to an object::
+
+          schedule { daily:
+            period => daily,
+            range => [2, 4]
+          }
+
+          exec { \"/usr/bin/apt-get update\":
+            schedule => daily
+          }
+
+        "
+      isnamevar
+    end
 
-        newparam(:range) do
-            desc "The earliest and latest that a resource can be applied.  This
-                is always a range within a 24 hour period, and hours must be
-                specified in numbers between 0 and 23, inclusive.  Minutes and
-                seconds can be provided, using the normal colon as a separator.
-                For instance::
-
-                    schedule { maintenance:
-                        range => \"1:30 - 4:30\"
-                    }
-
-                This is mostly useful for restricting certain resources to being
-                applied in maintenance windows or during off-peak hours."
-
-            # This is lame; properties all use arrays as values, but parameters don't.
-            # That's going to hurt eventually.
-            validate do |values|
-                values = [values] unless values.is_a?(Array)
-                values.each { |value|
-                    unless  value.is_a?(String) and
-                            value =~ /\d+(:\d+){0,2}\s*-\s*\d+(:\d+){0,2}/
-                        self.fail "Invalid range value '%s'" % value
-                    end
-                }
+    newparam(:range) do
+      desc "The earliest and latest that a resource can be applied.  This
+        is always a range within a 24 hour period, and hours must be
+        specified in numbers between 0 and 23, inclusive.  Minutes and
+        seconds can be provided, using the normal colon as a separator.
+        For instance::
+
+          schedule { maintenance:
+            range => \"1:30 - 4:30\"
+          }
+
+        This is mostly useful for restricting certain resources to being
+        applied in maintenance windows or during off-peak hours."
+
+      # This is lame; properties all use arrays as values, but parameters don't.
+      # That's going to hurt eventually.
+      validate do |values|
+        values = [values] unless values.is_a?(Array)
+        values.each { |value|
+          unless  value.is_a?(String) and
+              value =~ /\d+(:\d+){0,2}\s*-\s*\d+(:\d+){0,2}/
+            self.fail "Invalid range value '#{value}'"
+          end
+        }
+      end
+
+      munge do |values|
+        values = [values] unless values.is_a?(Array)
+        ret = []
+
+        values.each { |value|
+          range = []
+          # Split each range value into a hour, minute, second triad
+          value.split(/\s*-\s*/).each { |val|
+            # Add the values as an array.
+            range << val.split(":").collect { |n| n.to_i }
+          }
+
+          self.fail "Invalid range #{value}" if range.length != 2
+
+          # Make sure the hours are valid
+          [range[0][0], range[1][0]].each do |n|
+            raise ArgumentError, "Invalid hour '#{n}'" if n < 0 or n > 23
+          end
+
+          [range[0][1], range[1][1]].each do |n|
+            raise ArgumentError, "Invalid minute '#{n}'" if n and (n < 0 or n > 59)
+          end
+          if range[0][0] > range[1][0]
+            self.fail(("Invalid range #{value}; ") +
+              "ranges cannot span days."
+            )
+          end
+          ret << range
+        }
+
+        # Now our array of arrays
+        ret
+      end
+
+      def match?(previous, now)
+        # The lowest-level array is of the hour, minute, second triad
+        # then it's an array of two of those, to present the limits
+        # then it's array of those ranges
+        @value = [@value] unless @value[0][0].is_a?(Array)
+
+        @value.each do |value|
+          limits = value.collect do |range|
+            ary = [now.year, now.month, now.day, range[0]]
+            if range[1]
+              ary << range[1]
+            else
+              ary << now.min
             end
 
-            munge do |values|
-                values = [values] unless values.is_a?(Array)
-                ret = []
-
-                values.each { |value|
-                    range = []
-                    # Split each range value into a hour, minute, second triad
-                    value.split(/\s*-\s*/).each { |val|
-                        # Add the values as an array.
-                        range << val.split(":").collect { |n| n.to_i }
-                    }
-
-                    if range.length != 2
-                        self.fail "Invalid range %s" % value
-                    end
-
-                    # Make sure the hours are valid
-                    [range[0][0], range[1][0]].each do |n|
-                        if n < 0 or n > 23
-                            raise ArgumentError, "Invalid hour '%s'" % n
-                        end
-                    end
-
-                    [range[0][1], range[1][1]].each do |n|
-                        if n and (n < 0 or n > 59)
-                            raise ArgumentError, "Invalid minute '%s'" % n
-                        end
-                    end
-                    if range[0][0] > range[1][0]
-                        self.fail(("Invalid range %s; " % value) +
-                            "ranges cannot span days."
-                        )
-                    end
-                    ret << range
-                }
-
-                # Now our array of arrays
-                ret
+            if range[2]
+              ary << range[2]
+            else
+              ary << now.sec
             end
 
-            def match?(previous, now)
-                # The lowest-level array is of the hour, minute, second triad
-                # then it's an array of two of those, to present the limits
-                # then it's array of those ranges
-                unless @value[0][0].is_a?(Array)
-                    @value = [@value]
-                end
-
-                @value.each do |value|
-                    limits = value.collect do |range|
-                        ary = [now.year, now.month, now.day, range[0]]
-                        if range[1]
-                            ary << range[1]
-                        else
-                            ary << now.min
-                        end
-
-                        if range[2]
-                            ary << range[2]
-                        else
-                            ary << now.sec
-                        end
-
-                        time = Time.local(*ary)
-
-                        unless time.hour == range[0]
-                            self.devfail(
-                                "Incorrectly converted time: %s: %s vs %s" %
-                                    [time, time.hour, range[0]]
-                            )
-                        end
-
-                        time
-                    end
-
-                    unless limits[0] < limits[1]
-                        self.info(
-                        "Assuming upper limit should be that time the next day"
-                        )
-
-                        ary = limits[1].to_a
-                        ary[3] += 1
-                        limits[1] = Time.local(*ary)
-
-                        #self.devfail("Lower limit is above higher limit: %s" %
-                        #    limits.inspect
-                        #)
-                    end
-
-                    #self.info limits.inspect
-                    #self.notice now
-                    return now.between?(*limits)
-                end
-
-                # Else, return false, since our current time isn't between
-                # any valid times
-                return false
+            time = Time.local(*ary)
+
+            unless time.hour == range[0]
+              self.devfail(
+                "Incorrectly converted time: #{time}: #{time.hour} vs #{range[0]}"
+              )
             end
-        end
 
-        newparam(:periodmatch) do
-            desc "Whether periods should be matched by number (e.g., the two times
-                are in the same hour) or by distance (e.g., the two times are
-                60 minutes apart)."
+            time
+          end
 
-            newvalues(:number, :distance)
+          unless limits[0] < limits[1]
+            self.info(
+            "Assuming upper limit should be that time the next day"
+            )
 
-            defaultto :distance
-        end
+            ary = limits[1].to_a
+            ary[3] += 1
+            limits[1] = Time.local(*ary)
 
-        newparam(:period) do
-            desc "The period of repetition for a resource.  Choose from among
-                a fixed list of *hourly*, *daily*, *weekly*, and *monthly*.
-                The default is for a resource to get applied every time that
-                Puppet runs, whatever that period is.
-
-                Note that the period defines how often a given resource will get
-                applied but not when; if you would like to restrict the hours
-                that a given resource can be applied (e.g., only at night during
-                a maintenance window) then use the ``range`` attribute.
-
-                If the provided periods are not sufficient, you can provide a
-                value to the *repeat* attribute, which will cause Puppet to
-                schedule the affected resources evenly in the period the
-                specified number of times.  Take this schedule::
-
-                    schedule { veryoften:
-                        period => hourly,
-                        repeat => 6
-                    }
-
-                This can cause Puppet to apply that resource up to every 10 minutes.
-
-                At the moment, Puppet cannot guarantee that level of
-                repetition; that is, it can run up to every 10 minutes, but
-                internal factors might prevent it from actually running that
-                often (e.g., long-running Puppet runs will squash conflictingly
-                scheduled runs).
-
-                See the ``periodmatch`` attribute for tuning whether to match
-                times by their distance apart or by their specific value."
-
-            newvalues(:hourly, :daily, :weekly, :monthly, :never)
-
-            @@scale = {
-                :hourly => 3600,
-                :daily => 86400,
-                :weekly => 604800,
-                :monthly => 2592000
-            }
-            @@methods = {
-                :hourly => :hour,
-                :daily => :day,
-                :monthly => :month,
-                :weekly => proc do |prev, now|
-                    # Run the resource if the previous day was after this weekday (e.g., prev is wed, current is tue)
-                    # or if it's been more than a week since we ran
-                    prev.wday > now.wday or (now - prev) > (24 * 3600 * 7)
-                end
-            }
-
-            def match?(previous, now)
-                return false if value == :never
-
-                value = self.value
-                case @resource[:periodmatch]
-                when :number
-                    method = @@methods[value]
-                    if method.is_a?(Proc)
-                        return method.call(previous, now)
-                    else
-                        # We negate it, because if they're equal we don't run
-                        return now.send(method) != previous.send(method)
-                    end
-                when :distance
-                    scale = @@scale[value]
-
-                    # If the number of seconds between the two times is greater
-                    # than the unit of time, we match.  We divide the scale
-                    # by the repeat, so that we'll repeat that often within
-                    # the scale.
-                    diff = (now.to_i - previous.to_i)
-                    comparison = (scale / @resource[:repeat])
-
-                    return (now.to_i - previous.to_i) >= (scale / @resource[:repeat])
-                end
-            end
+            #self.devfail("Lower limit is above higher limit: %s" %
+            #    limits.inspect
+            #)
+          end
+
+          #self.info limits.inspect
+          #self.notice now
+          return now.between?(*limits)
         end
 
-        newparam(:repeat) do
-            desc "How often the application gets repeated in a given period.
-                Defaults to 1. Must be an integer."
+        # Else, return false, since our current time isn't between
+        # any valid times
+        false
+      end
+    end
 
-            defaultto 1
+    newparam(:periodmatch) do
+      desc "Whether periods should be matched by number (e.g., the two times
+        are in the same hour) or by distance (e.g., the two times are
+        60 minutes apart)."
 
-            validate do |value|
-                unless value.is_a?(Integer) or value =~ /^\d+$/
-                    raise Puppet::Error,
-                        "Repeat must be a number"
-                end
+      newvalues(:number, :distance)
 
-                # This implicitly assumes that 'periodmatch' is distance -- that
-                # is, if there's no value, we assume it's a valid value.
-                return unless @resource[:periodmatch]
+      defaultto :distance
+    end
 
-                if value != 1 and @resource[:periodmatch] != :distance
-                    raise Puppet::Error,
-                        "Repeat must be 1 unless periodmatch is 'distance', not '%s'" %
-                            @resource[:periodmatch]
-                end
-            end
+    newparam(:period) do
+      desc "The period of repetition for a resource.  Choose from among
+        a fixed list of *hourly*, *daily*, *weekly*, and *monthly*.
+        The default is for a resource to get applied every time that
+        Puppet runs, whatever that period is.
+
+        Note that the period defines how often a given resource will get
+        applied but not when; if you would like to restrict the hours
+        that a given resource can be applied (e.g., only at night during
+        a maintenance window) then use the ``range`` attribute.
+
+        If the provided periods are not sufficient, you can provide a
+        value to the *repeat* attribute, which will cause Puppet to
+        schedule the affected resources evenly in the period the
+        specified number of times.  Take this schedule::
+
+          schedule { veryoften:
+            period => hourly,
+            repeat => 6
+          }
+
+        This can cause Puppet to apply that resource up to every 10 minutes.
+
+        At the moment, Puppet cannot guarantee that level of
+        repetition; that is, it can run up to every 10 minutes, but
+        internal factors might prevent it from actually running that
+        often (e.g., long-running Puppet runs will squash conflictingly scheduled runs).
+
+        See the ``periodmatch`` attribute for tuning whether to match
+        times by their distance apart or by their specific value."
+
+      newvalues(:hourly, :daily, :weekly, :monthly, :never)
+
+      @@scale = {
+        :hourly => 3600,
+        :daily => 86400,
+        :weekly => 604800,
+        :monthly => 2592000
+      }
+      @@methods = {
+        :hourly => :hour,
+        :daily => :day,
+        :monthly => :month,
+        :weekly => proc do |prev, now|
+          # Run the resource if the previous day was after this weekday (e.g., prev is wed, current is tue)
+          # or if it's been more than a week since we ran
+          prev.wday > now.wday or (now - prev) > (24 * 3600 * 7)
+        end
+      }
+
+      def match?(previous, now)
+        return false if value == :never
+
+        value = self.value
+        case @resource[:periodmatch]
+        when :number
+          method = @@methods[value]
+          if method.is_a?(Proc)
+            return method.call(previous, now)
+          else
+            # We negate it, because if they're equal we don't run
+            return now.send(method) != previous.send(method)
+          end
+        when :distance
+          scale = @@scale[value]
+
+          # If the number of seconds between the two times is greater
+          # than the unit of time, we match.  We divide the scale
+          # by the repeat, so that we'll repeat that often within
+          # the scale.
+          diff = (now.to_i - previous.to_i)
+          comparison = (scale / @resource[:repeat])
+
+          return (now.to_i - previous.to_i) >= (scale / @resource[:repeat])
+        end
+      end
+    end
 
-            munge do |value|
-                unless value.is_a?(Integer)
-                    value = Integer(value)
-                end
+    newparam(:repeat) do
+      desc "How often the application gets repeated in a given period.
+        Defaults to 1. Must be an integer."
 
-                value
-            end
+      defaultto 1
 
-            def match?(previous, now)
-                true
-            end
+      validate do |value|
+        unless value.is_a?(Integer) or value =~ /^\d+$/
+          raise Puppet::Error,
+            "Repeat must be a number"
         end
 
-        def self.instances
-            []
+        # This implicitly assumes that 'periodmatch' is distance -- that
+        # is, if there's no value, we assume it's a valid value.
+        return unless @resource[:periodmatch]
+
+        if value != 1 and @resource[:periodmatch] != :distance
+          raise Puppet::Error,
+            "Repeat must be 1 unless periodmatch is 'distance', not '#{@resource[:periodmatch]}'"
         end
+      end
 
-        def self.mkdefaultschedules
-            result = []
-            Puppet.debug "Creating default schedules"
-            result << self.new(
-                :name => "puppet",
-                :period => :hourly,
-                :repeat => "2"
-            )
+      munge do |value|
+        value = Integer(value) unless value.is_a?(Integer)
 
-            # And then one for every period
-            @parameters.find { |p| p.name == :period }.value_collection.values.each { |value|
-                result << self.new(
-                    :name => value.to_s,
-                    :period => value
-                )
-            }
+        value
+      end
 
-            result
-        end
+      def match?(previous, now)
+        true
+      end
+    end
 
-        def match?(previous = nil, now = nil)
+    def self.instances
+      []
+    end
 
-            # If we've got a value, then convert it to a Time instance
-            if previous
-                previous = Time.at(previous)
-            end
+    def self.mkdefaultschedules
+      result = []
+      Puppet.debug "Creating default schedules"
 
-            now ||= Time.now
+            result << self.new(
+                
+        :name => "puppet",
+        :period => :hourly,
+        
+        :repeat => "2"
+      )
+
+      # And then one for every period
+      @parameters.find { |p| p.name == :period }.value_collection.values.each { |value|
+
+              result << self.new(
+                
+          :name => value.to_s,
+        
+          :period => value
+        )
+      }
+
+      result
+    end
 
-            # Pull them in order
-            self.class.allattrs.each { |param|
-                if @parameters.include?(param) and
-                    @parameters[param].respond_to?(:match?)
-                    return false unless @parameters[param].match?(previous, now)
-                end
-            }
+    def match?(previous = nil, now = nil)
 
-            # If we haven't returned false, then return true; in other words,
-            # any provided schedules need to all match
-            return true
+      # If we've got a value, then convert it to a Time instance
+      previous &&= Time.at(previous)
+
+      now ||= Time.now
+
+      # Pull them in order
+      self.class.allattrs.each { |param|
+        if @parameters.include?(param) and
+          @parameters[param].respond_to?(:match?)
+          return false unless @parameters[param].match?(previous, now)
         end
+      }
+
+      # If we haven't returned false, then return true; in other words,
+      # any provided schedules need to all match
+      true
     end
+  end
 end