motherbrain 0.0.0.placeholder → 0.13.1

data/lib/mb/rest_gateway.rb

@@ -0,0 +1,72 @@
+require 'reel/rack'
+
+module MotherBrain
+  class RestGateway < Reel::Rack::Server
+    class << self
+      # @raise [Celluloid::DeadActorError] if rest gateway has not been started
+      #
+      # @return [Celluloid::Actor(Gateway)]
+      def instance
+        MB::Application[:rest_gateway] or raise Celluloid::DeadActorError, "REST Gateway not running"
+      end
+
+      # Start the REST Gateway and add it to the application's registry.
+      #
+      # @note you probably don't want to manually start the REST Gateway unless you are testing. Start
+      #   the entire application with {MB::Application.run}
+      def start(options = {})
+        MB::Application[:rest_gateway] = new(options)
+      end
+
+      # Stop the currently running REST Gateway
+      #
+      # @note you probably don't want to manually stop the REST Gateway unless you are testing. Stop
+      #   the entire application with {MB::Application.stop}
+      def stop
+        instance.shutdown
+      end
+    end
+
+    include MB::Logging
+
+    DEFAULT_PORT = ENV["PORT"].to_i || 26100
+
+    DEFAULT_OPTIONS = {
+      host: '0.0.0.0',
+      port: DEFAULT_PORT,
+      quiet: false
+    }.freeze
+
+    VALID_OPTIONS = [
+      :host,
+      :port,
+      :quiet
+    ].freeze
+
+    finalizer :finalize_callback
+
+    # @option options [String] :host ('0.0.0.0')
+    # @option options [Integer] :port (26100)
+    # @option options [Boolean] :quiet (false)
+    def initialize(options = {})
+      log.debug { "REST Gateway starting..." }
+
+      options = DEFAULT_OPTIONS.merge(options.slice(*VALID_OPTIONS))
+      app     = MB::API::Application.new
+
+      # reel-rack uses Rack standard capitalizations in > 0.0.2
+      options[:Host] = options[:host]
+      options[:Port] = options[:port]
+
+      log.info { "REST Gateway listening on #{options[:host]}:#{options[:port]}" }
+      super(app, options)
+    end
+
+    private
+
+      def finalize_callback
+        log.debug { "REST Gateway stopping..." }
+        self.shutdown
+      end
+  end
+end

data/lib/mb/ridley_ext.rb

@@ -0,0 +1,5 @@
+require 'ridley'
+
+Dir["#{File.dirname(__FILE__)}/ridley_ext/*.rb"].sort.each do |path|
+  require "mb/ridley_ext/#{File.basename(path, '.rb')}"
+end

data/lib/mb/ridley_ext/cookbook_object.rb

@@ -0,0 +1,15 @@
+module Ridley
+  class CookbookObject < Ridley::ChefObject
+    # Check if the cookbook has the required files to be a motherbrain plugin
+    #
+    # @return [Boolean]
+    def has_motherbrain_plugin?
+      plugin_file   = root_files.find { |file| file[:name] == MB::Plugin::PLUGIN_FILENAME }
+      metadata_file = root_files.find do |file|
+        file[:name] == MB::CookbookMetadata::RUBY_FILENAME || file[:name] == MB::CookbookMetadata::JSON_FILENAME
+      end
+
+      plugin_file && metadata_file
+    end
+  end
+end

data/lib/mb/srv_ctl.rb

@@ -0,0 +1,183 @@
+require 'optparse'
+
+module MotherBrain
+  class SrvCtl
+    class << self
+      include MB::Mixin::CodedExit
+
+      def default_options
+        {
+          config: MB::Config.default_path
+        }
+      end
+
+      # @param [Array] args
+      # @param [#to_s] filename
+      #
+      # @return [Hash]
+      def parse(args, filename)
+        options = Hash.new
+
+        OptionParser.new("Usage: #{filename} [options]") do |opts|
+          opts.on("-c", "--config PATH", "path to configuration file", "(default: '#{default_options[:config]}')") do |v|
+            options[:config] = File.expand_path(v)
+          end
+
+          opts.on("-v", "--verbose", "run with verbose output") do
+            options[:log_level] = Logger::DEBUG
+          end
+
+          opts.on("-d", "--daemonize", "run in daemon mode") do
+            options[:daemonize] = true
+
+            unless options[:log_location]
+              options[:log_location] = FileSystem.logs.join('application.log').to_s
+            end
+          end
+
+          opts.on("-P", "--pid PATH", String, "pid file to read/write from") do |v|
+            options[:pid_file] = File.expand_path(v)
+          end
+
+          opts.on("-l", "--log PATH", String, "path to log file") do |v|
+            options[:log_location] = v
+          end
+
+          opts.on("-k", "--kill", "kill mbsrv if running") do |v|
+            options[:kill] = v
+          end
+
+          opts.on_tail("-h", "--help", "show this message") do
+            ui.say opts
+            exit
+          end
+        end.parse!(args)
+
+        options
+      end
+
+      # @param [Array] args
+      # @param [String] filename
+      def run(args, filename)
+        MB::Logging.setup
+
+        options = parse(args, filename)
+        ctl = new(options)
+
+        options[:kill] ? ctl.stop : ctl.start
+      rescue MB::MBError => ex
+        ui.error ex
+        exit_with(ex)
+      end
+
+      # @return [MB::Cli::Shell::Color, MB::Cli::Shell::Basic]
+      def ui
+        @ui ||= MB::Cli::Shell.shell.new
+      end
+    end
+
+    attr_reader :config
+
+    # @option options [String] :config (MB::Config.default_path)
+    # @option options [Boolean] :daemonize
+    # @option options [String] :pid_file
+    # @option options [Integer] :log_level
+    # @option options [String] :log_location
+    def initialize(options = {})
+      options  = self.class.default_options.merge(options)
+      @config  = MB::Config.from_file(options[:config])
+
+      unless options[:log_level].nil?
+        @config.log.level = options[:log_level]
+      end
+
+      unless options[:log_location].nil?
+        @config.log.location = options[:log_location]
+      end
+
+      unless options[:daemonize].nil?
+        @config.server.daemonize = options[:daemonize]
+      end
+
+      unless options[:pid_file].nil?
+        @config.server.pid = options[:pid_file]
+      end
+
+      MB::Logging.setup(@config.to_logger)
+    end
+
+    def start
+      if config.server.daemonize
+        if pid
+          ui.say "mbsrv already started"
+          exit 1
+        end
+
+        daemonize
+      end
+
+      MB::Application.run(config)
+    end
+
+    def stop
+      unless pid
+        ui.say "mbsrv not started"
+        exit 0
+      end
+
+      Process.kill('TERM', pid)
+      destroy_pid
+    rescue Errno::ESRCH
+      destroy_pid
+    end
+
+    private
+
+      def daemonize
+        unless File.exist?(pid_directory)
+          begin
+            ui.say "creating pid directory at #{pid_directory}"
+            FileUtils.mkdir_p(pid_directory)
+            rescue Errno::EACCES => ex
+              ui.error ex
+              self.class.exit_with(ex)
+            end
+        end
+
+        unless File.writable?(pid_directory)
+          ui.say "startup failed: couldn't write pid to #{config.server.pid}"
+          exit 1
+        end
+
+        Process.daemon
+        create_pid
+      end
+
+      def create_pid
+        File.open(config.server.pid, 'w') { |f| f.write Process.pid }
+      end
+
+      def pid_directory
+        File.dirname(config.server.pid)
+      end
+
+      def destroy_pid
+        FileUtils.rm(config.server.pid)
+      end
+
+      def pid
+        return nil unless pid_file?
+        pid = File.read(config.server.pid).chomp.to_i
+        return nil unless pid > 0
+        pid
+      end
+
+      def pid_file?
+        File.exists?(config.server.pid)
+      end
+
+      def ui
+        self.class.ui
+      end
+  end
+end

data/lib/mb/test.rb

@@ -0,0 +1,104 @@
+require 'rspec/mocks'
+require 'active_support/inflector'
+require 'webmock'
+
+module MotherBrain
+  module Test
+    def self.mock(type)
+      type = type.to_s
+      klass = begin
+                "::MB::Test::#{type.camelize}".constantize
+              rescue NameError
+                MB.log.warn { "Couldn't find test class for #{type}" }
+                return false
+              end
+      klass.mock!
+    end
+
+    class Base
+      def self.mock!
+        new.register_mocks
+      end
+
+      def initialize
+        ::RSpec::Mocks.setup(self)
+        WebMock.disable_net_connect!(allow_localhost: true)
+      end
+
+      def type
+        self.class.to_s.sub(/.*::/, '').upcase
+      end
+
+      def available_mocks
+        []
+      end
+
+      def register_mocks
+        return unless MB.testing?
+        available_mocks.each do |mock|
+          env = ENV["MB_TEST_#{type}_#{mock.upcase}"]
+          self.send(mock, env) if env
+        end
+      end
+    end
+
+    class Init < Base
+      include WebMock::API
+
+      def available_mocks
+        [:env, :cookbook, :bootstrap, :template, :template_url]
+      end
+
+      def ridley
+        return @ridley if @ridley
+        @ridley = double('ridley')
+        Application.ridley.wrapped_object.should_receive(:connection).and_return(@ridley)
+        @ridley.should_receive(:alive?).and_return(true)
+        @ridley.should_receive(:terminate).and_return(true)
+        @ridley.should_receive(:url_prefix).and_return("http://chef.example.com")
+        @ridley
+      end
+
+      def env(name)
+        ridley.should_receive(:get).with("environments/#{name}").
+          and_return(double(:response, :body => {}))
+      end
+
+      def cookbook(name, version = nil)
+        ridley.should_receive(:get).with("cookbooks").and_return(double(:response, :body => {}))
+        ridley.should_receive(:get).with("cookbooks/#{name}").and_return(double(:response, :body => {}))
+        plugin = MB::Application.plugin_manager.find(name, version)
+        MB::Application.plugin_manager.should_receive(:for_environment).and_return(plugin)
+      end
+
+      def bootstrap(x)
+        Application.bootstrap_manager.wrapped_object.should_receive(:bootstrap) do |job, environment, manifest, plugin, options|
+          job.report_running
+          job.report_success
+          job.terminate if job.alive?
+        end
+      end
+
+      def template(name)
+        ridley.should_receive(:get).with("nodes").and_return(double(:response, :body => []))
+        node = double('node')
+        Application.ridley.wrapped_object.should_receive(:node).and_return(node)
+        ssh = double('ssh')
+        node.should_receive(:bootstrap) do |hostnames, options|
+          raise "Template not set!" unless options[:template]
+          raise "Template not right!" unless options[:template] =~ /#{name}/
+          [ssh]
+        end
+        node.should_receive(:all).and_return([])
+        ssh.should_receive(:host).and_return("foo.example.com")
+        ssh.should_receive(:error?).and_return(false)
+        Application.node_querier.wrapped_object.should_receive(:node_name).and_return("foo.example.com")
+      end
+
+      def template_url(name_and_url)
+        name, url = name_and_url.split("##")
+        stub_request(:get, url).to_return(:body => name)
+      end
+    end
+  end
+end

data/lib/mb/thor_ext.rb

@@ -0,0 +1,49 @@
+# Code from https://github.com/wycats/thor/pull/317
+
+class Thor
+  module Shell
+    class Basic
+      def ask(statement, *args)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        color = args.first
+
+        if options[:limited_to]
+          ask_filtered(statement, color, options)
+        else
+          ask_simply(statement, color, options)
+        end
+      end
+
+      protected
+
+      def ask_simply(statement, color, options)
+        default = options[:default]
+        message = [statement, ("(#{default.inspect})" if default), nil].uniq.join(" ")
+        say(message, color)
+        result = stdin.gets
+
+        return unless result
+
+        result.strip!
+
+        if default && result == ""
+          default
+        else
+          result
+        end
+      end
+
+      def ask_filtered(statement, color, options)
+        answer_set = options[:limited_to]
+        correct_answer = nil
+        until correct_answer
+          answer = ask_simply("#{statement} #{answer_set.inspect}", color, options)
+          correct_answer = answer_set.include?(answer) ? answer : nil
+          answers = answer_set.map(&:inspect).join(", ")
+          say("Your response must be one of: [#{answers}]. Please try again.") unless correct_answer
+        end
+        correct_answer
+      end
+    end
+  end
+end

data/lib/mb/upgrade.rb

@@ -0,0 +1,6 @@
+module MotherBrain
+  module Upgrade
+    autoload :Manager, 'mb/upgrade/manager'
+    autoload :Worker, 'mb/upgrade/worker'
+  end
+end

data/lib/mb/upgrade/manager.rb

@@ -0,0 +1,85 @@
+module MotherBrain
+  module Upgrade
+    # Handles upgrading nodes in already environments.
+    class Manager
+      class << self
+        # @raise [Celluloid::DeadActorError] if Upgrade Manager has not been started
+        #
+        # @return [Celluloid::Actor(Upgrade::Manager)]
+        def instance
+          MB::Application[:upgrade_manager] or raise Celluloid::DeadActorError, "upgrade manager not running"
+        end
+      end
+
+      include Celluloid
+      include MB::Logging
+
+      finalizer :finalize_callback
+
+      def initialize
+        log.debug { "Upgrade Manager starting..." }
+      end
+
+      # Asynchronously upgrade an environment
+      #
+      # @param [String] environment
+      #   name of the environment to upgrade
+      # @param [MB::Plugin] plugin
+      #   plugin to use for performing the upgrade on the environment
+      #
+      # @option options [Hash] component_versions
+      #   Hash of components and the versions to set them to
+      # @option options [Hash] cookbook_versions
+      #   Hash of cookbooks and the versions to set them to
+      # @option options [Hash] environment_attributes
+      #   any additional attributes to set on the environment
+      # @option options [String] environment_attributes_file
+      #   any additional attributes to set on the environment via a json file
+      # @option options [Boolean] :force
+      #   Force any locks to be overwritten
+      #
+      # @return [JobTicket]
+      def async_upgrade(environment, plugin, options = {})
+        job = Job.new(:upgrade)
+
+        async(:upgrade, job, environment, plugin, options)
+
+        job.ticket
+      end
+
+      # Synchronously upgrade an environment
+      #
+      # @param [MB::Job] job
+      # @param [String] environment
+      #   name of the environment to upgrade
+      # @param [MB::Plugin] plugin
+      #   plugin to use for performing the upgrade on the environment
+      #
+      # @option options [Hash] component_versions
+      #   Hash of components and the versions to set them to
+      # @option options [Hash] cookbook_versions
+      #   Hash of cookbooks and the versions to set them to
+      # @option options [Hash] environment_attributes
+      #   any additional attributes to set on the environment
+      # @option options [String] environment_attributes_file
+      #   any additional attributes to set on the environment via a json file
+      # @option options [Boolean] :force
+      #   Force any locks to be overwritten
+      #
+      # @return [Job]
+      def upgrade(job, environment, plugin, options = {})
+        worker = Worker.new(job, environment.freeze, plugin.freeze, options.freeze)
+        worker.run
+      ensure
+        worker.terminate if worker && worker.alive?
+        job.terminate if job && job.alive?
+      end
+
+      private
+
+        def finalize_callback
+          log.debug { "Upgrade Manager stopping..." }
+        end
+    end
+  end
+end