kobako 0.30.0 → 0.31.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (266) hide show
  1. checksums.yaml +4 -4
  2. data/.release-please-manifest.json +1 -1
  3. data/CHANGELOG.md +335 -0
  4. data/Cargo.lock +469 -11
  5. data/README.md +43 -3
  6. data/ROADMAP.md +1 -1
  7. data/crates/kobako-runtime/CHANGELOG.md +219 -0
  8. data/crates/kobako-runtime/Cargo.toml +51 -3
  9. data/crates/kobako-runtime/README.md +7 -4
  10. data/crates/kobako-runtime/src/cred.rs +124 -0
  11. data/crates/kobako-runtime/src/dispatch.rs +4 -5
  12. data/crates/kobako-runtime/src/endpoint/buffer.rs +153 -44
  13. data/crates/kobako-runtime/src/endpoint/dispatch.rs +80 -41
  14. data/crates/kobako-runtime/src/endpoint/invoke.rs +23 -36
  15. data/crates/kobako-runtime/src/endpoint.rs +137 -36
  16. data/crates/kobako-runtime/src/errno.rs +391 -0
  17. data/crates/kobako-runtime/src/error.rs +31 -10
  18. data/crates/kobako-runtime/src/filesystem/anon_inodes.rs +52 -0
  19. data/crates/kobako-runtime/src/filesystem/bind/lookup.rs +52 -14
  20. data/crates/kobako-runtime/src/filesystem/bind/walk.rs +19 -20
  21. data/crates/kobako-runtime/src/filesystem/bind.rs +437 -245
  22. data/crates/kobako-runtime/src/filesystem/overlay/file.rs +6 -6
  23. data/crates/kobako-runtime/src/filesystem/overlay/path.rs +43 -65
  24. data/crates/kobako-runtime/src/filesystem/overlay/stack/copy_up.rs +9 -16
  25. data/crates/kobako-runtime/src/filesystem/overlay/stack/dir.rs +47 -72
  26. data/crates/kobako-runtime/src/filesystem/overlay/stack/namei.rs +12 -12
  27. data/crates/kobako-runtime/src/filesystem/overlay/stack/readdir.rs +4 -7
  28. data/crates/kobako-runtime/src/filesystem/overlay/stack.rs +121 -37
  29. data/crates/kobako-runtime/src/filesystem/overlay.rs +302 -343
  30. data/crates/kobako-runtime/src/filesystem/pipe.rs +12 -9
  31. data/crates/kobako-runtime/src/filesystem/rdir.rs +15 -32
  32. data/crates/kobako-runtime/src/filesystem/tmpfs/seed.rs +32 -0
  33. data/crates/kobako-runtime/src/filesystem/tmpfs/tmpfile.rs +3 -3
  34. data/crates/kobako-runtime/src/filesystem/tmpfs/whiteout.rs +57 -35
  35. data/crates/kobako-runtime/src/filesystem/tmpfs/xattr.rs +2 -2
  36. data/crates/kobako-runtime/src/filesystem/tmpfs.rs +172 -160
  37. data/crates/kobako-runtime/src/filesystem/wrap.rs +36 -52
  38. data/crates/kobako-runtime/src/filesystem.rs +6 -3
  39. data/crates/kobako-runtime/src/fork.rs +96 -0
  40. data/crates/kobako-runtime/src/grant.rs +3 -0
  41. data/crates/kobako-runtime/src/hashtable.rs +4 -2
  42. data/crates/kobako-runtime/src/lib.rs +18 -7
  43. data/crates/kobako-runtime/src/limits.rs +195 -0
  44. data/crates/kobako-runtime/src/locking.rs +10 -0
  45. data/crates/kobako-runtime/src/memcg.rs +383 -0
  46. data/crates/kobako-runtime/src/mount.rs +67 -9
  47. data/crates/kobako-runtime/src/net/backends.rs +43 -0
  48. data/crates/kobako-runtime/src/net/connections.rs +179 -0
  49. data/crates/kobako-runtime/src/net/credential.rs +125 -0
  50. data/crates/kobako-runtime/src/net/egress.rs +160 -0
  51. data/crates/kobako-runtime/src/net/family.rs +181 -0
  52. data/crates/kobako-runtime/src/net/http.rs +2733 -0
  53. data/crates/kobako-runtime/src/net/lookup.rs +285 -0
  54. data/crates/kobako-runtime/src/net/mock.rs +251 -0
  55. data/crates/kobako-runtime/src/net/namespace.rs +1366 -0
  56. data/crates/kobako-runtime/src/net/reactor.rs +531 -0
  57. data/crates/kobako-runtime/src/net/resolv/darwin.rs +275 -0
  58. data/crates/kobako-runtime/src/net/resolv/stub/tests.rs +469 -0
  59. data/crates/kobako-runtime/src/net/resolv/stub.rs +536 -0
  60. data/crates/kobako-runtime/src/net/resolv/windows.rs +248 -0
  61. data/crates/kobako-runtime/src/net/resolv.rs +227 -0
  62. data/crates/kobako-runtime/src/net/socket.rs +870 -0
  63. data/crates/kobako-runtime/src/net/tcp.rs +1588 -0
  64. data/crates/kobako-runtime/src/net/tls.rs +58 -0
  65. data/crates/kobako-runtime/src/net/transport.rs +279 -0
  66. data/crates/kobako-runtime/src/net/udp.rs +1003 -0
  67. data/crates/kobako-runtime/src/net.rs +42 -0
  68. data/crates/kobako-runtime/src/network/builder.rs +177 -0
  69. data/crates/kobako-runtime/src/network/ruleset.rs +777 -0
  70. data/crates/kobako-runtime/src/network.rs +551 -0
  71. data/crates/kobako-runtime/src/policy.rs +16 -0
  72. data/crates/kobako-runtime/src/profile.rs +29 -144
  73. data/crates/kobako-runtime/src/runtime.rs +3 -5
  74. data/crates/kobako-runtime/src/sched.rs +130 -29
  75. data/crates/kobako-runtime/src/security/entry_policy.rs +22 -0
  76. data/crates/kobako-runtime/src/{vfs/cred.rs → security/hooks.rs} +52 -144
  77. data/crates/kobako-runtime/src/security/mount_policy.rs +158 -0
  78. data/crates/kobako-runtime/src/security.rs +101 -196
  79. data/crates/kobako-runtime/src/snapshot.rs +121 -2
  80. data/crates/kobako-runtime/src/vfs/attr.rs +5 -5
  81. data/crates/kobako-runtime/src/vfs/dentry.rs +143 -89
  82. data/crates/kobako-runtime/src/vfs/file.rs +199 -203
  83. data/crates/kobako-runtime/src/vfs/inode.rs +41 -45
  84. data/crates/kobako-runtime/src/vfs/kern_path.rs +38 -42
  85. data/crates/kobako-runtime/src/vfs/mount.rs +10 -9
  86. data/crates/kobako-runtime/src/vfs/namei.rs +829 -700
  87. data/crates/kobako-runtime/src/vfs/namespace.rs +162 -0
  88. data/crates/kobako-runtime/src/vfs/open_files.rs +69 -0
  89. data/crates/kobako-runtime/src/vfs/openat2.rs +3 -3
  90. data/crates/kobako-runtime/src/vfs/path.rs +6 -6
  91. data/crates/kobako-runtime/src/vfs/readdir.rs +6 -6
  92. data/crates/kobako-runtime/src/vfs/stat.rs +159 -23
  93. data/crates/kobako-runtime/src/vfs/super_block.rs +18 -14
  94. data/crates/kobako-runtime/src/vfs/utimes.rs +37 -27
  95. data/crates/kobako-runtime/src/vfs.rs +9 -6
  96. data/crates/kobako-runtime/src/wait.rs +356 -0
  97. data/crates/kobako-transport/CHANGELOG.md +31 -0
  98. data/crates/kobako-transport/Cargo.toml +1 -1
  99. data/crates/kobako-transport/README.md +3 -4
  100. data/crates/kobako-transport/src/abi.rs +78 -72
  101. data/crates/kobako-transport/src/envelope/bytes.rs +17 -6
  102. data/crates/kobako-transport/src/envelope/call.rs +32 -4
  103. data/crates/kobako-transport/src/envelope/error_record.rs +21 -0
  104. data/crates/kobako-transport/src/envelope/name.rs +99 -0
  105. data/crates/kobako-transport/src/envelope/outcome.rs +9 -9
  106. data/crates/kobako-transport/src/envelope/preamble.rs +24 -21
  107. data/crates/kobako-transport/src/envelope/reply.rs +27 -27
  108. data/crates/kobako-transport/src/envelope/unsupported.rs +10 -10
  109. data/crates/kobako-transport/src/envelope.rs +13 -8
  110. data/crates/kobako-wasmtime/CHANGELOG.md +161 -0
  111. data/crates/kobako-wasmtime/Cargo.toml +26 -7
  112. data/crates/kobako-wasmtime/README.md +3 -2
  113. data/crates/kobako-wasmtime/build/preview2.rs +1339 -0
  114. data/crates/kobako-wasmtime/build.rs +16 -0
  115. data/crates/kobako-wasmtime/src/abi.rs +17 -37
  116. data/crates/kobako-wasmtime/src/ambient.rs +33 -18
  117. data/crates/kobako-wasmtime/src/cache.rs +23 -15
  118. data/crates/kobako-wasmtime/src/config.rs +52 -68
  119. data/crates/kobako-wasmtime/src/driver.rs +48 -63
  120. data/crates/kobako-wasmtime/src/exports.rs +143 -17
  121. data/crates/kobako-wasmtime/src/guest.rs +12 -6
  122. data/crates/kobako-wasmtime/src/guest_binary.rs +14 -0
  123. data/crates/kobako-wasmtime/src/imports.rs +42 -18
  124. data/crates/kobako-wasmtime/src/instance_pre.rs +4 -4
  125. data/crates/kobako-wasmtime/src/invocation.rs +74 -12
  126. data/crates/kobako-wasmtime/src/lib.rs +5 -3
  127. data/crates/kobako-wasmtime/src/limiter.rs +70 -5
  128. data/crates/kobako-wasmtime/src/preview1/descriptors.rs +309 -0
  129. data/crates/kobako-wasmtime/src/preview1/differential/mount.rs +5 -15
  130. data/crates/kobako-wasmtime/src/preview1/differential.rs +27 -31
  131. data/crates/kobako-wasmtime/src/preview1/errno.rs +55 -66
  132. data/crates/kobako-wasmtime/src/preview1/fd.rs +327 -296
  133. data/crates/kobako-wasmtime/src/preview1/memory.rs +21 -12
  134. data/crates/kobako-wasmtime/src/preview1/mount_view/wrap.rs +34 -53
  135. data/crates/kobako-wasmtime/src/preview1/mount_view.rs +231 -217
  136. data/crates/kobako-wasmtime/src/preview1/path.rs +56 -121
  137. data/crates/kobako-wasmtime/src/preview1/poll.rs +244 -120
  138. data/crates/kobako-wasmtime/src/preview1/sock.rs +10 -8
  139. data/crates/kobako-wasmtime/src/preview1/testsuite.rs +5 -15
  140. data/crates/kobako-wasmtime/src/preview1.rs +46 -42
  141. data/crates/kobako-wasmtime/src/preview2/abi.rs +227 -0
  142. data/crates/kobako-wasmtime/src/preview2/error.rs +118 -0
  143. data/crates/kobako-wasmtime/src/preview2/filesystem.rs +122 -0
  144. data/crates/kobako-wasmtime/src/preview2/host.rs +3959 -0
  145. data/crates/kobako-wasmtime/src/preview2/http.rs +1503 -0
  146. data/crates/kobako-wasmtime/src/preview2/io.rs +315 -0
  147. data/crates/kobako-wasmtime/src/preview2/sockets.rs +379 -0
  148. data/crates/kobako-wasmtime/src/preview2/table.rs +305 -0
  149. data/crates/kobako-wasmtime/src/preview2.rs +57 -0
  150. data/crates/kobako-wasmtime/src/trap.rs +24 -9
  151. data/crates/kobako-wasmtime/src/wasi.rs +210 -81
  152. data/crates/kobako-wasmtime/wit/deps/cli.wit +233 -0
  153. data/crates/kobako-wasmtime/wit/deps/clocks.wit +162 -0
  154. data/crates/kobako-wasmtime/wit/deps/filesystem.wit +589 -0
  155. data/crates/kobako-wasmtime/wit/deps/http.wit +733 -0
  156. data/crates/kobako-wasmtime/wit/deps/io.wit +299 -0
  157. data/crates/kobako-wasmtime/wit/deps/random.wit +92 -0
  158. data/crates/kobako-wasmtime/wit/deps/sockets.wit +949 -0
  159. data/data/kobako.wasm +0 -0
  160. data/ext/kobako/Cargo.toml +1 -1
  161. data/ext/kobako/src/{runtime/errors.rs → errors.rs} +34 -26
  162. data/ext/kobako/src/{runtime/escape.rs → escape.rs} +42 -11
  163. data/ext/kobako/src/{runtime/filesystem → filesystem}/grants.rs +30 -26
  164. data/ext/kobako/src/{runtime/filesystem → filesystem}/ruby.rs +149 -168
  165. data/ext/kobako/src/{runtime/filesystem.rs → filesystem.rs} +24 -15
  166. data/ext/kobako/src/gvl.rs +306 -0
  167. data/ext/kobako/src/lib.rs +64 -3
  168. data/ext/kobako/src/network/mock.rs +187 -0
  169. data/ext/kobako/src/network.rs +591 -0
  170. data/ext/kobako/src/runtime/bridge.rs +30 -29
  171. data/ext/kobako/src/runtime/snapshot.rs +4 -4
  172. data/ext/kobako/src/runtime.rs +221 -143
  173. data/ext/kobako/src/wire.rs +42 -0
  174. data/lib/kobako/catalog/extensions.rb +14 -2
  175. data/lib/kobako/catalog/flags.rb +3 -5
  176. data/lib/kobako/catalog/grants.rb +5 -4
  177. data/lib/kobako/catalog/handles.rb +5 -27
  178. data/lib/kobako/catalog/mount.rb +11 -3
  179. data/lib/kobako/catalog/network.rb +35 -0
  180. data/lib/kobako/catalog/replacements.rb +28 -0
  181. data/lib/kobako/catalog/services.rb +5 -19
  182. data/lib/kobako/catalog/snippets.rb +3 -18
  183. data/lib/kobako/catalog.rb +3 -0
  184. data/lib/kobako/codec/{utils.rb → boundary.rb} +4 -2
  185. data/lib/kobako/codec/decoder.rb +4 -4
  186. data/lib/kobako/codec/ext_types.rb +3 -3
  187. data/lib/kobako/codec/handle_walk.rb +3 -43
  188. data/lib/kobako/codec/value_budget.rb +132 -40
  189. data/lib/kobako/codec.rb +1 -1
  190. data/lib/kobako/context.rb +24 -11
  191. data/lib/kobako/errors.rb +15 -12
  192. data/lib/kobako/extension.rb +3 -2
  193. data/lib/kobako/filesystem.rb +9 -2
  194. data/lib/kobako/handle.rb +2 -2
  195. data/lib/kobako/names.rb +28 -0
  196. data/lib/kobako/network.rb +210 -0
  197. data/lib/kobako/outcome.rb +7 -7
  198. data/lib/kobako/pool.rb +45 -23
  199. data/lib/kobako/runtime.rb +3 -2
  200. data/lib/kobako/sandbox.rb +92 -35
  201. data/lib/kobako/sandbox_options.rb +41 -106
  202. data/lib/kobako/transport/argument_wrap.rb +64 -0
  203. data/lib/kobako/transport/block_failure.rb +1 -1
  204. data/lib/kobako/transport/dispatcher.rb +6 -6
  205. data/lib/kobako/transport/exposure.rb +26 -15
  206. data/lib/kobako/transport/reflection.rb +21 -4
  207. data/lib/kobako/transport/run.rb +8 -23
  208. data/lib/kobako/transport/yielder.rb +2 -9
  209. data/lib/kobako/transport.rb +1 -0
  210. data/lib/kobako/version.rb +1 -1
  211. data/lib/kobako.rb +6 -2
  212. data/release-please-config.json +15 -0
  213. data/sig/core/thread.rbs +6 -0
  214. data/sig/kobako/catalog/extensions.rbs +2 -0
  215. data/sig/kobako/catalog/grants.rbs +7 -4
  216. data/sig/kobako/catalog/handles.rbs +0 -2
  217. data/sig/kobako/catalog/mount.rbs +3 -1
  218. data/sig/kobako/catalog/network.rbs +20 -0
  219. data/sig/kobako/catalog/replacements.rbs +14 -0
  220. data/sig/kobako/catalog/services.rbs +0 -4
  221. data/sig/kobako/catalog/snippets.rbs +0 -2
  222. data/sig/kobako/codec/{utils.rbs → boundary.rbs} +2 -2
  223. data/sig/kobako/codec/handle_walk.rbs +0 -6
  224. data/sig/kobako/codec/value_budget.rbs +47 -4
  225. data/sig/kobako/context.rbs +3 -1
  226. data/sig/kobako/errors.rbs +4 -4
  227. data/sig/kobako/filesystem.rbs +21 -3
  228. data/sig/kobako/network.rbs +115 -0
  229. data/sig/kobako/outcome.rbs +1 -1
  230. data/sig/kobako/pool.rbs +7 -3
  231. data/sig/kobako/runtime.rbs +32 -3
  232. data/sig/kobako/sandbox.rbs +19 -2
  233. data/sig/kobako/sandbox_options.rbs +29 -38
  234. data/sig/kobako/transport/argument_wrap.rbs +15 -0
  235. data/sig/kobako/transport/error.rbs +1 -1
  236. data/sig/kobako/transport/exposure.rbs +2 -4
  237. data/sig/kobako/transport/reflection.rbs +10 -0
  238. data/sig/kobako/transport/run.rbs +0 -2
  239. data/sig/kobako/transport/yielder.rbs +0 -3
  240. data/sig/kobako/transport.rbs +1 -1
  241. data/sig/kobako.rbs +13 -0
  242. metadata +84 -35
  243. data/crates/kobako-runtime/src/endpoint/capture.rs +0 -115
  244. data/crates/kobako-runtime/src/endpoint/memory_cap.rs +0 -238
  245. data/crates/kobako-runtime/src/filesystem/path.rs +0 -21
  246. data/crates/kobako-runtime/src/vfs/errno.rs +0 -153
  247. data/crates/kobako-runtime/tests/linux_baseline/calls.rs +0 -171
  248. data/crates/kobako-runtime/tests/linux_baseline/concurrent.rs +0 -276
  249. data/crates/kobako-runtime/tests/linux_baseline/kobako.rs +0 -323
  250. data/crates/kobako-runtime/tests/linux_baseline/linux-baseline-expected.txt +0 -16
  251. data/crates/kobako-runtime/tests/linux_baseline/linux.rs +0 -449
  252. data/crates/kobako-runtime/tests/linux_baseline/main.rs +0 -611
  253. data/crates/kobako-runtime/tests/linux_baseline/permissions.rs +0 -236
  254. data/crates/kobako-wasmtime/src/descriptors.rs +0 -200
  255. data/crates/kobako-wasmtime/tests/integration/compile_posture.rs +0 -43
  256. data/crates/kobako-wasmtime/tests/integration/guest_file.rs +0 -1085
  257. data/crates/kobako-wasmtime/tests/integration/main.rs +0 -29
  258. data/crates/kobako-wasmtime/tests/integration/preamble_flags.rs +0 -70
  259. data/crates/kobako-wasmtime/tests/integration/snippet_compile.rs +0 -95
  260. data/crates/kobako-wasmtime/tests/integration/support/mod.rs +0 -30
  261. data/crates/kobako-wasmtime/tests/integration/unanswered_call.rs +0 -86
  262. data/crates/kobako-wasmtime/tests/integration/unsupported_call.rs +0 -51
  263. data/ext/kobako/src/runtime/gvl.rs +0 -147
  264. data/lib/kobako/constant_name.rb +0 -8
  265. data/sig/kobako/constant_name.rbs +0 -3
  266. /data/ext/kobako/src/{runtime/pinned_value.rs → pinned_value.rs} +0 -0
@@ -1,6 +1,7 @@
1
1
  //! The Ruby face of the Filesystem: `Kobako::Filesystem::Tmpfs`,
2
2
  //! `Bind`, and `Overlay`, each standing for the `kobako_runtime`
3
- //! Filesystem of that kind.
3
+ //! Filesystem of that kind, and `Kobako::Filesystem.validate_mount`,
4
+ //! refusing a Mount by the rules an invocation builds it with.
4
5
  //!
5
6
  //! A kind kobako ships runs in Rust; Ruby only picks it and the access.
6
7
  //! Ruby is asked again while the guest runs, through a mount's block and
@@ -19,9 +20,11 @@ use magnus::{
19
20
 
20
21
  use ruby::RubyFilesystem;
21
22
 
22
- use kobako_runtime::filesystem::{Bind, Filesystem, FilesystemError, Overlay, Tmpfs};
23
+ use kobako_runtime::filesystem::{Bind, Filesystem, Overlay, Tmpfs};
24
+ use kobako_runtime::Errno;
23
25
 
24
- pub(super) use grants::{to_grants, validate_mount};
26
+ pub(super) use grants::to_grants;
27
+ use grants::validate_mount;
25
28
 
26
29
  /// Each kind kobako ships is one Filesystem instance, made once with its
27
30
  /// Ruby object, so every Mount of that object shares it as a bind mount
@@ -54,10 +57,11 @@ impl DataTypeFunctions for OverlayFs {
54
57
 
55
58
  pub(super) fn register(ruby: &Ruby, kobako: RModule) -> Result<(), MagnusError> {
56
59
  let module = kobako.define_module("Filesystem")?;
60
+ module.define_singleton_method("validate_mount", function!(validate_mount, 3))?;
57
61
  let tmpfs = module.define_class("Tmpfs", ruby.class_object())?;
58
62
  tmpfs.define_singleton_method("new", function!(tmpfs_new, -1))?;
59
63
  let bind = module.define_class("Bind", ruby.class_object())?;
60
- bind.define_singleton_method("new", function!(bind_new, 1))?;
64
+ bind.define_singleton_method("new", function!(bind_new, -1))?;
61
65
  let overlay = module.define_class("Overlay", ruby.class_object())?;
62
66
  overlay.define_singleton_method("new", function!(overlay_new, -1))?;
63
67
  TmpfsFs::class(ruby);
@@ -92,7 +96,7 @@ fn tmpfs_new(args: &[Value]) -> Result<TmpfsFs, MagnusError> {
92
96
  }
93
97
  None => files.push((
94
98
  String::try_convert(key)?,
95
- super::rstring_to_vec(RString::try_convert(value)?),
99
+ crate::to_bytes(RString::try_convert(value)?),
96
100
  )),
97
101
  }
98
102
  Ok(magnus::r_hash::ForEach::Continue)
@@ -102,16 +106,16 @@ fn tmpfs_new(args: &[Value]) -> Result<TmpfsFs, MagnusError> {
102
106
  let tmpfs = Tmpfs::try_from_iter(files)
103
107
  .map_err(|error| MagnusError::new(ruby.exception_arg_error(), error.to_string()))?
104
108
  .with_size(size);
105
- let filesystem = Filesystem::new(Arc::new(match nr_inodes {
109
+ let filesystem = Filesystem::new(match nr_inodes {
106
110
  Some(nr_inodes) => tmpfs.with_nr_inodes(nr_inodes),
107
111
  None => tmpfs,
108
- }));
109
- filesystem.map(TmpfsFs).map_err(cannot_stand)
112
+ });
113
+ filesystem.map(TmpfsFs).map_err(to_instance_error)
110
114
  }
111
115
 
112
116
  /// A Filesystem whose instance cannot stand, an `ArgumentError` the Host App
113
117
  /// can rescue.
114
- fn cannot_stand(error: FilesystemError) -> MagnusError {
118
+ fn to_instance_error(error: Errno) -> MagnusError {
115
119
  let ruby = Ruby::get().expect("Ruby thread");
116
120
  MagnusError::new(
117
121
  ruby.exception_arg_error(),
@@ -124,17 +128,22 @@ fn to_count(count: Value) -> Result<Option<usize>, MagnusError> {
124
128
  Option::<usize>::try_convert(count)
125
129
  }
126
130
 
127
- fn bind_new(path: String) -> Result<BindFs, MagnusError> {
131
+ /// `Bind.new(path, exclusive: false)`.
132
+ fn bind_new(args: &[Value]) -> Result<BindFs, MagnusError> {
128
133
  let ruby = Ruby::get().expect("Ruby thread");
134
+ let args = scan_args::<(String,), (), (), (), RHash, ()>(args)?;
135
+ let (path,) = args.required;
136
+ let kwargs = get_kwargs::<_, (), (Option<bool>,), ()>(args.keywords, &[], &["exclusive"])?;
137
+ let (exclusive,) = kwargs.optional;
129
138
  let directory = Bind::new(&path).map_err(|err| {
130
139
  MagnusError::new(
131
140
  ruby.exception_arg_error(),
132
141
  format!("cannot open host directory {path}: {err}"),
133
142
  )
134
143
  })?;
135
- Filesystem::new(Arc::new(directory))
144
+ Filesystem::new(directory.with_exclusive(exclusive.unwrap_or(false)))
136
145
  .map(BindFs)
137
- .map_err(cannot_stand)
146
+ .map_err(to_instance_error)
138
147
  }
139
148
 
140
149
  /// `Overlay.new(lower:, upper: nil)`: the Filesystems in `lower`, topmost
@@ -176,7 +185,7 @@ fn overlay_new(args: &[Value]) -> Result<OverlayFs, MagnusError> {
176
185
  )
177
186
  })?;
178
187
  Ok(OverlayFs {
179
- filesystem: Filesystem::new(Arc::new(overlay)).map_err(cannot_stand)?,
188
+ filesystem: Filesystem::new(overlay).map_err(to_instance_error)?,
180
189
  layers: lower.into_iter().chain(upper).map(Opaque::from).collect(),
181
190
  })
182
191
  }
@@ -194,8 +203,8 @@ fn to_filesystem(value: Value) -> Result<Arc<Filesystem>, MagnusError> {
194
203
  if let Ok(fs) = <&OverlayFs>::try_convert(value) {
195
204
  return Ok(fs.filesystem.clone());
196
205
  }
197
- if let Some(fs) = RubyFilesystem::from_value(value) {
198
- return Filesystem::new(Arc::new(fs)).map_err(cannot_stand);
206
+ if let Some(fs) = RubyFilesystem::from_value(value)? {
207
+ return Filesystem::new(fs).map_err(to_instance_error);
199
208
  }
200
209
  let ruby = Ruby::get().expect("Ruby thread");
201
210
  Err(MagnusError::new(
@@ -0,0 +1,306 @@
1
+ //! Releasing Ruby's GVL for an invocation's guest span so distinct Sandboxes on
2
+ //! distinct Threads run their guest code in parallel.
3
+ //!
4
+ //! `region` brackets one invocation's guest span, releasing the GVL when the
5
+ //! Sandbox asks for it; `reenter` re-acquires the GVL for a guest→host dispatch
6
+ //! callback, which is ordinary Ruby and must hold the lock. A thread-local flag
7
+ //! stops a nested dispatch from re-acquiring a second time, and both directions
8
+ //! run their closure through a `catch_unwind` trampoline because a panic must
9
+ //! never cross the C frame of `rb_thread_call_without_gvl2` /
10
+ //! `rb_thread_call_with_gvl` (undefined behaviour). The flag is per-thread,
11
+ //! matching the one-thread-one-Sandbox contract, and is restored through a drop
12
+ //! guard so an unwinding panic cannot leave it corrupt for the next invocation.
13
+ //!
14
+ //! A raise where either direction returns jumps over every Rust frame of the
15
+ //! run and what they hold: a lock's guard, this flag. A release uses
16
+ //! `rb_thread_call_without_gvl2`, which declines rather than raises, and a run
17
+ //! releasing the GVL defers Ruby's interrupts (`defer_interrupts`) outside its
18
+ //! callbacks, as `rb_thread_call_with_gvl` checks for one as it gives the GVL
19
+ //! back. An interrupt waits for the run to end instead. Two kinds of work on the
20
+ //! main thread run whatever the mask says, so one that raises there still
21
+ //! jumps: a trap handler, and on Ruby 3.4+ the Thread another Ractor's
22
+ //! `require` starts there, which raises when it cannot start. No public Ruby
23
+ //! API defers either.
24
+
25
+ use std::cell::Cell;
26
+ use std::os::raw::c_void;
27
+ use std::panic::{catch_unwind, resume_unwind, AssertUnwindSafe};
28
+ use std::ptr;
29
+
30
+ use kobako_runtime::sched::{run_interruptible, Blocking, Task};
31
+
32
+ use magnus::block::Proc;
33
+ use magnus::{prelude::*, Error as MagnusError, Ruby, Value};
34
+
35
+ use super::escape;
36
+
37
+ thread_local! {
38
+ // True while this thread sits inside a region whose GVL we released and
39
+ // have not yet re-acquired. Drives `reenter`'s one-shot re-acquire.
40
+ static GVL_RELEASED: Cell<bool> = const { Cell::new(false) };
41
+ }
42
+
43
+ fn region<F, R>(release: bool, f: F) -> R
44
+ where
45
+ F: FnOnce() -> R,
46
+ {
47
+ if !release {
48
+ return f();
49
+ }
50
+ // An interrupt the thread receives meanwhile stops each wait the run meets,
51
+ // for a lock or a host-side event; the interrupt itself still waits for the
52
+ // run to end. One landing before or after the run itself, while the guest
53
+ // is set up or torn down, still belongs to this region and goes with it.
54
+ let task = Task::current();
55
+ let task_ptr = ptr::addr_of!(task).cast_mut().cast::<c_void>();
56
+ run_interruptible(|| {
57
+ let mut f = f;
58
+ loop {
59
+ let released = ReleasedGuard::set(true);
60
+ let ran = call_via(f, |func, data| {
61
+ // An interrupt that came before the region, which Ruby declines
62
+ // to start under or the run's mask defers, stops the waits as one
63
+ // inside it does, as a signal pending when a Linux task sleeps
64
+ // ends the sleep.
65
+ if escape::pending() || interrupt_pending() {
66
+ task.interrupt();
67
+ }
68
+ // SAFETY: `func` and `data` come from `call_via`, which keeps the
69
+ // closure alive across the call; `task` outlives it on this frame,
70
+ // and Ruby calls `interrupt_task` with it only while the region runs.
71
+ unsafe {
72
+ rb_sys::rb_thread_call_without_gvl2(
73
+ Some(func),
74
+ data,
75
+ Some(interrupt_task),
76
+ task_ptr,
77
+ )
78
+ }
79
+ });
80
+ drop(released);
81
+ match ran {
82
+ Ok(value) => return value,
83
+ // A run holds the interrupt and raises it once back in Ruby.
84
+ Err(declined) if escape::is_in_run() => {
85
+ escape::hold_interrupts();
86
+ f = declined;
87
+ }
88
+ // Outside a run nothing would raise a held interrupt, so it
89
+ // stays with Ruby, which raises it as this call returns; the
90
+ // wait runs with the GVL kept and ends at once, interrupted.
91
+ Err(declined) => {
92
+ task.interrupt();
93
+ return declined();
94
+ }
95
+ }
96
+ }
97
+ })
98
+ }
99
+
100
+ /// Whether Ruby holds an interrupt or a signal for this thread, deferred or
101
+ /// not, asked without running it.
102
+ fn interrupt_pending() -> bool {
103
+ // SAFETY: `rb_thread_interrupted` only reads the current thread's flags,
104
+ // which Ruby allows even without the GVL.
105
+ unsafe { rb_sys::rb_thread_interrupted(rb_sys::rb_thread_current()) != 0 }
106
+ }
107
+
108
+ /// Have the thread's run stop waiting for locks, called by Ruby without the GVL
109
+ /// as the region's unblocking function.
110
+ unsafe extern "C" fn interrupt_task(task: *mut c_void) {
111
+ // SAFETY: `region` passes its own `Task`, alive for the whole region
112
+ // Ruby calls this from.
113
+ let task = unsafe { &*task.cast::<Task>() };
114
+ task.interrupt();
115
+ }
116
+
117
+ /// Whether this thread holds the GVL: outside any released region, or
118
+ /// inside a dispatch that re-acquired it.
119
+ fn holds() -> bool {
120
+ !GVL_RELEASED.with(|g| g.get())
121
+ }
122
+
123
+ /// A thread waits for a lock or a host-side event without the GVL, so a
124
+ /// holder asking a Filesystem written in Ruby, or a mount's block, can take
125
+ /// the GVL and finish, and other Threads run while the guest sleeps.
126
+ pub(crate) struct GvlFreeWait;
127
+
128
+ impl Blocking for GvlFreeWait {
129
+ fn wait(&self, wait: &mut dyn FnMut()) {
130
+ region(holds(), wait);
131
+ }
132
+ }
133
+
134
+ /// Runs inline when the GVL is already held — hold mode, or a nested
135
+ /// dispatch whose outer frame re-acquired it.
136
+ pub(crate) fn reenter<F, R>(f: F) -> R
137
+ where
138
+ F: FnOnce() -> R,
139
+ {
140
+ if holds() {
141
+ return f();
142
+ }
143
+ let _guard = ReleasedGuard::set(false);
144
+ // Ruby checks for interrupts as it gives the GVL back on the way out, and
145
+ // raising there would jump over every Rust frame of the run. The run masks
146
+ // them (`defer_interrupts`), so the callback alone takes them as they come.
147
+ let run_callback = |f: F| {
148
+ let ruby = Ruby::get().expect("a thread back in Ruby holds the GVL");
149
+ let (value, raised) = handle_interrupt(&ruby, "immediate", f);
150
+ if let Err(error) = raised {
151
+ escape::keep(error);
152
+ }
153
+ value.expect("a callback run under handle_interrupt returns")
154
+ };
155
+ // SAFETY: `func` and `data` come from `call_via`, which keeps the
156
+ // closure alive across the call, and this thread is a Ruby thread
157
+ // inside a region that released the GVL, as the call requires.
158
+ call_via(
159
+ || run_callback(f),
160
+ |func, data| unsafe { rb_sys::rb_thread_call_with_gvl(Some(func), data) },
161
+ )
162
+ .ok()
163
+ .expect("rb_thread_call_with_gvl always runs its function")
164
+ }
165
+
166
+ /// Run `f` as one run of a Sandbox: giving up the GVL when `release` says so,
167
+ /// with Ruby's interrupts deferred until it is back in Ruby, and one the run
168
+ /// kept raised once it ends.
169
+ pub(crate) fn run<R>(ruby: &Ruby, release: bool, f: impl FnOnce() -> R) -> Result<R, MagnusError> {
170
+ let run = escape::Run::enter();
171
+ let ran = defer_interrupts(ruby, release, || region(release, f));
172
+ run.finish()?;
173
+ ran
174
+ }
175
+
176
+ /// Run `f` with Ruby's interrupts deferred, when `release` says the run gives
177
+ /// up the GVL, until it is back in Ruby, where one comes as the error. A run
178
+ /// keeping the GVL meets no interrupt check outside its callbacks.
179
+ fn defer_interrupts<R>(
180
+ ruby: &Ruby,
181
+ release: bool,
182
+ f: impl FnOnce() -> R,
183
+ ) -> Result<R, MagnusError> {
184
+ if !release {
185
+ return Ok(f());
186
+ }
187
+ let (value, raised) = handle_interrupt(ruby, "never", f);
188
+ raised?;
189
+ Ok(value.expect("a run under handle_interrupt returns"))
190
+ }
191
+
192
+ thread_local! {
193
+ // The body the block `handle_interrupt` yields to runs, kept here as a
194
+ // block takes no closure.
195
+ static BODY: Cell<Option<*mut (dyn FnMut() + 'static)>> = const { Cell::new(None) };
196
+ }
197
+
198
+ /// `Thread.handle_interrupt(Object => timing) { f }`: what `f` returned, if it
199
+ /// ran to its end, and what the call raised, as one deferred interrupt comes
200
+ /// as the mask is lifted.
201
+ fn handle_interrupt<R>(
202
+ ruby: &Ruby,
203
+ timing: &str,
204
+ f: impl FnOnce() -> R,
205
+ ) -> (Option<R>, Result<(), MagnusError>) {
206
+ /// The body of the call around this one, put back on drop.
207
+ struct OuterBody(Option<*mut (dyn FnMut() + 'static)>);
208
+
209
+ impl Drop for OuterBody {
210
+ fn drop(&mut self) {
211
+ BODY.with(|body| body.set(self.0));
212
+ }
213
+ }
214
+
215
+ fn run_body(ruby: &Ruby, _args: &[Value], _block: Option<Proc>) -> Value {
216
+ if let Some(body) = BODY.with(Cell::get) {
217
+ // SAFETY: `handle_interrupt` set it for the length of this call,
218
+ // which yields to this block at most once, on this thread.
219
+ unsafe { (*body)() };
220
+ }
221
+ ruby.qnil().as_value()
222
+ }
223
+
224
+ let mut f = Some(f);
225
+ let mut value = None;
226
+ let mut body = || value = f.take().map(|f| f());
227
+ let body: &mut dyn FnMut() = &mut body;
228
+ // SAFETY: only the lifetime is erased; `OuterBody` takes the pointer back
229
+ // before `body` goes out of scope, and nothing else keeps it.
230
+ let body: *mut (dyn FnMut() + 'static) = unsafe { std::mem::transmute(body) };
231
+ let outer = OuterBody(BODY.with(|current| current.replace(Some(body))));
232
+ let mask = ruby.hash_new();
233
+ let raised = mask
234
+ .aset(ruby.class_object(), ruby.to_symbol(timing))
235
+ .and_then(|()| {
236
+ ruby.class_thread()
237
+ .funcall_with_block::<_, _, Value>(
238
+ "handle_interrupt",
239
+ (mask,),
240
+ ruby.proc_new(run_body),
241
+ )
242
+ .map(|_| ())
243
+ });
244
+ drop(outer);
245
+ (value, raised)
246
+ }
247
+
248
+ /// Restores `GVL_RELEASED` to its prior value on drop, so an unwinding panic
249
+ /// through a released region cannot leave the flag stuck.
250
+ struct ReleasedGuard {
251
+ prev: bool,
252
+ }
253
+
254
+ impl ReleasedGuard {
255
+ fn set(value: bool) -> Self {
256
+ Self {
257
+ prev: GVL_RELEASED.with(|g| g.replace(value)),
258
+ }
259
+ }
260
+ }
261
+
262
+ impl Drop for ReleasedGuard {
263
+ fn drop(&mut self) {
264
+ GVL_RELEASED.with(|g| g.set(self.prev));
265
+ }
266
+ }
267
+
268
+ struct GvlCtx<F, R> {
269
+ f: Option<F>,
270
+ result: Option<std::thread::Result<R>>,
271
+ }
272
+
273
+ /// Runs the closure under `catch_unwind`, so a panic is captured here rather
274
+ /// than unwinding across the C frame.
275
+ unsafe extern "C" fn trampoline<F, R>(data: *mut c_void) -> *mut c_void
276
+ where
277
+ F: FnOnce() -> R,
278
+ {
279
+ // SAFETY: `call_via` passes its own `GvlCtx<F, R>`, borrowed by nothing
280
+ // else for the length of the call.
281
+ let ctx = unsafe { &mut *data.cast::<GvlCtx<F, R>>() };
282
+ let f = ctx.f.take().expect("gvl trampoline runs its closure once");
283
+ ctx.result = Some(catch_unwind(AssertUnwindSafe(f)));
284
+ ptr::null_mut()
285
+ }
286
+
287
+ /// Run `f` through `invoke`, or hand it back when Ruby ran nothing because an
288
+ /// interrupt is pending, as `rb_thread_call_without_gvl2` does.
289
+ fn call_via<F, R>(
290
+ f: F,
291
+ mut invoke: impl FnMut(unsafe extern "C" fn(*mut c_void) -> *mut c_void, *mut c_void) -> *mut c_void,
292
+ ) -> Result<R, F>
293
+ where
294
+ F: FnOnce() -> R,
295
+ {
296
+ let mut ctx = GvlCtx::<F, R> {
297
+ f: Some(f),
298
+ result: None,
299
+ };
300
+ invoke(trampoline::<F, R>, ptr::addr_of_mut!(ctx).cast::<c_void>());
301
+ match ctx.result.take() {
302
+ Some(Ok(value)) => Ok(value),
303
+ Some(Err(payload)) => resume_unwind(payload),
304
+ None => Err(ctx.f.take().expect("a declined call keeps its closure")),
305
+ }
306
+ }
@@ -1,10 +1,71 @@
1
- use magnus::{Error, Ruby};
1
+ //! The Ruby gem's native half. Each Context's module registers the Ruby
2
+ //! constants it answers for; the helpers every module shares sit beside
3
+ //! them.
2
4
 
5
+ use magnus::{prelude::*, Error, RModule, RString, Ruby, Symbol, TryConvert, Value};
6
+
7
+ mod errors;
8
+ mod escape;
9
+ mod filesystem;
10
+ mod gvl;
11
+ mod network;
12
+ mod pinned_value;
3
13
  mod runtime;
14
+ mod wire;
4
15
 
5
16
  #[magnus::init]
6
17
  fn init(ruby: &Ruby) -> Result<(), Error> {
7
- let module = ruby.define_module("Kobako")?;
8
- runtime::init(ruby, module)?;
18
+ let kobako = ruby.define_module("Kobako")?;
19
+ // This extension is the only frontend in its process, so the first
20
+ // registration is the one that stands.
21
+ let _ = kobako_runtime::sched::register_blocking(Box::new(gvl::GvlFreeWait));
22
+ runtime::register(ruby, kobako)?;
23
+ filesystem::register(ruby, kobako)?;
24
+ network::register(kobako)?;
25
+ wire::register(kobako)?;
9
26
  Ok(())
10
27
  }
28
+
29
+ /// The one place the boundary borrows an RString's bytes: the borrow does
30
+ /// not outlive this call, so no Ruby allocation can move the RString
31
+ /// between the borrow and the copy.
32
+ fn to_bytes(s: RString) -> Vec<u8> {
33
+ // SAFETY: see item doc.
34
+ unsafe { s.as_slice() }.to_vec()
35
+ }
36
+
37
+ /// The constant `path` names beneath `Kobako`. `lib/kobako` defines each
38
+ /// one the ext reads before the ext reads it, so a missing one is a wiring
39
+ /// bug and the `unwrap` fails fast.
40
+ fn constant_by_path<T: TryConvert>(ruby: &Ruby, path: &[&str]) -> T {
41
+ let kobako: RModule = ruby.class_object().const_get("Kobako").unwrap();
42
+ let (name, modules) = path.split_last().expect("a path names a constant");
43
+ let owner = modules
44
+ .iter()
45
+ .fold(kobako, |owner, module| owner.const_get(*module).unwrap());
46
+ owner.const_get(*name).unwrap()
47
+ }
48
+
49
+ /// The name of `value` when it is a Symbol, so each choice an option or a
50
+ /// field names is read the same way.
51
+ fn symbol_name_of(value: Value) -> Result<Option<String>, Error> {
52
+ Symbol::from_value(value)
53
+ .map(|symbol| symbol.name().map(|name| name.into_owned()))
54
+ .transpose()
55
+ }
56
+
57
+ /// The value `table` names `name`.
58
+ fn value_by_name<T: Copy>(table: &[(T, &str)], name: &str) -> Option<T> {
59
+ table
60
+ .iter()
61
+ .find(|(_, spelled)| *spelled == name)
62
+ .map(|(value, _)| *value)
63
+ }
64
+
65
+ /// The name `table` gives `value`.
66
+ fn name_of<T: PartialEq>(table: &[(T, &'static str)], value: &T) -> Option<&'static str> {
67
+ table
68
+ .iter()
69
+ .find(|(held, _)| held == value)
70
+ .map(|(_, name)| *name)
71
+ }
@@ -0,0 +1,187 @@
1
+ //! `Kobako::Network::Mock`, standing for the runtime's `Mock`: the table a
2
+ //! Host App's test writes in Ruby, answered in Rust. Nothing in it calls
3
+ //! back into Ruby, so its lookups and dials answer on any thread.
4
+
5
+ use std::net::{IpAddr, SocketAddr};
6
+ use std::sync::Arc;
7
+
8
+ use magnus::scan_args::{get_kwargs, scan_args};
9
+ use magnus::{
10
+ function, method, prelude::*, Error as MagnusError, RArray, RClass, RHash, RModule, Ruby, Value,
11
+ };
12
+
13
+ use kobako_runtime::net::{Backends, IpProtocol, Mock};
14
+ use kobako_runtime::network::Protocol;
15
+
16
+ use super::{symbol_name_of, value_by_name, PROTOCOL_NAMES};
17
+ use crate::errors::errno_of;
18
+
19
+ #[magnus::wrap(class = "Kobako::Network::Mock", free_immediately, size)]
20
+ pub(crate) struct MockNet(Arc<Mock>);
21
+
22
+ impl MockNet {
23
+ /// The backends a Sandbox built with this Mock dials and resolves
24
+ /// through.
25
+ pub(crate) fn backends(&self) -> Backends {
26
+ Backends::new(self.0.clone(), self.0.clone())
27
+ }
28
+ }
29
+
30
+ pub(super) fn register(network: RModule) -> Result<(), MagnusError> {
31
+ let ruby = Ruby::get().expect("Ruby thread");
32
+ let mock = network.define_class("Mock", ruby.class_object())?;
33
+ mock.define_singleton_method("new", function!(mock_new, -1))?;
34
+ mock.define_method("resolve", method!(resolve, -1))?;
35
+ mock.define_method("route", method!(route, -1))?;
36
+ mock.define_method("refuse", method!(refuse, -1))?;
37
+ mock.define_method("hold", method!(hold, 1))?;
38
+ mock.define_method("lookups", method!(lookups, 0))?;
39
+ mock.define_method("dialed_addresses", method!(dialed_addresses, 0))?;
40
+ Ok(())
41
+ }
42
+
43
+ /// `Mock.new(local_addresses: [])`: the host's own addresses, or `nil` for
44
+ /// a host that cannot say them.
45
+ fn mock_new(args: &[Value]) -> Result<MockNet, MagnusError> {
46
+ let args = scan_args::<(), (), (), (), RHash, ()>(args)?;
47
+ let kwargs = get_kwargs::<_, (), (Option<Option<RArray>>,), ()>(
48
+ args.keywords,
49
+ &[],
50
+ &["local_addresses"],
51
+ )?;
52
+ let mock = match kwargs.optional.0 {
53
+ None => Mock::default(),
54
+ Some(addresses) => Mock::default().with_local_addresses(addresses.map(to_ips).transpose()?),
55
+ };
56
+ Ok(MockNet(Arc::new(mock)))
57
+ }
58
+
59
+ /// `resolve(name, to: address)`, or `to: [address, ...]`.
60
+ fn resolve(rb_self: &MockNet, args: &[Value]) -> Result<(), MagnusError> {
61
+ let args = scan_args::<(String,), (), (), (), RHash, ()>(args)?;
62
+ let (name,) = args.required;
63
+ let kwargs = get_kwargs::<_, (Value,), (), ()>(args.keywords, &["to"], &[])?;
64
+ let to = kwargs.required.0;
65
+ let addresses = match RArray::from_value(to) {
66
+ Some(addresses) => to_ips(addresses)?,
67
+ None => vec![to_ip(&String::try_convert(to)?)?],
68
+ };
69
+ rb_self
70
+ .0
71
+ .resolve_to_addrs(&name, addresses)
72
+ .map_err(|_| to_name_error(&name))
73
+ }
74
+
75
+ /// `route(address, port, to: [address, port], protocol: :tcp)`.
76
+ fn route(rb_self: &MockNet, args: &[Value]) -> Result<(), MagnusError> {
77
+ let args = scan_args::<(String, u16), (), (), (), RHash, ()>(args)?;
78
+ let (address, port) = args.required;
79
+ let kwargs = get_kwargs::<_, ((String, u16),), (Option<Value>,), ()>(
80
+ args.keywords,
81
+ &["to"],
82
+ &["protocol"],
83
+ )?;
84
+ let (to_address, to_port) = kwargs.required.0;
85
+ rb_self.0.route(
86
+ to_protocol(kwargs.optional.0)?,
87
+ SocketAddr::new(to_ip(&address)?, port),
88
+ SocketAddr::new(to_ip(&to_address)?, to_port),
89
+ );
90
+ Ok(())
91
+ }
92
+
93
+ /// `refuse(address, port, errno, protocol: :tcp)`, the errno an `Errno`
94
+ /// class read by its POSIX name, since the number behind one differs between
95
+ /// hosts.
96
+ fn refuse(rb_self: &MockNet, args: &[Value]) -> Result<(), MagnusError> {
97
+ let args = scan_args::<(String, u16, RClass), (), (), (), RHash, ()>(args)?;
98
+ let (address, port, errno) = args.required;
99
+ let kwargs = get_kwargs::<_, (), (Option<Value>,), ()>(args.keywords, &[], &["protocol"])?;
100
+ let err = errno_of(errno).ok_or_else(|| {
101
+ let ruby = Ruby::get().expect("Ruby thread");
102
+ MagnusError::new(
103
+ ruby.exception_arg_error(),
104
+ format!("kobako answers no errno {}", errno.inspect()),
105
+ )
106
+ })?;
107
+ rb_self.0.refuse(
108
+ to_protocol(kwargs.optional.0)?,
109
+ SocketAddr::new(to_ip(&address)?, port),
110
+ err,
111
+ );
112
+ Ok(())
113
+ }
114
+
115
+ /// The protocol a route or a refusal keys on, `:tcp` unless written, by the
116
+ /// name an endpoint's protocol has; HTTP is no protocol a dial keys on.
117
+ fn to_protocol(protocol: Option<Value>) -> Result<IpProtocol, MagnusError> {
118
+ let Some(protocol) = protocol else {
119
+ return Ok(IpProtocol::Tcp);
120
+ };
121
+ symbol_name_of(protocol)?
122
+ .and_then(|name| value_by_name(&PROTOCOL_NAMES, &name))
123
+ .and_then(|protocol| match protocol {
124
+ Protocol::Tcp => Some(IpProtocol::Tcp),
125
+ Protocol::Udp => Some(IpProtocol::Udp),
126
+ _ => None,
127
+ })
128
+ .ok_or_else(|| {
129
+ let ruby = Ruby::get().expect("Ruby thread");
130
+ MagnusError::new(ruby.exception_arg_error(), "protocol must be :tcp or :udp")
131
+ })
132
+ }
133
+
134
+ /// `hold(name) { ... }`: the name answers no lookup until the block
135
+ /// returns or raises.
136
+ fn hold(ruby: &Ruby, rb_self: &MockNet, name: String) -> Result<Value, MagnusError> {
137
+ if !ruby.block_given() {
138
+ return Err(MagnusError::new(
139
+ ruby.exception_arg_error(),
140
+ "hold needs a block, which the hold lasts for",
141
+ ));
142
+ }
143
+ let _hold = rb_self.0.hold(&name).map_err(|_| to_name_error(&name))?;
144
+ ruby.yield_values(())
145
+ }
146
+
147
+ /// The `ArgumentError` for `name`, which no guest's lookup asks.
148
+ fn to_name_error(name: &str) -> MagnusError {
149
+ let ruby = Ruby::get().expect("Ruby thread");
150
+ MagnusError::new(
151
+ ruby.exception_arg_error(),
152
+ format!("not a name a lookup asks: {name:?}"),
153
+ )
154
+ }
155
+
156
+ /// Each name the guest's lookups asked, in order.
157
+ fn lookups(rb_self: &MockNet) -> Vec<String> {
158
+ rb_self.0.lookups()
159
+ }
160
+
161
+ /// Each address dialed, in order, as `[address, port]`.
162
+ fn dialed_addresses(rb_self: &MockNet) -> Vec<(String, u16)> {
163
+ rb_self
164
+ .0
165
+ .dialed_addresses()
166
+ .into_iter()
167
+ .map(|addr| (addr.ip().to_string(), addr.port()))
168
+ .collect()
169
+ }
170
+
171
+ fn to_ips(addresses: RArray) -> Result<Vec<IpAddr>, MagnusError> {
172
+ addresses
173
+ .into_iter()
174
+ .map(|address| to_ip(&String::try_convert(address)?))
175
+ .collect()
176
+ }
177
+
178
+ /// An address the Host App wrote, or an `ArgumentError` naming it.
179
+ fn to_ip(address: &str) -> Result<IpAddr, MagnusError> {
180
+ address.parse().map_err(|_| {
181
+ let ruby = Ruby::get().expect("Ruby thread");
182
+ MagnusError::new(
183
+ ruby.exception_arg_error(),
184
+ format!("not an IP address: {address:?}"),
185
+ )
186
+ })
187
+ }