motherbrain 0.0.0.placeholder → 0.13.1

data/lib/mb/command_invoker/worker.rb

@@ -0,0 +1,40 @@
+module MotherBrain
+  class CommandInvoker
+    class Worker
+      include Celluloid
+
+      # @return [MB::Command]
+      attr_reader :command
+      # @return [String]
+      attr_reader :environment
+      # @return [Array]
+      attr_reader :node_filter
+
+      # @param [MB::Command] command
+      #   command to invoke
+      # @param [String] environment
+      #   environment to invoke this command on
+      # @param [Array] node_filter = nil
+      #	  list of nodes to limit the command to
+      def initialize(command, environment, node_filter = nil)
+        @command     = command
+        @environment = environment
+        @node_filter = node_filter
+      end
+
+      # @param [MB::Job] job
+      # @param [Array] arguments
+      def run(job, arguments = Array.new)
+        arguments ||= Array.new
+
+        msg = "Invoking #{command.type} command #{command.scope.name} #{command.name} on #{environment}"
+        msg << " with arguments: #{arguments}" if arguments.any?
+        job.set_status(msg)
+
+        command.invoke(job, environment, node_filter, *arguments)
+      rescue RemoteCommandError => ex
+        abort(ex)
+      end
+    end
+  end
+end

data/lib/mb/command_runner.rb

@@ -0,0 +1,233 @@
+module MotherBrain
+  class CommandRunner
+    include MB::Mixin::Services
+
+    # @return [String]
+    attr_reader :environment
+    # @return [MB::Plugin, MB::Component]
+    attr_reader :scope
+    # @return [Proc]
+    attr_reader :execute
+    # @return [Array]
+    attr_reader :node_filter
+    # @return [Array]
+    attr_reader :args
+
+    # @param [String] environment
+    #   environment to run this command on
+    # @param [MB::Plugin, MB::Component] scope
+    #   scope to execute this command in.
+    #
+    #   * executing the command in the scope of an entire plugin will give you easy access to
+    #     component commands and other plugin level commands
+    #   * executing the command in the scope of a component will give you easy access to the
+    #     other commands available in that component
+    # @param [Proc] execute
+    #   the code to execute when the command runner is run
+    #
+    #   @example
+    #     proc {
+    #       on("some_nodes") { service("nginx").run("stop") }
+    #     }
+    # @param [Array] node_filter
+    #   a list of nodes to filter commands on
+    # @param [Array] args
+    #   any additional arguments to pass to the execution block
+    def initialize(job, environment, scope, execute, node_filter, *args)
+      @job         = job
+      @environment = environment
+      @scope       = scope
+      @execute     = execute
+      @node_filter = node_filter
+      @args        = args
+
+      @on_procs    = []
+      @async       = false
+
+      run
+    end
+
+    def run
+      if execute.arity.nonzero?
+        curried_execute = proc { execute.call(*args) }
+        instance_eval(&curried_execute)
+      else
+        instance_eval(&execute)
+      end
+    end
+
+    # Run the stored procs created by on() that have not been ran yet.
+    def apply
+      # TODO: This needs to happen in parallel but can't due to the way running multiple
+      # actions on a single node works. Actions work on a node and don't know about other
+      # actions which are being run on that node, so in a single node environment the
+      # state of a node can get weird when actions stomp all over each other.
+      #
+      # We should refactor this to APPLY actions to nodes and then allow them to converge
+      # together before we run them. This will allow us to execute multiple actions on a node at once
+      # without getting weird race conditions.
+      @on_procs.each do |on_proc|
+        on_proc.call
+      end
+
+      @on_procs.clear
+    end
+
+    # Are we inside an async block?
+    #
+    # @return [Boolean]
+    def async?
+      !!@async
+    end
+
+    # Run the block asynchronously.
+    def async(&block)
+      @nodes = []
+
+      @async = true
+      instance_eval(&block)
+      @async = false
+
+      apply
+
+      node_querier.bulk_chef_run job, @nodes
+    end
+
+    # Run the block specified on the nodes in the groups specified.
+    #
+    # @param [Array<String>] group_names groups to run on
+    #
+    # @option options [Integer] :any
+    #   the number of nodes to run on, which nodes are chosen doesn't matter
+    # @option options [Integer] :max_concurrent
+    #   the number of nodes to run on at a time
+    #
+    # @example running on masters and slaves, only 2 of them, 1 at a time
+    #
+    #   on("masters", "slaves", any: 2, max_concurrent: 1) do
+    #     # actions
+    #   end
+    def on(*group_names, &block)
+      options = group_names.last.kind_of?(Hash) ? group_names.pop : {}
+
+      unless block_given?
+        raise PluginSyntaxError, "Block required"
+      end
+
+      clean_room = CleanRoom.new(scope)
+      clean_room.instance_eval(&block)
+      actions = clean_room.send(:actions)
+
+      nodes = group_names.map do |name|
+        scope.group!(name.to_s)
+      end.flat_map do |group|
+        group.nodes(environment)
+      end.uniq
+
+      return unless nodes.any?
+
+      nodes = MB::NodeFilter.filter(node_filter, nodes) if node_filter
+
+      if options[:any]
+        nodes = nodes.sample(options[:any])
+      end
+
+      options[:max_concurrent] ||= nodes.count
+      node_groups = nodes.each_slice(options[:max_concurrent]).to_a
+
+      run_chef = !async?
+
+      @on_procs << -> {
+        node_groups.each do |nodes|
+          actions.each do |action|
+            action.run(job, environment, nodes, run_chef)
+          end
+        end
+      }
+
+      if async?
+        @nodes |= nodes
+      else
+        apply
+      end
+    end
+
+    # Select a component for the purposes of invoking a command.
+    # NB: returns a proxy object
+    #
+    # @param [String] component_name the name of the component you want to
+    #    invoke a command on
+    # @return [InvokableComponent] proxy for the actual component,
+    #    only useful if you call #invoke on it
+    def component(component_name)
+      InvokableComponent.new(job, environment, scope.component(component_name))
+    end
+
+    def command(command_name)
+      scope.command!(command_name).invoke(job, environment, node_filter)
+    end
+
+    private
+
+      attr_reader :job
+
+    # @api private
+    class CleanRoom < CleanRoomBase
+      def initialize(*args)
+        super
+        @actions = Array.new
+
+        Gear.all.each do |klass|
+          clean_room = self
+
+          klass.instance_eval do
+            define_method :run, ->(job, *args, &block) do
+              clean_room.send(:actions) << action = action(job, *args, &block)
+              action
+            end
+          end
+        end
+      end
+
+      Gear.all.each do |klass|
+        define_method Gear.get_fun(klass), ->(*args) do
+          real_model.send(Gear.get_fun(klass), *args)
+        end
+      end
+
+      protected
+
+        attr_reader :actions
+
+        # @param [Fixnum] seconds
+        def wait(seconds)
+          Celluloid.sleep(seconds)
+        end
+    end
+
+    # Proxy for invoking components in the DSL
+    #
+    # @api private
+    class InvokableComponent
+      attr_reader :job
+      attr_reader :environment
+      attr_reader :component
+
+      # @param [Job] job
+      # @param [String] environment the environment on which to
+      #   eventually invoke a command
+      # @param [Component] component the component we'll be invoking
+      def initialize(job, environment, component)
+        @job = job
+        @environment = environment
+        @component   = component
+      end
+
+      # @param [String] command the command to invoke in the component
+      # @param [Array] args additional arguments for the command
+      def invoke(command, *args)
+        component.invoke(job, environment, command, args)
+      end
+    end
+  end
+end

data/lib/mb/component.rb

@@ -0,0 +1,245 @@
+module MotherBrain
+  class Component
+    include VariaModel
+
+    attribute :name,
+      type: String,
+      required: true
+
+    attribute :description,
+      type: String
+
+    attribute :version_attribute,
+      type: String
+
+    # @return [MB::Plugin]
+    attr_reader :plugin
+    attr_reader :groups
+    attr_reader :commands
+
+    # @param [#to_s] name
+    # @param [MB::Plugin] plugin
+    def initialize(name, plugin, &block)
+      set_attribute(:name, name.to_s)
+      @plugin   = plugin
+      @groups   = Set.new
+      @commands = Set.new
+      @gears    = Hash.new
+
+      if block_given?
+        dsl_eval(&block)
+      end
+    end
+
+    # @return [String]
+    def description
+      _attributes_.description || "#{name} component commands"
+    end
+
+    # @return [Symbol]
+    def id
+      self.name.to_sym
+    end
+
+    # @param [#to_sym] name
+    def group(name)
+      self.groups.find { |group| group.name == name }
+    end
+
+    # @param [#to_sym] group_name
+    #
+    # @raise [GroupNotFound] if the group is not found
+    #
+    # @return [MB::Group]
+    def group!(group_name)
+      group = group(group_name)
+
+      if group.nil?
+        raise GroupNotFound, "Group #{group_name} does not exist on #{name}!"
+      end
+
+      group
+    end
+
+    # @param [#to_s] name
+    #
+    # @return [Boolean]
+    def has_group?(name)
+      group(name.to_s).present?
+    end
+
+    # @param [#to_sym] name
+    def command(name)
+      self.commands.find { |command| command.name == name }
+    end
+
+    # Return a command from the component's list of commands. If a command is not found an exception will be rasied.
+    #
+    # @param [#to_s] name
+    #   name of the command to find and return
+    #
+    # @raise [CommandNotFound] if a command matching the given name is not found on this component
+    #
+    # @return [MB::Command]
+    def command!(name)
+      found = command(name)
+
+      if found.nil?
+        raise CommandNotFound.new(name, self)
+      end
+
+      found
+    end
+
+    # Run a command of the given name on the component.
+    #
+    # @param [Job] job
+    # @param [String] environment
+    # @param [String, Symbol] name
+    # @param [Array] args
+    def invoke(job, environment, name, *args)
+      self.command(name).invoke(job, environment, args)
+    end
+
+    # Finds the nodes for the given environment for each {Group} and groups them
+    # by Group#name into a Hash where the keys are Group#name and values are a Hash
+    # representation of a node from Chef.
+    #
+    # @param [#to_s] environment
+    #
+    # @raise [MB::EnvironmentNotFound] if the target environment does not exist
+    # @raise [MB::ChefConnectionError] if there was an error communicating to the Chef Server
+    #
+    # @example
+    #
+    #   {
+    #     "database_masters" => [
+    #       {
+    #         "name" => "db-master1",
+    #         ...
+    #       }
+    #     ],
+    #     "database_slaves" => [
+    #       {
+    #         "name" => "db-slave1",
+    #         ...
+    #       },
+    #       {
+    #         "name" => "db-slave2"
+    #         ...
+    #       }
+    #     ]
+    #   }
+    #
+    # @return [Hash]
+    def nodes(environment)
+      unless Application.ridley.environment.find(environment)
+        raise EnvironmentNotFound.new(environment)
+      end
+
+      {}.tap do |nodes|
+        self.groups.each do |group|
+          nodes[group.name] = group.nodes(environment)
+        end
+      end
+    end
+
+    def add_group(group)
+      self.groups.add(group)
+    end
+
+    # @param [MB::Command] command
+    def add_command(command)
+      self.commands.add(command)
+    end
+
+    # Returns the gears of class klass defined on this component.
+    #
+    # @param [MB::Gear] klass the class of the gears to find
+    #
+    # @return [Array<MB::Gear>]
+    def gears(klass)
+      @gears[klass.keyword] ||= Set.new
+    end
+
+    # Adds a gear to this component.
+    #
+    # @param [MB::Gear] gear the gear
+    def add_gear(gear)
+      klass = gear.class
+
+      unless get_gear(klass, gear.name).nil?
+        raise DuplicateGear, "#{klass.keyword.capitalize} '#{gear.name}' already defined"
+      end
+
+      gears(klass).add(gear)
+    end
+
+    # Finds a gear of class klass identified by *args.
+    #
+    # @param [MB::Gear] klass the class of the gear to search for
+    # @param [Array] args the identifiers for the gear to find
+    #
+    # @example searching for a service gear
+    #
+    #   get_gear(MB::Gear::Service, "service_name")
+    #
+    # @example searching for a jmx gear
+    #
+    #   get_gear(MB::Gear::Jmx)
+    #
+    # @return [MB::Gear]
+    def get_gear(klass, *args)
+      if klass.respond_to? :find
+        klass.find(gears(klass), *args)
+      else
+        klass.new(*args)
+      end
+    end
+
+    Gear.all.each do |klass|
+      define_method Gear.get_fun(klass) do |*args|
+        get_gear(klass, *args)
+      end
+    end
+
+    def get_service(name)
+      get_gear(MB::Gear::Service, name)
+    end
+
+    def to_s
+      "#{name}: #{description}"
+    end
+
+    private
+
+      def dsl_eval(&block)
+        CleanRoom.new(self).instance_eval(&block)
+      end
+
+    # @api private
+    class CleanRoom < CleanRoomBase
+      dsl_attr_writer :description
+      dsl_attr_writer :version_attribute
+
+      def versioned(attribute_name = nil)
+        version_attribute attribute_name || "#{@real_model.name}.version"
+      end
+      alias_method :versioned_with, :versioned
+
+      def group(name, &block)
+        real_model.add_group Group.new(name, &block)
+      end
+
+      def command(name, &block)
+        real_model.add_command Command.new(name, real_model, &block)
+      end
+
+      Gear.all.each do |klass|
+        define_method Gear.element_name(klass) do |*args, &block|
+          real_model.add_gear(klass.new(real_model, *args, &block))
+        end
+      end
+    end
+  end
+end