berkshelf-api 0.1.0

data/lib/berkshelf/api/rspec/server.rb

@@ -0,0 +1,29 @@
+module Berkshelf::API::RSpec
+  module Server
+    class << self
+      include Berkshelf::API::Mixin::Services
+
+      def clear_cache
+        cache_manager.clear
+      end
+
+      def instance
+        Berkshelf::API::Application.instance
+      end
+
+      def running?
+        Berkshelf::API::Application.running?
+      end
+
+      def start(options = {})
+        options = options.reverse_merge(port: 26210, log_location: "/dev/null", endpoints: [])
+        Berkshelf::API::Application.config.endpoints = options[:endpoints]
+        Berkshelf::API::Application.run!(options) unless running?
+      end
+
+      def stop
+        Berkshelf::API::Application.shutdown
+      end
+    end
+  end
+end

data/lib/berkshelf/api/site_connector.rb

@@ -0,0 +1,7 @@
+module Berkshelf
+  module API
+    module SiteConnector
+      require_relative 'site_connector/opscode'
+    end
+  end
+end

data/lib/berkshelf/api/site_connector/opscode.rb

@@ -0,0 +1,162 @@
+require 'open-uri'
+require 'retryable'
+require 'archive'
+require 'tempfile'
+
+module Berkshelf::API
+  module SiteConnector
+    class Opscode
+      class << self
+        # @param [String] version
+        #
+        # @return [String]
+        def uri_escape_version(version)
+          version.to_s.gsub('.', '_')
+        end
+
+        # @param [String] uri
+        #
+        # @return [String]
+        def version_from_uri(uri)
+          File.basename(uri.to_s).gsub('_', '.')
+        end
+      end
+
+      include Celluloid
+      include Berkshelf::API::Logging
+
+      V1_API = 'http://cookbooks.opscode.com/api/v1'.freeze
+
+      # @return [String]
+      attr_reader :api_uri
+      # @return [Integer]
+      #   how many retries to attempt on HTTP requests
+      attr_reader :retries
+      # @return [Float]
+      #   time to wait between retries
+      attr_reader :retry_interval
+
+      # @param [Faraday::Connection] connection
+      #   Optional parameter for setting the connection object
+      #   This should only be set manually for testing
+      def initialize(uri = V1_API, options = {})
+        options  = { retries: 5, retry_interval: 0.5 }.merge(options)
+        @api_uri = uri
+
+        @connection = Faraday.new(uri) do |c|
+          c.response :parse_json
+          c.use Faraday::Adapter::NetHttp
+        end
+      end
+
+      # @return [Array<String>]
+      #   A list of cookbook names available on the server
+      def cookbooks
+        start     = 0
+        count     = connection.get("cookbooks").body["total"]
+        cookbooks = Array.new
+
+        while count > 0
+          cookbooks += connection.get("cookbooks?start=#{start}&items=#{count}").body["items"]
+          start += 100
+          count -= 100
+        end
+
+        cookbooks.map { |cb| cb["cookbook_name"] }
+      end
+
+      # @param [String] cookbook
+      #   the name of the cookbook to find version for
+      #
+      # @return [Array<String>]
+      #   A list of versions of this cookbook available on the server
+      def versions(cookbook)
+        response = connection.get("cookbooks/#{cookbook}")
+
+        case response.status
+        when (200..299)
+          response.body['versions'].collect do |version_uri|
+            self.class.version_from_uri(version_uri)
+          end
+        else
+          Array.new
+        end
+      end
+
+      # @param [String] cookbook
+      #   The name of the cookbook to download
+      # @param [String] version
+      #   The version of the cookbook to download
+      # @param [String] destination
+      #   The directory to download the cookbook to
+      #
+      # @return [String, nil]
+      def download(name, version, destination = Dir.mktmpdir)
+        log.info "downloading #{name}(#{version})"
+        if uri = download_uri(name, version)
+          archive = stream(uri)
+          Archive.extract(archive.path, destination)
+        end
+      ensure
+        archive.unlink unless archive.nil?
+      end
+
+      # Return the location where a cookbook of the given name and version can be downloaded from
+      #
+      # @param [String] cookbook
+      #   The name of the cookbook
+      # @param [String] version
+      #   The version of the cookbook
+      #
+      # @return [String, nil]
+      def download_uri(name, version)
+        unless cookbook = find(name, version)
+          return nil
+        end
+        cookbook[:file]
+      end
+
+      # @param [String] cookbook
+      #   The name of the cookbook to retrieve
+      # @param [String] version
+      #   The version of the cookbook to retrieve
+      #
+      # @return [Hashie::Mash, nil]
+      def find(name, version)
+        response = connection.get("cookbooks/#{name}/versions/#{self.class.uri_escape_version(version)}")
+
+        case response.status
+        when (200..299)
+          response.body
+        else
+          nil
+        end
+      end
+
+      # Stream the response body of a remote URL to a file on the local file system
+      #
+      # @param [String] target
+      #   a URL to stream the response body from
+      #
+      # @return [Tempfile]
+      def stream(target)
+        local = Tempfile.new('opscode-site-stream')
+        local.binmode
+
+        retryable(tries: retries, on: OpenURI::HTTPError, sleep: retry_interval) do
+          open(target, 'rb', connection.headers) do |remote|
+            local.write(remote.read)
+          end
+        end
+
+        local
+      ensure
+        local.close(false) unless local.nil?
+      end
+
+      private
+
+        attr_reader :connection
+    end
+  end
+end

data/lib/berkshelf/api/srv_ctl.rb

@@ -0,0 +1,63 @@
+require 'optparse'
+require 'buff/extensions'
+
+module Berkshelf
+  module API
+    class SrvCtl
+      class << self
+        # @param [Array] args
+        #
+        # @return [Hash]
+        def parse_options(args, filename)
+          options = Hash.new
+
+          OptionParser.new("Usage: #{filename} [options]") do |opts|
+            opts.on("-p", "--port PORT", Integer, "set the listening port") do |v|
+              options[:port] = v
+            end
+
+            opts.on("-v", "--verbose", "run with verbose output") do
+              options[:log_level] = "INFO"
+            end
+
+            opts.on("-d", "--debug", "run with debug output") do
+              options[:log_level] = "DEBUG"
+            end
+
+            opts.on("-q", "--quiet", "silence output") do
+              options[:log_location] = '/dev/null'
+            end
+
+            opts.on_tail("-h", "--help", "show this message") do
+              puts opts
+              exit
+            end
+          end.parse!(args)
+
+          options.symbolize_keys
+        end
+
+        # @param [Array] args
+        # @param [String] filename
+        def run(args, filename)
+          options = parse_options(args, filename)
+          new(options).start
+        end
+      end
+
+      attr_reader :options
+
+      # @param [Hash] options
+      #   @see {Berkshelf::API::Application.run} for the list of valid options
+      def initialize(options = {})
+        @options               = options
+        @options[:eager_build] = true
+      end
+
+      def start
+        require 'berkshelf/api'
+        Berkshelf::API::Application.run(options)
+      end
+    end
+  end
+end

data/lib/berkshelf/api/version.rb

@@ -0,0 +1,5 @@
+module Berkshelf
+  module API
+    VERSION = "0.1.0"
+  end
+end

data/spec/fixtures/reset.pem

@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEpQIBAAKCAQEAyyUMqrTh1IzKOyE0fvXEWC7m0AdMI8/dr9JJMUKtK9vhhP0w
+rm6m95GoybFM2IRryukFsAxpcir3M1ungTU3Smq4MshhMJ7H9FbvZVfQoknTbCsR
+w6scg2fBepxT2+fcGRufr8nAh92M3uUkN9bMMTAkt18D4br6035YvdmvHDJERxYq
+ByA/720AdI9VNSIvw+x8oqsIkXLEdF6dgT9MpG5iWZT66pbFsnNZpRrd4/bFNWBY
++13aOqdmjiTL08/EdgQFKMT5qimpos1TuQhA7mwInOjQgzVu9uCDkMiYejaLbUz0
+lGyS8y4uxu6z2hA900Jg/z+JJuXymH5QAX3GZQIDAQABAoIBAQCtFXkwbYPI1Nht
+/wG6du5+8B9K+hy+mppY9wPTy+q+Zs9Ev3Fd/fuXDm1QxBckl9c8AMUO1dR2KPOM
+t7gFl/DvH/SnmCFvCqp1nijFIUgrLlnMXPn6zG0z7RBlxpKQ2IGohufNIEpBuNwR
+Ag2U4hgChPGTp4ooJ2cVEh7MS5AupYPDbC62dWEdW68aRTWhh2BCGAWBb6s16yl9
+aZ7+OcxW2eeRJVbRfLkLQEDutJZi5TfOEn5QPc86ZgxcCmnvwulnpnhpz6QCkgQt
+OP/+KRqDhWSDVCFREVT30fUIj1EWvK7NFWASZQxueZStuIvMEKeFebYfrbHxRFzJ
+UmaxJnWVAoGBAPbKLpeky6ClccBaHHrCgjzakoDfGgyNKDQ9g753lJxB8nn7d9X4
+HQpkWpfqAGFRZp1hI2H+VxyUXLh2Ob5OUeTm0OZJll35vycOaQEtfgIScXTcvzn0
+16J9eX2YY4wIHEEMh85nKk8BEGgiNP5nuEviHocCeYXoi/Zq3+qj6v63AoGBANK5
+4nyi6LBQFs1CUc7Sh7vjtOE3ia7KeRmOr7gS6QhS3iK3Oa8FzBLJ6ETjN2a9Bw8N
+cF7I/+cr4s7DUJjxdb53D/J6TVSYORNNCUVnpF/uB2LqqdXDYmpO0PvFkXFoYTnJ
+kaLAN8uCoLKr6JH9tq3DfXIfDIHiZ+BOIvI070fDAoGBAMDyzEDFmGruTyRLj66u
++rJnVVmqlKwxhLhrS+CTj74nlVOnt0a0KMhiM65IRqnPwcHUG5zXBPaUTHXwAS93
+/nFPwQ37hLPOupPnoVNJZRZrowbyPBQtCJbDMURv64ylHqoBCQDoCd0hANnZvMMX
+BrFVhfaaibaXXS542r6SD/27AoGAECadHE5kJTdOOBcwK/jo3Fa8g1J9Y/8yvum3
+wBT69V9clS6T5j08geglvDnqAh7UzquKBEnFi1NKw+wmXkKLcrivaTdEfApavYb3
+AfHKoGue907jC3Y5Mcquq81ds2J7qTEwz1eKLzfo1yjj32ShvrmwALIuhDn1GjUC
+6qtx938CgYEApEqvu0nocR1jmVVlLe5uKQBj949dh6NGq0R5Lztz6xufaTYzMC3d
+AZG9XPPjRqSLs+ylSXJpwHEwoeyLFDaJcO+GgW1/ut4MC2HppOx6aImwDdXMHUWR
+KYGIFF4AU/IYoBcanAm4s078EH/Oz01B2c7tR2TqabisPgLYe7PXSCw=
+-----END RSA PRIVATE KEY-----

data/spec/spec_helper.rb

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'bundler'
+require 'rspec'
+require 'spork'
+require 'rack/test'
+
+Spork.prefork do
+  Dir[File.join(File.expand_path("../../spec/support/**/*.rb", __FILE__))].each { |f| require f }
+
+  RSpec.configure do |config|
+    config.include Berkshelf::RSpec::ChefServer
+
+    config.expect_with :rspec do |c|
+      c.syntax = :expect
+    end
+
+    config.mock_with :rspec
+    config.treat_symbols_as_metadata_keys_with_true_values = true
+    config.filter_run focus: true
+    config.run_all_when_everything_filtered = true
+
+    config.before(:suite) { Berkshelf::RSpec::ChefServer.start }
+    config.before(:all) { Berkshelf::API::Logging.init(location: '/dev/null') }
+
+    config.before do
+      Celluloid.shutdown
+      Celluloid.boot
+      Berkshelf::API::CacheManager.cache_file = tmp_path.join('cerch').to_s
+      clean_tmp_path
+    end
+  end
+
+  def app_root_path
+    Pathname.new(File.expand_path('../../', __FILE__))
+  end
+
+  def tmp_path
+    app_root_path.join('spec/tmp')
+  end
+
+  def fixtures_path
+    app_root_path.join('spec/fixtures')
+  end
+
+  def clean_tmp_path
+    FileUtils.rm_rf(tmp_path)
+    FileUtils.mkdir_p(tmp_path)
+  end
+end
+
+Spork.each_run do
+  require 'berkshelf/api'
+end

data/spec/support/actor_mocking.rb

@@ -0,0 +1,7 @@
+RSpec.configuration.before(:each) do
+  class Celluloid::ActorProxy
+    [ :should_receive, :should_not_receive, :stub, :stub_chain, :should, :should_not ].each do |method|
+      undef_method(method) if method_defined?(method)
+    end
+  end
+end

data/spec/support/chef_server.rb

@@ -0,0 +1,73 @@
+require 'chef_zero/server'
+
+module Berkshelf::RSpec
+  module ChefServer
+    class << self
+      def clear_request_log
+        @request_log = Array.new
+      end
+
+      def request_log
+        @request_log ||= Array.new
+      end
+
+      def server
+        @server ||= ChefZero::Server.new(port: PORT, generate_real_keys: false)
+      end
+
+      def server_url
+        (@server && @server.url) || "http://localhost/#{PORT}"
+      end
+
+      def start
+        server.start_background
+        server.on_response do |request, response|
+          request_log << [ request, response ]
+        end
+        clear_request_log
+
+        server
+      end
+
+      def stop
+        @server.stop if @server
+      end
+
+      def running?
+        @server && @server.running?
+      end
+    end
+
+    PORT = 8889
+
+    def chef_client(name, hash = Hash.new)
+      load_data(:clients, name, hash)
+    end
+
+    def chef_cookbook(name, version, cookbook = Hash.new)
+      ChefServer.server.load_data("cookbooks" => { "#{name}-#{version}" => cookbook })
+    end
+
+    def chef_data_bag(name, hash = Hash.new)
+      ChefServer.server.load_data({ 'data' => { name => hash }})
+    end
+
+    def chef_environment(name, hash = Hash.new)
+      load_data(:environments, name, hash)
+    end
+
+    def chef_node(name, hash = Hash.new)
+      load_data(:nodes, name, hash)
+    end
+
+    def chef_role(name, hash = Hash.new)
+      load_data(:roles, name, hash)
+    end
+
+    private
+
+      def load_data(key, name, hash)
+        ChefServer.server.load_data(key.to_s => { name => JSON.fast_generate(hash) })
+      end
+  end
+end

data/spec/unit/berkshelf/api/application_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Berkshelf::API::Application do
+  describe "ClassMethods" do
+    subject { described_class }
+
+    its(:registry) { should be_a(Celluloid::Registry) }
+
+    describe "::run!" do
+      include Berkshelf::API::Mixin::Services
+
+      let(:options) { { log_location: '/dev/null' } }
+      subject(:run) { described_class.run!(options) }
+
+      context "when given true for :disable_http" do
+        it "does not start the REST Gateway" do
+          options[:disable_http] = true
+          run
+          expect { rest_gateway }.to raise_error(Berkshelf::API::NotStartedError)
+        end
+      end
+    end
+  end
+end