wslc-wip 0.15.0 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b8248f18abf8e946e333de3e2e9b70e72b9b0f8806a3216c97e62bfe83ad53bb
-  data.tar.gz: 19119fe6787aad4b17cc6ed9e1f1048d664cbcd119414bd4bc4b86e0c26dfb5d
+  metadata.gz: 0b6d4bd2dc0f6ceb899efeaebe7378c6b043915b2d640bf4efff7501f5ca4852
+  data.tar.gz: e5d6c0ed4b89bacaa374482bc7e815a5b04883b4d817809b6dbb0a91c9801ae3
 SHA512:
-  metadata.gz: 91535a4b496bc4cc2e55cc44d7feadbf8709811df0ab660c7d7fe8e6f20feccac18a497804b13bd83a6d2775396e3061c51f64040864e3d6635eeaf22edf9b8e
-  data.tar.gz: 1151d286900c2c11812c607f123d966862ea41b1ac5ee01a74d957f0626667c616fdabf13f618fdad4a62a1b4c8a26f1c68bf837030f1e8f4508a8f2d0e733b1
+  metadata.gz: aed82d2db66e8036c55986181ce73fc032a1785c3ac3a314aadcc2ef7a8b91f6280dc31cbc209aa97dd25ad5eed536013954ca593b61ed966792004209ebcb2f
+  data.tar.gz: 94ee0961eddd267ca8fc8e8f1e198dbd4793801b15c2512539ff55c6cb5223c5ae7e331807030f7eca8d5264b38527db6f4e993ae61fb14d4ef6bdbf26eaf1ad

data/README.md

@@ -153,6 +153,17 @@ bind-mounted](#slow-boot-when-the-app-directory-is-bind-mounted) for why. A `syn
 that problem to `wip`: the source is mounted read-only, the app runs off a named volume, and wip
 mirrors one into the other with `rsync`.
 
+`wip up`'s pre-boot mirror always uses a throwaway container (the primary one isn't running yet),
+so `sync.image`/`sync.build` apply there regardless of `sync.mode` — falling back to the primary
+container's own image if neither is set under `mode: container`/`compose-native` (both have a
+`dependencies:` entry to borrow it from); `mode: compose` has no such entry, so one of
+`sync.image`/`sync.build` is required there. Where `sync.mode` actually matters is every mirror
+*after* that: under `sync.mode: exec` (the default for `mode: container`/`compose-native`), `wip
+sync`/`wip sync --watch` run `rsync` inside the already-running primary container instead, so
+*that* image needs `rsync` installed — `sync.image`/`sync.build` are ignored for these. Under
+`sync.mode: run`, every mirror (pre-boot included) uses a throwaway container, so `sync.image`/
+`sync.build` (or the primary image fallback, where available) need `rsync` throughout.
+
 ```yaml
 sync:
   source: .          # host path, relative to wip.yml (default: the wip.yml directory)
@@ -340,8 +351,11 @@ valid compose.yml over sections it doesn't need to look at:
   `compose.yml`, not wherever `wip` is invoked from), `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`, `depends_on` (ordering only — a `condition:` other than
-  `service_started` is rejected, since there's no health-check support).
+  long-syntax mappings), `working_dir`, `user`, `depends_on` (ordering only — a `condition:` other
+  than `service_started` is rejected, since there's no health-check support). `tty`, `stdin_open`,
+  and `networks` are accepted but silently ignored: TTY/stdin allocation is already decided per
+  invocation (see "TTY allocation" below), not fixed per service, and every service already shares
+  the one project network `compose.project` sets up.
 - `wip logs` takes at most one `SERVICE` (defaulting to `compose.service`) — `wslc logs`, like
   `docker logs`, follows a single container, unlike a real compose tool's multi-service view.
 - `sync:` behaves exactly like `mode: container`'s (falls back to the primary service's own image,
@@ -481,21 +495,28 @@ checklist.
 
 ## Not in the initial release
 
-Full Compose compatibility isn't reimplemented in `wip` itself — `mode: compose-native` only
-covers a minimal subset (see [Compose mode (native)](#compose-mode-native)), and full parity is
-otherwise available by delegating to a third-party compose-for-`wslc` tool (see
-[Compose mode](#compose-mode)). A resident/daemon process, a GUI, PowerShell-specific tuning,
-direct registry API/manifest parsing, self-update, and plugins are all unimplemented.
+Full Compose compatibility isn't reimplemented in `wip` itself — `mode: compose-native` parses
+`compose.yml` and drives `wslc` directly, but only covers a minimal subset (see
+[Compose mode (native)](#compose-mode-native)); full parity is otherwise available by delegating
+to a third-party compose-for-`wslc` tool (see [Compose mode](#compose-mode)). A resident/daemon
+process, a GUI, PowerShell-specific tuning, direct registry API/manifest parsing, self-update, and
+plugins are all unimplemented.
 
 ## Roadmap
 
 `wip` already covers most of what [`dip`](https://github.com/bibendi/dip) adds on top of Compose —
 named commands (`commands:`), `run`/`exec` hidden behind a single verb, `.env` passthrough, and
-sidecar services via `dependencies:` + `network:`. Fuller Compose semantics
-(`depends_on` ordering/health checks, log aggregation, named volumes, profiles, scaling) are now
-handled by delegating to a separate compose-for-`wslc` tool in [compose mode](#compose-mode)
-rather than being reimplemented in `wip` itself. Which of those actually work is entirely up to
-the external tool you point `compose.command` at — `wip` only forwards
+sidecar services via `dependencies:` + `network:`. Rather than waiting on `wslc`'s own Compose
+support ([microsoft/WSL#40948](https://github.com/microsoft/WSL/issues/40948)) or an external
+compose-for-`wslc` tool staying complete, `mode: compose-native` (see
+[Compose mode (native)](#compose-mode-native)) parses `compose.yml` itself and drives `wslc`
+directly — no external binary in the loop, `wip run` gets a real `--rm` container, and iterating
+on the parser is faster than chasing a third-party tool's own bugs. It's still a deliberately
+minimal subset (`depends_on` ordering but no health checks, single-container `logs`, no named
+volumes/scaling), and `dependencies:` + `network:` remains the escape hatch for sidecars it
+doesn't model. Fuller Compose semantics beyond that subset stay behind delegating to a separate
+compose-for-`wslc` tool in [compose mode](#compose-mode) — which of those actually work is
+entirely up to the external tool you point `compose.command` at; `wip` only forwards
 `-f FILE [-p PROJECT] up|down|exec|logs`, so treat that list as what Compose offers, not as
 something `wip` guarantees. See that section for what compose mode covers
 and its current limitations (`run`, and `commands:` of type `run`/`build`). What's still planned

data/lib/wip/cli.rb

@@ -294,6 +294,7 @@ module Wip
     def ensure_compose_images
       load_config.compose_build_specs.each_value do |spec|
         extra = spec['dockerfile'] ? ['-f', spec['dockerfile']] : []
+        spec['args']&.each { |key, value| extra.push('--build-arg', "#{key}=#{value}") }
         execute(builder.build(settings: { 'context' => spec['context'], 'tag' => spec['tag'] }, extra: extra))
       end
     end

data/lib/wip/command_builder.rb

@@ -159,17 +159,26 @@ module Wip
     private
 
     def options(values, include_container: false, include_publish: true, sync: true)
-      result = []
-      result.push('-w', values['workdir']) unless values['workdir'].to_s.empty?
+      result = scalar_options(values)
       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) }
-        volume_specs(values, sync: sync).each { |volume| result.push('-v', volume) }
-      end
+      result.concat(publish_options(values, sync: sync)) if include_publish
       result << required(values, 'container') if include_container
       result
     end
 
+    def scalar_options(values)
+      result = []
+      result.push('-w', values['workdir']) unless values['workdir'].to_s.empty?
+      result.push('-u', values['user']) unless values['user'].to_s.empty?
+      result
+    end
+
+    def publish_options(values, sync:)
+      result = Array(values['ports']).flat_map { |port| ['-p', port.to_s] }
+      volume_specs(values, sync: sync).each { |volume| result.push('-v', volume) }
+      result
+    end
+
     # With sync configured, a live bind mount of the target (`.:/app`) is
     # swapped for the read-only source mount plus the named volume, so the
     # running app only ever touches the volume.

data/lib/wip/compose_file.rb

@@ -15,10 +15,19 @@ module Wip
   # "Compose mode (native)") — once wslc ships that support, or a
   # compose-for-wslc tool reliably supports `run`.
   class ComposeFile
-    Service = Struct.new(:image, :build, :command, :env, :ports, :volumes, :workdir, :depends_on, keyword_init: true)
-
-    SERVICE_KEYS = %w[image build command environment ports volumes working_dir depends_on].freeze
-    BUILD_KEYS = %w[context dockerfile].freeze
+    Service = Struct.new(:image, :build, :command, :env, :ports, :volumes, :workdir, :user, :depends_on,
+                         keyword_init: true)
+
+    SERVICE_KEYS = %w[image build command environment ports volumes working_dir user depends_on].freeze
+    # Real Compose keys that read as meaningful here but have nothing to map onto: TTY/stdin
+    # allocation is already decided per invocation (see CommandBuilder#tty?), not fixed per
+    # service; there's no per-service network to join beyond the one project network `network`
+    # (config.rb) already puts every service on; `wslc run`/`exec` has no restart-policy or
+    # capability flag to forward `restart:`/`cap_add:` to; and `profiles:` gates which services a
+    # real `docker compose up` starts by default, which doesn't apply here since wip never starts
+    # "every service" — only `compose.service` and whatever it reaches via `depends_on`.
+    IGNORED_SERVICE_KEYS = %w[tty stdin_open networks restart cap_add profiles].freeze
+    BUILD_KEYS = %w[context dockerfile args].freeze
     SUPPORTED_CONDITIONS = %w[service_started].freeze
 
     def self.load(path)
@@ -44,10 +53,10 @@ module Wip
     # name => {context:, dockerfile:, tag:} for every service with a build:.
     def build_specs
       @order.filter_map do |name|
-        build = @services.fetch(name).build
-        next unless build
+        service = @services.fetch(name)
+        next unless service.build
 
-        [name, build.merge('tag' => image_tag(name))]
+        [name, service.build.merge('tag' => image_tag(name, service))]
       end.to_h
     end
 
@@ -56,35 +65,41 @@ module Wip
     def to_dependencies_hash
       @order.to_h do |name|
         service = @services.fetch(name)
-        [name, { 'image' => service.build ? image_tag(name) : service.image, 'command' => service.command,
+        [name, { 'image' => service.build ? image_tag(name, service) : service.image, 'command' => service.command,
                  'env' => service.env, 'ports' => service.ports, 'volumes' => service.volumes,
-                 'workdir' => service.workdir }]
+                 'workdir' => service.workdir, 'user' => service.user }]
       end
     end
 
     private
 
-    def image_tag(name) = "wip-compose-#{name}:latest"
+    # A service naming both `build:` and `image:` builds via the former and tags the
+    # result with the latter (real Compose's own rule for that combination), instead
+    # of the auto-generated tag a build:-only service gets.
+    def image_tag(name, service) = service.image || "wip-compose-#{name}:latest"
 
     def build_service(name, entry)
       raise ConfigError, "#{@path}: services.#{name} must be a mapping" unless entry.is_a?(Hash)
 
-      unknown = entry.keys.map(&:to_s) - SERVICE_KEYS
+      unknown = entry.keys.map(&:to_s) - SERVICE_KEYS - IGNORED_SERVICE_KEYS
       raise ConfigError, "#{@path}: services.#{name} has unsupported key(s): #{unknown.join(', ')}" if unknown.any?
 
       image, build = image_or_build(name, entry)
       Service.new(image: image, build: build, command: normalize_command(entry['command']),
-                  env: normalize_env(name, entry['environment']),
-                  ports: normalize_list(name, entry['ports'], 'ports'),
-                  volumes: normalize_list(name, entry['volumes'], 'volumes'),
-                  workdir: presence(entry['working_dir']), depends_on: normalize_depends_on(name, entry['depends_on']))
+                  env: normalize_env(name, entry['environment']), **normalize_service_lists(name, entry),
+                  workdir: presence(entry['working_dir']), user: presence(entry['user']),
+                  depends_on: normalize_depends_on(name, entry['depends_on']))
+    end
+
+    def normalize_service_lists(name, entry)
+      { ports: normalize_list(name, entry['ports'], 'ports'),
+        volumes: normalize_list(name, entry['volumes'], 'volumes') }
     end
 
     def image_or_build(name, entry)
       image = presence(entry['image'])
       build = normalize_build(name, entry['build'])
       raise ConfigError, "#{@path}: services.#{name} must set image or build" unless image || build
-      raise ConfigError, "#{@path}: services.#{name} must not set both image and build" if image && build
 
       [image, build]
     end
@@ -118,27 +133,33 @@ module Wip
 
       context = resolve_context(presence(value['context']) || '.')
       dockerfile = presence(value['dockerfile'])
-      { 'context' => context, 'dockerfile' => dockerfile && Pathname(context).join(dockerfile).to_s }.compact
+      { 'context' => context, 'dockerfile' => dockerfile && Pathname(context).join(dockerfile).to_s,
+        'args' => normalize_kv(name, value['args'], 'build.args') }.compact
     end
 
     # build.context is relative to compose.yml's own directory (Compose's own rule),
     # not wherever `wip` happens to be invoked from.
     def resolve_context(raw) = Pathname(@path).expand_path.dirname.join(raw).to_s
 
-    def normalize_env(name, value)
+    def normalize_env(name, value) = normalize_kv(name, value, 'environment')
+
+    # Shared by `environment:` and `build.args:` — both accept a mapping or a
+    # KEY=VALUE array, and neither supports host environment pass-through (a
+    # null mapping value, or a bare KEY with no `=`).
+    def normalize_kv(name, value, label)
       return {} unless value
 
       case value
-      when Hash then normalize_env_mapping(name, value)
-      when Array then normalize_env_array(name, value)
-      else raise ConfigError, "#{@path}: services.#{name}.environment must be a mapping or an array of KEY=VALUE"
+      when Hash then normalize_kv_mapping(name, value, label)
+      when Array then normalize_kv_array(name, value, label)
+      else raise ConfigError, "#{@path}: services.#{name}.#{label} must be a mapping or an array of KEY=VALUE"
       end
     end
 
-    def normalize_env_mapping(name, value)
+    def normalize_kv_mapping(name, value, label)
       value.to_h do |key, val|
         if val.nil?
-          raise ConfigError, "#{@path}: services.#{name}.environment.#{key} must have a value " \
+          raise ConfigError, "#{@path}: services.#{name}.#{label}.#{key} must have a value " \
                              '(host environment pass-through is not supported)'
         end
 
@@ -146,10 +167,10 @@ module Wip
       end
     end
 
-    def normalize_env_array(name, value)
+    def normalize_kv_array(name, value, label)
       value.to_h do |item|
         key, val = item.to_s.split('=', 2)
-        raise ConfigError, "#{@path}: services.#{name}.environment entries must be KEY=VALUE" unless val
+        raise ConfigError, "#{@path}: services.#{name}.#{label} entries must be KEY=VALUE" unless val
 
         [key, val]
       end

data/lib/wip/config.rb

@@ -7,7 +7,7 @@ module Wip
   class Config
     # Applied to every dependencies: entry, primary container included — there
     # is no separate, differently-shaped bucket for "the one you exec into."
-    DEPENDENCY_DEFAULTS = { 'workdir' => nil, 'interactive' => false, 'remove' => true,
+    DEPENDENCY_DEFAULTS = { 'workdir' => nil, 'user' => nil, 'interactive' => false, 'remove' => true,
                             'env' => {}, 'ports' => [], 'volumes' => [] }.freeze
     SECRET_PATTERN = /token|password|secret|credential|auth/i
     # Which orchestration path `up`/`down`/`sync`/etc. take. Explicit rather than

data/lib/wip/doctor.rb

@@ -138,6 +138,12 @@ module Wip
       results << result(File.directory?(sync.source) ? :ok : :fail,
                         "Sync source #{sync.source} mirrors into volume #{sync.volume} at #{sync.target}",
                         "Sync source not found: #{sync.source}")
+      return unless sync.exec? && (sync.image || sync.build)
+
+      results << Result.new(:warn, 'sync.image/sync.build only cover `wip up`’s one-time pre-boot mirror ' \
+                                   '(the primary container isn’t running yet, so that step always uses a ' \
+                                   'throwaway container) — sync.mode: exec’s `wip sync`/`wip sync --watch` run ' \
+                                   'rsync inside the primary container instead, so its image needs rsync too')
     end
 
     def result(condition, ok_message, fail_message)

data/lib/wip/initializer.rb

@@ -122,7 +122,13 @@ module Wip
         # optional; exec (default, mirrors into the running container) | run (always a fresh container)
         mode: exec
 
-        # only needed if sync.mode: run (or under mode: compose); image the mirror container runs
+        # image/build below always cover `wip up`'s pre-boot mirror (a throwaway container, since
+        # the primary one isn't running yet — falls back to the primary image if neither is set).
+        # With mode: exec above (the default here), `wip sync`/`wip sync --watch` afterward run
+        # rsync inside the already-running primary container instead, so its own image needs
+        # rsync installed too — image/build below aren't read for those.
+
+        # image the pre-boot (and, under sync.mode: run, every) mirror container runs
         # image: your/image:tag
 
         # alternative to image — let wip build a small dedicated mirror image itself

data/lib/wip/version.rb

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

metadata

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