Remove UUID handling and fix unit test

Author: sebastianrath

.github/workflows/graphs/build-test-publish.act

@@ -199,7 +199,9 @@ nodes:
                     else
                         P4_LIB="$(pwd)/p4api/windows-x86_64/lib"
                         P4_CGO_CPPFLAGS="-I$P4_INCLUDE -DOS_NT"
-                        P4_CGO_LDFLAGS="-L$P4_LIB -lp4api -lssl -lcrypto -lcrypt32 -lws2_32 -lole32 -lshell32 -luser32 -ladvapi32"
+                        # Use static OpenSSL from MSYS2 MinGW
+                        MSYS2_SSL_LIB="$(cygpath -u "${MSYS2_ROOT:-/d/a/_temp/msys64}")/mingw64/lib"
+                        P4_CGO_LDFLAGS="-L$P4_LIB -lp4api $MSYS2_SSL_LIB/libssl.a $MSYS2_SSL_LIB/libcrypto.a -lcrypt32 -lws2_32 -lole32 -lshell32 -luser32 -ladvapi32"
                     fi
                     ;;
             esac

agent/client.go

@@ -12,7 +12,6 @@ import (
 type Client struct {
 	serverURL  string
 	token      string
-	uuid       string
 	httpClient *http.Client
 }
 
@@ -26,10 +25,6 @@ func NewClient(serverURL, token string) *Client {
 	}
 }
 
-func (c *Client) SetUUID(uuid string) {
-	c.uuid = uuid
-}
-
 func (c *Client) doRequest(method, path string, body interface{}) (*http.Response, error) {
 	var bodyReader io.Reader
 	if body != nil {
@@ -45,9 +40,6 @@ func (c *Client) doRequest(method, path string, body interface{}) (*http.Respons
 		return nil, err
 	}
 	req.Header.Set("Authorization", "Bearer "+c.token)
-	if c.uuid != "" {
-		req.Header.Set("X-Agent-UUID", c.uuid)
-	}
 	if body != nil {
 		req.Header.Set("Content-Type", "application/json")
 	}

agent/flock_unix.go

@@ -74,7 +74,6 @@ type StatusReport struct {
 
 // HeartbeatRequest is sent periodically with agent metrics.
 type HeartbeatRequest struct {
-	UUID          string  `json:"uuid,omitempty"`
 	CPUPercent    float64 `json:"cpu_percent"`
 	MemPercent    float64 `json:"mem_percent"`
 	MemUsedBytes  int64   `json:"mem_used_bytes"`

agent/flock_windows.go

@@ -3,7 +3,6 @@ package agent
 import (
 	"bufio"
 	"context"
-	"crypto/rand"
 	"fmt"
 	"os"
 	"os/exec"
@@ -25,106 +24,27 @@ type Worker struct {
 	docker       DockerConfig
 	vcsOpts      vcs.Options
 	pollInterval time.Duration
-	uuid         string
-	slotCleanup  func()
 	log          *logrus.Entry
 
 	metricsMu    sync.Mutex
 	lastCounters *RawCounters
 }
 
 func NewWorker(client *Client, docker DockerConfig, vcsOpts vcs.Options) *Worker {
-	uuid, cleanup := acquireAgentSlot()
-	client.SetUUID(uuid)
 	return &Worker{
 		client:       client,
 		docker:       docker,
 		vcsOpts:      vcsOpts,
 		pollInterval: 1 * time.Second,
-		uuid:         uuid,
-		slotCleanup:  cleanup,
 		log:          logrus.WithField("component", "agent"),
 	}
 }
 
-// agentSlotDir returns the directory for agent UUID slot files.
-func agentSlotDir() string {
-	dir, err := os.UserConfigDir()
-	if err != nil {
-		dir = os.TempDir()
-	}
-	return filepath.Join(dir, "actionforge")
-}
-
-// acquireAgentSlot finds and locks the lowest available agent slot.
-// Each slot has a persistent UUID file and a lock file. When the process
-// exits, the lock is released so the next process can reuse that slot
-// (and its UUID/metrics history).
-// Returns the UUID and a cleanup function that releases the lock.
-func acquireAgentSlot() (string, func()) {
-	dir := agentSlotDir()
-	_ = os.MkdirAll(dir, 0700)
-
-	const maxSlots = 256
-	for i := 0; i < maxSlots; i++ {
-		lockPath := filepath.Join(dir, fmt.Sprintf("agent-%d.lock", i))
-		uuidPath := filepath.Join(dir, fmt.Sprintf("agent-%d.uuid", i))
-
-		lockFile, err := os.OpenFile(lockPath, os.O_CREATE|os.O_RDWR, 0600)
-		if err != nil {
-			continue
-		}
-
-		if err := lockFileExclusive(lockFile); err != nil {
-			if cerr := lockFile.Close(); cerr != nil {
-				logrus.WithError(cerr).Warn("failed to close lock file")
-			}
-			continue
-		}
-
-		// Slot acquired — read or generate UUID
-		uuid := ""
-		if data, err := os.ReadFile(uuidPath); err == nil {
-			if id := strings.TrimSpace(string(data)); len(id) == 36 {
-				uuid = id
-			}
-		}
-		if uuid == "" {
-			var buf [16]byte
-			_, _ = rand.Read(buf[:])
-			buf[6] = (buf[6] & 0x0f) | 0x40 // version 4
-			buf[8] = (buf[8] & 0x3f) | 0x80 // variant 1
-			uuid = fmt.Sprintf("%08x-%04x-%04x-%04x-%012x",
-				buf[0:4], buf[4:6], buf[6:8], buf[8:10], buf[10:16])
-			_ = os.WriteFile(uuidPath, []byte(uuid+"\n"), 0600)
-		}
-
-		cleanup := func() {
-			unlockFile(lockFile)
-			if cerr := lockFile.Close(); cerr != nil {
-				logrus.WithError(cerr).Warn("failed to close lock file")
-			}
-		}
-		return uuid, cleanup
-	}
-
-	// Fallback: all slots taken, generate ephemeral UUID with no lock
-	var buf [16]byte
-	_, _ = rand.Read(buf[:])
-	buf[6] = (buf[6] & 0x0f) | 0x40
-	buf[8] = (buf[8] & 0x3f) | 0x80
-	return fmt.Sprintf("%08x-%04x-%04x-%04x-%012x",
-		buf[0:4], buf[4:6], buf[6:8], buf[8:10], buf[10:16]), func() {}
-}
-
 // maxConsecutiveErrors is the number of consecutive connection errors before
 // Run returns ErrConnectionLost so the caller can decide to restart.
 const maxConsecutiveErrors = 10
 
 func (w *Worker) Run(ctx context.Context) error {
-	if w.slotCleanup != nil {
-		defer w.slotCleanup()
-	}
 	w.log.Info("starting")
 
 	// Take initial snapshot for delta computation
@@ -632,13 +552,13 @@ func (w *Worker) buildHeartbeatRequest() HeartbeatRequest {
 	snap, err := Snapshot()
 	if err != nil {
 		w.log.WithError(err).Warn("metrics snapshot error")
-		return HeartbeatRequest{UUID: w.uuid}
+		return HeartbeatRequest{}
 	}
 
 	w.metricsMu.Lock()
 	defer w.metricsMu.Unlock()
 
-	req := HeartbeatRequest{UUID: w.uuid}
+	req := HeartbeatRequest{}
 	if w.lastCounters != nil {
 		// CPU percent
 		if snap.CPUInstant {

agent/models.go

@@ -1,3 +1,23 @@
-//depot/pong/background.jpg#1 - add change 3 (binary+F)
-//depot/pong/build-pong-game.act#1 - add change 3 (text)
-//depot/pong/tutorial-readme.md#1 - add change 3 (text)
+build hasn't expired yet
+looking for value: 'env_file'
+  no value (is optional) found for: 'env_file'
+looking for value: 'config_file'
+  no value (is optional) found for: 'config_file'
+looking for value: 'concurrency'
+  no value (is optional) found for: 'concurrency'
+looking for value: 'graph_file'
+  no value (is optional) found for: 'graph_file'
+looking for value: 'session_token'
+  no value (is optional) found for: 'session_token'
+looking for value: 'create_debug_session'
+  found value in flags
+  evaluated to: 'false'
+PushNodeVisit: start, execute: true
+🟢 Execute 'P4 Run (list-files)'
+PushNodeVisit: list-files, execute: true
+🟢 Execute 'Print (print-result)'
+PushNodeVisit: print-result, execute: true
+PushNodeVisit: (cached) list-files, execute: false
+[REDACTED]/background.jpg#1 - add change 3 (binary+F)
+[REDACTED]/build-pong-game.act#2 - edit change 4 (text)
+[REDACTED]/tutorial-readme.md#1 - add change 3 (text)

agent/worker.go

@@ -6,6 +6,24 @@
 These scripts contain "#! test <command>" comments.
 They are expanded, executed and then diffed against the output in
 "tests/integrations/references".
+
+Platform-specific tests:
+    Scripts suffixed with _linux, _darwin, or _windows (e.g., docker-alpine_linux.sh)
+    only run on that platform. Scripts without a suffix run on all platforms.
+
+Build tags (p4):
+    Some nodes require Go build tags to be compiled in. P4 nodes (core/p4-run@v1,
+    core/p4-sync@v1, etc.) are guarded by `//go:build p4` and require the P4 API SDK.
+    The test runner auto-detects the P4 API SDK in `p4api/` and builds with `-tags=p4`
+    when available. Run `bash setup.sh` to download the SDK if not present.
+
+    To add a new P4 e2e test:
+    1. Run `bash setup.sh` to download the P4 API SDK (if not already done)
+    2. Create a .sh script in tests_e2e/scripts/ (no platform suffix = runs everywhere)
+    3. Set P4 env vars (P4PORT, P4USER, P4PASSWD) and use `#! test actrun <graph_file>`
+    4. Run `python tests_e2e/tests_e2e.py p4_connect.sh` to generate the reference file
+    5. Commit the reference file — it must match output for the tagged build in CI
+    6. See tests_e2e/scripts/p4_connect.sh for an example
 """
 
 import os
@@ -297,21 +315,95 @@ def process_and_run_test(root_dir: str, source_script: str, ref_dir: str, cov_di
     normalize_stack_trace_lines(ref_dir, script_name)
     return output.getvalue(), result.returncode == 0
 
+def get_p4_build_config() -> dict | None:
+    """Detect P4 API SDK and return CGO flags for building with p4 tag.
+    Returns None if P4 SDK is not available."""
+    p4api_dir = Path(os.getcwd()) / "p4api"
+    if not p4api_dir.exists():
+        return None
+
+    p4_include = str(p4api_dir / "include")
+    arch = platform.machine().lower()
+    if arch in ("aarch64", "arm64"):
+        arch = "arm64"
+    else:
+        arch = "x64"
+
+    if sys.platform == "linux":
+        lib_name = "linux-aarch64" if arch == "arm64" else "linux-x86_64"
+        p4_lib = str(p4api_dir / lib_name / "lib")
+        ssl_lib = str(p4api_dir / f"ssl-linux-{arch}" / "lib")
+        if not Path(p4_lib).exists():
+            return None
+        cgo_cppflags = f"-I{p4_include}"
+        if Path(ssl_lib).exists():
+            cgo_ldflags = f"-L{p4_lib} -lp4api {ssl_lib}/libssl.a {ssl_lib}/libcrypto.a"
+        else:
+            cgo_ldflags = f"-L{p4_lib} -lp4api -lssl -lcrypto"
+    elif sys.platform == "darwin":
+        p4_lib = str(p4api_dir / "macos" / "lib")
+        ssl_lib = str(p4api_dir / f"ssl-macos-{arch}" / "lib")
+        if not Path(p4_lib).exists():
+            return None
+        cgo_cppflags = f"-I{p4_include}"
+        cgo_ldflags = f"-L{p4_lib} -lp4api {ssl_lib}/libssl.a {ssl_lib}/libcrypto.a -framework ApplicationServices -framework Foundation -framework Security -framework CoreFoundation"
+    elif sys.platform == "win32":
+        if arch == "arm64":
+            return None  # P4 not supported on Windows ARM64
+        p4_lib = str(p4api_dir / "windows-x86_64" / "lib")
+        if not Path(p4_lib).exists():
+            return None
+        cgo_cppflags = f"-I{p4_include} -DOS_NT"
+        # Try static OpenSSL from MSYS2 MinGW
+        msys2_root = os.environ.get("MSYS2_ROOT", r"D:\a\_temp\msys64")
+        msys2_ssl = Path(msys2_root) / "mingw64" / "lib"
+        ssl_lib = str(p4api_dir / "ssl-windows-x64" / "lib")
+        if Path(ssl_lib).exists() and (Path(ssl_lib) / "libssl.a").exists():
+            cgo_ldflags = f"-L{p4_lib} -lp4api {ssl_lib}/libssl.a {ssl_lib}/libcrypto.a -lcrypt32 -lws2_32 -lole32 -lshell32 -luser32 -ladvapi32"
+        elif (msys2_ssl / "libssl.a").exists():
+            cgo_ldflags = f"-L{p4_lib} -lp4api {msys2_ssl}/libssl.a {msys2_ssl}/libcrypto.a -lcrypt32 -lws2_32 -lole32 -lshell32 -luser32 -ladvapi32"
+        else:
+            cgo_ldflags = f"-L{p4_lib} -lp4api -lssl -lcrypto -lcrypt32 -lws2_32 -lole32 -lshell32 -luser32 -ladvapi32"
+    else:
+        return None
+
+    return {
+        "CGO_ENABLED": "1",
+        "CGO_CPPFLAGS": cgo_cppflags,
+        "CGO_LDFLAGS": cgo_ldflags,
+    }
+
+
 def compile_binaries(is_github_runner: bool):
     if is_github_runner:
         return
 
     # build CLI
     cli_out = 'dist/actrun' + ('.exe' if IS_WINDOWS else '')
-    
+
     env = GLOBAL_ENVS.copy()
     env["GCFLAGS"] = "-N -l"
-    
-    build_cmd = ['go', 'build', '-o', cli_out, '.']
+
+    # Detect P4 API SDK and add build tag + CGO flags if available
+    tags = []
+    p4_config = get_p4_build_config()
+    if p4_config:
+        tags.append("p4")
+        env.update(p4_config)
+        print(f"P4 API SDK detected, building with -tags=p4")
+    else:
+        print(f"P4 API SDK not found, building without p4 support")
+
+    build_cmd = ['go', 'build']
+    if tags:
+        build_cmd.append(f'-tags={",".join(tags)}')
+    build_cmd.extend(['-o', cli_out, '.'])
+
     if COVERAGE:
         # TODO: (Seb) coverage build takes ages
-        build_cmd = ['go', 'test', '.', '-buildvcs=true', '-cover', '-coverprofile', '-tags=main_test', '-c', '-o', cli_out]
-    
+        coverage_tags = ['main_test'] + tags
+        build_cmd = ['go', 'test', '.', '-buildvcs=true', '-cover', '-coverprofile', f'-tags={",".join(coverage_tags)}', '-c', '-o', cli_out]
+
     print(f"Building {cli_out}")
     subprocess.run(build_cmd, stdout=sys.stdout, stderr=subprocess.STDOUT, check=True, env=env)