motherbrain 0.0.0.placeholder → 0.13.1

data/lib/mb/gears/service/action.rb

@@ -0,0 +1,58 @@
+module MotherBrain
+  module Gear
+    class Service
+      # @api private
+      class Action
+        include MB::Mixin::Services
+
+        # @return [String]
+        attr_reader :name
+
+        # @param [String] name
+        # @param [MB::Component] component
+        #
+        # @raise [ArgumentError] if no block is given
+        def initialize(name, component, &block)
+          unless block_given?
+            raise ArgumentError, "block required for action '#{name}' on component '#{component.name}'"
+          end
+
+          @name      = name
+          @component = component
+          @block     = block
+        end
+
+        # Run this action on the specified nodes.
+        #
+        # @param [MB::Job] job
+        #   a job to update with status
+        # @param [String] environment
+        #   the environment this command is being run on
+        # @param [Array<Ridley::Node>]
+        #   nodes the nodes to run this action on
+        #
+        # @return [Service::Action]
+        def run(job, environment, nodes, run_chef = true)
+          job.set_status("Running component: #{component.name} service action: #{name} on #{nodes.collect(&:name).join(', ')}")
+
+          runner = Service::ActionRunner.new(environment, nodes, &block)
+          runner.run(job)
+
+          if run_chef || runner.toggle_callbacks.any?
+            node_querier.bulk_chef_run(job, nodes, runner.service_recipe)
+          end
+
+          self
+        ensure
+          runner.reset(job)
+        end
+
+        private
+
+          attr_reader :component
+          attr_reader :runner
+          attr_reader :block
+      end
+    end
+  end
+end

data/lib/mb/gears/service/action_runner.rb

@@ -0,0 +1,161 @@
+module MotherBrain
+  module Gear
+    class Service
+      # @api private
+      class ActionRunner
+        include MB::Mixin::Services
+
+        attr_reader :environment
+        attr_reader :nodes
+        attr_reader :toggle_callbacks
+        attr_reader :service_recipe
+        attr_reader :environment_attributes
+        attr_reader :node_attributes
+
+        # @param [String] environment
+        # @param [Array<Ridley::Node>] nodes
+        def initialize(environment, nodes, &block)
+          @environment = environment
+          @nodes       = Array(nodes)
+
+          @environment_attributes = Array.new
+          @node_attributes        = Array.new
+          @toggle_callbacks       = Array.new
+
+          if block_given?
+            dsl_eval(&block)
+          end
+        end
+
+        def reset(job)
+          toggle_callbacks.concurrent_map { |callback| callback.call(job) }
+        end
+
+        def run(job)
+          set_node_attributes(job)
+          set_environment_attributes(job)
+        end
+
+        # Set an environment level attribute to the given value. The key is represented
+        # by a dotted path.
+        #
+        # @param [String] key
+        # @param [Object] value
+        #
+        # @option options [Boolean] :toggle (false)
+        #   set this environment attribute only for a single chef run
+        def add_environment_attribute(key, value, options = {})
+          @environment_attributes << { key: key, value: value, options: options }
+        end
+
+        # Set a node level attribute on all nodes for this action to the given value.
+        # The key is represented by a dotted path.
+        #
+        # @param [String] key
+        # @param [Object] value
+        #
+        # @option options [Boolean] :toggle (false)
+        #   set this node attribute only for a single chef run
+        def add_node_attribute(key, value, options)
+          @node_attributes << { key: key, value: value, options: options }
+        end
+
+        def set_service_recipe(recipe)
+          @service_recipe = recipe
+        end
+
+        private
+
+          def dsl_eval(&block)
+            CleanRoom.new(self).instance_eval(&block)
+          end
+
+          class CleanRoom < CleanRoomBase
+            dsl_attr_writer :component
+
+            def service_recipe(recipe)
+              real_model.set_service_recipe(recipe)
+            end
+
+            def environment_attribute(key, value, options = {})
+              options = options.reverse_merge(toggle: false)
+              real_model.add_environment_attribute(key, value, options)
+            end
+
+            def node_attribute(key, value, options = {})
+              options = options.reverse_merge(toggle: false)
+              real_model.add_node_attribute(key, value, options)
+            end
+          end
+
+          def set_environment_attributes(job)
+            return unless environment_attributes.any?
+
+            unless env_chef_object = ridley.environment.find(environment)
+              raise MB::EnvironmentNotFound.new(environment)
+            end
+
+            environment_attributes.each do |attribute|
+              key, value, options = attribute[:key], attribute[:value], attribute[:options]
+
+              if options[:toggle]
+                toggle_callbacks << ->(job) {
+                  message = "Toggling (removing) environment attribute '#{key}' on #{environment}"
+                  job.set_status(message)
+                  env_chef_object.delete_default_attribute(key)
+                  env_chef_object.save
+                }
+              end
+
+              job.set_status("Setting environment attribute '#{key}' to #{value.inspect} in #{environment}")
+              env_chef_object.set_default_attribute(key, value)
+            end
+
+            job.set_status("Saving environment #{environment}")
+            env_chef_object.save
+          end
+
+          # Set all node level attributes to the given node
+          #
+          # @param [Ridley::Job] job
+          #  a job to send status updates to
+          # @param [Ridley::NodeObject] node
+          #   the node to set the attribute on
+          def set_node_attributes(job)
+            return if node_attributes.empty?
+
+            nodes.concurrent_map do |node|
+              node.reload
+
+              node_attributes.each do |attribute|
+                key, value, options = attribute[:key], attribute[:value], attribute[:options]
+
+                if options[:toggle]
+                  original_value = node.chef_attributes.dig(key)
+
+                  toggle_callbacks << ->(job) {
+                    message = if original_value.nil?
+                      "Toggling off node attribute '#{key}' on #{node.name}"
+                    elsif !options[:force_value_to].nil?
+                      "Forcing node attribute to '#{options[:force_value_to]}' on #{node.name}"
+                    else
+                      "Toggling node attribute '#{key}' back to '#{original_value.inspect}' on #{node.name}"
+                    end
+                    job.set_status(message)
+                    value_to_set = options[:force_value_to].nil? ? original_value : options[:force_value_to]
+                    node.set_chef_attribute(key, value_to_set)
+                    node.save
+                  }
+                end
+
+                job.set_status("Setting node attribute '#{key}' to #{value.inspect} on #{node.name}")
+                node.set_chef_attribute(key, value)
+              end
+
+              node.save
+            end
+          end
+      end
+    end
+  end
+end

data/lib/mb/grape_ext.rb

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

data/lib/mb/grape_ext/endpoint.rb

@@ -0,0 +1,13 @@
+module Grape
+  class Endpoint
+    alias_method :old_params, :params
+
+    # Grape::Endpoint#params is an attr_reader that returns Grape::Request#params.
+    # The latter params method returns a Hashie::Mash with Strings as keys.
+    #
+    # https://github.com/intridea/grape/blob/v0.6.1/lib/grape/http/request.rb#L6
+    def params
+      old_params.to_hash.deep_symbolize_keys
+    end
+  end
+end

data/lib/mb/group.rb

@@ -0,0 +1,143 @@
+module MotherBrain
+  class Group
+    include VariaModel
+
+    attribute :name,
+      type: String,
+      required: true
+
+    # @return [Set]
+    attr_reader :roles
+    # @return [Set]
+    attr_reader :recipes
+    # @return [Hashie::Mash]
+    attr_reader :chef_attributes
+
+    # @param [#to_s] name
+    def initialize(name, &block)
+      set_attribute(:name, name.to_s)
+      @recipes         = Set.new
+      @roles           = Set.new
+      @chef_attributes = Hashie::Mash.new
+
+      if block_given?
+        dsl_eval(&block)
+      end
+    end
+
+    # @return [Symbol]
+    def id
+      self.name.to_sym
+    end
+
+    # Returns an Array Ridley::Node objects from Chef that match this {Group}'s
+    # signature.
+    #
+    # A signature is any combination of a recipe(s) or role(s) in a node's run_list or
+    # an attribute(s) on a node.
+    #
+    # @param [#to_s] environment
+    #
+    # @return [Array<Ridley::Node>]
+    def nodes(environment)
+      Application.ridley.partial_search(:node, search_query(environment), [ "public_ipv4", "public_hostname" ])
+    end
+
+    # Returns an escape search query for Solr from the roles, rescipes, and chef_attributes
+    # assigned to this Group.
+    #
+    # @param [#to_s] environment
+    #
+    # @return [String]
+    def search_query(environment)
+      items = ["chef_environment:#{environment}"]
+
+      items += chef_attributes.collect do |key, value|
+        key = key.gsub(/\./, "_")
+        "#{attribute_escape(key)}:#{value}"
+      end
+
+      items += roles.collect { |role| "roles:#{solr_escape(role)}" }
+      items += recipes.collect { |recipe| "recipes:#{solr_escape(recipe)}" }
+
+      items.join(' AND ')
+    end
+
+    def add_role(name)
+      self.roles.add(name)
+    end
+
+    def add_recipe(name)
+      self.recipes.add(name)
+    end
+
+    def add_chef_attribute(key, value)
+      if chef_attribute(key).present?
+        raise DuplicateChefAttribute, "An attribute '#{key}' has already been defined on group '#{_attributes_[:name]}'"
+      end
+
+      self.chef_attributes[key] = value
+    end
+
+    # @param [#to_sym] name
+    def chef_attribute(name)
+      self.chef_attributes.fetch(name.to_sym, nil)
+    end
+
+    # Combines the recipes and roles of this group into a run_list that can be passed to
+    # Chef or Ridley
+    #
+    #   [ "role[web_server]", "recipe[nginx::default]" ]
+    #
+    # @return [Array<String>]
+    def run_list
+      self.roles.collect { |role| "role[#{role}]" } +
+        self.recipes.collect { |recipe| "recipe[#{recipe}]" }
+    end
+
+    # Indicates whether the run list contains the recipe
+    #
+    # @return [TrueClass, FalseClass]
+    def includes_recipe?(recipe)
+      # todo expand roles?
+      self.run_list.include?("#{recipe}")
+    end
+
+    private
+
+      def dsl_eval(&block)
+        CleanRoom.new(self).instance_eval(&block)
+      end
+
+      def attribute_escape(value)
+        value.gsub(/\./, "_")
+      end
+
+      def solr_escape(value)
+        value.gsub(/[\:\[\]\+\!\^\(\)\{\}]/) { |x| "\\#{x}" }
+      end
+
+    # @api private
+    class CleanRoom < CleanRoomBase
+      # @param [#to_s] value
+      #
+      # @return [Set<String>]
+      def recipe(value)
+        real_model.add_recipe(value.to_s)
+      end
+
+      # @param [#to_s] value
+      #
+      # @return [Set<String>]
+      def role(value)
+        real_model.add_role(value.to_s)
+      end
+
+      # @param [#to_s] attr_key
+      # @param [Object] attr_value
+      def chef_attribute(attr_key, attr_value)
+        real_model.add_chef_attribute(attr_key, attr_value)
+      end
+    end
+  end
+end

data/lib/mb/job.rb

@@ -0,0 +1,183 @@
+module MotherBrain
+  # A Celluloid actor representing an active job. Jobs are handled by the {JobManager}
+  # and should not be returned to a consumer or user from the Public API.
+  #
+  # Jobs start in the 'pending' state and can only be in any one state at a given
+  # time. A Job is completed when in the 'success' or 'failure' state.
+  #
+  # The progress of a Job is recorded by the {JobManager} as a {JobRecord}. API
+  # consumers should reference the status of a running Job by it's {JobRecord}.
+  #
+  # Returning a {JobTicket} from the Public API will give a consumer or user an easy
+  # way to check the status of a job by polling a Job's {JobRecord}.
+  #
+  # @example running a job and checking it's status
+  #
+  #   job = Job.new('example_job')
+  #   ticket = job.ticket
+  #
+  #   ticket.completed? => false
+  #   ticket.state => :pending
+  #
+  #   job.transition(:success, 'done!')
+  #
+  #   ticket.completed? => true
+  #   ticket.state => :success
+  #
+  # @api private
+  class Job
+    autoload :StateMachine, 'mb/job/state_machine'
+    autoload :States, 'mb/job/states'
+
+    extend Forwardable
+
+    include Celluloid
+    include MB::Logging
+    include MB::Job::States
+    include MB::Mixin::Services
+
+    attr_reader :id
+    attr_reader :type
+    attr_reader :result
+
+    # Set when the state of the Job changes from 'pending' to 'running'
+    #
+    # @note do not modify outside of the state machine
+    #
+    # @return [Time]
+    attr_accessor :time_start
+
+    # Set when the state of the Job changes from 'running' to 'sucess' or 'failure'
+    #
+    # @note do not modify outside of the state machine
+    #
+    # @return [Time]
+    attr_accessor :time_end
+
+    def_delegator :machine, :state
+
+    finalizer :finalize_callback
+
+    # @param [#to_s] type
+    def initialize(type)
+      @machine = StateMachine.new
+      @type    = type.to_s
+      @id      = job_manager.uuid
+      @result  = nil
+      job_manager.add(Actor.current)
+    end
+
+    # @param [#to_json] result
+    #   a result which can be converted to JSON
+    # @param [Hash] options
+    #   options to pass to the state machine transition
+    #
+    # @return [Job]
+    def report_failure(result = nil, options = {})
+      log.fatal { "Job (#{id}) failure: #{result}" }
+      transition(:failure, result, options)
+    end
+
+    # @param [#to_json] result
+    #   a result which can be converted to JSON
+    # @param [Hash] options
+    #   options to pass to the state machine transition
+    #
+    # @return [Job]
+    def report_pending(result = nil, options = {})
+      log.info { "Job (#{id}) pending: #{result}" }
+      transition(:pending, result, options)
+    end
+
+    # @param [#to_json] result
+    #   a result which can be converted to JSON
+    # @param [Hash] options
+    #   options to pass to the state machine transition
+    #
+    # @return [Job]
+    def report_running(result = nil, options = {})
+      log.info { "Job (#{id}) running: #{result}" }
+      transition(:running, result, options)
+    end
+
+    # @param [#to_json] result
+    #   a result which can be converted to JSON
+    # @param [Hash] options
+    #   options to pass to the state machine transition
+    #
+    # @return [Job]
+    def report_success(result = nil, options = {})
+      log.info { "Job (#{id}) success: #{result}" }
+      transition(:success, result, options)
+    end
+
+    # @param [Boolean] boolean
+    #   a boolean value representing a success or failure
+    # @param [#to_json] result
+    #   a result which can be converted to JSON
+    # @param [Hash] options
+    #   options to pass to the state machine transition
+    #
+    # @return [Job]
+    def report_boolean(boolean, result = nil, options = {})
+      if boolean
+        report_success(result, options)
+      else
+        report_failure(result, options)
+      end
+    end
+
+    # @return [self]
+    def save
+      job_manager.update(Actor.current)
+    end
+
+    def status
+      @status || state.to_s.capitalize
+    end
+
+    def status=(string)
+      log.info { "Job (#{id}) status: #{string}" }
+      @status = string
+      status_buffer << string
+      save
+    end
+    alias_method :set_status, :status=
+
+    def status_buffer
+      @status_buffer ||= []
+    end
+
+    # @return [JobTicket]
+    def ticket
+      @ticket ||= JobTicket.new(id)
+    end
+
+    # @param [Symbol] state
+    #   the state to transition to in the Job's state machine
+    # @param [#cause, #to_s] result
+    #   a result which can be converted to JSON
+    # @param [Hash] options
+    #   options to pass to the state machine transition
+    #
+    # @return [Job]
+    def transition(state, result = nil, options = {})
+      @result = result.respond_to?(:cause) ? result.cause : result
+      machine.transition(state, options)
+      Actor.current
+    end
+
+    def to_s
+      "#<Job @type=#{type.inspect} @machine.state=#{state.inspect}>"
+    end
+    alias_method :inspect, :to_s
+
+    private
+
+      attr_reader :machine
+
+      def finalize_callback
+        job_manager.async.complete_job(Actor.current)
+      end
+  end
+end