feat: P2.5-5/6 add --peers/--ca-cert parsing to worker+scheduler with validation

Worker (P2.5-5):
- Added parse_peers() static helper to src/worker/src/main.c
- Switched getopt to getopt_long to support --peers and --ca-cert long options
- When --peers is given: parses into xce_cluster_config_t, calls
  xce_cluster_config_validate(), logs INFO with candidate count/identity/ca_cert
- If validation fails: prints clear error and exits(1)
- WARN logged when candidates_count > 3
- Backward compatible: no --peers falls back to existing single-controller path

Scheduler (P2.5-6):
- Added parse_peers() static helper to src/scheduler/src/main.c
- Extended argp struct with --peers (-P) and --ca-cert (-C) options
- Same validation/logging pattern as worker
- Backward compatible: no --peers falls back to existing single-controller path

Tests (new):
- src/lib/testsuite/test_cluster_parse.c: 8 unit tests for parse_peers logic
  (single entry, multiple entries, no-name format, empty/null/missing-port errors,
  name-stripped correctly, MAX_HA_CANDIDATES cap respected)
- Registered in test.c and meson.build
- All 8 tests GREEN; 3 pre-existing failures in unrelated GC/CSE tests unchanged

src/scheduler/src/main.c

@@ -2,10 +2,12 @@
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <unistd.h>
 
 #include "client.h"
 #include "controller.capnp.h"
+#include "xce/cluster.h"
 #include "xce/types.h"
 
 #include "scheduler.h"
@@ -13,6 +15,42 @@
 #include "resreq.h"
 #include "utils.h"
 
+/* parse_peers — parse "--peers ctrl-1=10.0.1.1:7000,ctrl-2=10.0.1.2:7001"
+ * into cfg->candidates[].  Returns 0 on success, -1 on parse error.
+ * If peers_str is NULL or empty returns -1 (caller falls back to single-host
+ * path). */
+static int parse_peers(const char* peers_str, xce_cluster_config_t* cfg)
+{
+    cfg->candidates_count = 0;
+    if (!peers_str || peers_str[0] == '\0')
+        return -1;
+
+    char  buf[2048];
+    strncpy(buf, peers_str, sizeof(buf) - 1);
+    buf[sizeof(buf) - 1] = '\0';
+
+    char* saveptr;
+    char* tok = strtok_r(buf, ",", &saveptr);
+
+    while (tok && cfg->candidates_count < MAX_HA_CANDIDATES) {
+        /* Format: name=host:port  OR  host:port */
+        char* eq    = strchr(tok, '=');
+        char* addr  = eq ? eq + 1 : tok;
+        char* colon = strrchr(addr, ':');
+        if (!colon)
+            return -1;
+        *colon = '\0';
+        strncpy(cfg->candidates[cfg->candidates_count].hostname, addr,
+                XCE_MAXHOSTNAME_LEN - 1);
+        cfg->candidates[cfg->candidates_count].hostname[XCE_MAXHOSTNAME_LEN - 1]
+            = '\0';
+        cfg->candidates[cfg->candidates_count].port = atoi(colon + 1);
+        cfg->candidates_count++;
+        tok = strtok_r(NULL, ",", &saveptr);
+    }
+    return cfg->candidates_count > 0 ? 0 : -1;
+}
+
 extern int scheduler_req_handler(xce_request_t*, void*);
 
 static char doc[]      = "xce_scheduler";
@@ -24,11 +62,15 @@ const char* argp_program_bug_address = BUG_EMAIL;
 struct arguments {
     char* logfile;
     int   verbose;
+    char* peers;   /* --peers value (optional) */
+    char* ca_cert; /* --ca-cert value (optional) */
 };
 
 static struct argp_option options[] = {
-    { "logfile", 'l', "FILE", 0, "The full path of log file" },
-    { "verbose", 'v', 0, 0, "Produce verbose log" },
+    { "logfile", 'l', "FILE",   0, "The full path of log file"                },
+    { "verbose", 'v', 0,        0, "Produce verbose log"                       },
+    { "peers",   'P', "LIST",   0, "HA candidate list: [name=]host:port,..."  },
+    { "ca-cert", 'C', "FILE",   0, "CA certificate path for TLS verification" },
     { 0 }
 };
 
@@ -43,6 +85,12 @@ static error_t parse_opt(int key, char* arg, struct argp_state* state)
     case 'v':
         arguments->verbose++;
         break;
+    case 'P':
+        arguments->peers = arg;
+        break;
+    case 'C':
+        arguments->ca_cert = arg;
+        break;
     default:
         return ARGP_ERR_UNKNOWN;
     }
@@ -109,6 +157,42 @@ int main(int argc, char* argv[])
 
     mylog_init(logfile, loglevel, logsize, logcount);
 
+    /* P2.5-6: populate and validate xce_cluster_config_t when --peers given */
+    if (arguments.peers) {
+        xce_cluster_config_t cluster_cfg = {0};
+
+        if (parse_peers(arguments.peers, &cluster_cfg) != 0) {
+            fprintf(stderr,
+                    "xce_scheduler: --peers parse error: expected "
+                    "\"[name=]host:port,...\" got \"%s\"\n",
+                    arguments.peers);
+            return 1;
+        }
+        if (arguments.ca_cert) {
+            strncpy(cluster_cfg.ca_cert_path, arguments.ca_cert,
+                    sizeof(cluster_cfg.ca_cert_path) - 1);
+        }
+        strncpy(cluster_cfg.identity, "xce_scheduler",
+                sizeof(cluster_cfg.identity) - 1);
+        if (xce_cluster_config_validate(&cluster_cfg) != 0) {
+            fprintf(stderr,
+                    "xce_scheduler: invalid cluster config (missing "
+                    "--ca-cert?).\n");
+            return 1;
+        }
+        if (cluster_cfg.candidates_count > 3) {
+            WARN("xce_scheduler: --peers has %d candidates; "
+                 "only <=3 validated for HA",
+                 cluster_cfg.candidates_count);
+        }
+        INFO("HA cluster config: %d candidate(s), identity=%s, ca_cert=%s",
+             cluster_cfg.candidates_count, cluster_cfg.identity,
+             cluster_cfg.ca_cert_path);
+        /* P3 will call xce_connect_cluster(&cluster_cfg) here */
+    } else {
+        INFO("No --peers flag; using single-controller path");
+    }
+
     init_config(&config);
 
     sched_init(&sched, &config, scheduler_req_handler);