puppet-parse 0.0.1 → 0.0.2

data/lib/vendor/puppet/network/handler/master.rb

@@ -0,0 +1,87 @@
+require 'openssl'
+require 'puppet'
+require 'xmlrpc/server'
+require 'yaml'
+require 'puppet/network/handler'
+
+class Puppet::Network::Handler
+  class MasterError < Puppet::Error; end
+  class Master < Handler
+    desc "Puppet's configuration interface.  Used for all interactions related to
+    generating client configurations."
+
+    include Puppet::Util
+
+    attr_accessor :ast
+    attr_reader :ca
+
+    @interface = XMLRPC::Service::Interface.new("puppetmaster") { |iface|
+        iface.add_method("string getconfig(string)")
+        iface.add_method("int freshness()")
+    }
+
+    # Tell a client whether there's a fresh config for it
+    def freshness(client = nil, clientip = nil)
+      # Always force a recompile.  Newer clients shouldn't do this (as of April 2008).
+      Time.now.to_i
+    end
+
+    def initialize(hash = {})
+      args = {}
+
+      @local = hash[:Local]
+
+      args[:Local] = true
+
+      # This is only used by the cfengine module, or if --loadclasses was
+      # specified in +puppet+.
+      args[:Classes] = hash[:Classes] if hash.include?(:Classes)
+    end
+
+    # Call our various handlers; this handler is getting deprecated.
+    def getconfig(facts, format = "marshal", client = nil, clientip = nil)
+      facts = decode_facts(facts)
+
+      client ||= facts["hostname"]
+
+      # Pass the facts to the fact handler
+      Puppet::Node::Facts.indirection.save(Puppet::Node::Facts.new(client, facts)) unless local?
+
+      catalog = Puppet::Resource::Catalog.indirection.find(client)
+
+      case format
+      when "yaml"
+        return CGI.escape(catalog.extract.to_yaml)
+      when "marshal"
+        return CGI.escape(Marshal.dump(catalog.extract))
+      else
+        raise "Invalid markup format '#{format}'"
+      end
+    end
+
+    #
+    def decode_facts(facts)
+      if @local
+        # we don't need to do anything, since we should already
+        # have raw objects
+        Puppet.debug "Our client is local"
+      else
+        Puppet.debug "Our client is remote"
+
+        begin
+          facts = YAML.load(CGI.unescape(facts))
+        rescue => detail
+          raise XMLRPC::FaultException.new(
+            1, "Could not rebuild facts"
+          )
+        end
+      end
+
+      facts
+    end
+
+    # Translate our configuration appropriately for sending back to a client.
+    def translate(config)
+    end
+  end
+end

data/lib/vendor/puppet/network/handler/report.rb

@@ -0,0 +1,82 @@
+require 'puppet/util/instance_loader'
+require 'puppet/reports'
+require 'puppet/network/handler'
+require 'xmlrpc/server'
+
+# A simple server for triggering a new run on a Puppet client.
+class Puppet::Network::Handler
+  class Report < Handler
+    desc "Accepts a Puppet transaction report and processes it."
+
+    @interface = XMLRPC::Service::Interface.new("puppetreports") { |iface|
+      iface.add_method("string report(array)")
+    }
+
+    # Add a new report type.
+    def self.newreport(name, options = {}, &block)
+      Puppet.warning "The interface for registering report types has changed; use Puppet::Reports.register_report for report type #{name}"
+      Puppet::Reports.register_report(name, options, &block)
+    end
+
+    def initialize(*args)
+      super
+      Puppet.settings.use(:main, :reporting, :metrics)
+    end
+
+    # Accept a report from a client.
+    def report(report, client = nil, clientip = nil)
+      # Unescape the report
+      report = CGI.unescape(report) unless @local
+
+      Puppet.info "Processing reports #{reports().join(", ")} for #{client}"
+      begin
+        process(report)
+      rescue => detail
+        Puppet.err "Could not process report for #{client}: #{detail}"
+        puts detail.backtrace if Puppet[:trace]
+      end
+    end
+
+    private
+
+    # Process the report using all of the existing hooks.
+    def process(yaml)
+      return if Puppet[:reports] == "none"
+
+      # First convert the report to real objects
+      begin
+        report = YAML.load(yaml)
+      rescue => detail
+        Puppet.warning "Could not load report: #{detail}"
+        return
+      end
+
+      # Used for those reports that accept yaml
+      client = report.host
+
+      reports.each do |name|
+        if mod = Puppet::Reports.report(name)
+          # We have to use a dup because we're including a module in the
+          # report.
+          newrep = report.dup
+          begin
+            newrep.extend(mod)
+            newrep.process
+          rescue => detail
+            puts detail.backtrace if Puppet[:trace]
+            Puppet.err "Report #{name} failed: #{detail}"
+          end
+        else
+          Puppet.warning "No report named '#{name}'"
+        end
+      end
+    end
+
+    # Handle the parsing of the reports attribute.
+    def reports
+      # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com]
+      x = Puppet[:reports].gsub(/(^\s+)|(\s+$)/, '').split(/\s*,\s*/)
+    end
+  end
+end
+

data/lib/vendor/puppet/network/handler/runner.rb

@@ -0,0 +1,33 @@
+require 'puppet/run'
+require 'puppet/network/handler'
+require 'xmlrpc/server'
+
+class Puppet::Network::Handler
+  class MissingMasterError < RuntimeError; end # Cannot find the master client
+  # A simple server for triggering a new run on a Puppet client.
+  class Runner < Handler
+    desc "An interface for triggering client configuration runs."
+
+    @interface = XMLRPC::Service::Interface.new("puppetrunner") { |iface|
+      iface.add_method("string run(string, string)")
+    }
+
+    side :client
+
+    # Run the client configuration right now, optionally specifying
+    # tags and whether to ignore schedules
+    def run(tags = nil, ignoreschedules = false, fg = true, client = nil, clientip = nil)
+      options = {}
+      options[:tags] = tags if tags
+      options[:ignoreschedules] = ignoreschedules if ignoreschedules
+      options[:background] = !fg
+
+      runner = Puppet::Run.new(options)
+
+      runner.run
+
+      runner.status
+    end
+  end
+end
+

data/lib/vendor/puppet/network/handler/status.rb

@@ -0,0 +1,18 @@
+require 'puppet/network/handler'
+require 'xmlrpc/server'
+class Puppet::Network::Handler
+  class Status < Handler
+    desc "A simple interface for testing Puppet connectivity."
+
+    side :client
+
+    @interface = XMLRPC::Service::Interface.new("status") { |iface|
+      iface.add_method("int status()")
+    }
+
+    def status(client = nil, clientip = nil)
+      1
+    end
+  end
+end
+

data/lib/vendor/puppet/network/handler.rb

@@ -0,0 +1,50 @@
+require 'puppet/util/docs'
+require 'puppet/util/subclass_loader'
+
+module Puppet::Network
+  # The base class for the different handlers.  The handlers are each responsible
+  # for separate xmlrpc namespaces.
+  class Handler
+    extend Puppet::Util::Docs
+
+    # This is so that the handlers can subclass just 'Handler', rather
+    # then having to specify the full class path.
+    Handler = self
+    attr_accessor :server, :local
+
+    extend Puppet::Util::SubclassLoader
+    extend Puppet::Util
+
+    handle_subclasses :handler, "puppet/network/handler"
+
+    # Return the xmlrpc interface.
+    def self.interface
+      if defined?(@interface)
+        return @interface
+      else
+        raise Puppet::DevError, "Handler #{self} has no defined interface"
+      end
+    end
+
+    # Set/Determine whether we're a client- or server-side handler.
+    def self.side(side = nil)
+      if side
+        side = side.intern if side.is_a?(String)
+        raise ArgumentError, "Invalid side registration '#{side}' for #{self.name}" unless [:client, :server].include?(side)
+        @side = side
+      else
+        @side ||= :server
+        return @side
+      end
+    end
+
+    # Create an empty init method with the same signature.
+    def initialize(hash = {})
+    end
+
+    def local?
+      self.local
+    end
+  end
+end
+

data/lib/vendor/puppet/network/http/api/v1.rb

@@ -0,0 +1,83 @@
+require 'puppet/network/http/api'
+
+module Puppet::Network::HTTP::API::V1
+  # How we map http methods and the indirection name in the URI
+  # to an indirection method.
+  METHOD_MAP = {
+    "GET" => {
+      :plural => :search,
+      :singular => :find
+    },
+    "POST" => {
+      :singular => :find,
+    },
+    "PUT" => {
+      :singular => :save
+    },
+    "DELETE" => {
+      :singular => :destroy
+    },
+    "HEAD" => {
+      :singular => :head
+    }
+  }
+
+  def uri2indirection(http_method, uri, params)
+    environment, indirection, key = uri.split("/", 4)[1..-1] # the first field is always nil because of the leading slash
+
+    raise ArgumentError, "The environment must be purely alphanumeric, not '#{environment}'" unless environment =~ /^\w+$/
+    raise ArgumentError, "The indirection name must be purely alphanumeric, not '#{indirection}'" unless indirection =~ /^\w+$/
+
+    method = indirection_method(http_method, indirection)
+
+    params[:environment] = Puppet::Node::Environment.new(environment)
+    params.delete(:bucket_path)
+
+    raise ArgumentError, "No request key specified in #{uri}" if key == "" or key.nil?
+
+    key = URI.unescape(key)
+
+    [indirection, method, key, params]
+  end
+
+  def indirection2uri(request)
+    indirection = request.method == :search ? pluralize(request.indirection_name.to_s) : request.indirection_name.to_s
+    "/#{request.environment.to_s}/#{indirection}/#{request.escaped_key}#{request.query_string}"
+  end
+
+  def request_to_uri_and_body(request)
+    indirection = request.method == :search ? pluralize(request.indirection_name.to_s) : request.indirection_name.to_s
+    ["/#{request.environment.to_s}/#{indirection}/#{request.escaped_key}", request.query_string.sub(/^\?/,'')]
+  end
+
+  def indirection_method(http_method, indirection)
+    raise ArgumentError, "No support for http method #{http_method}" unless METHOD_MAP[http_method]
+
+    unless method = METHOD_MAP[http_method][plurality(indirection)]
+      raise ArgumentError, "No support for plural #{http_method} operations"
+    end
+
+    method
+  end
+
+  def pluralize(indirection)
+    return(indirection == "status" ? "statuses" : indirection + "s")
+  end
+
+  def plurality(indirection)
+    # NOTE This specific hook for facts is ridiculous, but it's a *many*-line
+    # fix to not need this, and our goal is to move away from the complication
+    # that leads to the fix being too long.
+    return :singular if indirection == "facts"
+    return :singular if indirection == "status"
+    return :singular if indirection == "certificate_status"
+    return :plural if indirection == "inventory"
+
+    result = (indirection =~ /s$|_search$/) ? :plural : :singular
+
+    indirection.sub!(/s$|_search$/, '')
+    indirection.sub!(/statuse$/, 'status')
+
+    result
+  end
+end

data/lib/vendor/puppet/network/http/api.rb

@@ -0,0 +1,4 @@
+require 'puppet/network/http'
+
+class Puppet::Network::HTTP::API
+end

data/lib/vendor/puppet/network/http/compression.rb

@@ -0,0 +1,114 @@
+require 'puppet/network/http'
+
+module Puppet::Network::HTTP::Compression
+
+  # this module function allows to use the right underlying
+  # methods depending on zlib presence
+  def module
+    return(Puppet.features.zlib? ? Active : None)
+  end
+  module_function :module
+
+  module Active
+    require 'zlib'
+    require 'stringio'
+
+    # return an uncompressed body if the response has been
+    # compressed
+    def uncompress_body(response)
+      case response['content-encoding']
+      when 'gzip'
+        return Zlib::GzipReader.new(StringIO.new(response.body)).read
+      when 'deflate'
+        return Zlib::Inflate.new.inflate(response.body)
+      when nil, 'identity'
+        return response.body
+      else
+        raise Net::HTTPError.new("Unknown content encoding - #{response['content-encoding']}", response)
+      end
+    end
+
+    def uncompress(response)
+      raise Net::HTTPError.new("No block passed") unless block_given?
+
+      case response['content-encoding']
+      when 'gzip','deflate'
+        uncompressor = ZlibAdapter.new
+      when nil, 'identity'
+        uncompressor = IdentityAdapter.new
+      else
+        raise Net::HTTPError.new("Unknown content encoding - #{response['content-encoding']}", response)
+      end
+
+      yield uncompressor
+
+      uncompressor.close
+    end
+
+    def add_accept_encoding(headers={})
+      headers['accept-encoding'] = 'gzip; q=1.0, deflate; q=1.0; identity' if Puppet.settings[:http_compression]
+      headers
+    end
+
+    # This adapters knows how to uncompress both 'zlib' stream (the deflate algorithm from Content-Encoding)
+    # and GZip streams.
+    class ZlibAdapter
+      def initialize
+        # Create an inflater that knows to parse GZip streams and zlib streams.
+        # This uses a property of the C Zlib library, documented as follow:
+        #   windowBits can also be greater than 15 for optional gzip decoding. Add
+        #   32 to windowBits to enable zlib and gzip decoding with automatic header
+        #   detection, or add 16 to decode only the gzip format (the zlib format will
+        #   return a Z_DATA_ERROR).  If a gzip stream is being decoded, strm->adler is
+        #   a crc32 instead of an adler32.
+        @uncompressor = Zlib::Inflate.new(15 + 32)
+        @first = true
+      end
+
+      def uncompress(chunk)
+        out = @uncompressor.inflate(chunk)
+        @first = false
+        return out
+      rescue Zlib::DataError => z
+        # it can happen that we receive a raw deflate stream
+        # which might make our inflate throw a data error.
+        # in this case, we try with a verbatim (no header)
+        # deflater.
+        @uncompressor = Zlib::Inflate.new
+        if @first then
+          @first = false
+          retry
+        end
+        raise
+      end
+
+      def close
+        @uncompressor.finish
+        @uncompressor.close
+      end
+    end
+  end
+
+  module None
+    def uncompress_body(response)
+      response.body
+    end
+
+    def add_accept_encoding(headers)
+      headers
+    end
+
+    def uncompress(response)
+      yield IdentityAdapter.new
+    end
+  end
+
+  class IdentityAdapter
+    def uncompress(chunk)
+      chunk
+    end
+
+    def close
+    end
+  end
+end