warg 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a2f032dcff2708b375e016c4ed2b8809ef80784c1fa3845cf5e480c279003fd7
-  data.tar.gz: c17eab82ffa3f6e1ae78e1aeabaf460c2596d1d4d7c9c9633be7112d3687d7b7
+  metadata.gz: d96b90a94c51248029193228a27c43ef63e630b671a03f2cc5b5791878ef0456
+  data.tar.gz: 946d2c64356f0f9033ba9bb1bac0694737ad34c8a0d92c0fd990c2f3aede0913
 SHA512:
-  metadata.gz: 8b11f96e8c293f3005767d6471b58e04942121d8b87dbb6f61a9094182cbad8dc779e46c9f6c1d92ce0338e92a85a2231b58a88a1b2e55124028a8141ea04f64
-  data.tar.gz: 700b611540d8f704e8ea57d11d5be633c78a6e8050745f22a1096dd40e7eebf17f27a2f6280ba4e3c3cdca404fd8799f883f9b03ae6b65f7ac2944a557f685af
+  metadata.gz: eb1096029b3b316d249c813463440fae0264872b8be04e88c82dd97d3c9b8f592b0dc072bcbcc8e330fe9a44dedb8fe123d0f60f91b00c2d5afeb3ebe10b310f
+  data.tar.gz: 44c808ba4a6d3468a4a3594b9cd10183cf6b87cfc3613caa9c373143ea57b0b97e96fe4c0c8095251d0e50e6329153402e9700c5e68e1684fe3c6298bb0b569b

data/bin/console-playground

@@ -23,7 +23,6 @@ end
 require "pry"
 
 # NOTE: Unsure why `"set"` needs to be loaded here
-require "set"
 require "warg"
 
 console = Warg::Console.new

data/lib/warg.rb

@@ -594,38 +594,6 @@ module Warg
       outcome
     end
 
-    def defer(command, banner, &block)
-      run_object = BlockProxy.new(banner, &block)
-      hosts = CollectionProxy.new
-
-      Executor::Deferred.new(command, run_object, hosts, :serial)
-    end
-
-    class BlockProxy
-      def initialize(banner, &block)
-        @banner = banner
-        @block = block
-      end
-
-      def to_s
-        @banner.dup
-      end
-
-      def to_proc
-        @block
-      end
-    end
-
-    class CollectionProxy
-      def run_block(run_object, **)
-        outcome = LOCALHOST.run(&run_object)
-
-        execution_result = Executor::Result.new
-        execution_result.update(outcome)
-        execution_result
-      end
-    end
-
     class CommandOutcome
       attr_accessor :error
 
@@ -683,6 +651,10 @@ module Warg
         end
       end
 
+      def failure_reason
+        error
+      end
+
       def failure_summary
         error && error.full_message
       end
@@ -1378,11 +1350,12 @@ module Warg
   class Context < Config
     attr_reader :argv
     attr_reader :parser
+    attr_reader :playlist
 
-    def initialize(argv)
+    def initialize(argv, playlist)
       @argv = argv
+      @playlist = playlist
       @parser = OptionParser.new
-      @playlist = Playlist.new
 
       @parser.on("-t", "--target HOSTS", Array, "hosts to use") do |hosts_data|
         hosts_data.each { |host_data| hosts.add(host_data) }
@@ -1395,16 +1368,6 @@ module Warg
       @parser.parse(@argv)
     end
 
-    def queue!(command)
-      @playlist.queue(command)
-    end
-
-    def run!
-      Console.hostname_width = hosts.map { |host| host.address.length }.max
-
-      @playlist.start
-    end
-
     def copy(config)
       config.hosts.each do |host|
         hosts.add(host)
@@ -1416,30 +1379,53 @@ module Warg
         end
       end
     end
+  end
 
-    class Playlist
-      def initialize
-        @playing_at = 0
-        @insert_at = 0
-        @items = []
-        @started = false
-      end
+  class Playlist
+    attr_reader :insert_at
 
-      def start
-        @started = true
-        @insert_at = 1
+    def initialize
+      @start = @insert_at = Start.new
+    end
+
+    def play
+      playing = @insert_at = @start
+      command = nil
+
+      while playing.next
+        playing = @insert_at = playing.next
+
+        if command != playing.command
+          command = playing.command
+
+          Warg.console.puts Console::SGR(command.command_name.console).with(text_color: :blue, effect: :bold)
+        end
+
+        Warg.console.puts Console::SGR(" -> #{playing.banner}").with(text_color: :magenta)
 
-        until @playing_at >= @items.length
-          @items[@playing_at].run
+        result = playing.run
 
-          @playing_at += 1
-          @insert_at = @playing_at + 1
+        if result.failed?
+          command.on_failure(result)
         end
       end
+    end
+
+    def queue(command_step)
+      if @insert_at.next
+        command_step.next = @insert_at.next
+      end
+
+      command_step.previous = @insert_at
+      @insert_at.next = command_step
+
+      @insert_at = command_step
+    end
+
+    class Start
+      attr_accessor :next
 
-      def queue(command)
-        @items.insert(@insert_at, command)
-        @insert_at += 1
+      def previous
       end
     end
   end
@@ -1448,11 +1434,12 @@ module Warg
     def initialize(argv)
       @argv = argv.dup
       @path = nil
+      @playlist = Playlist.new
 
       find_warg_directory!
       load_config!
 
-      @context = Context.new(@argv)
+      @context = Context.new(@argv, @playlist)
       @context.copy(Warg.config)
 
       load_scripts!
@@ -1470,8 +1457,10 @@ module Warg
       @command.(@context)
       @context.parse_options!
 
+      Console.hostname_width = @context.hosts.map { |host| host.address.length }.max
+
       Warg.console.redirecting_stdout_and_stderr do
-        @context.run!
+        @playlist.play
       end
     end
 
@@ -1545,7 +1534,7 @@ module Warg
                 object = Class.new do
                   include Command::BehaviorWithoutRegistration
 
-                  def setup
+                  def run
                     run_script
                   end
                 end
@@ -1619,127 +1608,6 @@ module Warg
       end
     end
 
-    class Deferred
-      def initialize(command, run_object, hosts, order, &setup)
-        @command = command
-        @run_object = run_object
-        @hosts = hosts
-        @order = order
-        @setup = setup
-
-        @callbacks_queue = CallbacksQueue.new(order)
-
-        @run_type = case @run_object
-                    when Script
-                      :run_script
-                    when String
-                      :run_command
-                    when Localhost::BlockProxy
-                      :run_block
-                    end
-      end
-
-      def banner
-        @run_object
-      end
-
-      def and_then(&block)
-        @callbacks_queue << block
-        self
-      end
-
-      def run
-        execution_result = @hosts.public_send(@run_type, @run_object, order: @order, &@setup)
-
-        execution_result = @callbacks_queue.drain(execution_result)
-
-        if execution_result.failed?
-          @command.on_failure(execution_result)
-        end
-
-        execution_result
-      end
-
-      class CallbacksQueue
-        def initialize(execution_order)
-          @queue = []
-          @executor_class = Executor.for(execution_order)
-        end
-
-        def <<(callback)
-          @queue << callback
-        end
-
-        def drain(execution_result)
-          drain_queue = @queue.dup
-
-          # NOTE: It would be nice to incorporate the failure callback into the code here
-          until drain_queue.empty? || execution_result.failed?
-            callback = drain_queue.shift
-            executor = @executor_class.new(execution_result)
-
-            execution_result = executor.run do |outcome, result|
-              callback_outcome = Outcome.new(outcome)
-
-              begin
-                # Use `||=` in case `#value` is set in the callback
-                callback_outcome.value ||= callback.(outcome.host, outcome.value, callback_outcome)
-              rescue => error
-                callback_outcome.error = error
-              end
-
-              result.update callback_outcome
-            end
-          end
-
-          execution_result
-        end
-
-        class Outcome
-          attr_reader :error
-          attr_reader :host
-          attr_reader :source_outcome
-          attr_accessor :value
-
-          def initialize(outcome)
-            @source_outcome = outcome
-            @host = @source_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_summary
-            error && error.full_message
-          end
-        end
-      end
-
-      class CallbackFailedError < StandardError
-      end
-    end
-
     class Result
       include Enumerable
       extend Forwardable
@@ -1924,9 +1792,8 @@ module Warg
       attr_reader :argv
       attr_reader :context
       attr_reader :hosts
-      attr_reader :operations
       attr_reader :parser
-      attr_reader :steps
+      attr_reader :playlist
 
       def initialize(context)
         @context = context
@@ -1934,11 +1801,9 @@ module Warg
         @parser = @context.parser
         @hosts = @context.hosts
         @argv = @context.argv.dup
+        @playlist = @context.playlist
 
         configure_parser!
-
-        @context.queue!(self)
-        @steps = []
       end
 
       def name
@@ -1946,20 +1811,11 @@ module Warg
       end
 
       def call
-        setup
+        run
         self
       end
 
-      def setup
-      end
-
       def run
-        Warg.console.puts Console::SGR(command_name.console).with(text_color: :blue, effect: :bold)
-
-        @steps.each do |deferred|
-          Warg.console.puts Console::SGR(" -> #{deferred.banner}").with(text_color: :magenta)
-          deferred.run
-        end
       end
 
       def command_name
@@ -1984,6 +1840,10 @@ module Warg
         Console::SGR(text)
       end
 
+      def and_then(order: :parallel, &block)
+        @playlist.queue Step.callback(self, @playlist.insert_at, order, block)
+      end
+
       private
 
       def configure_parser!
@@ -1993,21 +1853,21 @@ module Warg
         script_name ||= command_name.script
         script = Script.new(script_name, context)
 
-        append Executor::Deferred.new(self, script, on, order, &setup)
+        queue Step.new(self, script, on, order, &setup)
       end
 
       def run_command(command, on: hosts, order: :parallel, &setup)
-        append Executor::Deferred.new(self, command, on, order, &setup)
+        queue Step.new(self, command, on, order, &setup)
       end
 
       def on_localhost(banner, &block)
-        append LOCALHOST.defer(self, banner, &block)
+        queue Step.local(self, banner, block)
       end
       alias locally on_localhost
 
-      def append(deferred)
-        @steps << deferred
-        deferred
+      def queue(step)
+        @playlist.queue(step)
+        step
       end
     end
 
@@ -2025,6 +1885,141 @@ module Warg
         klass.extend(Chaining)
       end
     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
+      end
+
+      attr_reader :command
+      attr_reader :hosts
+      attr_accessor :next
+      attr_accessor :previous
+      attr_reader :result
+
+      def initialize(command, run_object, hosts, order, &setup)
+        @command = command
+        @run_object = run_object
+        @hosts = hosts
+        @order = order
+        @setup = setup
+      end
+
+      def banner
+        @run_object
+      end
+
+      def and_then(order: :parallel, &block)
+        @command.and_then order: order, &block
+      end
+
+      def run
+        @result = case @run_object
+                  when String
+                    @hosts.run_command(@run_object, order: @order, &@setup)
+                  when Script
+                    @hosts.run_script(@run_object, order: @order, &@setup)
+                  when Callback
+                    @run_object.run(@order)
+                  when BlockProxy
+                    # NOTE: A `Proc` means `@hosts` is `LOCALHOST`
+                    Executor::Result.new.tap do |result|
+                      result.update LOCALHOST.run(&@run_object)
+                    end
+                  end
+      end
+
+      class BlockProxy < Struct.new(:banner, :block)
+        def to_s
+          banner
+        end
+
+        def to_proc
+          block
+        end
+      end
+
+      class Callback
+        def initialize(last_step, run_object)
+          @last_step = last_step
+          @run_object = run_object
+        end
+
+        def run(order)
+          Executor.for(order).new(@last_step.result).run do |last_outcome, result|
+            callback_outcome = Outcome.new(last_outcome)
+
+            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
+
+            result.update callback_outcome
+          end
+        end
+
+        def to_s
+          "(callback)"
+        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
+        end
+      end
+
+      class CallbackFailedError < StandardError
+      end
+    end
   end
 
   class ChainCommand

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: warg
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Eduardo Gutierrez
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-11-16 00:00:00.000000000 Z
+date: 2023-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bcrypt_pbkdf
@@ -120,6 +120,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.13'
+- !ruby/object:Gem::Dependency
+  name: pry-remote
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -179,7 +193,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.2.3
 signing_key:
 specification_version: 4
 summary: Light-weight interaction with servers