puppet-parse 0.0.1 → 0.0.2

data/lib/vendor/puppet/indirector/ssl_file.rb

@@ -0,0 +1,178 @@
+require 'puppet/ssl'
+
+class Puppet::Indirector::SslFile < Puppet::Indirector::Terminus
+  # Specify the directory in which multiple files are stored.
+  def self.store_in(setting)
+    @directory_setting = setting
+  end
+
+  # Specify a single file location for storing just one file.
+  # This is used for things like the CRL.
+  def self.store_at(setting)
+    @file_setting = setting
+  end
+
+  # Specify where a specific ca file should be stored.
+  def self.store_ca_at(setting)
+    @ca_setting = setting
+  end
+
+  class << self
+    attr_reader :directory_setting, :file_setting, :ca_setting
+  end
+
+  # The full path to where we should store our files.
+  def self.collection_directory
+    return nil unless directory_setting
+    Puppet.settings[directory_setting]
+  end
+
+  # The full path to an individual file we would be managing.
+  def self.file_location
+    return nil unless file_setting
+    Puppet.settings[file_setting]
+  end
+
+  # The full path to a ca file we would be managing.
+  def self.ca_location
+    return nil unless ca_setting
+    Puppet.settings[ca_setting]
+  end
+
+  # We assume that all files named 'ca' are pointing to individual ca files,
+  # rather than normal host files.  It's a bit hackish, but all the other
+  # solutions seemed even more hackish.
+  def ca?(name)
+    name == Puppet::SSL::Host.ca_name
+  end
+
+  def initialize
+    Puppet.settings.use(:main, :ssl)
+
+    (collection_directory || file_location) or raise Puppet::DevError, "No file or directory setting provided; terminus #{self.class.name} cannot function"
+  end
+
+  def path(name)
+    if name =~ Puppet::Indirector::BadNameRegexp then
+      Puppet.crit("directory traversal detected in #{self.class}: #{name.inspect}")
+      raise ArgumentError, "invalid key"
+    end
+
+    if ca?(name) and ca_location
+      ca_location
+    elsif collection_directory
+      File.join(collection_directory, name.to_s + ".pem")
+    else
+      file_location
+    end
+  end
+
+  # Remove our file.
+  def destroy(request)
+    path = path(request.key)
+    return false unless FileTest.exist?(path)
+
+    Puppet.notice "Removing file #{model} #{request.key} at '#{path}'"
+    begin
+      File.unlink(path)
+    rescue => detail
+      raise Puppet::Error, "Could not remove #{request.key}: #{detail}"
+    end
+  end
+
+  # Find the file on disk, returning an instance of the model.
+  def find(request)
+    path = path(request.key)
+
+    return nil unless FileTest.exist?(path) or rename_files_with_uppercase(path)
+
+    result = model.new(request.key)
+    result.read(path)
+    result
+  end
+
+  # Save our file to disk.
+  def save(request)
+    path = path(request.key)
+    dir = File.dirname(path)
+
+    raise Puppet::Error.new("Cannot save #{request.key}; parent directory #{dir} does not exist") unless FileTest.directory?(dir)
+    raise Puppet::Error.new("Cannot save #{request.key}; parent directory #{dir} is not writable") unless FileTest.writable?(dir)
+
+    write(request.key, path) { |f| f.print request.instance.to_s }
+  end
+
+  # Search for more than one file.  At this point, it just returns
+  # an instance for every file in the directory.
+  def search(request)
+    dir = collection_directory
+    Dir.entries(dir).reject { |file| file !~ /\.pem$/ }.collect do |file|
+      name = file.sub(/\.pem$/, '')
+      result = model.new(name)
+      result.read(File.join(dir, file))
+      result
+    end
+  end
+
+  private
+
+  # Demeterish pointers to class info.
+  def collection_directory
+    self.class.collection_directory
+  end
+
+  def file_location
+    self.class.file_location
+  end
+
+  def ca_location
+    self.class.ca_location
+  end
+
+  # A hack method to deal with files that exist with a different case.
+  # Just renames it; doesn't read it in or anything.
+  # LAK:NOTE This is a copy of the method in sslcertificates/support.rb,
+  # which we'll be EOL'ing at some point.  This method was added at 20080702
+  # and should be removed at some point.
+  def rename_files_with_uppercase(file)
+    dir, short = File.split(file)
+    return nil unless FileTest.exist?(dir)
+
+    raise ArgumentError, "Tried to fix SSL files to a file containing uppercase" unless short.downcase == short
+    real_file = Dir.entries(dir).reject { |f| f =~ /^\./ }.find do |other|
+      other.downcase == short
+    end
+
+    return nil unless real_file
+
+    full_file = File.join(dir, real_file)
+
+    Puppet.notice "Fixing case in #{full_file}; renaming to #{file}"
+    File.rename(full_file, file)
+
+    true
+  end
+
+  # Yield a filehandle set up appropriately, either with our settings doing
+  # the work or opening a filehandle manually.
+  def write(name, path)
+    if ca?(name) and ca_location
+      Puppet.settings.write(self.class.ca_setting) { |f| yield f }
+    elsif file_location
+      Puppet.settings.write(self.class.file_setting) { |f| yield f }
+    elsif setting = self.class.directory_setting
+      begin
+        Puppet.settings.writesub(setting, path) { |f| yield f }
+      rescue => detail
+        raise Puppet::Error, "Could not write #{path} to #{setting}: #{detail}"
+      end
+    else
+      raise Puppet::DevError, "You must provide a setting to determine where the files are stored"
+    end
+  end
+end
+
+# LAK:NOTE This has to be at the end, because classes like SSL::Key use this
+# class, and this require statement loads those, which results in a load loop
+# and lots of failures.
+require 'puppet/ssl/host'

data/lib/vendor/puppet/indirector/status/local.rb

@@ -0,0 +1,7 @@
+require 'puppet/indirector/status'
+
+class Puppet::Indirector::Status::Local < Puppet::Indirector::Code
+  def find( *anything )
+    model.new
+  end
+end

data/lib/vendor/puppet/indirector/status/rest.rb

@@ -0,0 +1,5 @@
+require 'puppet/indirector/status'
+require 'puppet/indirector/rest'
+
+class Puppet::Indirector::Status::Rest < Puppet::Indirector::REST
+end

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

@@ -0,0 +1,3 @@
+# A stub class, so our constants work.
+class Puppet::Indirector::Status
+end

data/lib/vendor/puppet/indirector/store_configs.rb

@@ -0,0 +1,30 @@
+class Puppet::Indirector::StoreConfigs < Puppet::Indirector::Terminus
+  def initialize
+    super
+    # This will raise if the indirection can't be found, so we can assume it
+    # is always set to a valid instance from here on in.
+    @target = indirection.terminus Puppet[:storeconfigs_backend]
+  end
+
+  attr_reader :target
+
+  def head(request)
+    target.head request
+  end
+
+  def find(request)
+    target.find request
+  end
+
+  def search(request)
+    target.search request
+  end
+
+  def save(request)
+    target.save request
+  end
+
+  def destroy(request)
+    target.save request
+  end
+end

data/lib/vendor/puppet/indirector/terminus.rb

@@ -0,0 +1,145 @@
+require 'puppet/indirector'
+require 'puppet/indirector/indirection'
+require 'puppet/util/instance_loader'
+
+# A simple class that can function as the base class for indirected types.
+class Puppet::Indirector::Terminus
+  require 'puppet/util/docs'
+  extend Puppet::Util::Docs
+
+  class << self
+    include Puppet::Util::InstanceLoader
+
+    attr_accessor :name, :terminus_type
+    attr_reader :abstract_terminus, :indirection
+
+    # Are we an abstract terminus type, rather than an instance with an
+    # associated indirection?
+    def abstract_terminus?
+      abstract_terminus
+    end
+
+    # Convert a constant to a short name.
+    def const2name(const)
+      const.sub(/^[A-Z]/) { |i| i.downcase }.gsub(/[A-Z]/) { |i| "_#{i.downcase}" }.intern
+    end
+
+    # Look up the indirection if we were only provided a name.
+    def indirection=(name)
+      if name.is_a?(Puppet::Indirector::Indirection)
+        @indirection = name
+      elsif ind = Puppet::Indirector::Indirection.instance(name)
+        @indirection = ind
+      else
+        raise ArgumentError, "Could not find indirection instance #{name} for #{self.name}"
+      end
+    end
+
+    def indirection_name
+      @indirection.name
+    end
+
+    # Register our subclass with the appropriate indirection.
+    # This follows the convention that our terminus is named after the
+    # indirection.
+    def inherited(subclass)
+      longname = subclass.to_s
+      if longname =~ /#<Class/
+        raise Puppet::DevError, "Terminus subclasses must have associated constants"
+      end
+      names = longname.split("::")
+
+      # Convert everything to a lower-case symbol, converting camelcase to underscore word separation.
+      name = names.pop.sub(/^[A-Z]/) { |i| i.downcase }.gsub(/[A-Z]/) { |i| "_#{i.downcase}" }.intern
+
+      subclass.name = name
+
+      # Short-circuit the abstract types, which are those that directly subclass
+      # the Terminus class.
+      if self == Puppet::Indirector::Terminus
+        subclass.mark_as_abstract_terminus
+        return
+      end
+
+      # Set the terminus type to be the name of the abstract terminus type.
+      # Yay, class/instance confusion.
+      subclass.terminus_type = self.name
+
+      # Our subclass is specifically associated with an indirection.
+      raise("Invalid name #{longname}") unless names.length > 0
+      indirection_name = names.pop.sub(/^[A-Z]/) { |i| i.downcase }.gsub(/[A-Z]/) { |i| "_#{i.downcase}" }.intern
+
+      if indirection_name == "" or indirection_name.nil?
+        raise Puppet::DevError, "Could not discern indirection model from class constant"
+      end
+
+      # This will throw an exception if the indirection instance cannot be found.
+      # Do this last, because it also registers the terminus type with the indirection,
+      # which needs the above information.
+      subclass.indirection = indirection_name
+
+      # And add this instance to the instance hash.
+      Puppet::Indirector::Terminus.register_terminus_class(subclass)
+    end
+
+    # Mark that this instance is abstract.
+    def mark_as_abstract_terminus
+      @abstract_terminus = true
+    end
+
+    def model
+      indirection.model
+    end
+
+    # Convert a short name to a constant.
+    def name2const(name)
+      name.to_s.capitalize.sub(/_(.)/) { |i| $1.upcase }
+    end
+
+    # Register a class, probably autoloaded.
+    def register_terminus_class(klass)
+      setup_instance_loading klass.indirection_name
+      instance_hash(klass.indirection_name)[klass.name] = klass
+    end
+
+    # Return a terminus by name, using the autoloader.
+    def terminus_class(indirection_name, terminus_type)
+      setup_instance_loading indirection_name
+      loaded_instance(indirection_name, terminus_type)
+    end
+
+    # Return all terminus classes for a given indirection.
+    def terminus_classes(indirection_name)
+      setup_instance_loading indirection_name
+      instance_loader(indirection_name).files_to_load.map do |file|
+        File.basename(file).chomp(".rb").intern
+      end
+    end
+
+    private
+
+    def setup_instance_loading(type)
+      instance_load type, "puppet/indirector/#{type}" unless instance_loading?(type)
+    end
+  end
+
+  def indirection
+    self.class.indirection
+  end
+
+  def initialize
+    raise Puppet::DevError, "Cannot create instances of abstract terminus types" if self.class.abstract_terminus?
+  end
+
+  def model
+    self.class.model
+  end
+
+  def name
+    self.class.name
+  end
+
+  def terminus_type
+    self.class.terminus_type
+  end
+end

data/lib/vendor/puppet/indirector/yaml.rb

@@ -0,0 +1,75 @@
+require 'puppet/indirector/terminus'
+require 'puppet/util/file_locking'
+
+# The base class for YAML indirection termini.
+class Puppet::Indirector::Yaml < Puppet::Indirector::Terminus
+  include Puppet::Util::FileLocking
+
+  # Read a given name's file in and convert it from YAML.
+  def find(request)
+    file = path(request.key)
+    return nil unless FileTest.exist?(file)
+
+    yaml = nil
+    begin
+      readlock(file) { |fh| yaml = fh.read }
+    rescue => detail
+      raise Puppet::Error, "Could not read YAML data for #{indirection.name} #{request.key}: #{detail}"
+    end
+    begin
+      return from_yaml(yaml)
+    rescue => detail
+      raise Puppet::Error, "Could not parse YAML data for #{indirection.name} #{request.key}: #{detail}"
+    end
+  end
+
+  # Convert our object to YAML and store it to the disk.
+  def save(request)
+    raise ArgumentError.new("You can only save objects that respond to :name") unless request.instance.respond_to?(:name)
+
+    file = path(request.key)
+
+    basedir = File.dirname(file)
+
+    # This is quite likely a bad idea, since we're not managing ownership or modes.
+    Dir.mkdir(basedir) unless FileTest.exist?(basedir)
+
+    begin
+      writelock(file, 0660) { |f| f.print to_yaml(request.instance) }
+    rescue TypeError => detail
+      Puppet.err "Could not save #{self.name} #{request.key}: #{detail}"
+    end
+  end
+
+  # Return the path to a given node's file.
+  def path(name,ext='.yaml')
+    if name =~ Puppet::Indirector::BadNameRegexp then
+      Puppet.crit("directory traversal detected in #{self.class}: #{name.inspect}")
+      raise ArgumentError, "invalid key"
+    end
+
+    base = Puppet.run_mode.master? ? Puppet[:yamldir] : Puppet[:clientyamldir]
+    File.join(base, self.class.indirection_name.to_s, name.to_s + ext)
+  end
+
+  def destroy(request)
+    file_path = path(request.key)
+    File.unlink(file_path) if File.exists?(file_path)
+  end
+
+  def search(request)
+    Dir.glob(path(request.key,'')).collect do |file|
+      YAML.load_file(file)
+    end
+  end
+
+  private
+
+  def from_yaml(text)
+    YAML.load(text)
+  end
+
+  def to_yaml(object)
+    YAML.dump(object)
+  end
+end

data/lib/vendor/puppet/indirector.rb

@@ -0,0 +1,57 @@
+# Manage indirections to termini.  They are organized in terms of indirections -
+# - e.g., configuration, node, file, certificate -- and each indirection has one
+# or more terminus types defined.  The indirection is configured via the
+# +indirects+ method, which will be called by the class extending itself
+# with this module.
+module Puppet::Indirector
+  # LAK:FIXME We need to figure out how to handle documentation for the
+  # different indirection types.
+
+  require 'puppet/indirector/indirection'
+  require 'puppet/indirector/terminus'
+  require 'puppet/indirector/envelope'
+  require 'puppet/network/format_handler'
+
+  def self.configure_routes(application_routes)
+    application_routes.each do |indirection_name, termini|
+      indirection_name = indirection_name.to_sym
+      terminus_name = termini["terminus"]
+      cache_name    = termini["cache"]
+
+      Puppet::Indirector::Terminus.terminus_class(indirection_name, terminus_name || cache_name)
+
+      indirection = Puppet::Indirector::Indirection.instance(indirection_name)
+      raise "Indirection #{indirection_name} does not exist" unless indirection
+
+      indirection.terminus_class = terminus_name if terminus_name
+      indirection.cache_class = cache_name if cache_name
+    end
+  end
+
+  # Declare that the including class indirects its methods to
+  # this terminus.  The terminus name must be the name of a Puppet
+  # default, not the value -- if it's the value, then it gets
+  # evaluated at parse time, which is before the user has had a chance
+  # to override it.
+  def indirects(indirection, options = {})
+    raise(ArgumentError, "Already handling indirection for #{@indirection.name}; cannot also handle #{indirection}") if @indirection
+    # populate this class with the various new methods
+    extend ClassMethods
+    include Puppet::Indirector::Envelope
+    extend Puppet::Network::FormatHandler
+
+    # instantiate the actual Terminus for that type and this name (:ldap, w/ args :node)
+    # & hook the instantiated Terminus into this class (Node: @indirection = terminus)
+    @indirection = Puppet::Indirector::Indirection.new(self, indirection,  options)
+  end
+
+  module ClassMethods
+    attr_reader :indirection
+  end
+
+  # Helper definition for indirections that handle filenames.
+  BadNameRegexp = Regexp.union(/^\.\./,
+                               %r{[\\/]},
+                               "\0",
+                               /(?i)^[a-z]:/)
+end