puppet-parse 0.0.1 → 0.0.2

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

@@ -0,0 +1,360 @@
+module Puppet
+  newtype(:schedule) do
+    @doc = <<-'EOT'
+      Define schedules for Puppet. Resources can be limited to a schedule by using the
+      [`schedule`](http://docs.puppetlabs.com/references/latest/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 (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 of the valid periods
+      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.
+      EOT
+
+    apply_to_all
+
+    newparam(:name) do
+      desc <<-EOT
+        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',
+            }
+
+        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.
+      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}'"
+          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
+
+            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: #{time}: #{time.hour} vs #{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 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 number (e.g., the two times
+        are in the same hour) or by distance (e.g., the two times are
+        60 minutes apart)."
+
+      newvalues(:number, :distance)
+
+      defaultto :distance
+    end
+
+    newparam(:period) do
+      desc <<-EOT
+        The period of repetition for a resource. The default is for a resource
+        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 (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.
+      EOT
+
+      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
+
+    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 '#{@resource[:periodmatch]}'"
+        end
+      end
+
+      munge do |value|
+        value = Integer(value) unless value.is_a?(Integer)
+
+        value
+      end
+
+      def match?(previous, now)
+        true
+      end
+    end
+
+    def self.instances
+      []
+    end
+
+    def self.mkdefaultschedules
+      result = []
+      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

data/lib/vendor/puppet/type/scheduled_task.rb

@@ -0,0 +1,166 @@
+require 'puppet/util'
+
+Puppet::Type.newtype(:scheduled_task) do
+  include Puppet::Util
+
+  @doc = "Installs and manages Windows Scheduled Tasks.  All attributes
+    except `name`, `command`, and `trigger` are optional; see the description
+    of the `trigger` attribute for details on setting schedules."
+
+  ensurable
+
+  newproperty(:enabled) do
+    desc "Whether the triggers for this task should be enabled. This attribute
+      affects every trigger for the task; triggers cannot be enabled or
+      disabled individually."
+
+    newvalue(:true,  :event => :task_enabled)
+    newvalue(:false, :event => :task_disabled)
+
+    defaultto(:true)
+  end
+
+  newparam(:name) do
+    desc "The name assigned to the scheduled task.  This will uniquely
+      identify the task on the system."
+
+    isnamevar
+  end
+
+  newproperty(:command) do
+    desc "The full path to the application to run, without any arguments."
+
+    validate do |value|
+      raise Puppet::Error.new('Must be specified using an absolute path.') unless absolute_path?(value)
+    end
+    munge do |value|
+      # windows converts slashes to backslashes, so the *is* value
+      # has backslashes. Do the same for the *should* value, so that
+      # we are slash-insensitive. See #13009
+      File.expand_path(value).gsub(/\//, '\\')
+    end
+  end
+
+  newproperty(:working_dir) do
+    desc "The full path of the directory in which to start the command."
+
+    validate do |value|
+      raise Puppet::Error.new('Must be specified using an absolute path.') unless absolute_path?(value)
+    end
+  end
+
+  newproperty(:arguments) do
+    desc "Any arguments or flags that should be passed to the command. Multiple arguments
+      should be specified as a space-separated string."
+  end
+
+  newproperty(:user) do
+    desc "The user to run the scheduled task as.  Please note that not
+      all security configurations will allow running a scheduled task
+      as 'SYSTEM', and saving the scheduled task under these
+      conditions will fail with a reported error of 'The operation
+      completed successfully'.  It is recommended that you either
+      choose another user to run the scheduled task, or alter the
+      security policy to allow v1 scheduled tasks to run as the
+      'SYSTEM' account.  Defaults to 'SYSTEM'."
+
+    defaultto :system
+
+    def insync?(current)
+      provider.user_insync?(current, @should)
+    end
+  end
+
+  newparam(:password) do
+    desc "The password for the user specified in the 'user' attribute.
+      This is only used if specifying a user other than 'SYSTEM'.
+      Since there is no way to retrieve the password used to set the
+      account information for a task, this parameter will not be used
+      to determine if a scheduled task is in sync or not."
+  end
+
+  newproperty(:trigger, :array_matching => :all) do
+    desc <<-'EOT'
+      One or more triggers defining when the task should run. A single trigger is
+      represented as a hash, and multiple triggers can be specified with an array of
+      hashes.
+
+      A trigger can contain the following keys:
+
+      * For all triggers:
+          * `schedule` **(Required)** --- The schedule type. Valid values are
+            `daily`, `weekly`, `monthly`, or `once`.
+          * `start_time` **(Required)** --- The time of day when the trigger should
+            first become active. Several time formats will work, but we
+            suggest 24-hour time formatted as HH:MM.
+          * `start_date` ---  The date when the trigger should first become active.
+            Defaults to "today." Several date formats will work, including
+            special dates like "today," but we suggest formatting dates as
+            YYYY-MM-DD.
+      * For daily triggers:
+          * `every` --- How often the task should run, as a number of days. Defaults
+            to 1. ("2" means every other day, "3" means every three days, etc.)
+      * For weekly triggers:
+          * `every` --- How often the task should run, as a number of weeks. Defaults
+            to 1. ("2" means every other week, "3" means every three weeks, etc.)
+          * `day_of_week` --- Which days of the week the task should run, as an array.
+            Defaults to all days. Each day must be one of `mon`, `tues`,
+            `wed`, `thurs`, `fri`, `sat`, `sun`, or `all`.
+      * For monthly-by-date triggers:
+          * `months` --- Which months the task should run, as an array. Defaults to
+            all months. Each month must be an integer between 1 and 12.
+          * `on` **(Required)** --- Which days of the month the task should run,
+            as an array. Each day must beeither an integer between 1 and 31,
+            or the special value `last,` which is always the last day of the month.
+      * For monthly-by-weekday triggers:
+          * `months` --- Which months the task should run, as an array. Defaults to
+            all months. Each month must be an integer between 1 and 12.
+          * `day_of_week` **(Required)** --- Which day of the week the task should
+            run, as an array with only one element. Each day must be one of `mon`,
+            `tues`, `wed`, `thurs`, `fri`, `sat`, `sun`, or `all`.
+          * `which_occurrence` **(Required)** --- The occurrence of the chosen weekday
+            when the task should run. Must be one of `first`, `second`, `third`,
+            `fourth`, `fifth`, or `last`.
+
+      Examples:
+
+          # Run at 8am on the 1st, 15th, and last day of the month in January, March,
+          # May, July, September, and November, starting after August 31st, 2011.
+          trigger => {
+            schedule   => monthly,
+            start_date => '2011-08-31',   # Defaults to 'today'
+            start_time => '08:00',        # Must be specified
+            months     => [1,3,5,7,9,11], # Defaults to all
+            on         => [1, 15, last],  # Must be specified
+          }
+
+          # Run at 8am on the first Monday of the month for January, March, and May,
+          # starting after August 31st, 2011.
+          trigger => {
+            schedule         => monthly,
+            start_date       => '2011-08-31', # Defaults to 'today'
+            start_time       => '08:00',      # Must be specified
+            months           => [1,3,5],      # Defaults to all
+            which_occurrence => first,        # Must be specified
+            day_of_week      => [mon],        # Must be specified
+          }
+
+    EOT
+
+    validate do |value|
+      provider.validate_trigger(value)
+    end
+
+    def insync?(current)
+      provider.trigger_insync?(current, @should)
+    end
+
+    def should_to_s(new_value=@should)
+      self.class.format_value_for_display(new_value)
+    end
+
+    def is_to_s(current_value=@is)
+      self.class.format_value_for_display(current_value)
+    end
+  end
+end

data/lib/vendor/puppet/type/selboolean.rb

@@ -0,0 +1,26 @@
+module Puppet
+  newtype(:selboolean) do
+    @doc = "Manages SELinux booleans on systems with SELinux support.  The supported booleans
+      are any of the ones found in `/selinux/booleans/`."
+
+    newparam(:name) do
+      desc "The name of the SELinux boolean to be managed."
+      isnamevar
+    end
+
+    newproperty(:value) do
+      desc "Whether the the SELinux boolean should be enabled or disabled."
+      newvalue(:on)
+      newvalue(:off)
+    end
+
+    newparam(:persistent) do
+      desc "If set true, SELinux booleans will be written to disk and persist accross reboots.
+        The default is `false`."
+
+      defaultto :false
+      newvalues(:true, :false)
+    end
+
+  end
+end

data/lib/vendor/puppet/type/selmodule.rb

@@ -0,0 +1,59 @@
+#
+# Simple module for manageing SELinux policy modules
+#
+
+Puppet::Type.newtype(:selmodule) do
+  @doc = "Manages loading and unloading of SELinux policy modules
+    on the system.  Requires SELinux support.  See man semodule(8)
+    for more information on SELinux policy modules.
+
+    **Autorequires:** If Puppet is managing the file containing this SELinux
+    policy module (which is either explicitly specified in the `selmodulepath`
+    attribute or will be found at {`selmoduledir`}/{`name`}.pp), the selmodule
+    resource will autorequire that file."
+
+  ensurable
+
+  newparam(:name) do
+    desc "The name of the SELinux policy to be managed.  You should not
+      include the customary trailing .pp extension."
+    isnamevar
+  end
+
+  newparam(:selmoduledir) do
+
+    desc "The directory to look for the compiled pp module file in.
+      Currently defaults to `/usr/share/selinux/targeted`.  If the
+      `selmodulepath` attribute is not specified, Puppet will expect to find
+      the module in `<selmoduledir>/<name>.pp`, where `name` is the value of the
+      `name` parameter."
+
+    defaultto "/usr/share/selinux/targeted"
+  end
+
+  newparam(:selmodulepath) do
+
+    desc "The full path to the compiled .pp policy module.  You only need to use
+      this if the module file is not in the `selmoduledir` directory."
+
+  end
+
+  newproperty(:syncversion) do
+
+    desc "If set to `true`, the policy will be reloaded if the
+    version found in the on-disk file differs from the loaded
+    version.  If set to `false` (the default) the the only check
+    that will be made is if the policy is loaded at all or not."
+
+    newvalue(:true)
+    newvalue(:false)
+  end
+
+  autorequire(:file) do
+    if self[:selmodulepath]
+      [self[:selmodulepath]]
+    else
+      ["#{self[:selmoduledir]}/#{self[:name]}.pp"]
+    end
+  end
+end