motherbrain 0.0.0.placeholder → 0.13.1

data/lib/mb/cli_gateway/sub_commands.rb

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

data/lib/mb/cli_gateway/sub_commands/environment.rb

@@ -0,0 +1,124 @@
+module MotherBrain
+  class CliGateway
+    module SubCommand
+      class Environment < Cli::Base
+        namespace :environment
+
+        method_option :force,
+          type: :boolean,
+          default: false,
+          desc: "perform the configuration even if the environment is locked",
+          aliases: "-f"
+        desc "configure ENVIRONMENT FILE", "configure a Chef environment"
+        def configure(environment, attributes_file)
+          attributes_file = File.expand_path(attributes_file)
+
+          begin
+            content = File.read(attributes_file)
+          rescue Errno::ENOENT
+            ui.say "No attributes file found at: '#{attributes_file}'"
+            exit(1)
+          end
+
+          begin
+            attributes = MultiJson.decode(content)
+          rescue MultiJson::DecodeError => ex
+            ui.say "Error decoding JSON from: '#{attributes_file}'"
+            ui.say ex
+            exit(1)
+          end
+
+          job = environment_manager.async_configure(environment, attributes: attributes, force: options[:force])
+
+          CliClient.new(job).display
+        end
+
+        method_option :yes,
+          type: :boolean,
+          default: false,
+          desc: "Don't confirm, just destroy the environment",
+          aliases: '-y'
+        method_option :force,
+          type: :boolean,
+          default: false,
+          desc: "Force destruction of a locked environment",
+          aliases: '-f'
+        method_option :provisioner,
+          type: :string,
+          desc: "Provisioner to use for destroying the environment"
+        desc "destroy ENVIRONMENT", "Destroy a provisioned environment"
+        def destroy(environment)
+          options[:with] = options[:provisioner] # TODO: rename with to provisioner
+          options[:yes] ||= options[:force]
+          destroy_options = Hash.new.merge(options).deep_symbolize_keys
+
+          if !options[:force] && ChefMutex.new(chef_environment: environment).locked?
+            raise MB::ResourceLocked,
+              "The environment \"#{environment}\" is locked. You may use --force to override this safeguard."
+          end
+
+          dialog = "This will destroy the '#{environment}' environment.\nAre you sure? (yes|no): "
+          really_destroy = options[:yes] || ui.yes?(dialog)
+
+          if really_destroy
+            job = provisioner.async_destroy(environment, destroy_options)
+            CliClient.new(job).display
+          else
+            ui.say("Aborting destruction of '#{environment}'")
+          end
+        end
+
+        desc "list", "List all environments"
+        def list
+          ui.say "\n"
+          ui.say "** listing environments"
+          ui.say "\n"
+
+          environment_manager.list.each do |env|
+            ui.say env.name
+          end
+        end
+
+        desc "lock ENVIRONMENT", "Lock an environment"
+        def lock(environment)
+          job = lock_manager.async_lock(environment)
+
+          CliClient.new(job).display
+        end
+
+        desc "unlock ENVIRONMENT", "Unlock an environment"
+        def unlock(environment)
+          job = lock_manager.async_unlock(environment)
+
+          CliClient.new(job).display
+        end
+
+        desc "from FILE", "Create an environment from JSON in a file"
+        def from(environment_file)
+          ui.say "Creating environment from #{environment_file}"
+
+          begin
+            environment_manager.create_from_file(environment_file)
+          rescue => e
+            ui.error e.message
+            exit(1)
+          end
+        end
+
+        desc "create ENVIRONMENT", "Create an empty environment"
+        def create(environment)
+          ui.say "Creating empty environment #{environment}"
+          
+          begin
+            environment_manager.create(environment)
+          rescue => e
+            ui.error e.message
+            exit(1)
+          end
+        end
+      end
+    end
+
+    register(SubCommand::Environment, :environment, "environment", "Environment level commands")
+  end
+end

data/lib/mb/cli_gateway/sub_commands/plugin.rb

@@ -0,0 +1,148 @@
+module MotherBrain
+  class CliGateway
+    module SubCommand
+      class Plugin < Cli::Base
+        namespace :plugin
+
+        source_root MB.app_root.join('templates')
+
+        desc "init [PATH]", "Generate a new motherbrain plugin in the target cookbook"
+        def init(path = Dir.pwd)
+          metadata = File.join(path, 'metadata.rb')
+
+          unless File.exist?(metadata)
+            ui.say "#{path} is not a cookbook"
+            exit(1)
+          end
+
+          cookbook = CookbookMetadata.from_file(metadata)
+          config = { name: cookbook.name, groups: %w[default] }
+          template 'bootstrap.json', File.join(path, 'bootstrap.json'), config
+          template 'motherbrain.rb', File.join(path, 'motherbrain.rb'), config
+
+          ui.say [
+            "",
+            "motherbrain plugin created.",
+            "",
+            "Take a look at motherbrain.rb and bootstrap.json,",
+            "and then bootstrap with:",
+            "",
+            "  mb #{cookbook.name} bootstrap bootstrap.json",
+            "",
+            "To see all available commands, run:",
+            "",
+            "  mb #{cookbook.name} help",
+            "\n"
+          ].join("\n")
+        end
+
+        method_option :version,
+          type: :string,
+          desc: "The version of the plugin to install"
+        desc "install NAME", "Install a plugin from the remote Chef server"
+        def install(name)
+          plugin = plugin_manager.install(name, options[:version])
+          ui.say "Successfully installed #{plugin}"
+        end
+
+        method_option :remote,
+          type: :boolean,
+          default: false,
+          desc: "search the remote Chef server and include plugins from the results"
+        desc "list", "List all installed plugins"
+        def list
+          if options[:remote]
+            ui.say "\n"
+            ui.say "** listing installed and remote plugins..."
+            ui.say "\n"
+          else
+            ui.say "\n"
+            ui.say "** listing installed plugins...\n"
+            ui.say "\n"
+          end
+
+          plugins = plugin_manager.list(remote: options[:remote])
+
+          if plugins.empty?
+            errmsg = "No plugins found in your Berkshelf: '#{Application.plugin_manager.berkshelf_path}'"
+
+            if options[:remote]
+              errmsg << " or on remote: '#{Application.config.chef.api_url}'"
+            end
+
+            ui.say errmsg
+            exit(0)
+          end
+
+          plugins.group_by(&:name).each do |name, plugins|
+            versions = plugins.collect(&:version).reverse!
+            ui.say "#{name}: #{versions.join(', ')}"
+          end
+        end
+
+        method_option :version,
+          type: :string,
+          desc: "The version of the plugin to display information for"
+        method_option :remote,
+          type: :boolean,
+          default: false,
+          desc: "Include plugins found on the remote Chef server"
+        desc "show NAME", "Show information about a plugin"
+        def show(name)
+          unless plugin = plugin_manager.find(name, options[:version], remote: options[:remote])
+            if options[:version]
+              errmsg = "#{name} (#{options[:version]}) not"
+            else
+              errmsg = "No versions of #{name}"
+            end
+            errmsg << " found in your Berkshelf"
+            errmsg << " or on the remote Chef server" if options[:remote]
+            ui.say errmsg
+            ui.say "You can search the Chef server with '--remote'" unless options[:remote]
+            exit(1)
+          end
+
+          pp_plugin(plugin)
+        end
+
+        method_option :version,
+          type: :string,
+          desc: "The version of the plugin to install",
+          required: true
+        desc "uninstall NAME", "Uninstall a plugin from your Berkshelf"
+        def uninstall(name)
+          if plugin = plugin_manager.uninstall(name, options[:version])
+            ui.say "Successfully uninstalled #{plugin}"
+          else
+            ui.say "#{name} (#{options[:version]}) was not installed"
+          end
+        end
+
+        no_tasks do
+          def pp_plugin(plugin)
+            info = [].tap do |a|
+              a.push "        Name: #{plugin.name}"
+              a.push "     Version: #{plugin.version}"
+              a.push " Description: #{plugin.description}" unless plugin.description.blank?
+              a.push "      Author: #{plugin.maintainer}" unless plugin.maintainer.blank?
+              a.push "       Email: #{plugin.maintainer_email}" unless plugin.maintainer_email.blank?
+              a.push "     License: #{plugin.license}" unless plugin.license.blank?
+              a.push "    Commands: #{pp_enumerable(plugin.commands, 14)}" unless plugin.commands.blank?
+              a.push "  Components: #{pp_enumerable(plugin.components, 14)}" unless plugin.components.blank?
+            end.join("\n")
+
+            ui.say info
+          end
+        end
+
+        private
+
+          def pp_enumerable(enum, padding)
+            enum.map { |item| "#{item}" }.join("\n" + ' '*padding)
+          end
+      end
+    end
+
+    register(SubCommand::Plugin, :plugin, "plugin", "Plugin level commands")
+  end
+end

data/lib/mb/command.rb

@@ -0,0 +1,88 @@
+module MotherBrain
+  class Command
+    include VariaModel
+    include MB::Mixin::Locks
+
+    attribute :name,
+      type: String,
+      required: true
+
+    attribute :description,
+      type: String,
+      required: true
+
+    attribute :execute,
+      type: Proc,
+      required: true
+
+    # @return [MB::Plugin, MB::Component]
+    attr_reader :scope
+    # @return [MB::Plugin]
+    attr_reader :plugin
+    # @return [Symbol]
+    attr_reader :type
+
+    # @param [#to_s] name
+    # @param [MB::Plugin, MB::Component] scope
+    def initialize(name, scope, &block)
+      set_attribute(:name, name.to_s)
+      @scope = scope
+
+      case @scope
+      when MB::Plugin
+        @plugin = @scope
+        @type   = :plugin
+      when MB::Component
+        @plugin = @scope.plugin
+        @type   = :component
+      else
+        raise RuntimeError, "no matching command type for the given scope: #{scope}."
+      end
+
+      if block_given?
+        dsl_eval(&block)
+      end
+    end
+
+    # @return [String]
+    def description
+      _attributes_.description || "run #{name} command on #{scope.name}"
+    end
+
+    # @return [Symbol]
+    def id
+      self.name.to_sym
+    end
+
+    # Run the command on the given environment
+    #
+    # @param [MB::Job] job
+    #   a job to update with progress
+    # @param [String] environment
+    #   the environment to invoke the command on
+    # @param [Array] node_filter
+    #   list of nodes to limit the command to
+    # @param [Array] args
+    #   additional arguments to pass to the command
+    #
+    # @raise [MB::ChefConnectionError] if there was an error communicating to the Chef Server
+    def invoke(job, environment, node_filter, *args)
+      CommandRunner.new(job, environment, scope, execute, node_filter, *args)
+    end
+
+    private
+
+      def dsl_eval(&block)
+        CleanRoom.new(self).instance_eval(&block)
+      end
+
+    # @api private
+    class CleanRoom < CleanRoomBase
+      dsl_attr_writer :description
+
+      def execute(&block)
+        real_model.execute = block
+      end
+    end
+  end
+end

data/lib/mb/command_invoker.rb

@@ -0,0 +1,235 @@
+module MotherBrain
+  class CommandInvoker
+    autoload :Worker, 'mb/command_invoker/worker'
+
+    class << self
+      # @raise [Celluloid::DeadActorError] if command invoker has not been started
+      #
+      # @return [Celluloid::Actor(CommandInvoker)]
+      def instance
+        MB::Application[:command_invoker] or raise Celluloid::DeadActorError, "command invoker not running"
+      end
+    end
+
+    include Celluloid
+    include MB::Logging
+    include MB::Mixin::Services
+    include MB::Mixin::Locks
+
+    finalizer :finalize_callback
+
+    def initialize
+      log.debug { "Command Invoker starting..." }
+    end
+
+    # Asynchronously invoke a command on a plugin or a component of a plugin.
+    #
+    # @param [String] command_name
+    #   Name of the command to invoke
+    #
+    # @option options [String] :plugin
+    # @option options [String] :component (optional)
+    # @option options [String] :version (optional)
+    # @option options [String] :environment
+    # @option options [Array] :arguments (Array.new)
+    # @option options [Boolean] :force (false)
+    #
+    # @return [MB::Job]
+    def async_invoke(command_name, options = {})
+      job = Job.new(:command)
+      async(:invoke, job, command_name, options)
+      job.ticket
+    end
+
+    # Find a plugin or component level which has already been loaded by a plugin.
+    #
+    # @param [String] command_name
+    #   Name of the command to find
+    # @param [String] plugin_name
+    #   The name of the plugin that the command you are looking for belongs to
+    #
+    # @option options [String] :component (optional)
+    #   Name of the component that this command belongs to. If no component name is specified then
+    #   it is assumed that you are searching for a plugin level command and not a component level
+    #   command.
+    # @option options [String] :environment (optional)
+    #   The environment the command will be executed on. The best version of the command to run on
+    #   that environment will be returned. If no environment is specified the latest version of the
+    #   command will be returned.
+    # @option options [String] :version (optional)
+    #   The specific version of the plugin you are looking for the command on
+    #
+    # @raise [MB::CommandNotFound]
+    # @raise [MB::PluginNotFound]
+    # @raise [MB::ComponentNotFound]
+    # @raise [MB::EnvironmentNotFound]
+    #
+    # @return [MB::Command]
+    def find(command_name, plugin_name, options = {})
+      if options[:version]
+        for_version(options[:version], command_name, plugin_name, options[:component])
+      elsif options[:environment]
+        for_environment(options[:environment], command_name, plugin_name, options[:component])
+      else
+        find_latest(command_name, plugin_name, options[:component])
+      end
+    end
+
+    # Invoke a command on a plugin or a component of a plugin
+    #
+    # @param [MB::Job] job
+    #   A job to update with progress
+    # @param [String] command_name
+    #   Name of the command to invoke
+    #
+    # @option options [String] :plugin
+    # @option options [String] :component (optional)
+    # @option options [String] :environment
+    # @option options [String] :version (optional)
+    # @option options [Array] :arguments (Array.new)
+    # @option options [Boolean] :force (false)
+    # @option options [Array] :node_filter (nil)
+    #
+    # @raise [MB::ArgumentError]
+    #
+    # @return [Boolean]
+    def invoke(job, command_name, options = {})
+      options = options.reverse_merge(arguments: Array.new, force: false)
+
+      job.report_running
+
+      if options[:plugin].nil?
+        job.report_failure MB::ArgumentError.new("must specify a plugin that the command belongs to")
+        return false
+      end
+
+      if options[:environment].nil?
+        job.report_failure MB::ArgumentError.new("must specify an environment to run this command on")
+        return false
+      end
+
+      job.set_status("Finding environment #{options[:environment]}")
+      environment_manager.find(options[:environment])
+
+      command = find(command_name, options[:plugin], options.slice(:component, :environment, :version))
+      worker  = Worker.new(command, options[:environment], options[:node_filter])
+
+      chef_synchronize(chef_environment: options[:environment], force: options[:force], job: job) do
+        worker.run(job, options[:arguments])
+      end
+
+      job.report_success("successfully executed command")
+      true
+    rescue => ex
+      job.report_failure(ex)
+      false
+    ensure
+      job.terminate if job && job.alive?
+      worker.terminate if worker && worker.alive?
+    end
+
+    private
+
+      def finalize_callback
+        log.debug { "Command Invoker stopping..." }
+      end
+
+      # Return a plugin level or component level command from the given plugin based on
+      # the arguments given.
+      #
+      #   * If a component name is not included it is assumed the command to return is a plugin level command.
+      #   * If a component name is included it is assumed that the command to return is a component level command.
+      #
+      # @param [MB::Plugin] plugin
+      #   Plugin to find the command on
+      # @param [String] command_name
+      #   Name of the command to find
+      # @param [String] component_name
+      #   Name of the component of the plugin that the command belongs to
+      #
+      # @raise [MB::CommandNotFound]
+      # @raise [MB::PluginNotFound]
+      # @raise [MB::ComponentNotFound]
+      #
+      # @return [MB::Command]
+      def command_for(plugin, command_name, component_name = nil)
+        if component_name.nil?
+          plugin.command!(command_name)
+        else
+          plugin.component!(component_name).command!(command_name)
+        end
+      rescue PluginNotFound, CommandNotFound, ComponentNotFound => ex
+        abort(ex)
+      end
+
+      # Return the latest version of a plugin or component level command the given command name, plugin name,
+      # and optional component name.
+      #
+      # @param [String] command_name
+      #   Name of the command to find
+      # @param [String] plugin_name
+      #   Name of the plugin the command you are looking for belongs to
+      # @param [String] component_name
+      #   Name of the component of the plugin that the command belongs to
+      #
+      # @raise [MB::CommandNotFound]
+      # @raise [MB::PluginNotFound]
+      # @raise [MB::ComponentNotFound]
+      #
+      # @return [MB::Command]
+      def find_latest(command_name, plugin_name, component_name = nil)
+        plugin = plugin_manager.latest(plugin_name)
+        command_for(plugin, command_name, component_name)
+      end
+
+      # Return the best version of a plugin or component level command the given command name, plugin name,
+      # and optional component name to use when communicating with the given environment.
+      #
+      # @param [String] environment_name
+      #   name of the environment
+      # @param [String] command_name
+      #   Name of the command to find
+      # @param [String] plugin_name
+      #   Name of the plugin the command you are looking for belongs to
+      # @param [String] component_name
+      #   Name of the component of the plugin that the command belongs to
+      #
+      # @raise [MB::EnvironmentNotFound]
+      # @raise [MB::CommandNotFound]
+      # @raise [MB::PluginNotFound]
+      # @raise [MB::ComponentNotFound]
+      #
+      # @return [MB::Command]
+      def for_environment(environment_name, command_name, plugin_name, component_name = nil)
+        plugin = plugin_manager.for_environment(plugin_name, environment_name)
+        command_for(plugin, command_name, component_name)
+      end
+
+      # Return the specific version of a plugin or component level command the given command name, plugin name,
+      # and optional component name.
+      #
+      # @param [String] plugin_version
+      #   Version of the plugin to find the command on
+      # @param [String] command_name
+      #   Name of the command to find
+      # @param [String] plugin_name
+      #   Name of the plugin to find the command on
+      # @param [String] component_name
+      #   Name of the component of the plugin that the command belongs to
+      #
+      # @raise [MB::CommandNotFound]
+      # @raise [MB::PluginNotFound]
+      # @raise [MB::ComponentNotFound]
+      #
+      # @return [MB::Command]
+      def for_version(plugin_version, command_name, plugin_name, component_name = nil)
+        plugin = plugin_manager.find(plugin_name, plugin_version)
+
+        if plugin.nil?
+          abort MB::PluginNotFound.new(plugin_name, plugin_version)
+        end
+
+        command_for(plugin, command_name, component_name)
+      end
+  end
+end