puppet 2.6.18 → 2.7.1

data/lib/puppet/face/status.rb

@@ -0,0 +1,52 @@
+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.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/puppet/feature/ssh.rb

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

data/lib/puppet/file_bucket/dipper.rb

@@ -39,8 +39,8 @@ class Puppet::FileBucket::Dipper
 
       # 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.head("#{@rest_path}#{file_bucket_file.checksum_type}/#{file_bucket_file.checksum_data}#{files_original_path}")
-        file_bucket_file.save(dest_path)
+      unless Puppet::FileBucket::File.indirection.head("#{@rest_path}#{file_bucket_file.checksum_type}/#{file_bucket_file.checksum_data}#{files_original_path}")
+        Puppet::FileBucket::File.indirection.save(file_bucket_file, dest_path)
       end
 
       return file_bucket_file.checksum_data
@@ -53,7 +53,7 @@ class Puppet::FileBucket::Dipper
   # Retrieve a file by sum.
   def getfile(sum)
     source_path = "#{@rest_path}md5/#{sum}"
-    file_bucket_file = Puppet::FileBucket::File.find(source_path, :bucket_path => @local_path)
+    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

data/lib/puppet/file_bucket/file.rb

@@ -8,7 +8,8 @@ class Puppet::FileBucket::File
   # 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
+  require 'puppet/file_bucket/file/indirection_hooks'
+  indirects :file_bucket_file, :terminus_class => :file, :extend => Puppet::FileBucket::File::IndirectionHooks
 
   attr :contents
   attr :bucket_path
@@ -41,15 +42,15 @@ class Puppet::FileBucket::File
     "#{checksum_type}/#{checksum_data}"
   end
 
-  def self.from_s(contents)
-    self.new(contents)
+  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"])
+  def self.from_pson( pson )
+    self.new( pson["contents"] )
   end
 end

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

@@ -0,0 +1,9 @@
+require 'puppet/file_bucket/file'
+
+# This module is used to pick the appropriate terminus
+# in filebucket indirections.
+module Puppet::FileBucket::File::IndirectionHooks
+  def select_terminus(request)
+    return(request.protocol == 'https' ? :rest : Puppet::FileBucket::File.indirection.terminus_class)
+  end
+end

data/lib/puppet/file_serving/configuration.rb

@@ -70,8 +70,7 @@ class Puppet::FileServing::Configuration
 
     mount_name, path = request.key.split(File::Separator, 2)
 
-    raise(ArgumentError, "Cannot find file: Invalid mount '#{mount_name}'") unless mount_name =~ %r{^[-\w]+$}
-    raise(ArgumentError, "Cannot find file: Invalid relative path '#{path}'") if path and path.split('/').include?('..')
+    raise(ArgumentError, "Cannot find file: Invalid path '#{mount_name}'") unless mount_name =~ %r{^[-\w]+$}
 
     return nil unless mount = find_mount(mount_name, request.environment)
     if mount.name == "modules" and mount_name != "modules"

data/lib/puppet/file_serving/content.rb

@@ -5,13 +5,14 @@
 require 'puppet/indirector'
 require 'puppet/file_serving'
 require 'puppet/file_serving/base'
+require 'puppet/file_serving/indirection_hooks'
 
 # A class that handles retrieving file contents.
 # It only reads the file when its content is specifically
 # asked for.
 class Puppet::FileServing::Content < Puppet::FileServing::Base
   extend Puppet::Indirector
-  indirects :file_content, :terminus_class => :selector
+  indirects :file_content, :extend => Puppet::FileServing::IndirectionHooks
 
   attr_writer :content
 

data/lib/puppet/file_serving/{terminus_selector.rb → indirection_hooks.rb}

@@ -8,10 +8,11 @@ require 'puppet/file_serving'
 # This module is used to pick the appropriate terminus
 # in file-serving indirections.  This is necessary because
 # the terminus varies based on the URI asked for.
-module Puppet::FileServing::TerminusSelector
+module Puppet::FileServing::IndirectionHooks
   PROTOCOL_MAP = {"puppet" => :rest, "file" => :file}
 
-  def select(request)
+  # Pick an appropriate terminus based on the protocol.
+  def select_terminus(request)
     # We rely on the request's parsing of the URI.
 
     # Short-circuit to :file if it's a fully-qualified path or specifies a 'file' protocol.

data/lib/puppet/file_serving/metadata.rb

@@ -7,6 +7,7 @@ require 'puppet/indirector'
 require 'puppet/file_serving'
 require 'puppet/file_serving/base'
 require 'puppet/util/checksums'
+require 'puppet/file_serving/indirection_hooks'
 
 # A class that handles retrieving file metadata.
 class Puppet::FileServing::Metadata < Puppet::FileServing::Base
@@ -14,7 +15,7 @@ class Puppet::FileServing::Metadata < Puppet::FileServing::Base
   include Puppet::Util::Checksums
 
   extend Puppet::Indirector
-  indirects :file_metadata, :terminus_class => :selector
+  indirects :file_metadata, :extend => Puppet::FileServing::IndirectionHooks
 
   attr_reader :path, :owner, :group, :mode, :checksum_type, :checksum, :ftype, :destination
 

data/lib/puppet/file_serving/mount/modules.rb

@@ -5,7 +5,6 @@ require 'puppet/file_serving/mount'
 class Puppet::FileServing::Mount::Modules < Puppet::FileServing::Mount
   # Return an instance of the appropriate class.
   def find(path, request)
-    raise "No module specified" if path.to_s.empty?
     module_name, relative_path = path.split("/", 2)
     return nil unless mod = request.environment.module(module_name)
 
@@ -13,9 +12,11 @@ class Puppet::FileServing::Mount::Modules < Puppet::FileServing::Mount
   end
 
   def search(path, request)
-    if result = find(path, request)
-      [result]
-    end
+    module_name, relative_path = path.split("/", 2)
+    return nil unless mod = request.environment.module(module_name)
+
+    return nil unless path = mod.file(relative_path)
+    [path]
   end
 
   def valid?

data/lib/puppet/indirector.rb

@@ -12,6 +12,22 @@ module Puppet::Indirector
   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
@@ -21,7 +37,6 @@ module Puppet::Indirector
     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 InstanceMethods
     include Puppet::Indirector::Envelope
     extend Puppet::Network::FormatHandler
 
@@ -32,47 +47,5 @@ module Puppet::Indirector
 
   module ClassMethods
     attr_reader :indirection
-
-    def cache_class=(klass)
-      indirection.cache_class = klass
-    end
-
-    def terminus_class=(klass)
-      indirection.terminus_class = klass
-    end
-
-    # Expire any cached instance.
-    def expire(*args)
-      indirection.expire(*args)
-    end
-
-    def find(*args)
-      indirection.find(*args)
-    end
-
-    def head(*args)
-      indirection.head(*args)
-    end
-
-    def destroy(*args)
-      indirection.destroy(*args)
-    end
-
-    def search(*args)
-      indirection.search(*args)
-    end
-  end
-
-  module InstanceMethods
-    def save(key = nil)
-      self.class.indirection.save key, self
-    end
   end
-
-
-  # Helper definition for indirections that handle filenames.
-  BadNameRegexp = Regexp.union(/^\.\./,
-                               %r{[\\/]},
-                               "\0",
-                               /(?i)^[a-z]:/)
 end

data/lib/puppet/indirector/catalog/active_record.rb

@@ -30,7 +30,7 @@ class Puppet::Resource::Catalog::ActiveRecord < Puppet::Indirector::ActiveRecord
       host.merge_resources(catalog.vertices)
       host.last_compile = Time.now
 
-      if node = Puppet::Node.find(catalog.name)
+      if node = Puppet::Node.indirection.find(catalog.name)
         host.ip = node.parameters["ipaddress"]
         host.environment = node.environment.to_s
       end

data/lib/puppet/indirector/catalog/compiler.rb

@@ -13,9 +13,7 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
 
   def extract_facts_from_request(request)
     return unless text_facts = request.options[:facts]
-    unless format = request.options[:facts_format]
-      raise ArgumentError, "Facts but no fact format provided for #{request.key}"
-    end
+    raise ArgumentError, "Facts but no fact format provided for #{request.name}" unless format = request.options[:facts_format]
 
     # If the facts were encoded as yaml, then the param reconstitution system
     # in Network::HTTP::Handler will automagically deserialize the value.
@@ -24,12 +22,8 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
     else
       facts = Puppet::Node::Facts.convert_from(format, text_facts)
     end
-
-    unless facts.name == request.key
-      raise Puppet::Error, "Catalog for #{request.key.inspect} was requested with fact definition for the wrong node (#{facts.name.inspect})."
-    end
-
-    facts.save
+    facts.add_timestamp
+    Puppet::Node::Facts.indirection.save(facts)
   end
 
   # Compile a node's catalog.
@@ -94,7 +88,7 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
   # Turn our host name into a node object.
   def find_node(name)
     begin
-      return nil unless node = Puppet::Node.find(name)
+      return nil unless node = Puppet::Node.indirection.find(name)
     rescue => detail
       puts detail.backtrace if Puppet[:trace]
       raise Puppet::Error, "Failed when searching for node #{name}: #{detail}"
@@ -111,11 +105,7 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
   # to find the node.
   def node_from_request(request)
     if node = request.options[:use_node]
-      if request.remote?
-        raise Puppet::Error, "Invalid option use_node for a remote request"
-      else
-        return node
-      end
+      return node
     end
 
     # We rely on our authorization system to determine whether the connected

data/lib/puppet/indirector/catalog/static_compiler.rb

@@ -0,0 +1,137 @@
+require 'puppet/node'
+require 'puppet/resource/catalog'
+require 'puppet/indirector/code'
+
+class Puppet::Resource::Catalog::StaticCompiler < Puppet::Indirector::Code
+  def compiler
+    @compiler ||= indirection.terminus(:compiler)
+  end
+
+  def find(request)
+    return nil unless catalog = compiler.find(request)
+
+    raise "Did not get catalog back" unless catalog.is_a?(model)
+
+    catalog.resources.find_all { |res| res.type == "File" }.each do |resource|
+      next unless source = resource[:source]
+      next unless source =~ /^puppet:/
+
+      file = resource.to_ral
+      if file.recurse?
+        add_children(request.key, catalog, resource, file)
+      else
+        find_and_replace_metadata(request.key, resource, file)
+      end
+    end
+
+    catalog
+  end
+
+  def find_and_replace_metadata(host, resource, file)
+    # We remove URL info from it, so it forces a local copy
+    # rather than routing through the network.
+    # Weird, but true.
+    newsource = file[:source][0].sub("puppet:///", "")
+    file[:source][0] = newsource
+
+    raise "Could not get metadata for #{resource[:source]}" unless metadata = file.parameter(:source).metadata
+
+    replace_metadata(host, resource, metadata)
+  end
+
+  def replace_metadata(host, resource, metadata)
+    [:mode, :owner, :group].each do |param|
+      resource[param] ||= metadata.send(param)
+    end
+
+    resource[:ensure] = metadata.ftype
+    if metadata.ftype == "file"
+      unless resource[:content]
+        resource[:content] = metadata.checksum
+        resource[:checksum] = metadata.checksum_type
+      end
+    end
+
+    store_content(resource) if resource[:ensure] == "file"
+    old_source = resource.delete(:source)
+    Puppet.info "Metadata for #{resource} in catalog for '#{host}' added from '#{old_source}'"
+  end
+
+  def add_children(host, catalog, resource, file)
+    file = resource.to_ral
+
+    children = get_child_resources(host, catalog, resource, file)
+
+    remove_existing_resources(children, catalog)
+
+    children.each do |name, res|
+      catalog.add_resource res
+      catalog.add_edge(resource, res)
+    end
+  end
+
+  def get_child_resources(host, catalog, resource, file)
+    sourceselect = file[:sourceselect]
+    children = {}
+
+    source = resource[:source]
+
+    # This is largely a copy of recurse_remote in File
+    total = file[:source].collect do |source|
+      next unless result = file.perform_recursion(source)
+      return if top = result.find { |r| r.relative_path == "." } and top.ftype != "directory"
+      result.each { |data| data.source = "#{source}/#{data.relative_path}" }
+      break result if result and ! result.empty? and sourceselect == :first
+      result
+    end.flatten
+
+    # This only happens if we have sourceselect == :all
+    unless sourceselect == :first
+      found = []
+      total.reject! do |data|
+        result = found.include?(data.relative_path)
+        found << data.relative_path unless found.include?(data.relative_path)
+        result
+      end
+    end
+
+    total.each do |meta|
+      # This is the top-level parent directory
+      if meta.relative_path == "."
+        replace_metadata(host, resource, meta)
+        next
+      end
+      children[meta.relative_path] ||= Puppet::Resource.new(:file, File.join(file[:path], meta.relative_path))
+
+      # I think this is safe since it's a URL, not an actual file
+      children[meta.relative_path][:source] = source + "/" + meta.relative_path
+      replace_metadata(host, children[meta.relative_path], meta)
+    end
+
+    children
+  end
+
+  def remove_existing_resources(children, catalog)
+    existing_names = catalog.resources.collect { |r| r.to_s }
+
+    both = (existing_names & children.keys).inject({}) { |hash, name| hash[name] = true; hash }
+    
+    both.each { |name| children.delete(name) }
+  end
+
+  def store_content(resource)
+    @summer ||= Object.new
+    @summer.extend(Puppet::Util::Checksums)
+
+    type = @summer.sumtype(resource[:content])
+    sum = @summer.sumdata(resource[:content])
+
+    if Puppet::FileBucket::File.indirection.find("#{type}/#{sum}")
+      Puppet.info "Content for '#{resource[:source]}' already exists"
+    else
+      Puppet.info "Storing content for source '#{resource[:source]}'"
+      content = Puppet::FileServing::Content.find(resource[:source])
+      Puppet::FileBucket::File.new(content.content).save
+    end
+  end
+end