puppet-retrospec 1.5.0 → 1.6.0

data/vendor/pup410/lib/puppet/type/augeas.rb

@@ -0,0 +1,211 @@
+#
+#   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. Defaults to false."
+    newvalues(:true, :false)
+
+    defaultto :false
+  end
+
+  newparam(:lens) do
+    desc "Use a specific lens, e.g. `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, e.g. `/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/vendor/pup410/lib/puppet/type/component.rb

@@ -0,0 +1,88 @@
+
+require 'puppet'
+require 'puppet/type'
+require 'puppet/transaction'
+
+Puppet::Type.newtype(:component) do
+  include Enumerable
+
+  newparam(:name) do
+    desc "The name of the component.  Generally optional."
+    isnamevar
+  end
+
+  # Override how parameters are handled so that we support the extra
+  # parameters that are used with defined resource types.
+  def [](param)
+    return super if self.class.valid_parameter?(param)
+    @extra_parameters[param.to_sym]
+  end
+
+  # Override how parameters are handled so that we support the extra
+  # parameters that are used with defined resource types.
+  def []=(param, value)
+    return super if self.class.valid_parameter?(param)
+    @extra_parameters[param.to_sym] = value
+  end
+
+  # Initialize a new component
+  def initialize(*args)
+    @extra_parameters = {}
+    super
+  end
+
+  # Component paths are special because they function as containers.
+  def pathbuilder
+    if reference.type == "Class"
+      myname = reference.title
+    else
+      myname = reference.to_s
+    end
+    if p = self.parent
+      return [p.pathbuilder, myname]
+    else
+      return [myname]
+    end
+  end
+
+  def ref
+    reference.to_s
+  end
+
+  # We want our title to just be the whole reference, rather than @title.
+  def title
+    ref
+  end
+
+  def title=(str)
+    @reference = Puppet::Resource.new(str)
+  end
+
+  def refresh
+    catalog.adjacent(self).each do |child|
+      if child.respond_to?(:refresh)
+        child.refresh
+        child.log "triggering #{:refresh}"
+      end
+    end
+  end
+
+  def to_s
+    reference.to_s
+  end
+
+  # Overrides the default implementation to do nothing.
+  # This type contains data from class/define parameters, but does
+  # not have actual parameters or properties at the Type level. We can
+  # simply ignore anything flagged as sensitive here, since any
+  # contained resources will handle that sensitivity themselves. There
+  # is no risk of this information leaking into reports, since no
+  # Component instances survive the graph transmutation.
+  #
+  def set_sensitive_parameters(sensitive_parameters)
+  end
+
+  private
+
+  attr_reader :reference
+end

data/vendor/pup410/lib/puppet/type/cron.rb

@@ -0,0 +1,492 @@
+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 synched, 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.upcase == name[0..2].upcase
+            return index
+          end
+        }
+      else
+        return ary.index(tmp) if ary.include?(tmp)
+      end
+
+      false
+    end
+
+    def should_to_s(newvalue = @should)
+      if newvalue
+        newvalue = [newvalue] unless newvalue.is_a?(Array)
+        if self.name == :command or newvalue[0].is_a? Symbol
+          newvalue[0]
+        else
+          newvalue.join(",")
+        end
+      else
+        nil
+      end
+    end
+
+    def is_to_s(currentvalue = @is)
+      if currentvalue
+        return currentvalue unless currentvalue.is_a?(Array)
+
+        if self.name == :command or currentvalue[0].is_a? Symbol
+          currentvalue[0]
+        else
+          currentvalue.join(",")
+        end
+      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 #{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.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 between 0 and 7, inclusive, with
+      0 (or 7) being Sunday, or must be the name of the day (e.g., 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 between 1 and 12 or the month name (e.g., 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, e.g., `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.inspect}"
+      end
+    end
+
+    def insync?(is)
+      if is.is_a? Array
+        return is.sort == @should.sort
+      else
+        return is == @should
+      end
+    end
+
+    def is_to_s(newvalue)
+      if newvalue
+        if newvalue.is_a?(Array)
+          newvalue.join(",")
+        else
+          newvalue
+        end
+      else
+        nil
+      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, "#{self.ref} cannot specify both a special schedule and a value for #{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
+