puppet-parse 0.0.1 → 0.0.2

data/lib/vendor/puppet/util/resource_template.rb

@@ -0,0 +1,61 @@
+require 'puppet/util'
+require 'puppet/util/logging'
+require 'erb'
+
+# A template wrapper that evaluates a template in the
+# context of a resource, allowing the resource attributes
+# to be looked up from within the template.
+#  This provides functionality essentially equivalent to
+# the language's template() function.  You pass your file
+# path and the resource you want to use into the initialization
+# method, then call result on the instance, and you get back
+# a chunk of text.
+#  The resource's parameters are available as instance variables
+# (as opposed to the language, where we use a method_missing trick).
+#  For example, say you have a resource that generates a file.  You would
+# need to implement the following style of `generate` method:
+#
+#   def generate
+#       template = Puppet::Util::ResourceTemplate.new("/path/to/template", self)
+#
+#       return Puppet::Type.type(:file).new :path => "/my/file",
+#           :content => template.evaluate
+#   end
+#
+# This generated file gets added to the catalog (which is what `generate` does),
+# and its content is the result of the template.  You need to use instance
+# variables in your template, so if your template just needs to have the name
+# of the generating resource, it would just have:
+#
+#   <%= @name %>
+#
+# Since the ResourceTemplate class sets as instance variables all of the resource's
+# parameters.
+#
+# Note that this example uses the generating resource as its source of
+# parameters, which is generally most useful, since it allows you to configure
+# the generated resource via the generating resource.
+class Puppet::Util::ResourceTemplate
+  include Puppet::Util::Logging
+
+  def evaluate
+    set_resource_variables
+    ERB.new(File.read(@file), 0, "-").result(binding)
+  end
+
+  def initialize(file, resource)
+    raise ArgumentError, "Template #{file} does not exist" unless FileTest.exist?(file)
+    @file = file
+    @resource = resource
+  end
+
+  private
+
+  def set_resource_variables
+    @resource.to_hash.each do |param, value|
+      var = "@#{param.to_s}"
+      instance_variable_set(var, value)
+    end
+  end
+end
+

data/lib/vendor/puppet/util/retryaction.rb

@@ -0,0 +1,48 @@
+module Puppet::Util::RetryAction
+  class RetryException < Exception; end
+  class RetryException::NoBlockGiven < RetryException; end
+  class RetryException::NoRetriesGiven < RetryException;end
+  class RetryException::RetriesExceeded < RetryException; end
+
+  def self.retry_action( parameters = { :retry_exceptions => nil, :retries => nil } )
+    # Retry actions for a specified amount of time. This method will allow the final
+    # retry to complete even if that extends beyond the timeout period.
+    unless block_given?
+      raise RetryException::NoBlockGiven
+    end
+
+    raise RetryException::NoRetriesGiven if parameters[:retries].nil?
+    parameters[:retry_exceptions] ||= Hash.new
+
+    start = Time.now
+    failures = 0
+
+    begin
+      yield
+    rescue Exception => e
+      # If we were giving exceptions to catch,
+      # catch the excptions we care about and retry.
+      # All others fail hard
+
+      raise RetryException::RetriesExceeded if parameters[:retries] == 0
+
+      if (not parameters[:retry_exceptions].keys.empty?) and parameters[:retry_exceptions].keys.include?(e.class)
+        Puppet.info("Caught exception #{e.class}:#{e}")
+        Puppet.info(parameters[:retry_exceptions][e.class])
+      elsif (not parameters[:retry_exceptions].keys.empty?)
+        # If the exceptions is not in the list of retry_exceptions re-raise.
+        raise e
+      end
+
+      failures += 1
+      parameters[:retries] -= 1
+
+      # Increase the amount of time that we sleep after every
+      # failed retry attempt.
+      sleep (((2 ** failures) -1) * 0.1)
+
+      retry
+
+    end
+  end
+end

data/lib/vendor/puppet/util/run_mode.rb

@@ -0,0 +1,82 @@
+require 'etc'
+
+module Puppet
+  module Util
+    class RunMode
+      def initialize(name)
+        @name = name.to_sym
+      end
+
+      @@run_modes = Hash.new {|h, k| h[k] = RunMode.new(k)}
+
+      attr :name
+
+      def self.[](name)
+        @@run_modes[name]
+      end
+
+      def master?
+        name == :master
+      end
+
+      def agent?
+        name == :agent
+      end
+
+      def user?
+        name == :user
+      end
+
+      def conf_dir
+        which_dir(
+          (Puppet.features.microsoft_windows? ? File.join(Dir::COMMON_APPDATA, "PuppetLabs", "puppet", "etc") : "/etc/puppet"),
+          "~/.puppet"
+        )
+      end
+
+      def var_dir
+        which_dir(
+          (Puppet.features.microsoft_windows? ? File.join(Dir::COMMON_APPDATA, "PuppetLabs", "puppet", "var") : "/var/lib/puppet"),
+          "~/.puppet/var"
+        )
+      end
+
+      def run_dir
+        "$vardir/run"
+      end
+
+      def logopts
+        if master?
+          {
+            :default => "$vardir/log",
+            :mode    => 0750,
+            :owner   => "service",
+            :group   => "service",
+            :desc    => "The Puppet log directory."
+          }
+        else
+          ["$vardir/log", "The Puppet log directory."]
+        end
+      end
+
+      private
+
+      def which_dir( global, user )
+        #FIXME: we should test if we're user "puppet"
+        #       there's a comment that suggests that we do that
+        #       and we currently don't.
+        expand_path case
+          when name == :master; global
+          when Puppet.features.root?; global
+          else user
+        end
+      end
+
+      def expand_path( dir )
+        ENV["HOME"] ||= Etc.getpwuid(Process.uid).dir
+        File.expand_path(dir)
+      end
+
+    end
+  end
+end

data/lib/vendor/puppet/util/selinux.rb

@@ -0,0 +1,211 @@
+# Provides utility functions to help interface Puppet to SELinux.
+#
+# This requires the very new SELinux Ruby bindings.  These bindings closely
+# mirror the SELinux C library interface.
+#
+# Support for the command line tools is not provided because the performance
+# was abysmal.  At this time (2008-11-02) the only distribution providing
+# these Ruby SELinux bindings which I am aware of is Fedora (in libselinux-ruby).
+
+Puppet.features.selinux? # check, but continue even if it's not
+
+require 'pathname'
+
+module Puppet::Util::SELinux
+
+  def selinux_support?
+    return false unless defined?(Selinux)
+    if Selinux.is_selinux_enabled == 1
+      return true
+    end
+    false
+  end
+
+  # Retrieve and return the full context of the file.  If we don't have
+  # SELinux support or if the SELinux call fails then return nil.
+  def get_selinux_current_context(file)
+    return nil unless selinux_support?
+    retval = Selinux.lgetfilecon(file)
+    if retval == -1
+      return nil
+    end
+    retval[1]
+  end
+
+  # Retrieve and return the default context of the file.  If we don't have
+  # SELinux support or if the SELinux call fails to file a default then return nil.
+  def get_selinux_default_context(file)
+    return nil unless selinux_support?
+    # If the filesystem has no support for SELinux labels, return a default of nil
+    # instead of what matchpathcon would return
+    return nil unless selinux_label_support?(file)
+    # If the file exists we should pass the mode to matchpathcon for the most specific
+    # matching.  If not, we can pass a mode of 0.
+    begin
+      filestat = File.lstat(file)
+      mode = filestat.mode
+    rescue Errno::ENOENT
+      mode = 0
+    end
+    retval = Selinux.matchpathcon(file, mode)
+    if retval == -1
+      return nil
+    end
+    retval[1]
+  end
+
+  # Take the full SELinux context returned from the tools and parse it
+  # out to the three (or four) component parts.  Supports :seluser, :selrole,
+  # :seltype, and on systems with range support, :selrange.
+  def parse_selinux_context(component, context)
+    if context.nil? or context == "unlabeled"
+      return nil
+    end
+    unless context =~ /^([a-z0-9_]+):([a-z0-9_]+):([a-zA-Z0-9_]+)(?::([a-zA-Z0-9:,._-]+))?/
+      raise Puppet::Error, "Invalid context to parse: #{context}"
+    end
+    ret = {
+      :seluser => $1,
+      :selrole => $2,
+      :seltype => $3,
+      :selrange => $4,
+    }
+    ret[component]
+  end
+
+  # This updates the actual SELinux label on the file.  You can update
+  # only a single component or update the entire context.
+  # The caveat is that since setting a partial context makes no sense the
+  # file has to already exist.  Puppet (via the File resource) will always
+  # just try to set components, even if all values are specified by the manifest.
+  # I believe that the OS should always provide at least a fall-through context
+  # though on any well-running system.
+  def set_selinux_context(file, value, component = false)
+    return nil unless selinux_support? && selinux_label_support?(file)
+
+    if component
+      # Must first get existing context to replace a single component
+      context = Selinux.lgetfilecon(file)[1]
+      if context == -1
+        # We can't set partial context components when no context exists
+        # unless/until we can find a way to make Puppet call this method
+        # once for all selinux file label attributes.
+        Puppet.warning "Can't set SELinux context on file unless the file already has some kind of context"
+        return nil
+      end
+      context = context.split(':')
+      case component
+        when :seluser
+          context[0] = value
+        when :selrole
+          context[1] = value
+        when :seltype
+          context[2] = value
+        when :selrange
+          context[3] = value
+        else
+          raise ArguementError, "set_selinux_context component must be one of :seluser, :selrole, :seltype, or :selrange"
+      end
+      context = context.join(':')
+    else
+      context = value
+    end
+
+    retval = Selinux.lsetfilecon(file, context)
+    if retval == 0
+      return true
+    else
+      Puppet.warning "Failed to set SELinux context #{context} on #{file}"
+      return false
+    end
+  end
+
+  # Since this call relies on get_selinux_default_context it also needs a
+  # full non-relative path to the file.  Fortunately, that seems to be all
+  # Puppet uses.  This will set the file's SELinux context to the policy's
+  # default context (if any) if it differs from the context currently on
+  # the file.
+  def set_selinux_default_context(file)
+    new_context = get_selinux_default_context(file)
+    return nil unless new_context
+    cur_context = get_selinux_current_context(file)
+    if new_context != cur_context
+      set_selinux_context(file, new_context)
+      return new_context
+    end
+    nil
+  end
+
+  ########################################################################
+  # Internal helper methods from here on in, kids.  Don't fiddle.
+  private
+
+  # Check filesystem a path resides on for SELinux support against
+  # whitelist of known-good filesystems.
+  # Returns true if the filesystem can support SELinux labels and
+  # false if not.
+  def selinux_label_support?(file)
+    fstype = find_fs(file)
+    return false if fstype.nil?
+    filesystems = ['ext2', 'ext3', 'ext4', 'gfs', 'gfs2', 'xfs', 'jfs']
+    filesystems.include?(fstype)
+  end
+
+  # Internal helper function to read and parse /proc/mounts
+  def read_mounts
+    mounts = ""
+    begin
+      if File.method_defined? "read_nonblock"
+        # If possible we use read_nonblock in a loop rather than read to work-
+        # a linux kernel bug.  See ticket #1963 for details.
+        mountfh = File.open("/proc/mounts")
+        mounts += mountfh.read_nonblock(1024) while true
+      else
+        # Otherwise we shell out and let cat do it for us
+        mountfh = IO.popen("/bin/cat /proc/mounts")
+        mounts = mountfh.read
+      end
+    rescue EOFError
+      # that's expected
+    rescue
+      return nil
+    ensure
+      mountfh.close if mountfh
+    end
+
+    mntpoint = {}
+
+    # Read all entries in /proc/mounts.  The second column is the
+    # mountpoint and the third column is the filesystem type.
+    # We skip rootfs because it is always mounted at /
+    mounts.each_line do |line|
+      params = line.split(' ')
+      next if params[2] == 'rootfs'
+      mntpoint[params[1]] = params[2]
+    end
+    mntpoint
+  end
+
+  # Internal helper function to return which type of filesystem a given file
+  # path resides on
+  def find_fs(path)
+    return nil unless mounts = read_mounts
+
+    # cleanpath eliminates useless parts of the path (like '.', or '..', or
+    # multiple slashes), without touching the filesystem, and without
+    # following symbolic links.  This gives the right (logical) tree to follow
+    # while we try and figure out what file-system the target lives on.
+    path = Pathname(path).cleanpath
+    unless path.absolute?
+      raise Puppet::DevError, "got a relative path in SELinux find_fs: #{path}"
+    end
+
+    # Now, walk up the tree until we find a match for that path in the hash.
+    path.ascend do |segment|
+      return mounts[segment.to_s] if mounts.has_key?(segment.to_s)
+    end
+
+    # Should never be reached...
+    return mounts['/']
+  end
+end

data/lib/vendor/puppet/util/settings/boolean_setting.rb

@@ -0,0 +1,30 @@
+require 'puppet/util/settings/setting'
+
+# A simple boolean.
+class Puppet::Util::Settings::BooleanSetting < Puppet::Util::Settings::Setting
+  # get the arguments in getopt format
+  def getopt_args
+    if short
+      [["--#{name}", "-#{short}", GetoptLong::NO_ARGUMENT], ["--no-#{name}", GetoptLong::NO_ARGUMENT]]
+    else
+      [["--#{name}", GetoptLong::NO_ARGUMENT], ["--no-#{name}", GetoptLong::NO_ARGUMENT]]
+    end
+  end
+
+  def optparse_args
+    if short
+      ["--[no-]#{name}", "-#{short}", desc, :NONE ]
+    else
+      ["--[no-]#{name}", desc, :NONE]
+    end
+  end
+
+  def munge(value)
+    case value
+    when true, "true"; return true
+    when false, "false"; return false
+    else
+      raise ArgumentError, "Invalid value '#{value.inspect}' for #{@name}"
+    end
+  end
+end

data/lib/vendor/puppet/util/settings/file_setting.rb

@@ -0,0 +1,135 @@
+require 'puppet/util/settings/setting'
+
+# A file.
+class Puppet::Util::Settings::FileSetting < Puppet::Util::Settings::Setting
+  AllowedOwners = %w{root service}
+  AllowedGroups = %w{root service}
+
+  class SettingError < StandardError; end
+
+  attr_accessor :mode, :create
+
+  # Should we create files, rather than just directories?
+  def create_files?
+    create
+  end
+
+  def group=(value)
+    unless AllowedGroups.include?(value)
+      identifying_fields = [desc,name,default].compact.join(': ')
+      raise SettingError, "Internal error: The :group setting for #{identifying_fields} must be 'service', not '#{value}'"
+    end
+    @group = value
+  end
+
+  def group
+    return unless @group
+    @settings[:group]
+  end
+
+  def owner=(value)
+    unless AllowedOwners.include?(value)
+      identifying_fields = [desc,name,default].compact.join(': ')
+      raise SettingError, "Internal error: The :owner setting for #{identifying_fields} must be either 'root' or 'service', not '#{value}'"
+    end
+    @owner = value
+  end
+
+  def owner
+    return unless @owner
+    return "root" if @owner == "root" or ! use_service_user?
+    @settings[:user]
+  end
+
+  def use_service_user?
+    @settings[:mkusers] or @settings.service_user_available?
+  end
+
+  # Set the type appropriately.  Yep, a hack.  This supports either naming
+  # the variable 'dir', or adding a slash at the end.
+  def munge(value)
+    # If it's not a fully qualified path...
+    if value.is_a?(String) and value !~ /^\$/ and value != 'false'
+      # Preserve trailing slash (stripped by expand_path)
+      isdir = value =~ /\/$/
+      value = File.expand_path(value)
+      value += '/' if isdir
+    end
+    value
+  end
+
+  # Return the appropriate type.
+  def type
+    value = @settings.value(self.name)
+    if @name.to_s =~ /dir/
+      return :directory
+    elsif value.to_s =~ /\/$/
+      return :directory
+    elsif value.is_a? String
+      return :file
+    else
+      return nil
+    end
+  end
+
+  # Turn our setting thing into a Puppet::Resource instance.
+  def to_resource
+    return nil unless type = self.type
+
+    path = self.value
+
+    return nil unless path.is_a?(String)
+
+    # Make sure the paths are fully qualified.
+    path = File.expand_path(path)
+
+    return nil unless type == :directory or create_files? or File.exist?(path)
+    return nil if path =~ /^\/dev/ or path =~ /^[A-Z]:\/dev/i
+
+    resource = Puppet::Resource.new(:file, path)
+
+    if Puppet[:manage_internal_file_permissions]
+      if self.mode
+        # This ends up mimicking the munge method of the mode
+        # parameter to make sure that we're always passing the string
+        # version of the octal number.  If we were setting the
+        # 'should' value for mode rather than the 'is', then the munge
+        # method would be called for us automatically.  Normally, one
+        # wouldn't need to call the munge method manually, since
+        # 'should' gets set by the provider and it should be able to
+        # provide the data in the appropriate format.
+        mode = self.mode
+        mode = mode.to_i(8) if mode.is_a?(String)
+        mode = mode.to_s(8)
+        resource[:mode] = mode
+      end
+
+      # REMIND fails on Windows because chown/chgrp functionality not supported yet
+      if Puppet.features.root? and !Puppet.features.microsoft_windows?
+        resource[:owner] = self.owner if self.owner
+        resource[:group] = self.group if self.group
+      end
+    end
+
+    resource[:ensure] = type
+    resource[:loglevel] = :debug
+    resource[:links] = :follow
+    resource[:backup] = false
+
+    resource.tag(self.section, self.name, "settings")
+
+    resource
+  end
+
+  # Make sure any provided variables look up to something.
+  def validate(value)
+    return true unless value.is_a? String
+    value.scan(/\$(\w+)/) { |name|
+      name = $1
+      unless @settings.include?(name)
+        raise ArgumentError,
+          "Settings parameter '#{name}' is undefined"
+      end
+    }
+  end
+end

data/lib/vendor/puppet/util/settings/setting.rb

@@ -0,0 +1,94 @@
+# The base element type.
+class Puppet::Util::Settings::Setting
+  attr_accessor :name, :section, :default, :setbycli, :call_on_define
+  attr_reader :desc, :short
+
+  def desc=(value)
+    @desc = value.gsub(/^\s*/, '')
+  end
+
+  # get the arguments in getopt format
+  def getopt_args
+    if short
+      [["--#{name}", "-#{short}", GetoptLong::REQUIRED_ARGUMENT]]
+    else
+      [["--#{name}", GetoptLong::REQUIRED_ARGUMENT]]
+    end
+  end
+
+  # get the arguments in OptionParser format
+  def optparse_args
+    if short
+      ["--#{name}", "-#{short}", desc, :REQUIRED]
+    else
+      ["--#{name}", desc, :REQUIRED]
+    end
+  end
+
+  def hook=(block)
+    meta_def :handle, &block
+  end
+
+  # Create the new element.  Pretty much just sets the name.
+  def initialize(args = {})
+    unless @settings = args.delete(:settings)
+      raise ArgumentError.new("You must refer to a settings object")
+    end
+
+    args.each do |param, value|
+      method = param.to_s + "="
+      raise ArgumentError, "#{self.class} does not accept #{param}" unless self.respond_to? method
+
+      self.send(method, value)
+    end
+
+    raise ArgumentError, "You must provide a description for the #{self.name} config option" unless self.desc
+  end
+
+  def iscreated
+    @iscreated = true
+  end
+
+  def iscreated?
+    @iscreated
+  end
+
+  def set?
+    !!(!@value.nil?)
+  end
+
+  # short name for the celement
+  def short=(value)
+    raise ArgumentError, "Short names can only be one character." if value.to_s.length != 1
+    @short = value.to_s
+  end
+
+  # Convert the object to a config statement.
+  def to_config
+    str = @desc.gsub(/^/, "# ") + "\n"
+
+    # Add in a statement about the default.
+    str += "# The default value is '#{@default}'.\n" if @default
+
+    # If the value has not been overridden, then print it out commented
+    # and unconverted, so it's clear that that's the default and how it
+    # works.
+    value = @settings.value(self.name)
+
+    if value != @default
+      line = "#{@name} = #{value}"
+    else
+      line = "# #{@name} = #{@default}"
+    end
+
+    str += line + "\n"
+
+    str.gsub(/^/, "    ")
+  end
+
+  # Retrieves the value, or if it's not set, retrieves the default.
+  def value
+    @settings.value(self.name)
+  end
+end
+