ridley 0.0.1

data/Thorfile

@@ -0,0 +1,48 @@
+# encoding: utf-8
+$:.push File.expand_path("../lib", __FILE__)
+
+require 'bundler'
+require 'bundler/setup'
+
+require 'ridley'
+require 'thor/rake_compat'
+
+class Default < Thor
+  include Thor::RakeCompat
+  Bundler::GemHelper.install_tasks
+
+  desc "build", "Build berkshelf-#{Ridley::VERSION}.gem into the pkg directory"
+  def build
+    Rake::Task["build"].execute
+  end
+
+  desc "install", "Build and install berkshelf-#{Ridley::VERSION}.gem into system gems"
+  def install
+    Rake::Task["install"].execute
+  end
+
+  desc "release", "Create tag v#{Ridley::VERSION} and build and push berkshelf-#{Ridley::VERSION}.gem to Rubygems"
+  def release
+    Rake::Task["release"].execute
+  end
+
+  class Spec < Thor
+    namespace :spec
+    default_task :all
+
+    desc "all", "run all tests"
+    def all
+      exec "rspec --color --format=documentation spec"
+    end
+
+    desc "unit", "run only unit tests"
+    def unit
+      exec "rspec --color --format=documentation spec --tag ~type:acceptance" 
+    end
+
+    desc "acceptance", "run only acceptance tests"
+    def acceptance
+      exec "rspec --color --format=documentation spec --tag type:acceptance"
+    end
+  end
+end

data/lib/ridley.rb

@@ -0,0 +1,48 @@
+require 'faraday'
+require 'addressable/uri'
+require 'yajl'
+require 'multi_json'
+require 'active_model'
+require 'active_support/inflector'
+require 'active_support/core_ext'
+require 'forwardable'
+require 'set'
+require 'thread'
+
+require 'ridley/errors'
+
+# @author Jamie Winsor <jamie@vialstudios.com>
+module Ridley
+  CHEF_VERSION = '10.12.0'.freeze
+
+  autoload :Log, 'ridley/log'  
+  autoload :Connection, 'ridley/connection'
+  autoload :DSL, 'ridley/dsl'
+  autoload :Context, 'ridley/context'
+  autoload :Resource, 'ridley/resource'
+  autoload :Environment, 'ridley/resources/environment'
+  autoload :Role, 'ridley/resources/role'
+  autoload :Client, 'ridley/resources/client'
+  autoload :Node, 'ridley/resources/node'
+  autoload :DataBag, 'ridley/resources/data_bag'
+  autoload :DataBagItem, 'ridley/resources/data_bag_item'
+  autoload :Cookbook, 'ridley/resources/cookbook'
+
+  class << self
+    def connection(*args)
+      Connection.new(*args)
+    end
+
+    def sync(*args, &block)
+      Connection.sync(*args, &block)
+    end
+
+    # @return [Ridley::Log]
+    def log
+      Ridley::Log
+    end
+    alias_method :logger, :log
+  end
+end
+
+require 'ridley/middleware'

data/lib/ridley/connection.rb

@@ -0,0 +1,131 @@
+module Ridley
+  # @author Jamie Winsor <jamie@vialstudios.com>
+  class Connection
+    class << self
+      def sync(options, &block)
+        new(options).sync(&block)
+      end
+    end
+
+    extend Forwardable
+    include Ridley::DSL
+
+    attr_reader :client_name
+    attr_reader :client_key
+    attr_reader :organization
+
+    attr_accessor :thread_count
+
+    def_delegator :conn, :build_url
+    def_delegator :conn, :scheme
+    def_delegator :conn, :host
+    def_delegator :conn, :port
+    def_delegator :conn, :path_prefix
+
+    def_delegator :conn, :get
+    def_delegator :conn, :put
+    def_delegator :conn, :post
+    def_delegator :conn, :delete
+    def_delegator :conn, :head
+
+    def_delegator :conn, :in_parallel
+
+    REQUIRED_OPTIONS = [
+      :server_url,
+      :client_name,
+      :client_key
+    ]
+
+    DEFAULT_THREAD_COUNT = 8
+
+    # @option options [String] :server_url
+    # @option options [String] :client_name
+    # @option options [String] :client_key
+    # @option options [Integer] :thread_count
+    # @option options [Hash] :params
+    #   URI query unencoded key/value pairs
+    # @option options [Hash] :headers
+    #   unencoded HTTP header key/value pairs
+    # @option options [Hash] :request
+    #   request options
+    # @option options [Hash] :ssl
+    #   SSL options
+    # @option options [URI, String, Hash] :proxy
+    #   URI, String, or Hash of HTTP proxy options
+    def initialize(options = {})
+      options[:thread_count] ||= DEFAULT_THREAD_COUNT
+
+      validate_options(options)
+
+      @client_name  = options[:client_name]
+      @client_key   = options[:client_key]
+      @organization = options[:organization]
+      @thread_count = options[:thread_count]
+
+      faraday_options = options.slice(:params, :headers, :request, :ssl, :proxy)
+      uri_hash = Addressable::URI.parse(options[:server_url]).to_hash.slice(:scheme, :host, :port)
+
+      unless uri_hash[:port]
+        uri_hash[:port] = (uri_hash[:scheme] == "https" ? 443 : 80)
+      end
+
+      if organization
+        uri_hash[:path] = "/organizations/#{organization}"
+      end
+
+      server_uri = Addressable::URI.new(uri_hash)
+
+      @conn = Faraday.new(server_uri, faraday_options) do |c|
+        c.request :chef_auth, client_name, client_key
+        c.response :chef_response
+        c.response :json
+
+        c.adapter Faraday.default_adapter
+      end
+    end
+
+    def sync(&block)
+      unless block
+        raise Errors::InternalError, "A block must be given to synchronously process requests."
+      end
+
+      evaluate(&block)
+    end
+
+    # @return [Symbol]
+    def api_type
+      organization.nil? ? :foss : :hosted
+    end
+
+    # @return [Boolean]
+    def hosted?
+      api_type == :hosted
+    end
+
+    # @return [Boolean]
+    def foss?
+      api_type == :foss
+    end
+
+    private
+
+      attr_reader :conn
+
+      def evaluate(&block)
+        @self_before_instance_eval = eval("self", block.binding)
+        instance_eval(&block)
+      end
+
+      def method_missing(method, *args, &block)
+        @self_before_instance_eval.send(method, *args, &block)
+      end
+
+      def validate_options(options)
+        missing = REQUIRED_OPTIONS - options.keys
+        unless missing.empty?
+          missing.collect! { |opt| "'#{opt}'" }
+          raise ArgumentError, "missing required option(s): #{missing.join(', ')}"
+        end
+      end
+  end
+end

data/lib/ridley/context.rb

@@ -0,0 +1,25 @@
+module Ridley
+  # @api private
+  # @author Jamie Winsor <jamie@vialstudios.com>
+  class Context
+    attr_reader :resource
+    attr_reader :connection
+
+    # @param [Constant] resource
+    #   the constant of the class to send class functions to
+    # @param [Ridley::Connection] connection
+    #   the connection to use when sending class functions to resources
+    def initialize(resource, connection)
+      @resource = resource
+      @connection = connection
+    end
+
+    def new(*args)
+      resource.send(:new, connection, *args)
+    end
+
+    def method_missing(fun, *args, &block)
+      resource.send(fun, connection, *args, &block)
+    end
+  end
+end

data/lib/ridley/dsl.rb

@@ -0,0 +1,58 @@
+module Ridley
+  # @api public
+  # @author Jamie Winsor <jamie@vialstudios.com>
+  #
+  # A DSL to be included into Ridley::Connection. Instance functions of the same name as
+  # Chef a resource are coerced into class functions of a class of the same name.
+  #
+  # This is accomplished by returning a Ridley::Context object and coercing any messages sent
+  # to it into a message to the Chef resource's class in Ridley.
+  #
+  # @example
+  #   class Connection
+  #     include Ridley::DSL
+  #   end
+  #
+  #   connection = Ridley::Connection.new
+  #   connection.role.all
+  #
+  #   The 'role' function is made available to the instance of Ridley::Connection by including
+  #   Ridley::DSL. This function returns a Ridley::Context object which receives the 'all' message.
+  #   The Ridley::Context coerces the 'all' message into a message to the Ridley::Role class and
+  #   sends along the instance of Ridley::Connection that is chaining 'role.all'
+  #
+  #   connection.role.all => Ridley::Role.all(connection)
+  #
+  #   Any additional arguments will also be passed to the class function of the Chef resource's class
+  #
+  #   connection.role.find("reset") => Ridley::Role.find(connection, "reset")
+  #
+  # @example instantiating new resources
+  #   class connection
+  #     include Ridley::DSL
+  #   end
+  #
+  #   connection = Ridley::Connection.new
+  #   connection.role.new(name: "hello") => <#Ridley::Role: @name="hello">
+  #
+  #   New instances of resources can be instantiated by calling new on the Ridley::Context. These messages
+  #   will be send to the Chef resource's class in Ridley and can be treated as a normal Ruby object. Each
+  #   instantiated object will have the connection information contained within so you can do things like
+  #   save a role after changing it's attributes.
+  #
+  #   r = connection.role.new(name: "new-role")
+  #   r.name => "new-role"
+  #   r.name = "other-name"
+  #   r.save
+  #
+  #   connection.role.find("new-role") => <#Ridley::Role: @name="new-role">
+  #
+  # @see Ridley::Context
+  # @see Ridley::Role
+  # @see Ridley::Connection
+  module DSL; end
+end
+
+Dir["#{File.dirname(__FILE__)}/resources/*.rb"].sort.each do |path|
+  require "ridley/resources/#{File.basename(path, '.rb')}"
+end

data/lib/ridley/errors.rb

@@ -0,0 +1,82 @@
+module Ridley
+  # @author Jamie Winsor <jamie@vialstudios.com>
+  module Errors
+    class RidleyError < StandardError; end
+    class InternalError < RidleyError; end
+
+    class InvalidResource < RidleyError
+      attr_reader :errors
+
+      def initialize(errors)
+        @errors = errors
+      end
+
+      def message
+        errors.full_messages.join(', ')
+      end
+      alias_method :to_s, :message
+    end
+
+    class HTTPError < RidleyError
+      class << self
+        def fabricate(env)
+          klass = lookup_error(env[:status].to_i)
+          klass.new(env)
+        end
+
+        def register_error(status)
+          error_map[status.to_i] = self
+        end
+
+        def lookup_error(status)
+          error_map.fetch(status.to_i)
+        rescue KeyError
+          HTTPUnknownStatus
+        end
+
+        def error_map
+          @@error_map ||= Hash.new
+        end        
+      end
+
+      attr_reader :env
+      attr_reader :errors
+
+      attr_reader :message
+      alias_method :to_s, :message
+
+      def initialize(env)
+        @env = env
+        @errors = Array(env[:body][:error]) || []
+
+        if errors.empty?
+          @message = env[:body] || "no content body"
+        else
+          @message = "errors: "
+          @message << errors.collect { |e| "'#{e}'" }.join(', ')
+        end
+      end
+    end
+
+    class HTTPUnknownStatus < HTTPError
+      def initialize(env)
+        super(env)
+        @message = "status: #{env[:status]} is an unknown HTTP status code or not an error."
+      end
+    end
+
+    class HTTPBadRequest < HTTPError; register_error(400); end
+    class HTTPUnauthorized < HTTPError; register_error(401); end
+    class HTTPForbidden < HTTPError; register_error(403); end
+    class HTTPNotFound < HTTPError; register_error(404); end
+    class HTTPMethodNotAllowed < HTTPError; register_error(405); end
+    class HTTPRequestTimeout < HTTPError; register_error(408); end
+    class HTTPConflict < HTTPError; register_error(409); end
+    
+    class HTTPInternalServerError < HTTPError; register_error(500); end
+    class HTTPNotImplemented < HTTPError; register_error(501); end
+    class HTTPBadGateway < HTTPError; register_error(502); end
+    class HTTPServiceUnavailable < HTTPError; register_error(503); end
+    class HTTPGatewayTimeout < HTTPError; register_error(504); end
+  end
+end

data/lib/ridley/log.rb

@@ -0,0 +1,10 @@
+require 'mixlib/log'
+
+module Ridley
+  # @author Jamie Winsor <jamie@vialstudios.com>
+  class Log
+    extend Mixlib::Log
+
+    init
+  end
+end

data/lib/ridley/middleware.rb

@@ -0,0 +1,19 @@
+module Ridley
+  # @author Jamie Winsor <jamie@vialstudios.com>
+  module Middleware
+    CONTENT_TYPE = 'content-type'.freeze
+
+    require 'ridley/middleware/parse_json'
+    require 'ridley/middleware/chef_response'
+    require 'ridley/middleware/chef_auth'
+
+    Faraday.register_middleware :request,
+      chef_auth: -> { ChefAuth }
+
+    Faraday.register_middleware :response,
+      json: -> { ParseJson }
+
+    Faraday.register_middleware :response,
+      chef_response: -> { ChefResponse }
+  end
+end

data/lib/ridley/middleware/chef_auth.rb

@@ -0,0 +1,45 @@
+require 'mixlib/authentication/signedheaderauth'
+
+module Ridley
+  module Middleware
+    # @author Jamie Winsor <jamie@vialstudios.com>
+    class ChefAuth < Faraday::Middleware
+      attr_reader :client_name
+      attr_reader :client_key
+
+      def initialize(app, client_name, client_key)
+        super(app)
+        @client_name = client_name
+        @client_key = OpenSSL::PKey::RSA.new(File.read(client_key))
+      end
+
+      def call(env)
+        sign_obj = Mixlib::Authentication::SignedHeaderAuth.signing_object(
+          http_method: env[:method],
+          host: env[:url].host,
+          path: env[:url].path,
+          body: env[:body] || '',
+          timestamp: Time.now.utc.iso8601,
+          user_id: client_name
+        )
+        authentication_headers = sign_obj.sign(client_key)
+        env[:request_headers] = env[:request_headers].merge(authentication_headers).merge(default_headers)
+        env[:request_headers] = env[:request_headers].merge('Content-Length' => env[:body].bytesize.to_s) if env[:body]
+
+        Ridley.log.debug(env)
+
+        @app.call(env)
+      end
+
+      private
+
+        def default_headers
+          {
+            'Accept' => 'application/json',
+            'Content-Type' => 'application/json',
+            'X-Chef-Version' => Ridley::CHEF_VERSION
+          }
+        end
+    end
+  end
+end