containerization-framework 0.7.0

Rust bindings for Apple's Containerization framework: Linux containers in lightweight VMs, in-process and without a daemon.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

//===----------------------------------------------------------------------===//
// `RegistryClient`, from ContainerizationOCI.
//===----------------------------------------------------------------------===//

import ContainerizationOCI
import Foundation

func newRegistryClient(reference: RustStr, insecure: Bool, auth: CzAuthentication) -> CzOutcome {
  let reference = reference.toString()
  let auth = auth.authentication

  return CzOutcome { CzRegistryClient(try RegistryClient(reference: reference, insecure: insecure, auth: auth)) }
}

func registryClientWithHost(
  host: RustStr,
  scheme: RustString?,
  port: UInt16?,
  authentication: CzAuthentication,
  clientID: RustString?,
  hasRetryOptions: Bool,
  maxRetries: Int,
  retryInterval: UInt64,
  bufferSize: UInt
) -> CzOutcome {
  let host = host.toString()
  let scheme = scheme?.toString()
  let authentication = authentication.authentication
  let clientID = clientID?.toString()
  let retryOptions = hasRetryOptions ? RetryOptions(maxRetries: maxRetries, retryInterval: retryInterval) : nil

  return CzOutcome {
    CzRegistryClient(
      RegistryClient(
        host: host,
        scheme: scheme,
        port: port.map { Int($0) },
        authentication: authentication,
        clientID: clientID,
        retryOptions: retryOptions,
        bufferSize: try int(bufferSize, "buffer size")
      ))
  }
}

final class CzRegistryClient: Sendable {
  let client: RegistryClient

  init(_ client: RegistryClient) {
    self.client = client
  }

  func ping() -> CzOutcome {
    let client = client

    return CzOutcome { try blocking { try await client.ping() } }
  }

  func resolve(name: RustStr, tag: RustStr) -> CzOutcome {
    let name = name.toString()
    let tag = tag.toString()
    let client = client

    return CzOutcome { try blocking { try await client.resolve(name: name, tag: tag) } }
  }

  func fetchData(name: RustStr, descriptor: RustDescriptor) -> CzOutcome {
    let name = name.toString()
    let descriptor = Descriptor(descriptor)
    let client = client

    return CzOutcome { try blocking { try await client.fetchData(name: name, descriptor: descriptor) } }
  }

  func fetchBlob(name: RustStr, descriptor: RustDescriptor, into: RustStr, progress: RustProgressHandler) -> CzOutcome {
    let name = name.toString()
    let descriptor = Descriptor(descriptor)
    let file = URL(filePath: into.toString())
    let progress = progressHandler(progress)
    let client = client

    return CzOutcome {
      let (size, digest) = try blocking {
        try await client.fetchBlob(name: name, descriptor: descriptor, into: file, progress: progress)
      }
      return Written(size: size, digest: digest.digestString)
    }
  }

  func catalog(prefix: RustString?) -> CzOutcome {
    let prefix = prefix?.toString()
    let client = client

    return CzOutcome { try blocking { try await client.catalog(prefix: prefix) } }
  }

  func referrers(name: RustStr, digest: RustStr, artifactType: RustString?) -> CzOutcome {
    let name = name.toString()
    let digest = digest.toString()
    let artifactType = artifactType?.toString()
    let client = client

    return CzOutcome {
      try blocking { try await client.referrers(name: name, digest: digest, artifactType: artifactType) }
    }
  }
}

extension CzOutcome {
  func registryClient() -> CzRegistryClient { taken() }
}