puppet-parse 0.0.1 → 0.0.2

data/lib/vendor/puppet/indirector/facts/facter.rb

@@ -0,0 +1,96 @@
+require 'puppet/node/facts'
+require 'puppet/indirector/code'
+
+class Puppet::Node::Facts::Facter < Puppet::Indirector::Code
+  desc "Retrieve facts from Facter.  This provides a somewhat abstract interface
+    between Puppet and Facter.  It's only `somewhat` abstract because it always
+    returns the local host's facts, regardless of what you attempt to find."
+
+
+  # Clear out all of the loaded facts. Reload facter but not puppet facts.
+  # NOTE: This is clumsy and shouldn't be required for later (1.5.x) versions
+  # of Facter.
+  def self.reload_facter
+    Facter.clear
+
+    # Reload everything.
+    if Facter.respond_to? :loadfacts
+      Facter.loadfacts
+    elsif Facter.respond_to? :load
+      Facter.load
+    else
+      Puppet.warning "You should upgrade your version of Facter to at least 1.3.8"
+    end
+  end
+
+  def self.load_fact_plugins
+    # Add any per-module fact directories to the factpath
+    module_fact_dirs = Puppet[:modulepath].split(File::PATH_SEPARATOR).collect do |d|
+      ["lib", "plugins"].map do |subdirectory|
+        Dir.glob("#{d}/*/#{subdirectory}/facter")
+      end
+    end.flatten
+    dirs = module_fact_dirs + Puppet[:factpath].split(File::PATH_SEPARATOR)
+    x = dirs.uniq.each do |dir|
+      load_facts_in_dir(dir)
+    end
+  end
+
+  def self.load_facts_in_dir(dir)
+    return unless FileTest.directory?(dir)
+
+    Dir.chdir(dir) do
+      Dir.glob("*.rb").each do |file|
+        fqfile = ::File.join(dir, file)
+        begin
+          Puppet.info "Loading facts in #{fqfile}"
+          Timeout::timeout(self.timeout) do
+            load file
+          end
+        rescue SystemExit,NoMemoryError
+          raise
+        rescue Exception => detail
+          Puppet.warning "Could not load fact file #{fqfile}: #{detail}"
+        end
+      end
+    end
+  end
+
+  def self.timeout
+    timeout = Puppet[:configtimeout]
+    case timeout
+    when String
+      if timeout =~ /^\d+$/
+        timeout = Integer(timeout)
+      else
+        raise ArgumentError, "Configuration timeout must be an integer"
+      end
+    when Integer # nothing
+    else
+      raise ArgumentError, "Configuration timeout must be an integer"
+    end
+
+    timeout
+  end
+
+  def destroy(facts)
+    raise Puppet::DevError, "You cannot destroy facts in the code store; it is only used for getting facts from Facter"
+  end
+
+  # Look a host's facts up in Facter.
+  def find(request)
+    self.class.reload_facter
+    self.class.load_fact_plugins
+    result = Puppet::Node::Facts.new(request.key, Facter.to_hash)
+
+    result.add_local_facts
+    result.stringify
+    result.downcase_if_necessary
+
+    result
+  end
+
+  def save(facts)
+    raise Puppet::DevError, "You cannot save facts to the code store; it is only used for getting facts from Facter"
+  end
+end

data/lib/vendor/puppet/indirector/facts/inventory_active_record.rb

@@ -0,0 +1,100 @@
+require 'puppet/rails'
+require 'puppet/rails/inventory_node'
+require 'puppet/rails/inventory_fact'
+require 'puppet/indirector/active_record'
+require 'puppet/util/retryaction'
+
+class Puppet::Node::Facts::InventoryActiveRecord < Puppet::Indirector::ActiveRecord
+  def find(request)
+    node = Puppet::Rails::InventoryNode.find_by_name(request.key)
+    return nil unless node
+    facts = Puppet::Node::Facts.new(node.name, node.facts_to_hash)
+    facts.timestamp = node.timestamp
+    facts
+  end
+
+  def save(request)
+    Puppet::Util::RetryAction.retry_action :retries => 4, :retry_exceptions => {ActiveRecord::StatementInvalid => 'MySQL Error.  Retrying'} do
+      facts = request.instance
+      node = Puppet::Rails::InventoryNode.find_by_name(request.key) || Puppet::Rails::InventoryNode.create(:name => request.key, :timestamp => facts.timestamp)
+      node.timestamp = facts.timestamp
+
+      ActiveRecord::Base.transaction do
+        Puppet::Rails::InventoryFact.delete_all(:node_id => node.id)
+        # We don't want to save internal values as facts, because those are
+        # metadata that belong on the node
+        facts.values.each do |name,value|
+          next if name.to_s =~ /^_/
+          node.facts.build(:name => name, :value => value)
+        end
+        node.save
+      end
+    end
+  end
+
+  def search(request)
+    return [] unless request.options
+    matching_nodes = []
+    fact_names = []
+    fact_filters = Hash.new {|h,k| h[k] = []}
+    meta_filters = Hash.new {|h,k| h[k] = []}
+    request.options.each do |key,value|
+      type, name, operator = key.to_s.split(".")
+      operator ||= "eq"
+      if type == "facts"
+        fact_filters[operator] << [name,value]
+      elsif type == "meta" and name == "timestamp"
+        meta_filters[operator] << [name,value]
+      end
+    end
+
+    matching_nodes = nodes_matching_fact_filters(fact_filters) + nodes_matching_meta_filters(meta_filters)
+
+    # to_a because [].inject == nil
+    matching_nodes.inject {|nodes,this_set| nodes & this_set}.to_a.sort
+  end
+
+  private
+
+  def nodes_matching_fact_filters(fact_filters)
+    node_sets = []
+    fact_filters['eq'].each do |name,value|
+      node_sets << Puppet::Rails::InventoryNode.has_fact_with_value(name,value).map {|node| node.name}
+    end
+    fact_filters['ne'].each do |name,value|
+      node_sets << Puppet::Rails::InventoryNode.has_fact_without_value(name,value).map {|node| node.name}
+    end
+    {
+      'gt' => '>',
+      'lt' => '<',
+      'ge' => '>=',
+      'le' => '<='
+    }.each do |operator_name,operator|
+      fact_filters[operator_name].each do |name,value|
+        facts = Puppet::Rails::InventoryFact.find_by_sql(["SELECT inventory_facts.value, inventory_nodes.name AS node_name
+                                                           FROM inventory_facts INNER JOIN inventory_nodes
+                                                           ON inventory_facts.node_id = inventory_nodes.id
+                                                           WHERE inventory_facts.name = ?", name])
+        node_sets << facts.select {|fact| fact.value.to_f.send(operator, value.to_f)}.map {|fact| fact.node_name}
+      end
+    end
+    node_sets
+  end
+
+  def nodes_matching_meta_filters(meta_filters)
+    node_sets = []
+    {
+      'eq' => '=',
+      'ne' => '!=',
+      'gt' => '>',
+      'lt' => '<',
+      'ge' => '>=',
+      'le' => '<='
+    }.each do |operator_name,operator|
+      meta_filters[operator_name].each do |name,value|
+        node_sets << Puppet::Rails::InventoryNode.find(:all, :select => "name", :conditions => ["timestamp #{operator} ?", value]).map {|node| node.name}
+      end
+    end
+    node_sets
+  end
+end

data/lib/vendor/puppet/indirector/facts/inventory_service.rb

@@ -0,0 +1,20 @@
+require 'puppet/node/facts'
+require 'puppet/indirector/rest'
+
+class Puppet::Node::Facts::InventoryService < Puppet::Indirector::REST
+  desc "Find and save facts about nodes using a remote inventory service."
+  use_server_setting(:inventory_server)
+  use_port_setting(:inventory_port)
+
+  # We don't want failing to upload to the inventory service to cause any
+  # failures, so we just suppress them and warn.
+  def save(request)
+    begin
+      super
+      true
+    rescue => e
+      Puppet.warning "Could not upload facts for #{request.key} to inventory service: #{e.to_s}"
+      false
+    end
+  end
+end

data/lib/vendor/puppet/indirector/facts/memory.rb

@@ -0,0 +1,9 @@
+require 'puppet/node/facts'
+require 'puppet/indirector/memory'
+
+class Puppet::Node::Facts::Memory < Puppet::Indirector::Memory
+  desc "Keep track of facts in memory but nowhere else.  This is used for
+    one-time compiles, such as what the stand-alone `puppet` does.
+    To use this terminus, you must load it with the data you want it
+    to contain."
+end

data/lib/vendor/puppet/indirector/facts/network_device.rb

@@ -0,0 +1,25 @@
+require 'puppet/node/facts'
+require 'puppet/indirector/code'
+
+class Puppet::Node::Facts::NetworkDevice < Puppet::Indirector::Code
+  desc "Retrieve facts from a network device."
+
+  # Look a device's facts up through the current device.
+  def find(request)
+    result = Puppet::Node::Facts.new(request.key, Puppet::Util::NetworkDevice.current.facts)
+
+    result.add_local_facts
+    result.stringify
+    result.downcase_if_necessary
+
+    result
+  end
+
+  def destroy(facts)
+    raise Puppet::DevError, "You cannot destroy facts in the code store; it is only used for getting facts from a remote device"
+  end
+
+  def save(facts)
+    raise Puppet::DevError, "You cannot save facts to the code store; it is only used for getting facts from a remote device"
+  end
+end

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

@@ -0,0 +1,8 @@
+require 'puppet/node/facts'
+require 'puppet/indirector/rest'
+
+class Puppet::Node::Facts::Rest < Puppet::Indirector::REST
+  desc "Find and save facts about nodes over HTTP via REST."
+  use_server_setting(:inventory_server)
+  use_port_setting(:inventory_port)
+end

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

@@ -0,0 +1,5 @@
+require 'puppet/node/facts'
+require 'puppet/indirector/store_configs'
+
+class Puppet::Node::Facts::StoreConfigs < Puppet::Indirector::StoreConfigs
+end

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

@@ -0,0 +1,82 @@
+require 'puppet/node/facts'
+require 'puppet/indirector/yaml'
+
+class Puppet::Node::Facts::Yaml < Puppet::Indirector::Yaml
+  desc "Store client facts as flat files, serialized using YAML, or
+    return deserialized facts from disk."
+
+  def search(request)
+    node_names = []
+    Dir.glob(yaml_dir_path).each do |file|
+      facts = YAML.load_file(file)
+      node_names << facts.name if node_matches?(facts, request.options)
+    end
+    node_names
+  end
+
+  private
+
+  # Return the path to a given node's file.
+  def yaml_dir_path
+    base = Puppet.run_mode.master? ? Puppet[:yamldir] : Puppet[:clientyamldir]
+    File.join(base, 'facts', '*.yaml')
+  end
+
+  def node_matches?(facts, options)
+    options.each do |key, value|
+      type, name, operator = key.to_s.split(".")
+      operator ||= 'eq'
+
+      return false unless node_matches_option?(type, name, operator, value, facts)
+    end
+    return true
+  end
+
+  def node_matches_option?(type, name, operator, value, facts)
+    case type
+    when "meta"
+      case name
+      when "timestamp"
+        compare_timestamp(operator, facts.timestamp, Time.parse(value))
+      end
+    when "facts"
+      compare_facts(operator, facts.values[name], value)
+    end
+  end
+
+  def compare_facts(operator, value1, value2)
+    return false unless value1
+
+    case operator
+    when "eq"
+      value1.to_s == value2.to_s
+    when "le"
+      value1.to_f <= value2.to_f
+    when "ge"
+      value1.to_f >= value2.to_f
+    when "lt"
+      value1.to_f < value2.to_f
+    when "gt"
+      value1.to_f > value2.to_f
+    when "ne"
+      value1.to_s != value2.to_s
+    end
+  end
+
+  def compare_timestamp(operator, value1, value2)
+    case operator
+    when "eq"
+      value1 == value2
+    when "le"
+      value1 <= value2
+    when "ge"
+      value1 >= value2
+    when "lt"
+      value1 < value2
+    when "gt"
+      value1 > value2
+    when "ne"
+      value1 != value2
+    end
+  end
+end

data/lib/vendor/puppet/indirector/file_bucket_file/file.rb

@@ -0,0 +1,136 @@
+require 'puppet/indirector/code'
+require 'puppet/file_bucket/file'
+require 'puppet/util/checksums'
+require 'fileutils'
+
+module Puppet::FileBucketFile
+  class File < Puppet::Indirector::Code
+    include Puppet::Util::Checksums
+
+    desc "Store files in a directory set based on their checksums."
+
+    def initialize
+      Puppet.settings.use(:filebucket)
+    end
+
+    def find( request )
+      checksum, files_original_path = request_to_checksum_and_path( request )
+      dir_path = path_for(request.options[:bucket_path], checksum)
+      file_path = ::File.join(dir_path, 'contents')
+
+      return nil unless ::File.exists?(file_path)
+      return nil unless path_match(dir_path, files_original_path)
+
+      if request.options[:diff_with]
+        hash_protocol = sumtype(checksum)
+        file2_path = path_for(request.options[:bucket_path], request.options[:diff_with], 'contents')
+        raise "could not find diff_with #{request.options[:diff_with]}" unless ::File.exists?(file2_path)
+        return `diff #{file_path.inspect} #{file2_path.inspect}`
+      else
+        contents = IO.binread(file_path)
+        Puppet.info "FileBucket read #{checksum}"
+        model.new(contents)
+      end
+    end
+
+    def head(request)
+      checksum, files_original_path = request_to_checksum_and_path(request)
+      dir_path = path_for(request.options[:bucket_path], checksum)
+
+      ::File.exists?(::File.join(dir_path, 'contents')) and path_match(dir_path, files_original_path)
+    end
+
+    def save( request )
+      instance = request.instance
+      checksum, files_original_path = request_to_checksum_and_path(request)
+
+      save_to_disk(instance, files_original_path)
+      instance.to_s
+    end
+
+    private
+
+    def path_match(dir_path, files_original_path)
+      return true unless files_original_path # if no path was provided, it's a match
+      paths_path = ::File.join(dir_path, 'paths')
+      return false unless ::File.exists?(paths_path)
+      ::File.open(paths_path) do |f|
+        f.each_line do |line|
+          return true if line.chomp == files_original_path
+        end
+      end
+      return false
+    end
+
+    def save_to_disk( bucket_file, files_original_path )
+      filename = path_for(bucket_file.bucket_path, bucket_file.checksum_data, 'contents')
+      dir_path = path_for(bucket_file.bucket_path, bucket_file.checksum_data)
+      paths_path = ::File.join(dir_path, 'paths')
+
+      # If the file already exists, do nothing.
+      if ::File.exist?(filename)
+        verify_identical_file!(bucket_file)
+      else
+        # Make the directories if necessary.
+        unless ::File.directory?(dir_path)
+          Puppet::Util.withumask(0007) do
+            ::FileUtils.mkdir_p(dir_path)
+          end
+        end
+
+        Puppet.info "FileBucket adding #{bucket_file.checksum}"
+
+        # Write the file to disk.
+        Puppet::Util.withumask(0007) do
+          ::File.open(filename, ::File::WRONLY|::File::CREAT, 0440) do |of|
+            of.binmode
+            of.print bucket_file.contents
+          end
+          ::File.open(paths_path, ::File::WRONLY|::File::CREAT, 0640) do |of|
+            # path will be written below
+          end
+        end
+      end
+
+      unless path_match(dir_path, files_original_path)
+        ::File.open(paths_path, 'a') do |f|
+          f.puts(files_original_path)
+        end
+      end
+    end
+
+    def request_to_checksum_and_path( request )
+      checksum_type, checksum, path = request.key.split(/\//, 3)
+      if path == '' # Treat "md5/<checksum>/" like "md5/<checksum>"
+        path = nil
+      end
+      raise "Unsupported checksum type #{checksum_type.inspect}" if checksum_type != 'md5'
+      raise "Invalid checksum #{checksum.inspect}" if checksum !~ /^[0-9a-f]{32}$/
+      [checksum, path]
+    end
+
+    def path_for(bucket_path, digest, subfile = nil)
+      bucket_path ||= Puppet[:bucketdir]
+
+      dir     = ::File.join(digest[0..7].split(""))
+      basedir = ::File.join(bucket_path, dir, digest)
+
+      return basedir unless subfile
+      ::File.join(basedir, subfile)
+    end
+
+    # If conflict_check is enabled, verify that the passed text is
+    # the same as the text in our file.
+    def verify_identical_file!(bucket_file)
+      disk_contents = IO.binread(path_for(bucket_file.bucket_path, bucket_file.checksum_data, 'contents'))
+
+      # If the contents don't match, then we've found a conflict.
+      # Unlikely, but quite bad.
+      if disk_contents != bucket_file.contents
+        raise Puppet::FileBucket::BucketError, "Got passed new contents for sum #{bucket_file.checksum}"
+      else
+        Puppet.info "FileBucket got a duplicate file #{bucket_file.checksum}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+require 'puppet/indirector/rest'
+require 'puppet/file_bucket/file'
+
+module Puppet::FileBucketFile
+  class Rest < Puppet::Indirector::REST
+    desc "This is a REST based mechanism to send/retrieve file to/from the filebucket"
+  end
+end

data/lib/vendor/puppet/indirector/file_bucket_file/selector.rb

@@ -0,0 +1,49 @@
+require 'puppet/indirector/code'
+
+module Puppet::FileBucketFile
+  class Selector < Puppet::Indirector::Code
+    desc "Select the terminus based on the request"
+
+    def select(request)
+      if request.protocol == 'https'
+        :rest
+      else
+        :file
+      end
+    end
+
+    def get_terminus(request)
+      indirection.terminus(select(request))
+    end
+
+    def head(request)
+      get_terminus(request).head(request)
+    end
+
+    def find(request)
+      get_terminus(request).find(request)
+    end
+
+    def save(request)
+      get_terminus(request).save(request)
+    end
+
+    def search(request)
+      get_terminus(request).search(request)
+    end
+
+    def destroy(request)
+      get_terminus(request).destroy(request)
+    end
+
+    def authorized?(request)
+      terminus = get_terminus(request)
+      if terminus.respond_to?(:authorized?)
+        terminus.authorized?(request)
+      else
+        true
+      end
+    end
+  end
+end
+

data/lib/vendor/puppet/indirector/file_content/file.rb

@@ -0,0 +1,7 @@
+require 'puppet/file_serving/content'
+require 'puppet/indirector/file_content'
+require 'puppet/indirector/direct_file_server'
+
+class Puppet::Indirector::FileContent::File < Puppet::Indirector::DirectFileServer
+  desc "Retrieve file contents from disk."
+end

data/lib/vendor/puppet/indirector/file_content/file_server.rb

@@ -0,0 +1,7 @@
+require 'puppet/file_serving/content'
+require 'puppet/indirector/file_content'
+require 'puppet/indirector/file_server'
+
+class Puppet::Indirector::FileContent::FileServer < Puppet::Indirector::FileServer
+  desc "Retrieve file contents using Puppet's fileserver."
+end

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

@@ -0,0 +1,7 @@
+require 'puppet/file_serving/content'
+require 'puppet/indirector/file_content'
+require 'puppet/indirector/rest'
+
+class Puppet::Indirector::FileContent::Rest < Puppet::Indirector::REST
+  desc "Retrieve file contents via a REST HTTP interface."
+end

data/lib/vendor/puppet/indirector/file_content/selector.rb

@@ -0,0 +1,30 @@
+require 'puppet/file_serving/content'
+require 'puppet/indirector/file_content'
+require 'puppet/indirector/code'
+require 'puppet/file_serving/terminus_selector'
+
+class Puppet::Indirector::FileContent::Selector < Puppet::Indirector::Code
+  desc "Select the terminus based on the request"
+  include Puppet::FileServing::TerminusSelector
+
+  def get_terminus(request)
+    indirection.terminus(select(request))
+  end
+
+  def find(request)
+    get_terminus(request).find(request)
+  end
+
+  def search(request)
+    get_terminus(request).search(request)
+  end
+
+  def authorized?(request)
+    terminus = get_terminus(request)
+    if terminus.respond_to?(:authorized?)
+      terminus.authorized?(request)
+    else
+      true
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+# A stub class, so our constants work.
+class Puppet::Indirector::FileContent # :nodoc:
+end
+
+require 'puppet/file_serving/content'

data/lib/vendor/puppet/indirector/file_metadata/file.rb

@@ -0,0 +1,22 @@
+require 'puppet/file_serving/metadata'
+require 'puppet/indirector/file_metadata'
+require 'puppet/indirector/direct_file_server'
+
+class Puppet::Indirector::FileMetadata::File < Puppet::Indirector::DirectFileServer
+  desc "Retrieve file metadata directly from the local filesystem."
+
+  def find(request)
+    return unless data = super
+    data.collect
+
+    data
+  end
+
+  def search(request)
+    return unless result = super
+
+    result.each { |instance| instance.collect }
+
+    result
+  end
+end

data/lib/vendor/puppet/indirector/file_metadata/file_server.rb

@@ -0,0 +1,7 @@
+require 'puppet/file_serving/metadata'
+require 'puppet/indirector/file_metadata'
+require 'puppet/indirector/file_server'
+
+class Puppet::Indirector::FileMetadata::FileServer < Puppet::Indirector::FileServer
+  desc "Retrieve file metadata using Puppet's fileserver."
+end

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

@@ -0,0 +1,7 @@
+require 'puppet/file_serving/metadata'
+require 'puppet/indirector/file_metadata'
+require 'puppet/indirector/rest'
+
+class Puppet::Indirector::FileMetadata::Rest < Puppet::Indirector::REST
+  desc "Retrieve file metadata via a REST HTTP interface."
+end

data/lib/vendor/puppet/indirector/file_metadata/selector.rb

@@ -0,0 +1,30 @@
+require 'puppet/file_serving/metadata'
+require 'puppet/indirector/file_metadata'
+require 'puppet/indirector/code'
+require 'puppet/file_serving/terminus_selector'
+
+class Puppet::Indirector::FileMetadata::Selector < Puppet::Indirector::Code
+  desc "Select the terminus based on the request"
+  include Puppet::FileServing::TerminusSelector
+
+  def get_terminus(request)
+    indirection.terminus(select(request))
+  end
+
+  def find(request)
+    get_terminus(request).find(request)
+  end
+
+  def search(request)
+    get_terminus(request).search(request)
+  end
+
+  def authorized?(request)
+    terminus = get_terminus(request)
+    if terminus.respond_to?(:authorized?)
+      terminus.authorized?(request)
+    else
+      true
+    end
+  end
+end