puppet-parse 0.0.1 → 0.0.2

data/lib/vendor/puppet/face/status.rb

@@ -0,0 +1,53 @@
+require 'puppet/indirector/face'
+
+Puppet::Indirector::Face.define(:status, '0.0.1') do
+  copyright "Puppet Labs", 2011
+  license   "Apache 2 license; see COPYING"
+
+  summary "View puppet server status."
+
+  get_action(:destroy).summary "Invalid for this subcommand."
+  get_action(:save).summary "Invalid for this subcommand."
+  get_action(:save).description "Invalid for this subcommand."
+  get_action(:search).summary "Invalid for this subcommand."
+
+  find = get_action(:find)
+  find.default = true
+  find.summary "Check status of puppet master server."
+  find.arguments "<dummy_text>"
+  find.returns <<-'EOT'
+    A "true" response or a low-level connection error. When used from the Ruby
+    API: returns a Puppet::Status object.
+  EOT
+  find.description <<-'EOT'
+    Checks whether a Puppet server is properly receiving and processing
+    HTTP requests. This action is only useful when used with '--terminus
+    rest'; when invoked with the `local` terminus, `find` will always
+    return true.
+
+    Over REST, this action will query the configured puppet master by default.
+    To query other servers, including puppet agent nodes started with the
+    <--listen> option, you can set set the global <--server> and <--masterport>
+    options on the command line; note that agent nodes listen on port 8139.
+  EOT
+  find.short_description <<-EOT
+    Checks whether a Puppet server is properly receiving and processing HTTP
+    requests. Due to a known bug, this action requires a dummy argument, the
+    content of which is irrelevant. This action is only useful when used with
+    '--terminus rest', and will always return true when invoked locally.
+  EOT
+  find.notes <<-'EOT'
+    This action requires that the server's `auth.conf` file allow find
+    access to the `status` REST terminus. Puppet agent does not use this
+    facility, and it is turned off by default. See
+    <http://docs.puppetlabs.com/guides/rest_auth_conf.html> for more details.
+
+    Although this action always returns an unnamed status object, it requires a
+    dummy argument. This is a known bug.
+  EOT
+  find.examples <<-'EOT'
+    Check the status of the configured puppet master:
+
+    $ puppet status find x --terminus rest
+  EOT
+end

data/lib/vendor/puppet/face.rb

@@ -0,0 +1,12 @@
+# The public name of this feature is 'face', but we have hidden all the
+# plumbing over in the 'interfaces' namespace to make clear the distinction
+# between the two.
+#
+# This file exists to ensure that the public name is usable without revealing
+# the details of the implementation; you really only need go look at anything
+# under Interfaces if you are looking to extend the implementation.
+#
+# It isn't hidden to gratuitously hide things, just to make it easier to
+# separate out the interests people will have.  --daniel 2011-04-07
+require 'puppet/interface'
+Puppet::Face = Puppet::Interface

data/lib/vendor/puppet/feature/base.rb

@@ -0,0 +1,67 @@
+require 'puppet/util/feature'
+
+# Add the simple features, all in one file.
+
+# Order is important as some features depend on others
+
+# We have a syslog implementation
+Puppet.features.add(:syslog, :libs => ["syslog"])
+
+# We can use POSIX user functions
+Puppet.features.add(:posix) do
+  require 'etc'
+  Etc.getpwuid(0) != nil && Puppet.features.syslog?
+end
+
+# We can use Microsoft Windows functions
+Puppet.features.add(:microsoft_windows) do
+  begin
+    require 'sys/admin'
+    require 'win32/process'
+    require 'win32/dir'
+    require 'win32/service'
+    require 'win32ole'
+    require 'win32/api'
+    require 'win32/taskscheduler'
+    require 'puppet/util/windows/security'
+    true
+  rescue LoadError => err
+    warn "Cannot run on Microsoft Windows without the sys-admin, win32-process, win32-dir, win32-service and win32-taskscheduler gems: #{err}" unless Puppet.features.posix?
+  end
+end
+
+raise Puppet::Error,"Cannot determine basic system flavour" unless Puppet.features.posix? or Puppet.features.microsoft_windows?
+
+# We've got LDAP available.
+Puppet.features.add(:ldap, :libs => ["ldap"])
+
+# We have the Rdoc::Usage library.
+Puppet.features.add(:usage, :libs => %w{rdoc/ri/ri_paths rdoc/usage})
+
+# We have libshadow, useful for managing passwords.
+Puppet.features.add(:libshadow, :libs => ["shadow"])
+
+# We're running as root.
+Puppet.features.add(:root) { require 'puppet/util/suidmanager'; Puppet::Util::SUIDManager.root? }
+
+# We've got mongrel available
+Puppet.features.add(:mongrel, :libs => %w{rubygems mongrel puppet/network/http_server/mongrel})
+
+# We have lcs diff
+Puppet.features.add :diff, :libs => %w{diff/lcs diff/lcs/hunk}
+
+# We have augeas
+Puppet.features.add(:augeas, :libs => ["augeas"])
+
+# We have RRD available
+Puppet.features.add(:rrd_legacy, :libs => ["RRDtool"])
+Puppet.features.add(:rrd, :libs => ["RRD"])
+
+# We have OpenSSL
+Puppet.features.add(:openssl, :libs => ["openssl"])
+
+# We have CouchDB
+Puppet.features.add(:couchdb, :libs => ["couchrest"])
+
+# We have sqlite
+Puppet.features.add(:sqlite, :libs => ["sqlite3"])

data/lib/vendor/puppet/feature/eventlog.rb

@@ -0,0 +1,6 @@
+require 'puppet/util/feature'
+
+if Puppet.features.microsoft_windows?
+  Puppet.features.rubygems?
+  Puppet.features.add(:eventlog, :libs => %{win32/eventlog})
+end

data/lib/vendor/puppet/feature/pson.rb

@@ -0,0 +1,6 @@
+Puppet.features.add(:pson) do
+  require 'puppet/external/pson/common'
+  require 'puppet/external/pson/version'
+  require 'puppet/external/pson/pure'
+  true
+end

data/lib/vendor/puppet/feature/rack.rb

@@ -0,0 +1,24 @@
+require 'puppet/util/feature'
+
+# See if we have rack available, an HTTP Application Stack
+# Explicitly depend on rack library version >= 1.0.0
+Puppet.features.add(:rack) do
+  begin
+    require 'rack'
+  rescue LoadError => detail
+    require 'rubygems'
+    require 'rack'
+  end
+
+  if ! (defined?(::Rack) and defined?(::Rack.release))
+    false
+  else
+    major_version = ::Rack.release.split('.')[0].to_i
+    if major_version >= 1
+      true
+    else
+      false
+    end
+  end
+end
+

data/lib/vendor/puppet/feature/rails.rb

@@ -0,0 +1,30 @@
+require 'puppet/util/feature'
+
+Puppet.features.rubygems?
+
+Puppet.features.add(:rails) do
+  begin
+    require 'active_record'
+    require 'active_record/version'
+  rescue LoadError => detail
+    if FileTest.exists?("/usr/share/rails")
+      count = 0
+      Dir.entries("/usr/share/rails").each do |dir|
+        libdir = File.join("/usr/share/rails", dir, "lib")
+        if FileTest.exists?(libdir) and ! $LOAD_PATH.include?(libdir)
+          count += 1
+          $LOAD_PATH << libdir
+        end
+      end
+
+      retry if count > 0
+    end
+  end
+
+  unless (Puppet::Util.activerecord_version >= 2.1)
+    Puppet.info "ActiveRecord 2.1 or later required for StoreConfigs"
+    false
+  else
+    true
+  end
+end

data/lib/vendor/puppet/feature/rubygems.rb

@@ -0,0 +1,3 @@
+require 'puppet/util/feature'
+
+Puppet.features.add(:rubygems, :libs => "rubygems")

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

@@ -0,0 +1,3 @@
+require 'puppet/util/feature'
+
+Puppet.features.add(:selinux, :libs => ["selinux"])

data/lib/vendor/puppet/feature/ssh.rb

@@ -0,0 +1,4 @@
+require 'puppet/util/feature'
+
+Puppet.features.rubygems?
+Puppet.features.add(:ssh, :libs => %{net/ssh})

data/lib/vendor/puppet/feature/stomp.rb

@@ -0,0 +1,6 @@
+require 'puppet/util/feature'
+
+# We want this to load if possible, but it's not automatically
+# required.
+Puppet.features.rubygems?
+Puppet.features.add(:stomp, :libs => %{stomp})

data/lib/vendor/puppet/feature/zlib.rb

@@ -0,0 +1,6 @@
+require 'puppet/util/feature'
+
+# We want this to load if possible, but it's not automatically
+# required.
+Puppet.features.rubygems?
+Puppet.features.add(:zlib, :libs => %{zlib})

data/lib/vendor/puppet/file_bucket/dipper.rb

@@ -0,0 +1,107 @@
+require 'pathname'
+require 'puppet/file_bucket'
+require 'puppet/file_bucket/file'
+require 'puppet/indirector/request'
+
+class Puppet::FileBucket::Dipper
+  # This is a transitional implementation that uses REST
+  # to access remote filebucket files.
+
+  attr_accessor :name
+
+  # Create our bucket client
+  def initialize(hash = {})
+    # Emulate the XMLRPC client
+    server      = hash[:Server]
+    port        = hash[:Port] || Puppet[:masterport]
+    environment = Puppet[:environment]
+
+    if hash.include?(:Path)
+      @local_path = hash[:Path]
+      @rest_path  = nil
+    else
+      @local_path = nil
+      @rest_path = "https://#{server}:#{port}/#{environment}/file_bucket_file/"
+    end
+  end
+
+  def local?
+    !! @local_path
+  end
+
+  # Back up a file to our bucket
+  def backup(file)
+    raise(ArgumentError, "File #{file} does not exist") unless ::File.exist?(file)
+    contents = IO.binread(file)
+    begin
+      file_bucket_file = Puppet::FileBucket::File.new(contents, :bucket_path => @local_path)
+      files_original_path = absolutize_path(file)
+      dest_path = "#{@rest_path}#{file_bucket_file.name}/#{files_original_path}"
+      file_bucket_path = "#{@rest_path}#{file_bucket_file.checksum_type}/#{file_bucket_file.checksum_data}/#{files_original_path}"
+
+      # Make a HEAD request for the file so that we don't waste time
+      # uploading it if it already exists in the bucket.
+      unless Puppet::FileBucket::File.indirection.head(file_bucket_path)
+        Puppet::FileBucket::File.indirection.save(file_bucket_file, dest_path)
+      end
+
+      return file_bucket_file.checksum_data
+    rescue => detail
+      puts detail.backtrace if Puppet[:trace]
+      raise Puppet::Error, "Could not back up #{file}: #{detail}"
+    end
+  end
+
+  # Retrieve a file by sum.
+  def getfile(sum)
+    source_path = "#{@rest_path}md5/#{sum}"
+    file_bucket_file = Puppet::FileBucket::File.indirection.find(source_path, :bucket_path => @local_path)
+
+    raise Puppet::Error, "File not found" unless file_bucket_file
+    file_bucket_file.to_s
+  end
+
+  # Restore the file
+  def restore(file,sum)
+    restore = true
+    if FileTest.exists?(file)
+      cursum = Digest::MD5.hexdigest(IO.binread(file))
+
+      # if the checksum has changed...
+      # this might be extra effort
+      if cursum == sum
+        restore = false
+      end
+    end
+
+    if restore
+      if newcontents = getfile(sum)
+        tmp = ""
+        newsum = Digest::MD5.hexdigest(newcontents)
+        changed = nil
+        if FileTest.exists?(file) and ! FileTest.writable?(file)
+          changed = ::File.stat(file).mode
+          ::File.chmod(changed | 0200, file)
+        end
+        ::File.open(file, ::File::WRONLY|::File::TRUNC|::File::CREAT) { |of|
+          of.binmode
+          of.print(newcontents)
+        }
+        ::File.chmod(changed, file) if changed
+      else
+        Puppet.err "Could not find file with checksum #{sum}"
+        return nil
+      end
+      return newsum
+    else
+      return nil
+    end
+  end
+
+  private
+  def absolutize_path( path )
+    Pathname.new(path).realpath
+  end
+
+end
+

data/lib/vendor/puppet/file_bucket/file.rb

@@ -0,0 +1,55 @@
+require 'puppet/file_bucket'
+require 'puppet/indirector'
+require 'puppet/util/checksums'
+require 'digest/md5'
+
+class Puppet::FileBucket::File
+  # This class handles the abstract notion of a file in a filebucket.
+  # There are mechanisms to save and load this file locally and remotely in puppet/indirector/filebucketfile/*
+  # There is a compatibility class that emulates pre-indirector filebuckets in Puppet::FileBucket::Dipper
+  extend Puppet::Indirector
+  indirects :file_bucket_file, :terminus_class => :selector
+
+  attr :contents
+  attr :bucket_path
+
+  def initialize(contents, options = {})
+    raise ArgumentError.new("contents must be a String, got a #{contents.class}") unless contents.is_a?(String)
+    @contents = contents
+
+    @bucket_path = options.delete(:bucket_path)
+    raise ArgumentError.new("Unknown option(s): #{options.keys.join(', ')}") unless options.empty?
+  end
+
+  def checksum_type
+    'md5'
+  end
+
+  def checksum
+    "{#{checksum_type}}#{checksum_data}"
+  end
+
+  def checksum_data
+    @checksum_data ||= Digest::MD5.hexdigest(contents)
+  end
+
+  def to_s
+    contents
+  end
+
+  def name
+    "#{checksum_type}/#{checksum_data}"
+  end
+
+  def self.from_s(contents)
+    self.new(contents)
+  end
+
+  def to_pson
+    { "contents" => contents }.to_pson
+  end
+
+  def self.from_pson(pson)
+    self.new(pson["contents"])
+  end
+end

data/lib/vendor/puppet/file_bucket.rb

@@ -0,0 +1,4 @@
+# stub
+module Puppet::FileBucket
+  class BucketError < RuntimeError; end
+end

data/lib/vendor/puppet/file_collection/lookup.rb

@@ -0,0 +1,10 @@
+require 'puppet/file_collection'
+
+module Puppet::FileCollection::Lookup
+  # Yeah, this is all the external interface that was added to the folks who
+  # included this really was.  Thankfully.
+  #
+  # See the comments in `puppet/file_collection.rb` for the annotated version,
+  # or just port your code away from this by adding the accessors on your own.
+  attr_accessor :line, :file
+end

data/lib/vendor/puppet/file_collection.rb

@@ -0,0 +1,19 @@
+# This was a simple way to turn file names into singletons,
+#
+# The theory was, like:
+# 1. Turn filenames into singletons.
+# 2. ????
+# 3. Huge memory savings!
+#
+# In practice it used several MB more memory overall, and it cost more CPU
+# time, and it added complexity to the code.  Which was awesome.
+#
+# So, I gutted it.  It doesn't do anything any more, but we retain the
+# external form that people included so that they don't explode so much.
+#
+# This should be removed from the system after a graceful deprecation period,
+# probably about the time that a version of Puppet containing this change is
+# the last supported version. --daniel 2012-07-17
+class Puppet::FileCollection
+  require 'puppet/file_collection/lookup'
+end

data/lib/vendor/puppet/file_serving/base.rb

@@ -0,0 +1,88 @@
+require 'puppet/file_serving'
+require 'puppet/util'
+
+# The base class for Content and Metadata; provides common
+# functionality like the behaviour around links.
+class Puppet::FileServing::Base
+  # This is for external consumers to store the source that was used
+  # to retrieve the metadata.
+  attr_accessor :source
+
+  # Does our file exist?
+  def exist?
+      stat
+      return true
+  rescue => detail
+      return false
+  end
+
+  # Return the full path to our file.  Fails if there's no path set.
+  def full_path(dummy_argument=:work_arround_for_ruby_GC_bug)
+    (if relative_path.nil? or relative_path == "" or relative_path == "."
+       path
+     else
+       File.join(path, relative_path)
+     end).gsub(%r{//+}, "/")
+  end
+
+  def initialize(path, options = {})
+    self.path = path
+    @links = :manage
+
+    options.each do |param, value|
+      begin
+        send param.to_s + "=", value
+      rescue NoMethodError
+        raise ArgumentError, "Invalid option #{param} for #{self.class}"
+      end
+    end
+  end
+
+  # Determine how we deal with links.
+  attr_reader :links
+  def links=(value)
+    value = value.to_sym
+    value = :manage if value == :ignore
+    raise(ArgumentError, ":links can only be set to :manage or :follow") unless [:manage, :follow].include?(value)
+    @links = value
+  end
+
+  # Set our base path.
+  attr_reader :path
+  def path=(path)
+    raise ArgumentError.new("Paths must be fully qualified") unless Puppet::FileServing::Base.absolute?(path)
+    @path = path
+  end
+
+  # Set a relative path; this is used for recursion, and sets
+  # the file's path relative to the initial recursion point.
+  attr_reader :relative_path
+  def relative_path=(path)
+    raise ArgumentError.new("Relative paths must not be fully qualified") if Puppet::FileServing::Base.absolute?(path)
+    @relative_path = path
+  end
+
+  # Stat our file, using the appropriate link-sensitive method.
+  def stat
+    @stat_method ||= self.links == :manage ? :lstat : :stat
+    File.send(@stat_method, full_path)
+  end
+
+  def to_pson_data_hash
+    {
+      # No 'document_type' since we don't send these bare
+      'data'       => {
+        'path'          => @path,
+        'relative_path' => @relative_path,
+        'links'         => @links
+        },
+      'metadata' => {
+        'api_version' => 1
+        }
+    }
+  end
+
+  def self.absolute?(path)
+    Puppet::Util.absolute_path?(path, :posix) or (Puppet.features.microsoft_windows? and Puppet::Util.absolute_path?(path, :windows))
+  end
+end

data/lib/vendor/puppet/file_serving/configuration/parser.rb

@@ -0,0 +1,115 @@
+require 'puppet/file_serving/configuration'
+require 'puppet/util/loadedfile'
+
+class Puppet::FileServing::Configuration::Parser < Puppet::Util::LoadedFile
+  Mount = Puppet::FileServing::Mount
+  MODULES = 'modules'
+
+  # Parse our configuration file.
+  def parse
+    raise("File server configuration #{self.file} does not exist") unless FileTest.exists?(self.file)
+    raise("Cannot read file server configuration #{self.file}") unless FileTest.readable?(self.file)
+
+    @mounts = {}
+    @count = 0
+
+    File.open(self.file) { |f|
+      mount = nil
+      f.each_line { |line|
+        # Have the count increment at the top, in case we throw exceptions.
+        @count += 1
+
+        case line
+        when /^\s*#/; next # skip comments
+        when /^\s*$/; next # skip blank lines
+        when /\[([-\w]+)\]/
+          mount = newmount($1)
+        when /^\s*(\w+)\s+(.+?)(\s*#.*)?$/
+          var = $1
+          value = $2
+          value.strip!
+          raise(ArgumentError, "Fileserver configuration file does not use '=' as a separator") if value =~ /^=/
+          case var
+          when "path"
+            path(mount, value)
+          when "allow"
+            allow(mount, value)
+          when "deny"
+            deny(mount, value)
+          else
+            raise ArgumentError.new("Invalid argument '#{var}'", @count, file)
+          end
+        else
+          raise ArgumentError.new("Invalid line '#{line.chomp}'", @count, file)
+        end
+      }
+    }
+
+    validate
+
+    @mounts
+  end
+
+  private
+
+  # Allow a given pattern access to a mount.
+  def allow(mount, value)
+    # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com]
+    x = value.split(/\s*,\s*/).each { |val|
+      begin
+        mount.info "allowing #{val} access"
+        mount.allow(val)
+      rescue Puppet::AuthStoreError => detail
+        raise ArgumentError.new(detail.to_s, @count, file)
+      end
+    }
+  end
+
+  # Deny a given pattern access to a mount.
+  def deny(mount, value)
+    # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com]
+    x = value.split(/\s*,\s*/).each { |val|
+      begin
+        mount.info "denying #{val} access"
+        mount.deny(val)
+      rescue Puppet::AuthStoreError => detail
+        raise ArgumentError.new(detail.to_s, @count, file)
+      end
+    }
+  end
+
+  # Create a new mount.
+  def newmount(name)
+    raise ArgumentError, "#{@mounts[name]} is already mounted at #{name}", @count, file if @mounts.include?(name)
+    case name
+    when "modules"
+      mount = Mount::Modules.new(name)
+    when "plugins"
+      mount = Mount::Plugins.new(name)
+    else
+      mount = Mount::File.new(name)
+    end
+    @mounts[name] = mount
+    mount
+  end
+
+  # Set the path for a mount.
+  def path(mount, value)
+    if mount.respond_to?(:path=)
+      begin
+        mount.path = value
+      rescue ArgumentError => detail
+        Puppet.err "Removing mount #{mount.name}: #{detail}"
+        @mounts.delete(mount.name)
+      end
+    else
+      Puppet.warning "The '#{mount.name}' module can not have a path. Ignoring attempt to set it"
+    end
+  end
+
+  # Make sure all of our mounts are valid.  We have to do this after the fact
+  # because details are added over time as the file is parsed.
+  def validate
+    @mounts.each { |name, mount| mount.validate }
+  end
+end