bopeep 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0c6ba8791b9e8e28d2650fcbed8846c95b86d210758362119e6ebaf67ae79644
-  data.tar.gz: 74d7390521096432e82a3e5aca5eb8ce70ed090f46136aa64bc2adaa758e739c
+  metadata.gz: 225fd316f342c4a23f15c428d44816f55ce5760e20d2aceef2e84ac27784c218
+  data.tar.gz: 43e00f49265f4bcac5dc99f1917ecf8d85151a42aea4da86177befebe13a03a0
 SHA512:
-  metadata.gz: 57bb72361cf6ebbee6602ba7988cd2760b519b16c5feccf05d1ff6074bdc069fb036320182871664bc9a3720085d4a0a4955ed65133866edb7e731db0a384df4
-  data.tar.gz: 3ceb06f5ffdc5c10643a21eee61623081736165c211b2bf16dbf53e2fee0df90d14879b6434bada1b5c0b46129d2310ca39489bac5f17195d1b68bfbfea5d7ed
+  metadata.gz: 8e540b83379b5661c897286b30170bda85b72fa6cad22f5cdd7fe0e0bbb7a6924cb33404a24193aeff4bfb7b7e14e749d9f16499bdb1167c1d10ed1f5cfac494
+  data.tar.gz: 13883aa073f0cb2739c0e7c203833cb53c232724d30110578a92bf2d9a0dde71bf936d3c5239a83e2f84da8872b8eb21eb1b52ec544ffa87c2009750157ca19d

data/lib/bopeep.rb

@@ -424,7 +424,7 @@ module BoPeep
     class HostStatus
       attr_accessor :row_number
 
-      def initialize(host, console)
+      def initialize(host, console = BoPeep.console)
         @host = host
         @console = console
 
@@ -475,6 +475,19 @@ module BoPeep
 
         content
       end
+
+      class DevNull
+        def started!
+        end
+
+        def failed!(*)
+        end
+
+        def success!
+        end
+      end
+
+      DEV_NULL = DevNull.new
     end
 
     class SelectGraphicRendition
@@ -579,8 +592,8 @@ module BoPeep
       "localhost"
     end
 
-    def run
-      outcome = CommandOutcome.new
+    def run(callbacks: nil, log: false)
+      outcome = CommandOutcome.new(callbacks: callbacks, log: log)
 
       begin
         outcome.command_started!
@@ -597,8 +610,15 @@ module BoPeep
     class CommandOutcome
       attr_accessor :error
 
-      def initialize
-        @console_status = Console::HostStatus.new(LOCALHOST, BoPeep.console)
+      def initialize(callbacks: nil, log:)
+        @callbacks = Host::Callbacks.from(callbacks)
+
+        if log
+          @console_status = Console::HostStatus.new(LOCALHOST)
+        else
+          @console_status = Console::HostStatus::DEV_NULL
+        end
+
         @started_at = nil
         @finished_at = nil
       end
@@ -624,8 +644,10 @@ module BoPeep
 
         if successful?
           @console_status.success!
+          @callbacks.on_success(self)
         else
           @console_status.failed!(failure_summary)
+          @callbacks.on_failure(self)
         end
       end
 
@@ -774,8 +796,8 @@ module BoPeep
       inspect.hash
     end
 
-    def run_command(command, &setup)
-      outcome = CommandOutcome.new(self, command, &setup)
+    def run_command(command, callbacks: nil, log: false, &setup)
+      outcome = CommandOutcome.new(self, command, callbacks: callbacks, log: log, &setup)
 
       connection.open_channel do |channel|
         channel.exec(command) do |_, success|
@@ -817,12 +839,12 @@ module BoPeep
       outcome
     end
 
-    def run_script(script, &setup)
+    def run_script(script, callbacks: nil, log: false, &setup)
       create_directory script.install_directory
 
       create_file_from script.content, path: script.install_path, mode: 0755
 
-      run_command(script.remote_path, &setup)
+      run_command(script.remote_path, callbacks: callbacks, log: log, &setup)
     end
 
     def create_directory(directory)
@@ -906,6 +928,83 @@ module BoPeep
       @id = Digest::SHA1.hexdigest(@uri.to_s)
     end
 
+    class Callbacks
+      def on_stdout(data)
+      end
+
+      def on_stderr(data)
+      end
+
+      def on_success(command_outcome)
+      end
+
+      def on_failure(command_outcome)
+      end
+
+      class Proxy
+        extend Forwardable
+
+        def_delegators :@callbacks, :on_stdout, :on_stderr, :on_success, :on_failure
+
+        def initialize(callbacks)
+          @callbacks = callbacks
+        end
+
+        def method_missing(name, *args, &block)
+          if @callbacks.respond_to?(name)
+            @callbacks.send(name, *args, &block)
+          else
+            super
+          end
+        end
+
+        protected
+
+        def respond_to_missing?(name, include_private = false)
+          @callbacks.respond_to_missing?(name, include_private) || super
+        end
+      end
+
+      class Definition
+        attr_reader :callbacks
+
+        def initialize(callbacks = nil, &setup)
+          if callbacks
+            @callbacks = Proxy.new(callbacks)
+          else
+            @callbacks = Callbacks.new
+          end
+
+          case setup&.arity
+          when 1
+            setup.call(self)
+          when 0
+            instance_eval(&setup)
+          end
+        end
+
+        def on_stdout(&block)
+          @callbacks.singleton_class.define_method(:on_stdout, &block)
+        end
+
+        def on_stderr(&block)
+          @callbacks.singleton_class.define_method(:on_stderr, &block)
+        end
+
+        def on_success(&block)
+          @callbacks.singleton_class.define_method(:on_success, &block)
+        end
+
+        def on_failure(&block)
+          @callbacks.singleton_class.define_method(:on_failure, &block)
+        end
+      end
+
+      def self.from(callbacks = nil, &setup)
+        Definition.new(callbacks, &setup).callbacks
+      end
+    end
+
     class CommandOutcome
       attr_reader :command
       attr_reader :connection_error_code
@@ -920,46 +1019,37 @@ module BoPeep
       attr_reader :stderr
       attr_reader :stdout
 
-      def initialize(host, command, &setup)
+      def initialize(host, command, callbacks: nil, log: false, &setup)
         @host = host
         @command = command
 
-        @console_status = Console::HostStatus.new(host, BoPeep.console)
+        if log
+          @console_status = Console::HostStatus.new(host)
+        else
+          @console_status = Console::HostStatus::DEV_NULL
+        end
 
         @stdout = ""
-        @stdout_callback = proc {}
-
         @stderr = ""
-        @stderr_callback = proc {}
 
         @started_at = nil
         @finished_at = nil
 
-        if setup
-          instance_eval(&setup)
-        end
+        @callbacks = Callbacks.from(callbacks, &setup)
       end
 
       def value
         self
       end
 
-      def on_stdout(&block)
-        @stdout_callback = block
-      end
-
       def collect_stdout(data)
         @stdout << data
-        @stdout_callback.call(data)
-      end
-
-      def on_stderr(&block)
-        @stderr_callback = block
+        @callbacks.on_stdout(data)
       end
 
       def collect_stderr(data)
         @stderr << data
-        @stderr_callback.call(data)
+        @callbacks.on_stderr(data)
       end
 
       def successful?
@@ -986,6 +1076,7 @@ module BoPeep
 
           if failed?
             @failure_reason = :nonzero_exit_status
+            @callbacks.on_failure(self)
           end
         end
 
@@ -1000,6 +1091,8 @@ module BoPeep
           @exit_signal.freeze
 
           @failure_reason = :exit_signal
+
+          @callbacks.on_failure(self)
         end
 
         value
@@ -1034,6 +1127,7 @@ module BoPeep
 
           if successful?
             @console_status.success!
+            @callbacks.on_success(self)
           else
             @console_status.failed!(failure_summary)
           end
@@ -1049,6 +1143,8 @@ module BoPeep
         unless started?
           @console_status.failed!(failure_summary)
         end
+
+        @callbacks.on_failure(self)
       end
 
       def failure_summary
@@ -1192,15 +1288,15 @@ module BoPeep
         end
       end
 
-      def run_script(script, order: :parallel, &setup)
+      def run_script(script, order: :parallel, callbacks: nil, log: false, &setup)
         run(order: order) do |host, result|
-          result.update host.run_script(script, &setup)
+          result.update host.run_script(script, callbacks: callbacks, log: log, &setup)
         end
       end
 
-      def run_command(command, order: :parallel, &setup)
+      def run_command(command, order: :parallel, callbacks: nil, log: false, &setup)
         run(order: order) do |host, result|
-          result.update host.run_command(command, &setup)
+          result.update host.run_command(command, callbacks: callbacks, log: log, &setup)
         end
       end
 
@@ -1297,6 +1393,7 @@ module BoPeep
   class Config
     attr_accessor :default_user
     attr_reader :hosts
+    attr_accessor :on_failure_command
     attr_reader :variables_sets
 
     def initialize
@@ -1318,7 +1415,7 @@ module BoPeep
       end
     end
 
-    def variables(name, &block)
+    def variables(name)
       variables_name = name.to_s
       ivar_name = "@#{variables_name}"
 
@@ -1331,7 +1428,7 @@ module BoPeep
         variables_object = instance_variable_set(ivar_name, VariableSet.new(variables_name, self))
       end
 
-      block.call(variables_object)
+      yield variables_object
     end
 
     class VariableSet
@@ -1352,15 +1449,25 @@ module BoPeep
         @properties.include?(property_name.to_s)
       end
 
-      def define!(property_name)
-        @properties << property_name.to_s
+      def define!(property_name, value = nil, &block)
+        property_name = property_name.to_s
+
+        if self.defined?(property_name)
+          raise ArgumentError, "`#{@_name}.#{property_name}' is already defined"
+        elsif Property::REGEXP.match?(property_name)
+          @properties << property_name
+
+          extend Property.new(property_name, block || value)
+        else
+          raise ArgumentError, "`#{property_name}' is not a valid property name"
+        end
       end
 
       def copy(other)
         other.properties.each do |property_name|
           value = other.instance_variable_get("@#{property_name}")
 
-          extend Property.new(property_name, value)
+          define!(property_name, value)
         end
       end
 
@@ -1378,7 +1485,7 @@ module BoPeep
         writer_name = name.to_s
         reader_name = writer_name.chomp("=")
 
-        if reader_name !~ Property::REGEXP
+        if ! Property::REGEXP.match?(reader_name)
           super
         elsif reader_name == writer_name && block.nil?
           $stderr.puts "`#{@_name}.#{reader_name}' was accessed before it was defined"
@@ -1386,7 +1493,7 @@ module BoPeep
         elsif writer_name.end_with?("=") or not block.nil?
           value = block || args
 
-          extend Property.new(reader_name, *value)
+          define!(reader_name, *value)
         end
       end
 
@@ -1401,8 +1508,6 @@ module BoPeep
         end
 
         def extended(variables_set)
-          variables_set.define! @name
-
           variables_set.singleton_class.class_eval <<-PROPERTY_METHODS
             attr_writer :#{@name}
 
@@ -1433,9 +1538,9 @@ module BoPeep
     attr_reader :parser
     attr_reader :playlist
 
-    def initialize(argv, playlist)
+    def initialize(argv)
       @argv = argv
-      @playlist = playlist
+      @playlist = Playlist.new(self)
       @parser = OptionParser.new
 
       @parser.on("-t", "--target HOSTS", Array, "hosts to use") do |hosts_data|
@@ -1462,24 +1567,37 @@ module BoPeep
         hosts.add(host)
       end
 
+      self.on_failure_command = config.on_failure_command
+
       config.variables_sets.each do |variables_name|
         variables(variables_name) do |variables_object|
           variables_object.copy config.instance_variable_get("@#{variables_name}")
         end
       end
     end
+
+    def on_failure_command
+      case @on_failure_command
+      when String
+        Object.const_get(@on_failure_command)
+      else
+        @on_failure_command
+      end
+    end
   end
 
   class Playlist
     attr_reader :insert_at
 
-    def initialize
+    def initialize(context)
+      @context = context
       @start = @insert_at = Start.new
     end
 
     def play
       playing = @insert_at = @start
       command = nil
+      on_failure_command_used = false
 
       while playing.next
         playing = @insert_at = playing.next
@@ -1487,15 +1605,23 @@ module BoPeep
         if command != playing.command
           command = playing.command
 
-          BoPeep.console.puts Console::SGR(command.command_name.console).with(text_color: :blue, effect: :bold)
+          playing.log_command
         end
 
-        BoPeep.console.puts Console::SGR(" -> #{playing.banner}").with(text_color: :magenta)
+        playing.log_step
 
         result = playing.run
 
         if result.failed?
-          command.on_failure(result)
+          if @context.on_failure_command && on_failure_command_used == false
+            playing.next = nil
+            @context.on_failure_command.(@context)
+            # Prevents infinite loops if `on_failure_command` fails
+            on_failure_command_used = true
+          else
+            # This is redefined in `test/test_helper.rb` to avoid exiting the test process
+            exit 1
+          end
         end
       end
     end
@@ -1523,12 +1649,11 @@ module BoPeep
     def initialize(argv)
       @argv = argv.dup
       @path = nil
-      @playlist = Playlist.new
 
       find_bopeep_directory!
       load_config!
 
-      @context = Context.new(@argv, @playlist)
+      @context = Context.new(@argv)
       @context.copy(BoPeep.config)
 
       load_scripts!
@@ -1550,7 +1675,7 @@ module BoPeep
       Console.hostname_width = @context.hosts.map { |host| host.address.length }.max
 
       BoPeep.console.redirecting_stdout_and_stderr do
-        @playlist.play
+        @context.playlist.play
       end
     end
 
@@ -1922,16 +2047,20 @@ module BoPeep
         end
       end
 
-      def on_failure(execution_result)
-        exit 1
+      def on_stdout(data)
       end
 
-      def SGR(text)
-        Console::SGR(text)
+      def on_stderr(data)
       end
 
-      def and_then(order: :parallel, &block)
-        @playlist.queue Step.callback(self, @playlist.insert_at, order, block)
+      def on_success(command_outcome)
+      end
+
+      def on_failure(command_outcome)
+      end
+
+      def SGR(text)
+        Console::SGR(text)
       end
 
       private
@@ -1939,19 +2068,19 @@ module BoPeep
       def configure_parser!
       end
 
-      def run_script(script_name = nil, on: hosts, order: :parallel, &setup)
+      def run_script(script_name = nil, on: hosts, **options, &setup)
         script_name ||= command_name.script
         script = Script.new(script_name, context)
 
-        queue Step.new(self, script, on, order, &setup)
+        queue Step.new(self, script, on, **options, &setup)
       end
 
-      def run_command(command, on: hosts, order: :parallel, &setup)
-        queue Step.new(self, command, on, order, &setup)
+      def run_command(command, on: hosts, **options, &setup)
+        queue Step.new(self, command, on, **options, &setup)
       end
 
-      def on_localhost(banner, &block)
-        queue Step.local(self, banner, block)
+      def on_localhost(banner, **options, &block)
+        queue Step.local(self, banner, block, **options)
       end
       alias locally on_localhost
 
@@ -1977,16 +2106,8 @@ module BoPeep
     end
 
     class Step
-      def self.local(command, banner, block)
-        new(command, BlockProxy.new(banner, block), LOCALHOST, :serial)
-      end
-
-      def self.callback(command, last_step, order, block)
-        new \
-          command,
-          Callback.new(last_step, block),
-          last_step.hosts,
-          order
+      def self.local(command, banner, block, **options)
+        new(command, BlockProxy.new(banner, block), LOCALHOST, **options)
       end
 
       attr_reader :command
@@ -1995,120 +2116,70 @@ module BoPeep
       attr_accessor :previous
       attr_reader :result
 
-      def initialize(command, run_object, hosts, order, &setup)
+      def initialize(command, run_object, hosts, order: nil, log: nil, &setup)
         @command = command
         @run_object = run_object
         @hosts = hosts
-        @order = order
-        @setup = setup
+        @order = order || :parallel
+        @log = log.nil? ? true : log
+        @callbacks_definition = Host::Callbacks::Definition.new(command, &setup)
       end
 
-      def banner
-        @run_object
-      end
-
-      def and_then(order: :parallel, &block)
-        @command.and_then order: order, &block
+      def log?
+        @log
       end
 
       def run
         @result = case @run_object
                   when String
-                    @hosts.run_command(@run_object, order: @order, &@setup)
+                    @hosts.run_command(@run_object, order: @order, callbacks: @callbacks_definition.callbacks, log: @log)
                   when Script
-                    @hosts.run_script(@run_object, order: @order, &@setup)
-                  when Callback
-                    @run_object.run(@order)
+                    @hosts.run_script(@run_object, order: @order, callbacks: @callbacks_definition.callbacks, log: @log)
                   when BlockProxy
                     # NOTE: A `Proc` means `@hosts` is `LOCALHOST`
                     Executor::Result.new.tap do |result|
-                      result.update LOCALHOST.run(&@run_object)
+                      result.update LOCALHOST.run(callbacks: @callbacks_definition.callbacks, log: @log, &@run_object)
                     end
                   end
       end
 
-      class BlockProxy < Struct.new(:banner, :block)
-        def to_s
-          banner
+      def log_command
+        if log?
+          BoPeep.console.puts Console::SGR(command.command_name.console).with(text_color: :blue, effect: :bold)
         end
+      end
 
-        def to_proc
-          block
+      def log_step
+        if log?
+          BoPeep.console.puts Console::SGR(" -> #{@run_object}").with(text_color: :magenta)
         end
       end
 
-      class Callback
-        def initialize(last_step, run_object)
-          @last_step = last_step
-          @run_object = run_object
-        end
+      def on_stdout(&block)
+        @callbacks_definition.on_stdout(&block)
+      end
 
-        def run(order)
-          Executor.for(order).new(@last_step.result).run do |last_outcome, result|
-            callback_outcome = Outcome.new(last_outcome)
+      def on_stderr(&block)
+        @callbacks_definition.on_stderr(&block)
+      end
 
-            begin
-              # Use `||=` in case `#value` is set in the callback
-              callback_outcome.value ||= @run_object.(last_outcome.host, last_outcome.value, callback_outcome)
-            rescue => error
-              callback_outcome.error = error
-            end
+      def on_success(&block)
+        @callbacks_definition.on_success(&block)
+      end
 
-            result.update callback_outcome
-          end
-        end
+      def on_failure(&block)
+        @callbacks_definition.on_failure(&block)
+      end
 
+      class BlockProxy < Struct.new(:banner, :block)
         def to_s
-          "(callback)"
+          banner
         end
 
-        class Outcome
-          attr_reader :error
-          attr_reader :host
-          attr_reader :last_outcome
-          attr_accessor :value
-
-          def initialize(outcome)
-            @last_outcome = outcome
-            @host = @last_outcome.host
-            @successful = true
-          end
-
-          def resolve(value)
-            @value = value
-          end
-
-          def fail!(message)
-            @successful = false
-
-            raise CallbackFailedError.new(message)
-          end
-
-          def error=(error)
-            @successful = false
-            @error = error
-          end
-
-          def successful?
-            @successful
-          end
-
-          def failed?
-            !successful?
-          end
-
-          def failure_reason
-            error
-          end
-
-          def failure_summary
-            error && error.full_message
-          end
+        def to_proc
+          block
         end
       end
-
-      class CallbackFailedError < StandardError
-      end
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bopeep
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - Eduardo Gutierrez
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-07-20 00:00:00.000000000 Z
+date: 2024-08-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bcrypt_pbkdf