berkshelf-api 0.1.0

data/lib/berkshelf/api/config.rb

@@ -0,0 +1,23 @@
+require 'buff/config/json'
+
+module Berkshelf::API
+  class Config < Buff::Config::JSON
+    class << self
+      # @return [String]
+      def default_path
+        File.expand_path("~/.berkshelf/api-server/config.json")
+      end
+    end
+
+    attribute 'endpoints',
+      type: Array,
+      default: [
+        {
+          type: "opscode",
+          options: {
+            url: 'http://cookbooks.opscode.com/api/v1'
+          }
+        }
+      ]
+  end
+end

data/lib/berkshelf/api/cucumber.rb

@@ -0,0 +1,11 @@
+require_relative 'rspec'
+
+World(Berkshelf::API::RSpec)
+
+Given(/^the Berkshelf API server cache is up to date$/) do
+  cache_builder.build
+end
+
+Given(/^the Berkshelf API server's cache is empty$/) do
+  cache_manager.clear
+end

data/lib/berkshelf/api/dependency_cache.rb

@@ -0,0 +1,123 @@
+module Berkshelf::API
+  # @note
+  #   DependencyCache stores its data internally as a Mash
+  #   The structure is as follows
+  #
+  #   {
+  #     "cookbook_name" => {
+  #       "x.y.z" => {
+  #         :dependencies => { "cookbook_name" => "constraint" },
+  #         :platforms => { "platform" => "constraint" }
+  #       }
+  #     }
+  #   }
+  class DependencyCache
+    class << self
+      # Read an archived cache and re-instantiate it
+      #
+      # @param [#to_s] filepath
+      #   path to an archived cache
+      #
+      # @raise [Berkshelf::API::SaveNotFoundError]
+      # @raise [Berkshelf::API::InvalidSaveError]
+      #
+      # @return [DependencyCache]
+      def from_file(filepath)
+        contents = JSON.parse(File.read(filepath.to_s))
+        new(contents)
+      rescue Errno::ENOENT => ex
+        raise SaveNotFoundError.new(ex)
+      rescue JSON::ParserError => ex
+        raise InvalidSaveError.new(ex)
+      end
+    end
+
+    extend Forwardable
+    def_delegators :@cache, :[], :[]=
+
+    # @param [Hash] contents
+    def initialize(contents = {})
+      @cache = Hash[contents]
+    end
+
+    # @param [RemoteCookbook] cookbook
+    # @param [Ridley::Chef::Cookbook::Metadata] metadata
+    #
+    # @return [Hash]
+    def add(cookbook, metadata)
+      platforms    = metadata.platforms || Hash.new
+      dependencies = metadata.dependencies || Hash.new
+      @cache[cookbook.name.to_s] ||= Hash.new
+      @cache[cookbook.name.to_s][cookbook.version.to_s] = {
+        platforms: platforms,
+        dependencies: dependencies,
+        location_type: cookbook.location_type,
+        location_path: cookbook.location_path
+      }
+    end
+
+    # Clear any items added to this instance
+    #
+    # @return [Hash]
+    def clear
+      @cache.clear
+    end
+
+    # Check if the cache knows about the given cookbook version
+    #
+    # @param [#to_s] name
+    # @param [#to_s] version
+    #
+    # @return [Boolean]
+    def has_cookbook?(name, version)
+      unless cookbook = @cache[name.to_s]
+        return false
+      end
+
+      cookbook.has_key?(version.to_s)
+    end
+
+    # @param [String] name
+    # @param [String] version
+    #
+    # @return [Hash]
+    def remove(name, version)
+      @cache[name.to_s].delete(version.to_s)
+      if @cache[name.to_s].empty?
+        @cache.delete(name.to_s)
+      end
+      @cache
+    end
+
+    # @return [Boolean]
+    def empty?
+      @cache.empty?
+    end
+
+    # @return [Hash]
+    def to_hash
+      @cache.to_hash
+    end
+
+    # @return [String]
+    def to_json(options = {})
+      JSON.generate(to_hash, options)
+    end
+
+    # @return [Array<RemoteCookbook>]
+    def cookbooks
+      [].tap do |remote_cookbooks|
+        @cache.each_pair do |name, versions|
+          versions.each do |version, metadata|
+            remote_cookbooks << RemoteCookbook.new(name, version, metadata[:location_type], metadata[:location_path])
+          end
+        end
+      end
+    end
+
+    def save(path)
+      FileUtils.mkdir_p(File.dirname(path))
+      File.open(path, 'w+') { |f| f.write(self.to_json) }
+    end
+  end
+end

data/lib/berkshelf/api/endpoint.rb

@@ -0,0 +1,17 @@
+require 'grape'
+
+module Berkshelf::API
+  module Endpoint
+    class Base < Grape::API
+      # Force inbound requests to be JSON
+      def call(env)
+        env['CONTENT_TYPE'] = 'application/json'
+        super
+      end
+    end
+  end
+end
+
+Dir["#{File.dirname(__FILE__)}/endpoint/*.rb"].sort.each do |path|
+  require "berkshelf/api/endpoint/#{File.basename(path, '.rb')}"
+end

data/lib/berkshelf/api/endpoint/v1.rb

@@ -0,0 +1,19 @@
+module Berkshelf::API
+  module Endpoint
+    class V1 < Endpoint::Base
+      helpers Berkshelf::API::Mixin::Services
+      version 'v1', using: :header, vendor: 'berkshelf'
+      format :json
+
+      rescue_from Grape::Exceptions::Validation do |e|
+        body = JSON.generate({status: e.status, message: e.message, param: e.param})
+        rack_response(body, e.status, "Content-type" => "application/json")
+      end
+
+      desc "list all known cookbooks"
+      get 'universe' do
+        cache_manager.cache
+      end
+    end
+  end
+end

data/lib/berkshelf/api/errors.rb

@@ -0,0 +1,8 @@
+module Berkshelf::API
+  class APIError < StandardError; end
+  # Thrown when an actor was expected to be running but wasn't
+  class NotStartedError < APIError; end
+  class SaveNotFoundError < APIError; end
+  class InvalidSaveError < APIError; end
+  class MetadataLoadError < APIError; end
+end

data/lib/berkshelf/api/generic_server.rb

@@ -0,0 +1,50 @@
+module Berkshelf::API
+  module GenericServer
+    class << self
+      def included(base)
+        base.send(:include, Celluloid)
+        base.send(:extend, ClassMethods)
+      end
+    end
+
+    module ClassMethods
+      # Returns the currently running instance of the including Class
+      #
+      # @return [Celluloid::Actor]
+      def instance
+        unless Application[server_name] && Application[server_name].alive?
+          raise NotStartedError, "#{server_name} not running"
+        end
+        Application[server_name]
+      end
+
+      # Set the name that the actor will be registered as with the applicaiton
+      #
+      # @param [#to_sym, nil]
+      #
+      # @return [Symbol]
+      def server_name(name = nil)
+        return @server_name if name.nil?
+        @server_name = name.to_sym
+      end
+
+      # Start the cache manager and add it to the application's registry.
+      #
+      # @note you probably do not want to manually start the cache manager unless you
+      #   are testing the application. Start the entire application with {Berkshelf::API::Application.run}
+      def start(*args)
+        Application[server_name] = new(*args)
+      end
+
+      # Stop the cache manager if it's running.
+      #
+      # @note you probably don't want to manually stop the cache manager unless you are testing
+      #   the application. Stop the entire application with {Berkshelf::API::Application.shutdown}
+      def stop
+        unless actor = Application[server_name]
+          actor.terminate
+        end
+      end
+    end
+  end
+end

data/lib/berkshelf/api/logging.rb

@@ -0,0 +1,37 @@
+module Berkshelf::API
+  module Logging
+    class << self
+      # @return [Logger]
+      attr_accessor :logger
+
+      # @option options [String, Fixnum] :location (STDOUT)
+      # @option options [String, nil] :level ("INFO")
+      #   - "DEBUG
+      #   - "INFO"
+      #   - "WARN"
+      #   - "ERROR"
+      #   - "FATAL"
+      # @option options [Logger::Formatter] :formatter
+      #
+      # @return [Logger]
+      def init(options = {})
+        level     = options[:level] || "INFO"
+        location  = options[:location] || STDOUT
+        formatter = options[:formatter] || nil
+
+        Celluloid.logger = @logger = Logger.new(location).tap do |log|
+          log.level     = Logger::Severity.const_get(level.upcase)
+          log.formatter = formatter if formatter
+        end
+      end
+    end
+
+    init
+
+    # @return [Logger]
+    def logger
+      Logging.logger
+    end
+    alias_method :log, :logger
+  end
+end

data/lib/berkshelf/api/mixin.rb

@@ -0,0 +1,7 @@
+module Berkshelf::API
+  module Mixin; end
+end
+
+Dir["#{File.dirname(__FILE__)}/mixin/*.rb"].sort.each do |path|
+  require_relative "mixin/#{File.basename(path, '.rb')}"
+end

data/lib/berkshelf/api/mixin/services.rb

@@ -0,0 +1,48 @@
+module Berkshelf::API
+  module Mixin
+    module Services
+      class << self
+        def included(base)
+          base.extend(ClassMethods)
+          base.send(:include, ClassMethods)
+        end
+
+        def extended(base)
+          base.send(:include, ClassMethods)
+        end
+      end
+
+      module ClassMethods
+        # @raise [Berkshelf::API::NotStartedError] if the cache manager has not been started
+        #
+        # @return [Berkshelf::API::CacheBuilder]
+        def cache_builder
+          app_actor(:cache_builder)
+        end
+
+        # @raise [Berkshelf::API::NotStartedError] if the cache manager has not been started
+        #
+        # @return [Berkshelf::API::CacheManager]
+        def cache_manager
+          app_actor(:cache_manager)
+        end
+
+        # @raise [Berkshelf::API::NotStartedError] if the rest gateway has not been started
+        #
+        # @return [Berkshelf::API::RESTGateway]
+        def rest_gateway
+          app_actor(:rest_gateway)
+        end
+
+        private
+
+          def app_actor(id)
+            unless Application[id] && Application[id].alive?
+              raise NotStartedError, "#{id} not running"
+            end
+            Application[id]
+          end
+      end
+    end
+  end
+end

data/lib/berkshelf/api/rack_app.rb

@@ -0,0 +1,5 @@
+module Berkshelf::API
+  class RackApp < Endpoint::Base
+    mount Berkshelf::API::Endpoint::V1
+  end
+end

data/lib/berkshelf/api/remote_cookbook.rb

@@ -0,0 +1,3 @@
+module Berkshelf::API
+  class RemoteCookbook < Struct.new(:name, :version, :location_type, :location_path); end
+end

data/lib/berkshelf/api/rest_gateway.rb

@@ -0,0 +1,62 @@
+require 'reel'
+
+module Berkshelf::API
+  class RESTGateway < Reel::Server
+    extend Forwardable
+    include Berkshelf::API::GenericServer
+    include Berkshelf::API::Logging
+
+    DEFAULT_OPTIONS = {
+      host: '0.0.0.0',
+      port: 26200,
+      quiet: false,
+      workers: 10
+    }.freeze
+
+    # @return [String]
+    attr_reader :host
+    # @return [Integer]
+    attr_reader :port
+    # @return [Integer]
+    attr_reader :workers
+
+    def_delegator :handler, :rack_app
+
+    server_name :rest_gateway
+    finalizer :finalize_callback
+
+    # @option options [String] :host ('0.0.0.0')
+    # @option options [Integer] :port (26100)
+    # @option options [Boolean] :quiet (false)
+    # @option options [Integer] :workers (10)
+    def initialize(options = {})
+      options       = DEFAULT_OPTIONS.merge(options)
+      options[:app] = Berkshelf::API::RackApp.new
+
+      @host    = options[:host]
+      @port    = options[:port]
+      @workers = options[:workers]
+      @handler = ::Rack::Handler::Reel.new(options)
+      @pool    = ::Reel::RackWorker.pool(size: @workers, args: [ @handler ])
+
+      log.info "REST Gateway listening on #{@host}:#{@port}"
+      super(@host, @port, &method(:on_connect))
+    end
+
+    # @param [Reel::Connection] connection
+    def on_connect(connection)
+      pool.handle(connection.detach)
+    end
+
+    private
+
+      # @return [Reel::RackWorker]
+      attr_reader :pool
+      # @return [Rack::Handler::Reel]
+      attr_reader :handler
+
+      def finalize_callback
+        pool.terminate if pool && pool.alive?
+      end
+  end
+end

data/lib/berkshelf/api/rspec.rb

@@ -0,0 +1,20 @@
+require 'berkshelf/api'
+
+module Berkshelf::API
+  module RSpec
+    require_relative 'rspec/server'
+
+    include Mixin::Services
+
+    def berks_dependency(name, version, options = {})
+      options[:platforms] ||= Hash.new
+      options[:dependencies] ||= Hash.new
+      cookbook = RemoteCookbook.new(name, version,
+        CacheBuilder::Worker::Opscode.worker_type, SiteConnector::Opscode::V1_API)
+      metadata = Ridley::Chef::Cookbook::Metadata.new
+      options[:platforms].each { |name, version| metadata.supports(name, version) }
+      options[:dependencies].each { |name, constraint| metadata.depends(name, constraint) }
+      cache_manager.add(cookbook, metadata)
+    end
+  end
+end