AI 모델 파일을 여러 엣지 장비에 배포하기

                    Model Repository
                           │
              Model + Config + Metadata
                           │
                           ▼
                    Distribution Flow
                           │
          ┌────────────────┼────────────────┐
          ▼                ▼                ▼
      Edge Device 01   Edge Device 02   Edge Device 03
          │                │                │
          ▼                ▼                ▼
       Model Ready      Model Ready      Check Required

                  AI Model Package
                         │
             ┌───────────┴───────────┐
             │                       │
             ▼                       ▼
       Standard Model           Specialized Model
             │                       │
       ┌─────┼─────┐           ┌─────┴─────┐
       ▼     ▼     ▼           ▼           ▼
     Edge A Edge B Edge C    Edge D      Edge E

model-release/
│
├── model/
│   └── inference-model.bin
│
├── config/
│   └── inference.yaml
│
├── labels/
│   └── classes.json
│
└── metadata/
    └── version.json

                   Model Source
                 /release/model-v2
                         │
                         ▼
                    Deployment
                         │
          ┌──────────────┼──────────────┐
          ▼              ▼              ▼
       Edge-01         Edge-02        Edge-03
     /opt/model       /opt/model     /opt/model

                    Deployment Flow
                           │
             ┌─────────────┼─────────────┐
             ▼             ▼             ▼
        Factory Group   Store Group   Test Group
             │             │             │
             ▼             ▼             ▼
        Model-A v2      Model-B v4   Model-A v3

                     Model Package
                           │
                           ▼
                     Deployment Flow
                           │
           ┌───────────────┼───────────────┐
           │               │               │
           ▼               ▼               ▼
        Edge-01          Edge-02          Edge-03
           │               │               │
           ▼               ▼               ▼
       Transferring    Completed        Transferring

Model Update
     │
     ▼
┌───────────────┐
│ Release Check │
└───────┬───────┘
        │
   ┌────┼─────────┐
   ▼    ▼         ▼
Manual  Schedule  Previous
Run              Job Complete
   │    │         │
   └────┴────┬────┘
             ▼
        Deployment

Model Package Ready
        │
        ▼
Target Selection
        │
        ▼
Parallel Distribution
        │
        ├──── Edge-01 ────┐
        ├──── Edge-02 ────┤
        └──── Edge-03 ────┘
                           │
                           ▼
                    Result Review
                           │
             ┌─────────────┴─────────────┐
             ▼                           ▼
        All Completed              Check Required
             │                           │
             ▼                           ▼
       Next Operation                Retry Target

Deployment Run
       │
       ▼
Device Status
       │
 ┌─────┼─────────────┐
 ▼     ▼             ▼
Edge-01 Edge-02    Edge-03
  ✓       ✓           !
                      │
                      ▼
                 View Details
                      │
           ┌──────────┼──────────┐
           ▼          ▼          ▼
       Connection    Path    Permission
           │          │          │
           └──────────┼──────────┘
                      ▼
                    Adjust
                      │
                      ▼
                     Retry
                      │
                      ▼
                  New Result

import time


def deploy_model(source, source_path, targets, target_path, action="overwrite"):
    monitors, start_failed = {}, []
    for device in targets:
        try:
            transfer = api("POST", "/api/transfers/manual", {
                "sourceDevice": source,
                "targetDevice": device,
                "targetPath": target_path,
                "sourcePaths": [source_path],
                "sendAllFolder": True,
                "checkIntegrity": True,   # verify model file integrity after transfer
                "transferOptions": {"target-action": action},
            })
            monitors[device] = transfer["monitorId"]
        except Exception:
            start_failed.append(device)   # device whose transfer creation itself failed (e.g. offline)

    results = {}
    for device, monitor_id in monitors.items():
        detail = wait_transfer(monitor_id)
        results[device] = detail.get("status") == STATUS_COMPLETE
    # report devices that never started separately from in-transfer failures
    return {"results": results, "start_failed": start_failed}


def wait_transfer(monitor_id, timeout=14400, interval=5):
    deadline = time.time() + timeout
    while time.time() < deadline:
        detail = api("GET", f"/api/transfers/{monitor_id}") or {}
        if detail.get("status") in TERMINAL:
            return detail
        time.sleep(interval)
    raise TimeoutError(monitor_id)


out = deploy_model("model-src", "/registry/model/v3",
                   ["edge-01", "edge-02", "edge-03"], "/opt/models")
results, start_failed = out["results"], out["start_failed"]
ok = [d for d, c in results.items() if c]
print(f"ok {len(ok)} / started {len(results)} / start-failed {len(start_failed)}")
for device, complete in results.items():
    if not complete:
        print("  transfer failed:", device)
for device in start_failed:
    print("  start failed (check connection):", device)

// returns: results (success after the transfer started) + startFailed (devices whose transfer creation failed)
static Map<String, Object> deployModel(InnorixClient client, String source, String sourcePath,
        List<String> targets, String targetPath, String action) throws InterruptedException {
    Map<String, String> monitors = new LinkedHashMap<>();
    List<String> startFailed = new ArrayList<>();
    for (String device : targets) {
        try {
            Map<String, Object> transfer = client.apiObj("POST", "/api/transfers/manual", Json.newObj(
                    "sourceDevice", source,
                    "targetDevice", device,
                    "targetPath", targetPath,
                    "sourcePaths", List.of(sourcePath),
                    "sendAllFolder", true,
                    "checkIntegrity", true,   // verify model file integrity after transfer
                    "transferOptions", Json.newObj("target-action", action)), null);
            monitors.put(device, Json.str(transfer, "monitorId"));
        } catch (Exception ex) {
            startFailed.add(device);   // transfer creation failed (e.g. offline)
        }
    }

    Map<String, Boolean> results = new LinkedHashMap<>();
    for (Map.Entry<String, String> e : monitors.entrySet()) {
        Map<String, Object> detail = waitTransfer(client, e.getValue(), 14400, 5);
        Integer status = Json.intOrNull(detail, "status");
        results.put(e.getKey(), status != null && status == InnorixClient.STATUS_COMPLETE);
    }
    return Json.newObj("results", results, "startFailed", startFailed);
}

static Map<String, Object> waitTransfer(InnorixClient client, String monitorId,
        long timeoutSec, long intervalSec) throws InterruptedException {
    long deadline = System.currentTimeMillis() + timeoutSec * 1000;
    while (System.currentTimeMillis() < deadline) {
        Map<String, Object> detail = client.apiObj("GET", "/api/transfers/" + monitorId, null, null);
        Integer status = Json.intOrNull(detail, "status");
        if (status != null && InnorixClient.TERMINAL.contains(status))
            return detail;
        Thread.sleep(intervalSec * 1000);
    }
    throw new RuntimeException("timeout: " + monitorId);
}

async function deployModel(source, sourcePath, targets, targetPath, action = "overwrite") {
  const monitors = {};
  const startFailed = [];
  for (const device of targets) {
    try {
      const transfer = await api("POST", "/api/transfers/manual", {
        sourceDevice: source,
        targetDevice: device,
        targetPath,
        sourcePaths: [sourcePath],
        sendAllFolder: true,
        checkIntegrity: true,   // verify model file integrity after transfer
        transferOptions: { "target-action": action },
      });
      monitors[device] = transfer.monitorId;
    } catch {
      startFailed.push(device);   // transfer creation failed (e.g. offline)
    }
  }

  const results = {};
  for (const [device, monitorId] of Object.entries(monitors)) {
    const detail = await waitTransfer(monitorId);
    results[device] = detail.status === STATUS_COMPLETE;
  }
  return { results, startFailed };
}

async function waitTransfer(monitorId, { timeout = 14400, interval = 5 } = {}) {
  const deadline = Date.now() + timeout * 1000;
  while (Date.now() < deadline) {
    const detail = (await api("GET", `/api/transfers/${monitorId}`)) || {};
    if (TERMINAL.has(detail.status)) return detail;
    await new Promise((r) => setTimeout(r, interval * 1000));
  }
  throw new Error(`timeout: ${monitorId}`);
}

const { results, startFailed } = await deployModel("model-src", "/registry/model/v3",
                                  ["edge-01", "edge-02", "edge-03"], "/opt/models");
const ok = Object.values(results).filter(Boolean).length;
console.log(`ok ${ok} / started ${Object.keys(results).length} / start-failed ${startFailed.length}`);
for (const [device, complete] of Object.entries(results))
  if (!complete) console.log("  transfer failed:", device);
for (const device of startFailed) console.log("  start failed (check connection):", device);

// returns: results (success after the transfer started) + startFailed (devices whose transfer creation failed)
static async Task<(Dictionary<string, bool> results, List<string> startFailed)> DeployModelAsync(
    InnorixClient client, string source, string sourcePath, IEnumerable<string> targets,
    string targetPath, string action = "overwrite")
{
    var monitors = new Dictionary<string, string>();
    var startFailed = new List<string>();
    foreach (string device in targets)
    {
        try
        {
            var transfer = await client.ApiObjAsync("POST", "/api/transfers/manual", new JsonObject
            {
                ["sourceDevice"] = source,
                ["targetDevice"] = device,
                ["targetPath"] = targetPath,
                ["sourcePaths"] = J.ArrOfStrings(new[] { sourcePath }),
                ["sendAllFolder"] = true,
                ["checkIntegrity"] = true,   // verify model file integrity after transfer
                ["transferOptions"] = new JsonObject { ["target-action"] = action },
            });
            monitors[device] = J.Str(transfer, "monitorId");
        }
        catch
        {
            startFailed.Add(device);   // transfer creation failed (e.g. offline)
        }
    }

    var results = new Dictionary<string, bool>();
    foreach (var kv in monitors)
    {
        JsonObject detail = await WaitTransferAsync(client, kv.Value);
        int? status = J.IntOrNull(detail, "status");
        results[kv.Key] = status != null && status == InnorixClient.StatusComplete;
    }
    return (results, startFailed);
}

static async Task<JsonObject> WaitTransferAsync(InnorixClient client, string monitorId,
    int timeoutSec = 14400, int intervalSec = 5)
{
    DateTime deadline = DateTime.UtcNow.AddSeconds(timeoutSec);
    while (DateTime.UtcNow < deadline)
    {
        JsonObject detail = await client.ApiObjAsync("GET", 
quot;/api/transfers/{monitorId}", null, null);
        int? status = J.IntOrNull(detail, "status");
        if (status != null && InnorixClient.Terminal.Contains(status.Value))
            return detail;
        await Task.Delay(intervalSec * 1000);
    }
    throw new TimeoutException(monitorId);
}

모델 레지스트리 (model-src)
   ↓  장비별 전송 생성(checkIntegrity) → monitorId 수집

edge-01 · edge-02 · edge-03 배포
   ↓  전체 대기 → 장비별 성공 여부 집계

실패 장비만 재배포