bolt 0.20.0 → 0.20.2

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

@@ -0,0 +1,180 @@
+require 'puppet'
+require 'puppet/parameter/boolean'
+
+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 unmanaged 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."
+
+    validate do |name|
+      raise ArgumentError, _("Could not find resource type '%{name}'") % { name: name } unless Puppet::Type.type(name)
+    end
+
+    munge { |v| v.to_s }
+  end
+
+  newparam(:purge, :boolean => true, :parent => Puppet::Parameter::Boolean) do
+    desc "Whether to purge unmanaged resources.  When set to `true`, this will
+      delete any resource that is not specified in your configuration and is not
+      autorequired by any managed resources. **Note:** The `ssh_authorized_key`
+      resource type can't be purged this way; instead, see the `purge_ssh_keys`
+      attribute of the `user` type."
+
+    defaultto :false
+
+    validate do |value|
+      if munge(value)
+        unless @resource.resource_type.respond_to?(:instances)
+          raise ArgumentError, _("Purging resources of type %{res_type} is not supported, since they cannot be queried from the system") % { res_type: @resource[:name] }
+        end
+        raise ArgumentError, _("Purging is only supported on types that accept 'ensure'") unless @resource.resource_type.validproperty?(:ensure)
+      end
+    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 the minimum UID for the system (typically 500 or 1000), 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
+        @resource.class.system_users_max_uid
+      when :false, false
+        false
+      when Integer; value
+      else
+        raise ArgumentError, _("Invalid value %{value}") % { value: value.inspect }
+      end
+    end
+
+    defaultto {
+      if @resource[:name] == "user"
+        @resource.class.system_users_max_uid
+      else
+        nil
+      end
+    }
+  end
+
+  newparam(:unless_uid) do
+    desc 'This keeps specific uids or ranges of uids from being purged when purge is true.
+      Accepts integers, integer strings, and arrays of integers or integer strings.
+      To specify a range of uids, consider using the range() function from stdlib.'
+
+    munge do |value|
+      value = [value] unless value.is_a? Array
+      value.flatten.collect do |v|
+        case v
+          when Integer
+            v
+          when String
+            Integer(v)
+          else
+            raise ArgumentError, _("Invalid value %{value}.") % { value: v.inspect }
+        end
+      end
+    end
+  end
+
+  def check(resource)
+    @checkmethod ||= "#{self[:name]}_check"
+    @hascheck ||= respond_to?(@checkmethod)
+    if @hascheck
+      return send(@checkmethod, resource)
+    else
+      return true
+    end
+  end
+
+  def able_to_ensure_absent?(resource)
+      resource[:ensure] = :absent
+  rescue ArgumentError, Puppet::Error
+      err _("The 'ensure' attribute on %{name} resources does not accept 'absent' as a value") % { name: self[:name] }
+      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
+
+        # 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 with specific uids
+  def user_check(resource)
+    return true unless self[:name] == "user"
+    return true unless self[:unless_system_user]
+    resource[:audit] = :uid
+    current_values = resource.retrieve_resource
+    current_uid = current_values[resource.property(:uid)]
+    unless_uids = self[:unless_uid]
+
+    return false if system_users.include?(resource[:name])
+    return false if unless_uids && unless_uids.include?(current_uid)
+
+    current_uid > self[:unless_system_user]
+  end
+
+  def system_users
+    %w{root nobody bin noaccess daemon sys}
+  end
+
+  def self.system_users_max_uid
+    return @system_users_max_uid if @system_users_max_uid
+
+    # First try to read the minimum user id from login.defs
+    if Puppet::FileSystem.exist?('/etc/login.defs')
+      @system_users_max_uid = Puppet::FileSystem.each_line '/etc/login.defs' do |line|
+        break $1.to_i - 1 if line =~ /^\s*UID_MIN\s+(\d+)(\s*#.*)?$/
+      end
+    end
+
+    # Otherwise, use a sensible default based on the OS family
+    @system_users_max_uid ||= case Facter.value(:osfamily)
+      when 'OpenBSD', 'FreeBSD'
+        999
+      else
+        499
+    end
+
+    @system_users_max_uid
+  end
+
+  def self.reset_system_users_max_uid!
+    @system_users_max_uid = nil
+  end
+end

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

@@ -0,0 +1,17 @@
+#
+# Manage a router abstraction
+
+
+module Puppet
+  Type.newtype(:router) do
+    @doc = "Manages connected router."
+
+    newparam(:url) do
+      desc <<-EOT
+        An SSH or telnet URL at which to access the router, in the form
+        `ssh://user:pass:enable@host/` or `telnet://user:pass:enable@host/`.
+      EOT
+      isnamevar
+    end
+  end
+end

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

@@ -0,0 +1,481 @@
+module Puppet
+  Type.newtype(:schedule) do
+    @doc = <<-'EOT'
+      Define schedules for Puppet. Resources can be limited to a schedule by using the
+      [`schedule`](https://docs.puppetlabs.com/puppet/latest/reference/metaparameter.html#schedule)
+      metaparameter.
+
+      Currently, **schedules can only be used to stop a resource from being
+      applied;** they cannot cause a resource to be applied when it otherwise
+      wouldn't be, and they cannot accurately specify a time when a resource
+      should run.
+
+      Every time Puppet applies its configuration, it will apply the
+      set 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 is advisable to use wider scheduling (for example, 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 of the valid periods
+      with the same name as that period (such as 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.
+      EOT
+
+    apply_to_all
+
+    newparam(:name) do
+      desc <<-EOT
+        The name of the schedule.  This name is used when assigning the schedule
+        to a resource with the `schedule` metaparameter:
+
+            schedule { 'everyday':
+              period => daily,
+              range  => '2 - 4',
+            }
+
+            exec { '/usr/bin/apt-get update':
+              schedule => 'everyday',
+            }
+
+        EOT
+      isnamevar
+    end
+
+    newparam(:range) do
+      desc <<-EOT
+        The earliest and latest that a resource can be applied.  This is
+        always a hyphen-separated range within a 24 hour period, and hours
+        must be specified in numbers between 0 and 23, inclusive.  Minutes and
+        seconds can optionally 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. Multiple
+        ranges can be applied in array context. As a convenience when specifying
+        ranges, you can cross midnight (for example, `range => "22:00 - 04:00"`).
+      EOT
+
+      # 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}'") % { 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}") % { value: 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}'") % { n: n } if n < 0 or n > 23
+          end
+
+          [range[0][1], range[1][1]].each do |n|
+            raise ArgumentError, _("Invalid minute '%{n}'") % { n: n } if n and (n < 0 or n > 59)
+          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 an 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 << 0
+            end
+
+            if range[2]
+              ary << range[2]
+            else
+              ary << 0
+            end
+
+            time = Time.local(*ary)
+
+            unless time.hour == range[0]
+              self.devfail(
+                _("Incorrectly converted time: %{time}: %{hour} vs %{value}") % { time: time, hour: time.hour, value: range[0] }
+              )
+            end
+
+            time
+          end
+
+          unless limits[0] < limits[1]
+            self.info(
+            _("Assuming upper limit should be that time the next day")
+            )
+
+            # Find midnight between the two days. Adding one second
+            # to the end of the day is easier than dealing with dates.
+            ary = limits[0].to_a
+            ary[0] = 59
+            ary[1] = 59
+            ary[2] = 23
+            midnight = Time.local(*ary)+1
+
+            # If it is currently between the range start and midnight
+            # we consider that a successful match.
+            if now.between?(limits[0], midnight)
+              # We have to check the weekday match here as it is special-cased
+              # to support day-spanning ranges.
+              if @resource[:weekday]
+                return false unless @resource[:weekday].has_key?(now.wday)
+              end
+              return true
+            end
+
+            # If we didn't match between the starting time and midnight
+            # we must now move our midnight back 24 hours and try
+            # between the new midnight (24 hours prior) and the
+            # ending time.
+            midnight -= 86400
+
+            # Now we compare the current time between midnight and the
+            # end time.
+            if now.between?(midnight, limits[1])
+              # This case is the reason weekday matching is special cased
+              # in the range parameter. If we match a range that has spanned
+              # past midnight we want to match against the weekday when the range
+              # started, not when it currently is.
+              if @resource[:weekday]
+                return false unless @resource[:weekday].has_key?((now - 86400).wday)
+              end
+              return true
+            end
+
+            # If neither of the above matched then we don't match the
+            # range schedule.
+            return false
+          end
+
+          # Check to see if a weekday parameter was specified and, if so,
+          # do we match it or not. If we fail we can stop here.
+          # This is required because spanning ranges forces us to check
+          # weekday within the range parameter.
+          if @resource[:weekday]
+            return false unless @resource[:weekday].has_key?(now.wday)
+          end
+
+          return true if now.between?(*limits)
+        end
+
+        # Else, return false, since our current time isn't between
+        # any valid times
+        false
+      end
+    end
+
+    newparam(:periodmatch) do
+      desc "Whether periods should be matched by a numeric value (for instance,
+        whether two times are in the same hour) or by their chronological
+        distance apart (whether two times are 60 minutes apart)."
+
+      newvalues(:number, :distance)
+
+      defaultto :distance
+    end
+
+    newparam(:period) do
+      desc <<-EOT
+        The period of repetition for resources on this schedule. The default is
+        for resources to get applied every time Puppet runs.
+
+        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 (for instance, 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, the resource can applied _up to_ every 10 minutes, but internal
+        factors might prevent it from actually running that often (for instance,
+        if a Puppet run is still in progress when the next run is scheduled to
+        start, that next run will be suppressed).
+
+        See the `periodmatch` attribute for tuning whether to match
+        times by their distance apart or by their specific value.
+      EOT
+
+      newvalues(:hourly, :daily, :weekly, :monthly, :never)
+
+      ScheduleScales = {
+        :hourly => 3600,
+        :daily => 86400,
+        :weekly => 604800,
+        :monthly => 2592000
+      }
+      ScheduleMethods = {
+        :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 = ScheduleMethods[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 = ScheduleScales[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.
+          return (now.to_i - previous.to_i) >= (scale / @resource[:repeat])
+        end
+      end
+    end
+
+    newparam(:repeat) do
+      desc "How often a given resource may be applied in this schedule's `period`.
+        Defaults to 1; must be an integer."
+
+      defaultto 1
+
+      validate do |value|
+        unless value.is_a?(Integer) or value =~ /^\d+$/
+          raise Puppet::Error,
+            _("Repeat must be a number")
+        end
+
+        # 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 '%{period}'") % { period: @resource[:periodmatch] }
+        end
+      end
+
+      munge do |value|
+        value = Integer(value) unless value.is_a?(Integer)
+
+        value
+      end
+
+      def match?(previous, now)
+        true
+      end
+    end
+
+    newparam(:weekday) do
+      desc <<-EOT
+        The days of the week in which the schedule should be valid.
+        You may specify the full day name 'Tuesday', the three character
+        abbreviation 'Tue', or a number (as a string or as an integer) corresponding to the day of the
+        week where 0 is Sunday, 1 is Monday, and so on. Multiple days can be specified
+        as an array. If not specified, the day of the week will not be
+        considered in the schedule.
+
+        If you are also using a range match that spans across midnight
+        then this parameter will match the day that it was at the start
+        of the range, not necessarily the day that it is when it matches.
+        For example, consider this schedule:
+
+            schedule { 'maintenance_window':
+              range   => '22:00 - 04:00',
+              weekday => 'Saturday',
+            }
+
+        This will match at 11 PM on Saturday and 2 AM on Sunday, but not
+        at 2 AM on Saturday.
+      EOT
+
+      validate do |values|
+        values = [values] unless values.is_a?(Array)
+        values.each { |value|
+          if weekday_integer?(value) || weekday_string?(value)
+            value
+          else
+            raise ArgumentError, _("%{value} is not a valid day of the week") % { value: value }
+          end
+        }
+      end
+
+      def weekday_integer?(value)
+        value.is_a?(Integer) && (0..6).include?(value)
+      end
+
+      def weekday_string?(value)
+        value.is_a?(String) && (value =~ /^[0-6]$/ || value =~ /^(Mon|Tues?|Wed(?:nes)?|Thu(?:rs)?|Fri|Sat(?:ur)?|Sun)(day)?$/i)
+      end
+
+      weekdays = {
+        'sun' => 0,
+        'mon' => 1,
+        'tue' => 2,
+        'wed' => 3,
+        'thu' => 4,
+        'fri' => 5,
+        'sat' => 6,
+      }
+
+      munge do |values|
+        values = [values] unless values.is_a?(Array)
+        ret = {}
+
+        values.each do |value|
+          case value
+          when /^[0-6]$/
+            index = value.to_i
+          when 0..6
+            index = value
+          else
+            index = weekdays[value[0,3].downcase]
+          end
+          ret[index] = true
+        end
+        ret
+      end
+
+      def match?(previous, now)
+        # Special case weekday matching with ranges to a no-op here.
+        # If the ranges span days then we can't simply match the current
+        # weekday, as we want to match the weekday as it was when the range
+        # started.  As a result, all of that logic is in range, not here.
+        return true if @resource[:range]
+
+        return true if value.has_key?(now.wday)
+        false
+      end
+    end
+
+    def self.instances
+      []
+    end
+
+    def self.mkdefaultschedules
+      result = []
+      unless Puppet[:default_schedules]
+        Puppet.debug "Not creating default schedules: default_schedules is false"
+        return result
+      end
+
+      Puppet.debug "Creating default schedules"
+
+            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
+
+    def match?(previous = nil, now = nil)
+
+      # 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