motherbrain 0.0.0.placeholder → 0.13.1

data/lib/mb/gears/jmx.rb

@@ -0,0 +1,24 @@
+module MotherBrain
+  module Gear
+    class JMX < Gear::Base
+      register_gear :jmx
+
+      # @param [Fixnum] port
+      #   the port to connect over
+      # @param [String] object_name
+      #   the name of the jmx object
+      #
+      # @raise [ActionNotSupported] if not running JRuby
+      # @raise [ArgumentError]
+      def action(port, object_name, &block)
+        unless jruby?
+          raise ActionNotSupported, "The JMX Gear is only supported on JRuby"
+        end
+
+        JMX::Action.new(port, object_name, &block)
+      end
+    end
+
+    require_relative 'jmx/action'
+  end
+end

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

@@ -0,0 +1,46 @@
+begin
+  require 'jmx4r'
+rescue LoadError; end
+
+module MotherBrain
+  module Gear
+    class JMX
+      # @api private
+      class Action
+        attr_reader :port
+        attr_reader :object_name
+        attr_reader :block
+
+        # @param [Fixnum] port the port to connect over
+        # @param [String] object_name the name of the jmx object
+        #
+        # @raise [ArgumentError]
+        def initialize(port, object_name, &block)
+          unless block_given? && block.arity == 1
+            raise ArgumentError, "block with one argument required to run JMX actions"
+          end
+
+          @port        = port
+          @object_name = object_name
+          @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
+        def run(job, environment, nodes)
+          nodes.each do |node|
+            connection = ::JMX::MBean.connection(host: node.public_hostname, port: port)
+            mbean      = ::JMX::MBean.find_by_name(object_name, connection: connection)
+            block.call(mbean)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mb/gears/mysql.rb

@@ -0,0 +1,20 @@
+module MotherBrain
+  module Gear
+    class MySQL < Gear::Base
+      register_gear :mysql
+
+      # @param [String] sql
+      #   the sql to run
+      #
+      # @option options [Hash] :data_bag
+      #   specify the data bag, item, and location inside the item to find the MySQL credentials
+      #
+      # @return [MB::Gear::MySQL::Action]
+      def action(sql, options)
+        MySQL::Action.new(sql, options)
+      end
+    end
+
+    require_relative 'mysql/action'
+  end
+end

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

@@ -0,0 +1,190 @@
+if jruby?
+  require 'jdbc/mysql'
+  require 'java'
+else
+  require 'mysql2'
+end
+
+module MotherBrain
+  module Gear
+    class MySQL
+      # @api private
+      class Action
+        include MB::Mixin::Services
+
+        # @return [String]
+        attr_reader :sql
+        # @return [Hash]
+        attr_reader :options
+
+        class << self
+          # @param [Hash] options
+          #   the options to validate
+          #
+          # @raise [MB::ArgumentError] if the options are invalid
+          def validate_options(options)
+            unless options.key?(:data_bag)
+              raise ArgumentError, "You are missing a :data_bag key in your MySQL gear options!"
+            end
+
+            unless options[:data_bag].key?(:name)
+              raise ArgumentError, "You are missing a :name key in your MySQL gear data bag options!"
+            end
+          end
+        end
+
+        # @param [String] sql
+        #   the sql to run
+        #
+        # @option options [Hash] :data_bag
+        #   specify the data bag, item, and location inside the item to find the MySQL credentials
+        def initialize(sql, options)
+          self.class.validate_options(options)
+          @sql     = sql
+          @options = options
+        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
+        def run(job, environment, nodes)
+          threads = []
+
+          nodes.each do |node|
+            threads << Thread.new(node) do |node|
+              query(environment, sql, node)
+            end
+          end
+
+          threads.each(&:join)
+        end
+
+        # The MySQL connection information/credentials for the specified node.
+        #
+        # @param [String] environment
+        #   name of the environment to retrieve credentials from
+        # @param [Ridley::Node] node
+        #   the node to to find connection information for
+        #
+        # @raise [MB::GearError] if the MySQL credentials cannot be found or are malformed
+        #
+        # @return [Hash] MySQL connection information for the node
+        def connection_info(environment, node)
+          credentials(environment).merge(host: node.public_hostname)
+        rescue MB::DataBagNotFound, MB::DataBagItemNotFound => ex
+          raise MB::GearError.new(ex)
+        end
+
+        # @return [Hash] The keys used to look up MySQL connection information in a data bag item.
+        def data_bag_keys
+          hash = data_bag_spec[:location][:hash]
+
+          if hash
+            Hash[data_bag_spec[:location][:keys].map { |k, v| [k, "#{hash}.#{v}"] }]
+          else
+            data_bag_spec[:location][:keys]
+          end
+        end
+
+        private
+
+          # Runs a sql query on a node.
+          #
+          # @param [String] sql
+          #   the sql query
+          # @param [Ridley::Node] node
+          #   the node to run the query on
+          def query(environment, sql, node)
+            jruby? ? jdbc_query(environment, sql, node) : mysql2_query(environment, sql, node)
+          end
+
+          # Runs a sql query on a node using jdbc.
+          #
+          # @param [String] sql
+          #   the sql query
+          # @param [Ridley::Node] node
+          #   the node to run the query on
+          def jdbc_query(environment, sql, node)
+            info = connection_info(environment, node)
+            Java::com.mysql.jdbc.Driver
+            connection_url = "jdbc:mysql://#{info[:host]}:#{info[:port]}/#{info[:database]}"
+            connection = java.sql.DriverManager.get_connection(connection_url, info[:username], info[:password])
+            connection.create_statement.execute(sql)
+          end
+
+          # Runs a sql query on a node using mysql2.
+          #
+          # @param [String] sql
+          #   the sql query
+          # @param [Ridley::Node] node
+          #   the node to run the query on
+          def mysql2_query(environment, sql, node)
+            connection = Mysql2::Client.new(connection_info(environment, node))
+            connection.query(sql)
+          end
+
+          # Retrieves the MySQL credentials from the data bag.
+          #
+          # @param [String] environment
+          #
+          # @raise [MB::DataBagNotFound] if the data bag is not found
+          # @raise [MB::DataBagItemNotFound] if an item with the name of the given environment is not found
+          #   in the credentials data bag
+          # @raise [MB::GearError] if any MySQL credentials are missing
+          #
+          # @return [Hash] MySQL credentials
+          def credentials(environment)
+            return @credentials if @credentials
+
+            unless data_bag = ridley.data_bag.find(data_bag_spec[:name])
+              raise MB::DataBagNotFound.new(data_bag_spec[:name])
+            end
+
+            unless dbi = data_bag.item.find(environment)
+              raise MB::DataBagItemNotFound.new(data_bag_spec[:name], environment)
+            end
+
+            dbi = dbi.decrypt
+
+            @credentials = Hash[data_bag_keys.map { |key, dbi_key| [key, dbi.dig(dbi_key)] }]
+
+            @credentials.each do |key, value|
+              if value.nil?
+                err_msg = "Missing a MySQL credential.  Could not find a #{key} at the location you specified. "
+                err_msg << "You specified that the #{key} can be found at '#{data_bag_keys[key]}' "
+                err_msg << "in the '#{environment}' data bag item inside the '#{data_bag_spec[:name]}' "
+                err_msg << "data bag."
+                raise GearError, err_msg
+              end
+            end
+
+            @credentials
+          end
+
+          # @return [Hash] where to find the MySQL connection information
+          def data_bag_spec
+            @data_bag_spec ||= default_data_bag_spec.deep_merge(options[:data_bag])
+          end
+
+          # @return [Hash] the default specification for where to find MySQL connection information
+          def default_data_bag_spec
+            {
+              location: {
+                keys: {
+                  username: "username",
+                  password: "password",
+                  database: "database",
+                  port: "port"
+                }
+              }
+            }
+          end
+      end
+    end
+  end
+end

data/lib/mb/gears/service.rb

@@ -0,0 +1,163 @@
+module MotherBrain
+  module Gear
+    class Service < Gear::Base
+      register_gear :service
+
+      class << self
+        # Finds a gear identified by name in the list of gears supplied.
+        #
+        # @param [Array<MB::Gear::Service>] gears
+        #   the list of gears to search in
+        # @param [#to_s] name
+        #   the name of the gear to search for
+        #
+        # @return [MB::Gear::Service]
+        def find(gears, name)
+          gears.find { |obj| obj.name == name.to_s }
+        end
+      end
+
+      # @return [String]
+      attr_reader :name
+      # @return [Set<Action>]
+      attr_reader :actions
+      # @return [MB::Component]
+      attr_reader :component
+
+      attr_reader :service_group
+      attr_reader :service_recipe
+      attr_reader :service_attribute
+
+      # @param [MB::Component] component
+      # @param [#to_s] name
+      def initialize(component, name, &block)
+        @name      = name.to_s
+        @component = component
+        @actions   = Set.new
+
+        if block_given?
+          dsl_eval(&block)
+        end
+      end
+
+      # Find and return the given action
+      #
+      # @param [String] name
+      #
+      # @raise [ActionNotFound] if there is no action of the given name defined
+      #
+      # @return [Gear::Action]
+      def action!(name)
+        action = action(name)
+
+        unless action
+          raise ActionNotFound, "#{self.class.keyword} '#{_attributes_[:name]}' does not have the action '#{name}'"
+        end
+
+        action
+      end
+
+      # Find and return the given action
+      #
+      # @param [String] name
+      #
+      # @raise [ActionNotFound] if there is no action of the given name defined
+      #
+      # @return [Gear::Action]
+      def action(name)
+        actions.find { |action| action.name == name }
+      end
+
+      # Find and return the stop action
+      #
+      # @return [Gear::Action]
+      def stop_action
+        action(:stop)
+      end
+
+      # Add a new action to this Service
+      #
+      # @param [Service::Action] new_action
+      #
+      # @return [Set<Action>]
+      def add_action(new_action)
+        if action(new_action.name)
+          raise DuplicateAction, "Action '#{new_action.name}' already defined on service '#{_attributes_[:name]}'"
+        end
+
+        actions << new_action
+      end
+
+      def set_service_group(group)
+        @service_group = group
+      end
+
+      def set_service_recipe(recipe)
+        @service_recipe = recipe
+      end
+
+      def set_service_attribute(attribute)
+        @service_attribute = attribute
+      end
+
+      # Convert a Service to a DynamicService
+      #
+      # @return [MB::Gears::DynamicService]
+      def to_dynamic_service
+        log {
+          "Service '#{self.name}' does not appear to by a dynamic service. It does not define the following fields which are required for dynamic services: #{self.missing_fields_for_dynamic_service.join(",")}"
+        } unless dynamic_service?
+
+        MotherBrain::Gear::DynamicService.new(component.name, name)
+      end
+
+      # Indicates whether this service conforms to the dyanamic service pattern
+      # 
+      # @return TrueClass, FalseClass
+      def dynamic_service?
+        missing_fields_for_dynamic_service.empty?
+      end
+
+      private
+
+        def dsl_eval(&block)
+          CleanRoom.new(self).instance_eval do
+            instance_eval(&block)
+          end
+        end
+
+        def missing_fields_for_dynamic_service
+          %w[service_group service_recipe service_attribute].collect do |field|
+            field if self.instance_variable_get("@#{field}").nil?
+          end.compact
+        end
+
+        # @api private
+        class CleanRoom < CleanRoomBase
+          # @param [String] name
+          def action(name, &block)
+            real_model.add_action Service::Action.new(name, real_model.component, &block)
+          end
+
+          def service_group(group)
+            real_model.set_service_group(group)
+          end
+
+          def service_recipe(recipe)
+            real_model.set_service_recipe([recipe].flatten)
+          end
+
+          def service_attribute(attribute)
+            real_model.set_service_attribute([attribute].flatten)
+          end
+
+          private
+
+            attr_reader :component
+        end
+    end
+
+    require_relative 'service/action'
+    require_relative 'service/action_runner'
+  end
+end