motherbrain 0.0.0.placeholder → 0.13.1

data/lib/mb/chef_mutex.rb

@@ -0,0 +1,304 @@
+module MotherBrain
+  # Allows for motherbrain clients to lock a chef resource. A mutex is created
+  # with a type and name. Sending #lock to the mutex will then store a data bag
+  # item with mutex, the requestor's client_name, and the current time. An
+  # attempt to lock an already-locked mutex will fail if the lock is owned by
+  # someone else, or succeed if the lock is owned by the current user.
+  #
+  # @example Creating a mutex and obtaining a lock
+  #
+  #   mutex = ChefMutex.new(chef_environment: "my_environment")
+  #
+  #   mutex.lock # => true
+  #   # do stuff
+  #   mutex.unlock # => true
+  #
+  # @example Running a block within an obtained lock
+  #
+  #   mutex = ChefMutex.new(chef_environment: "my_environment")
+  #
+  #   mutex.synchronize do
+  #     # do stuff
+  #   end
+  #
+  class ChefMutex
+    class << self
+      # Create a new ChefMutex and run the given block of code within it. Terminate the
+      # ChefMutex after the block of code finishes executing.
+      #
+      # @see {ChefMutex#initialize}, {ChefMutex#synchronize}
+      def synchronize(options, &block)
+        mutex = new(options)
+        mutex.synchronize(&block)
+      ensure
+        mutex.terminate
+      end
+    end
+
+    include Celluloid
+    include Celluloid::Notifications
+    include MB::Logging
+    include MB::Mixin::Services
+
+    extend Forwardable
+
+    DATA_BAG = "_motherbrain_locks_".freeze
+
+    LOCK_TYPES = [
+      :chef_environment
+    ]
+
+    attr_reader :type
+    attr_reader :name
+
+    attr_reader :force
+    attr_reader :job
+    attr_reader :report_job_status
+    attr_reader :unlock_on_failure
+
+    execute_block_on_receiver :synchronize
+
+    finalizer :finalize_callback
+
+    # @option options [#to_s] :chef_environment
+    #   The name of the environment to lock
+    # @option options [Boolean] :force (false)
+    #   Force the lock to be written, even if it already exists.
+    # @option options [MotherBrain::Job] :job
+    #   A job that will receive status updates during lock/unlock
+    # @option options [Boolean] :report_job_status (false)
+    # @option options [Boolean] :unlock_on_failure (true)
+    #   If false and the block raises an error, the lock will persist.
+    def initialize(options = {})
+      options = options.reverse_merge(
+        force: false,
+        unlock_on_failure: true
+      )
+
+      type, name = options.find { |key, value| LOCK_TYPES.include? key }
+
+      @type              = type
+      @name              = name
+      @force             = options[:force]
+      @job               = options[:job]
+      @report_job_status = options[:report_job_status]
+      @unlock_on_failure = options[:unlock_on_failure]
+
+      lock_manager.register(Actor.current)
+    end
+
+    # @return [String]
+    def data_bag_id
+      result = to_s.dup
+
+      result.downcase!
+      result.gsub! /[^\w]+/, "-" # dasherize
+      result.gsub! /^-+|-+$/, "" # remove dashes from beginning/end
+
+      result
+    end
+
+    # @return [String]
+    def to_s
+      "#{type}:#{name}"
+    end
+
+    # Attempts to create a lock. Fails if the lock already exists.
+    #
+    # @return [Boolean]
+    def lock
+      unless type
+        raise InvalidLockType, "Must pass a valid lock type (#{LOCK_TYPES})"
+      end
+
+      log.info { "Locking #{to_s}" }
+
+      if job
+        job.set_status "Locking #{to_s}"
+        job.report_running if report_job_status
+      end
+
+      report(attempt_lock)
+    end
+
+    # Returns whether or not the object is locked.
+    #
+    # @return [Boolean]
+    def locked?
+      !!read
+    end
+
+    # Obtains a lock, runs the block, and releases the lock when the block
+    # completes. Raises a ResourceLocked error if the lock was unobtainable.
+    # If the block raises an error, the resource is unlocked, unless
+    # unlock_on_failure: true is passed in to the option hash.
+    #
+    # @raise [MotherBrain::ResourceLocked] if the lock is unobtainable
+    #
+    # @return [Boolean]
+    def synchronize
+      unless lock
+        current_lock = read
+
+        err = "Resource #{current_lock['id']} locked by #{current_lock['client_name']}"
+        err << " since #{current_lock['time']} (PID #{current_lock['process_id']})"
+
+        raise ResourceLocked.new(err)
+      end
+
+      yield
+
+      unlock
+    rescue => ex
+      ex = ex.respond_to?(:cause) ? ex.cause : ex
+
+      unless ex.is_a?(ResourceLocked)
+        unlock if unlock_on_failure
+      end
+
+      abort(ex)
+    end
+
+    # Attempts to unlock the lock. Fails if the lock doesn't exist, or if it is
+    # held by someone else
+    #
+    # @return [Boolean]
+    def unlock
+      if job
+        job.report_running if report_job_status
+        job.set_status("Unlocking #{to_s}")
+      end
+
+      attempt_unlock
+
+      report(true)
+    end
+
+    private
+
+      def finalize_callback
+        lock_manager.async.unregister(Actor.current) if lock_manager.alive?
+      end
+
+      # Reports a job status
+      # @param [Object] result
+      # @return [Object] result
+      def report(result)
+        if job && report_job_status
+          job.report_boolean(result)
+        end
+
+        result
+      end
+
+      # Check to see if the passed in lock was created by us
+      #
+      # @param [Hash] current_lock the lock data obtained from #read
+      # @return [Boolean]
+      def our_lock?(current_lock)
+        return nil unless current_lock
+        return false unless current_lock["client_name"] == client_name
+        return false unless current_lock["process_id"] == Process.pid
+        true
+      end
+
+      # @return [Boolean]
+      def attempt_lock
+        unless self.force
+          current_lock = read
+          return our_lock?(current_lock) if current_lock
+        end
+
+        write
+      end
+
+      # @return [Boolean]
+      def attempt_unlock
+        unless self.force
+          current_lock = read
+
+          return unless current_lock && our_lock?(current_lock)
+        end
+
+        delete
+      end
+
+      # @return [String]
+      def client_name
+        Application.ridley.client_name
+      end
+
+      # @return [Ridley::ChainLink]
+      def data_bag
+        Application.ridley.data_bag
+      end
+
+      # Delete the lock from the data bag.
+      #
+      # @return [Boolean]
+      def delete
+        return true unless locks
+
+        result = locks.delete(data_bag_id)
+
+        lock_manager.unregister(Actor.current)
+
+        result
+      rescue
+        lock_manager.register(Actor.current)
+      end
+
+      # Create our data bag if it doesn't already exist
+      def ensure_data_bag_exists
+        data_bag.create(name: DATA_BAG) unless locks
+      end
+
+      # @return [Ridley::DBIChainLink] if the data bag exists
+      # @return [nil] if it does not
+      def locks
+        result = data_bag.find(DATA_BAG)
+
+        return unless result
+
+        result.item
+      end
+
+      # Read the lock from the data bag.
+      #
+      # @return [Hash] if the lock exists
+      # @return [nil] if it does not
+      def read
+        return unless locks
+
+        result = locks.find(data_bag_id)
+
+        result.to_hash if result
+      end
+
+      def unregister_lock
+        lock_manager.unregister(Actor.current)
+      end
+
+      # Write the lock to the data bag.
+      #
+      # @return [Boolean]
+      def write
+        ensure_data_bag_exists
+
+        result = locks.new(
+          id: data_bag_id,
+          type: type,
+          name: name,
+          client_name: client_name,
+          process_id: Process.pid,
+          time: Time.now
+        ).save
+
+        lock_manager.register(Actor.current)
+
+        result
+      rescue
+        lock_manager.unregister(Actor.current)
+      end
+  end
+end

data/lib/mb/clean_room_base.rb

@@ -0,0 +1,39 @@
+module MotherBrain
+  class CleanRoomBase
+    class << self
+      # Create a DSL writer function that will assign the a given value
+      # to the real object of this clean room.
+      #
+      # @param [Symbol] attribute
+      def dsl_attr_writer(attribute)
+        class_eval do
+          define_method(attribute) do |value|
+            set_attribute(attribute, value)
+          end
+        end
+      end
+    end
+
+    include MB::Logging
+
+    # @param [Object] real_model
+    def initialize(real_model, &block)
+      @real_model = real_model
+    end
+
+    private
+
+      attr_reader :real_model
+
+      def set_attribute(name, value)
+        real_model.send("#{name}=", value)
+      end
+
+      def method_missing(method_name, *args, &block)
+        ErrorHandler.wrap PluginSyntaxError,
+          backtrace: caller,
+          method_name: method_name,
+          text: "'#{method_name}' is not a valid keyword"
+      end
+  end
+end

data/lib/mb/cli.rb

@@ -0,0 +1,50 @@
+module MotherBrain
+  module Cli
+    autoload :Base, 'mb/cli/base'
+    autoload :Shell, 'mb/cli/shell'
+    autoload :SubCommand, 'mb/cli/sub_command'
+
+    # This is the main entry point for the CLI. It exposes the method {#execute!} to
+    # start the CliGateway.
+    #
+    # @note the arity of {#initialize} and {#execute!} are extremely important for testing purposes. It
+    #   is a requirement to perform in-process testing with Aruba. In process testing is much faster
+    #   than spawning a new Ruby process for each test.
+    class Runner
+      # @param [Array] argv
+      # @param [IO] stdin
+      # @param [IO] stdout
+      # @param [IO] stderr
+      # @param [Kernel] kernel
+      def initialize(argv, stdin = STDIN, stdout = STDOUT, stderr = STDERR, kernel = Kernel)
+        @argv, @stdin, @stdout, @stderr, @kernel = argv, stdin, stdout, stderr, kernel
+      end
+
+      # Start the CLI Gateway
+      def execute!
+        MB::CliGateway.start(@argv)
+      rescue MBError => ex
+        ui.error ex
+        @kernel.exit(ex.exit_code)
+      rescue Ridley::Errors::ConnectionFailed => ex
+        ui.error "[ERROR] Unable to connect to the configured Chef server: #{ex.message}."
+        ui.error "[ERROR] Check your configuration and network settings and try again."
+        @kernel.exit(MB::ChefConnectionError.exit_code)
+      rescue Thor::Error => ex
+        ui.error ex.message
+        @kernel.exit(1)
+      rescue Errno::EPIPE
+        # This happens if a thor command is piped to something like `head`,
+        # which closes the pipe when it's done reading. This will also
+        # mean that if the pipe is closed, further unnecessary
+        # computation will not occur.
+        @kernel.exit(0)
+      end
+
+      # @return [MB::Cli::Shell::Color, MB::Cli::Shell::Basic]
+      def ui
+        @ui ||= MB::Cli::Shell.shell.new
+      end
+    end
+  end
+end

data/lib/mb/cli/base.rb

@@ -0,0 +1,51 @@
+module MotherBrain
+  module Cli
+    class Base < Thor
+      include Thor::Actions
+      include MB::Mixin::CodedExit
+      include MB::Mixin::Services
+
+      class << self
+        # Registers a SubCommand with this Cli::Base class
+        #
+        # @param [MB::Cli::SubCommand] klass
+        def register_subcommand(klass)
+          self.register(klass, klass.name.gsub('-', '_'), klass.usage.gsub('-', '_'), klass.description)
+        end
+
+        # @return [MB::Cli::Shell::Color, MB::Cli::Shell::Basic]
+        def ui
+          @ui ||= MB::Cli::Shell.shell.new
+        end
+      end
+
+      no_tasks do
+        # @param [MB::Job] job
+        def display_job(job)
+          CliClient.new(job).display
+        end
+        # @note from Jamie: Increased verbosity for Michael Ivey. This is pretty much the most important line of code
+        #   in this entire codebase so DO NOT REMOVE.
+        alias_method :display_job_status_and_wait_until_it_is_done_while_providing_user_feedback, :display_job
+
+        # @return [MB::Cli::Shell::Color, MB::Cli::Shell::Basic]
+        def ui
+          self.class.ui
+        end
+
+        def requires_one_of(*valid_options)
+          valid_options = valid_options.flatten
+
+          return if options.slice(*valid_options).any?
+
+          valid_cli_arguments = valid_options.map { |key|
+            key.to_s.dasherize.prepend('--')
+          }
+
+          ui.say "Requires one of #{valid_cli_arguments.join(', ')}"
+          exit 1
+        end
+      end
+    end
+  end
+end

data/lib/mb/cli/shell.rb

@@ -0,0 +1,29 @@
+module MotherBrain
+  module Cli
+    module Shell
+      autoload :Basic, 'mb/cli/shell/basic'
+      autoload :Color, 'mb/cli/shell/color'
+      autoload :Ext, 'mb/cli/shell/ext'
+
+      class << self
+        attr_writer :shell
+
+        # Returns the shell used in the motherbrain CLI. If you are in a Unix platform
+        # it will use a colored shell, otherwise it will use a color-less one.
+        #
+        # @return [Shell::Basic, Shell::Color]
+        def shell
+          @shell ||= if ENV['MB_SHELL'] && ENV['MB_SHELL'].size > 0
+            Shell.const_get(ENV['MB_SHELL'].capitalize)
+          elsif Buff::Platform.windows? && !ENV['ANSICON']
+            Shell::Basic
+          else
+            Shell::Color
+          end
+        end
+      end
+
+      ::Thor::Base.shell = shell
+    end
+  end
+end