Improve handling of conflict/missing plugins

Author: hyfen

lib/chronicle/etl/cli/jobs.rb

@@ -45,15 +45,19 @@ class Jobs < SubcommandBase
 LONG_DESC
         # Run an ETL job
         def start
-          run_job(options)
-        rescue Chronicle::ETL::JobDefinitionError => e
-          missing_plugins = e.job_definition.errors
-            .select { |error| error.is_a?(Chronicle::ETL::PluginLoadError) }
-            .map(&:name)
-            .uniq
+          job_definition = build_job_definition(options)
+
+          if job_definition.plugins_missing?
+            missing_plugins = job_definition.errors[:plugins]
+              .select { |error| error.is_a?(Chronicle::ETL::PluginLoadError) }
+              .map(&:name)
+              .uniq
+            install_missing_plugins(missing_plugins)
+          end
 
-          install_missing_plugins(missing_plugins)
-          run_job(options)
+          run_job(job_definition)
+        rescue Chronicle::ETL::JobDefinitionError => e
+          cli_fail(message: "Error running job.\n#{job_definition.errors}", exception: e)
         end
 
         desc "create", "Create a job"
@@ -104,8 +108,7 @@ def list
 
         private
 
-        def run_job(options)
-          job_definition = build_job_definition(options)
+        def run_job(job_definition)
           job = Chronicle::ETL::Job.new(job_definition)
           runner = Chronicle::ETL::Runner.new(job)
           runner.run!
@@ -118,18 +121,10 @@ def install_missing_plugins(missing_plugins)
           message += "Do you want to install "
           message += missing_plugins.map { |name| "chronicle-#{name}".bold}.join(", ")
           message += " and start the job?"
-          install = prompt.yes?(message)
-          return unless install
+          will_install = prompt.yes?(message)
+          cli_fail(message: "Must install #{missing_plugins.join(", ")} plugin to run job") unless will_install
 
-          spinner = TTY::Spinner.new("[:spinner] Installing plugins...", format: :dots_2)
-          spinner.auto_spin
-          missing_plugins.each do |plugin|
-            Chronicle::ETL::Registry::PluginRegistry.install(plugin)
-          end
-          spinner.success("(#{'successful'.green})")
-        rescue Chronicle::ETL::PluginNotAvailableError => e
-          spinner.error("Error".red)
-          Chronicle::ETL::Logger.fatal("Plugin '#{e.name}' could not be installed".red)
+          Chronicle::ETL::CLI::Plugins.new.install(*missing_plugins)
         end
 
         # Create job definition by reading config file and then overwriting with flag options

lib/chronicle/etl/cli/plugins.rb

@@ -13,14 +13,19 @@ class Plugins < SubcommandBase
         namespace :plugins
 
         desc "install", "Install a plugin"
-        def install(name)
-          spinner = TTY::Spinner.new("[:spinner] Installing plugin #{name}...", format: :dots_2)
+        def install(*plugins)
+          cli_fail(message: "Please specify a plugin to install") unless plugins.any?
+
+          spinner = TTY::Spinner.new("[:spinner] Installing #{plugins.join(", ")}...", format: :dots_2)
           spinner.auto_spin
-          Chronicle::ETL::Registry::PluginRegistry.install(name)
+          plugins.each do |plugin|
+            spinner.update(title: "Installing #{plugin}")
+            Chronicle::ETL::Registry::PluginRegistry.install(plugin)
+          rescue Chronicle::ETL::PluginError => e
+            spinner.error("Error".red)
+            cli_fail(message: "Plugin '#{plugin}' could not be installed", exception: e)
+          end
           spinner.success("(#{'successful'.green})")
-        rescue Chronicle::ETL::PluginError => e
-          spinner.error("Error".red)
-          cli_fail(message: "Plugin '#{name}' could not be installed", exception: e)
         end
 
         desc "uninstall", "Unintall a plugin"

lib/chronicle/etl/exceptions.rb

@@ -23,6 +23,7 @@ def initialize(name)
       end
     end
 
+    class PluginConflictError < PluginError; end
     class PluginNotAvailableError < PluginError; end
     class PluginLoadError < PluginError; end
 

lib/chronicle/etl/job_definition.rb

@@ -26,20 +26,32 @@ def initialize()
         @definition = SKELETON_DEFINITION
       end
 
+      def valid?
+        validate
+        @errors.empty?
+      end
+
       def validate
-        @errors = []
+        @errors = {}
 
         Chronicle::ETL::Registry::PHASES.each do |phase|
           __send__("#{phase}_klass".to_sym)
         rescue Chronicle::ETL::PluginError => e
-          @errors << e
+          @errors[:plugins] ||= []
+          @errors[:plugins] << e
         end
+      end
 
-        @errors.empty?
+      def plugins_missing?
+        validate
+
+        @errors[:plugins] || []
+          .filter { |e| e.instance_of?(Chronicle::ETL::PluginLoadError) }
+          .any?
       end
 
       def validate!
-        raise(Chronicle::ETL::JobDefinitionError.new(self), "Job definition is invalid") unless validate
+        raise(Chronicle::ETL::JobDefinitionError.new(self), "Job definition is invalid") unless valid?
 
         true
       end
@@ -48,7 +60,6 @@ def validate!
       def add_config(config = {})
         @definition = @definition.deep_merge(config)
         load_credentials
-        validate
       end
 
       # Is this job continuing from a previous run?

lib/chronicle/etl/registry/plugin_registry.rb

@@ -36,8 +36,11 @@ def self.activate(name)
           # By default, activates the latest available version of a gem
           # so don't have to run Kernel#gem separately
           require "chronicle/#{name}"
-        rescue LoadError
-          raise Chronicle::ETL::PluginLoadError.new(name), "Plugin #{name} couldn't be loaded" if exists?(name)
+        rescue Gem::ConflictError => e
+          # TODO: figure out if there's more we can do here
+          raise Chronicle::ETL::PluginConflictError.new(name), "Plugin '#{name}' couldn't be loaded. #{e.message}"
+        rescue LoadError => e
+          raise Chronicle::ETL::PluginLoadError.new(name), "Plugin '#{name}' couldn't be loaded" if exists?(name)
 
           raise Chronicle::ETL::PluginNotAvailableError.new(name), "Plugin #{name} doesn't exist"
         end
@@ -49,9 +52,11 @@ def self.install(name)
 
           Gem::DefaultUserInteraction.ui = Gem::SilentUI.new
           Gem.install(gem_name)
+
+          activate(name)
         rescue Gem::UnsatisfiableDependencyError
           # TODO: we need to catch a lot more than this here
-          raise Chronicle::ETL::PluginNotAvailableError.new(name), "Plugin #{name} doesn't exist"
+          raise Chronicle::ETL::PluginNotAvailableError.new(name), "Plugin #{name} could not be installed."
         end
 
         # Uninstall a plugin