ridley 0.0.1

data/lib/ridley/middleware/chef_response.rb

@@ -0,0 +1,28 @@
+module Ridley
+  module Middleware
+    # @author Jamie Winsor <jamie@vialstudios.com>
+    class ChefResponse < Faraday::Response::Middleware
+      class << self
+        # Determines if a response from the Chef server was successful
+        #
+        # @param [Hash] env
+        #   a faraday request env
+        #
+        # @return [Boolean]
+        def success?(env)
+          (200..210).to_a.index(env[:status].to_i) ? true : false
+        end
+      end
+
+      def on_complete(env)
+        Ridley.log.debug("Handling Chef Response")
+        Ridley.log.debug(env)
+        
+        unless self.class.success?(env)
+          Ridley.log.debug("Error encounted in Chef Response")
+          raise Errors::HTTPError.fabricate(env)
+        end
+      end
+    end
+  end
+end

data/lib/ridley/middleware/parse_json.rb

@@ -0,0 +1,107 @@
+module Ridley
+  module Middleware
+    # @author Jamie Winsor <jamie@vialstudios.com>
+    class ParseJson < Faraday::Response::Middleware
+      JSON_TYPE  = 'application/json'.freeze
+      
+      BRACKETS   = [ 
+        "[",
+        "{"
+      ].freeze
+
+      WHITESPACE = [
+        " ",
+        "\n",
+        "\r",
+        "\t"
+      ].freeze
+      
+      class << self
+        # Takes a string containing JSON and converts it to a Ruby hash
+        # symbols for keys
+        #
+        # @param [String] body
+        #
+        # @return [Hash]
+        def parse(body)
+          MultiJson.load(body, symbolize_keys: true)
+        end
+
+        # Extracts the type of the response from the response headers
+        # of a Faraday request env. 'text/html' will be returned if no
+        # content-type is specified in the response 
+        #
+        # @example
+        #   env = {
+        #     :response_headers => {
+        #       'content-type' => 'text/html; charset=utf-8'
+        #     }
+        #     ...
+        #   }
+        #
+        #   ParseJson.response_type(env) => 'application/json'
+        #
+        # @param [Hash] env
+        #   a Faraday request env
+        #
+        # @return [String]
+        def response_type(env)
+          if env[:response_headers][CONTENT_TYPE].nil?
+            Ridley.log.debug "Response did not specify a content type."
+            return "text/html"
+          end
+
+          env[:response_headers][CONTENT_TYPE].split(';', 2).first
+        end
+
+        # Determines if the response of the given Faraday request env
+        # contains JSON
+        #
+        # @param [Hash] env
+        #   a Faraday request env
+        #
+        # @return [Boolean]
+        def json_response?(env)
+          response_type(env) == JSON_TYPE ||
+            looks_like_json?(env)
+        end
+
+        # Examines the body of a request env and returns true if it appears
+        # to contain JSON or false if it does not
+        #
+        # @param [Hash] env
+        #   a Faraday request env
+        # @return [Boolean]
+        def looks_like_json?(env)
+          return false unless env[:body].present?
+
+          BRACKETS.include?(first_char(env[:body]))
+        end
+
+        private
+
+          def first_char(body)
+            idx = -1
+            begin
+              char = body[idx += 1]
+              char = char.chr if char
+            end while char && WHITESPACE.include?(char)
+
+            char
+          end
+      end
+
+      def on_complete(env)
+        if self.class.json_response?(env)
+          Ridley.log.debug("Parsing JSON Chef Response")
+          Ridley.log.debug(env)
+
+          env[:body] = self.class.parse(env[:body])
+        else
+          Ridley.log.debug("Chef Response was not JSON")
+          Ridley.log.debug(env)
+        end
+      end
+    end
+  end
+end

data/lib/ridley/resource.rb

@@ -0,0 +1,305 @@
+module Ridley
+  # @author Jamie Winsor <jamie@vialstudios.com>
+  module Resource
+    extend ActiveSupport::Concern
+    include ActiveModel::AttributeMethods
+    include ActiveModel::Validations
+    include ActiveModel::Serializers::JSON
+
+    included do
+      attribute_method_suffix('=')
+    end
+
+    module ClassMethods
+      # @return [String, nil]
+      def chef_id
+        @chef_id
+      end
+
+      # @param [String, Symbol] identifier
+      #
+      # @return [String]
+      def set_chef_id(identifier)
+        @chef_id = identifier.to_sym
+      end
+
+      # @return [String]
+      def resource_path
+        @resource_path ||= self.chef_type.pluralize
+      end
+
+      # @param [String] path
+      #
+      # @return [String]
+      def set_resource_path(path)
+        @resource_path = path
+      end
+
+      # @return [String]
+      def chef_type
+        @chef_type ||= self.class.name.underscore
+      end
+
+      # @param [String, Symbol] type
+      #
+      # @return [String]
+      def set_chef_type(type)
+        @chef_type = type.to_s
+        attribute(:chef_type, default: type)
+      end
+
+      # @return [String, nil]
+      def chef_json_class
+        @chef_json_class
+      end
+
+      # @param [String, Symbol] klass
+      #
+      # @return [String]
+      def set_chef_json_class(klass)
+        @chef_json_class = klass
+        attribute(:json_class, default: klass)
+      end
+
+      # @return [Set]
+      def attributes
+        @attributes ||= Set.new
+      end
+
+      # @return [Hash]
+      def attribute_defaults
+        @attribute_defaults ||= Hash.new
+      end
+
+      # @param [String, Symbol] name
+      # @option options [Object] :default
+      #   defines the default value for the attribute
+      #
+      # @return [Set]
+      def attribute(name, options = {})
+        if options.has_key?(:default)
+          default_for_attribute(name, options[:default])
+        end
+        define_attribute_method(name)
+        attributes << name.to_sym
+      end
+
+      # @param [Ridley::Connection] connection
+      #
+      # @return [Array<Object>]
+      def all(connection)
+        connection.get(self.resource_path).body.collect do |identity, location|
+          new(connection, self.chef_id => identity)
+        end
+      end
+      
+      # @param [Ridley::Connection] connection
+      # @param [String, #chef_id] object
+      #
+      # @return [nil, Object]
+      def find(connection, object)
+        find!(connection, object)
+      rescue Errors::HTTPNotFound
+        nil
+      end
+
+      # @param [Ridley::Connection] connection
+      # @param [String, #chef_id] object
+      #
+      # @raise [Errors::HTTPNotFound]
+      #   if a resource with the given chef_id is not found
+      #
+      # @return [Object]
+      def find!(connection, object)
+        chef_id = object.respond_to?(:chef_id) ? object.chef_id : object
+        new(connection, connection.get("#{self.resource_path}/#{chef_id}").body)
+      end
+
+      # @param [Ridley::Connection] connection
+      # @param [#to_hash] object
+      #
+      # @return [Object]
+      def create(connection, object)
+        resource = new(connection, object.to_hash)
+        new_attributes = connection.post(self.resource_path, resource.to_json).body
+        resource.attributes = resource.attributes.merge(new_attributes)
+        resource
+      end
+
+      # @param [Ridley::Connection] connection
+      # @param [String, #chef_id] object
+      #
+      # @return [Object]
+      def delete(connection, object)
+        chef_id = object.respond_to?(:chef_id) ? object.chef_id : object
+        new(connection, connection.delete("#{self.resource_path}/#{chef_id}").body)
+      end
+
+      # @param [Ridley::Connection] connection
+      #
+      # @return [Array<Object>]
+      def delete_all(connection)
+        mutex = Mutex.new
+        deleted = []
+        resources = all(connection)
+
+        connection.thread_count.times.collect do
+          Thread.new(connection, resources, deleted) do |connection, resources, deleted|
+            while resource = mutex.synchronize { resources.pop }
+              result = delete(connection, resource)
+              mutex.synchronize { deleted << result }
+            end
+          end
+        end.each(&:join)
+
+        deleted
+      end
+
+      # @param [Ridley::Connection] connection
+      # @param [#to_hash] object
+      #
+      # @return [Object]
+      def update(connection, object)
+        resource = new(connection, object.to_hash)
+        new(connection, connection.put("#{self.resource_path}/#{resource.chef_id}", resource.to_json).body)
+      end
+
+      private
+
+        def default_for_attribute(name, value)
+          attribute_defaults[name.to_sym] = value
+        end
+    end
+
+    # @param [Ridley::Connection] connection
+    # @param [Hash] attributes
+    def initialize(connection, attributes = {})
+      @connection = connection
+      self.attributes = self.class.attribute_defaults.merge(attributes)
+    end
+
+    # @param [String, Symbol] key
+    #
+    # @return [Object]
+    def attribute(key)
+      if instance_variable_defined?("@#{key}")
+        instance_variable_get("@#{key}")
+      else
+        self.class.attribute_defaults[key]
+      end
+    end
+    alias_method :[], :attribute
+
+    # @param [String, Symbol] key
+    # @param [Object] value
+    #
+    # @return [Object]
+    def attribute=(key, value)
+      instance_variable_set("@#{key}", value)
+    end
+    alias_method :[]=, :attribute=
+
+    # @param [String, Symbol] key
+    #
+    # @return [Boolean]
+    def attribute?(key)
+      attribute(key).present?
+    end
+
+    # @return [Hash]
+    def attributes
+      {}.tap do |attrs|
+        self.class.attributes.each do |attr|
+          attrs[attr] = attribute(attr)
+        end
+      end
+    end
+
+    # @param [#to_hash] new_attributes
+    #
+    # @return [Hash]
+    def attributes=(new_attributes)
+      new_attributes.to_hash.symbolize_keys!
+
+      self.class.attributes.each do |attr_name|
+        send(:attribute=, attr_name, new_attributes[attr_name.to_sym])
+      end
+    end
+
+    # Creates a resource on the target remote or updates one if the resource
+    # already exists.
+    #
+    # @raise [Errors::InvalidResource]
+    #   if the resource does not pass validations
+    #
+    # @return [Boolean]
+    #   true if successful and false for failure
+    def save
+      raise Errors::InvalidResource.new(self.errors) unless valid?
+
+      self.attributes = self.class.create(connection, self).attributes
+      true
+    rescue Errors::HTTPConflict
+      self.attributes = self.class.update(connection, self).attributes
+      true
+    end
+
+    # @return [String]
+    def chef_id
+      attribute(self.class.chef_id)
+    end
+
+    # @param [String] json
+    # @option options [Boolean] :symbolize_keys
+    # @option options [Class, Symbol, String] :adapter
+    #
+    # @return [Object]
+    def from_json(json, options = {})
+      self.attributes = MultiJson.load(json, options)
+      self
+    end
+
+    # @param [#to_hash] hash
+    #
+    # @return [Object]
+    def from_hash(hash)
+      self.attributes = hash.to_hash
+      self
+    end
+
+    # @option options [Boolean] :symbolize_keys
+    # @option options [Class, Symbol, String] :adapter
+    #
+    # @return [String]
+    def to_json(options = {})
+      MultiJson.dump(self.attributes, options)
+    end
+    alias_method :as_json, :to_json
+
+    def to_hash
+      self.attributes
+    end
+
+    def to_s
+      self.attributes
+    end
+
+    # @param [Object] other
+    #
+    # @return [Boolean]
+    def ==(other)
+      self.attributes == other.attributes
+    end
+
+    # @param [Object] other
+    #
+    # @return [Boolean]
+    def eql?(other)
+      other.is_a?(self.class) && send(:==, other)
+    end
+
+    private
+
+      attr_reader :connection
+  end
+end

data/lib/ridley/resources/client.rb

@@ -0,0 +1,75 @@
+module Ridley
+  # @author Jamie Winsor <jamie@vialstudios.com>
+  class Client
+    include Ridley::Resource
+
+    class << self
+      # Retrieves a client from the remote connection matching the given chef_id
+      # and regenerates it's private key. An instance of the updated object will
+      # be returned and have a value set for the 'private_key' accessor.
+      #
+      # @param [Ridley::Connection] connection
+      # @param [String, #chef_id] client
+      #
+      # @raise [Errors::HTTPNotFound]
+      #   if a client with the given chef_id is not found
+      # @raise [Errors::HTTPError]
+      #
+      # @return [Ridley::Client]
+      def regenerate_key(connection, client)
+        obj = find!(connection, client)
+        obj.regenerate_key
+        obj
+      end
+    end
+
+    set_chef_id "name"
+    set_chef_type "client"
+    set_chef_json_class "Chef::ApiClient"
+    set_resource_path "clients"
+
+    attribute :name
+    validates_presence_of :name
+
+    attribute :admin, default: false
+    validates_inclusion_of :admin, in: [ true, false ]
+
+    attribute :validator, default: false
+    validates_inclusion_of :validator, in: [ true, false ]
+
+    attribute :certificate
+    attribute :public_key
+    attribute :private_key
+    attribute :orgname
+
+    def attributes
+      # @todo JW: reflect on the connection type to determine if we need to strip the
+      # json_class attribute. Only OHC/OPC needs this stripped.
+      super.except(:json_class)
+    end
+
+    # Regenerates the private key of the instantiated client object. The new
+    # private key will be set to the value of the 'private_key' accessor
+    # of the instantiated client object.
+    #
+    # @return [Boolean]
+    #   true for success and false for failure
+    def regenerate_key
+      self.private_key = true
+      self.save
+    end
+  end
+
+  module DSL
+    # Coerces instance functions into class functions on Ridley::Client. This coercion
+    # sends an instance of the including class along to the class function.
+    #
+    # @see Ridley::Context
+    #
+    # @return [Ridley::Context]
+    #   a context object to delegate instance functions to class functions on Ridley::Client
+    def client
+      Context.new(Ridley::Client, self)
+    end
+  end
+end