chef-infra-api 0.9.1

data/lib/chef-api/defaults.rb

@@ -0,0 +1,197 @@
+require 'chef-api/version'
+require 'pathname'
+require 'json'
+
+module ChefAPI
+  module Defaults
+    # Default API endpoint
+    ENDPOINT = 'https://api.opscode.com/'.freeze
+
+    # Default User Agent header string
+    USER_AGENT = "ChefAPI Ruby Gem #{ChefAPI::VERSION}".freeze
+
+    class << self
+      #
+      # The list of calculated default options for the configuration.
+      #
+      # @return [Hash]
+      #
+      def options
+        Hash[Configurable.keys.map { |key| [key, send(key)] }]
+      end
+
+      #
+      # The Chef API configuration
+      #
+      # @return [Hash]
+      def config
+        path = config_path
+        @config ||= path.exist? ? JSON.parse(path.read) : {}
+      end
+
+      #
+      # Pathname to configuration file, or a blank Pathname.
+      #
+      # @return [Pathname] an expanded Pathname or a non-existent Pathname
+      def config_path
+        if result = chef_api_config_path
+          Pathname(result).expand_path
+        else
+          Pathname('')
+        end
+      end
+
+      #
+      # String representation of path to configuration file
+      #
+      # @return [String, nil] Path to config file, or nil
+      def chef_api_config_path
+        ENV['CHEF_API_CONFIG'] || if ENV.key?('HOME')
+                                    '~/.chef-api'
+                                  else
+                                    nil
+                                  end
+      end
+
+      #
+      # The endpoint where the Chef Server lives. This is equivalent to the
+      # +chef_server_url+ in Chef terminology. If you are using Enterprise
+      # Hosted Chef or Enterprise Chef on premise, this endpoint should include
+      # your organization name. For example:
+      #
+      #     https://api.opscode.com/organizations/bacon
+      #
+      # If you are running Open Source Chef Server or Chef Zero, this is the
+      # full URL to your Chef Server instance, including the server port and
+      # FQDN.
+      #
+      #     https://chef.server.local:4567/
+      #
+      # @return [String] (default: +https://api.opscode.com/+)
+      #
+      def endpoint
+        ENV['CHEF_API_ENDPOINT'] || config['CHEF_API_ENDPOINT'] || ENDPOINT
+      end
+
+      #
+      # The flavor of the target Chef Server. There are two possible values:
+      #
+      #   - enterprise
+      #   - open_source
+      #
+      # "Enterprise" covers both Hosted Chef and Enterprise Chef. "Open Source"
+      # covers both Chef Zero and Open Source Chef Server.
+      #
+      # @return [true, false]
+      #
+      def flavor
+        if ENV['CHEF_API_FLAVOR']
+          ENV['CHEF_API_FLAVOR'].to_sym
+        elsif config['CHEF_API_FLAVOR']
+          config['CHEF_API_FLAVOR']
+        else
+          endpoint.include?('/organizations') ? :enterprise : :open_source
+        end
+      end
+
+      #
+      # The User Agent header to send along.
+      #
+      # @return [String]
+      #
+      def user_agent
+        ENV['CHEF_API_USER_AGENT'] || config['CHEF_API_USER_AGENT'] || USER_AGENT
+      end
+
+      #
+      # The name of the Chef API client. This is the equivalent of
+      # +client_name+ in Chef terminology. In most cases, this is your Chef
+      # username.
+      #
+      # @return [String, nil]
+      #
+      def client
+        ENV['CHEF_API_CLIENT'] || config['CHEF_API_CLIENT']
+      end
+
+      #
+      # The private key to authentication against the Chef Server. This is
+      # equivalent to the +client_key+ in Chef terminology. This value can
+      # be the client key in plain text or a path to the key on disk.
+      #
+      # @return [String, nil]
+      #
+      def key
+         ENV['CHEF_API_KEY'] || config['CHEF_API_KEY']
+      end
+      #
+      # The HTTP Proxy server address as a string
+      #
+      # @return [String, nil]
+      #
+      def proxy_address
+        ENV['CHEF_API_PROXY_ADDRESS'] || config['CHEF_API_PROXY_ADDRESS']
+      end
+
+      #
+      # The HTTP Proxy user password as a string
+      #
+      # @return [String, nil]
+      #
+      def proxy_password
+        ENV['CHEF_API_PROXY_PASSWORD'] || config['CHEF_API_PROXY_PASSWORD']
+      end
+
+      #
+      # The HTTP Proxy server port as a string
+      #
+      # @return [String, nil]
+      #
+      def proxy_port
+        ENV['CHEF_API_PROXY_PORT'] || config['CHEF_API_PROXY_PORT']
+      end
+
+      #
+      # The HTTP Proxy server username as a string
+      #
+      # @return [String, nil]
+      #
+      def proxy_username
+        ENV['CHEF_API_PROXY_USERNAME'] || config['CHEF_API_PROXY_USERNAME']
+      end
+
+      #
+      # The path to a pem file on disk for use with a custom SSL verification
+      #
+      # @return [String, nil]
+      #
+      def ssl_pem_file
+        ENV['CHEF_API_SSL_PEM_FILE'] || config['CHEF_API_SSL_PEM_FILE']
+      end
+
+      #
+      # Verify SSL requests (default: true)
+      #
+      # @return [true, false]
+      #
+      def ssl_verify
+        if ENV['CHEF_API_SSL_VERIFY'].nil? && config['CHEF_API_SSL_VERIFY'].nil?
+          true
+        else
+          %w[t y].include?(ENV['CHEF_API_SSL_VERIFY'].downcase[0]) || config['CHEF_API_SSL_VERIFY']
+        end
+      end
+
+      #
+      # Network request read timeout in seconds (default: 60)
+      #
+      # @return [Integer, nil]
+      #
+      def read_timeout
+        timeout_from_env = ENV['CHEF_API_READ_TIMEOUT'] || config['CHEF_API_READ_TIMEOUT']
+
+        Integer(timeout_from_env) unless timeout_from_env.nil?
+      end
+    end
+  end
+end

data/lib/chef-api/error_collection.rb

@@ -0,0 +1,44 @@
+module ChefAPI
+  #
+  # Private internal class for managing the error collection.
+  #
+  class ErrorCollection < Hash
+    #
+    # The default proc for the hash needs to be an empty Array.
+    #
+    # @return [Proc]
+    #
+    def initialize
+      super { |h, k| h[k] = [] }
+    end
+
+    #
+    # Add a new error to the hash.
+    #
+    # @param [Symbol] key
+    #   the attribute key
+    # @param [String] error
+    #   the error message to push
+    #
+    # @return [self]
+    #
+    def add(key, error)
+      self[key].push(error)
+      self
+    end
+
+    #
+    # Output the full messages for each error. This is useful for displaying
+    # information about validation to the user when something goes wrong.
+    #
+    # @return [Array<String>]
+    #
+    def full_messages
+      self.map do |key, errors|
+        errors.map do |error|
+          "`#{key}' #{error}"
+        end
+      end.flatten
+    end
+  end
+end

data/lib/chef-api/errors.rb

@@ -0,0 +1,64 @@
+require 'erb'
+
+module ChefAPI
+  module Error
+    class ErrorBinding
+      def initialize(options = {})
+        options.each do |key, value|
+          instance_variable_set(:"@#{key}", value)
+        end
+      end
+
+      def get_binding
+        binding
+      end
+    end
+
+    class ChefAPIError < StandardError
+      def initialize(options = {})
+        @options  = options
+        @filename = options.delete(:_template)
+
+        super()
+      end
+
+      def message
+        erb = ERB.new(File.read(template))
+        erb.result(ErrorBinding.new(@options).get_binding)
+      end
+      alias_method :to_s, :message
+
+      private
+
+      def template
+        class_name = self.class.to_s.split('::').last
+        filename   = @filename || Util.underscore(class_name)
+        ChefAPI.root.join('templates', 'errors', "#{filename}.erb")
+      end
+    end
+
+    class AbstractMethod < ChefAPIError; end
+    class CannotRegenerateKey < ChefAPIError; end
+    class FileNotFound < ChefAPIError; end
+
+    class HTTPError < ChefAPIError; end
+    class HTTPBadRequest < HTTPError; end
+    class HTTPForbiddenRequest < HTTPError; end
+    class HTTPGatewayTimeout < HTTPError; end
+    class HTTPNotAcceptable < HTTPError; end
+    class HTTPNotFound < HTTPError; end
+    class HTTPMethodNotAllowed < HTTPError; end
+    class HTTPServerUnavailable < HTTPError; end
+
+    class HTTPUnauthorizedRequest < ChefAPIError; end
+    class InsufficientFilePermissions < ChefAPIError; end
+    class InvalidResource < ChefAPIError; end
+    class InvalidValidator < ChefAPIError; end
+    class MissingURLParameter < ChefAPIError; end
+    class NotADirectory < ChefAPIError; end
+    class ResourceAlreadyExists < ChefAPIError; end
+    class ResourceNotFound < ChefAPIError; end
+    class ResourceNotMutable < ChefAPIError; end
+    class UnknownAttribute < ChefAPIError; end
+  end
+end

data/lib/chef-api/multipart.rb

@@ -0,0 +1,164 @@
+require 'cgi'
+require 'mime/types'
+
+module ChefAPI
+  module Multipart
+    BOUNDARY = '------ChefAPIMultipartBoundary'.freeze
+
+    class Body
+      def initialize(params = {})
+        params.each do |key, value|
+          if value.respond_to?(:read)
+            parts << FilePart.new(key, value)
+          else
+            parts << ParamPart.new(key, value)
+          end
+        end
+
+        parts << EndingPart.new
+      end
+
+      def stream
+        MultiIO.new(*parts.map(&:io))
+      end
+
+      def content_type
+        "multipart/form-data; boundary=#{BOUNDARY}"
+      end
+
+      def content_length
+        parts.map(&:size).inject(:+)
+      end
+
+      private
+
+      def parts
+        @parts ||= []
+      end
+    end
+
+    class MultiIO
+      attr_reader :ios
+
+      def initialize(*ios)
+        @ios = ios
+        @index = 0
+      end
+
+      # Read from IOs in order until `length` bytes have been received.
+      def read(length = nil, outbuf = nil)
+        got_result = false
+        outbuf = outbuf ? outbuf.replace('') : ''
+
+        while io = current_io
+          if result = io.read(length)
+            got_result ||= !result.nil?
+            result.force_encoding('BINARY') if result.respond_to?(:force_encoding)
+            outbuf << result
+            length -= result.length if length
+            break if length == 0
+          end
+          advance_io
+        end
+
+        (!got_result && length) ? nil : outbuf
+      end
+
+      def rewind
+        @ios.each { |io| io.rewind }
+        @index = 0
+      end
+
+      private
+
+      def current_io
+        @ios[@index]
+      end
+
+      def advance_io
+        @index += 1
+      end
+    end
+
+    #
+    # A generic key => value part.
+    #
+    class ParamPart
+      def initialize(name, value)
+        @part = build(name, value)
+      end
+
+      def io
+        @io ||= StringIO.new(@part)
+      end
+
+      def size
+        @part.bytesize
+      end
+
+      private
+
+      def build(name, value)
+        part =  %|--#{BOUNDARY}\r\n|
+        part << %|Content-Disposition: form-data; name="#{CGI.escape(name)}"\r\n\r\n|
+        part << %|#{value}\r\n|
+        part
+      end
+    end
+
+    #
+    # A File part
+    #
+    class FilePart
+      def initialize(name, file)
+        @file = file
+        @head = build(name, file)
+        @foot = "\r\n"
+      end
+
+      def io
+        @io ||= MultiIO.new(
+          StringIO.new(@head),
+          @file,
+          StringIO.new(@foot)
+        )
+      end
+
+      def size
+        @head.bytesize + @file.size + @foot.bytesize
+      end
+
+      private
+
+      def build(name, file)
+        filename  = File.basename(file.path)
+        mime_type = MIME::Types.type_for(filename)[0] || MIME::Types['application/octet-stream'][0]
+
+        part =  %|--#{BOUNDARY}\r\n|
+        part << %|Content-Disposition: form-data; name="#{CGI.escape(name)}"; filename="#{filename}"\r\n|
+        part << %|Content-Length: #{file.size}\r\n|
+        part << %|Content-Type: #{mime_type.simplified}\r\n|
+        part << %|Content-Transfer-Encoding: binary\r\n|
+        part << %|\r\n|
+        part
+      end
+    end
+
+    #
+    # The end of the entire request
+    #
+    class EndingPart
+      def initialize
+        @part = "--#{BOUNDARY}--\r\n\r\n"
+      end
+
+      def io
+        @io ||= StringIO.new(@part)
+      end
+
+      def size
+        @part.bytesize
+      end
+    end
+  end
+end