motherbrain 0.0.0.placeholder → 0.13.1

data/lib/mb/logging/basic_format.rb

@@ -0,0 +1,31 @@
+module MotherBrain
+  module Logging
+    class BasicFormat < Logger::Formatter
+      def call(severity, datetime, progname, msg)
+        message = msg.to_s
+
+        if match = message.match(/NODE\[.+?\]/)
+          format_matched_lines match, message
+        else
+          "[#{datetime.utc.iso8601}] PID[#{Process.pid}] TID[#{Thread.current.object_id.to_s(36)}] #{severity}: #{message}\n"
+        end
+      end
+
+      private
+
+      def format_matched_lines(match, message)
+        lines = message.lines.to_a
+
+        lines.map! do |line|
+          if line.start_with? match.to_s
+            line
+          else
+            "#{match} #{line}"
+          end
+        end
+
+        lines.join("\n") << "\n"
+      end
+    end
+  end
+end

data/lib/mb/manifest.rb

@@ -0,0 +1,128 @@
+module MotherBrain
+  class Manifest < Hash
+    class << self
+      # @param [#to_s] path
+      #
+      # @raise [ManifestNotFound] if the manifest file is not found
+      #
+      # @return [Manifest]
+      def from_file(path)
+        path = File.expand_path(path.to_s)
+        data = File.read(path)
+        obj = new.from_json(data)
+        obj.path = path
+        obj
+      rescue Errno::ENOENT
+        raise ManifestNotFound, "No manifest found at: '#{path}'"
+      end
+
+      # @param [#to_s] data
+      #
+      # @return [Manifest]
+      def from_json(data)
+        new.from_json(data)
+      end
+
+      # @param [Hash] data
+      #
+      # @return [Manifest]
+      def from_hash(data)
+        new.from_hash(data)
+      end
+    end
+
+    # return [String]
+    attr_accessor :path
+
+    # @param [Hash] attributes (Hash.new)
+    def initialize(attributes = Hash.new)
+      if attributes && attributes.any?
+        from_hash(attributes)
+      end
+    end
+
+    # @param [String] json
+    # @param [Hash] options
+    #   @see MultiJson.decode
+    #
+    # @raise [InvalidManifest] if the given string is not valid JSON
+    #
+    # @return [Manifest]
+    def from_json(json, options = {})
+      from_hash(MultiJson.decode(json, options))
+    rescue MultiJson::DecodeError => error
+      raise InvalidManifest, error
+    end
+
+    # @param [Hash] hash
+    #
+    # @return [Manifest]
+    def from_hash(hash)
+      mass_assign(hash)
+
+      self
+    end
+
+    # @param [String] path
+    #
+    # @raise [MB::InternalError] if the path attribute is nil or an empty string
+    #
+    # @return [Manifest]
+    def save(path = nil)
+      self.path = path || self.path
+
+      unless path.present?
+        raise InternalError, "Cannot save manifest without a destination. Set the 'path' attribute on your object."
+      end
+
+      FileUtils.mkdir_p(File.dirname(path))
+      File.open(path, 'w+') do |file|
+        file.write(MultiJson.dump(self, pretty: true))
+      end
+
+      self
+    end
+
+    # @return [Array]
+    def node_groups
+      self[:nodes] || []
+    end
+
+    # @return [Hash]
+    def options
+      self[:options] || {}
+    end
+
+    # Returns the number of nodes expected to be created by this manifest regardless of type
+    #
+    # @return [Integer]
+    def node_count
+      node_groups.reduce(0) { |total, node|
+        total + (node[:count] || 1)
+      }
+    end
+
+    private
+
+      # Assign the key value pairs of the given hash to self
+      #
+      # @param [Hash] hash
+      def mass_assign(hash)
+        hash.each_pair do |key, value|
+          self[key] = value
+        end
+
+        deep_symbolize_keys!
+
+        each do |key, value|
+          if value.is_a?(Array)
+            value.each do |object|
+              if object.respond_to?(:deep_symbolize_keys!)
+                object.deep_symbolize_keys!
+              end
+            end
+          end
+        end
+      end
+  end
+end

data/lib/mb/mixin.rb

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

data/lib/mb/mixin/attribute_setting.rb

@@ -0,0 +1,265 @@
+require 'mb/mixin/services'
+
+module MotherBrain
+  module Mixin
+    module AttributeSetting
+      extend Forwardable
+      include MB::Logging
+      include MB::Mixin::Services
+
+      # Set the appropriate attributes at the environment level to the desired version
+      # for each component given
+      #
+      # @param [String] env_id
+      #   the name identifier of the environment to modify
+      # @param [MB::Plugin] plugin
+      #   the plugin to use for finding the appropriate version attributes
+      # @param [Hash] component_versions
+      #   Hash of components and the versions to set them to
+      #
+      # @raise [MB::EnvironmentNotFound] if the environment does not exist
+      #
+      # @example setting the versions of multiple components on an environment
+      #
+      #   set_component_versions("test-environment",
+      #     "component_one" => "1.0.0",
+      #     "component_two" => "2.3.0"
+      #   )
+      def set_component_versions(env_id, plugin, component_versions)
+        default_attributes = Hash.new
+
+        component_versions.each do |component_name, version|
+          version_hash = Hash.from_dotted_path(version_attribute(plugin, component_name), version)
+          default_attributes.deep_merge!(version_hash)
+        end
+
+        log.info "Setting component versions #{component_versions}"
+
+        unless env = chef_connection.environment.find(env_id)
+          raise EnvironmentNotFound.new(env_id)
+        end
+
+        env.default_attributes.merge!(default_attributes)
+        env.save
+      end
+
+      # Lock the cookbook versions on the target environment from the given hash of
+      # cookbooks and versions
+      #
+      # @param [String] env_id
+      #   the name identifier of the environment to modify
+      # @param [Hash] cookbook_versions
+      #   Hash of cookbooks and the versions to set them to
+      #
+      # @raise [MB::EnvironmentNotFound] if the environment does not exist
+      #
+      # @example setting cookbook versions on an environment
+      #
+      #   set_cookbook_versions("test-environment",
+      #     "league" => "1.74.2",
+      #     "pvpnet" => "3.2.0"
+      #   )
+      #
+      # @raise [ArgumentError] if given invalid version constraints
+      def set_cookbook_versions(env_id, cookbook_versions)
+        cookbook_versions = expand_constraints(expand_latest_versions(cookbook_versions))
+        satisfies_constraints?(cookbook_versions)
+        log.info "Setting cookbook versions #{cookbook_versions}"
+
+        unless env = chef_connection.environment.find(env_id)
+          raise EnvironmentNotFound.new(env_id)
+        end
+
+        env.cookbook_versions.merge!(cookbook_versions)
+        env.save
+      end
+
+      # Set environment level attributes on an environment from a hash containing
+      # keys identifying attributes using the dot notation syntax and values of those
+      # attributes as values.
+      #
+      # @param [String] env_id
+      #   the name identifier of the environment to modify
+      # @param [Hash] new_attributes
+      #   Hash of attributes and values
+      #
+      # @example setting multiple attributes on an environment
+      #
+      #   set_environment_attributes("test-environment",
+      #     "foo"      => "bar",
+      #     "baz.quux" => 42
+      #   )
+      def set_environment_attributes(env_id, new_attributes)
+        default_attributes = Hash.new
+
+        new_attributes.each do |attribute, value|
+          attribute_hash = Hash.from_dotted_path(attribute.to_s, value.to_s)
+          default_attributes.deep_merge!(attribute_hash)
+        end
+
+        set_environment_attributes_from_hash(env_id, default_attributes)
+      end
+
+      # Set arbitrary attributes at the environment level
+      #
+      # @param [String] env_id
+      #   the name of the environment to modify
+      # @param [Hash] new_attributes
+      #   Hash of attributes to set on the environment
+      #
+      # @raise [MB::EnvironmentNotFound] if the environment does not exist
+      #
+      # @example setting multiple attributes on an environment
+      #
+      #   set_environment_attributes_from_hash("test-environment",
+      #     "foo" => "bar",
+      #     "baz  => {
+      #       "quux" => 42
+      #     }
+      #   )
+      def set_environment_attributes_from_hash(env_id, new_attributes)
+        log.info "Setting environment attributes: #{new_attributes}"
+
+        unless env = chef_connection.environment.find(env_id)
+          raise EnvironmentNotFound.new(env_id)
+        end
+
+        env.default_attributes.deep_merge!(new_attributes)
+        env.save
+      end
+
+      # Set environment level attributes on an environment from the contents of the file
+      # at the given filepath
+      #
+      # @param [String] env_id
+      #   the name of the environment to modify
+      # @param [String] filepath
+      #   path to the file to read attributes from
+      # @param [Symbol] type
+      #   the type of the contents found within the file
+      #
+      # @raise [InvalidAttributesFile]
+      #   if the contents of the attributes file are missing or not well formed
+      # @raise [ArgumentError]
+      #   if an unknown value for the 'type' parameter is specified
+      def set_environment_attributes_from_file(env_id, filepath, type = :json)
+        contents = File.read(filepath)
+
+        case type
+        when :json
+          set_environment_attributes_from_json(env_id, contents)
+        else
+          raise ArgumentError, "cannot read attributes from files of type: #{type}"
+        end
+      rescue MultiJson::DecodeError => ex
+        raise InvalidAttributesFile, "Invalid JSON in #{filepath}: #{ex}"
+      end
+
+      # Set environment level attributes on an environment from the given JSON string
+      #
+      # @param [String] env_id
+      #   the name of the environment to modify
+      # @param [String] json
+      #   the json to use as attributes
+      def set_environment_attributes_from_json(env_id, json)
+        set_environment_attributes_from_hash(env_id, MultiJson.decode(json))
+      end
+
+      private
+
+        # retrieve the version attribute of a given component and raise if the
+        # component is not versioned
+        #
+        # @param [MB::Plugin] plugin
+        # @param [#to_s] component_name
+        #
+        # @raise [ComponentNotVersioned]
+        #
+        # @return [String]
+        def version_attribute(plugin, component_name)
+          result = plugin.component!(component_name).version_attribute
+
+          unless result
+            raise ComponentNotVersioned.new component_name
+          end
+
+          log.info "Component '#{component_name}' versioned with '#{result}'"
+
+          result
+        end
+
+        # Expand the "latest" cookbook versions to the latest verison number
+        # for the cookbook
+        #
+        # @param [Hash] cookbook_versions
+        #   Hash of cookbooks and the versions
+        #
+        # @example expanding versions when 3.1.0 is the latest pvpnet cookbook
+        #
+        #   expand_latest_versions(
+        #     "league" => "1.74.2",
+        #     "pvpnet" => "latest"
+        #   )
+        #
+        #   # => {"league" => "1.74.2", "pvpnet" => "3.1.0"}
+        def expand_latest_versions(cookbook_versions)
+          expanded_cookbook_versions = cookbook_versions.map do |name, version|
+            if version.downcase == "latest"
+              version = chef_connection.cookbook.latest_version(name)
+            end
+
+            [name, version]
+          end
+
+          Hash[expanded_cookbook_versions]
+        end
+
+        # Expand constraints strings given to their fully qualified constraint operators
+        #
+        # @param [Hash] cookbook_versions
+        #   Hash of cookbooks and the versions
+        #
+        # @raise [ArgumentError] if the array of constraints contains an entry which is not in the
+        #   correct version constraint format
+        #
+        # @example
+        #   expand_constraints(
+        #     "league" => "1.74.2",
+        #     "pvpnet" => ">= 1.2.3"
+        #   )
+        #
+        #   # => { "league" => "= 1.74.2", "pvpnet" => ">= 1.2.3" }
+        #
+        # @return [Hash]
+        def expand_constraints(cookbook_versions)
+          expanded = cookbook_versions.collect do |name, constraint|
+            [name, Solve::Constraint.new(constraint).to_s]
+          end
+
+          Hash[expanded]
+        rescue Solve::Errors::InvalidConstraintFormat => ex
+          raise ArgumentError, ex
+        end
+
+        # Ensure the chef server can satisfy the desired cookbook version constraints
+        #
+        # @param [Hash] cookbook_versions
+        #   Hash of cookbooks and the versions
+        #
+        # @raise [MB::CookbookConstraintNotSatisfied]
+        #   if the constraints cannot be satisfied
+        def satisfies_constraints?(cookbook_versions)
+          failures = cookbook_versions.concurrent_map do |name, constraint|
+            if chef_connection.cookbook.satisfy(name, constraint).nil?
+              "#{name} (#{constraint})"
+            end
+          end.compact
+
+          unless failures.empty?
+            raise MB::CookbookConstraintNotSatisfied,
+              "couldn't satisfy constraints for cookbook version(s): #{failures.join(', ')}"
+          end
+        end
+    end
+  end
+end

data/lib/mb/mixin/coded_exit.rb

@@ -0,0 +1,49 @@
+module MotherBrain
+  module Mixin
+    # Include a collection of helper functions for exiting with exit statuses from error constants
+    # and determining exit statuses for string representations of motherbrain exceptions.
+    module CodedExit
+      class << self
+        def included(base)
+          base.extend(ClassMethods)
+          base.send(:include, ClassMethods)
+        end
+
+        def extended(base)
+          base.extend(ClassMethods)
+        end
+      end
+
+      module ClassMethods
+        # Exit the application with the exit status associated with the given motherbrain error
+        #
+        # @param [String, #exit_code] obj
+        #
+        # @example exit the application with an exit status for InvalidConfig (14)
+        #   exit_with(MB::InvalidConfig)
+        #
+        # @raise [SystemExit]
+        def exit_with(obj)
+          err_const = obj.is_a?(String) ? constant_for(obj) : obj
+          exit_code = err_const.try(:exit_code) || MBError::DEFAULT_EXIT_CODE
+
+          Kernel.exit(exit_code)
+        end
+
+        # Look up the exit status for motherbrain error matching the given name
+        #
+        # @param [String] const_name
+        #   name of the error constant to lookup
+        #
+        # @example retrieving the exit status for MB::InvalidConfig
+        #   exit_code_for("InvalidConfig") #=> 14
+        #
+        # @return [Integer]
+        def exit_code_for(const_name)
+          MB.const_get(const_name).exit_code
+        end
+        alias_method :exit_status_for, :exit_code_for
+      end
+    end
+  end
+end