puppet-parse 0.0.1 → 0.0.2

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

@@ -0,0 +1,204 @@
+require 'cgi'
+require 'uri'
+require 'puppet/indirector'
+
+# This class encapsulates all of the information you need to make an
+# Indirection call, and as a a result also handles REST calls.  It's somewhat
+# analogous to an HTTP Request object, except tuned for our Indirector.
+class Puppet::Indirector::Request
+  attr_accessor :key, :method, :options, :instance, :node, :ip, :authenticated, :ignore_cache, :ignore_terminus
+
+  attr_accessor :server, :port, :uri, :protocol
+
+  attr_reader :indirection_name
+
+  OPTION_ATTRIBUTES = [:ip, :node, :authenticated, :ignore_terminus, :ignore_cache, :instance, :environment]
+
+  # Is this an authenticated request?
+  def authenticated?
+    # Double negative, so we just get true or false
+    ! ! authenticated
+  end
+
+  def environment
+    @environment ||= Puppet::Node::Environment.new
+  end
+
+  def environment=(env)
+    @environment = if env.is_a?(Puppet::Node::Environment)
+      env
+    else
+      Puppet::Node::Environment.new(env)
+    end
+  end
+
+  def escaped_key
+    URI.escape(key)
+  end
+
+  # LAK:NOTE This is a messy interface to the cache, and it's only
+  # used by the Configurer class.  I decided it was better to implement
+  # it now and refactor later, when we have a better design, than
+  # to spend another month coming up with a design now that might
+  # not be any better.
+  def ignore_cache?
+    ignore_cache
+  end
+
+  def ignore_terminus?
+    ignore_terminus
+  end
+
+  def initialize(indirection_name, method, key_or_instance, options_or_instance = {})
+    if options_or_instance.is_a? Hash
+      options = options_or_instance
+      @instance = nil
+    else
+      options  = {}
+      @instance = options_or_instance
+    end
+
+    self.indirection_name = indirection_name
+    self.method = method
+
+    set_attributes(options)
+
+    @options = options.inject({}) { |hash, ary| hash[ary[0].to_sym] = ary[1]; hash }
+
+    if key_or_instance.is_a?(String) || key_or_instance.is_a?(Symbol)
+      key = key_or_instance
+    else
+      @instance ||= key_or_instance
+    end
+
+    if key
+      # If the request key is a URI, then we need to treat it specially,
+      # because it rewrites the key.  We could otherwise strip server/port/etc
+      # info out in the REST class, but it seemed bad design for the REST
+      # class to rewrite the key.
+
+      if key.to_s =~ /^\w+:\// and not Puppet::Util.absolute_path?(key.to_s) # it's a URI
+        set_uri_key(key)
+      else
+        @key = key
+      end
+    end
+
+    @key = @instance.name if ! @key and @instance
+  end
+
+  # Look up the indirection based on the name provided.
+  def indirection
+    Puppet::Indirector::Indirection.instance(indirection_name)
+  end
+
+  def indirection_name=(name)
+    @indirection_name = name.to_sym
+  end
+
+
+  def model
+    raise ArgumentError, "Could not find indirection '#{indirection_name}'" unless i = indirection
+    i.model
+  end
+
+  # Should we allow use of the cached object?
+  def use_cache?
+    if defined?(@use_cache)
+      ! ! use_cache
+    else
+      true
+    end
+  end
+
+  # Are we trying to interact with multiple resources, or just one?
+  def plural?
+    method == :search
+  end
+
+  # Create the query string, if options are present.
+  def query_string
+    return "" unless options and ! options.empty?
+    "?" + options.collect do |key, value|
+      case value
+      when nil; next
+      when true, false; value = value.to_s
+      when Fixnum, Bignum, Float; value = value # nothing
+      when String; value = CGI.escape(value)
+      when Symbol; value = CGI.escape(value.to_s)
+      when Array; value = CGI.escape(YAML.dump(value))
+      else
+        raise ArgumentError, "HTTP REST queries cannot handle values of type '#{value.class}'"
+      end
+
+      "#{key}=#{value}"
+    end.join("&")
+  end
+
+  def to_hash
+    result = options.dup
+
+    OPTION_ATTRIBUTES.each do |attribute|
+      if value = send(attribute)
+        result[attribute] = value
+      end
+    end
+    result
+  end
+
+  def to_s
+    return(uri ? uri : "/#{indirection_name}/#{key}")
+  end
+
+  def remote?
+    self.node or self.ip
+  end
+
+  private
+
+  def set_attributes(options)
+    OPTION_ATTRIBUTES.each do |attribute|
+      if options.include?(attribute)
+        send(attribute.to_s + "=", options[attribute])
+        options.delete(attribute)
+      end
+    end
+  end
+
+  # Parse the key as a URI, setting attributes appropriately.
+  def set_uri_key(key)
+    @uri = key
+    begin
+      uri = URI.parse(URI.escape(key))
+    rescue => detail
+      raise ArgumentError, "Could not understand URL #{key}: #{detail}"
+    end
+
+    # Just short-circuit these to full paths
+    if uri.scheme == "file"
+      @key = Puppet::Util.uri_to_path(uri)
+      return
+    end
+
+    @server = uri.host if uri.host
+
+    # If the URI class can look up the scheme, it will provide a port,
+    # otherwise it will default to '0'.
+    if uri.port.to_i == 0 and uri.scheme == "puppet"
+      @port = Puppet.settings[:masterport].to_i
+    else
+      @port = uri.port.to_i
+    end
+
+    @protocol = uri.scheme
+
+    if uri.scheme == 'puppet'
+      @key = URI.unescape(uri.path.sub(/^\//, ''))
+      return
+    end
+
+    env, indirector, @key = URI.unescape(uri.path.sub(/^\//, '')).split('/',3)
+    @key ||= ''
+    self.environment = env unless env == ''
+  end
+end

data/lib/vendor/puppet/indirector/resource/active_record.rb

@@ -0,0 +1,93 @@
+require 'puppet/indirector/active_record'
+
+class Puppet::Resource::ActiveRecord < Puppet::Indirector::ActiveRecord
+  def search(request)
+    type   = request_to_type_name(request)
+    host   = request.options[:host]
+    filter = request.options[:filter]
+
+    if filter and filter[1] =~ /^(and|or)$/i then
+      raise Puppet::Error, "Complex search on StoreConfigs resources is not supported"
+    end
+
+    query = build_active_record_query(type, host, filter)
+    Puppet::Rails::Resource.find(:all, query)
+  end
+
+  private
+  def request_to_type_name(request)
+    request.key.split('/', 2)[0] or
+      raise "No key found in the request, failing: #{request.inspect}"
+  end
+
+  def filter_to_active_record(filter)
+    # Don't call me if you don't have a filter, please.
+    filter.is_a?(Array) or raise ArgumentError, "active record filters must be arrays"
+    a, op, b = filter
+
+    case op
+    when /^(and|or)$/i then
+      extra = []
+      first, args = filter_to_active_record a
+      extra += args
+
+      second, args = filter_to_active_record b
+      extra += args
+
+      return "(#{first}) #{op.upcase} (#{second})", extra
+
+    when "==", "!=" then
+      op = '=' if op == '=='    # SQL, yayz!
+      case a
+      when "title" then
+        return "title #{op} ?", [b]
+
+      when "tag" then
+        return "puppet_tags.name #{op} ?", [b]
+
+      else
+        return "param_names.name = ? AND param_values.value #{op} ?", [a, b]
+      end
+
+    else
+      raise ArgumentError, "unknown operator #{op.inspect} in #{filter.inspect}"
+    end
+  end
+
+  def build_active_record_query(type, host, filter)
+    raise Puppet::DevError, "Cannot collect resources for a nil host" unless host
+
+    search = "(exported=? AND restype=?)"
+    arguments = [true, type]
+
+    if filter then
+      sql, values = filter_to_active_record(filter)
+      search    += " AND #{sql}"
+      arguments += values
+    end
+
+    # note: we're not eagerly including any relations here because it can
+    # create large numbers of objects that we will just throw out later.  We
+    # used to eagerly include param_names/values but the way the search filter
+    # is built ruined those efforts and we were eagerly loading only the
+    # searched parameter and not the other ones.
+    query = {}
+    case search
+    when /puppet_tags/
+      query = { :joins => { :resource_tags => :puppet_tag } }
+    when /param_name/
+      query = { :joins => { :param_values => :param_name } }
+    end
+
+    # We're going to collect objects from rails, but we don't want any
+    # objects from this host.
+    if host = Puppet::Rails::Host.find_by_name(host)
+      search += " AND (host_id != ?)"
+      arguments << host.id
+    end
+
+    query[:conditions] = [search, *arguments]
+
+    query
+  end
+end

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

@@ -0,0 +1,53 @@
+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
+    transaction = catalog.apply
+
+    [ral_res.to_resource, transaction.report]
+  end
+
+  private
+
+  # {type,resource}_name: the resource name may contain slashes:
+  # File["/etc/hosts"]. To handle, assume the type name does
+  # _not_ have any slashes in it, and split only on the first.
+
+  def type_name( request )
+    request.key.split('/', 2)[0]
+  end
+
+  def resource_name( request )
+    name = request.key.split('/', 2)[1]
+    name unless name == ""
+  end
+
+  def type( request )
+    Puppet::Type.type(type_name(request)) or raise Puppet::Error, "Could not find type #{type}"
+  end
+end

data/lib/vendor/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/vendor/puppet/indirector/resource/store_configs.rb

@@ -0,0 +1,3 @@
+require 'puppet/indirector/store_configs'
+class Puppet::Resource::StoreConfigs < Puppet::Indirector::StoreConfigs
+end

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

@@ -0,0 +1,43 @@
+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|
+      # We have to us 'find_<type>' here because it will
+      # load any missing types from disk, whereas the plain
+      # '<type>' method only returns from memory.
+      if r = krt.send("find_#{type}", [""], request.key)
+        return r
+      end
+    end
+    nil
+  end
+
+  def search(request)
+    krt = request.environment.known_resource_types
+    # Make sure we've got all of the types loaded.
+    krt.loader.import_all
+    result = [krt.hostclasses.values, krt.definitions.values, krt.nodes.values].flatten.reject { |t| t.name == "" }
+    return nil if result.empty?
+    return result if request.key == "*"
+
+    # Strip the regex of any wrapping slashes that might exist
+    key = request.key.sub(/^\//, '').sub(/\/$/, '')
+    begin
+      regex = Regexp.new(key)
+    rescue => detail
+      raise ArgumentError, "Invalid regex '#{request.key}': #{detail}"
+    end
+
+    result.reject! { |t| t.name.to_s !~ regex }
+    return nil if result.empty?
+    result
+  end
+end

data/lib/vendor/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/vendor/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/vendor/puppet/indirector/rest.rb

@@ -0,0 +1,166 @@
+require 'net/http'
+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
+  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.
+      raise convert_to_http_error(response)
+    end
+  end
+
+  def convert_to_http_error(response)
+    message = "Error #{response.code} on SERVER: #{(response.body||'').empty? ? response.message : uncompress_body(response)}"
+    Net::HTTPError.new(message, response)
+  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
+
+  [:get, :post, :head, :delete, :put].each do |method|
+    define_method "http_#{method}" do |request, *args|
+      http_request(method, request, *args)
+    end
+  end
+
+  def http_request(method, request, *args)
+    http_connection = network(request)
+    peer_certs = []
+    verify_errors = []
+
+    http_connection.verify_callback = proc do |preverify_ok, ssl_context|
+      # We use the callback to collect the certificates for use in constructing
+      # the error message if the verification failed.  This is necessary since we
+      # don't have direct access to the cert that we expected the connection to
+      # use otherwise.
+      peer_certs << Puppet::SSL::Certificate.from_s(ssl_context.current_cert.to_pem)
+      # And also keep the detailed verification error if such an error occurs
+      if ssl_context.error_string and not preverify_ok
+        verify_errors << "#{ssl_context.error_string} for #{ssl_context.current_cert.subject}"
+      end
+      preverify_ok
+    end
+
+    http_connection.send(method, *args)
+  rescue OpenSSL::SSL::SSLError => error
+    if error.message.include? "certificate verify failed"
+      msg = error.message
+      msg << ": [" + verify_errors.join('; ') + "]"
+      raise Puppet::Error, msg
+    elsif error.message =~ /hostname (was )?not match/
+      raise unless cert = peer_certs.find { |c| c.name !~ /^puppet ca/i }
+
+      valid_certnames = [cert.name, *cert.subject_alt_names].uniq
+      msg = valid_certnames.length > 1 ? "one of #{valid_certnames.join(', ')}" : valid_certnames.first
+
+      raise Puppet::Error, "Server hostname '#{http_connection.address}' did not match server certificate; expected #{msg}"
+    else
+      raise
+    end
+  end
+
+  def find(request)
+    uri, body = request_to_uri_and_body(request)
+    uri_with_query_string = "#{uri}?#{body}"
+    # WEBrick in Ruby 1.9.1 only supports up to 1024 character lines in an HTTP request
+    # http://redmine.ruby-lang.org/issues/show/3991
+    response = if "GET #{uri_with_query_string} HTTP/1.1\r\n".length > 1024
+      http_post(request, uri, body, headers)
+    else
+      http_get(request, uri_with_query_string, headers)
+    end
+    result = deserialize response
+    result.name = request.key if result.respond_to?(:name=)
+    result
+  end
+
+  def head(request)
+    response = http_head(request, indirection2uri(request), headers)
+    case response.code
+    when "404"
+      return false
+    when /^2/
+      return true
+    else
+      # Raise the http error if we didn't get a 'success' of some kind.
+      raise convert_to_http_error(response)
+    end
+  end
+
+  def search(request)
+    unless result = deserialize(http_get(request, indirection2uri(request), headers), true)
+      return []
+    end
+    result
+  end
+
+  def destroy(request)
+    raise ArgumentError, "DELETE does not accept options" unless request.options.empty?
+    deserialize http_delete(request, indirection2uri(request), headers)
+  end
+
+  def save(request)
+    raise ArgumentError, "PUT does not accept options" unless request.options.empty?
+    deserialize http_put(request, indirection2uri(request), request.instance.render, headers.merge({ "Content-Type" => request.instance.mime }))
+  end
+
+  private
+
+  def environment
+    Puppet::Node::Environment.new
+  end
+end

data/lib/vendor/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/vendor/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