wslc-wip 1.1.2 → 1.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 37c2e70c286c4dd7b163201674eff9b4111fbe3f05ef032500a5b7ac516f97b5
-  data.tar.gz: fbad7b94e10bb0cbd9efc8c70f1a2546830ac0c20f276a925b48e0d668679902
+  metadata.gz: 753cbc1f34c7c0c598edd7b4e4bc821953b97e12c66cec448096e05a0debd909
+  data.tar.gz: c9cc51e4f53a4f8240be292487315ee4cdec019febc006d232d09560457e1a20
 SHA512:
-  metadata.gz: 70319980be04f8abdbb6d5e167e8941ca4fa3a8ab65b0cd71ec884daff639205a70935b4c5a756ec3403678982c2859423051930379aa3d79f302506b0f88326
-  data.tar.gz: f100b5622d566ab77da4437cb028138a7fa33f47d4d19ff70874c683e2995e9c3213bc95b0109c03c82556827a26ee22b47a034bf7fc96895effc2c8fcb3950f
+  metadata.gz: c45401f388f42dc378066a1a3e14b39b622f13087f8627439f59ce8fa384fa2fb7f162bee8d6ee1f11581e32d5ece6d782bcb2d1c7bfd06f64973944d30ee1c5
+  data.tar.gz: beb47f232295309e11aa6df585b829165fa125024283da3e29f8ee222ea05eaee530df0ee9f759bb2de8b29b11dfb789d883691c8750e43e6e5655b44ebc4122

data/README.md

@@ -159,9 +159,12 @@ The two are aliases for the same feature, not separate ones: pick whichever name
 
 `dependencies:` holds every container uniformly — the primary one `container:` points at and any
 sidecar services (a database, Redis, ...) alongside it. Each entry accepts `image` (required),
-`command`, `env`, `ports`, `volumes`, and `workdir`; there's no separate, differently-shaped block
-for "the one you exec into." `container:` has no default; once `dependencies:` has any entries,
-wip needs to be told explicitly which one is primary rather than guessing a name.
+`command`, `env`, `ports`, `volumes`, `workdir`, and `restart`; there's no separate, differently-shaped
+block for "the one you exec into." `container:` has no default; once `dependencies:` has any entries,
+wip needs to be told explicitly which one is primary rather than guessing a name. `restart` is stored
+but inert on its own — see
+[Restarting exited dependencies](#restarting-exited-dependencies-wip-up---watch) for what actually
+acts on it (`wip up --watch`).
 
 What sets the primary entry apart is operational, not structural: `wip up` brings up every other
 entry by name first (creating `network:` beforehand if it doesn't exist and set), then boots or
@@ -172,6 +175,46 @@ in place). Only the primary container is a target for `exec`/`run`/`build`/`inte
 are only ever started and stopped, matching Compose's own service-vs-you-exec-into-one-of-them
 split.
 
+#### Restarting exited dependencies (`wip up --watch`)
+
+Real Compose auto-restarts a container tagged `restart: always`/`unless-stopped`/`on-failure` when
+it exits. `wslc` has no such policy, and no push-based "container exited" notification for `wip` to
+hook into, so the closest approximation is polling: `wip up --watch` brings everything up the same
+way `wip up -d` does, then keeps checking (`--interval SECONDS`, default 5) whether any
+dependency — the primary container included — has exited, restarting the ones whose `restart:`
+allows it.
+
+```console
+$ wip up --watch
+wip: watching app, mysql for exited restart: containers every 5s (running detached; Ctrl-C to stop)
+```
+
+- `restart:` accepts the same values Compose does — `no` (the default), `always`, `unless-stopped`,
+  `on-failure`, optionally with a `:MAX_RETRIES` suffix. `wip up --watch` treats the three
+  restarting values identically: it restarts on any exited container regardless of exit code,
+  unlike real `on-failure`, which skips a clean (zero) exit — reading an exit code needs a heavier
+  call this polling loop doesn't make.
+- This is a foreground loop, not a background daemon or service — the project intentionally has
+  neither (see [Roadmap](#roadmap)). Keep the terminal it's running in open, the same as
+  `wip sync --watch`; Ctrl-C (or closing the terminal) stops the supervision.
+- `--watch` implies `-d`: it can't attach a TTY to the primary container and poll in a loop on the
+  same thread, so the primary container always runs detached under `--watch`, whether or not you
+  also passed `-d`.
+- Not available under `mode: compose` — wip never parses a service list in that mode, so there's
+  nothing for it to poll; use whatever restart support your external compose-for-`wslc` tool offers.
+- It's status-based, not event-based: each tick checks whether a dependency is currently exited, not
+  whether it *just* exited. It can't tell "crashed on its own" apart from "you ran `wip stop`/
+  `wip down` in another terminal" — Ctrl-C the `--watch` loop first, or it may race and restart
+  what you just stopped.
+- Re-running `wip up -d --watch` against an already-running stack is safe: an already-running
+  container's `start` is a no-op, the same as it is for plain `wip up`.
+- The exit-detection reads `wslc list --all --format json`'s `State` field as a raw integer, per
+  `WslcContainerState` ([wsl.dev](https://wsl.dev/api-reference/c/enumerations/wslccontainerstate/)):
+  `0` invalid, `1` created, `2` running, `3` exited, `4` deleted. Unlike Docker, there's no separate
+  `dead` state — a `deleted` container is gone and needs `wip up` (not `--watch`) to recreate it.
+  If `--watch` never restarts anything you believe really exited, run `wip up --watch --debug` and
+  check the logged `list` entry against this enum.
+
 ### Compose mode
 
 If your project already has a real `compose.yml`, don't duplicate it in `dependencies:` — point
@@ -250,11 +293,13 @@ valid compose.yml over sections it doesn't need to look at:
   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
-  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.
+  long-syntax mappings), `working_dir`, `user`, `restart` (stored as-is; `no` is the default —
+  `wip up --watch` is what actually acts on it, see
+  [Restarting exited dependencies](#restarting-exited-dependencies-wip-up---watch)), `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,
@@ -422,7 +467,7 @@ to that tag directly — `sync.build`'s tag wins if both are set, so don't confi
 | `wip doctor` | Diagnose WSL2, interop, WSLC, config, architecture, and Git |
 | `wip config` | Print the effective configuration (secrets masked) |
 | `wip build [--no-cache] [-- OPTIONS]` | Build the image from the `build` definition. `wslc build` reuses matching local layers by default; `--no-cache` disables that. |
-| `wip up [-d] [--no-sync] [--no-cache]` | Start the primary `dependencies:` entry (`container:` names which one) and its sidecars (creating any that are missing, on `network:` if set). `-d` runs the main container in the background; with `sync:` configured, the source is mirrored into the volume first unless `--no-sync` |
+| `wip up [-d] [--no-sync] [--no-cache] [--watch] [--interval N]` | Start the primary `dependencies:` entry (`container:` names which one) and its sidecars (creating any that are missing, on `network:` if set). `-d` runs the main container in the background; with `sync:` configured, the source is mirrored into the volume first unless `--no-sync`. `--watch` polls every `N` seconds (default 5, implies `-d`) and restarts any exited dependency whose `restart:` allows it (not available under mode: compose) |
 | `wip stop` | Stop the primary container and its sidecar `dependencies:` without removing them |
 | `wip down` | Stop and remove the primary container and its sidecar `dependencies:` |
 | `wip exec [--no-interactive] COMMAND...` | Run a command in the existing container |
@@ -635,7 +680,11 @@ and its current limitations (`run`, and `interaction:` of type `run`/`build`).
 
 Beyond Compose parity, a resident/daemon process, a GUI, PowerShell-specific tuning, direct
 registry API/manifest parsing, self-update, and plugins are all unimplemented and not currently
-planned. What's still planned for `wip`, roughly in priority order:
+planned. (`wip up --watch`'s restart-policy poll loop isn't an exception to this — it's a
+foreground, opt-in loop you keep a terminal open for, the same shape as `wip sync --watch`, not a
+background service; see
+[Restarting exited dependencies](#restarting-exited-dependencies-wip-up---watch).) What's still
+planned for `wip`, roughly in priority order:
 
 1. **`wip provision`** — a dip-style one-shot bootstrap hook (build → up deps → install deps →
    create/migrate/seed DB) so a new contributor can go from `git clone` to a working environment

data/lib/wip/cli.rb

@@ -16,6 +16,42 @@ module Wip
     class_option :debug_log, type: :string, desc: 'Where --debug snapshots go: a file path, or "-" for inline'
     default_task :dispatch
 
+    # Thor only recognizes class_options (--config, --debug, ...) once they
+    # appear after the command name (`wip up --config foo`). Pull a leading
+    # run of them off the front of ARGV and reinsert it right after the
+    # command name so `wip --config foo up` works too.
+    GLOBAL_SWITCHES = {
+      '--config' => :value,
+      '--env-file' => :value,
+      '--debug' => :flag,
+      '--debug-log' => :value
+    }.freeze
+
+    def self.start(given_args = ARGV, config = {})
+      super(reorder_global_options(given_args), config)
+    end
+
+    def self.reorder_global_options(args)
+      remaining = args.dup
+      extracted = []
+
+      until remaining.empty?
+        name, _, inline_value = remaining.first.to_s.partition('=')
+        kind = GLOBAL_SWITCHES[name]
+        break unless kind
+
+        switch = remaining.shift
+        extracted << switch
+        extracted << remaining.shift if kind == :value && inline_value.empty? && !remaining.empty?
+      end
+
+      command_index = remaining.index { |arg| !arg.start_with?('-') }
+      return args if command_index.nil?
+
+      remaining.insert(command_index + 1, *extracted)
+      remaining
+    end
+
     def self.exit_on_failure? = true
 
     # Thor only falls back to the default task when no command name is given at
@@ -82,21 +118,41 @@ module Wip
       progress&.finish
     end
 
+    # Real Compose values that trigger a restart when a container's exited; `no` (the default)
+    # and anything unrecognized both mean "leave it alone." Exact match only — a typo'd value
+    # like "always-invalid" must stay inert, not accidentally match via a loose prefix check.
+    AUTO_RESTART_POLICIES = %w[always unless-stopped].freeze
+    ON_FAILURE_POLICY = /\Aon-failure(?::\d+)?\z/ # optional `:MAX_RETRIES` suffix, e.g. "on-failure:3"
+
+    # WSLC's `WslcContainerState` (confirmed via microsoft/WSL's own docs and
+    # ContainerModel.h — ContainerInformation#State has no custom JSON enum serializer, so
+    # nlohmann::json emits its raw ordinal): 0 invalid, 1 created, 2 running, 3 exited, 4
+    # deleted. Unlike Docker, there's no separate "dead" state — only `exited` is a live,
+    # restartable exit; `deleted` means the container itself is gone (needs `wip up` to
+    # recreate it, not `start`).
+    WSLC_CONTAINER_STATE_EXITED = 3
+
     desc 'up', 'Start the configured container and its dependencies, creating them if necessary'
     option :detach, type: :boolean, default: false, aliases: '-d'
     option :sync, type: :boolean, default: true, desc: 'Mirror the source into the sync volume first (--no-sync skips)'
     option :no_cache, type: :boolean, default: false, desc: 'Build compose-native images without cached layers'
+    option :watch, type: :boolean, default: false, aliases: '-w',
+                   desc: 'Poll dependencies and restart any exited one whose restart: allows it (implies -d)'
+    option :interval, type: :numeric, default: 5, desc: 'Seconds between --watch polls (default: 5)'
     def up
-      if load_config.compose?
-        sync_before_boot if options[:sync]
-        return execute(compose_bridge.up(detach: options[:detach]), interactive: tty?(!options[:detach]))
-      end
+      return up_via_compose_bridge if load_config.compose?
+
+      # Validated up front, before any startup side effect (image build, network/dependency/
+      # container creation) — otherwise a bad --interval would only surface as a ConfigError
+      # after already bringing everything up.
+      interval = restart_interval if options[:watch]
 
       ensure_compose_images
       ensure_network
       sidecar_names.each { |name| ensure_dependency(name) }
       sync_before_boot if options[:sync]
       ensure_container
+      watch_restarts(interval) if options[:watch]
     end
 
     desc 'sync', 'Mirror the source tree into the sync volume'
@@ -194,7 +250,7 @@ module Wip
 
     desc 'dispatch COMMAND [ARGS...]', 'Run a command defined in wip.yml'
     def dispatch(name = nil, *arguments)
-      raise ConfigError, 'A command is required' unless name
+      return help if name.nil?
 
       values = load_config.command(name) || raise(ConfigError, "Unknown command: #{name}")
       return dispatch_compose(name, values, arguments) if load_config.compose?
@@ -407,16 +463,79 @@ module Wip
       warn "wip: run `wip sync --watch` in another terminal to keep #{settings.target} up to date"
     end
 
+    def up_via_compose_bridge
+      if options[:watch]
+        raise ConfigError, '`wip up --watch` is not supported under mode: compose (wip never parses a ' \
+                           'compose.yml service list in that mode, so there is nothing to poll)'
+      end
+
+      sync_before_boot if options[:sync]
+      execute(compose_bridge.up(detach: options[:detach]), interactive: tty?(!options[:detach]))
+    end
+
     def ensure_container
       container = load_config.container
-      interactive = tty?(!options[:detach])
+      interactive = tty?(!detach?)
       if resource_exists?(builder.find)
         warn "wip: starting existing container '#{container}'"
-        execute(builder.start(detach: options[:detach]), interactive: interactive)
+        execute(builder.start(detach: detach?), interactive: interactive)
       else
         warn "wip: container '#{container}' not found, creating it"
-        execute(builder.up(detach: options[:detach]), interactive: interactive)
+        execute(builder.up(detach: detach?), interactive: interactive)
+      end
+    end
+
+    # --watch polls in a loop after boot, which can't share this one thread with an attached
+    # (`-it`) primary container — force the same effective behavior `-d` gives ensure_container.
+    def detach? = options[:detach] || options[:watch]
+
+    # Approximates Docker Compose's `restart:` policy via a foreground poll loop — not a
+    # background daemon/service (see README "Roadmap"); the same opt-in, keep-a-terminal-open
+    # shape as `wip sync --watch`.
+    def watch_restarts(interval)
+      names = load_config.dependencies.keys
+      warn "wip: watching #{names.join(', ')} for exited restart: containers every #{interval}s " \
+           '(running detached; Ctrl-C to stop)'
+      loop do
+        names.each { |name| restart_if_exited(name) }
+        sleep interval
       end
+    rescue Interrupt
+      warn "\nwip: watch stopped"
+    end
+
+    def restart_interval
+      raise ConfigError, '--interval must be a positive number' unless options[:interval].positive?
+
+      options[:interval]
+    end
+
+    # Status-based, not transition-based: each tick checks current state, not whether it *just*
+    # exited. Can't distinguish "crashed on its own" from "you ran `wip stop`/`wip down` in
+    # another terminal" — Ctrl-C this loop first if you're about to do either (see README).
+    def restart_if_exited(name)
+      policy = load_config.dependency(name)['restart']
+      return unless auto_restart?(policy)
+      return unless container_status(name) == WSLC_CONTAINER_STATE_EXITED
+
+      warn "wip: '#{name}' has exited, restarting it (restart: #{policy})"
+      execute(builder.dependency_start(name), exit_on_failure: false)
+    end
+
+    def auto_restart?(policy) = AUTO_RESTART_POLICIES.include?(policy) || ON_FAILURE_POLICY.match?(policy.to_s)
+
+    # Isolated to this one method: if a future wslc release changes this shape, fixing it here
+    # is a one-line change. Logs the raw entry under --debug so that's immediately visible
+    # instead of silently no-op'ing forever.
+    def container_status(name)
+      code, output = probe(builder.dependency_find(name))
+      return nil unless code.zero?
+
+      entry = JSON.parse(output).first
+      warn "wip: [debug] '#{name}': #{entry.inspect}" if debug?
+      entry&.fetch('State', nil)
+    rescue JSON::ParserError
+      nil
     end
   end
 end

data/lib/wip/compose_file.rb

@@ -15,15 +15,17 @@ 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, :user, :depends_on, :profiles,
-                         keyword_init: true)
+    Service = Struct.new(:image, :build, :command, :env, :ports, :volumes, :workdir, :user, :restart, :depends_on,
+                         :profiles, keyword_init: true)
 
-    SERVICE_KEYS = %w[image build command environment ports volumes working_dir user depends_on profiles].freeze
+    SERVICE_KEYS = %w[image build command environment ports volumes working_dir user restart depends_on
+                      profiles].freeze
     # Real Compose keys that read as meaningful here but have nothing to map onto: TTY/stdin
     # allocation is decided per invocation (CommandBuilder#tty?), not per service; every
     # 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
+    # capability flag to forward `cap_add:` to. (`restart:` used to be here too, silently
+    # ignored — it's parsed below now and approximated by `wip up --watch`, see cli.rb.)
+    IGNORED_SERVICE_KEYS = %w[tty stdin_open networks cap_add].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'
@@ -65,14 +67,14 @@ module Wip
       end.to_h
     end
 
-    # Shaped like Config::DEPENDENCY_DEFAULTS expects: image/command/env/ports/volumes/workdir,
+    # Shaped like Config::DEPENDENCY_DEFAULTS expects: image/command/env/ports/volumes/workdir/restart,
     # in dependency order so callers iterating sidecars start them before their dependents.
     def to_dependencies_hash
       startable_order.to_h do |name|
         service = @services.fetch(name)
         [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, 'user' => service.user }]
+                 'workdir' => service.workdir, 'user' => service.user, 'restart' => service.restart }]
       end
     end
 
@@ -97,6 +99,7 @@ module Wip
       Service.new(image: image, build: build, command: normalize_command(entry['command']),
                   env: normalize_env(name, entry['environment']), **normalize_service_lists(name, entry),
                   workdir: presence(entry['working_dir']), user: presence(entry['user']),
+                  restart: normalize_restart(entry['restart']),
                   depends_on: normalize_depends_on(name, entry['depends_on']))
     end
 
@@ -250,6 +253,20 @@ module Wip
       order << name
     end
 
+    # Compose's own default (`no`) applies whether restart: is absent or explicitly falsy —
+    # including the very common unquoted `restart: no`, which YAML resolves to the boolean
+    # `false`, not the string "no" (confirmed against this repo's own Psych: `YAML.safe_load
+    # ("restart: no")` => {"restart"=>false}). Every other value is accepted as-is, even ones
+    # outside always/unless-stopped/on-failure[:N]: this parser's job is to read what's in
+    # compose.yml, not police it — `wip up --watch` (cli.rb) decides which values it acts on.
+    # Rejecting a real, valid Compose value here would break projects that already work today
+    # (compose.yml predates wip, unlike wip.yml itself).
+    def normalize_restart(value)
+      return 'no' if value == false
+
+      presence(value) || 'no'
+    end
+
     def presence(value) = value.to_s.empty? ? nil : value.to_s
   end
 end

data/lib/wip/config.rb

@@ -8,7 +8,7 @@ module Wip
     # 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, 'user' => nil, 'interactive' => false, 'remove' => true,
-                            'env' => {}, 'ports' => [], 'volumes' => [] }.freeze
+                            'env' => {}, 'ports' => [], 'volumes' => [], 'restart' => 'no' }.freeze
     SECRET_PATTERN = /token|password|secret|credential|auth/i
     # Which orchestration path `up`/`down`/`sync`/etc. take. Explicit rather than
     # inferred from a `compose:` block's presence, so a config reader doesn't have
@@ -209,6 +209,16 @@ module Wip
       raise ConfigError, "dependencies.#{name} must set image" if entry['image'].to_s.empty?
 
       entry['env']&.transform_values!(&:to_s)
+      normalize_dependency_restart!(entry)
+    end
+
+    # Mirrors ComposeFile#normalize_restart: an unquoted `restart: no` parses as the boolean
+    # false rather than the string "no", and an explicit nil/"" should default the same way an
+    # absent key does (DEPENDENCY_DEFAULTS only fills in a genuinely *missing* key).
+    def normalize_dependency_restart!(entry)
+      return unless entry.key?('restart')
+
+      entry['restart'] = 'no' if entry['restart'] == false || entry['restart'].to_s.empty?
     end
 
     def stringify(object)

data/lib/wip/initializer.rb

@@ -159,6 +159,10 @@ module Wip
             # optional; remove the container after each run
             remove: true
 
+            # optional; restart policy `wip up --watch` polls for — always/unless-stopped/on-failure
+            # restart an exited container; "no" (the default) never does — see README
+            restart: "no"
+
             # optional; environment variables passed to the container, e.g. {FOO: bar}
             env: {}
 

data/lib/wip/version.rb

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

metadata

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