motherbrain 0.0.0.placeholder → 0.13.1

data/features/cli/service_command/service_command.feature

@@ -0,0 +1,21 @@
+Feature: dynamic commands for managing service state
+  As a motherbrain plugin author using the service orchestration pattern
+  I want to manage the state of my service using a dedicated command
+  So that I don't have lots of duplicated commands in my plugin
+  
+  Background:
+    Given a valid motherbrain configuration
+    
+  Scenario: listing the command
+    Given a cookbook "awesomed" at version "1.2.3" with a plugin that can bootstrap
+    When I run the "awesomed service -e Foo" command
+    Then the output should contain:
+      """
+      Usage: "mb service [COMPONENT].[SERVICE] [STATE]".
+      """
+    And the exit status should be 1
+
+  Scenario: Get a service to start
+    Given a cookbook "awesomed" at version "1.2.3" with a plugin that can bootstrap
+    When I create an environment named "test_env"
+    And I run the "awesomed service app.tomcat start -e test_env" command

data/features/cli/template_command.feature

@@ -0,0 +1,10 @@
+Feature: installing custom bootstrap templates
+  As a user of the motherbrain CLIGateway
+  I need a way to install custom bootstrap templates
+  So I can use a different template for bootstrapping
+
+Scenario: installing a template that does not exist
+  Given I have no templates installed
+  When I run `mb template my_template http://does.not.exist.com`
+  Then the exit status should be the code for error "BootstrapTemplateNotFound"
+  And I should have no templates installed

data/features/cli/validate_config.feature

@@ -0,0 +1,46 @@
+Feature: listing the plugins available to motherbrain
+  As a user of the motherbrain (MB) command line interface (CLI)
+  I need a way to list all of the available plugins and versions
+  So I can see what plugins and versions of those plugins I have installed
+
+  Scenario: validate that the configuration exists
+    Given a motherbrain configuration does not exist
+    When I run a command that requires a config
+    Then the output should contain:
+      """
+      No configuration found at:
+      """
+    And the exit status should be the code for error "ConfigNotFound"
+
+  Scenario: validate that the configuration is valid
+    Given an invalid motherbrain configuration
+    When I run a command that requires a config
+    Then the output should contain:
+      """
+      [err_code]: 3009 [message]: Invalid Configuration File
+      """
+    And the exit status should be the code for error "InvalidConfig"
+
+  Scenario: asking for help with an invalid or non existent canfiguration file
+    Given an invalid motherbrain configuration
+    When I run the "help" command
+    Then the exit status should be 0
+
+  Scenario: getting version information with an invalid configuration file
+    Given an invalid motherbrain configuration
+    When I run the "version" command
+    Then the exit status should be 0
+
+  Scenario: configuring with an invalid configuration file
+    Given an invalid motherbrain configuration
+    When I run the "configure" command interactively with:
+      | --force |
+    And I type "https://api.opscode.com/organizations/vialstudio"
+    And I type "reset"
+    And I type "/Users/reset/.chef/reset.pem"
+    And I type "riot"
+    And I type "deployer"
+    And I type "secr3tPassw0rd"
+    And I type "root"
+    And I type "secretpass"
+    And the exit status should be 0

data/features/step_definitions/bootstrap_steps.rb

@@ -0,0 +1,57 @@
+Given /^a cookbook "(.*?)" at version "(.*?)" with a plugin that can bootstrap$/ do |name, version|
+  generate_cookbook(name, version: version, with_plugin: true, with_bootstrap: true)
+  dir = File.dirname(mb_config_path)
+  @bootstrap_manifest = File.join(dir, "#{name}-#{version}-bootstrap.json")
+  File.open(@bootstrap_manifest, "w+") do |file|
+    file.write %Q|
+{
+  "nodes": [
+    {
+      "groups": ["#{name}::server"],
+      "hosts": ["#{name}01.fake.cloud.riotgames.com"]
+    }
+  ]
+}
+|
+  end
+end
+
+When /^I bootstrap "(.*?)"$/ do |name|
+  set_env "MB_TEST_INIT_ENV", "#{name}prod"
+  set_env "MB_TEST_INIT_COOKBOOK", name
+  set_env "MB_TEST_INIT_BOOTSTRAP", "true"
+  run_simple(unescape("mb #{name} bootstrap #{@bootstrap_manifest} --environment #{name}prod -d -L /tmp/aruba-mb.log"), false)
+end
+
+Given /^an extra bootstrap template$/ do
+  @template = tmp_path.join("extra_bootstrap_template.erb").to_s
+  File.open(@template, 'w+') {|f| f.write "echo 'HELLO'" }
+end
+
+Given(/^an installed bootstrap template named "(.*?)"$/) do |template|
+  File.open(MB::FileSystem.templates.join("#{template}.erb").to_s, "w+") {|f| f.write "echo 'HELLO'" }
+end
+
+When /^I bootstrap "(.*?)" with the "(.*?)" bootstrap template$/ do |name, template|
+  template = @template if template == "extra"
+  set_env "MB_TEST_INIT_ENV", "#{name}prod"
+  set_env "MB_TEST_INIT_COOKBOOK", name
+  set_env "MB_TEST_INIT_BOOTSTRAP", "true"
+  set_env "MB_TEST_INIT_TEMPLATE", template
+  run_simple(unescape("mb #{name} bootstrap #{@bootstrap_manifest} --environment #{name}prod --template #{template} -d -L /tmp/aruba-mb.log"), false)
+end
+
+When(/^I install a template named "(.*?)" from "(.*?)"$/) do |name, location|
+  if location.match(URI.regexp(['http','https']))
+    set_env "MB_TEST_INIT_TEMPLATE_URL", "#{name}###{location}"
+  else
+    location = tmp_path.join(location).to_s
+    File.open(location, 'w+') {|f| f.write "echo 'HELLO'" }
+  end
+  run_simple(unescape("mb template #{name} #{location} -d -L /tmp/aruba-mb.log"), false)
+end
+
+Then(/^the "(.*?)" template should exist$/) do |template|
+  MB::FileSystem.templates.join("#{template}.erb").exist?.should be_true
+end
+

data/features/step_definitions/chef_server_steps.rb

@@ -0,0 +1,3 @@
+Given(/^the Chef Server is empty$/) do
+  MB::RSpec::ChefServer.clear_data
+end

data/features/step_definitions/configuration_steps.rb

@@ -0,0 +1,18 @@
+Given /^a motherbrain configuration does not exist$/ do
+  FileUtils.rm_f(mb_config_path)
+end
+
+Given /^a valid motherbrain configuration$/ do
+  generate_valid_config(mb_config_path)
+end
+
+Given /^an invalid motherbrain configuration$/ do
+  generate_invalid_config(mb_config_path)
+end
+
+Then /^a motherbrain config file should exist and contain:$/ do |table|
+  config = MB::Config.from_file(mb_config_path)
+  table.raw.each do |key, value|
+    config.get_attribute(key).should eql(value)
+  end
+end

data/features/step_definitions/core_cli_steps.rb

@@ -0,0 +1,33 @@
+When /^I run MB with no arguments$/ do
+  run_simple(unescape("mb"), false)
+end
+
+When /^I run the "(.*?)" command$/ do |command|
+  run_simple(unescape("mb #{command}"), false)
+end
+
+When /^I run the "(.*?)" command with:$/ do |command, arguments|
+  run_simple(unescape("mb #{command} #{arguments.raw.join(' ')}"), false)
+end
+
+When /^I run the "(.*?)" command interactively$/ do |command|
+  run_interactive("mb #{command}")
+end
+
+When /^I run the "(.*?)" command interactively with:$/ do |command, arguments|
+  run_interactive("mb #{command} #{arguments.raw.join(' ')}")
+end
+
+When /^I run a command that requires a config$/ do
+  step %Q{I run the "plugins" command}
+end
+
+Then /^the exit status should be the code for error "(.*?)"$/ do |konstant|
+  assert_exit_status(exit_code_for(konstant))
+end
+
+Given /^we have AWS credentials$/ do
+  set_env "AWS_ACCESS_KEY", "022QF06E7MXBSAMPLE"
+  set_env "AWS_SECRET_KEY", "kWcrlUX5JEDGM/SAMPLE/aVmYvHNif5zB+d9+ct"
+  set_env "EC2_URL", "https://ec2.us-east-1.amazonaws.com"
+end

data/features/step_definitions/environment_steps.rb

@@ -0,0 +1,43 @@
+Given(/^there is an environment on the chef server named "(.*?)"$/) do |environment_name|
+  ridley.environment.find(environment_name) || ridley.environment.create(name: environment_name)
+end
+
+Given(/^the environment "(.*?)" is locked$/) do |environment_name|
+  step %Q[I run the "environment lock #{environment_name}" command]
+end
+
+Given(/^there is a file from input named "(.*?)"$/) do |file|
+  expect(File.exists?(file)).to be_true
+end
+
+Given(/^there is not an environment on the chef server named "(.*?)"$/) do |environment_name|
+  ridley.environment.find(environment_name).nil? || ridley.environment.delete(environment_name)
+end
+
+When(/^I destroy the environment "(.*?)"$/) do |environment_name|
+  step %Q[I run the "environment destroy #{environment_name}" command interactively]
+  step %q[I type "yes"]
+end
+
+When(/^I destroy the environment "(.*?)" with flags:$/) do |environment_name, table|
+  flags_string = table.raw.flatten.join(' ')
+  step %Q[I run the "environment destroy #{environment_name} #{flags_string}" command]
+end
+
+When(/^I create an environment from file "(.*?)"$/) do |file|
+  real_file = File.join(File.dirname(__FILE__), "..", "..", file)
+  step %Q[I run the "environment from #{real_file}" command]
+end
+
+When(/^I create an environment named "(.*?)"$/) do |name|
+  step %Q[I run the "environment create #{name}" command]
+end
+
+
+Then(/^there should be an environment "(.*?)" on the chef server$/) do |environment_name|
+  expect(ridley.environment.find(environment_name)).to_not be_nil
+end
+
+Then(/^there should not be an environment "(.*?)" on the chef server$/) do |environment_name|
+  expect(ridley.environment.find(environment_name)).to be_nil
+end

data/features/step_definitions/node_steps.rb

@@ -0,0 +1,3 @@
+Given(/^I have a node named "(.*?)"$/) do |node_name|
+  ridley.node.create(name: node_name)
+end

data/features/step_definitions/plugin_steps.rb

@@ -0,0 +1,15 @@
+Given /^a cookbook "(.*?)" at version "(.*?)"$/ do |name, version|
+  generate_cookbook(name, version: version, with_plugin: false)
+end
+
+Given /^a cookbook "(.*?)" at version "(.*?)" with a plugin$/ do |name, version|
+  generate_cookbook(name, version: version, with_plugin: true)
+end
+
+Given(/^a cookbook on the Chef Server "(.*?)" at version "(.*?)" with a plugin$/) do |name, version|
+  chef_cookbook(name, version, with_plugin: true)
+end
+
+Given /^I have an empty Berkshelf$/ do
+  FileUtils.rm_r(berkshelf_path, force: true)
+end

data/features/step_definitions/template_steps.rb

@@ -0,0 +1,7 @@
+Given(/^I have no templates installed$/) do
+  FileUtils.rm_rf Dir.glob(MB::FileSystem.templates.join("*"))
+end
+
+Then(/^I should have no templates installed$/) do
+  expect(Dir.glob(MB::FileSystem.templates.join("*"))).to have(0).items
+end

data/features/support/env.rb

@@ -0,0 +1,68 @@
+ENV['RUBY_ENV'] ||= 'test'
+ENV['MOTHERBRAIN_PATH'] ||= File.join(File.expand_path("../../", File.dirname(__FILE__)), "spec/tmp/.mb")
+ENV['BERKSHELF_PATH'] ||= File.join(File.expand_path("../../", File.dirname(__FILE__)), "spec/tmp/.berkshelf")
+ENV['CHEF_API_URL'] = 'http://localhost:28891'
+
+require 'rubygems'
+require 'bundler'
+require 'motherbrain'
+
+def setup_env
+  require 'rspec'
+  require 'aruba/cucumber'
+  require 'aruba/in_process'
+  require 'aruba/spawn_process'
+  require 'chef_zero/server'
+
+  Dir[File.join(File.expand_path("../../../spec/support/**/*.rb", __FILE__))].each { |f| require f }
+
+  RSpec.configure do |config|
+    config.include MotherBrain::SpecHelpers
+
+    config.before(:each) do
+      clean_tmp_path
+    end
+  end
+
+  Aruba::InProcess.main_class = MB::Cli::Runner
+  Aruba.process               = Aruba::InProcess
+
+  World(Aruba::Api)
+  World(MotherBrain::SpecHelpers)
+  World(MotherBrain::RSpec::ChefServer)
+
+  WebMock.disable_net_connect!(allow_localhost: true, net_http_connect_on_start: true)
+  MB::RSpec::ChefServer.start
+
+  at_exit { MB::RSpec::ChefServer.stop }
+
+  Before do
+    Celluloid.boot
+    @aruba_timeout_seconds = 30
+    @config = generate_valid_config
+  end
+
+  Before('@in-process') do
+    Aruba.process = Aruba::InProcess
+  end
+
+  Before('@spawn') do
+    Aruba.process = Aruba::SpawnProcess
+  end
+end
+
+if jruby?
+  setup_env
+else
+  require 'spork'
+
+  Spork.prefork do
+    setup_env
+  end
+
+  Spork.each_run do
+    require 'motherbrain'
+
+    World(MB::Mixin::CodedExit)
+  end
+end

data/lib/mb/api.rb

@@ -0,0 +1,8 @@
+module MotherBrain
+  module API
+    require_relative 'api/endpoint'
+    require_relative 'api/helpers'
+    require_relative 'api/validators'
+    require_relative 'api/application'
+  end
+end

data/lib/mb/api/application.rb

@@ -0,0 +1,7 @@
+module MotherBrain::API
+  require_relative 'v1'
+
+  class Application < MB::API::Endpoint
+    mount MB::API::V1
+  end
+end

data/lib/mb/api/endpoint.rb

@@ -0,0 +1,5 @@
+module MotherBrain::API
+  class Endpoint < Grape::API
+    include MB::Logging
+  end
+end

data/lib/mb/api/helpers.rb

@@ -0,0 +1,38 @@
+module MotherBrain::API
+  module Helpers
+    include MB::Mixin::Services
+
+    # @param [String] name
+    # @param [String] version (nil)
+    #
+    # @return [Plugin]
+    def find_plugin!(name, version = nil)
+      version = convert_uri_version(version)
+
+      unless plugin = plugin_manager.find(name, version)
+        raise MB::PluginNotFound.new(name, version)
+      end
+
+      plugin
+    end
+
+    # @param [String] id
+    #
+    # @return [JobRecord]
+    def find_job!(id)
+      unless job = job_manager.find(id)
+        raise MB::JobNotFound.new(id)
+      end
+
+      job
+    end
+
+    def convert_uri_version(version)
+      return nil if version.nil?
+
+      ver_string = version.gsub('_', '.')
+      Solve::Version.split(ver_string)
+      ver_string
+    end
+  end
+end

data/lib/mb/api/v1.rb

@@ -0,0 +1,56 @@
+require 'grape-swagger'
+
+module MotherBrain::API
+  class V1 < MB::API::Endpoint
+    require_relative 'v1/config_endpoint'
+    require_relative 'v1/environments_endpoint'
+    require_relative 'v1/jobs_endpoint'
+    require_relative 'v1/plugins_endpoint'
+
+    version 'v1', using: :header, vendor: 'motherbrain'
+    format :json
+    default_format :json
+
+    rescue_from Grape::Exceptions::Validation do |e|
+      body = MultiJson.encode(
+        status: e.status,
+        message: e.message,
+        param: e.param
+      )
+      rack_response(body, e.status, "Content-type" => "application/json")
+    end
+
+    rescue_from :all do |ex|
+      body = if ex.is_a?(MB::MBError)
+        ex.to_json
+      else
+        MB.log.fatal { "an unknown error occured: #{ex}" }
+        MultiJson.encode(code: -1, message: ex.message)
+      end
+
+      rack_response(body, 500, "Content-type" => "application/json")
+    end
+
+    before do
+      header['Access-Control-Allow-Origin'] = '*'
+      header['Access-Control-Request-Method'] = '*'
+      header.delete('Transfer-Encoding')
+    end
+
+    mount V1::ConfigEndpoint
+    mount V1::JobsEndpoint
+    mount V1::EnvironmentsEndpoint
+    mount V1::PluginsEndpoint
+    add_swagger_documentation
+
+    if MB.testing?
+      get :mb_error do
+        raise MB::InternalError, "a nice error message"
+      end
+
+      get :unknown_error do
+        raise ::ArgumentError, "hidden error message"
+      end
+    end
+  end
+end