wslc-wip 1.1.0 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e2bffbab317006bdd799443ef1dc7e16d9527219261f91c9758504ae85aef638
-  data.tar.gz: b1e0f8f72d44878564573fcc8076af18defe14375d1bee4cd4946c72139bcc1e
+  metadata.gz: 37c2e70c286c4dd7b163201674eff9b4111fbe3f05ef032500a5b7ac516f97b5
+  data.tar.gz: fbad7b94e10bb0cbd9efc8c70f1a2546830ac0c20f276a925b48e0d668679902
 SHA512:
-  metadata.gz: d16eda21cb080e2dd7decc2522c4dac7c99536f3c720c1de7d64f0065edd7487c633450db9eeb687b12138b2763d3093628e0d169b82d7896c781e7c8298bb3c
-  data.tar.gz: 5f668930355e17877237892da08dc440630f2015253b072c715e324c38045598765c58cb84d9657d7769527d3f27774f8d4f03f6bec2cc1bb785bca9a308cce2
+  metadata.gz: 70319980be04f8abdbb6d5e167e8941ca4fa3a8ab65b0cd71ec884daff639205a70935b4c5a756ec3403678982c2859423051930379aa3d79f302506b0f88326
+  data.tar.gz: f100b5622d566ab77da4437cb028138a7fa33f47d4d19ff70874c683e2995e9c3213bc95b0109c03c82556827a26ee22b47a034bf7fc96895effc2c8fcb3950f

data/README.md

@@ -244,8 +244,10 @@ top level (`networks:`, `volumes:`, `configs:`, `secrets:`, ...) is the one exce
 real Compose tools, not by `wip`, so `wip` silently ignores it rather than rejecting an otherwise
 valid compose.yml over sections it doesn't need to look at:
 
-- Per service: `image`, `build` (string or `{context:, dockerfile:}`; resolved relative to
-  `compose.yml`, not wherever `wip` is invoked from), `command` (shell or exec form), `environment`
+- Per service: `image`, `build` (string or `{context:, dockerfile:, args:, shadow_context:}`;
+  `context` is resolved relative to `compose.yml`, not wherever `wip` is invoked from; `dockerfile`
+  stays relative to `context` itself — see [.dockerignore](#dockerignore) for what `shadow_context`
+  does), `command` (shell or exec form), `environment`
   (mapping or `KEY=VALUE` array — a mapping value must not be null; host environment pass-through
   isn't supported), `ports`/`volumes` (short syntax only — `"host:container"` strings, not
   long-syntax mappings), `working_dir`, `user`, `depends_on` (ordering only — a `condition:` other
@@ -272,13 +274,14 @@ to load a different file instead.
 
 `wip build` reads `.dockerignore` from the build context and excludes anything it matches before
 handing the context to `wslc build`, since `wslc` sends the context as-is otherwise. Set
-`commands.build.shadow_context` in `wip.yml` to a directory on the Windows filesystem to enable a
-persistent shadow context for projects outside `/mnt/<drive>`. The first build copies every
-included file; later builds only copy added or changed files and remove deleted or newly ignored
-files. Without this setting the optimization is disabled, and it only applies under WSL2 — on WSL1
-(or anywhere else) the context is handed to `wslc build` directly. Projects already on `/mnt/c` (or
-another mounted Windows drive) also continue to build directly even when the setting is present.
-The path must live outside the build context itself, or `wip build` refuses it.
+`commands.build.shadow_context` in `wip.yml` (or `build.shadow_context` on a compose-native
+`build:` service in `compose.yml`) to a directory on the Windows filesystem to enable a persistent
+shadow context for projects outside `/mnt/<drive>`. The first build copies every included file;
+later builds only copy added or changed files and remove deleted or newly ignored files. Without
+this setting the optimization is disabled, and it only applies under WSL2 — on WSL1 (or anywhere
+else) the context is handed to `wslc build` directly. Projects already on `/mnt/c` (or another
+mounted Windows drive) also continue to build directly even when the setting is present. The path
+must live outside the build context itself, or `wip build`/`wip up` refuses it.
 
 ### Source sync
 

data/lib/wip/build_context.rb

@@ -30,6 +30,11 @@ module Wip
       end
     end
 
+    # Whether the upcoming stage will use the Windows-side shadow directory
+    # (configured shadow_root, on WSL2, with a context outside /mnt) rather
+    # than staging in place or under a WSL-side tmpdir.
+    def shadow? = shadow_required?
+
     private
 
     # A shadow root under the context would itself be walked by included_files

data/lib/wip/cli.rb

@@ -76,8 +76,7 @@ module Wip
       build_context = BuildContext.new(context, shadow_root: settings['shadow_context'])
       build_context.stage(on_progress: progress.method(:tick)) do |staged_context|
         progress.finish
-        built = builder.build(settings: settings.merge('context' => staged_context), extra: extra)
-        execute(built, interactive: tty?(true))
+        run_staged_build(build_context, staged_context, settings, extra)
       end
     ensure
       progress&.finish
@@ -248,10 +247,12 @@ module Wip
       execute(exec_target(command, interactive: interactive), interactive: tty?(interactive))
     end
 
-    def execute(command, interactive: false, exit_on_failure: true)
+    def execute(command, interactive: false, exit_on_failure: true, chdir: nil)
       runner = CommandRunner.new(debug: debug?)
+      run_options = { interactive: interactive }
+      run_options[:chdir] = chdir if chdir
       code = reporter.step("running: #{CommandDisplay.for_debug(command)}", live: !interactive) do
-        runner.run(command, interactive: interactive)
+        runner.run(command, **run_options)
       end
       exit(code) if exit_on_failure && !code.zero?
       code
@@ -322,15 +323,23 @@ module Wip
       extra = compose_build_extra(spec)
       warn "wip: building service '#{name}' (tag: #{spec['tag']}) from #{spec['context']}"
       progress = StagingProgress.new
-      BuildContext.new(spec['context']).stage(on_progress: progress.method(:tick)) do |staged_context|
+      build_context = BuildContext.new(spec['context'], shadow_root: spec['shadow_context'])
+      build_context.stage(on_progress: progress.method(:tick)) do |staged_context|
         progress.finish
-        settings = { 'context' => staged_context, 'tag' => spec['tag'] }
-        execute(builder.build(settings: settings, extra: extra), interactive: tty?(true))
+        run_staged_build(build_context, staged_context, { 'tag' => spec['tag'] }, extra)
       end
     ensure
       progress&.finish
     end
 
+    # wslc build crashes (ERROR_UNHANDLED_EXCEPTION) when handed an absolute
+    # context path; running from inside the context and passing "." avoids it.
+    def run_staged_build(build_context, staged_context, settings, extra)
+      warn "wip: using shadow build context at #{staged_context}" if build_context.shadow?
+      built = builder.build(settings: settings.merge('context' => '.'), extra: extra)
+      execute(built, interactive: tty?(true), chdir: staged_context)
+    end
+
     def build_extra_options(extra)
       extra = extra.dup
       extra.shift if extra.first == '--'
@@ -356,7 +365,9 @@ module Wip
 
       Dir.mktmpdir('wip-sync-build-') do |dir|
         File.write(File.join(dir, 'Dockerfile'), settings.build['dockerfile'])
-        execute(builder.sync_build(dir))
+        # wslc build crashes (ERROR_UNHANDLED_EXCEPTION) when handed an absolute
+        # context path; running from inside the context and passing "." avoids it.
+        execute(builder.sync_build('.'), chdir: dir)
       end
     end
 

data/lib/wip/command_runner.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require 'open3'
+require 'pty' unless Gem.win_platform?
+require 'io/console'
 
 module Wip
   # Executes a built command, pumping its I/O and returning the exit status.
@@ -14,13 +16,14 @@ module Wip
       @debug = debug
     end
 
-    def run(command, env: {}, interactive: false)
+    def run(command, env: {}, interactive: false, chdir: nil)
       @stderr.puts "+ #{CommandDisplay.for_debug(command)}" if @debug
-      return run_attached(command, env) if interactive
+      return run_interactive(command, env, chdir) if interactive
 
+      opts = chdir ? { chdir: chdir } : {}
       captured = +''
       status = nil
-      Open3.popen3(env, *command) do |input, output, error, wait|
+      Open3.popen3(env, *command, opts) do |input, output, error, wait|
         input.close
         threads = [pump(output, @stdout, captured), pump(error, @stderr, captured)]
         threads.each(&:join)
@@ -38,6 +41,10 @@ module Wip
 
     private
 
+    def run_interactive(command, env, chdir)
+      Gem.win_platform? ? run_inherited(command, env, chdir) : run_attached(command, env, chdir)
+    end
+
     # exitstatus is nil when the process was killed by a signal instead of
     # exiting normally; fall back to the conventional 128+signal shell code
     # so callers always get a comparable integer.
@@ -52,15 +59,128 @@ module Wip
 
     # Piping stdin/stdout/stderr (as `run` does above) closes the child's
     # stdin immediately, which breaks anything that reads from the terminal
-    # (a shell, `rails console`, ...). Inherit the real file descriptors
-    # instead so the child gets a genuine TTY.
-    def run_attached(command, env)
-      pid = Process.spawn(env, *command)
+    # (a shell, `rails console`, ...). Run it behind a pseudo-terminal instead
+    # of inheriting wip's real fds directly: a pty still gives the child a
+    # genuine controlling terminal (job control, Ctrl-C -> SIGINT, isatty-gated
+    # rendering all work the same as direct inheritance), but routes output
+    # through wip first, so report_hint can still see it — inherited fds go
+    # straight to the terminal and wip never would. wip's own terminal is
+    # switched to raw mode for the duration so only the pty's line discipline
+    # echoes input; without that, every keystroke would echo twice.
+    def run_attached(command, env, chdir)
+      opts = chdir ? { chdir: chdir } : {}
+      captured = +''
+      status = nil
+      PTY.spawn(env, *command, opts) do |output, input, pid|
+        sync_winsize(output)
+        with_winsize_sync(output) { with_raw_stdin { pump_attached(output, input, captured) } }
+        _, status = Process.wait2(pid)
+      end
+      report_hint(captured) unless status.success?
+      exitstatus(status)
+    rescue Errno::ENOENT => e
+      @stderr.puts e.message
+      127
+    rescue Interrupt
+      @stderr.puts "\nwip: interrupted"
+      130
+    end
+
+    # Ruby's PTY library wraps openpty(3), which native Windows builds don't
+    # ship (require 'pty' is skipped there entirely, see the top of this
+    # file). Fall back to letting the child inherit wip's real stdio
+    # directly, same as `run` would've done pre-pty for the piped case: it
+    # still gives the child a real console (job control, Ctrl-C, isatty
+    # rendering all work), just without a way for wip to see the output, so
+    # report_hint can't run on failure here.
+    def run_inherited(command, env, chdir)
+      opts = chdir ? { chdir: chdir } : {}
+      opts[:in] = @stdin if io_stream?(@stdin)
+      opts[:out] = @stdout if io_stream?(@stdout)
+      opts[:err] = @stderr if io_stream?(@stderr)
+      pid = nil
+      pid = Process.spawn(env, *command, opts)
       _, status = Process.wait2(pid)
       exitstatus(status)
     rescue Errno::ENOENT => e
       @stderr.puts e.message
       127
+    rescue Interrupt
+      reap_interrupted_child(pid)
+      @stderr.puts "\nwip: interrupted"
+      130
+    end
+
+    # Process.spawn can only redirect to real OS-backed streams (an IO, or
+    # something that wraps one via to_io) — StringIO and friends (used by
+    # tests, and by wip's own quiet/capture modes) aren't valid redirection
+    # targets. Fall back to the process's own inherited fds for those rather
+    # than passing them through and having Process.spawn reject them.
+    def io_stream?(stream) = stream.respond_to?(:to_io)
+
+    # The child shares wip's real controlling terminal here (unlike the pty
+    # path), so it already received the same Ctrl-C the terminal delivered to
+    # wip; there's nothing to kill, just something to reap so it doesn't
+    # linger as a zombie once wip moves on.
+    def reap_interrupted_child(pid)
+      return unless pid
+
+      Process.wait2(pid)
+    rescue Errno::ECHILD, Interrupt
+      nil
+    end
+
+    def pump_attached(output, input, captured)
+      stdin_thread = forward_stdin(input)
+      loop do
+        chunk = output.readpartial(4096)
+        @stdout.write(chunk)
+        captured << chunk
+      end
+    rescue Errno::EIO, IOError
+      # the pty's slave side closed when the child exited
+    ensure
+      stdin_thread.kill
+    end
+
+    # Keeps the child's pty sized to wip's real terminal so full-screen
+    # programs (an editor, `less`, ...) render correctly. A non-tty @stdout
+    # (piped output, tests) has no size to read, so the pty keeps its default.
+    def sync_winsize(output)
+      output.winsize = @stdout.winsize if @stdout.respond_to?(:winsize) && @stdout.tty?
+    end
+
+    # The child's pty only gets the terminal size wip had at spawn time
+    # (sync_winsize, above) — it's a separate pty from wip's own real one, so
+    # later resizes of wip's terminal don't reach it on their own. Trap
+    # SIGWINCH for the duration to re-sync it live, restoring whatever handler
+    # was already installed (if any) once the command finishes.
+    def with_winsize_sync(output)
+      return yield unless @stdout.respond_to?(:winsize) && @stdout.tty?
+
+      previous = Signal.trap('WINCH') { sync_winsize(output) }
+      yield
+    ensure
+      Signal.trap('WINCH', previous) if previous
+    end
+
+    # A non-tty @stdin (piped input, tests) has no raw mode to switch to, so
+    # it's forwarded to the child as-is.
+    def with_raw_stdin(&)
+      return yield unless @stdin.respond_to?(:raw) && @stdin.tty?
+
+      @stdin.raw(&)
+    end
+
+    def forward_stdin(input)
+      Thread.new do
+        loop do
+          chunk = @stdin.readpartial(4096)
+          input.write(chunk)
+        end
+      rescue IOError, Errno::EIO, Errno::EBADF
+        nil
+      end
     end
 
     # An Interrupt during the main thread's `join` closes these pipes out from

data/lib/wip/compose_file.rb

@@ -24,7 +24,7 @@ module Wip
     # service already shares one project network (config.rb); and `wslc run`/`exec` has no
     # restart-policy or capability flag to forward `restart:`/`cap_add:` to.
     IGNORED_SERVICE_KEYS = %w[tty stdin_open networks restart cap_add].freeze
-    BUILD_KEYS = %w[context dockerfile args].freeze
+    BUILD_KEYS = %w[context dockerfile args shadow_context].freeze
     SUPPORTED_CONDITIONS = %w[service_started].freeze
     LIST_HINT = 'only supports short syntax ("host:container"), not long-syntax mappings'
 
@@ -140,9 +140,11 @@ module Wip
         unless unknown.empty?
 
       context = resolve_context(presence(value['context']) || '.')
-      dockerfile = presence(value['dockerfile'])
-      { 'context' => context, 'dockerfile' => dockerfile && Pathname(context).join(dockerfile).to_s,
-        'args' => normalize_kv(name, value['args'], 'build.args') }.compact
+      # Kept relative to context (not resolved against it) so `-f` still finds it once
+      # `wip up`/`wip build` chdir into a staged or shadowed copy of that context.
+      { 'context' => context, 'dockerfile' => presence(value['dockerfile']),
+        'args' => normalize_kv(name, value['args'], 'build.args'),
+        'shadow_context' => presence(value['shadow_context']) }.compact
     end
 
     # build.context is relative to compose.yml's own directory (Compose's own rule),

data/lib/wip/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wslc-wip
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.2
 platform: ruby
 authors:
 - Wip contributors