motherbrain 0.0.0.placeholder → 0.13.1

data/lib/mb/core_ext.rb

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

data/lib/mb/core_ext/dir.rb

@@ -0,0 +1,37 @@
+class Dir
+  class << self
+    # Check if the given directory contains a cookbook with a motherbrain plugin
+    #
+    # @param [#to_s] path
+    #   the directory path
+    #
+    # @return [Boolean]
+    def has_mb_plugin?(path)
+      return false unless exists?(path)
+      return false unless has_mb_file?(path)
+      return false unless has_chef_metadata?(path)
+      true
+    end
+
+    # Check if the given directory contains a motherbrain plugin file
+    #
+    # @param [#to_s] path
+    #   the directory path
+    #
+    # @return [Boolean]
+    def has_mb_file?(path)
+      File.exist?(File.join(path, MB::Plugin::PLUGIN_FILENAME))
+    end
+
+    # Check if the given directory contains a Chef metadata file
+    #
+    # @param [#to_s] path
+    #   the directory path
+    #
+    # @return [Boolean]
+    def has_chef_metadata?(path)
+      File.exist?(File.join(path, MB::CookbookMetadata::RUBY_FILENAME)) ||
+        File.exist?(File.join(path, MB::CookbookMetadata::JSON_FILENAME))
+    end
+  end
+end

data/lib/mb/core_ext/enumerable.rb

@@ -0,0 +1,48 @@
+module Enumerable
+  # Map across all members using Celluloid futures, and wait for the results.
+  #
+  # This chooses the best behavior based on each item, and whether a method and
+  # argument list or block are passed.
+  #
+  # @param [Symbol] method_name
+  #   The name of the method to call on each item in the collection
+  # @param [Array] args
+  #   The argument list, if any, to pass to each method send
+  # @param [Proc] block
+  #   A block to yield each item to
+  #
+  # @example Passing a method and arguments
+  #
+  #   [1, 2, 3].concurrent_map(:next)
+  #   # => [2, 3, 4]
+  #
+  #   [1, 2, 3].concurrent_map(:modulo, 2)
+  #   # => [1, 0, 1]
+  #
+  # @example Passing a block
+  #
+  #   [1, 2, 3].concurrent_map { |n| n + 1 }
+  #   # => [2, 3, 4]
+  #
+  # @return [Array] a new array containing the values returned by the futures
+  def concurrent_map(method_name = nil, *args, &block)
+    futures = if method_name
+      map { |item|
+        if item.respond_to?(:future)
+          item.future(method_name, *args)
+        else
+          Celluloid::Future.new { item.send(method_name, *args) }
+        end
+      }
+    elsif block_given?
+      map { |item|
+        Celluloid::Future.new { block.yield item }
+      }
+    else
+      raise ArgumentError, "Requires method and argument list, or a block"
+    end
+
+    futures.map(&:value)
+  end
+  alias_method :concurrent_collect, :concurrent_map
+end

data/lib/mb/core_ext/file.rb

@@ -0,0 +1,24 @@
+class File
+  class << self
+    # Determine if the given filepath points to a Chef metadata file
+    #
+    # @param [#to_s] filepath
+    #
+    # @return [Boolean]
+    def is_chef_metadata?(filepath)
+      return false unless exists?(filepath)
+      filename = basename(filepath)
+      filename == MB::CookbookMetadata::RUBY_FILENAME || filename == MB::CookbookMetadata::JSON_FILENAME
+    end
+
+    # Determine if the given filepath points to a motherbrain plugin file
+    #
+    # @param [#to_s] filepath
+    #
+    # @return [Boolean]
+    def is_mb_plugin?(filepath)
+      return false unless exists?(filepath)
+      basename(filepath) == MB::Plugin::PLUGIN_FILENAME
+    end
+  end
+end

data/lib/mb/core_ext/signal.rb

@@ -0,0 +1,11 @@
+module Signal
+  class << self
+    # Check if a given signal is supported on the current platform
+    #
+    # @param [#to_s] id
+    #   the signal ID
+    def supported?(id)
+      list.has_key?(id.to_s)
+    end
+  end
+end

data/lib/mb/environment_manager.rb

@@ -0,0 +1,195 @@
+module MotherBrain
+  class EnvironmentManager
+    class << self
+      # @raise [Celluloid::DeadActorError] if the environment manager has not been started
+      #
+      # @return [Celluloid::Actor(EnvironmentManager)]
+      def instance
+        MB::Application[:environment_manager] or raise Celluloid::DeadActorError, "environment manager not running"
+      end
+    end
+
+    include Celluloid
+    include MB::Logging
+    include MB::Mixin::Locks
+    include MB::Mixin::Services
+
+    finalizer :finalize_callback
+
+    def initialize
+      log.debug { "Environment Manager starting..." }
+    end
+
+    # Asynchronously configure a target environment with the given attributes
+    #
+    # @param [String] id
+    #   identifier of the environment to configure
+    #
+    # @option options [Hash] :attributes (Hash.new)
+    #   a hash of attributes to merge with the existing attributes of an environment
+    # @option options [Boolean] :force (false)
+    #   force configure even if the environment is locked
+    #
+    # @note attributes will be set at the 'default' level and will be merged into the
+    #   existing attributes of the environment
+    #
+    # @return [JobTicket]
+    def async_configure(id, options = {})
+      job = Job.new(:environment_configure)
+      async(:configure, job, id, options)
+
+      job.ticket
+    end
+
+    # Configure a target environment with the given attributes
+    #
+    # @param [MB::Job] job
+    #   a job to update with progress
+    # @param [String] id
+    #   identifier of the environment to configure
+    #
+    # @option options [Hash] :attributes (Hash.new)
+    #   a hash of attributes to merge with the existing attributes of an environment
+    # @option options [Boolean] :force (false)
+    #   force configure even if the environment is locked
+    #
+    # @api private
+    def configure(job, id, options = {})
+      options = options.reverse_merge(
+        attributes: Hash.new,
+        force: false
+      )
+
+      node_successes_count = 0
+      node_successes = Array.new
+
+      node_failures_count  = 0
+      node_failures = Array.new
+
+      environment = find(id)
+      job.report_running("Finding environment #{environment.name}")
+
+      chef_synchronize(chef_environment: environment.name, force: options[:force], job: job) do
+        job.set_status("Saving updated environment with - #{options[:attributes]}")
+        environment.default_attributes.deep_merge!(options[:attributes])
+        environment.save
+
+        job.set_status("Searching for nodes in the environment")
+        nodes = nodes_for_environment(environment.name)
+
+        job.set_status("Performing a chef client run on #{nodes.length} nodes")
+        nodes.collect do |node|
+          node_querier.future(:chef_run, node.public_hostname)
+        end.each do |future|
+          begin
+            response = future.value
+            node_successes_count += 1
+            node_successes << response.host
+          rescue RemoteCommandError => error
+            node_failures_count += 1
+            node_failures << error.host
+          end
+        end
+      end
+
+      if node_failures_count > 0
+        job.report_failure("chef client run failed on #{node_failures_count} node(s) - #{node_failures.join(', ')}")
+      else
+        job.report_success("Finished chef client run on #{node_successes_count} node(s) - #{node_successes.join(', ')}")
+      end
+    rescue => ex
+      job.report_failure(ex)
+    ensure
+      job.terminate if job && job.alive?
+    end
+
+    # Find an environment on the remote Chef server
+    #
+    # @param [#to_s] id
+    #   identifier for the environment to find
+    #
+    # @raise [EnvironmentNotFound] if the given environment does not exist
+    #
+    # @return [Ridley::EnvironmentResource]
+    def find(id)
+      unless environment = ridley.environment.find(id)
+        abort EnvironmentNotFound.new(id)
+      end
+
+      environment
+    end
+
+    # Creates an environment
+    #
+    # @param [#to_s] name
+    #
+    # @return [Ridley::EnvironmentResource]
+    def create(name)
+      ridley.environment.create(name: name)
+    rescue Ridley::Errors::HTTPConflict
+      abort EnvironmentExists.new(name)
+    rescue => error
+      abort error
+    end
+
+    # Creates an environment from JSON contained in a file
+    #
+    # @param [#to_s] path
+    #
+    # @return [Ridley::EnvironmentResource]
+    def create_from_file(path)
+      abort FileNotFound.new(path) unless File.exist? path
+
+      env = ridley.environment.from_file(path)
+      ridley.environment.create(env)
+    rescue Ridley::Errors::HTTPConflict
+      abort EnvironmentExists.new(env.name)
+    end
+
+    # Destroys an environment
+    #
+    # @param [#to_s] name
+    #
+    # @return [Ridley::EnvironmentResource, nil]
+    def destroy(name)
+      ridley.environment.delete(name)
+    end
+
+    # Returns a list of environments present on the remote server
+    #
+    # @return [Array<Ridley::EnvironmentResource>]
+    def list
+      ridley.environment.all
+    end
+
+    # Removes all nodes and clients from the Chef server for a given environment
+    #
+    # @param [String] name
+    def purge_nodes(name)
+      nodes = nodes_for_environment(name)
+      futures = []
+
+      nodes.each do |node|
+        futures << ridley.client.future(:delete, node)
+        futures << ridley.node.future(:delete, node)
+      end
+
+      futures.map(&:value)
+    end
+
+    # Returns an array of nodes for an environment
+    #
+    # @param [String] name
+    #
+    # @return [Array(Ridley::NodeObject)]
+    def nodes_for_environment(name)
+      ridley.search(:node, "chef_environment:#{name}")
+    end
+
+    private
+
+      def finalize_callback
+        log.debug { "Environment Manager stopping..." }
+      end
+  end
+end

data/lib/mb/error_handler.rb

@@ -0,0 +1,212 @@
+module MotherBrain
+  # An object to help with the display of errors in a more user-friendly format.
+  # An ErrorHandler is created with an error and a set of options to control the
+  # display of the error. Some options can be inferred from the error itself.
+  # A typical use case would be to wrap an error generated deep in a call stack,
+  # and then add data to the error as it bubbles up.
+  #
+  # @example Wrapping and raising an error with more data
+  #
+  #   ErrorHandler.wrap StandardError.new,
+  #     file_path: "/a/b/c.rb",
+  #     method_name: :wat,
+  #     plugin_name: "hi",
+  #     plugin_version: "1.2.3",
+  #     text: "Invalid thing"
+  #
+  #   # Would raise an error with a message of:
+  #
+  #   hi (1.2.3)
+  #   /a/b/c.rb, on line 1, in 'wat'
+  #   Invalid thing
+  #
+  # @example Wrapping an error at multiple points in the call chain
+  #
+  #   def load_file(path)
+  #     load File.read(path)
+  #   rescue => error
+  #     ErrorHandler.wrap error, file_path: path
+  #   end
+  #
+  #   def load(code)
+  #     eval code
+  #   rescue => error
+  #     ErrorHandler.wrap error, plugin_name: code.lines.to_a.first
+  #   end
+  #
+  #   def method_missing(method_name, *args, &block)
+  #     ErrorHandler.wrap CodeError.new, method_name: method_name
+  #   end
+  #
+  #
+  class ErrorHandler
+    NEWLINE = "\n"
+    SOURCE_RANGE = 5
+
+    class << self
+      # Wraps an error with additional data and raises it.
+      #
+      # @raise [StandardError]
+      # @see #initialize
+      def wrap(error, options = {})
+        error_handler = new(error, options)
+
+        raise error_handler.error, error_handler.message
+      end
+    end
+
+    attr_reader :error
+
+    OPTIONS = %w[
+      backtrace
+      file_path
+      method_name
+      plugin_name
+      plugin_version
+      text
+    ].map(&:to_sym)
+
+    OPTIONS.each do |option|
+      attr_reader option
+    end
+
+    # @param [StandardError] error
+    #
+    # @option options [Array] backtrace
+    #   An array of strings containing filenames, line numbers, and method
+    #   names. Typically comes from `caller`.
+    #
+    # @option options [String] file_path
+    #   The location of a file on disk to display to the user.
+    #
+    # @option options [Symbol] method_name
+    #   The name of the method or keyword which generated the error.
+    #
+    # @option options [String] plugin_name
+    #   The name of the plugin the error relates to.
+    #
+    # @option options [String] plugin_version
+    #   The version of the plugin the error relates to.
+    #
+    # @option options [String] text
+    #   A custom error message to display to the user.
+    #
+    def initialize(error, options = {})
+      error = error.new if error.is_a? Class
+
+      @error = error
+
+      extract_data_from_options options
+      extract_data_from_error
+
+      embed_data_in_error
+    end
+
+    # Extracts data from an options hash and stores it in instance variables.
+    #
+    # @param [Hash] options
+    #
+    # @see #initialize
+    def extract_data_from_options(options)
+      OPTIONS.each do |option|
+        instance_variable_set "@#{option}", options[option]
+      end
+    end
+
+    # Extracts data from the error and stores it in instance variables. Does not
+    # overwrite existing instance variables.
+    def extract_data_from_error
+      OPTIONS.each do |option|
+        data = error.instance_variable_get "@_error_handler_#{option}"
+
+        unless instance_variable_get "@#{option}"
+          instance_variable_set "@#{option}", data
+        end
+      end
+
+      @backtrace ||= error.backtrace
+      @method_name ||= error.name if error.respond_to? :name
+      @text ||= error.message
+    end
+
+    # Stores the data in the error and defines getters.
+    def embed_data_in_error
+      OPTIONS.each do |option|
+        data = instance_variable_get "@#{option}"
+
+        if data
+          error.instance_variable_set "@_error_handler_#{option}", data
+        end
+      end
+    end
+
+    # @return [String]
+    def message
+      result = [
+        plugin_name_and_plugin_version,
+        file_path_and_line_number_and_method_name,
+        text,
+        relevant_source_lines
+      ].compact.join NEWLINE
+
+      result << NEWLINE unless result.end_with? NEWLINE
+
+      result
+    end
+
+    # @return [String]
+    def file_contents
+      return unless file_path and File.exist? file_path
+
+      File.read file_path
+    end
+
+    # @return [String]
+    def relevant_source_lines
+      return unless file_contents and line_number
+
+      beginning = line_number - (SOURCE_RANGE / 2) - 1
+      beginning = [beginning, 0].max
+      numbered_source_lines[beginning, SOURCE_RANGE].join NEWLINE
+    end
+
+    # @return [Array]
+    def numbered_source_lines
+      lines = file_contents.lines.to_a.map(&:rstrip)
+      rjust_size = lines.count.to_s.length
+
+      result = []
+
+      lines.each_with_index do |line, index|
+        current_line_number = index + 1
+
+        result << "#{current_line_number.to_s.rjust rjust_size}#{line_number == current_line_number ? '>>' : ': '}#{line}"
+      end
+
+      result
+    end
+
+    # @return [String]
+    def file_path_and_line_number_and_method_name
+      buffer = []
+      buffer << file_path if file_path
+      buffer << "on line #{line_number}" if line_number
+      buffer << "in '#{method_name}'" if method_name
+      buffer.join ", "
+    end
+
+    # @return [String]
+    def plugin_name_and_plugin_version
+      "#{plugin_name} (#{plugin_version})" if plugin_name and plugin_version
+    end
+
+    # Extracts the first line number from the backtrace.
+    #
+    # @return [Fixnum]
+    def line_number
+      return unless backtrace and backtrace[0]
+
+      backtrace[0].split(":")[1].to_i
+    end
+  end
+end