motherbrain 0.0.0.placeholder → 0.13.1

data/lib/mb/job/state_machine.rb

@@ -0,0 +1,34 @@
+module MotherBrain
+  class Job
+    # An FSM for {Job}. During each transition the Job will be instructed to save
+    #
+    # @api private
+    class StateMachine
+      include Celluloid::FSM
+      include MB::Logging
+
+      state :pending, to: [ :running, :failure ], default: true do
+        log.debug { "job (#{actor.id}) transitioning to '#{state}'" }
+        actor.save
+      end
+
+      state :running, to: [ :success, :failure ] do
+        log.debug { "job (#{actor.id}) transitioning to '#{state}'" }
+        actor.time_start = Time.now
+        actor.save
+      end
+
+      state :success do
+        log.debug { "job (#{actor.id}) transitioning to '#{state}'" }
+        actor.time_end = Time.now
+        actor.save
+      end
+
+      state :failure do
+        log.debug { "job (#{actor.id}) transitioning to '#{state}'" }
+        actor.time_end = Time.now
+        actor.save
+      end
+    end
+  end
+end

data/lib/mb/job/states.rb

@@ -0,0 +1,46 @@
+module MotherBrain
+  class Job
+    # A mixin to provide helper functions around the state of a Job, JobRecord, or
+    # JobTicket. The helper functions are based on states set by {Job::StateMachine}
+    module States
+      attr_reader :state
+
+      # If a job has succeeded or failed it considered completed
+      #
+      # @return [Boolean]
+      def completed?
+        self.success? || self.failure?
+      end
+      alias_method :finished?, :completed?
+
+      # If a job has failed it is considered a failure
+      #
+      # @return [Boolean]
+      def failure?
+        self.state == :failure
+      end
+      alias_method :failed?, :failure?
+
+      # If a job has not begun and is in the pending state it is considered pending
+      #
+      # @return [Boolean]
+      def pending?
+        self.state == :pending
+      end
+
+      # If a job has begun running and is in the running state it is considered running
+      #
+      # @return [Boolean]
+      def running?
+        self.state == :running
+      end
+
+      # If a job has succeeded it is considered a success
+      #
+      # @return [Boolean]
+      def success?
+        self.state == :success
+      end
+    end
+  end
+end

data/lib/mb/job_manager.rb

@@ -0,0 +1,96 @@
+module MotherBrain
+  class JobManager
+    class << self
+      # @raise [Celluloid::DeadActorError] if job manager has not been started
+      #
+      # @return [Celluloid::Actor(JobManager)]
+      def instance
+        MB::Application[:job_manager] or raise Celluloid::DeadActorError, "job manager not running"
+      end
+
+      def running?
+        MB::Application[:job_manager] && instance.alive?
+      end
+
+      def stopped?
+        !running?
+      end
+    end
+
+    include Celluloid
+    include MB::Logging
+
+    trap_exit :force_complete
+
+    # @return [Set<JobRecord>]
+    #   listing of records of all jobs; completed and active
+    attr_reader :records
+    alias_method :list, :records
+
+    finalizer :finalize_callback
+
+    def initialize
+      log.debug { "Job Manager starting..." }
+      @records = Set.new
+      @_active = Set.new
+    end
+
+    # Track and record the given job
+    #
+    # @param [Job] job
+    def add(job)
+      @_active.add(job)
+      records.add JobRecord.new(job)
+      monitor(job)
+    end
+
+    # Complete the given active job
+    #
+    # @param [Job] job
+    def complete_job(job)
+      @_active.delete(job)
+    end
+
+    # listing of all active jobs
+    #
+    # @return [Set<JobRecord>]
+    def active
+      active_ids = @_active.collect {|j| j.id }
+      records.select {|r| active_ids.include?(r.id) }
+    end
+
+    # @param [String] id
+    def find(id)
+      records.find { |record| record.id == id }
+    end
+
+    # Update the record for the given Job
+    #
+    # @param [Job] job
+    def update(job)
+      find(job.id).update(job)
+    end
+
+    def terminate_active
+      @_active.map { |job| job.terminate if job.alive? }
+    end
+
+    # Generate a new Job ID
+    #
+    # @return [String]
+    def uuid
+      Celluloid::UUID.generate
+    end
+
+    private
+
+      def finalize_callback
+        log.debug { "Job Manager stopping..." }
+        terminate_active
+      end
+
+      def force_complete(actor, reason)
+        complete_job(actor)
+      end
+  end
+end

data/lib/mb/job_record.rb

@@ -0,0 +1,67 @@
+module MotherBrain
+  class JobRecord
+    include MB::Job::States
+
+    attr_reader :id
+
+    attr_reader :result
+    attr_reader :state
+    attr_reader :status
+    attr_reader :status_buffer
+    attr_reader :type
+
+    attr_reader :time_start
+    attr_reader :time_end
+
+    # @param [Job] job
+    def initialize(job)
+      @id = job.id
+      mass_assign(job)
+    end
+
+    # Update the instantiated JobRecord with the attributes of the given Job
+    #
+    # @param [Job] job
+    #   the updated job to update the record with
+    #
+    # @return [self]
+    def update(job)
+      mass_assign(job)
+      self
+    end
+
+    # @return [Hash]
+    def to_hash
+      {
+        id: id,
+        type: type,
+        state: state,
+        status: status,
+        result: result,
+        time_start: time_start,
+        time_end: time_end
+      }
+    end
+
+    # @param [Hash] options
+    #   a set of options to pass to MultiJson.encode
+    #
+    # @return [String]
+    def to_json(options = {})
+      MultiJson.encode(self.to_hash, options)
+    end
+
+    private
+
+      # @param [Job] job
+      def mass_assign(job)
+        @result        = job.result
+        @state         = job.state
+        @status        = job.status
+        @status_buffer = job.status_buffer
+        @time_end      = job.time_end
+        @time_start    = job.time_start
+        @type          = job.type
+      end
+  end
+end

data/lib/mb/job_ticket.rb

@@ -0,0 +1,25 @@
+module MotherBrain
+  # A proxy object around a {JobRecord} stored in the {JobManager}. This wrapper object can
+  # be returned as a response of the public API to a consumer. A ticket will poll it's
+  # referenced {JobRecord} in the {JobManager} for an update about a running or completed {Job}
+  #
+  # @api public
+  class JobTicket < BasicObject
+    attr_reader :id
+
+    # @param [Integer] id
+    def initialize(id)
+      @id = id
+    end
+
+    private
+
+      def record
+        JobManager.instance.find(id)
+      end
+
+      def method_missing(method, *args, &block)
+        record.send(method, *args, &block)
+      end
+  end
+end

data/lib/mb/lock_manager.rb

@@ -0,0 +1,116 @@
+module MotherBrain
+  # A registry of locks obtained against resources on a Chef Server
+  class LockManager
+    class << self
+      # @raise [Celluloid::DeadActorError] if lock manager has not been started
+      #
+      # @return [Celluloid::Actor(LockManager)]
+      def instance
+        MB::Application[:lock_manager] or raise Celluloid::DeadActorError, "lock manager not running"
+      end
+    end
+
+    include Celluloid
+    include MB::Logging
+
+    # @return [Set<ChefMutex>]
+    attr_reader :locks
+
+    finalizer :finalize_callback
+
+    def initialize
+      log.debug { "Lock Manager starting..." }
+      @locks = Set.new
+    end
+
+    # Find a lock of the given name in the list of registered locks
+    #
+    # @see ChefMutex#initialize
+    #
+    # @return [ChefMutex, nil]
+    def find(options)
+      type, name = options.to_a.flatten
+
+      locks.find { |mutex|
+        mutex.type == type &&
+        mutex.name == name
+      }
+    end
+
+    # Register the given lock
+    #
+    # @param [ChefMutex] mutex
+    def register(mutex)
+      locks.add(mutex)
+    end
+
+    def reset
+      self.locks.clear
+    end
+
+    # Unregister the given lock
+    #
+    # @param [ChefMutex] mutex
+    def unregister(mutex)
+      locks.delete(mutex)
+    end
+
+    # Asynchronously lock an environment
+    #
+    # @param [String] environment
+    #
+    # @return [MB::JobRecord]
+    def async_lock(environment)
+      job = Job.new(:lock)
+      async(:lock, job, environment)
+      job.ticket
+    end
+
+    # Lock an environment
+    #
+    # @param [MB::Job] job
+    # @param [String] environment
+    #
+    # @return [Boolean]
+    def lock(job, environment)
+      ChefMutex.new(
+        chef_environment: environment,
+        force: true,
+        job: job,
+        report_job_status: true
+      ).lock
+    end
+
+    # Asynchronously unlock an environment
+    #
+    # @param [String] environment
+    #
+    # @return [MB::JobRecord]
+    def async_unlock(environment)
+      job = Job.new(:unlock)
+      async(:unlock, job, environment)
+      job.ticket
+    end
+
+    # Unlock an environment
+    #
+    # @param [MB::Job] job
+    # @param [String] environment
+    #
+    # @return [Boolean]
+    def unlock(job, environment)
+      ChefMutex.new(
+        chef_environment: environment,
+        force: true,
+        job: job,
+        report_job_status: true
+      ).unlock
+    end
+
+    private
+
+      def finalize_callback
+        log.debug { "Lock Manager stopping..." }
+      end
+  end
+end

data/lib/mb/logging.rb

@@ -0,0 +1,134 @@
+require 'logger'
+
+module MotherBrain
+  module Logging
+    autoload :BasicFormat, 'mb/logging/basic_format'
+    include Logger::Severity
+
+    class << self
+      include Logger::Severity
+
+      # Places the arguments given surrounded by whitespace at the top of the
+      # logfile. This makes it easier to scan logs for the beginning of a
+      # command.
+      def add_argument_header
+        return if dev == STDOUT
+
+        logger.unknown nil
+        logger.unknown nil
+        logger.unknown ARGV.join(" ")
+        logger.unknown nil
+      end
+
+      # Returns the currrent logging device
+      #
+      # @return [IO, nil]
+      def dev
+        logdev.dev
+      end
+
+      # Returns the filename of the current logger
+      #
+      # @return [String, nil]
+      def filename
+        logdev.filename
+      end
+
+      # @return [Logger]
+      def logger
+        @logger ||= setup
+      end
+
+      # @return [nil]
+      def reset
+        @logger = nil
+        @preserved_options = nil
+      end
+
+      # @option options [String, Integer] :level (INFO)
+      # @option options [String, IO] :location
+      #
+      # @return [Logger]
+      def setup(options = {})
+        options = options.keep_if { |key, value| value }
+        options = preserve(options).reverse_merge(
+          level: INFO,
+          location: FileSystem.logs.join('application.log')
+        )
+
+        level    = options[:level].is_a?(String) ? options[:level].upcase : options[:level]
+        location = options[:location]
+
+        if %w[DEBUG INFO WARN ERROR FATAL].include?(level)
+          level = const_get(level)
+        end
+
+        if %w[STDERR STDOUT].include?(location)
+          location = location.constantize
+        end
+
+        unless [STDERR, STDOUT].include?(location)
+          setup_logdir(location)
+        end
+
+        if jruby? && location.is_a?(Pathname)
+          location = location.to_s
+        end
+
+        @logger = Ridley::Logging::Logger.new(location).tap do |log|
+          log.level = level
+          log.formatter = BasicFormat.new
+        end
+
+        Ridley.logger = @logger
+        Celluloid.logger = ENV["DEBUG_CELLULOID"] ? @logger : nil
+
+        @logger
+      end
+
+      # @param [Logger, nil] obj
+      #
+      # @return [Logger]
+      def set_logger(obj)
+        @logger = (obj.nil? ? Logger.new('/dev/null') : obj)
+      end
+
+      private
+
+        def logdev
+          logger.instance_variable_get(:@logdev)
+        end
+
+        # Stores and returns an updated hash, so that #setup can be called
+        # multiple times
+        #
+        # @param [Hash] options
+        #
+        # @return [Hash]
+        def preserve(options)
+          @preserved_options ||= Hash.new
+          @preserved_options.reverse_merge! options
+        end
+
+        def setup_logdir(location)
+          FileUtils.mkdir_p(File.dirname(location), mode: 0755)
+        end
+    end
+
+    # @return [Logger]
+    def logger
+      MB::Logging.logger
+    end
+    alias_method :log, :logger
+
+    # Log an exception and it's backtrace to FATAL
+    #
+    # @param [Exception] ex
+    def log_exception(ex)
+      ex = ex.respond_to?(:cause) ? ex.cause : ex
+
+      log.fatal { "#{ex.class}: #{ex}" }
+      log.fatal { ex.backtrace.join("\n") } unless ex.backtrace.nil?
+    end
+  end
+end