wslc-wip 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: da7bb5fa632921c307adeeea727e792d38e688204393dfd3ee2c7759e40791b4
-  data.tar.gz: 2e2a277a4ab2dcf0ce540778b6263a142553430452905924f67158dc13ffed54
+  metadata.gz: '0845dfb67f17323b8a99e6f2f92ef06c17bc03fd1316680cf5f43f2640d73da3'
+  data.tar.gz: 6eea9bb520aed0fff5b401b71a20dccdade6b50d9a71403037e59e4e5b83ab2e
 SHA512:
-  metadata.gz: f71156a19e193d0402f2fa4dc501aca0f32b27d63807c20b7a1a8dcddf1932f091af8ec12a0310aac36084a6c28034d843100abbf4adc3ac9c081d4e9304c18c
-  data.tar.gz: 538f842fd08441c9ec1603fc147d7c5ce7a5c6f2f2ce22edd0673b12709da19a6c23d3e7f1231a73d69d675337f09a17bc312aa07792308df414f1130e11b2a5
+  metadata.gz: 1b522d206ba3070244f51bda9d4e144dfe95df63ab01bb92b35d0fe0e84a29035c997d7b061c2ec23286c8bd9f586c69e276b7304abd1c8ad81fe808293599b5
+  data.tar.gz: d7fc237820edfcc734f55775e027133c5f9877c24b16f5b1ca6aa98304b35fdea5825a179ff7f64b4d22fe2634d52d11761777284b68a86e76faa56432d33230

data/README.md

@@ -103,6 +103,22 @@ commands:
 credential, or auth. Keep real secrets out of the config file and in your runtime environment
 instead.
 
+### .env
+
+Like `docker compose`, `wip` automatically loads a `.env` file next to `wip.yml` (one `KEY=VALUE`
+per line; `#` comments, blank lines, `export` prefixes, and quoted values are all supported) and
+passes its keys through as container environment variables on `build`, `up`, `run`, `exec`, and
+custom commands. `.env` only fills in keys that aren't already set by `defaults.env` or a
+command/dependency's own `env` — those always win on conflict. Pass `--env-file PATH` to load a
+different file instead.
+
+### .dockerignore
+
+`wip build` reads `.dockerignore` from the build context and stages a filtered copy of the
+context (skipping anything it matches) before handing it to `wslc build`, since `wslc` sends the
+context as-is otherwise. If there's no `.dockerignore`, the original context directory is used
+directly with no copying.
+
 ### Dependency containers
 
 If your app needs sidecar services (a database, Redis, ...), declare them under `dependencies`
@@ -148,14 +164,30 @@ exit, but the timestamp of the `+ ...` line tells you when wip finished its own
 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:
+While a step is still running, wip also prints a host resource snapshot (load average, memory,
+disk I/O, 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
+wip: [debug] still running (load 3.42 2.10 1.05 | mem 6.1G/15.6G | io read 12000KB/s write 400KB/s | top: wslc.exe(8842) cpu 61.0%/mem 3.2%, ...): running: wslc.exe exec -it -w /app app bin/rails c
 ```
 
+The disk I/O figure is worth watching first if the host's CPU and memory look idle — a slow
+`bundle`/`rails` boot is often WSL2's bind-mounted (`.:/app`-style) volumes doing a lot of small
+reads, not the container starving for CPU.
+
+For commands that hand the real terminal to the child (`-it`, e.g. `rails c`), these periodic
+snapshots go to a log file instead of your terminal — wip prints the path once at the start —
+since writing into a terminal the child controls in raw mode would garble both outputs. Commands
+that don't need a TTY still get the snapshots printed live.
+
+Override that choice with `--debug-log`:
+
+- `--debug-log=-` forces snapshots inline even for `-it` commands (only useful if you know your
+  terminal/pager can tolerate the interleaving).
+- `--debug-log=PATH` always writes snapshots to `PATH`, including for non-TTY commands, e.g. to
+  keep every run's snapshots in one place: `wip rails c --debug --debug-log=/tmp/wip-debug.log`.
+
 ## doctor
 
 Each check prints as `[OK]`, `[WARN]`, or `[FAIL]`. Warnings alone exit 0; a WSL2, interop, WSLC,

data/lib/wip/build_context.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'pathname'
+require 'tmpdir'
+
+module Wip
+  # Stages a build context into a scratch directory with anything matched by
+  # .dockerignore left out, since wslc build (unlike `docker build`) sends the
+  # context as-is instead of filtering it itself.
+  class BuildContext
+    def initialize(context, ignore: nil)
+      @root = Pathname(context).expand_path
+      @ignore = ignore || DockerIgnore.load(@root.join('.dockerignore'))
+    end
+
+    def stage
+      return yield @root.to_s if @ignore.empty?
+
+      Dir.mktmpdir('wip-build-context-') do |dir|
+        copy_included_files(Pathname(dir))
+        yield dir
+      end
+    end
+
+    private
+
+    def copy_included_files(destination)
+      each_included_file do |relative_path|
+        target = destination.join(relative_path)
+        FileUtils.mkdir_p(target.dirname)
+        FileUtils.cp(@root.join(relative_path), target)
+      end
+    end
+
+    def each_included_file
+      Dir.glob('**/*', File::FNM_DOTMATCH, base: @root.to_s).each do |entry|
+        next if %w[. ..].include?(entry)
+
+        path = @root.join(entry)
+        next unless path.file?
+        next if @ignore.ignored?(entry)
+
+        yield entry
+      end
+    end
+  end
+end

data/lib/wip/cli.rb

@@ -9,7 +9,9 @@ module Wip
   # Thor-based command-line interface for wip.
   class CLI < Thor
     class_option :config, type: :string, desc: 'Path to wip.yml'
+    class_option :env_file, type: :string, desc: 'Path to a dotenv file (default: .env next to wip.yml)'
     class_option :debug, type: :boolean, default: false, desc: 'Print progress and timing for each step'
+    class_option :debug_log, type: :string, desc: 'Where --debug snapshots go: a file path, or "-" for inline'
     default_task :dispatch
 
     def self.exit_on_failure? = true
@@ -51,7 +53,11 @@ module Wip
     desc 'build [OPTIONS]', 'Build the configured image'
     def build(*extra)
       extra.shift if extra.first == '--'
-      execute(builder.build(settings: load_config.command('build') || {}, extra: extra))
+      settings = load_config.command('build') || {}
+      context = settings['context'] || load_config.defaults['context'] || '.'
+      BuildContext.new(context).stage do |staged_context|
+        execute(builder.build(settings: settings.merge('context' => staged_context), extra: extra))
+      end
     end
 
     desc 'up', 'Start the configured container and its dependencies, creating them if necessary'
@@ -117,11 +123,20 @@ module Wip
     def loader = ConfigLoader.new(path: options[:config])
     def load_config = (@load_config ||= loader.load)
     def resolver = CommandResolver.new
-    def builder = CommandBuilder.new(wslc: resolver.resolve(load_config.wslc_command), config: load_config)
+
+    def dotenv_path
+      options[:env_file] ? Pathname(options[:env_file]).expand_path : Pathname(load_config.path).dirname.join('.env')
+    end
+
+    def dotenv = @dotenv ||= DotenvLoader.new(dotenv_path).load
+
+    def builder
+      CommandBuilder.new(wslc: resolver.resolve(load_config.wslc_command), config: load_config, dotenv: dotenv)
+    end
 
     def execute(command, interactive: false, exit_on_failure: true)
       runner = CommandRunner.new(debug: debug?)
-      code = reporter.step("running: #{CommandDisplay.for_debug(command)}") do
+      code = reporter.step("running: #{CommandDisplay.for_debug(command)}", live: !interactive) do
         runner.run(command, interactive: interactive)
       end
       exit(code) if exit_on_failure && !code.zero?
@@ -143,7 +158,7 @@ module Wip
     end
 
     def debug? = options[:debug] || !ENV['WIP_DEBUG'].to_s.empty?
-    def reporter = @reporter ||= DebugReporter.new(enabled: debug?)
+    def reporter = @reporter ||= DebugReporter.new(enabled: debug?, log: options[:debug_log])
 
     def ensure_network
       network = load_config.network

data/lib/wip/command_builder.rb

@@ -5,10 +5,11 @@ require 'shellwords'
 module Wip
   # Builds the argument arrays for wslc build/exec/run/custom invocations.
   class CommandBuilder
-    def initialize(wslc:, config:, environment: Environment.new)
+    def initialize(wslc:, config:, environment: Environment.new, dotenv: {})
       @wslc = wslc
       @config = config
       @environment = environment
+      @dotenv = dotenv
     end
 
     def exec(arguments, settings: {}, interactive: true)
@@ -115,7 +116,7 @@ module Wip
     def options(values, include_container: false, include_publish: true)
       result = []
       result.push('-w', values['workdir']) unless values['workdir'].to_s.empty?
-      values.fetch('env', {}).each { |key, value| result.push('-e', "#{key}=#{value}") }
+      merged_env(values).each { |key, value| result.push('-e', "#{key}=#{value}") }
       if include_publish
         Array(values['ports']).each { |port| result.push('-p', port.to_s) }
         Array(values['volumes']).each { |volume| result.push('-v', volume.to_s) }
@@ -124,6 +125,9 @@ module Wip
       result
     end
 
+    # .env supplies defaults; env set in wip.yml (defaults or per-command) wins on conflict.
+    def merged_env(values) = @dotenv.merge(values.fetch('env', {}))
+
     def required(values, key)
       value = values[key]
       raise ConfigError, "Configured #{key} must not be empty" if value.to_s.empty?

data/lib/wip/debug_reporter.rb

@@ -1,27 +1,59 @@
 # frozen_string_literal: true
 
+require 'tmpdir'
+
 module Wip
   # Prints each step wip takes and how long it took, when debug mode is enabled.
   class DebugReporter
-    def initialize(enabled:, out: $stderr)
+    # `log:` overrides where resource snapshots go, regardless of `live`:
+    #   nil  - automatic (see `step`'s `live:`)
+    #   '-'  - always print inline, even for interactive steps
+    #   path - always write to this file, even for non-interactive steps
+    def initialize(enabled:, out: $stderr, log: nil)
       @enabled = enabled
       @out = out
+      @log = log
     end
 
-    def step(label)
+    # `live: false` is for steps that hand the real TTY to the child process
+    # (e.g. `wslc exec -it`). The child owns raw-mode cursor control there, so
+    # writing periodic snapshots straight into that same terminal races with
+    # it and garbles the output; those snapshots go to a log file instead,
+    # unless overridden by `log:` in the constructor.
+    def step(label, live: true)
       return yield unless @enabled
 
       started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       @out.puts "wip: [debug] #{label}"
-      monitor = ResourceMonitor.new(out: @out)
+      file = log_file(live)
+      monitor = ResourceMonitor.new(out: file || @out)
       monitor.start(label)
       begin
         yield
       ensure
         monitor.stop
+        file&.close
         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
+
+    private
+
+    def log_file(live)
+      return nil if @log == '-'
+      return open_log(@log, "streaming resource snapshots to #{@log}") if @log
+      return nil if live
+
+      path = File.join(Dir.tmpdir, "wip-debug-#{Process.pid}-#{Time.now.to_i}.log")
+      open_log(path, "command owns the terminal; streaming resource snapshots to #{path}")
+    end
+
+    def open_log(path, notice)
+      @out.puts "wip: [debug] #{notice}"
+      file = File.open(path, 'a') # rubocop:disable Style/FileOpen -- closed by `step`'s ensure block
+      file.sync = true
+      file
+    end
   end
 end

data/lib/wip/docker_ignore.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module Wip
+  # Parses a .dockerignore file and decides whether a build-context-relative
+  # path should be excluded, following the same pattern rules as the Docker
+  # CLI (gitignore-like globs, later rules override earlier ones, `!` negates).
+  class DockerIgnore
+    Rule = Struct.new(:pattern, :negate)
+
+    FNMATCH_FLAGS = File::FNM_PATHNAME | File::FNM_DOTMATCH | File::FNM_EXTGLOB
+
+    def self.load(path)
+      path = Pathname(path)
+      return new([]) unless path.file?
+
+      new(path.readlines)
+    end
+
+    def initialize(lines)
+      @rules = lines.filter_map { |line| parse(line) }
+    end
+
+    def empty? = @rules.empty?
+
+    def ignored?(relative_path)
+      @rules.reduce(false) do |ignored, rule|
+        matches?(rule.pattern, relative_path) ? !rule.negate : ignored
+      end
+    end
+
+    private
+
+    def parse(line)
+      line = line.strip
+      return nil if line.empty? || line.start_with?('#')
+
+      negate = line.start_with?('!')
+      pattern = negate ? line[1..] : line
+      pattern = pattern.delete_suffix('/')
+      anchored = pattern.start_with?('/')
+      pattern = pattern.delete_prefix('/')
+      pattern = "**/#{pattern}" if !anchored && !pattern.include?('/')
+      Rule.new(pattern, negate)
+    end
+
+    # A match on a directory component also excludes everything under it,
+    # so every prefix of the path (not just the full path) is tested.
+    def matches?(pattern, relative_path)
+      components = relative_path.split('/')
+      (1..components.size).any? do |i|
+        File.fnmatch(pattern, components[0...i].join('/'), FNMATCH_FLAGS)
+      end
+    end
+  end
+end

data/lib/wip/dotenv_loader.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module Wip
+  # Parses a .env file the way `docker compose` does, so values don't have to
+  # be duplicated into wip.yml just to reach the container as -e flags.
+  class DotenvLoader
+    LINE_PATTERN = /\A(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)=(.*)\z/
+
+    def initialize(path)
+      @path = Pathname(path)
+    end
+
+    def load
+      return {} unless @path.file?
+
+      @path.readlines.each_with_object({}) do |line, env|
+        line = line.strip
+        next if line.empty? || line.start_with?('#')
+
+        match = LINE_PATTERN.match(line)
+        next unless match
+
+        env[match[1]] = unquote(match[2])
+      end
+    end
+
+    private
+
+    def unquote(value)
+      value = value.strip
+      return value[1..-2] if value.start_with?('"') && value.end_with?('"') && value.length >= 2
+      return value[1..-2] if value.start_with?("'") && value.end_with?("'") && value.length >= 2
+
+      value.split(/\s+#/, 2).first.to_s.strip
+    end
+  end
+end

data/lib/wip/resource_monitor.rb

@@ -1,19 +1,22 @@
 # 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.
+  # Periodically prints host CPU/memory/disk-IO/process info while a debug step
+  # is still running, so a hung or slow step is visible even before it produces
+  # output of its own.
   class ResourceMonitor
     def initialize(interval: 5, out: $stderr)
       @interval = interval
       @out = out
+      @last_disk = disk_sectors
+      @last_sampled_at = monotonic
     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}"
+          @out.puts "wip: [debug] still running (#{snapshot}): #{label}"
         end
       end
     end
@@ -25,6 +28,12 @@ module Wip
 
     private
 
+    def monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+    def snapshot
+      [load_average, memory, disk_io, top_processes].join(' | ')
+    end
+
     def load_average
       "load #{File.read('/proc/loadavg').split[0..2].join(' ')}"
     rescue Errno::ENOENT, IOError
@@ -40,15 +49,46 @@ module Wip
       'mem n/a'
     end
 
+    # WSL2's bind-mounted (9p) volumes are often the real bottleneck behind a
+    # slow `bundle`/`rails` boot, and that shows up here rather than in CPU.
+    def disk_io
+      now = monotonic
+      elapsed = [now - @last_sampled_at, 0.001].max
+      current = disk_sectors
+      read_kbps = (current[:read] - @last_disk[:read]) * 0.5 / elapsed
+      write_kbps = (current[:write] - @last_disk[:write]) * 0.5 / elapsed
+      @last_disk = current
+      @last_sampled_at = now
+      format('io read %<read>.0fKB/s write %<write>.0fKB/s', read: read_kbps, write: write_kbps)
+    rescue Errno::ENOENT, IOError
+      'io n/a'
+    end
+
+    def disk_sectors
+      totals = { read: 0, write: 0 }
+      File.readlines('/proc/diskstats').each do |line|
+        fields = line.split
+        next if fields[2].to_s.match?(/\A(loop|ram)/)
+
+        totals[:read] += fields[5].to_i
+        totals[:write] += fields[9].to_i
+      end
+      totals
+    rescue Errno::ENOENT, IOError
+      { read: 0, write: 0 }
+    end
+
     def top_processes
-      `ps -eo pid,pcpu,pmem,comm --sort=-pcpu 2>/dev/null`.lines.drop(1).first(3).filter_map do |line|
+      lines = `ps -eo pid,pcpu,pmem,comm --sort=-pcpu 2>/dev/null`.lines.drop(1).first(3)
+      entries = lines.filter_map do |line|
         pid, cpu, mem, comm = line.split(nil, 4)
         next unless comm
 
         "#{comm.strip}(#{pid}) cpu #{cpu}%/mem #{mem}%"
-      end.join(', ')
+      end
+      "top: #{entries.join(', ')}"
     rescue StandardError
-      'n/a'
+      'top: n/a'
     end
   end
 end

data/lib/wip/version.rb

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

data/lib/wip.rb

@@ -5,6 +5,9 @@ require_relative 'wip/errors'
 require_relative 'wip/config'
 require_relative 'wip/config_loader'
 require_relative 'wip/environment'
+require_relative 'wip/dotenv_loader'
+require_relative 'wip/docker_ignore'
+require_relative 'wip/build_context'
 require_relative 'wip/command_resolver'
 require_relative 'wip/error_interpreter'
 require_relative 'wip/command_builder'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wslc-wip
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.5.0
 platform: ruby
 authors:
 - Wip contributors
@@ -33,6 +33,7 @@ files:
 - README.md
 - exe/wip
 - lib/wip.rb
+- lib/wip/build_context.rb
 - lib/wip/cli.rb
 - lib/wip/command_builder.rb
 - lib/wip/command_display.rb
@@ -41,7 +42,9 @@ files:
 - lib/wip/config.rb
 - lib/wip/config_loader.rb
 - lib/wip/debug_reporter.rb
+- lib/wip/docker_ignore.rb
 - lib/wip/doctor.rb
+- lib/wip/dotenv_loader.rb
 - lib/wip/environment.rb
 - lib/wip/error_interpreter.rb
 - lib/wip/errors.rb