puppet-rest 0.0.3

data/lib/puppet-rest/monkey_patches/mash.rb

@@ -0,0 +1,219 @@
+# Copyright (c) 2009 Dan Kubb
+
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+# ---
+# ---
+
+# Some portions of blank.rb and mash.rb are verbatim copies of software
+# licensed under the MIT license. That license is included below:
+
+# Copyright (c) 2005-2008 David Heinemeier Hansson
+
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+# This class has dubious semantics and we only have it so that people can write
+# params[:key] instead of params['key'].
+class Mash < Hash
+
+  # @param constructor<Object>
+  #   The default value for the mash. Defaults to an empty hash.
+  #
+  #  [Alternatives]
+  #   If constructor is a Hash, a new mash will be created based on the keys of
+  #   the hash and no default value will be set.
+  def initialize(constructor = {})
+    if constructor.is_a?(Hash)
+      super()
+      update(constructor)
+    else
+      super(constructor)
+    end
+  end
+
+  # @param orig<Object> Mash being copied
+  #
+  # @return [Object] A new copied Mash
+  def initialize_copy(orig)
+    super
+    # Handle nested values
+    each do |k,v|
+      if v.kind_of?(Mash) || v.is_a?(Array)
+        self[k] = v.dup
+      end
+    end
+    self
+  end
+
+  # @param key<Object> The default value for the mash. Defaults to nil.
+  #
+  #  [Alternatives]
+  #   If key is a Symbol and it is a key in the mash, then the default value will
+  #   be set to the value matching the key.
+  def default(key = nil)
+    if key.is_a?(Symbol) && include?(key = key.to_s)
+      self[key]
+    else
+      super
+    end
+  end
+
+  alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
+  alias_method :regular_update, :update unless method_defined?(:regular_update)
+
+  # @param key<Object> The key to set.
+  # @param value<Object>
+  #   The value to set the key to.
+  #
+  # @see Mash#convert_key
+  # @see Mash#convert_value
+  def []=(key, value)
+    regular_writer(convert_key(key), convert_value(value))
+  end
+
+  # @param other_hash<Hash>
+  #   A hash to update values in the mash with. The keys and the values will be
+  #   converted to Mash format.
+  #
+  # @return [Mash] The updated mash.
+  def update(other_hash)
+    other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
+    self
+  end
+
+  alias_method :merge!, :update
+
+  # @param key<Object> The key to check for. This will be run through convert_key.
+  #
+  # @return [Boolean] True if the key exists in the mash.
+  def key?(key)
+    super(convert_key(key))
+  end
+
+  # def include? def has_key? def member?
+  alias_method :include?, :key?
+  alias_method :has_key?, :key?
+  alias_method :member?, :key?
+
+  # @param key<Object> The key to fetch. This will be run through convert_key.
+  # @param extras<Array> Default value.
+  #
+  # @return [Object] The value at key or the default value.
+  def fetch(key, *extras)
+    super(convert_key(key), *extras)
+  end
+
+  # @param indices<Array>
+  #   The keys to retrieve values for. These will be run through +convert_key+.
+  #
+  # @return [Array] The values at each of the provided keys
+  def values_at(*indices)
+    indices.collect {|key| self[convert_key(key)]}
+  end
+
+  # @param hash<Hash> The hash to merge with the mash.
+  #
+  # @return [Mash] A new mash with the hash values merged in.
+  def merge(hash)
+    self.dup.update(hash)
+  end
+
+  # @param key<Object>
+  #   The key to delete from the mash.\
+  def delete(key)
+    super(convert_key(key))
+  end
+
+  # @return [Mash] A new mash without the selected keys.
+  #
+  # @example
+  #   { :one => 1, :two => 2, :three => 3 }.except(:one)
+  #     #=> { "two" => 2, "three" => 3 }
+  def except(*keys)
+    super(*keys.map {|k| convert_key(k)})
+  end
+
+  # Used to provide the same interface as Hash.
+  #
+  # @return [Mash] This mash unchanged.
+  def stringify_keys!; self end
+
+  # @return [Hash] The mash as a Hash with symbolized keys.
+  def symbolize_keys
+    h = Hash.new(default)
+    each { |key, val| h[key.to_sym] = val }
+    h
+  end
+
+  # @return [Hash] The mash as a Hash with string keys.
+  def to_hash
+    Hash.new(default).merge(self)
+  end
+
+  # @return [Mash] Convert a Hash into a Mash
+  # The input Hash's default value is maintained
+  def self.from_hash(hash)
+    mash = Mash.new(hash)
+    mash.default = hash.default
+    mash
+  end
+
+  protected
+  # @param key<Object> The key to convert.
+  #
+  # @api private
+  def convert_key(key)
+    key.kind_of?(Symbol) ? key.to_s : key
+  end
+
+  # @param value<Object> The value to convert.
+  #
+  # @return [Object]
+  #   The converted value. A Hash or an Array of hashes, will be converted to
+  #   their Mash equivalents.
+  #
+  # @api private
+  def convert_value(value)
+    if value.class == Hash
+      Mash.from_hash(value)
+    elsif value.is_a?(Array)
+      value.collect { |e| convert_value(e) }
+    else
+      value
+    end
+  end
+end

data/lib/puppet-rest/pe/client.rb

@@ -0,0 +1,42 @@
+module PuppetRestClient::PE
+  extend PuppetRestClient::PE::Config
+
+  class << self
+    # Convenience alias for PuppetRestClient::DbConnection.new
+    #
+    # return [PuppetRestClient::DbConnection]
+    def new(options=Mash.new)
+      PuppetRestClient::PE::Connection.new(options)
+    end
+
+    # Delegate methods to PuppetRestClient::Connection
+    def method_missing(method, *args, &block)
+      return super unless new.respond_to?(method)
+      new.send(method, *args, &block)
+    end
+
+    def respond_to?(method, include_private=false)
+      new.respond_to?(method, include_private) || super(method, include_private)
+    end
+
+    def read_key_file(path)
+      key_file_path = File.expand_path(path)
+
+      begin
+        raw_key = File.read(key_file_path).strip
+      rescue SystemCallError, IOError => e
+        raise IOError, "Unable to read #{key_file_path}"
+      end
+
+      begin_rsa = '-----BEGIN RSA PRIVATE KEY-----'
+      end_rsa   = '-----END RSA PRIVATE KEY-----'
+
+      unless (raw_key =~ /\A#{begin_rsa}$/) && (raw_key =~ /^#{end_rsa}\Z/)
+        msg = "The file #{key_file_path} is not a properly formatted private key.\n"
+        msg << "It must contain '#{begin_rsa}' and '#{end_rsa}'"
+        raise ArgumentError, msg
+      end
+      return OpenSSL::PKey::RSA.new(raw_key)
+    end
+  end
+end

data/lib/puppet-rest/pe/config.rb

@@ -0,0 +1,93 @@
+module PuppetRestClient::PE
+  module Config
+
+    # The default Chef server URL
+    DEFAULT_SERVER_URL = 'http://localhost:8140'
+
+    # The default Spice User-Agent header
+    DEFAULT_USER_AGENT = "PuppetRestClient #{PuppetRestClient::VERSION}"
+
+    # Default connection options
+    DEFAULT_CONNECTION_OPTIONS = {}
+
+    # Default client name
+    DEFAULT_CLIENT_NAME = ''
+
+    # Default key file
+    DEFAULT_CLIENT_KEY = ''
+
+    DEFAULT_ENVIRONMENT = 'production'
+
+    DEFAULT_ACCEPT = 'pson'
+
+    # Default puppetpe rest api version
+    # v1, v2 leave blank
+    # 2015.2 or greater pass in 'puppet/v3'
+    DEFAULT_API_VERSION = nil
+
+    # An array of valid config options
+    VALID_OPTIONS_KEYS = [
+      :server_url,
+      :environment,
+      :api_version,
+      :client_name,
+      :client_key,
+      :user_agent,
+      :connection_options,
+      :middleware,
+      :accept
+    ]
+
+    # Default middleware stack
+    DEFAULT_MIDDLEWARE = Proc.new do |builder|
+      builder.use PuppetRestClient::Response::ParseJSON
+      builder.use PuppetRestClient::Response::ClientError
+      builder.adapter Faraday.default_adapter
+    end
+
+    VALID_OPTIONS_KEYS.each do |key|
+      attr_accessor key
+    end
+
+    # Reset all config options to default when the module is extended
+    def self.extended(base)
+      base.reset
+    end # def self.extended
+
+    # Convenience method to configure PuppetRestClient in a block
+    # @example Configuring PuppetRestClient
+    #   PuppetRestClient.setup do |s|
+    #     s.server_url  = "http://puppetdb.example.com:8081"
+    #     s.client_name = "admin"
+    #     s.client_key    = PuppetRestClient.read_key_file("/path/to/key_file.pem")
+    #   end
+    # @yieldparam PuppetRestClient
+    # @yieldreturn PuppetRestClient
+    def setup
+      yield self
+      self
+    end
+
+    # Create an options hash from valid options keys
+    def options
+      options = {}
+      VALID_OPTIONS_KEYS.each{|k| options[k] = send(k)}
+      options
+    end
+
+    # Reset all config options to their defaults
+    def reset
+      self.user_agent         = DEFAULT_USER_AGENT
+      self.environment        = DEFAULT_ENVIRONMENT
+      self.api_version        = DEFAULT_API_VERSION
+      self.server_url         = DEFAULT_SERVER_URL
+      self.client_name        = DEFAULT_CLIENT_NAME
+      self.client_key         = DEFAULT_CLIENT_KEY
+      self.connection_options = DEFAULT_CONNECTION_OPTIONS
+      self.middleware         = DEFAULT_MIDDLEWARE
+      self.accept             = DEFAULT_ACCEPT
+      self
+    end
+
+  end
+end

data/lib/puppet-rest/pe/connection.rb

@@ -0,0 +1,25 @@
+module PuppetRestClient::PE
+  class Connection
+    include PuppetRestClient::PE::Connection::Node
+    include PuppetRestClient::PE::Connection::Catalog
+    include PuppetRestClient::PE::Connection::CaCert
+    include PuppetRestClient::PE::Request
+
+    Config::VALID_OPTIONS_KEYS.each do |key|
+      attr_accessor key
+    end
+
+    def initialize(attrs=Mash.new)
+      attrs = PuppetRestClient::PE.options.merge(attrs)
+
+      #unless attrs[:client_key].is_a?(OpenSSL::PKey::RSA)
+      #  attrs[:client_key] = OpenSSL::PKey::RSA.new(attrs[:client_key])
+      #end
+
+      PuppetRestClient::PE::Config::VALID_OPTIONS_KEYS.each do |key|
+        instance_variable_set("@#{key}".to_sym, attrs[key])
+      end
+    end
+
+  end
+end

data/lib/puppet-rest/pe/connection/ca_cert.rb

@@ -0,0 +1,10 @@
+module PuppetRestClient::PE
+  class Connection
+    module CaCert
+      def ca_cert
+        self.accept = 's'
+        get(api_path('certificate', 'ca'), nil, {:raw => 1}).body.strip
+      end
+    end
+  end
+end

data/lib/puppet-rest/pe/connection/catalog.rb

@@ -0,0 +1,10 @@
+module PuppetRestClient::PE
+  class Connection
+    module Catalog
+      def catalog(name)
+        attributes = get(api_path('catalog', name))
+        PuppetRestClient::PE::Catalog.get_or_new(attributes)
+      end
+    end
+  end
+end

data/lib/puppet-rest/pe/connection/node.rb

@@ -0,0 +1,10 @@
+module PuppetRestClient::PE
+  class Connection
+    module Node
+      def node(name)
+        attributes = get(api_path('node', name))
+        PuppetRestClient::PE::Node.get_or_new(attributes)
+      end
+    end
+  end
+end

data/lib/puppet-rest/pe/entities/base.rb

@@ -0,0 +1,100 @@
+module PuppetRestClient::PE
+  class Base
+    attr_accessor :attrs
+    alias :to_hash :attrs
+
+    @@identity_map = PuppetRestClient::IdentityMap.new
+
+    def self.identity_map
+      @@identity_map
+    end # def self.identity_map
+
+    # Define methods that retrieve the value from an initialized instance variable Hash, using the attribute as a key
+    #
+    # @overload self.attr_reader(attr)
+    #   @param attr [Symbol]
+    # @overload self.attr_reader(attrs)
+    #   @param attrs [Array<Symbol>]
+    def self.attr_reader(*attrs)
+      attrs.each do |attribute|
+        class_eval do
+          define_method attribute do
+            @attrs[attribute.to_s]
+          end
+          define_method "#{attribute}=" do |value|
+            @attrs[attribute.to_s] = value
+          end
+        end
+      end
+    end # def self.attr_reader
+
+    def self.get(attrs=Mash.new)
+      @@identity_map[self] ||= {}
+      if attrs['title']
+        @@identity_map[self][attrs['title']] && @@identity_map[self][attrs['title']].update(attrs)
+      elsif attrs['resource']
+        @@identity_map[self][attrs['resource']] && @@identity_map[self][attrs['resource']].update(attrs)
+      else
+        @@identity_map[self][Marshal.dump(attrs)]
+      end
+    end # def self.get
+
+    # Retrieve an object from the identity map or initialize a new object
+    def self.get_or_new(attrs=Mash.new)
+      self.get(attrs) || self.new(attrs)
+    end # def self.get_or_new
+
+    # Initializes a new object
+    #
+    # @param attrs [Hash]
+    # @return [PuppetRestClient::Base]
+    def initialize(attrs=Mash.new)
+      self.class.attr_reader *attrs.keys
+      attrs.stringify_keys!
+      self.update attrs
+      if attrs['title']
+        @@identity_map[self.class] ||= {}
+        @@identity_map[self.class][attrs['title']] = self
+      elsif attrs['resource']
+        @@identity_map[self.class] ||= {}
+        @@identity_map[self.class][attrs['resource']] = self
+      else
+        @@identity_map[self.class] ||= {}
+        @@identity_map[self.class][Marshal.dump(attrs)] = self
+      end
+    end # def initialize
+
+    # Fetches an attribute of an object using hash notation
+    #
+    # @param method [String, Symbol] Message to send to the object
+    def [](method)
+      self.__send__(method.to_sym)
+    rescue NoMethodError
+      nil
+    end # def []
+
+    # Update the attributes of an object
+    #
+    # @param attrs [Hash]
+    # @return [PuppetRestClient::Base]
+    def update(attrs)
+      @attrs = attrs
+      self
+    end # def update
+
+    # @return [String]
+    def resource
+      @attrs['resource']
+    end # def id
+
+    # @return [String]
+    def title
+      @attrs['title']
+    end # def name
+
+    def keys
+      @attrs.keys
+    end # def keys
+
+  end
+end