motherbrain 0.0.0.placeholder → 0.13.1

data/lib/mb/cli/shell/basic.rb

@@ -0,0 +1,11 @@
+module MotherBrain
+  module Cli
+    module Shell
+      class Basic < Thor::Shell::Basic
+        include MB::Cli::Shell::Ext
+
+        alias_method :fatal, :error
+      end
+    end
+  end
+end

data/lib/mb/cli/shell/color.rb

@@ -0,0 +1,11 @@
+module MotherBrain
+  module Cli
+    module Shell
+      class Color < Thor::Shell::Color
+        include MB::Cli::Shell::Ext
+
+        alias_method :fatal, :error
+      end
+    end
+  end
+end

data/lib/mb/cli/shell/ext.rb

@@ -0,0 +1,41 @@
+module MotherBrain
+  module Cli
+    module Shell
+      module Ext
+        class << self
+          def included(base)
+            base.send(:include, ClassMethods)
+            base.extend(ClassMethods)
+          end
+        end
+
+        module ClassMethods
+          # Mute the output of this instance of UI until {#unmute!} is called
+          def mute!
+            @mute = true
+          end
+
+          # Unmute the output of this instance of UI until {#mute!} is called
+          def unmute!
+            @mute = false
+          end
+
+          def say(message = "", color = nil, force_new_line = nil)
+            return if quiet?
+
+            super(message, color)
+          end
+          alias_method :info, :say
+
+          def warn(message)
+            say(message, :yellow)
+          end
+
+          def deprecated(message)
+            warn("[DEPRECATION] #{message}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mb/cli/sub_command.rb

@@ -0,0 +1,95 @@
+module MotherBrain
+  module Cli
+    # Generates SubCommands for Thor from motherbrain plugins or pieces of motherbrain plugins
+    module SubCommand
+      autoload :Component, 'mb/cli/sub_command/component'
+      autoload :Plugin, 'mb/cli/sub_command/plugin'
+
+      class << self
+        # Generate a new SubCommand for Thor from a motherbrain plugin or component
+        #
+        # @param [MB::Plugin, MB::Component] object
+        #
+        # @raise [ArgumentError]
+        #
+        # @return [SubCommand::Plugin, SubCommand::Component]
+        def new(object)
+          case object
+          when MB::Plugin
+            SubCommand::Plugin.fabricate(object)
+          when MB::Component
+            SubCommand::Component.fabricate(object)
+          else
+            raise ::ArgumentError, "don't know how to fabricate a subcommand for a '#{object.class}'"
+          end
+        end
+      end
+
+      # A base class that all dynamically generated SubCommands inherit from
+      class Base < Cli::Base
+        class << self
+          alias_method :name, :namespace
+
+          # @raise [AbstractFunction] if the inheriting class does not implement this function
+          def fabricate(*args)
+            raise AbstractFunction, "Class '#{self}' must implement abstract function"
+          end
+
+          def usage
+            "#{name} [COMMAND]"
+          end
+
+          def description
+            raise AbstractFunction
+          end
+
+          # Define a new Thor task from the given {MotherBrain::Command}
+          #
+          # @param [MB::Command] command
+          def define_task(command)
+            plugin_name    = command.plugin.name
+            plugin_version = command.plugin.version.to_s
+            component_name = nil
+
+            if command.type == :component
+              component_name = command.scope.name
+            end
+
+            environment  = CliGateway.invoked_opts[:environment]
+            execute_args = command.execute.parameters.collect { |type, parameter| parameter }
+
+            usage = command.name
+            if execute_args.any?
+              usage += " #{execute_args.map(&:upcase).join(' ')}"
+            end
+
+            method_option :force,
+              type: :boolean,
+              default: false,
+              desc: "Run command even if the environment is locked",
+              aliases: "-f"
+            method_option :only,
+              type: :array,
+              default: nil,
+              desc: "Run command only on the given hostnames or IPs",
+              aliases: "-o"
+            desc(usage, command.description)
+            define_method command.name.to_sym, ->(*task_args) do
+              job = command_invoker.async_invoke(command.name,
+                plugin: plugin_name,
+                component: component_name,
+                version: plugin_version,
+                environment: environment,
+                arguments: task_args,
+                force: options[:force],
+		            node_filter: options[:only]
+              )
+
+              display_job(job)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mb/cli/sub_command/component.rb

@@ -0,0 +1,56 @@
+module MotherBrain
+  module Cli
+    module SubCommand
+      # A set of component tasks collected into a SubCommand to be registered with the
+      # CliGateway. This class should not be instantiated, configured, and used by itself.
+      # Use {SubCommand::Component.fabricate} to create an anonymous class of this type.
+      #
+      # @api private
+      class Component < SubCommand::Base
+        class << self
+          extend Forwardable
+
+          def_delegator :component, :description
+
+          # Return the component associated with this instance of the class
+          #
+          # @return [MB::Component]
+          attr_reader :component
+
+          # @param [MB::Component] component
+          #
+          # @return [SubCommand::Component]
+          def fabricate(component)
+            environment = CliGateway.invoked_opts[:environment]
+
+            Class.new(self) do
+              set_component(component)
+
+              component.commands.each do |command|
+                define_task(command)
+              end
+
+              desc("nodes", "List all nodes grouped by Group")
+              define_method(:nodes) do
+                ui.say "Listing nodes for '#{component.name}' in '#{environment}':"
+                nodes = component.nodes(environment).each do |group, nodes|
+                  nodes.collect! { |node| "#{node.public_hostname} (#{node.public_ipv4})" }
+                end
+                ui.say nodes.to_yaml
+              end
+            end
+          end
+
+          # Set the component for this instance of the class and tailor the class for the
+          # given component.
+          #
+          # @param [MB::Component] component
+          def set_component(component)
+            self.namespace(component.name)
+            @component = component
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mb/cli/sub_command/plugin.rb

@@ -0,0 +1,232 @@
+module MotherBrain
+  module Cli
+    module SubCommand
+      # A set of component tasks collected into a SubCommand to be registered with the
+      # CliGateway. This class should not be instantiated, configured, and used by itself.
+      # Use {SubCommand::Plugin.fabricate} to create an anonymous class of this type.
+      #
+      # @api private
+      class Plugin < SubCommand::Base
+        class << self
+          extend Forwardable
+
+          def_delegator :plugin, :description
+
+          # Return the plugin used to generate the anonymous CLI class
+          #
+          # @return [MotherBrain::Plugin]
+          attr_reader :plugin
+
+          # @param [MotherBrain::Plugin] plugin
+          #
+          # @return [SubCommand::Plugin]
+          def fabricate(plugin)
+            environment = CliGateway.invoked_opts[:environment]
+
+            klass = Class.new(self) do
+              include MB::Mixin::Services
+              set_plugin(plugin)
+            end
+
+            plugin.commands.each do |command|
+              klass.define_task(command)
+            end
+
+            plugin.components.each do |component|
+              klass.register_subcommand MB::Cli::SubCommand.new(component)
+            end
+
+            klass.class_eval do
+              desc("nodes", "List all nodes grouped by Component and Group")
+              define_method(:nodes) do
+                nodes = plugin.nodes(environment).each do |component, groups|
+                  groups.each do |group, nodes|
+                    nodes.collect! { |node| "#{node.public_hostname} (#{node.public_ipv4})" }
+                  end
+                end
+
+                ui.say "\n"
+                ui.say "** listing nodes in #{environment}:"
+                ui.say "\n"
+                ui.say nodes.to_yaml
+              end
+
+              if plugin.bootstrap_routine.present?
+                method_option :chef_version,
+                  type: :string,
+                  desc: "The version of Chef to bootstrap the node(s) with"
+                method_option :component_versions,
+                  type: :hash,
+                  desc: "The component versions to set with default attributes",
+                  aliases: "--components"
+                method_option :cookbook_versions,
+                  type: :hash,
+                  desc: "The cookbook versions to set on the environment",
+                  aliases: "--cookbooks"
+                method_option :environment_attributes,
+                  type: :hash,
+                  desc: "Any additional attributes to set on the environment",
+                  aliases: "--attributes"
+                method_option :environment_attributes_file,
+                  type: :string,
+                  desc: "Any additional attributes to set on the environment via a json file.",
+                  aliases: "--attributes-file"
+                method_option :template,
+                  type: :string,
+                  desc: "Path to bootstrap template (ERB)"
+                method_option :force,
+                  type: :boolean,
+                  default: false,
+                  desc: "Perform bootstrap even if the environment is locked",
+                  aliases: "-f"
+                desc("bootstrap MANIFEST", "Bootstrap a manifest of node groups")
+                define_method(:bootstrap) do |manifest_file|
+                  boot_options = Hash.new.merge(options).deep_symbolize_keys
+                  manifest     = MB::Bootstrap::Manifest.from_file(manifest_file)
+
+                  job = bootstrapper.async_bootstrap(
+                    environment.freeze,
+                    manifest.freeze,
+                    plugin.freeze,
+                    boot_options.freeze
+                  )
+
+                  CliClient.new(job).display
+                end
+
+                method_option :chef_version,
+                  type: :string,
+                  desc: "The version of Chef to bootstrap the node(s) with"
+                method_option :component_versions,
+                  type: :hash,
+                  desc: "The component versions to set with default attributes",
+                  aliases: "--components"
+                method_option :cookbook_versions,
+                  type: :hash,
+                  desc: "The cookbook versions to set on the environment",
+                  aliases: "--cookbooks"
+                method_option :environment_attributes,
+                  type: :hash,
+                  desc: "Any additional attributes to set on the environment",
+                  aliases: "--attributes"
+                method_option :environment_attributes_file,
+                  type: :string,
+                  desc: "Any additional attributes to set on the environment via a json file.",
+                  aliases: "--attributes-file"
+                method_option :skip_bootstrap,
+                  type: :boolean,
+                  desc: "Nodes will be created and added to the Chef environment but not bootstrapped",
+                  default: false
+                method_option :template,
+                  type: :string,
+                  desc: "Path to bootstrap template (ERB)"
+                method_option :force,
+                  type: :boolean,
+                  default: false,
+                  desc: "Perform bootstrap even if the environment is locked"
+                desc("provision MANIFEST", "Create a cluster of nodes and add them to a Chef environment")
+                define_method(:provision) do |manifest_file|
+                  prov_options = Hash.new.merge(options).deep_symbolize_keys
+                  manifest     = Provisioner::Manifest.from_file(manifest_file)
+
+                  job = provisioner.async_provision(
+                    environment.freeze,
+                    manifest.freeze,
+                    plugin.freeze,
+                    prov_options.freeze
+                  )
+
+                  CliClient.new(job).display
+                end
+
+                method_option :cluster_override,
+                  type: :boolean,
+                  default: false,
+                  desc: "Sets the service operation to execute at the environment level"
+                method_option :force,
+                  type: :boolean,
+                  default: false,
+                  desc: "Perform service change even if the environment is locked",
+                  aliases: "-f"
+                desc("service [COMPONENT].[SERVICE] [STATE]", "Change the specified service to a new state")
+                define_method(:service) do |service, state|
+                  service_options = Hash.new.merge(options).deep_symbolize_keys
+
+                  job = MB::Gear::DynamicService.change_service_state(
+                    service.freeze,
+                    plugin.freeze,
+                    environment.freeze,
+                    state.freeze,
+                    service_options
+                  )
+
+                  CliClient.new(job).display
+                end
+
+                method_option :component_versions,
+                  type: :hash,
+                  desc: "The component versions to set with default attributes",
+                  aliases: "--components"
+                method_option :cookbook_versions,
+                  type: :hash,
+                  desc: "The cookbook versions to set on the environment",
+                  aliases: "--cookbooks"
+                method_option :environment_attributes,
+                  type: :hash,
+                  desc: "Any additional attributes to set on the environment",
+                  aliases: "--attributes"
+                method_option :environment_attributes_file,
+                  type: :string,
+                  desc: "Any additional attributes to set on the environment via a json file.",
+                  aliases: "--attributes-file"
+                method_option :force,
+                  type: :boolean,
+                  default: false,
+                  desc: "Perform upgrade even if the environment is locked",
+                  aliases: "-f"
+                desc("upgrade", "Upgrade an environment to the specified versions")
+                define_method(:upgrade) do
+                  upgrade_options = Hash.new.merge(options).deep_symbolize_keys
+
+                  requires_one_of [
+                    :component_versions,
+                    :cookbook_versions,
+                    :environment_attributes,
+                    :environment_attributes_file
+                  ]
+
+                  job = upgrade_manager.async_upgrade(
+                    environment.freeze,
+                    plugin.freeze,
+                    upgrade_options.freeze
+                  )
+
+                  CliClient.new(job).display
+                end
+
+                desc("attributes", "View available attributes for plugin.")
+                define_method(:attributes) do 
+                  ui.say "\n"
+                  ui.say "** listing attributes for #{plugin}:"
+                  ui.say "\n"
+                  ui.say plugin.metadata.attributes.to_yaml
+                end
+              end
+            end
+
+            klass
+          end
+
+          # Set the plugin for this instance of the class and tailor the class for the
+          # given plugin.
+          #
+          # @param [MotherBrain::Plugin] plugin
+          def set_plugin(plugin)
+            self.namespace(plugin.name)
+            @plugin = plugin
+          end
+        end
+      end
+    end
+  end
+end