wslc-wip 0.4.0 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c1e6e4afaf5e33e69fa5dd6dc35f4fc32695e9916b0ceeac998ae58334fab3d4
-  data.tar.gz: 56e438283cad62937ac37132bb49048a1159897de4d3058c122f14272bca9e68
+  metadata.gz: da7bb5fa632921c307adeeea727e792d38e688204393dfd3ee2c7759e40791b4
+  data.tar.gz: 2e2a277a4ab2dcf0ce540778b6263a142553430452905924f67158dc13ffed54
 SHA512:
-  metadata.gz: 29bfbc9430132bf62ae58813e333f64df00d9228ad98386f3374e3a0de897e55605b977d7208bf7ce9622957e0a3acd1d598e25f25a594eed839fc7007deb37d
-  data.tar.gz: 8588e1b97851a59936bb42daf6a8d09002e1c3fdba12dafba0a35bfe8a1c9e430742bee1b8f818a677b83cc793f6b96151be1d729f7465632c3c368d9b518cd8
+  metadata.gz: f71156a19e193d0402f2fa4dc501aca0f32b27d63807c20b7a1a8dcddf1932f091af8ec12a0310aac36084a6c28034d843100abbf4adc3ac9c081d4e9304c18c
+  data.tar.gz: 538f842fd08441c9ec1603fc147d7c5ce7a5c6f2f2ce22edd0673b12709da19a6c23d3e7f1231a73d69d675337f09a17bc312aa07792308df414f1130e11b2a5

data/README.md

@@ -5,6 +5,8 @@
 [![License: MIT](https://img.shields.io/github/license/slidict/wip.svg)](LICENSE)
 [![Ruby](https://img.shields.io/badge/ruby-%3E%3D%203.2-red.svg)](wslc-wip.gemspec)
 
+Homepage: https://wslc-wip.slidict.com/
+
 `wip` is a Ruby-built OSS CLI wrapper that brings a [`dip`](https://github.com/bibendi/dip)-like
 workflow to Microsoft WSLC. It collects a project's container, image, environment variables, and
 commands into a single `wip.yml`, and forwards them to `wslc.exe` / `wslc` as safe argument arrays
@@ -127,8 +129,32 @@ dependencies down (the network itself is left in place). Each dependency entry a
 | `wip NAME ARGS...` | Run `commands.NAME`, appending any extra arguments |
 
 TTY allocation is decided by combining the command's config, the CLI option, and whether both
-stdin and stdout are real TTYs. Set `WIP_DEBUG=1` to print the `Shellwords`-joined command before
-running it.
+stdin and stdout are real TTYs.
+
+Pass `--debug` (or set `WIP_DEBUG=1`) to see where time is going: wip prints each step it takes —
+checking for an existing network/container/dependency, and running the resolved `wslc`/`docker`
+command — along with how long that step took, e.g.:
+
+```console
+$ wip rails c --debug
+wip: [debug] running: wslc.exe exec -it -w /app app bin/rails c
++ wslc.exe exec -it -w /app app bin/rails c
+...
+wip: [debug] done in 4.32s: running: wslc.exe exec -it -w /app app bin/rails c
+```
+
+For long-running interactive commands (like `rails c`), the "done" line only prints after you
+exit, but the timestamp of the `+ ...` line tells you when wip finished its own setup and handed
+off to `wslc`/`docker` — useful for telling wip-side overhead apart from time spent booting inside
+the container.
+
+While a step is still running, wip also prints a host resource snapshot (load average, memory
+used, and the top CPU-consuming processes) every 5 seconds, so a hang is visible even before the
+command has produced any output of its own:
+
+```console
+wip: [debug] still running (load 3.42 2.10 1.05 | mem 6.1G/15.6G | top: wslc.exe(8842) cpu 61.0%/mem 3.2%, ...): running: wslc.exe exec -it -w /app app bin/rails c
+```
 
 ## doctor
 

data/lib/wip/cli.rb

@@ -9,6 +9,7 @@ module Wip
   # Thor-based command-line interface for wip.
   class CLI < Thor
     class_option :config, type: :string, desc: 'Path to wip.yml'
+    class_option :debug, type: :boolean, default: false, desc: 'Print progress and timing for each step'
     default_task :dispatch
 
     def self.exit_on_failure? = true
@@ -119,19 +120,31 @@ module Wip
     def builder = CommandBuilder.new(wslc: resolver.resolve(load_config.wslc_command), config: load_config)
 
     def execute(command, interactive: false, exit_on_failure: true)
-      code = CommandRunner.new.run(command, interactive: interactive)
+      runner = CommandRunner.new(debug: debug?)
+      code = reporter.step("running: #{CommandDisplay.for_debug(command)}") do
+        runner.run(command, interactive: interactive)
+      end
       exit(code) if exit_on_failure && !code.zero?
       code
     end
 
     def resource_exists?(find_command)
-      out = StringIO.new
-      code = CommandRunner.new(stdout: out, stderr: StringIO.new).run(find_command)
-      code.zero? && !JSON.parse(out.string).empty?
+      code, output = probe(find_command)
+      code.zero? && !JSON.parse(output).empty?
     rescue JSON::ParserError
       false
     end
 
+    def probe(command)
+      out = StringIO.new
+      runner = CommandRunner.new(stdout: out, stderr: StringIO.new, debug: debug?)
+      code = reporter.step("checking: #{CommandDisplay.for_debug(command)}") { runner.run(command) }
+      [code, out.string]
+    end
+
+    def debug? = options[:debug] || !ENV['WIP_DEBUG'].to_s.empty?
+    def reporter = @reporter ||= DebugReporter.new(enabled: debug?)
+
     def ensure_network
       network = load_config.network
       return unless network
@@ -142,11 +155,8 @@ module Wip
     end
 
     def network_exists?(network)
-      out = StringIO.new
-      code = CommandRunner.new(stdout: out, stderr: StringIO.new).run(builder.network_list)
-      return false unless code.zero?
-
-      JSON.parse(out.string).any? { |entry| entry['Name'] == network }
+      code, output = probe(builder.network_list)
+      code.zero? && JSON.parse(output).any? { |entry| entry['Name'] == network }
     rescue JSON::ParserError
       false
     end

data/lib/wip/command_display.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'shellwords'
+
+module Wip
+  # Renders a command array for debug output, masking `-e KEY=value` env values
+  # so secrets from wip.yml never reach logs.
+  module CommandDisplay
+    def self.for_debug(command)
+      masked = command.each_cons(2).with_index.each_with_object(command.dup) do |((flag, pair), index), result|
+        next unless flag == '-e'
+
+        key, = pair.split('=', 2)
+        result[index + 1] = "#{key}=***"
+      end
+      Shellwords.join(masked)
+    end
+  end
+end

data/lib/wip/command_runner.rb

@@ -1,20 +1,21 @@
 # frozen_string_literal: true
 
 require 'open3'
-require 'shellwords'
 
 module Wip
   # Executes a built command, pumping its I/O and returning the exit status.
   class CommandRunner
-    def initialize(stdin: $stdin, stdout: $stdout, stderr: $stderr, interpreter: ErrorInterpreter.new)
+    def initialize(stdin: $stdin, stdout: $stdout, stderr: $stderr, interpreter: ErrorInterpreter.new,
+                   debug: !ENV['WIP_DEBUG'].to_s.empty?)
       @stdin = stdin
       @stdout = stdout
       @stderr = stderr
       @interpreter = interpreter
+      @debug = debug
     end
 
     def run(command, env: {}, interactive: false)
-      @stderr.puts "+ #{Shellwords.join(command)}" if ENV['WIP_DEBUG']
+      @stderr.puts "+ #{CommandDisplay.for_debug(command)}" if @debug
       return run_attached(command, env) if interactive
 
       captured = +''

data/lib/wip/debug_reporter.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Wip
+  # Prints each step wip takes and how long it took, when debug mode is enabled.
+  class DebugReporter
+    def initialize(enabled:, out: $stderr)
+      @enabled = enabled
+      @out = out
+    end
+
+    def step(label)
+      return yield unless @enabled
+
+      started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      @out.puts "wip: [debug] #{label}"
+      monitor = ResourceMonitor.new(out: @out)
+      monitor.start(label)
+      begin
+        yield
+      ensure
+        monitor.stop
+        elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started
+        @out.puts format('wip: [debug] done in %<elapsed>.2fs: %<label>s', elapsed: elapsed, label: label)
+      end
+    end
+  end
+end

data/lib/wip/doctor.rb

@@ -15,9 +15,8 @@ module Wip
 
     def call
       results = []
-      results << result(@environment.wsl2? ? :ok : :fail, 'Running on WSL2', 'Not running on WSL2')
-      results << result(@environment.windows_interop? ? :ok : :fail, 'Windows executable interoperability is enabled',
-                        'Windows executable interoperability is disabled')
+      results << result(@environment.wsl2? ? :ok : :fail, *wsl2_messages)
+      results << interop_result unless @environment.windows?
       results << Result.new(:ok, "Architecture: #{@environment.architecture}")
       config = load_config(results)
       command = resolve(config, results) if config
@@ -29,6 +28,17 @@ module Wip
 
     private
 
+    def wsl2_messages
+      return ['WSL2 is available', 'WSL2 is not available'] if @environment.windows?
+
+      ['Running on WSL2', 'Not running on WSL2']
+    end
+
+    def interop_result
+      result(@environment.windows_interop? ? :ok : :fail, 'Windows executable interoperability is enabled',
+             'Windows executable interoperability is disabled')
+    end
+
     def load_config(results)
       config = @loader.load
       invalid = %w[container image].select { |key| config.defaults[key].to_s.empty? }

data/lib/wip/environment.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'open3'
+
 module Wip
   # Detects WSL2, Windows interop, and architecture facts about the host.
   class Environment
@@ -8,7 +10,11 @@ module Wip
       @stdout = stdout
     end
 
+    def windows? = Gem.win_platform?
+
     def wsl2?
+      return wsl2_backend_available? if windows?
+
       File.read('/proc/version').match?(/microsoft.*WSL2/i)
     rescue Errno::ENOENT
       false
@@ -18,9 +24,20 @@ module Wip
     def interactive? = @stdin.tty? && @stdout.tty?
 
     def architecture
-      machine = `uname -m`.strip
-      { 'x86_64' => 'linux/amd64', 'aarch64' => 'linux/arm64', 'arm64' => 'linux/arm64' }.fetch(machine,
-                                                                                                "linux/#{machine}")
+      machine = RbConfig::CONFIG['host_cpu']
+      { 'x86_64' => 'linux/amd64', 'x64' => 'linux/amd64', 'aarch64' => 'linux/arm64', 'arm64' => 'linux/arm64' }
+        .fetch(machine, "linux/#{machine}")
+    end
+
+    private
+
+    # On native Windows there is no /proc/version to read, so ask Windows
+    # itself whether the WSL2 backend that WSLC depends on is installed.
+    def wsl2_backend_available?
+      _output, status = Open3.capture2e('wsl.exe', '--status')
+      status.success?
+    rescue Errno::ENOENT
+      false
     end
   end
 end

data/lib/wip/resource_monitor.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Wip
+  # Periodically prints host CPU/memory/process info while a debug step is still
+  # running, so a hung or slow step is visible even before it produces output.
+  class ResourceMonitor
+    def initialize(interval: 5, out: $stderr)
+      @interval = interval
+      @out = out
+    end
+
+    def start(label)
+      @thread = Thread.new do
+        loop do
+          sleep @interval
+          @out.puts "wip: [debug] still running (#{load_average} | #{memory} | top: #{top_processes}): #{label}"
+        end
+      end
+    end
+
+    def stop
+      @thread&.kill
+      @thread&.join
+    end
+
+    private
+
+    def load_average
+      "load #{File.read('/proc/loadavg').split[0..2].join(' ')}"
+    rescue Errno::ENOENT, IOError
+      'load n/a'
+    end
+
+    def memory
+      fields = File.read('/proc/meminfo').lines.to_h { |line| line.split(':', 2).then { |k, v| [k, v.to_i] } }
+      total_gb = fields.fetch('MemTotal', 0) / 1_048_576.0
+      used_gb = total_gb - (fields.fetch('MemAvailable', 0) / 1_048_576.0)
+      format('mem %<used>.1fG/%<total>.1fG', used: used_gb, total: total_gb)
+    rescue Errno::ENOENT, IOError
+      'mem n/a'
+    end
+
+    def top_processes
+      `ps -eo pid,pcpu,pmem,comm --sort=-pcpu 2>/dev/null`.lines.drop(1).first(3).filter_map do |line|
+        pid, cpu, mem, comm = line.split(nil, 4)
+        next unless comm
+
+        "#{comm.strip}(#{pid}) cpu #{cpu}%/mem #{mem}%"
+      end.join(', ')
+    rescue StandardError
+      'n/a'
+    end
+  end
+end

data/lib/wip/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Wip
-  VERSION = '0.4.0'
+  VERSION = '0.4.2'
 end

data/lib/wip.rb

@@ -8,6 +8,9 @@ require_relative 'wip/environment'
 require_relative 'wip/command_resolver'
 require_relative 'wip/error_interpreter'
 require_relative 'wip/command_builder'
+require_relative 'wip/command_display'
 require_relative 'wip/command_runner'
+require_relative 'wip/resource_monitor'
+require_relative 'wip/debug_reporter'
 require_relative 'wip/doctor'
 require_relative 'wip/cli'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wslc-wip
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.2
 platform: ruby
 authors:
 - Wip contributors
@@ -35,20 +35,24 @@ files:
 - lib/wip.rb
 - lib/wip/cli.rb
 - lib/wip/command_builder.rb
+- lib/wip/command_display.rb
 - lib/wip/command_resolver.rb
 - lib/wip/command_runner.rb
 - lib/wip/config.rb
 - lib/wip/config_loader.rb
+- lib/wip/debug_reporter.rb
 - lib/wip/doctor.rb
 - lib/wip/environment.rb
 - lib/wip/error_interpreter.rb
 - lib/wip/errors.rb
+- lib/wip/resource_monitor.rb
 - lib/wip/version.rb
-homepage: https://github.com/slidict/wip
+homepage: https://wslc-wip.slidict.com/
 licenses:
 - MIT
 metadata:
   rubygems_mfa_required: 'true'
+  homepage_uri: https://wslc-wip.slidict.com/
   source_code_uri: https://github.com/slidict/wip
   changelog_uri: https://github.com/slidict/wip/releases
   bug_tracker_uri: https://github.com/slidict/wip/issues