motherbrain 0.0.0.placeholder → 0.13.1

data/lib/mb/file_system.rb

@@ -0,0 +1,60 @@
+require 'tmpdir'
+
+module MotherBrain
+  module FileSystem
+    autoload :Tempfile, 'mb/file_system/tempfile'
+
+    class << self
+      # Create the directory structure for motherbrain
+      def init
+        FileUtils.mkdir_p(logs)
+        FileUtils.mkdir_p(manifests)
+        FileUtils.mkdir_p(root)
+        FileUtils.mkdir_p(templates)
+        FileUtils.mkdir_p(tmp)
+      end
+
+      # @return [Pathname]
+      def logs
+        root.join("logs")
+      end
+
+      # @return [Pathname]
+      def manifests
+        root.join("manifests")
+      end
+
+      # @return [Pathname]
+      def root
+        Pathname.new(default_root_path)
+      end
+
+      # @return [Pathname]
+      def tmp
+        root.join("tmp")
+      end
+
+      # @return [Pathname]
+      def templates
+        root.join("templates")
+      end
+
+      # Create a temporary directory in the tmp directory of the motherbrain
+      # file system
+      #
+      # @param [String] prefix (nil)
+      #   a prefix suffix to attach to name of the generated directory
+      #
+      # @return [String]
+      def tmpdir(prefix = nil)
+        Dir.mktmpdir(prefix, tmp)
+      end
+
+      private
+
+        def default_root_path
+          File.expand_path(ENV["MOTHERBRAIN_PATH"] || "~/.mb")
+        end
+    end
+  end
+end

data/lib/mb/file_system/tempfile.rb

@@ -0,0 +1,25 @@
+require 'tempfile'
+
+module MotherBrain
+  module FileSystem
+    # Thin wrapper around ::Tempfile to ensure we always write temporary files
+    # into motherbrain's configured temporary directory
+    class Tempfile < ::Tempfile
+      BASENAME = 'mb_'.freeze
+
+      class << self
+        # @param [Hash] options
+        #   options to pass to ::Tempfile.open
+        def open(options = {})
+          super(options)
+        end
+      end
+
+      # @param [Hash] options
+      #   options to pass to ::Tempfile.new
+      def initialize(options = {})
+        super(BASENAME, FileSystem.tmpdir, options)
+      end
+    end
+  end
+end

data/lib/mb/gear.rb

@@ -0,0 +1,154 @@
+module MotherBrain
+  # The base module for defining new Gears for a plugin. Any class including this module
+  # and registered with {MotherBrain} as a {Gear} will be available for use in the plugin DSL.
+  #
+  # Gears represent the proverbial knobs and levers that can be used to manipulate a
+  # {Component}.
+  #
+  # @example Defining a new Gear
+  #
+  #   class Twitter < MB::Gear::Base
+  #     register_gear :twitter
+  #   end
+  #
+  # @example Plugin DSL usage
+  #
+  #   component "news_post" do
+  #
+  #     twitter do
+  #     ...
+  #     end
+  #   end
+  #
+  module Gear
+    class Base
+      class << self
+        # The identifier for the Gear. The keyword is automatically populated based on the name
+        # of the Class including {MotherBrain::Gear}. The keyword must be unique among the other
+        # registered Gears. Also used to define a Gear in the plugin DSL.
+        #
+        # @return [Symbol]
+        attr_reader :keyword
+
+        # Register the gear with {MotherBrain::Gear} with the given keyword. This is how a gear is
+        # identified within a plugin.
+        #
+        # @param [#to_sym] keyword
+        def register_gear(keyword)
+          @keyword = keyword.to_sym
+          Gear.register(self)
+        end
+      end
+
+      include VariaModel
+
+      # @param [MB::Job] job
+      #   a job to update with status
+      # @param [String] environment
+      #   the environment this command is being run on
+      def run(job, environment, *args)
+        raise AbstractFunction, "#run(environment, *args) must be implemented on #{self.class}"
+      end
+    end
+
+    RESERVED_KEYWORDS = [
+      :name,
+      :version,
+      :description,
+      :author,
+      :email,
+      :depends,
+      :command,
+      :component,
+      :group,
+      :execute
+    ].freeze
+
+    class << self
+      # Registers a given Class as a Gear to be used within MotherBrain plugins. This
+      # function is automatically called when {MotherBrain::Gear} is included into
+      # a Class. You probably don't want to call this function directly.
+      #
+      # @api private
+      #
+      # @param [~MotherBrain::Gear] klass
+      def register(klass)
+        validate_keyword(klass.keyword)
+
+        all.add(klass)
+      end
+
+      # Return a Set containing all of the registered Gears that can be used within
+      # a MotherBrain plugin.
+      #
+      # @return [Set<MotherBrain::Gear>]
+      def all
+        @all ||= Set.new
+      end
+
+      # Clears all of the registered Gears and then traverses the ObjectSpace to find
+      # all classes which include {MotherBrain::Gear} and calls {::register} with each.
+      #
+      # @return [Set<MotherBrain::Gear>]
+      #   the Set of registered Gears
+      def reload!
+        clear!
+        ObjectSpace.each_object(::Module).each do |mod|
+          if mod < MB::Gear
+            register(mod)
+          end
+        end
+
+        all
+      end
+
+      # Clears all of the registered Gears.
+      #
+      # @return [Set]
+      #   an empty Set
+      def clear!
+        @all = Set.new
+      end
+
+      # @param [Symbol] keyword
+      #
+      # @return [MotherBrain::Gear, nil]
+      def find_by_keyword(keyword)
+        all.find { |klass| klass.keyword == keyword }
+      end
+
+      def element_name(klass)
+        klass.keyword
+      end
+
+      def get_fun(klass)
+        element_name(klass)
+      end
+
+      private
+
+        # Determine if the given keyword is valid
+        #
+        # @param [Symbol] keyword
+        #
+        # @raise [ReservedGearKeyword] if the given keyword is reserved
+        # @raise [DuplicateGearKeyword] if the given keyword has already been registered
+        #
+        # @return [Boolean]
+        def validate_keyword(keyword)
+          if RESERVED_KEYWORDS.include?(keyword)
+            reserved = RESERVED_KEYWORDS.collect { |key| "'#{key}'" }
+            raise ReservedGearKeyword, "'#{keyword}' is a reserved keyword. Reserved Keywords: #{reserved.join(', ')}."
+          end
+
+          culprit = find_by_keyword(keyword)
+
+          unless culprit.nil?
+            raise DuplicateGearKeyword, "Keyword '#{keyword}' already used by #{culprit}"
+          end
+
+          true
+        end
+    end
+  end
+end

data/lib/mb/gears.rb

@@ -0,0 +1,8 @@
+Dir["#{File.dirname(__FILE__)}/gears/*.rb"].sort.each do |path|
+  basename = File.basename(path, '.rb')
+  begin
+    require "mb/gears/#{basename}"
+  rescue LoadError => error
+    MB.log.warn "Error loading #{basename} gear: #{error.message}"
+  end
+end

data/lib/mb/gears/dynamic_service.rb

@@ -0,0 +1,218 @@
+module MotherBrain
+  module Gear
+    class DynamicService < Gear::Base
+      class << self
+
+        # Parses a service, creates a new instance of DynamicService
+        # and executes a Chef run to change the state of the service.
+        #
+        # @param service [String]
+        #   a dotted string "component.service_name"
+        # @param plugin [MB::Plugin]
+        #   the plugin currently in use
+        # @param environment [String]
+        #   the environment to operate on
+        # @param state [String]
+        #   the state of the service to change to
+        # @param options [Hash]
+        # 
+        # @return [MB::JobTicket]
+        def change_service_state(service, plugin, environment, state, run_chef = true, options = {})
+          job = Job.new(:dynamic_service_state_change)
+
+          component, service_name = service.split('.')
+          raise InvalidDynamicService.new(component, service_name) unless component && service_name
+          dynamic_service = new(component, service_name)
+          dynamic_service.state_change(job, plugin, environment, state, run_chef, options)
+          job.report_success
+          job.ticket
+        rescue => ex
+          job.report_failure(ex)
+        ensure
+          job.terminate if job && job.alive?
+        end
+      end
+
+      include MB::Mixin::Services
+      include MB::Mixin::Locks
+      include MB::Logging
+
+      START   = "start".freeze
+      STOP    = "stop".freeze
+      RESTART = "restart".freeze
+      COMMON_STATES = [
+        START,
+        STOP,
+        RESTART
+      ].freeze
+
+      # @return [String]
+      attr_reader :component
+      # @return [String]
+      attr_reader :name
+
+      def initialize(component, name)
+        @name      = name
+        @component = component
+      end
+
+      # Executes a bulk chef run on a group of nodes using the service recipe.
+      # Default behavior is to set a node attribute on each individual node serially
+      # and then execute the chef run.
+      #
+      # @param job [MB::Job]
+      # @param plugin [MB::Plugin]
+      #   the plugin currently in use
+      # @param environment [String]
+      #   the environment to execute on
+      # @param state [String]
+      #   the state to change the service to
+      # @param options [Hash]
+      #
+      # @return [MB::JobTicket]
+      def state_change(job, plugin, environment, state, run_chef = true, options = {})
+        log.warn { 
+          "Component's service state is being changed to #{state}, which is not one of #{COMMON_STATES}" 
+        } unless COMMON_STATES.include?(state)
+
+        chef_synchronize(chef_environment: environment, force: options[:force]) do
+          component_object = plugin.component(component)
+          service_object = component_object.get_service(name)
+          group = component_object.group(service_object.service_group)
+          nodes = group.nodes(environment)
+          job.report_running("preparing to change the #{name} service to #{state}")
+
+          if options[:cluster_override]
+            set_environment_attribute(job, environment, service_object.service_attribute, state)
+          else
+            unset_environment_attribute(job, environment, service_object.service_attribute)
+            set_node_attributes(job, nodes, service_object.service_attribute, state)
+          end
+          if run_chef
+            node_querier.bulk_chef_run(job, nodes, service_object.service_recipe)
+          end
+        end
+      end
+
+      def node_state_change(job, plugin, node, state, run_chef = true)
+        log.warn { 
+          "Component's service state is being changed to #{state}, which is not one of #{COMMON_STATES}" 
+        } unless COMMON_STATES.include?(state)
+
+        component_object = plugin.component(component)
+        service = component_object.get_service(name)
+        set_node_attributes(job, [node], service.service_attribute, state)
+        if run_chef
+          node_querier.bulk_chef_run(job, [node], service.service_recipe)
+        end
+      end
+
+      def remove_node_state_change(job, plugin, node, run_chef = true)
+        component_object = plugin.component(component)
+        service = component_object.get_service(name)
+        
+        unset_node_attributes(job, [node], service.service_attribute)
+        if run_chef
+          node_querier.bulk_chef_run(job, [node], service.service_recipe)
+        end
+      end
+
+      # Finds the environment object, sets an attribute at the
+      # override level, and saves the environment back to the 
+      # Chef server
+      #
+      # @param job [MB::Job]
+      #   the job to track status
+      # @param environment [String]
+      #   the environment being operated on
+      # @param attribute_keys [Array<String>]
+      #   an array of dotted paths to attribute keys
+      # @param state [String]
+      #   the state to set the attribute to
+      #
+      # @return [Boolean]
+      def set_environment_attribute(job, environment, attribute_keys, state)
+        chef_environment = get_chef_environment(environment)
+
+        attribute_keys.each do |attribute_key|
+          job.set_status("Setting environment attribute '#{attribute_key}' to #{state} on #{environment}")
+          chef_environment.set_override_attribute(attribute_key, state)
+        end
+        chef_environment.save
+      end
+
+      # Finds and returns the current Chef environment
+      #
+      # @param environment [String]
+      #
+      # @return [Ridley::EnvironmentObject]
+      def get_chef_environment(environment)
+        chef_connection.environment.find(environment)
+      end
+
+      # Deletes an override attribute from the environment
+      #
+      # @param job [MB::Job]
+      # @param environment [String]
+      # @param attribute_keys [Array<String>]
+      #
+      # @return [Boolean]
+      def unset_environment_attribute(job, environment, attribute_keys)
+        chef_environment = get_chef_environment(environment)
+
+        attribute_keys.each do |attribute_key|
+          job.set_status("Unsetting environment attribute '#{attribute_key}' on #{environment}")
+          chef_environment.delete_override_attribute(attribute_key)
+        end
+        chef_environment.save
+      end
+
+      # Sets a default node attribute on the provided array
+      # of nodes.
+      #
+      # @param job [MB::Job]
+      #   the job to track status
+      # @param nodes [Array<Ridley::NodeObject>]
+      #   the nodes being operated on
+      # @param attribute_keys [Array<String>]
+      #   an array of dotted paths to attribute keys
+      # @param state [String]
+      #   the state to set the attribute to
+      #
+      # @return [Boolean]
+      def set_node_attributes(job, nodes, attribute_keys, state)
+        nodes.concurrent_map do |node|
+          node.reload
+          attribute_keys.each do |attribute_key|
+            job.set_status("Setting node attribute '#{attribute_key}' to #{state.nil? ? 'nil' : state} on #{node.name}")
+            node.set_chef_attribute(attribute_key, state)
+          end
+          node.save
+        end
+      end
+
+      # Removes a default node attribute on the provided array
+      # of nodes.
+      #
+      # @param job [MB::Job]
+      #   the job to track status
+      # @param nodes [Array<Ridley::NodeObject>]
+      #   the nodes being operated on
+      # @param attribute_keys [Array<String>]
+      #   an array of dotted paths to attribute keys
+      #
+      # @return [Boolean]
+      def unset_node_attributes(job, nodes, attribute_keys)
+        nodes.concurrent_map do |node|
+          node.reload
+          attribute_keys.each do |attribute_key|
+            job.set_status("Unsetting node attribute '#{attribute_key}' to respect default and environment attributes.")
+            node.unset_chef_attribute(attribute_key)
+          end
+          node.save
+        end
+      end
+
+    end
+  end
+end