feat(lock): Add update CLI command (#92)

Author: dmcilvaney

.github/instructions/concurrency.instructions.md

@@ -0,0 +1,81 @@
+---
+applyTo: "**/*.go"
+description: "Concurrency patterns for parallel task execution. Follow these patterns when writing code that runs tasks concurrently."
+---
+
+# Concurrency Patterns
+
+When running tasks in parallel (e.g., per-component operations), follow these patterns:
+
+## Concurrency Limits
+
+Use `env.IOBoundConcurrency()` or `env.CPUBoundConcurrency()` from `azldev.Env` to determine the worker count:
+
+- **I/O-bound** (network clones, file copies): `env.IOBoundConcurrency()` — 2× CPU count
+- **CPU-bound** (hashing, parsing): `env.CPUBoundConcurrency()` — 1× CPU count
+
+**Never launch unbounded goroutines.** With 7k+ components, unbounded parallelism will overwhelm the system (loadavg 500+).
+
+## Semaphore Pattern
+
+Use a buffered channel as a semaphore to limit concurrency:
+
+```go
+semaphore := make(chan struct{}, env.IOBoundConcurrency())
+
+go func() {
+    select {
+    case semaphore <- struct{}{}:
+        defer func() { <-semaphore }()
+    case <-ctx.Done():
+        // handle cancellation
+        return
+    }
+    // do work
+}()
+```
+
+## Cancellation (Ctrl+C)
+
+Always support graceful cancellation via `env.WithCancel()`:
+
+1. Create a cancellable child env: `workerEnv, cancel := env.WithCancel(); defer cancel()`
+2. Use context-aware semaphore acquisition (select on semaphore and `workerEnv.Done()`)
+3. Pass `workerEnv` (not `env`) to worker goroutines so they respect cancellation
+
+Example from `render.go` and `update.go`:
+
+```go
+workerEnv, cancel := env.WithCancel()
+defer cancel()
+
+semaphore := make(chan struct{}, env.IOBoundConcurrency())
+
+for idx, item := range items {
+    waitGroup.Add(1)
+    go func() {
+        defer waitGroup.Done()
+
+        select {
+        case semaphore <- struct{}{}:
+            defer func() { <-semaphore }()
+        case <-workerEnv.Done():
+            results[idx].Error = "context cancelled"
+            return
+        }
+
+        // Do work using workerEnv (not env)
+        doWork(workerEnv, item)
+    }()
+}
+
+waitGroup.Wait()
+```
+
+## Limits
+
+The `Env` type provides a set of methods to determine appropriate concurrency limits for different types of tasks: `IOBoundConcurrency()`, `CPUBoundConcurrency()`, and `FastConcurrency()`. Use these methods to set the size of worker pools or semaphores based on the nature of the tasks being performed.
+
+## Thread Safety
+
+- Events are currently not thread-safe; control long-running event handling outside of worker goroutines.

.github/workflows/devcontainer.yml

@@ -1,13 +1,13 @@
 name: "Check devcontainer build"
 on:
   push:
-    branches: [ main ]
+    branches: [main]
   pull_request:
-    branches: [ main ]
+    branches: [main]
   workflow_dispatch:
   schedule:
     # Run every night at 3:15am PST (11:15am UTC)
-    - cron: '15 11 * * *'
+    - cron: "15 11 * * *"
 
 # Cancel in-progress runs of this workflow if a new run is triggered.
 concurrency:
@@ -32,6 +32,7 @@ jobs:
           # We disable the unix-chkpwd AppArmor profile to avoid errors building the container.
           # We also need to purge a few packages to avoid profile conflicts.
           set -euxo pipefail
+          sudo apt-get update
           sudo apt-get purge firefox passt
           sudo systemctl reload apparmor.service
           sudo apt-get install apparmor-utils

.github/workflows/test.yml

@@ -1,13 +1,13 @@
 name: "Run tests"
 on:
   push:
-    branches: [ main ]
+    branches: [main]
   pull_request:
-    branches: [ main ]
+    branches: [main]
   workflow_dispatch:
   schedule:
     # Run every night at 3:15am PST (11:15am UTC)
-    - cron: '15 11 * * *'
+    - cron: "15 11 * * *"
 
 # Cancel in-progress runs of this workflow if a new run is triggered.
 concurrency:
@@ -53,6 +53,7 @@ jobs:
           # containerized tests. We also need to purge a few packages to avoid
           # profile conflicts.
           set -euxo pipefail
+          sudo apt-get update
           sudo apt-get purge firefox passt
           sudo systemctl reload apparmor.service
           sudo apt-get install apparmor-utils

docs/user/reference/cli/azldev_component.md

@@ -30,4 +30,5 @@ components defined in the project configuration.`,
 	prepareOnAppInit(app, cmd)
 	queryOnAppInit(app, cmd)
 	renderOnAppInit(app, cmd)
+	updateOnAppInit(app, cmd)
 }

docs/user/reference/cli/azldev_component_update.md

@@ -8,7 +8,6 @@ import (
 	"fmt"
 	"log/slog"
 	"path/filepath"
-	"runtime"
 	"slices"
 	"strings"
 	"sync"
@@ -115,13 +114,6 @@ const (
 	renderStatusCancelled = "cancelled"
 )
 
-// concurrentRenderLimit returns the number of concurrent goroutines for phases 1 and 3.
-// Each goroutine involves git clone + overlay (phase 1) or file filtering + copy (phase 3),
-// so this bounds I/O parallelism. Uses 2x CPU count since these operations are I/O-bound.
-func concurrentRenderLimit() int {
-	return max(1, 2*runtime.NumCPU()) //nolint:mnd // 2x CPU empirically chosen via benchmarking
-}
-
 // RenderComponents renders the post-overlay spec and sidecar files for each
 // selected component into the output directory. Processing is done in three phases:
 //  1. Parallel source preparation (clone, overlay, synthetic git)
@@ -290,7 +282,7 @@ func parallelPrepare(
 	defer cancel()
 
 	resultsChan := make(chan prepResult, len(comps))
-	semaphore := make(chan struct{}, concurrentRenderLimit())
+	semaphore := make(chan struct{}, env.IOBoundConcurrency())
 
 	var waitGroup sync.WaitGroup
 
@@ -486,7 +478,7 @@ func batchMockProcess(
 		}
 	}
 
-	mockResults, err := mockProcessor.BatchProcess(env, env, stagingDir, inputs, env.FS())
+	mockResults, err := mockProcessor.BatchProcess(env, env, stagingDir, inputs, env.FS(), env.CPUBoundConcurrency())
 	if err != nil {
 		slog.Error("Batch mock processing failed", "error", err)
 		// Return empty map — all components will get reported as errors in phase 3.
@@ -532,7 +524,7 @@ func parallelFinish(
 	}
 
 	resultsChan := make(chan finishResult, len(prepared))
-	semaphore := make(chan struct{}, concurrentRenderLimit())
+	semaphore := make(chan struct{}, env.IOBoundConcurrency())
 
 	var waitGroup sync.WaitGroup