twinshot 1.2.1 → 1.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 61129562a7595873fe7d577f08d2d98b5a7d608a4c021c1b76eb3b66533deca8
-  data.tar.gz: 1c78a3f84ad0edcffe46144084a959d7db5eadd0886baa9d348f72d8d89fb2d7
+  metadata.gz: c9826a2a05669fc0e17f6eba0e9c65974007862176b2944998982be28faf7f61
+  data.tar.gz: 4ff7da0c51c214ce05f27298669f8a3e787d7e9b61450d903c494aa66411bd4d
 SHA512:
-  metadata.gz: f71390ff6a0309a3d7f2008cb44cb96a902494275bbfc0993f0f3ff2cc492cf3f75fddffb6eecaf7b11fdc6ea23a892a892ed0324a364d2bd2f412bc96a21d07
-  data.tar.gz: 3984e3f511e04341b7ddaaf3089c9281c415988fa73590a248ca2d12a38ef080ffd934439b0a3d63a835eadb8965851833c379aeba88c77c5d9aaa4bc9e8c4ce
+  metadata.gz: b7997f0505c7414ed6305a3039d0058c5c6259e025cf30a154425586094a566056b4b22ca9fd6e5cf43a0d3327c245661c7d3f0839a7dcc0c80bcc0d607bbd7f
+  data.tar.gz: 332282358ce1a8bca3faa57798b577b48c334a2028f4aa3318ba45fd0acab3d099afbc184359e1b76ed927205538fb48362bd8a5c3d64001518be3152ef73901

data/lib/twinshot/cli.rb

@@ -4,6 +4,8 @@ require "json"
 require "optparse"
 require "shellwords"
 require "fileutils"
+require "English"
+require "colorize"
 require_relative "progress"
 
 module Twinshot
@@ -65,7 +67,7 @@ module Twinshot
         @err.puts global_parser
         EXIT_ERROR
       end
-    rescue OptionParser::ParseError, Config::Error, Compare::Error => e
+    rescue OptionParser::ParseError, Config::Error, Compare::Error, Lockfile::Error => e
       @err.puts "twinshot: #{e.message}"
       EXIT_ERROR
     end
@@ -196,7 +198,7 @@ module Twinshot
       end
 
       config = Config.load(@config_path)
-      run_compare(config, select_groups(config))
+      Lockfile.under(config) { run_compare(config, select_groups(config)) }
     end
 
     # The compare run shared by compare and review: compares the groups,
@@ -269,22 +271,24 @@ module Twinshot
       end
 
       config = Config.load(@config_path)
-      groups, side = generate_selection(config, @argv.shift)
-      if (extra = @argv.shift)
-        @err.puts "twinshot: unexpected argument #{extra.inspect}"
-        @err.puts generate_parser
-        return EXIT_ERROR
-      end
+      Lockfile.under(config) do
+        groups, side = generate_selection(config, @argv.shift)
+        if (extra = @argv.shift)
+          @err.puts "twinshot: unexpected argument #{extra.inspect}"
+          @err.puts generate_parser
+          next EXIT_ERROR
+        end
 
-      targets = generate_targets(groups, side)
-      if targets.empty?
-        what = side ? "#{side}.generate" : "generate"
-        scope = groups.size == 1 ? "for group #{groups.first.name}" : "in any selected group"
-        @err.puts "twinshot: no #{what} configured #{scope} in #{File.basename(config.path)}"
-        return EXIT_ERROR
-      end
+        targets = generate_targets(groups, side)
+        if targets.empty?
+          what = side ? "#{side}.generate" : "generate"
+          scope = groups.size == 1 ? "for group #{groups.first.name}" : "in any selected group"
+          @err.puts "twinshot: no #{what} configured #{scope} in #{File.basename(config.path)}"
+          next EXIT_ERROR
+        end
 
-      run_generate(config, targets) ? EXIT_OK : EXIT_DIFF
+        run_generate(config, targets) ? EXIT_OK : EXIT_DIFF
+      end
     end
 
     # The review command is generate + compare in one run: both sides of the selected
@@ -300,11 +304,18 @@ module Twinshot
       end
 
       config = Config.load(@config_path)
-      groups = select_groups(config)
-      targets = generate_targets(groups)
-      return run_compare(config, groups) if targets.empty?
-
-      run_generate(config, targets) ? run_compare(config, groups) : EXIT_DIFF
+      Lockfile.under(config) do
+        groups = select_groups(config)
+        targets = generate_targets(groups)
+        next run_compare(config, groups) if targets.empty?
+
+        unless run_generate(config, targets)
+          @err.puts err_paint("twinshot: generate failed — skipping compare " \
+                              "(a report over stale trees would be misleading)")
+          next EXIT_DIFF
+        end
+        run_compare(config, groups)
+      end
     end
 
     # Trees (group, side, command) with a generate command, in oracle-then-
@@ -319,15 +330,27 @@ module Twinshot
       end
     end
 
+    # Red for failures on stderr — but only when stderr is a tty, like
+    # Progress paints stdout (piped/CI logs stay plain).
+    def err_paint(text)
+      return text.to_s unless @err.tty?
+
+      text.to_s.red
+    end
+
     # Says the full list of trees about to be regenerated first, then runs
     # the commands one by one from the config's directory; a failing command
-    # doesn't stop the rest. true — all succeeded.
+    # doesn't stop the rest, it just says so on stderr. true — all succeeded.
     def run_generate(config, targets)
       @out.puts "Generate:"
       targets.each { |group, tree, _command| @out.puts "- #{group.name}/#{tree}" }
       targets.map do |group, tree, command|
         @out.puts "twinshot: [#{group.name}/#{tree}] #{command}"
-        system(command, chdir: config.root)
+        next true if system(command, chdir: config.root)
+
+        @err.puts err_paint("twinshot: [#{group.name}/#{tree}] generate command " \
+                            "failed with exit #{$CHILD_STATUS.exitstatus}")
+        false
       end.all?
     end
 

data/lib/twinshot/lockfile.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Twinshot
+  # One run at a time per project: while a command works on a config's
+  # trees, tmp/twinshot.pid in the config's directory holds the running
+  # pid. A second run refuses to start with a clear error; a pid file
+  # left behind by a crashed run is never removed automatically — it is
+  # reported so the user can remove it by hand.
+  class Lockfile
+    class Error < StandardError; end
+
+    # Where the lock lives, relative to the config's directory.
+    RELATIVE_PATH = File.join("tmp", "twinshot.pid").freeze
+
+    # Runs the block under the lock: acquires first, releases after —
+    # also on failure. Raises Error before the block starts when another
+    # run holds the lock or a stale pid file is in the way.
+    def self.under(config)
+      lock = new(File.join(config.root, RELATIVE_PATH))
+      lock.acquire
+      begin
+        yield
+      ensure
+        lock.release
+      end
+    end
+
+    def initialize(path)
+      @path = path
+      @held = false
+    end
+
+    # Creates the pid file atomically (O_EXCL), so two runs starting at
+    # the same moment can't both win; the loser gets the "already
+    # running" error from the winner's pid.
+    def acquire
+      FileUtils.mkdir_p(File.dirname(@path))
+      File.open(@path, File::CREAT | File::EXCL | File::WRONLY) { |f| f.write(Process.pid.to_s) }
+      @held = true
+    rescue Errno::EEXIST
+      raise Error, taken_message if File.exist?(@path)
+
+      retry # vanished between EEXIST and the check — try to take it again
+    end
+
+    # Removes the pid file. Only the run that created it releases, and a
+    # file already gone (a stray `rm`, say) is fine.
+    def release
+      return unless @held
+
+      File.delete(@path)
+    rescue Errno::ENOENT
+      nil
+    ensure
+      @held = false
+    end
+
+    private
+
+    # The error when the pid file is already there: a live pid means
+    # another run is active; a dead or unreadable pid means a leftover
+    # from a crashed run — the user removes it manually.
+    def taken_message
+      pid = Integer(File.read(@path).strip, 10)
+      raise ArgumentError if pid <= 0 # a real process pid is always positive
+
+      return "another twinshot run is already active (pid #{pid}, see #{RELATIVE_PATH}) — wait for it to finish" if alive?(pid)
+
+      "#{RELATIVE_PATH} holds pid #{pid}, but that process is not running — " \
+        "it may be left over from a crashed run; remove #{RELATIVE_PATH} manually and try again"
+    rescue Errno::ENOENT, ArgumentError
+      "#{RELATIVE_PATH} exists but holds no readable pid — " \
+        "it may be left over from a crashed run; remove #{RELATIVE_PATH} manually and try again"
+    end
+
+    # Signal 0 is the existence probe, and it is cross-platform: POSIX
+    # sends nothing and just checks, while Ruby's Windows build maps it
+    # onto OpenProcess. EPERM (Unix) and EACCES (Windows) mean the
+    # process is there but not ours; ESRCH — on both — means the pid is
+    # gone. One caveat: on Windows a child that exited but was not
+    # reaped can still answer (like a Unix zombie); that only makes the
+    # check err on the safe side — the error tells the user to wait.
+    def alive?(pid)
+      Process.kill(0, pid)
+      true
+    rescue Errno::EPERM, Errno::EACCES
+      true
+    rescue Errno::ESRCH
+      false
+    end
+  end
+end

data/lib/twinshot/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Twinshot
-  VERSION = "1.2.1"
+  VERSION = "1.2.2"
 end

data/lib/twinshot.rb

@@ -8,6 +8,7 @@ require_relative "twinshot/compare"
 require_relative "twinshot/progress"
 require_relative "twinshot/report"
 require_relative "twinshot/opener"
+require_relative "twinshot/lockfile"
 require_relative "twinshot/cli"
 
 # Twinshot: 1:1 artifact parity between a verified oracle tree and a current

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: twinshot
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.2.2
 platform: ruby
 authors:
 - Oleg Orlov
@@ -92,6 +92,7 @@ files:
 - lib/twinshot/compare.rb
 - lib/twinshot/compare_worker.rb
 - lib/twinshot/config.rb
+- lib/twinshot/lockfile.rb
 - lib/twinshot/logo.svg
 - lib/twinshot/opener.rb
 - lib/twinshot/opener/darwin.rb