wslc-wip 1.1.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e2bffbab317006bdd799443ef1dc7e16d9527219261f91c9758504ae85aef638
-  data.tar.gz: b1e0f8f72d44878564573fcc8076af18defe14375d1bee4cd4946c72139bcc1e
+  metadata.gz: 49996dea1b8ae083cceb0caaafc0b8ddcc6de0a3ab8a7f5f4f856156948840d3
+  data.tar.gz: cca5758770d9f4364427c1ae7519ee8026c598b1002206fc9af8f22f5ffc0a64
 SHA512:
-  metadata.gz: d16eda21cb080e2dd7decc2522c4dac7c99536f3c720c1de7d64f0065edd7487c633450db9eeb687b12138b2763d3093628e0d169b82d7896c781e7c8298bb3c
-  data.tar.gz: 5f668930355e17877237892da08dc440630f2015253b072c715e324c38045598765c58cb84d9657d7769527d3f27774f8d4f03f6bec2cc1bb785bca9a308cce2
+  metadata.gz: df63da254bbbb1b6dedf5e56b5a78d8fbb09fd7d6dfa41ae0b3b58db600f07e8703ea3d729a4bb125e8d1a29e498ce8c3e4504e93d74ad51ce37b7d4a3bad0db
+  data.tar.gz: 8b8607bdda225610b7c7389210c16a04764aa95ba45748f9bcd3c384f9b6eb3ccb371342cea89a12749d7c4226f9fe6b94729c191513690b40168b339d21dd7b

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'
+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_attached(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)
@@ -52,15 +55,84 @@ 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)
-      _, status = Process.wait2(pid)
+    # (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
+
+    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.1'
 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.1
 platform: ruby
 authors:
 - Wip contributors