puppet 0.25.5 → 2.6.0

data/lib/puppet/indirector/resource/ral.rb

@@ -0,0 +1,48 @@
+class Puppet::Resource::Ral < Puppet::Indirector::Code
+  def find( request )
+    # find by name
+    res   = type(request).instances.find { |o| o.name == resource_name(request) }
+    res ||= type(request).new(:name => resource_name(request), :audit => type(request).properties.collect { |s| s.name })
+
+    res.to_resource
+  end
+
+  def search( request )
+    conditions = request.options.dup
+    conditions[:name] = resource_name(request) if resource_name(request)
+
+    type(request).instances.map do |res|
+      res.to_resource
+    end.find_all do |res|
+      conditions.all? {|property, value| res.to_resource[property].to_s == value.to_s}
+    end.sort do |a,b|
+      a.title <=> b.title
+    end
+  end
+
+  def save( request )
+    # In RAL-land, to "save" means to actually try to change machine state
+    res = request.instance
+    ral_res = res.to_ral
+
+    catalog = Puppet::Resource::Catalog.new
+    catalog.add_resource ral_res
+    catalog.apply
+
+    ral_res.to_resource
+  end
+
+  private
+
+  def type_name( request )
+    request.key.split('/')[0]
+  end
+
+  def resource_name( request )
+    request.key.split('/')[1]
+  end
+
+  def type( request )
+    Puppet::Type.type(type_name(request)) or raise Puppet::Error, "Could not find type #{type}"
+  end
+end

data/lib/puppet/indirector/resource/rest.rb

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

data/lib/puppet/indirector/resource_type.rb

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

data/lib/puppet/indirector/resource_type/parser.rb

@@ -0,0 +1,27 @@
+require 'puppet/resource/type'
+require 'puppet/indirector/code'
+require 'puppet/indirector/resource_type'
+
+class Puppet::Indirector::ResourceType::Parser < Puppet::Indirector::Code
+  desc "Return the data-form of a resource type."
+
+  def find(request)
+    krt = request.environment.known_resource_types
+
+    # This is a bit ugly.
+    [:hostclass, :definition, :node].each do |type|
+      if r = krt.send(type, request.key)
+        return r
+      end
+    end
+    nil
+  end
+
+  def search(request)
+    raise ArgumentError, "Only '*' is acceptable as a search request" unless request.key == "*"
+    krt = request.environment.known_resource_types
+    result = [krt.hostclasses.values, krt.definitions.values, krt.nodes.values].flatten
+    return nil if result.empty?
+    result
+  end
+end

data/lib/puppet/indirector/resource_type/rest.rb

@@ -0,0 +1,7 @@
+require 'puppet/resource/type'
+require 'puppet/indirector/rest'
+require 'puppet/indirector/resource_type'
+
+class Puppet::Indirector::ResourceType::Rest < Puppet::Indirector::REST
+  desc "Retrieve resource types via a REST HTTP interface."
+end

data/lib/puppet/indirector/rest.rb

@@ -3,92 +3,96 @@ require 'uri'
 
 require 'puppet/network/http_pool'
 require 'puppet/network/http/api/v1'
+require 'puppet/network/http/compression'
 
 # Access objects via REST
 class Puppet::Indirector::REST < Puppet::Indirector::Terminus
-    include Puppet::Network::HTTP::API::V1
-
-    class << self
-        attr_reader :server_setting, :port_setting
-    end
-
-    # Specify the setting that we should use to get the server name.
-    def self.use_server_setting(setting)
-        @server_setting = setting
+  include Puppet::Network::HTTP::API::V1
+  include Puppet::Network::HTTP::Compression.module
+
+  class << self
+    attr_reader :server_setting, :port_setting
+  end
+
+  # Specify the setting that we should use to get the server name.
+  def self.use_server_setting(setting)
+    @server_setting = setting
+  end
+
+  def self.server
+    Puppet.settings[server_setting || :server]
+  end
+
+  # Specify the setting that we should use to get the port.
+  def self.use_port_setting(setting)
+    @port_setting = setting
+  end
+
+  def self.port
+    Puppet.settings[port_setting || :masterport].to_i
+  end
+
+  # Figure out the content type, turn that into a format, and use the format
+  # to extract the body of the response.
+  def deserialize(response, multiple = false)
+    case response.code
+    when "404"
+      return nil
+    when /^2/
+      raise "No content type in http response; cannot parse" unless response['content-type']
+
+      content_type = response['content-type'].gsub(/\s*;.*$/,'') # strip any appended charset
+
+      body = uncompress_body(response)
+
+      # Convert the response to a deserialized object.
+      if multiple
+        model.convert_from_multiple(content_type, body)
+      else
+        model.convert_from(content_type, body)
+      end
+    else
+      # Raise the http error if we didn't get a 'success' of some kind.
+      message = "Error #{response.code} on SERVER: #{(response.body||'').empty? ? response.message : uncompress_body(response)}"
+      raise Net::HTTPError.new(message, response)
     end
-
-    def self.server
-        return Puppet.settings[server_setting || :server]
+  end
+
+  # Provide appropriate headers.
+  def headers
+    add_accept_encoding({"Accept" => model.supported_formats.join(", ")})
+  end
+
+  def network(request)
+    Puppet::Network::HttpPool.http_instance(request.server || self.class.server, request.port || self.class.port)
+  end
+
+  def find(request)
+    return nil unless result = deserialize(network(request).get(indirection2uri(request), headers))
+    result.name = request.key if result.respond_to?(:name=)
+    result
+  end
+
+  def search(request)
+    unless result = deserialize(network(request).get(indirection2uri(request), headers), true)
+      return []
     end
+    result
+  end
 
-    # Specify the setting that we should use to get the port.
-    def self.use_port_setting(setting)
-        @port_setting = setting
-    end
+  def destroy(request)
+    raise ArgumentError, "DELETE does not accept options" unless request.options.empty?
+    deserialize network(request).delete(indirection2uri(request), headers)
+  end
 
-    def self.port
-        return Puppet.settings[port_setting || :masterport].to_i
-    end
+  def save(request)
+    raise ArgumentError, "PUT does not accept options" unless request.options.empty?
+    deserialize network(request).put(indirection2uri(request), request.instance.render, headers.merge({ "Content-Type" => request.instance.mime }))
+  end
 
-    # Figure out the content type, turn that into a format, and use the format
-    # to extract the body of the response.
-    def deserialize(response, multiple = false)
-        case response.code
-        when "404"
-            return nil
-        when /^2/
-            unless response['content-type']
-                raise "No content type in http response; cannot parse"
-            end
-
-            content_type = response['content-type'].gsub(/\s*;.*$/,'') # strip any appended charset
-
-            # Convert the response to a deserialized object.
-            if multiple
-                model.convert_from_multiple(content_type, response.body)
-            else
-                model.convert_from(content_type, response.body)
-            end
-        else
-            # Raise the http error if we didn't get a 'success' of some kind.
-            message = "Error %s on SERVER: %s" % [response.code, (response.body||'').empty? ? response.message : response.body]
-            raise Net::HTTPError.new(message, response)
-        end
-    end
-
-    # Provide appropriate headers.
-    def headers
-        {"Accept" => model.supported_formats.join(", ")}
-    end
-
-    def network(request)
-        Puppet::Network::HttpPool.http_instance(request.server || self.class.server, request.port || self.class.port)
-    end
+  private
 
-    def find(request)
-        deserialize network(request).get(indirection2uri(request), headers)
-    end
-
-    def search(request)
-        unless result = deserialize(network(request).get(indirection2uri(request), headers), true)
-            return []
-        end
-        return result
-    end
-
-    def destroy(request)
-        raise ArgumentError, "DELETE does not accept options" unless request.options.empty?
-        deserialize network(request).delete(indirection2uri(request), headers)
-    end
-
-    def save(request)
-        raise ArgumentError, "PUT does not accept options" unless request.options.empty?
-        deserialize network(request).put(indirection2uri(request), request.instance.render, headers.merge({ "Content-Type" => request.instance.mime }))
-    end
-
-    private
-
-    def environment
-        Puppet::Node::Environment.new
-    end
+  def environment
+    Puppet::Node::Environment.new
+  end
 end

data/lib/puppet/indirector/run/local.rb

@@ -0,0 +1,8 @@
+require 'puppet/run'
+require 'puppet/indirector/code'
+
+class Puppet::Run::Local < Puppet::Indirector::Code
+  def save( request )
+    request.instance.run
+  end
+end

data/lib/puppet/indirector/run/rest.rb

@@ -0,0 +1,6 @@
+require 'puppet/run'
+require 'puppet/indirector/rest'
+
+class Puppet::Run::Rest < Puppet::Indirector::REST
+  desc "Trigger Agent runs via REST."
+end

data/lib/puppet/indirector/ssl_file.rb

@@ -1,171 +1,171 @@
 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 %s cannot function" % self.class.name
-    end
-
-    # Use a setting to determine our path.
-    def path(name)
-        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 %s %s at '%s'" % [model, request.key, path]
-        begin
-            File.unlink(path)
-        rescue => detail
-            raise Puppet::Error, "Could not remove %s: %s" % [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 %s; parent directory %s does not exist" % [request.key, dir]) unless FileTest.directory?(dir)
-        raise Puppet::Error.new("Cannot save %s; parent directory %s is not writable" % [request.key, dir]) 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 %s; renaming to %s" % [full_file, file]
-        File.rename(full_file, file)
-
-        return 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 %s to %s: %s" % [path, setting, detail]
-            end
-        else
-            raise Puppet::DevError, "You must provide a setting to determine where the files are stored"
-        end
-    end
+  # 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
+
+  # Use a setting to determine our path.
+  def path(name)
+    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