berkshelf-api-2.2.0/0000755000004100000410000000000012751111271014255 5ustar www-datawww-databerkshelf-api-2.2.0/bin/0000755000004100000410000000000012751111271015025 5ustar www-datawww-databerkshelf-api-2.2.0/bin/berks-api0000755000004100000410000000023712751111271016632 0ustar www-datawww-data#!/usr/bin/env ruby $:.push File.expand_path("../../lib", __FILE__) require 'berkshelf/api/srv_ctl' Berkshelf::API::SrvCtl.run(ARGV, File.basename(__FILE__)) berkshelf-api-2.2.0/berkshelf-api.gemspec0000644000004100000410000001515312751111271020343 0ustar www-datawww-data######################################################### # This file has been automatically generated by gem2tgz # ######################################################### # -*- encoding: utf-8 -*- Gem::Specification.new do |s| s.name = "berkshelf-api" s.version = "2.2.0" s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version= s.authors = ["Jamie Winsor", "Andrew Garson"] s.date = "2016-08-03" s.description = "Berkshelf dependency API server" s.email = ["jamie@vialstudios.com", "agarson@riotgames"] s.executables = ["berks-api"] s.files = ["CHANGELOG.md", "LICENSE", "README.md", "bin/berks-api", "lib/berkshelf-api.rb", "lib/berkshelf/api.rb", "lib/berkshelf/api/application.rb", "lib/berkshelf/api/cache_builder.rb", "lib/berkshelf/api/cache_builder/worker.rb", "lib/berkshelf/api/cache_builder/worker/chef_server.rb", "lib/berkshelf/api/cache_builder/worker/file_store.rb", "lib/berkshelf/api/cache_builder/worker/github.rb", "lib/berkshelf/api/cache_builder/worker/supermarket.rb", "lib/berkshelf/api/cache_manager.rb", "lib/berkshelf/api/config.rb", "lib/berkshelf/api/core_ext.rb", "lib/berkshelf/api/core_ext/pathname.rb", "lib/berkshelf/api/cucumber.rb", "lib/berkshelf/api/dependency_cache.rb", "lib/berkshelf/api/endpoint.rb", "lib/berkshelf/api/endpoint/v1.rb", "lib/berkshelf/api/errors.rb", "lib/berkshelf/api/generic_server.rb", "lib/berkshelf/api/logging.rb", "lib/berkshelf/api/mixin.rb", "lib/berkshelf/api/mixin/services.rb", "lib/berkshelf/api/rack_app.rb", "lib/berkshelf/api/remote_cookbook.rb", "lib/berkshelf/api/rest_gateway.rb", "lib/berkshelf/api/rspec.rb", "lib/berkshelf/api/rspec/server.rb", "lib/berkshelf/api/site_connector.rb", "lib/berkshelf/api/site_connector/supermarket.rb", "lib/berkshelf/api/srv_ctl.rb", "lib/berkshelf/api/version.rb", "spec/fixtures/cookbooks/example_cookbook/metadata.rb", "spec/spec_helper.rb", "spec/support/actor_mocking.rb", "spec/support/chef_server.rb", "spec/support/human_reaable.rb", "spec/unit/berkshelf/api/application_spec.rb", "spec/unit/berkshelf/api/cache_builder/worker/chef_server_spec.rb", "spec/unit/berkshelf/api/cache_builder/worker/file_store_spec.rb", "spec/unit/berkshelf/api/cache_builder/worker/github_spec.rb", "spec/unit/berkshelf/api/cache_builder/worker/supermarket_spec.rb", "spec/unit/berkshelf/api/cache_builder/worker_spec.rb", "spec/unit/berkshelf/api/cache_builder_spec.rb", "spec/unit/berkshelf/api/cache_manager_spec.rb", "spec/unit/berkshelf/api/config_spec.rb", "spec/unit/berkshelf/api/dependency_cache_spec.rb", "spec/unit/berkshelf/api/endpoint/v1_spec.rb", "spec/unit/berkshelf/api/logging_spec.rb", "spec/unit/berkshelf/api/mixin/services_spec.rb", "spec/unit/berkshelf/api/rack_app_spec.rb", "spec/unit/berkshelf/api/rest_gateway_spec.rb", "spec/unit/berkshelf/api/site_connector/supermarket_spec.rb", "spec/unit/berkshelf/api/srv_ctl_spec.rb"] s.homepage = "https://github.com/berkshelf/berkshelf-api" s.licenses = ["Apache 2.0"] s.require_paths = ["lib"] s.required_ruby_version = Gem::Requirement.new(">= 2.1.0") s.rubygems_version = "1.8.23" s.summary = "A server which indexes cookbooks from various sources and hosts it over a REST API" s.test_files = ["spec/fixtures/cookbooks/example_cookbook/metadata.rb", "spec/spec_helper.rb", "spec/support/actor_mocking.rb", "spec/support/chef_server.rb", "spec/support/human_reaable.rb", "spec/unit/berkshelf/api/application_spec.rb", "spec/unit/berkshelf/api/cache_builder/worker/chef_server_spec.rb", "spec/unit/berkshelf/api/cache_builder/worker/file_store_spec.rb", "spec/unit/berkshelf/api/cache_builder/worker/github_spec.rb", "spec/unit/berkshelf/api/cache_builder/worker/supermarket_spec.rb", "spec/unit/berkshelf/api/cache_builder/worker_spec.rb", "spec/unit/berkshelf/api/cache_builder_spec.rb", "spec/unit/berkshelf/api/cache_manager_spec.rb", "spec/unit/berkshelf/api/config_spec.rb", "spec/unit/berkshelf/api/dependency_cache_spec.rb", "spec/unit/berkshelf/api/endpoint/v1_spec.rb", "spec/unit/berkshelf/api/logging_spec.rb", "spec/unit/berkshelf/api/mixin/services_spec.rb", "spec/unit/berkshelf/api/rack_app_spec.rb", "spec/unit/berkshelf/api/rest_gateway_spec.rb", "spec/unit/berkshelf/api/site_connector/supermarket_spec.rb", "spec/unit/berkshelf/api/srv_ctl_spec.rb"] if s.respond_to? :specification_version then s.specification_version = 4 if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then s.add_runtime_dependency(%q, ["~> 4.0"]) s.add_runtime_dependency(%q, ["= 0.0.6"]) s.add_runtime_dependency(%q, ["~> 1.0"]) s.add_runtime_dependency(%q, ["~> 0.16"]) s.add_runtime_dependency(%q, ["~> 0.16"]) s.add_runtime_dependency(%q, ["~> 0.14"]) s.add_runtime_dependency(%q, ["~> 0.1"]) s.add_runtime_dependency(%q, ["< 4.0.0", ">= 2.0.4"]) s.add_runtime_dependency(%q, ["< 5.0.0", ">= 3.0.0"]) s.add_runtime_dependency(%q, ["~> 1.0"]) s.add_runtime_dependency(%q, ["~> 0.6.0"]) s.add_runtime_dependency(%q, ["~> 4.4"]) s.add_runtime_dependency(%q, ["~> 1.0"]) s.add_runtime_dependency(%q, ["~> 0.4"]) else s.add_dependency(%q, ["~> 4.0"]) s.add_dependency(%q, ["= 0.0.6"]) s.add_dependency(%q, ["~> 1.0"]) s.add_dependency(%q, ["~> 0.16"]) s.add_dependency(%q, ["~> 0.16"]) s.add_dependency(%q, ["~> 0.14"]) s.add_dependency(%q, ["~> 0.1"]) s.add_dependency(%q, ["< 4.0.0", ">= 2.0.4"]) s.add_dependency(%q, ["< 5.0.0", ">= 3.0.0"]) s.add_dependency(%q, ["~> 1.0"]) s.add_dependency(%q, ["~> 0.6.0"]) s.add_dependency(%q, ["~> 4.4"]) s.add_dependency(%q, ["~> 1.0"]) s.add_dependency(%q, ["~> 0.4"]) end else s.add_dependency(%q, ["~> 4.0"]) s.add_dependency(%q, ["= 0.0.6"]) s.add_dependency(%q, ["~> 1.0"]) s.add_dependency(%q, ["~> 0.16"]) s.add_dependency(%q, ["~> 0.16"]) s.add_dependency(%q, ["~> 0.14"]) s.add_dependency(%q, ["~> 0.1"]) s.add_dependency(%q, ["< 4.0.0", ">= 2.0.4"]) s.add_dependency(%q, ["< 5.0.0", ">= 3.0.0"]) s.add_dependency(%q, ["~> 1.0"]) s.add_dependency(%q, ["~> 0.6.0"]) s.add_dependency(%q, ["~> 4.4"]) s.add_dependency(%q, ["~> 1.0"]) s.add_dependency(%q, ["~> 0.4"]) end end berkshelf-api-2.2.0/spec/0000755000004100000410000000000012751111271015207 5ustar www-datawww-databerkshelf-api-2.2.0/spec/spec_helper.rb0000644000004100000410000000223712751111271020031 0ustar www-datawww-data$:.push File.expand_path("../../lib", __FILE__) 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.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 ENV['BERKSHELF_API_PATH'] = tmp_path.join('api-server').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 berkshelf-api-2.2.0/spec/fixtures/0000755000004100000410000000000012751111271017060 5ustar www-datawww-databerkshelf-api-2.2.0/spec/fixtures/cookbooks/0000755000004100000410000000000012751111271021051 5ustar www-datawww-databerkshelf-api-2.2.0/spec/fixtures/cookbooks/example_cookbook/0000755000004100000410000000000012751111271024372 5ustar www-datawww-databerkshelf-api-2.2.0/spec/fixtures/cookbooks/example_cookbook/metadata.rb0000644000004100000410000000037012751111271026477 0ustar www-datawww-dataname "example_cookbook" maintainer "Josiah Kiehl" maintainer_email "jkiehl@riotgames.com" license "DO WHAT YOU WANT CAUSE A PIRATE IS FREE" description "Installs/Configures example_cookbook" version "0.5.0" berkshelf-api-2.2.0/spec/unit/0000755000004100000410000000000012751111271016166 5ustar www-datawww-databerkshelf-api-2.2.0/spec/unit/berkshelf/0000755000004100000410000000000012751111271020133 5ustar www-datawww-databerkshelf-api-2.2.0/spec/unit/berkshelf/api/0000755000004100000410000000000012751111271020704 5ustar www-datawww-databerkshelf-api-2.2.0/spec/unit/berkshelf/api/mixin/0000755000004100000410000000000012751111271022030 5ustar www-datawww-databerkshelf-api-2.2.0/spec/unit/berkshelf/api/mixin/services_spec.rb0000644000004100000410000000351112751111271025212 0ustar www-datawww-datarequire 'spec_helper' require 'berkshelf/api/rest_gateway' describe Berkshelf::API::Mixin::Services do let(:includer) do Class.new { include Berkshelf::API::Mixin::Services }.new end describe "#cache_builder" do subject { includer.cache_builder } context "when the CacheBuilder is running" do before { Berkshelf::API::CacheBuilder.start } it "returns the running instance of CacheBuilder" do expect(subject).to be_a(Berkshelf::API::CacheBuilder) end end context "when the CacheBuilder is not running" do before { Berkshelf::API::CacheBuilder.stop } it "raises a NotStartedError" do expect { subject }.to raise_error(Berkshelf::API::NotStartedError) end end end describe "#cache_manager" do subject { includer.cache_manager } context "when the CacheManager is running" do before { Berkshelf::API::CacheManager.start } it "returns the running instance of CacheManager" do expect(subject).to be_a(Berkshelf::API::CacheManager) end end context "when the CacheManager is not running" do before { Berkshelf::API::CacheManager.stop } it "raises a NotStartedError" do expect { subject }.to raise_error(Berkshelf::API::NotStartedError) end end end describe "#rest_gateway" do subject { includer.rest_gateway } context "when the RESTGateway is running" do before { Berkshelf::API::RESTGateway.start } it "returns the running instance of RESTGateway" do expect(subject).to be_a(Berkshelf::API::RESTGateway) end end context "when the RESTGateway is not running" do before { Berkshelf::API::RESTGateway.stop } it "raises a NotStartedError" do expect { subject }.to raise_error(Berkshelf::API::NotStartedError) end end end end berkshelf-api-2.2.0/spec/unit/berkshelf/api/logging_spec.rb0000644000004100000410000000113712751111271023673 0ustar www-datawww-datarequire 'spec_helper' describe Berkshelf::API::Logging do describe "ClassMethods" do subject { described_class } describe "::init" do after { described_class.init(location: nil) } it "sets the Celluloid.logger to ::logger" do subject.init expect(Celluloid.logger).to eql(subject.logger) end end describe "::logger" do it "returns a Logger object" do expect(subject.logger).to be_a(Logger) end end end describe "#logger" do it "returns a Logger object" do expect(subject.logger).to be_a(Logger) end end end berkshelf-api-2.2.0/spec/unit/berkshelf/api/config_spec.rb0000644000004100000410000000120312751111271023504 0ustar www-datawww-datarequire 'spec_helper' describe Berkshelf::API::Config do describe "ClassMethods" do describe "::default_path" do it "returns a String" do expect(described_class.default_path).to be_a(String) end end end describe "default config" do subject { described_class.new } it "has a endpoint configured" do expect(subject.endpoints.size).to eq(1) end it "has the Supermarket community site as an endpoint" do expect(subject.endpoints.first.type).to eql("supermarket") end it "has the default build_interval" do expect(subject.build_interval).to eq(5.0) end end end berkshelf-api-2.2.0/spec/unit/berkshelf/api/site_connector/0000755000004100000410000000000012751111271023722 5ustar www-datawww-databerkshelf-api-2.2.0/spec/unit/berkshelf/api/site_connector/supermarket_spec.rb0000644000004100000410000000450412751111271027626 0ustar www-datawww-datarequire 'spec_helper' describe Berkshelf::API::SiteConnector::Supermarket do let(:url) { 'https://example.com' } let(:json) do <<-EOH.gsub(/^ {6}/, '') { "berkshelf": { "0.1.0": { "location_type": "supermarket", "location_path": "#{url}", "download_url": "#{url}/cookbooks/berkshelf/versions/0.1.0/download", "dependencies": { "ruby": ">= 0.0.0" } }, "0.2.0": { "location_type": "supermarket", "location_path": "#{url}", "download_url": "#{url}/cookbooks/berkshelf/versions/0.2.0/download", "dependencies": { "ruby": ">= 0.0.0" } } } } EOH end subject { described_class.new(url: url) } before do allow(subject).to receive(:open) .and_return(double(File, read: json)) end describe "#universe" do it "uses OpenURI to get the universe" do expect(subject).to receive(:open) .with("#{url}/universe.json", kind_of(Hash)) subject.universe end it 'parses the response as JSON' do expect(subject.universe).to be_a(Hash) expect(subject.universe).to have_key('berkshelf') end context 'when the server does not respond' do before do allow(subject).to receive(:open) .and_raise(Timeout::Error) end it 'catches and logs the error' do expect(subject.log).to receive(:error).with(/in 15 seconds/) expect { subject.universe }.to_not raise_error end end context 'when the response is not valid JSON' do let(:json) { 'bad json' } it 'catches a JSON::ParserError' do expect(subject.log).to receive(:error).with(/^Failed to parse JSON/) expect { subject.universe }.to_not raise_error end end [ SocketError, Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::ENETUNREACH, ].each do |error| context "when `#{error}' is raised" do before do allow(subject).to receive(:open) .and_raise(error) end it "catches and logs the error" do expect(subject.log).to receive(:error).with(/^Failed to get/) expect { subject.universe }.to_not raise_error end end end end end berkshelf-api-2.2.0/spec/unit/berkshelf/api/rack_app_spec.rb0000644000004100000410000000030112751111271024015 0ustar www-datawww-datarequire 'spec_helper' describe Berkshelf::API::RackApp do describe '.endpoints' do it 'has at least one item' do expect(described_class.endpoints.size).to be > 0 end end end berkshelf-api-2.2.0/spec/unit/berkshelf/api/cache_builder/0000755000004100000410000000000012751111271023455 5ustar www-datawww-databerkshelf-api-2.2.0/spec/unit/berkshelf/api/cache_builder/worker/0000755000004100000410000000000012751111271024766 5ustar www-datawww-databerkshelf-api-2.2.0/spec/unit/berkshelf/api/cache_builder/worker/supermarket_spec.rb0000644000004100000410000000703412751111271030673 0ustar www-datawww-datarequire 'spec_helper' module Berkshelf module API describe CacheBuilder::Worker::Supermarket do describe '.worker_type' do it 'is supermarket' do expect(described_class.worker_type).to eq('supermarket') end end let(:location_path) { SiteConnector::Supermarket::V1_API } let(:location_type) { described_class.worker_type } let(:priority) { 1 } let(:universe) do { 'chicken' => { '1.0' => { 'location_type' => 'supermarket', 'location_path' => location_path, 'download_url' => "#{location_path}/cookbooks/chicken/versions/1.0/download", }, '2.0' => { 'location_type' => 'supermarket', 'location_path' => location_path, 'download_url' => "#{location_path}/cookbooks/chicken/versions/2.0/download", } }, 'tuna' => { '3.0.0' => { 'location_type' => 'supermarket', 'location_path' => location_path, 'download_url' => "#{location_path}/cookbooks/tuna/versions/3.0.0/download", }, '3.0.1' => { 'location_type' => 'supermarket', 'location_path' => location_path, 'download_url' => "#{location_path}/cookbooks/tuna/versions/3.0.1/download", } } } end let(:connection) do double(SiteConnector::Supermarket, universe: universe, api_url: location_path, ) end before do allow(subject.wrapped_object).to receive(:connection) .and_return(connection) end subject do CacheManager.start described_class.new(priority: priority) end it_behaves_like "a human-readable string" describe "#cookbooks" do it "returns an array of RemoteCookbooks described by the server" do expected = [ RemoteCookbook.new('chicken', '1.0', location_type, location_path, priority), RemoteCookbook.new('chicken', '2.0', location_type, location_path, priority), RemoteCookbook.new('tuna', '3.0.0', location_type, location_path, priority), RemoteCookbook.new('tuna', '3.0.1', location_type, location_path, priority), ] result = subject.cookbooks expect(result).to be_a(Array) expect(result[0].name).to eq('chicken') expect(result[0].version).to eq('1.0') expect(result[0].location_type).to eq(location_type) expect(result[0].location_path).to eq(location_path) expect(result[0].priority).to eq(priority) expect(result[1].name).to eq('chicken') expect(result[1].version).to eq('2.0') expect(result[1].location_type).to eq(location_type) expect(result[1].location_path).to eq(location_path) expect(result[1].priority).to eq(priority) expect(result[2].name).to eq('tuna') expect(result[2].version).to eq('3.0.0') expect(result[2].location_type).to eq(location_type) expect(result[2].location_path).to eq(location_path) expect(result[2].priority).to eq(priority) expect(result[3].name).to eq('tuna') expect(result[3].version).to eq('3.0.1') expect(result[3].location_type).to eq(location_type) expect(result[3].location_path).to eq(location_path) expect(result[3].priority).to eq(priority) end end end end end berkshelf-api-2.2.0/spec/unit/berkshelf/api/cache_builder/worker/file_store_spec.rb0000644000004100000410000000164712751111271030470 0ustar www-datawww-datarequire 'spec_helper' describe Berkshelf::API::CacheBuilder::Worker::FileStore do describe '.worker_type' do it 'is file_store' do expect(described_class.worker_type).to eq('file_store') end end subject do described_class.new(path: fixtures_path.join("cookbooks")) end it_behaves_like "a human-readable string" describe "#cookbooks" do it "returns an array containing an item for each valid cookbook on the server" do expect(subject.cookbooks.size).to eq(1) end it "returns an array of RemoteCookbooks" do subject.cookbooks.each do |cookbook| expect(cookbook).to be_a(Berkshelf::API::RemoteCookbook) end end it "each RemoteCookbook is tagged with a location_type matching the worker_type of the builder" do subject.cookbooks.each do |cookbook| expect(cookbook.location_type).to eql(described_class.worker_type) end end end end berkshelf-api-2.2.0/spec/unit/berkshelf/api/cache_builder/worker/chef_server_spec.rb0000644000004100000410000000222312751111271030617 0ustar www-datawww-datarequire 'spec_helper' describe Berkshelf::API::CacheBuilder::Worker::ChefServer do describe '.worker_type' do it 'is chef_server' do expect(described_class.worker_type).to eq('chef_server') end end subject do described_class.new(url: "http://localhost:8889", client_name: "reset", client_key: fixtures_path.join("reset.pem")) end it_behaves_like "a human-readable string" describe "#cookbooks" do before do chef_cookbook("ruby", "1.0.0") chef_cookbook("ruby", "2.0.0") chef_cookbook("elixir", "3.0.0") chef_cookbook("elixir", "3.0.1") end it "returns an array containing an item for each cookbook on the server" do expect(subject.cookbooks.size).to eq(4) end it "returns an array of RemoteCookbooks" do subject.cookbooks.each do |cookbook| expect(cookbook).to be_a(Berkshelf::API::RemoteCookbook) end end it "each RemoteCookbook is tagged with a location_type matching the worker_type of the builder" do subject.cookbooks.each do |cookbook| expect(cookbook.location_type).to eql(described_class.worker_type) end end end end berkshelf-api-2.2.0/spec/unit/berkshelf/api/cache_builder/worker/github_spec.rb0000644000004100000410000000403212751111271027606 0ustar www-datawww-datarequire 'spec_helper' describe Berkshelf::API::CacheBuilder::Worker::Github do describe '.worker_type' do it 'is github' do expect(described_class.worker_type).to eq('github') end end let(:connection) do double('connection') end let(:good_tag) do double('good_tag', name: 'v1.0.0') end let(:bad_tag) do double('good_tag', name: 'beta2') end let :contents do double('contents', content: 'dmVyc2lvbiAiMS4wLjAi') end let(:repo) do double('repo', name: 'apt', full_name: 'opscode-cookbooks/apt', html_url: 'https://github.com/opscode-cookbooks/apt', ) end let(:repo_mismached) do double('repo', name: 'enterprise', full_name: 'opscode-cookbooks/enterprise-chef-common', html_url: 'https://github.com/opscode-cookbooks/enterprise-chef-common', ) end let(:repos) do [repo, repo_mismached] end subject do expect(Octokit::Client).to receive(:new).and_return(connection) described_class.new(organization: "opscode-cookbooks", access_token: "asdf") end it_behaves_like "a human-readable string" describe "#cookbooks" do before do expect(connection).to receive(:organization_repositories) { repos } repos.each do |repo| expect(connection).to receive(:tags) { [good_tag, bad_tag] } expect(connection).to receive(:contents).with("opscode-cookbooks/" + repo.name, { path: "metadata.rb", ref: "v1.0.0"}) { contents } end end it "returns an array containing an item for each valid cookbook on the server" do expect(subject.cookbooks.size).to eq(2) end it "returns an array of RemoteCookbooks" do subject.cookbooks.each do |cookbook| expect(cookbook).to be_a(Berkshelf::API::RemoteCookbook) end end it "each RemoteCookbook is tagged with a location_type matching the worker_type of the builder" do subject.cookbooks.each do |cookbook| expect(cookbook.location_type).to eql(described_class.worker_type) end end end end berkshelf-api-2.2.0/spec/unit/berkshelf/api/cache_builder/worker_spec.rb0000644000004100000410000000210512751111271026323 0ustar www-datawww-datarequire 'spec_helper' describe Berkshelf::API::CacheBuilder::Worker do describe "ClassMethods" do describe "::[]" do it "returns the class of the registered worker" do expect(described_class["supermarket"]).to eql(Berkshelf::API::CacheBuilder::Worker::Supermarket) end end describe "::register" do it "adds the item to the Hash of types" do worker = double('new-worker') described_class.register("rspec-2", worker) expect(described_class.types["rspec-2"]).to eql(worker) end end describe "::types" do subject { described_class.types } it "returns a Hash" do expect(subject).to be_a(Hash) end end end end describe Berkshelf::API::CacheBuilder::Worker::Base do describe "ClassMethods" do describe "::worker_type" do let(:klass) { Class.new(described_class) } it "registers the worker type and class to Worker.types" do klass.worker_type("rspec") expect(Berkshelf::API::CacheBuilder::Worker.types).to include("rspec") end end end end berkshelf-api-2.2.0/spec/unit/berkshelf/api/endpoint/0000755000004100000410000000000012751111271022524 5ustar www-datawww-databerkshelf-api-2.2.0/spec/unit/berkshelf/api/endpoint/v1_spec.rb0000644000004100000410000000572112751111271024416 0ustar www-datawww-datarequire 'spec_helper' describe Berkshelf::API::Endpoint::V1 do include Rack::Test::Methods include Berkshelf::API::Mixin::Services let(:app) { described_class.new } let(:cache_warm) { false } let(:rack_env) { Hash.new } before do Berkshelf::API::CacheManager.start cache_manager.set_warmed if cache_warm end subject { last_response } describe "GET /universe" do before { get '/universe', {}, rack_env } let(:app_cache) { cache_manager.cache } context "the cache has been warmed" do let(:cache_warm) { true } context "the default format is json" do subject { last_response } let(:app_cache) { cache_manager.cache } it 'has the right status' do expect(subject.status).to eq(200) end it 'has the right body' do expect(subject.body).to eq(app_cache.to_json) end end context "the user requests json" do subject { last_response } let(:app_cache) { cache_manager.cache } let(:rack_env) { { 'HTTP_ACCEPT' => 'application/json' } } it 'has the right status' do expect(subject.status).to eq(200) end it 'has the right body' do expect(subject.body).to eq(app_cache.to_json) end end context "the user requests msgpack" do subject { last_response } let(:app_cache) { cache_manager.cache } let(:rack_env) { { 'HTTP_ACCEPT' => 'application/x-msgpack' } } it 'has the right status' do expect(subject.status).to eq(200) end it 'has the right body' do expect(subject.body).to eq(app_cache.to_msgpack) end end end context "the cache is still warming" do it 'has the right status' do expect(subject.status).to eq(503) end it 'has the right headers' do expect(subject.headers).to have_key('Retry-After') end end end describe "GET /status" do before do allow(Berkshelf::API::Application).to receive(:start_time) { Time.at(0) } allow(Time).to receive(:now) { Time.at(100) } get '/status' end context "the cache has been warmed" do let(:cache_warm) { true } it 'has the right status' do expect(subject.status).to eq(200) end it 'has the right body' do status = { status: 'ok', version: Berkshelf::API::VERSION, cache_status: 'ok', uptime: 100.0, }.to_json expect(subject.body).to eq(status) end end context "the cache is still warming" do let(:cache_warm) { false } it 'has the right status' do expect(subject.status).to eq(200) end it 'has the right body' do status = { status: 'ok', version: Berkshelf::API::VERSION, cache_status: 'warming', uptime: 100.0, }.to_json expect(subject.body).to eq(status) end end end end berkshelf-api-2.2.0/spec/unit/berkshelf/api/cache_builder_spec.rb0000644000004100000410000000511012751111271025011 0ustar www-datawww-datarequire 'spec_helper' describe Berkshelf::API::CacheBuilder do before { Berkshelf::API::CacheManager.start } let(:instance) { described_class.new } describe "#build" do subject(:build) { instance.build } let(:workers) { [ double('worker') ] } let(:future) { double('future', value: nil) } let(:cache_manager) { double('cache_manager') } before do # https://github.com/celluloid/celluloid/wiki/Testing allow(instance.wrapped_object).to receive(:workers).and_return(workers) allow(instance.wrapped_object).to receive(:cache_manager).and_return(cache_manager) allow(cache_manager).to receive(:process_workers) end it "asks the cache_manager to process all of its actors" do expect(cache_manager).to receive(:process_workers).with(workers) instance.build end end describe "#workers" do subject(:workers) { instance.workers } it "returns an array of workers" do expect(workers).to be_a(Array) workers.each do |worker| expect(worker).to be_a(described_class::Worker::Base) end end context "when no workers are explicitly configured" do it "has one worker started by default" do expect(workers.size).to eq(1) end it "has an Supermarket worker started by default" do expect(workers.first).to be_a(described_class::Worker::Supermarket) end end context "when there are multiple workers" do let(:endpoint_array) { [ first_worker, second_worker ] } let(:first_worker) { double(options: endpoint_options.dup.merge(priority: 0), type: 'chicken') } let(:second_worker) { double(options: endpoint_options.dup.merge(priority: 1), type: 'tuna') } let(:endpoint_options) do { "url" => "www.fake.com", "client_name" => "fake", "client_key" => "/path/to/fake.key" } end let(:dummy_endpoint_klass) do Class.new do attr_reader :options include Celluloid def initialize(options = {}) @options = options end end end before do allow(Berkshelf::API::Application.config).to receive(:endpoints).and_return(endpoint_array) allow(Berkshelf::API::CacheBuilder::Worker).to receive(:[]).and_return(dummy_endpoint_klass, dummy_endpoint_klass) end it "has two workers" do expect(workers.size).to eq(2) end it "keeps the ordering" do expect(workers.first.options[:priority]).to be(0) expect(workers.last.options[:priority]).to be(1) end end end end berkshelf-api-2.2.0/spec/unit/berkshelf/api/dependency_cache_spec.rb0000644000004100000410000000620412751111271025506 0ustar www-datawww-datarequire 'spec_helper' def remote_cookbook(name, version, location_type = 'supermarket', location_path = 'https://supermarket.getchef.com', priority = 1, info = {}) Berkshelf::API::RemoteCookbook.new(name, version, location_type, location_path, priority, info) end describe Berkshelf::API::DependencyCache do describe "ClassMethods" do describe "::from_file" do let(:filepath) { @tempfile.path } before { @tempfile = Tempfile.new('berkshelf-api-rspec') } after { @tempfile.close(true) } subject { described_class.from_file(filepath) } context "when the file contains valid json" do before do @tempfile.write(JSON.generate({brooke: "winsor"})) @tempfile.flush end it "returns an instance of DependencyCache" do expect(subject).to be_a(described_class) end end context "when the filepath does not exist" do let(:filepath) { nil } it "raises a SaveNotFoundError" do expect { subject }.to raise_error(Berkshelf::API::SaveNotFoundError) end end context "when the file does not contain valid JSON" do let(:filepath) { @tempfile.path } before do @tempfile.write("asdfasdfasdf") @tempfile.flush end it "raises an InvalidSaveError" do expect { subject }.to raise_error(Berkshelf::API::InvalidSaveError) end end end end let(:chicken) do { "1.0" => { dependencies: { "tuna" => "= 3.0.0" }, platforms: { "centos" => ">= 0.0.0" } } } end let(:tuna) do { "3.0.0" => { dependencies: { }, platforms: { "centos" => ">= 0.0.0" } } } end let(:contents) do { "chicken" => chicken, "tuna" => tuna, } end subject { described_class.new(contents) } context "when a new DependencyCache is created" do it "should allow indifferent access to items in the cache" do expect(subject[:chicken]).to be_a(Hash) expect(subject[:chicken][:'1.0'][:dependencies]).to be_a(Hash) end end describe "#cookbooks" do it "should return a list of RemoteCookbooks" do expected_value = [ remote_cookbook("chicken", "1.0"), remote_cookbook("tuna", "3.0.0") ] expect(subject.cookbooks).to eql(expected_value) end end describe "#add" do let(:cookbook) { remote_cookbook("ruby", "1.2.3", "supermarket") } before { subject.clear } it "adds items to the cache" do subject.add(cookbook, double(platforms: nil, dependencies: nil)) expect(subject.to_hash.size).to eq(1) end end describe "#save" do let(:path) { tmp_path.join('cerch.json') } it "saves the contents of the cache as json to the given path" do subject.save(path) expect(File.exist?(path)).to be_truthy end end describe "#clear" do let(:cookbook) { remote_cookbook("ruby", "1.2.3", "supermarket") } before { subject.add(cookbook, double(platforms: nil, dependencies: nil)) } it "empties items added to the cache" do subject.clear expect(subject).to be_empty end end end berkshelf-api-2.2.0/spec/unit/berkshelf/api/srv_ctl_spec.rb0000644000004100000410000000272112751111271023721 0ustar www-datawww-datarequire 'spec_helper' describe Berkshelf::API::SrvCtl do describe "ClassMethods" do describe "::parse_options" do let(:args) { Array.new } let(:filename) { "berks-api" } subject { described_class.parse_options(args, filename) } it "returns a hash" do expect(subject).to be_a(Hash) end context "given -p" do let(:args) { ["-p", "1234"] } it "sets :pid_file to the given value" do expect(subject[:port]).to eql(1234) end end context "given -V" do let(:args) { ["-V"] } it "sets :log_level to INFO" do expect(subject[:log_level]).to eql("INFO") end end context "given -d" do let(:args) { ["-d"] } it "sets :log_level to DEBUG" do expect(subject[:log_level]).to eql("DEBUG") end end context "given -q" do let(:args) { ["-q"] } it "sets :log_location to /dev/null" do expect(subject[:log_location]).to eql("/dev/null") end end context "given -V and -d" do let(:args) { ["-V", "-d"] } it "sets :log_level to DEBUG" do expect(subject[:log_level]).to eql("DEBUG") end end context "given -c" do let(:args) { ["-c", "/path/to/config"] } it "sets :config_file to the given value" do expect(subject[:config_file]).to eql("/path/to/config") end end end end end berkshelf-api-2.2.0/spec/unit/berkshelf/api/application_spec.rb0000644000004100000410000000316512751111271024553 0ustar www-datawww-datarequire 'spec_helper' describe Berkshelf::API::Application do describe "ClassMethods" do describe '.registry' do it 'returns a Celluloid::Registry' do expect(described_class.registry).to be_a(Celluloid::Registry) end end describe "::configure" do let(:options) { Hash.new } subject(:configure) { described_class.configure(options) } before { @original = described_class.config } after { described_class.set_config(@original) } context "given a value for :config_file" do let(:filepath) { tmp_path.join('rspec-config.json') } before { options[:config_file] = filepath } it "sets the configuration from the contents of the file" do generated = Berkshelf::API::Config.new(filepath) generated.endpoints = [ { what: "this" } ] generated.save configure expect(described_class.config.endpoints.size).to eq(1) end context "if the file cannot be found or loaded" do it "raises a ConfigNotFoundError" do expect { configure }.to raise_error(Berkshelf::API::ConfigNotFoundError) end end end end 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 berkshelf-api-2.2.0/spec/unit/berkshelf/api/rest_gateway_spec.rb0000644000004100000410000000165412751111271024747 0ustar www-datawww-datarequire 'spec_helper' require 'berkshelf/api/rest_gateway' module Berkshelf module API describe RESTGateway do let(:options) { {} } subject { described_class.new(options) } describe '.new' do context 'when given a different port' do before do options[:port] = 26210 end it 'uses the correct port' do expect(subject.port).to eq(26210) end end end describe '#host' do it 'has the default value' do expect(subject.host).to eq(described_class::DEFAULT_OPTIONS[:host]) end end describe '#port' do it 'has the default value' do expect(subject.port).to eq(described_class::DEFAULT_OPTIONS[:port]) end end describe '#app' do it 'has the default value' do expect(subject.app).to be_a(RackApp) end end end end end berkshelf-api-2.2.0/spec/unit/berkshelf/api/cache_manager_spec.rb0000644000004100000410000001070212751111271025000 0ustar www-datawww-datarequire 'spec_helper' describe Berkshelf::API::CacheManager do subject { described_class.new } describe "ClassMethods" do describe ".new" do it 'has an empty cache' do expect(subject.cache).to be_empty end context "when a save file exists" do before do @tempfile = Tempfile.new('berkshelf-api-rspec') allow(described_class).to receive(:cache_file) { @tempfile.path } end after { @tempfile.close(true) } it "loads the saved cache" do expect_any_instance_of(described_class).to receive(:load_save) subject end end context "when a save file does not exist" do before do allow(described_class).to receive(:cache_file).and_return(tmp_path.join('does_not_exist').to_s) end it "skips loading of the saved cache" do expect_any_instance_of(described_class).not_to receive(:load_save) subject end end end describe "::start" do it "starts and registers a cache manager it with the application" do described_class.start expect(Berkshelf::API::Application[:cache_manager]).to be_a(described_class) expect(Berkshelf::API::Application[:cache_manager]).to be_alive end end end it_behaves_like "a human-readable string" describe "#add" do skip end describe "#load_save" do skip end describe "#remove" do skip end describe "#clear" do it "returns an empty Hash" do result = subject.clear expect(result).to be_a(Hash) expect(result).to be_empty end it "empties the cache" do subject.clear expect(subject.cache).to be_empty end end describe "#diff" do let(:cookbook_one) { Berkshelf::API::RemoteCookbook.new("ruby", "1.2.3", "supermarket", nil, 1) } let(:cookbook_two) { Berkshelf::API::RemoteCookbook.new("elixir", "2.0.0", "supermarket", nil, 1) } let(:comparison) { Array.new } before do subject.send(:add, cookbook_one, double(dependencies: nil, platforms: nil)) subject.send(:add, cookbook_two, double(dependencies: nil, platforms: nil)) @created, @deleted = @diff = subject.send(:diff, comparison, 1) end it "returns two items" do expect(@diff.size).to eq(2) end context "when there are more than one worker endpoints" do let(:new_cookbook) { Berkshelf::API::RemoteCookbook.new("ruby", "3.0.0", "supermarket", nil, 2) } let(:comparison) { [ cookbook_one, cookbook_two, new_cookbook ] } before do @created, @deleted = @diff = subject.send(:diff, comparison, 2) end it "only creates cookbooks that have the same or lower priority" do expect(@created).to eql([new_cookbook]) end context "when the cookbook has been deleted" do let(:comparison) { [cookbook_one] } before do @created, @deleted = @diff = subject.send(:diff, comparison, 1) end it "only deletes cookbooks at the same priority" do expect(@deleted).to eql([cookbook_two]) end end end context "when there are created and deleted cookbooks" do let(:new_cookbook) { Berkshelf::API::RemoteCookbook.new("ruby", "3.0.0", "supermarket", nil, 1) } let(:comparison) { [ cookbook_one, new_cookbook ] } it "should return created and deleted cookbooks" do expect(@created).to eql([new_cookbook]) expect(@deleted).to eql([cookbook_two]) end end context "when there are only created cookbooks" do let(:new_cookbook) { Berkshelf::API::RemoteCookbook.new("ruby", "3.0.0", "supermarket", nil, 1) } let(:comparison) { [ cookbook_one, cookbook_two, new_cookbook ] } it "should return only created cookbooks" do expect(@created).to eql([new_cookbook]) expect(@deleted).to be_empty end end context "when there are only deleted cookbooks" do let(:comparison) { [ cookbook_one ] } before do @created, @deleted = @diff = subject.send(:diff, comparison, 1) end it "should return only deleted cookbooks" do expect(@created).to be_empty expect(@deleted).to eql([cookbook_two]) end end context "when there are no differences" do let(:comparison) { [ cookbook_one, cookbook_two ] } it "should return empty arrays" do expect(@created).to be_empty expect(@deleted).to be_empty end end end end berkshelf-api-2.2.0/spec/support/0000755000004100000410000000000012751111271016723 5ustar www-datawww-databerkshelf-api-2.2.0/spec/support/actor_mocking.rb0000644000004100000410000000036312751111271022071 0ustar www-datawww-dataRSpec.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 berkshelf-api-2.2.0/spec/support/chef_server.rb0000644000004100000410000000324712751111271021551 0ustar www-datawww-datarequire 'chef_zero/server' module Berkshelf module 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 end berkshelf-api-2.2.0/spec/support/human_reaable.rb0000644000004100000410000000040512751111271022032 0ustar www-datawww-datashared_examples_for "a human-readable string" do it "does not start with Ruby object notation" do expect(subject.to_s).to_not start_with("#<") end it "does not contain a hex prefix" do expect(subject.to_s).to_not match(%r{0x[0-9a-f]+}) end end berkshelf-api-2.2.0/lib/0000755000004100000410000000000012751111271015023 5ustar www-datawww-databerkshelf-api-2.2.0/lib/berkshelf/0000755000004100000410000000000012751111271016770 5ustar www-datawww-databerkshelf-api-2.2.0/lib/berkshelf/api/0000755000004100000410000000000012751111271017541 5ustar www-datawww-databerkshelf-api-2.2.0/lib/berkshelf/api/core_ext.rb0000644000004100000410000000020312751111271021671 0ustar www-datawww-dataDir["#{File.dirname(__FILE__)}/core_ext/*.rb"].sort.each do |path| require_relative "core_ext/#{File.basename(path, '.rb')}" end berkshelf-api-2.2.0/lib/berkshelf/api/mixin/0000755000004100000410000000000012751111271020665 5ustar www-datawww-databerkshelf-api-2.2.0/lib/berkshelf/api/mixin/services.rb0000644000004100000410000000233312751111271023036 0ustar www-datawww-datamodule 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 berkshelf-api-2.2.0/lib/berkshelf/api/application.rb0000644000004100000410000001113412751111271022371 0ustar www-datawww-datatrap 'INT' do Berkshelf::API::Application.shutdown end trap 'TERM' do Berkshelf::API::Application.shutdown end module Berkshelf::API class ApplicationSupervisor < Celluloid::SupervisionGroup # @option options [Boolean] :disable_http (false) # run the application without the rest gateway def initialize(registry, options = {}) super(registry) supervise_as(:cache_manager, Berkshelf::API::CacheManager) supervise_as(:cache_builder, Berkshelf::API::CacheBuilder) unless options[:disable_http] require_relative 'rest_gateway' supervise_as(:rest_gateway, Berkshelf::API::RESTGateway, options) end end end module Application class << self extend Forwardable include Berkshelf::API::Logging include Berkshelf::API::Mixin::Services attr_reader :start_time def_delegators :registry, :[], :[]= # @return [Berkshelf::API::Config] def config @config ||= begin Berkshelf::API::Config.from_file(Berkshelf::API::Config.default_path) rescue Berkshelf::API::Config.new end end # @param [Berkshelf::API::Config] config def set_config(config) @config = config end # Configure the application # # @option options [String] :config_file # filepath to a configuration file to use # @option options [String, Fixnum] :log_location (STDOUT) # @option options [String, nil] :log_level ("INFO") # - "DEBUG # - "INFO" # - "WARN" # - "ERROR" # - "FATAL" # # @raise [Berkshelf::API::ConfigNotFoundError] # # @return [Berkshelf::API::Config] def configure(options = {}) unless options[:config_file].nil? set_config Berkshelf::API::Config.from_file(options[:config_file]) end configure_logger(options) config rescue Buff::Errors::ConfigNotFound => ex raise ConfigNotFoundError, ex end # @option options [String, Fixnum] :log_location (STDOUT) # @option options [String, nil] :log_level ("INFO") # - "DEBUG # - "INFO" # - "WARN" # - "ERROR" # - "FATAL" def configure_logger(options = {}) Logging.init(level: options[:log_level], location: options[:log_location]) end # @return [String] def home_path ENV['BERKSHELF_API_PATH'] || config.home_path end # Retrieve the running instance of the Application # # @raise [Berkshelf::API::NotStartedError] # # @return [Berkshelf::API::Application] def instance return @instance if @instance raise NotStartedError, "application not running" end # The Actor registry for Berkshelf::API. # # @note Berkshelf::API uses it's own registry instead of Celluloid::Registry.root to # avoid conflicts in the larger namespace. Use Berkshelf::API::Application[] to access Berkshelf::API # actors instead of Celluloid::Actor[]. # # @return [Celluloid::Registry] def registry @registry ||= Celluloid::Registry.new end # Run the application in the foreground (sleep on main thread) # # @option options [Boolean] :disable_http (false) # run the application without the rest gateway def run(options = {}) @start_time = Time.now.utc loop do supervisor = run!(options) while supervisor.alive? sleep 0.1 instance.terminate if @shutdown end break if @shutdown log.error "!!! #{self} crashed. Restarting..." end end # Run the application in the background # # @option options [Boolean] :disable_http (false) # run the application without the rest gateway # @option options [Boolean] :eager_build (false) # automatically begin and loop all cache builders # # @return [Berkshelf::API::Application] def run!(options = {}) options = { disable_http: false, eager_build: false }.merge(options) configure(options) @instance = ApplicationSupervisor.new(registry, options) cache_builder.async(:build_loop) if options[:eager_build] @instance end # @return [Boolean] def running? instance.alive? rescue NotStartedError false end # Shutdown the running instance # # @raise [Berkshelf::API::NotStartedError] # if there is no running instance def shutdown @shutdown = true end end end end berkshelf-api-2.2.0/lib/berkshelf/api/cache_manager.rb0000644000004100000410000001342012751111271022623 0ustar www-datawww-datamodule Berkshelf::API class CacheManager class << self # @return [String] def cache_file File.join(Application.home_path, "cerch") end end include Berkshelf::API::GenericServer include Berkshelf::API::Logging extend Forwardable def_delegators :@cache, :warmed?, :set_warmed, :clear SAVE_INTERVAL = 30.0 server_name :cache_manager finalizer :finalize_callback exclusive :merge, :add, :remove # @return [DependencyCache] attr_reader :cache def initialize log.info "#{self} starting..." @cache = DependencyCache.new load_save if File.exist?(self.class.cache_file) every(SAVE_INTERVAL) { save } end # @param [RemoteCookbook] cookbook # @param [Ridley::Chef::Cookbook::Metadata] metadata # # @return [Hash] def add(cookbook, metadata) log.debug "#{self} adding (#{cookbook.name}, #{cookbook.version})" cache.add(cookbook, metadata) end # Remove the cached item matching the given name and version # # @param [#to_s] name # @param [#to_s] version # # @return [DependencyCache] def remove(name, version) log.debug "#{self} removing (#{name}, #{version})" cache.remove(name, version) end # Loops through a list of workers and merges their cookbook sets into the cache # # @param [Array] workers # The workers for this cache # # @return [Boolean] def process_workers(workers) # If the cache has been warmed already, we want to spawn # workers for all the endpoints concurrently. However, if the # cache is cold we want to run sequentially, so higher priority # endpoints can work before lower priority, avoiding duplicate # downloads. # We don't want crashing workers to crash the CacheManager. # Crashes are logged so just ignore the exceptions if warmed? Array(workers).flatten.collect do |worker| self.future(:process_worker, worker) end.each do |f| f.value rescue nil end else Array(workers).flatten.each do |worker| process_worker(worker) rescue nil end end self.set_warmed end # @param [CacheBuilder::Worker::Base] worker def process_worker(worker) log.info "Processing #{worker}" remote_cookbooks = worker.cookbooks log.info "Found #{remote_cookbooks.size} cookbooks from #{worker}" created_cookbooks, deleted_cookbooks = diff(remote_cookbooks, worker.priority) log.debug "#{created_cookbooks.size} cookbooks to be added to the cache from #{worker}" log.debug "#{deleted_cookbooks.size} cookbooks to be removed from the cache from #{worker}" # Process metadata in chunks - Ridley cookbook resource uses a # task_class TaskThread, which means each future gets its own # thread. If we have many (>2000) cookbooks we can easily # exhaust the available threads on the system. created_cookbooks_with_metadata = [] until created_cookbooks.empty? work = created_cookbooks.slice!(0,500) log.info "Processing metadata for #{work.size} cookbooks with #{created_cookbooks.size} remaining on #{worker}" work.map! do |remote| [ remote, worker.future(:metadata, remote) ] end.map! do |remote, metadata| metadata.value ? [remote, metadata.value] : nil end created_cookbooks_with_metadata += work.compact end log.info "About to merge cookbooks" merge(created_cookbooks_with_metadata, deleted_cookbooks) log.info "#{self} cache updated." 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) @cache.has_cookbook?(name, version) end def load_save log.info "Loading save from #{self.class.cache_file}" @cache = DependencyCache.from_file(self.class.cache_file) log.info "Cache contains #{@cache.cookbooks.size} items" end # @return [String] def to_s "Cache manager" end private def merge(created_cookbooks, deleted_cookbooks) log.info "#{self} adding (#{created_cookbooks.length}) items..." created_cookbooks.each do |remote_with_metadata| remote, metadata = remote_with_metadata add(remote, metadata) end log.info "#{self} removing (#{deleted_cookbooks.length}) items..." deleted_cookbooks.each { |remote| remove(remote.name, remote.version) } log.info "#{self} cache updated." save end def save if warmed? log.info "Saving the cache to: #{self.class.cache_file}" cache.save(self.class.cache_file) log.info "Cache saved!" end end # @param [Array] cookbooks # An array of RemoteCookbooks representing all the cookbooks on the indexed site # @param [Integer] worker_priority # The priority/ID of the endpoint that is running # @return [Array(Array, Array)] # A tuple of Arrays of RemoteCookbooks # The first array contains items not in the cache # The second array contains items in the cache, but not in the cookbooks parameter def diff(cookbooks, worker_priority) known_cookbooks = cache.cookbooks.select { |c| c.priority <= worker_priority } created_cookbooks = cookbooks - known_cookbooks deleted_cookbooks = (known_cookbooks - cookbooks).select { |c| c.priority == worker_priority } [ created_cookbooks, deleted_cookbooks ] end def finalize_callback log.info "Cache Manager shutting down..." save end end end berkshelf-api-2.2.0/lib/berkshelf/api/cache_builder.rb0000644000004100000410000000310112751111271022632 0ustar www-datawww-datamodule Berkshelf::API class CacheBuilder require_relative 'cache_builder/worker' class WorkerSupervisor < Celluloid::SupervisionGroup; end include Berkshelf::API::GenericServer include Berkshelf::API::Logging include Berkshelf::API::Mixin::Services server_name :cache_builder finalizer :finalize_callback def initialize log.info "Cache Builder starting..." @worker_registry = Celluloid::Registry.new @worker_supervisor = WorkerSupervisor.new(@worker_registry) @building = false @build_interval = Application.config.build_interval Application.config.endpoints.each_with_index do |endpoint, index| endpoint_options = (endpoint.options || {}).to_hash.deep_symbolize_keys @worker_supervisor.supervise(CacheBuilder::Worker[endpoint.type], endpoint_options.merge(priority: index)) end end def build cache_manager.process_workers(workers) end # Issue a build command to all workers at the scheduled interval # # @param [Fixnum, Float] interval def build_loop(interval = @build_interval) return if @building loop do @building = true build sleep interval end end # Return the list of running workers # # @return [Array] def workers @worker_supervisor.actors end private def finalize_callback log.info "Cache Builder shutting down..." @worker_supervisor.terminate if @worker_supervisor && @worker_supervisor.alive? end end end berkshelf-api-2.2.0/lib/berkshelf/api/core_ext/0000755000004100000410000000000012751111271021351 5ustar www-datawww-databerkshelf-api-2.2.0/lib/berkshelf/api/core_ext/pathname.rb0000644000004100000410000000040712751111271023474 0ustar www-datawww-dataclass Pathname # Returns true or false if the path contains a "metadata.json" or a "metadata.rb" file. # # @return [Boolean] def cookbook? join("metadata.json").exist? || join("metadata.rb").exist? end alias_method :chef_cookbook?, :cookbook? end berkshelf-api-2.2.0/lib/berkshelf/api/site_connector.rb0000644000004100000410000000017512751111271023107 0ustar www-datawww-datamodule Berkshelf module API module SiteConnector require_relative 'site_connector/supermarket' end end end berkshelf-api-2.2.0/lib/berkshelf/api/errors.rb0000644000004100000410000000052212751111271021401 0ustar www-datawww-datamodule 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 class ConfigNotFoundError < APIError; end end berkshelf-api-2.2.0/lib/berkshelf/api/site_connector/0000755000004100000410000000000012751111271022557 5ustar www-datawww-databerkshelf-api-2.2.0/lib/berkshelf/api/site_connector/supermarket.rb0000644000004100000410000000363312751111271025453 0ustar www-datawww-datarequire 'open-uri' require 'archive' require 'tempfile' module OpenURI class << self # # The is a bug in Ruby's implementation of OpenURI that prevents redirects # from HTTP -> HTTPS. That should totally be a valid redirect, so we # override that method here and call it a day. # # Note: this does NOT permit HTTPS -> HTTP redirects, as that would be a # major security hole in the fabric of space-time! # def redirectable?(uri1, uri2) a, b = uri1.scheme.downcase, uri2.scheme.downcase a == b || (a == 'http' && b == 'https') end end end module Berkshelf::API module SiteConnector class Supermarket include Berkshelf::API::Logging # The default API server V1_API = 'https://supermarket.getchef.com/'.freeze # The timeout for the HTTP request TIMEOUT = 15 EMPTY_UNIVERSE = {}.freeze # @return [String] attr_reader :api_url # @option options [String] :url ({V1_API}) # url of community site def initialize(options = {}) @api_url = options[:url] || V1_API end # @return [Hash] def universe universe_url = URI.parse(File.join(api_url, 'universe.json')).to_s log.debug "Loading universe from `#{universe_url}'..." Timeout.timeout(TIMEOUT) do response = open(universe_url, 'User-Agent' => USER_AGENT) JSON.parse(response.read) end rescue JSON::ParserError => e log.error "Failed to parse JSON: #{e}" EMPTY_UNIVERSE rescue Timeout::Error log.error "Failed to get `#{universe_url}' in #{TIMEOUT} seconds!" EMPTY_UNIVERSE rescue SocketError, Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::ENETUNREACH, OpenURI::HTTPError => e log.error "Failed to get `#{universe_url}': #{e}" EMPTY_UNIVERSE end end end end berkshelf-api-2.2.0/lib/berkshelf/api/srv_ctl.rb0000644000004100000410000000405512751111271021546 0ustar www-datawww-datarequire '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("-h", "--host HOST", String, "set the listening address") do |h| options[:host] = h end 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("-c", "--config FILE", String, "path to a configuration file to use") do |v| options[:config_file] = v end opts.on("-v", "--version", "show version") do |v| require 'berkshelf/api/version' puts Berkshelf::API::VERSION exit 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 berkshelf-api-2.2.0/lib/berkshelf/api/cucumber.rb0000644000004100000410000000034212751111271021672 0ustar www-datawww-datarequire_relative 'rspec' World(Berkshelf::API::RSpec) Given(/^the Berkshelf API server's cache is up to date$/) do cache_builder.build end Given(/^the Berkshelf API server's cache is empty$/) do cache_manager.clear end berkshelf-api-2.2.0/lib/berkshelf/api/cache_builder/0000755000004100000410000000000012751111271022312 5ustar www-datawww-databerkshelf-api-2.2.0/lib/berkshelf/api/cache_builder/worker/0000755000004100000410000000000012751111271023623 5ustar www-datawww-databerkshelf-api-2.2.0/lib/berkshelf/api/cache_builder/worker/supermarket.rb0000644000004100000410000000255112751111271026515 0ustar www-datawww-datamodule Berkshelf::API class CacheBuilder module Worker class Supermarket < Worker::Base worker_type 'supermarket' # @param [Hash] options # see {API::SiteConnector::Supermarket.new} for options def initialize(options = {}) @connection = Berkshelf::API::SiteConnector::Supermarket.new(options) super end # @return [Array] # The list of cookbooks this builder can find def cookbooks connection.universe.inject([]) do |list, (name, versions)| versions.each do |version, info| list << RemoteCookbook.new(name, version, self.class.worker_type, info["location_path"], priority, info) end list end end # Return the metadata of the given RemoteCookbook. If the metadata could not be found or parsed # nil is returned. # # @param [RemoteCookbook] remote # # @return [Ridley::Chef::Cookbook::Metadata, nil] def metadata(remote) Ridley::Chef::Cookbook::Metadata.from_hash( 'name' => remote.name, 'version' => remote.version, 'dependencies' => remote.info['dependencies'] || {}, ) end private attr_accessor :connection end end end end berkshelf-api-2.2.0/lib/berkshelf/api/cache_builder/worker/chef_server.rb0000644000004100000410000000373312751111271026451 0ustar www-datawww-datamodule Berkshelf::API class CacheBuilder module Worker class ChefServer < Worker::Base worker_type "chef_server" finalizer :finalize_callback # @return [String] attr_reader :url # @option options [String] :url # the URL of the target Chef Server # @option options [String] :client_name # the name of the client for authenticating to the Chef Server # @option options [String] :client_key # a client key for authenticating to the Chef Server # @option options [Boolean] :ssl_verify # turn ssl verification off if you have an unsigned SSL certificate def initialize(options = {}) @url = options[:url] @connection = Ridley::Client.new_link(server_url: url, client_key: options[:client_key], client_name: options[:client_name], ssl: { verify: options[:ssl_verify] }) super end # @return [String] def to_s friendly_name(url) end # @return [Array] # The list of cookbooks this builder can find def cookbooks [].tap do |cookbook_versions| connection.cookbook.all.each do |cookbook, versions| versions.each do |version| cookbook_versions << RemoteCookbook.new(cookbook, version, self.class.worker_type, @connection.server_url, priority) end end end end # @param [RemoteCookbook] remote # # @return [Ridley::Chef::Cookbook::Metadata] def metadata(remote) metadata_hash = connection.cookbook.find(remote.name, remote.version).metadata Ridley::Chef::Cookbook::Metadata.from_hash(metadata_hash) end private attr_reader :connection def finalize_callback connection.terminate if connection && connection.alive? end end end end end berkshelf-api-2.2.0/lib/berkshelf/api/cache_builder/worker/github.rb0000644000004100000410000001147412751111271025441 0ustar www-datawww-datarequire 'octokit' require 'semverse' require 'net/http' module Berkshelf::API class CacheBuilder module Worker class Github < Worker::Base worker_type "github" include Logging # @return [String] attr_reader :organization # @option options [String] :organization # the organization to crawl for cookbooks # @option options [String] :access_token # authentication token for accessing the Github organization. This is necessary # since Github throttles unauthenticated API requests def initialize(options = {}) @connection = Octokit::Client.new(access_token: options[:access_token], auto_paginate: true, api_endpoint: options[:api_endpoint], web_endpoint: options[:web_endpoint], connection_options: {ssl: {verify: options[:ssl_verify].nil? ? true : options[:ssl_verify]}}) @organization = options[:organization] log.warn "You have configured a GitHub endpoint to index the #{@organization} organization." log.warn "Using unfinalized artifacts, such as cookbooks retrieved from Git, to satisfiy your" log.warn "dependencies is *STRONGLY FROWNED UPON* and potentially *DANGEROUS*." log.warn "" log.warn "Please consider setting up a release process for the cookbooks you wish to retrieve from this" log.warn "GitHub organization where the cookbook is uploaded into a Hosted Chef organization, an internal" log.warn "Chef Server, or the community site, and then replace this endpoint with a chef_server endpoint." super(options) end # @return [String] def to_s friendly_name(organization) end # @return [Array] # The list of cookbooks this builder can find def cookbooks [].tap do |cookbook_versions| connection.organization_repositories(organization).each do |repo| connection.tags(repo.full_name).each do |tag| if match = /^v(?.*)$/.match(tag.name) begin next unless cookbook_metadata = load_metadata(repo.name, tag.name) if cookbook_metadata.version.to_s == match[:version].to_s cookbook_versions << RemoteCookbook.new(cookbook_metadata.name, cookbook_metadata.version, self.class.worker_type, repo.html_url, priority, {:repo_name => repo.name} ) else log.warn "Version found in metadata for #{repo.name} (#{tag.name}) does not " + "match the tag. Got #{cookbook_metadata.version}." end rescue Semverse::InvalidVersionFormat log.debug "Ignoring tag #{tag.name} for: #{repo.name}. Does not conform to semver." rescue Octokit::NotFound log.debug "Ignoring tag #{tag.name} for: #{repo.name}. No raw metadata found." end else log.debug "Version number cannot be parsed" end end end end end # Return the metadata of the given RemoteCookbook. If the metadata could not be found or parsed # nil is returned. # # @param [RemoteCookbook] remote # # @return [Ridley::Chef::Cookbook::Metadata, nil] def metadata(remote) load_metadata(remote.info[:repo_name], "v#{remote.version}") end private attr_reader :connection # Helper function for loading metadata from a particular ref in a Github repository # # @param [String] repo # name of repository to load from # @param [String] ref # reference, tag, or branch to load from # # @return [Ridley::Chef::Cookbook::Metadata, nil] def load_metadata(repo, ref) metadata_content = read_content(repo, ref, Ridley::Chef::Cookbook::Metadata::RAW_FILE_NAME) cookbook_metadata = Ridley::Chef::Cookbook::Metadata.new cookbook_metadata.instance_eval(metadata_content) cookbook_metadata rescue => ex nil end # Read content from a file from a particular ref in a Github repository # # @param [String] repo # name of the repository to load from # @param [String] ref # reference, tag, or branch to load from # @param [String] file # file to read content from # # @return [String] def read_content(repo, ref, file) Base64.decode64(connection.contents("#{organization}/#{repo}", path: file, ref: ref).content) end end end end end berkshelf-api-2.2.0/lib/berkshelf/api/cache_builder/worker/file_store.rb0000644000004100000410000000456712751111271026317 0ustar www-datawww-datamodule Berkshelf::API class CacheBuilder module Worker class FileStore < Worker::Base worker_type "file_store" include Logging # @return [String] attr_reader :path # @option options [String] :path # the directory to search for local cookbooks def initialize(options = {}) @path = Pathname(options[:path]) log.warn "You have configured a FileStore endpoint to index the contents of #{@path}." log.warn "Using unfinalized artifacts, which this path may contain, to satisfiy your" log.warn "dependencies is *STRONGLY FROWNED UPON* and potentially *DANGEROUS*." log.warn "" log.warn "Please consider setting up a release process for the cookbooks you wish to retrieve from this" log.warn "filepath where the cookbook is uploaded into a Hosted Chef organization, an internal" log.warn "Chef Server, or the community site, and then replace this endpoint with a chef_server endpoint." super(options) end # @return [String] def to_s friendly_name(path) end # @return [Array] # The list of cookbooks this builder can find def cookbooks [].tap do |cookbook_versions| @path.each_child do |dir| next unless dir.cookbook? begin cookbook = Ridley::Chef::Cookbook.from_path(dir) cookbook_versions << RemoteCookbook.new(cookbook.cookbook_name, cookbook.version, self.class.worker_type, cookbook.path, priority) rescue => ex log.debug ex.message end end end end # @param [RemoteCookbook] remote # # @return [Ridley::Chef::Cookbook::Metadata] def metadata(remote) load_metadata(remote.location_path) end private # Helper function for loading metadata from a particular directory # # @param [String] path # path of directory to load from # # @return [Ridley::Chef::Cookbook::Metadata, nil] def load_metadata(path) cookbook = Ridley::Chef::Cookbook.from_path(path) cookbook.metadata rescue => ex nil end end end end end berkshelf-api-2.2.0/lib/berkshelf/api/cache_builder/worker.rb0000644000004100000410000000412212751111271024147 0ustar www-datawww-datamodule Berkshelf::API class CacheBuilder module Worker class Base class << self # @param [#to_s, nil] type def worker_type(type = nil) return @worker_type if @worker_type @worker_type = type.to_s Worker.register(@worker_type, self) end end include Celluloid include Berkshelf::API::Logging include Berkshelf::API::Mixin::Services attr_reader :options attr_reader :priority def initialize(options = {}) @priority = options[:priority] end # @return [String] def to_s friendly_name end # @abstract # # @param [RemoteCookbook] remote # # @return [Ridley::Chef::Cookbook::Metadata] def metadata(remote) raise RuntimeError, "must be implemented" end # @abstract # # @return [Array] # The list of cookbooks this builder can find def cookbooks raise RuntimeError, "must be implemented" end private # @param [String] data # any string to append to the worker_type # @return [String] def friendly_name(data = nil) string = self.class.worker_type.dup string << ": #{data}" if data string end end class << self # @param [#to_s] name # # @return [Worker::Base] def [](name) types[name.to_s] end # @param [#to_s] name # @param [Worker::Base] klass def register(name, klass) name = name.to_s if types.has_key?(name) raise RuntimeError, "worker already registered with the name '#{name}'" end types[name] = klass end # @return [Hash] def types @types ||= Hash.new end end end end end Dir["#{File.dirname(__FILE__)}/worker/*.rb"].sort.each do |path| require_relative "worker/#{File.basename(path, '.rb')}" end berkshelf-api-2.2.0/lib/berkshelf/api/remote_cookbook.rb0000644000004100000410000000116012751111271023245 0ustar www-datawww-datamodule Berkshelf::API class RemoteCookbook attr_accessor :name attr_accessor :version attr_accessor :location_type attr_accessor :location_path attr_accessor :priority attr_accessor :info def initialize(name, version, location_type, location_path, priority, info = {}) @name = name @version = version @location_type = location_type @location_path = location_path @priority = priority @info = info end def hash "#{name}|#{version}".hash end def eql?(other) self.hash == other.hash end end end berkshelf-api-2.2.0/lib/berkshelf/api/endpoint/0000755000004100000410000000000012751111271021361 5ustar www-datawww-databerkshelf-api-2.2.0/lib/berkshelf/api/endpoint/v1.rb0000644000004100000410000000164412751111271022241 0ustar www-datawww-datamodule Berkshelf::API module Endpoint class V1 < Endpoint::Base helpers Berkshelf::API::Mixin::Services version 'v1', using: :header, vendor: 'berkshelf' default_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 if cache_manager.warmed? cache_manager.cache else header "Retry-After", 600 status 503 end end desc "health check" get 'status' do { status: 'ok', version: Berkshelf::API::VERSION, cache_status: cache_manager.warmed? ? 'ok' : 'warming', uptime: Time.now.utc - Application.start_time, } end end end end berkshelf-api-2.2.0/lib/berkshelf/api/logging.rb0000644000004100000410000000162612751111271021521 0ustar www-datawww-datamodule 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 berkshelf-api-2.2.0/lib/berkshelf/api/endpoint.rb0000644000004100000410000000112312751111271021703 0ustar www-datawww-datarequire 'grape' require 'grape-msgpack' module Berkshelf::API module Endpoint class Base < Grape::API # Force inbound requests to be JSON def call(env) env['CONTENT_TYPE'] = 'application/json' # If coming from a browser or other naive HTTP client, we want JSON back env['HTTP_ACCEPT'] = 'application/json' if !env['HTTP_ACCEPT'] || env['HTTP_ACCEPT'].include?('text/html') super end end end end Dir["#{File.dirname(__FILE__)}/endpoint/*.rb"].sort.each do |path| require "berkshelf/api/endpoint/#{File.basename(path, '.rb')}" end berkshelf-api-2.2.0/lib/berkshelf/api/generic_server.rb0000644000004100000410000000300612751111271023067 0ustar www-datawww-datamodule 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 berkshelf-api-2.2.0/lib/berkshelf/api/version.rb0000644000004100000410000000007612751111271021556 0ustar www-datawww-datamodule Berkshelf module API VERSION = "2.2.0" end end berkshelf-api-2.2.0/lib/berkshelf/api/config.rb0000644000004100000410000000140312751111271021331 0ustar www-datawww-datarequire 'buff/config/json' require 'digest/sha1' module Berkshelf::API class Config < Buff::Config::JSON class << self # @return [String] def default_path home_path = ENV['BERKSHELF_API_PATH'] || "#{ENV['HOME']}/.berkshelf/api-server" File.expand_path(File.join(home_path, "config.json")) end end attribute 'home_path', type: String, default: File.expand_path("#{ENV['HOME']}/.berkshelf/api-server") attribute 'endpoints', type: Array, default: [ { type: "supermarket" } ] attribute 'build_interval', type: Float, default: 5.0 def endpoints_checksum Digest::SHA1.hexdigest(endpoints.collect {|x| x.to_hash }.to_s) end end end berkshelf-api-2.2.0/lib/berkshelf/api/dependency_cache.rb0000644000004100000410000000765112751111271023340 0ustar www-datawww-datamodule Berkshelf::API # @note # DependencyCache stores its data internally as a Mash # The structure is as follows # # { # "cookbook_name" => { # "x.y.z" => { # :endpoint_priority => 1, # :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 include Berkshelf::API::Logging extend Forwardable def_delegators :@cache, :[], :[]= # @param [Hash] contents def initialize(contents = {}) @warmed = false @cache = Hash[contents].with_indifferent_access if @cache['endpoints_checksum'] && (@cache['endpoints_checksum'] != Application.config.endpoints_checksum) log.warn "Endpoints in config have changed - invalidating cache" @cache.clear end @cache.delete('endpoints_checksum') 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] = { endpoint_priority: cookbook.priority, 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 # @param [Hash] options # # @return [String] def to_json(options = {}) output = to_hash output['endpoints_checksum'] = Application.config.endpoints_checksum if options[:saving] JSON.generate(output, options) end # @param [Hash] options # # @return [String] def to_msgpack(options = {}) output = to_hash output['endpoints_checksum'] = Application.config.endpoints_checksum if options[:saving] MessagePack.pack(output) end # @return [Array] 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], metadata[:endpoint_priority]) end end end end def save(path) FileUtils.mkdir_p(File.dirname(path)) File.open(path, 'w+') { |f| f.write(self.to_json(saving: true)) } end def warmed? @warmed end def set_warmed @warmed = true end end end berkshelf-api-2.2.0/lib/berkshelf/api/rest_gateway.rb0000644000004100000410000001166512751111271022575 0ustar www-datawww-datarequire 'reel' module Berkshelf::API class RESTGateway < Reel::Server::HTTP extend Forwardable include Berkshelf::API::GenericServer include Berkshelf::API::Logging DEFAULT_OPTIONS = { host: '0.0.0.0', port: 26200, quiet: false, workers: 10 }.freeze INITIAL_BODY = '' CONTENT_TYPE_ORIG = 'Content-Type'.freeze CONTENT_LENGTH_ORIG = 'Content-Length'.freeze CONTENT_TYPE = 'CONTENT_TYPE'.freeze CONTENT_LENGTH = 'CONTENT_LENGTH'.freeze SERVER_SOFTWARE = 'SERVER_SOFTWARE'.freeze SERVER_NAME = 'SERVER_NAME'.freeze SERVER_PORT = 'SERVER_PORT'.freeze SERVER_PROTOCOL = 'SERVER_PROTOCOL'.freeze GATEWAY_INTERFACE = "GATEWAY_INTERFACE".freeze LOCALHOST = 'localhost'.freeze HTTP_VERSION = 'HTTP_VERSION'.freeze CGI_1_1 = 'CGI/1.1'.freeze REMOTE_ADDR = 'REMOTE_ADDR'.freeze CONNECTION = 'HTTP_CONNECTION'.freeze SCRIPT_NAME = 'SCRIPT_NAME'.freeze PATH_INFO = 'PATH_INFO'.freeze REQUEST_METHOD = 'REQUEST_METHOD'.freeze QUERY_STRING = 'QUERY_STRING'.freeze HTTP_1_0 = 'HTTP/1.0'.freeze HTTP_1_1 = 'HTTP/1.1'.freeze HTTP_ = 'HTTP_'.freeze HOST = 'Host'.freeze RACK_INPUT = 'rack.input'.freeze RACK_LOGGER = 'rack.logger'.freeze RACK_VERSION = 'rack.version'.freeze RACK_ERRORS = 'rack.errors'.freeze RACK_MULTITHREAD = 'rack.multithread'.freeze RACK_MULTIPROCESS = 'rack.multiprocess'.freeze RACK_RUN_ONCE = 'rack.run_once'.freeze RACK_URL_SCHEME = 'rack.url_scheme'.freeze RACK_WEBSOCKET = 'rack.websocket'.freeze PROTO_RACK_ENV = { RACK_VERSION => ::Rack::VERSION, RACK_ERRORS => STDERR, RACK_MULTITHREAD => true, RACK_MULTIPROCESS => false, RACK_RUN_ONCE => false, RACK_URL_SCHEME => "http".freeze, SCRIPT_NAME => ENV[SCRIPT_NAME] || "", SERVER_PROTOCOL => HTTP_1_1, SERVER_SOFTWARE => "berkshelf-api/#{Berkshelf::API::VERSION}".freeze, GATEWAY_INTERFACE => CGI_1_1 }.freeze # @return [String] attr_reader :host # @return [Integer] attr_reader :port # @return [Integer] attr_reader :workers # @return [Berkshelf::API::RackApp] attr_reader :app server_name :rest_gateway # @option options [String] :host ('0.0.0.0') # @option options [Integer] :port (26200) # @option options [Boolean] :quiet (false) # @option options [Integer] :workers (10) def initialize(options = {}) options = DEFAULT_OPTIONS.merge(options) @host = options[:host] @port = options[:port] log.info "REST Gateway listening on #{@host}:#{@port}" super(@host, @port, &method(:on_connect)) @app = Berkshelf::API::RackApp.new end def on_connect(connection) while request = connection.request case request when request.websocket? request.respond(:bad_request, "WebSockets not supported") else route_request(connection, request) end end end def route_request(connection, request) status, headers, body_parts = app.call(request_env(request, connection)) body, is_stream = response_body(body_parts) response_klass = is_stream ? Reel::StreamResponse : Reel::Response response = response_klass.new(status, headers, body) connection.respond(response) end def request_env(request, connection) env = env(request) env[REMOTE_ADDR] = connection.remote_ip env end private def env(request) env = Hash[PROTO_RACK_ENV] env[RACK_INPUT] = StringIO.new(request.body.to_s || INITIAL_BODY) env[RACK_INPUT].set_encoding(Encoding::BINARY) if env[RACK_INPUT].respond_to?(:set_encoding) env[SERVER_NAME], env[SERVER_PORT] = (request[HOST]||'').split(':', 2) env[SERVER_PORT] ||= port.to_s env[HTTP_VERSION] = request.version || env[SERVER_PROTOCOL] env[REQUEST_METHOD] = request.method env[PATH_INFO] = request.path env[QUERY_STRING] = request.query_string || '' (_ = request.headers.delete CONTENT_TYPE_ORIG) && (env[CONTENT_TYPE] = _) (_ = request.headers.delete CONTENT_LENGTH_ORIG) && (env[CONTENT_LENGTH] = _) request.headers.each_pair do |key, val| env[HTTP_ + key.gsub('-', '_').upcase] = val end env end def response_body(body_parts) if body_parts.respond_to?(:to_path) ::File.new(body_parts.to_path) else body = '' body_parts.each do |c| return [c, true] if c.is_a?(Reel::Stream) body << c end body_parts.close if body_parts.respond_to?(:close) body end end end end berkshelf-api-2.2.0/lib/berkshelf/api/rack_app.rb0000644000004100000410000000015012751111271021642 0ustar www-datawww-datamodule Berkshelf::API class RackApp < Endpoint::Base mount Berkshelf::API::Endpoint::V1 end end berkshelf-api-2.2.0/lib/berkshelf/api/rspec/0000755000004100000410000000000012751111271020655 5ustar www-datawww-databerkshelf-api-2.2.0/lib/berkshelf/api/rspec/server.rb0000644000004100000410000000134212751111271022510 0ustar www-datawww-datamodule 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] unless running? Berkshelf::API::Application.run!(options) cache_builder.build end end def stop Berkshelf::API::Application.shutdown end end end end berkshelf-api-2.2.0/lib/berkshelf/api/rspec.rb0000644000004100000410000000127412751111271021206 0ustar www-datawww-datarequire '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::Supermarket.worker_type, SiteConnector::Supermarket::V1_API, 0) 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 berkshelf-api-2.2.0/lib/berkshelf/api/mixin.rb0000644000004100000410000000025412751111271021213 0ustar www-datawww-datamodule Berkshelf::API module Mixin; end end Dir["#{File.dirname(__FILE__)}/mixin/*.rb"].sort.each do |path| require_relative "mixin/#{File.basename(path, '.rb')}" end berkshelf-api-2.2.0/lib/berkshelf/api.rb0000644000004100000410000000154512751111271020073 0ustar www-datawww-datarequire 'berkshelf/api/version' require 'celluloid' require 'hashie' require 'ridley' require 'json' require_relative 'api/core_ext' module Berkshelf module API Encoding.default_external = Encoding::UTF_8 USER_AGENT = "Berkshelf API v#{Berkshelf::API::VERSION}".freeze require_relative 'api/errors' require_relative 'api/logging' require_relative 'api/mixin' require_relative 'api/generic_server' require_relative 'api/application' require_relative 'api/cache_builder' require_relative 'api/cache_manager' require_relative 'api/config' require_relative 'api/dependency_cache' require_relative 'api/endpoint' require_relative 'api/rack_app' require_relative 'api/remote_cookbook' require_relative 'api/site_connector' require_relative 'api/srv_ctl' end end Celluloid.logger.level = Logger::ERROR berkshelf-api-2.2.0/lib/berkshelf-api.rb0000644000004100000410000000003012751111271020055 0ustar www-datawww-datarequire 'berkshelf/api' berkshelf-api-2.2.0/LICENSE0000644000004100000410000002512712751111271015271 0ustar www-datawww-data Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright 2012-2013, Riot Games Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. berkshelf-api-2.2.0/CHANGELOG.md0000644000004100000410000000566612751111271016103 0ustar www-datawww-data# 2.1.3 * Dependency updates # 2.1.2 * Dependency updates # 2.1.1 * Bug Fixes * Calling berks_dependency/2 rspec support function no longer results in a runtime crash * Failures when calling Supermarket.universe/0 will now return a hash instead of a boolean * Cookbook name, not repo name, will be used when caching Github cookbooks * Group/User will be created in proper order during cookbook converge # 2.1.0 * Enhancements * Added --version flag for displaying version (alias -v) * Build interval for cache builder is now configurable * Bug Fixes * Supermarket location_path was not correctly set * Backwards incompatible changes * --verbose alias is now -V. Previously -v. # 2.0.0 * Enhancements * Opscode Cache builder is now the Supermarket cache builder * Bug fixes * API server will now be configured to run as API user instead of root * Fix issue where Berkshelf API user's home directory was not created * Backwards incompatible changes * The Opscode cache builder was removed - the old community site is no longer a valid endpoint to cache # 1.4.0 * Enhancements * Always return JSON to native HTTP clients * Listen host can now be passed to cli with the `-h` flag * berkshelf-api user will now be created as a system user * Update many dependent gems * Bug fixes * Fix race condition when creating the user's home directory in cookbook * Gracefully handle results from the community site which are empty * Backwards incompatible changes * Renamed cookbook from `berkshelf-api` to `berkshelf-api-server` # 1.3.1 * Enhancements * Fix cookbook issue when installing on `> Ubuntu 12.04` # 1.3.0 * Enhancements * Added warning messages to startup when using github/file_store endpoints * Bump Octokit dependency to ~> 3.0 * Bug Fix * Fixed issue with GH indexing where there were a high number of repositories in an organization # 1.2.2 * Enhancements * Bump to Reel 0.5 * Set Celluloid log level to ERROR * Bug Fixes * Include full URL to Github location in items cached by Github builder # 1.2.0 * Enhancements * Loosen constraints and bump versions of various gems * Bug Fixes * Fix issue with default configuration where home path was not being set # 1.1.1 * Enhancements * Added /status endpoint to REST API * Bug Fixes * Github cache builder will autopaginate to get all repos * Fix dependency issues with Faraday # 1.1.0 * Enhancements * Added Github cache builder and Github endpoint. You can now add Github organization's as endpoints and the cache builder will crawl each repository looking for repositories which contain SemVer tags and raw cookbook metadata. * Bug Fixes * Fix cache builder crashes when builder encounters a cookbook with invalid or missing metadata. * Invalid cookbooks won't be added to cache. # 1.0.0 * Prioritize Cache Builders so their entries do not clobber one another * An entire config file is checksumed so that when it changes, the cache is rebuilt berkshelf-api-2.2.0/README.md0000644000004100000410000001360312751111271015537 0ustar www-datawww-data# Berkshelf::API [![Gem Version](https://badge.fury.io/rb/berkshelf-api.png)](http://badge.fury.io/rb/berkshelf-api) [![Build Status](https://secure.travis-ci.org/berkshelf/berkshelf-api.png?branch=master)](http://travis-ci.org/berkshelf/berkshelf-api) A server which indexes cookbooks from various sources and hosts it over a REST API ## Installation The API server can be installed in two ways; from a Chef Cookbook (recommended) and from a Rubygem. ## Supports Chef >= 12.2 Ubuntu 12.04/16.04 RHEL/CentOS 6.x/7.x ### Cookbook install #### Basic 1. Select a [release](https://github.com/berkshelf/berkshelf-api/releases) and download its cookbooks artifact (`cookbooks.tar.gz`). 2. Upload the cookbooks to your Chef Server if you're using Chef Client or just give them to Chef Solo if that's your thing. 3. Add "recipe[berkshelf-api-server::default]" to your node's run_list and run Chef. #### Express Install and configure [Chef/Knife](https://github.com/opscode/chef) and [Berkflow](https://github.com/reset/berkflow) on your machine. Create an environment $ knife environment create berks-api-production -d Bootstrap a server into that environment $ knife ec2 server create -I ami-23f78e13 -f t1.micro -E berks-api-production -r "recipe[organization-base::default]" -G ssh-admin,http-https --ssh-user ubuntu Install the cookbooks into your environment $ blo in https://github.com/berkshelf/berkshelf-api/releases/download/v1.3.1/cookbooks.tar.gz Add the recipe to your new node's run_list $ knife node run_list add i-c8cd9ac1 "recipe[berkshelf-api-server::default]" Edit the environment to configure the API server $ knife environment edit berks-api-production And add your configuration to the `node[:berkshelf_api][:config]` attribute ```json "default_attributes": { "berkshelf_api": { "config": { "endpoints": [ { "type": "chef_server", "options": { "url": "https://api.opscode.com/organizations/vialstudios", "client_key": "/etc/berkshelf/api-server/client.pem", "client_name": "berkshelf" } } ], "build_interval": 5.0 }, "host": "your.fqdn.here" } } ``` Options: * build_interval - the number of seconds before it refreshes from the endpoints. * endpoints - an array of endpoints to cache * home_path - data directory for the berkshelf-api server > See configuration endpoints below for a complete list of supported endpoints, and the [api cookbook readme](https://github.com/berkshelf/berkshelf-api/tree/master/cookbook) for all configuration options. Update the machine you bootstrapped to the latest version of Berkshelf-API $ blo up berks-api-production berkshelf-api-server latest ### Gem install $ gem install berkshelf-api ## Running the server $ berks-api I, [2014-02-21T12:05:07.639699 #43671] INFO -- : Cache Manager starting... I, [2014-02-21T12:05:07.639883 #43671] INFO -- : Loading save from /Users/reset/.berkshelf/api-server/cerch I, [2014-02-21T12:05:07.640462 #43671] INFO -- : Cache contains 0 items I, [2014-02-21T12:05:07.641021 #43671] INFO -- : Cache Builder starting... I, [2014-02-21T12:05:07.723779 #43671] INFO -- : REST Gateway listening on 0.0.0.0:26200 ## Supported Platforms Berkshelf-API is tested on Ruby 1.9.3, 2.0.0, and JRuby 1.7+. Ruby 1.9 mode is required on all interpreters. ## Configuring Endpoints You may configure the endpoints to index by editing the JSON configuration file (default: `#{ENV['HOME']}/.berkshelf/api-server/config.json`). ### Supermarket Community Site Please note: this is unnecessary. You may point your Berksfile at "https://supermarket.getchef.com" instead. ```json { "endpoints": [ { "type": "supermarket" } ] } ``` ### Supermarket "Behind the Firewall" Please note: this is unnecessary. You may point your Berksfile at "https://your-supermarket-install.example.com" instead. ```json { "endpoints": [ { "type": "supermarket", "options": { "url": "https://your-supermarket-install.example.com/" } } ] } ``` ### Chef Server ```json { "endpoints": [ { "type": "chef_server", "options": { "url": "https://api.opscode.com/organizations/vialstudios", "client_name": "berkshelf", "client_key": "/etc/berkshelf/api-server/client.pem" } } ] } ``` ### GitHub Organization > WARNING: Using the GitHub endpoint is *STRONGLY FROWNED UPON* and potentially *DANGEROUS*. Please consider setting up a proper release process for the cookbooks you wish to index instead where they are uploaded to the community site or a Chef Server and use the chef_server endpoint instead. GitHub limits the rate of requests to their API if not authenticated. For this reason the access_token option is required. The api_endpoint, web_endpoint and ssl_verify options are only needed when you want to point to a GitHub Enterprise server within your own organization ```json { "endpoints": [ { "type": "github", "options": { "organization": "opscode-cookbooks", "access_token": "", "api_endpoint": "https://github.enterprise.local/api/v3", "web_endpoint": "https://github.enterprise.local", "ssl_verify": true } } ] } ``` ### FileStore directory A local directory containing cookbooks. ```json { "endpoints": [ { "type": "file_store", "options": { "path": "/Users/chef/code/cookbooks" } } ] } ``` ## Getting Help * If you have an issue: report it on the [issue tracker](https://github.com/berkshelf/berkshelf/issues) * If you have a question: visit the #chef or #berkshelf channel on irc.freenode.net # Authors and Contributors * Jamie Winsor () * Andrew Garson () Thank you to all of our [Contributors](https://github.com/berkshelf/berkshelf-api/graphs/contributors), testers, and users.