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.
- checksums.yaml +4 -4
- data/.release-please-manifest.json +1 -1
- data/CHANGELOG.md +335 -0
- data/Cargo.lock +469 -11
- data/README.md +43 -3
- data/ROADMAP.md +1 -1
- data/crates/kobako-runtime/CHANGELOG.md +219 -0
- data/crates/kobako-runtime/Cargo.toml +51 -3
- data/crates/kobako-runtime/README.md +7 -4
- data/crates/kobako-runtime/src/cred.rs +124 -0
- data/crates/kobako-runtime/src/dispatch.rs +4 -5
- data/crates/kobako-runtime/src/endpoint/buffer.rs +153 -44
- data/crates/kobako-runtime/src/endpoint/dispatch.rs +80 -41
- data/crates/kobako-runtime/src/endpoint/invoke.rs +23 -36
- data/crates/kobako-runtime/src/endpoint.rs +137 -36
- data/crates/kobako-runtime/src/errno.rs +391 -0
- data/crates/kobako-runtime/src/error.rs +31 -10
- data/crates/kobako-runtime/src/filesystem/anon_inodes.rs +52 -0
- data/crates/kobako-runtime/src/filesystem/bind/lookup.rs +52 -14
- data/crates/kobako-runtime/src/filesystem/bind/walk.rs +19 -20
- data/crates/kobako-runtime/src/filesystem/bind.rs +437 -245
- data/crates/kobako-runtime/src/filesystem/overlay/file.rs +6 -6
- data/crates/kobako-runtime/src/filesystem/overlay/path.rs +43 -65
- data/crates/kobako-runtime/src/filesystem/overlay/stack/copy_up.rs +9 -16
- data/crates/kobako-runtime/src/filesystem/overlay/stack/dir.rs +47 -72
- data/crates/kobako-runtime/src/filesystem/overlay/stack/namei.rs +12 -12
- data/crates/kobako-runtime/src/filesystem/overlay/stack/readdir.rs +4 -7
- data/crates/kobako-runtime/src/filesystem/overlay/stack.rs +121 -37
- data/crates/kobako-runtime/src/filesystem/overlay.rs +302 -343
- data/crates/kobako-runtime/src/filesystem/pipe.rs +12 -9
- data/crates/kobako-runtime/src/filesystem/rdir.rs +15 -32
- data/crates/kobako-runtime/src/filesystem/tmpfs/seed.rs +32 -0
- data/crates/kobako-runtime/src/filesystem/tmpfs/tmpfile.rs +3 -3
- data/crates/kobako-runtime/src/filesystem/tmpfs/whiteout.rs +57 -35
- data/crates/kobako-runtime/src/filesystem/tmpfs/xattr.rs +2 -2
- data/crates/kobako-runtime/src/filesystem/tmpfs.rs +172 -160
- data/crates/kobako-runtime/src/filesystem/wrap.rs +36 -52
- data/crates/kobako-runtime/src/filesystem.rs +6 -3
- data/crates/kobako-runtime/src/fork.rs +96 -0
- data/crates/kobako-runtime/src/grant.rs +3 -0
- data/crates/kobako-runtime/src/hashtable.rs +4 -2
- data/crates/kobako-runtime/src/lib.rs +18 -7
- data/crates/kobako-runtime/src/limits.rs +195 -0
- data/crates/kobako-runtime/src/locking.rs +10 -0
- data/crates/kobako-runtime/src/memcg.rs +383 -0
- data/crates/kobako-runtime/src/mount.rs +67 -9
- data/crates/kobako-runtime/src/net/backends.rs +43 -0
- data/crates/kobako-runtime/src/net/connections.rs +179 -0
- data/crates/kobako-runtime/src/net/credential.rs +125 -0
- data/crates/kobako-runtime/src/net/egress.rs +160 -0
- data/crates/kobako-runtime/src/net/family.rs +181 -0
- data/crates/kobako-runtime/src/net/http.rs +2733 -0
- data/crates/kobako-runtime/src/net/lookup.rs +285 -0
- data/crates/kobako-runtime/src/net/mock.rs +251 -0
- data/crates/kobako-runtime/src/net/namespace.rs +1366 -0
- data/crates/kobako-runtime/src/net/reactor.rs +531 -0
- data/crates/kobako-runtime/src/net/resolv/darwin.rs +275 -0
- data/crates/kobako-runtime/src/net/resolv/stub/tests.rs +469 -0
- data/crates/kobako-runtime/src/net/resolv/stub.rs +536 -0
- data/crates/kobako-runtime/src/net/resolv/windows.rs +248 -0
- data/crates/kobako-runtime/src/net/resolv.rs +227 -0
- data/crates/kobako-runtime/src/net/socket.rs +870 -0
- data/crates/kobako-runtime/src/net/tcp.rs +1588 -0
- data/crates/kobako-runtime/src/net/tls.rs +58 -0
- data/crates/kobako-runtime/src/net/transport.rs +279 -0
- data/crates/kobako-runtime/src/net/udp.rs +1003 -0
- data/crates/kobako-runtime/src/net.rs +42 -0
- data/crates/kobako-runtime/src/network/builder.rs +177 -0
- data/crates/kobako-runtime/src/network/ruleset.rs +777 -0
- data/crates/kobako-runtime/src/network.rs +551 -0
- data/crates/kobako-runtime/src/policy.rs +16 -0
- data/crates/kobako-runtime/src/profile.rs +29 -144
- data/crates/kobako-runtime/src/runtime.rs +3 -5
- data/crates/kobako-runtime/src/sched.rs +130 -29
- data/crates/kobako-runtime/src/security/entry_policy.rs +22 -0
- data/crates/kobako-runtime/src/{vfs/cred.rs → security/hooks.rs} +52 -144
- data/crates/kobako-runtime/src/security/mount_policy.rs +158 -0
- data/crates/kobako-runtime/src/security.rs +101 -196
- data/crates/kobako-runtime/src/snapshot.rs +121 -2
- data/crates/kobako-runtime/src/vfs/attr.rs +5 -5
- data/crates/kobako-runtime/src/vfs/dentry.rs +143 -89
- data/crates/kobako-runtime/src/vfs/file.rs +199 -203
- data/crates/kobako-runtime/src/vfs/inode.rs +41 -45
- data/crates/kobako-runtime/src/vfs/kern_path.rs +38 -42
- data/crates/kobako-runtime/src/vfs/mount.rs +10 -9
- data/crates/kobako-runtime/src/vfs/namei.rs +829 -700
- data/crates/kobako-runtime/src/vfs/namespace.rs +162 -0
- data/crates/kobako-runtime/src/vfs/open_files.rs +69 -0
- data/crates/kobako-runtime/src/vfs/openat2.rs +3 -3
- data/crates/kobako-runtime/src/vfs/path.rs +6 -6
- data/crates/kobako-runtime/src/vfs/readdir.rs +6 -6
- data/crates/kobako-runtime/src/vfs/stat.rs +159 -23
- data/crates/kobako-runtime/src/vfs/super_block.rs +18 -14
- data/crates/kobako-runtime/src/vfs/utimes.rs +37 -27
- data/crates/kobako-runtime/src/vfs.rs +9 -6
- data/crates/kobako-runtime/src/wait.rs +356 -0
- data/crates/kobako-transport/CHANGELOG.md +31 -0
- data/crates/kobako-transport/Cargo.toml +1 -1
- data/crates/kobako-transport/README.md +3 -4
- data/crates/kobako-transport/src/abi.rs +78 -72
- data/crates/kobako-transport/src/envelope/bytes.rs +17 -6
- data/crates/kobako-transport/src/envelope/call.rs +32 -4
- data/crates/kobako-transport/src/envelope/error_record.rs +21 -0
- data/crates/kobako-transport/src/envelope/name.rs +99 -0
- data/crates/kobako-transport/src/envelope/outcome.rs +9 -9
- data/crates/kobako-transport/src/envelope/preamble.rs +24 -21
- data/crates/kobako-transport/src/envelope/reply.rs +27 -27
- data/crates/kobako-transport/src/envelope/unsupported.rs +10 -10
- data/crates/kobako-transport/src/envelope.rs +13 -8
- data/crates/kobako-wasmtime/CHANGELOG.md +161 -0
- data/crates/kobako-wasmtime/Cargo.toml +26 -7
- data/crates/kobako-wasmtime/README.md +3 -2
- data/crates/kobako-wasmtime/build/preview2.rs +1339 -0
- data/crates/kobako-wasmtime/build.rs +16 -0
- data/crates/kobako-wasmtime/src/abi.rs +17 -37
- data/crates/kobako-wasmtime/src/ambient.rs +33 -18
- data/crates/kobako-wasmtime/src/cache.rs +23 -15
- data/crates/kobako-wasmtime/src/config.rs +52 -68
- data/crates/kobako-wasmtime/src/driver.rs +48 -63
- data/crates/kobako-wasmtime/src/exports.rs +143 -17
- data/crates/kobako-wasmtime/src/guest.rs +12 -6
- data/crates/kobako-wasmtime/src/guest_binary.rs +14 -0
- data/crates/kobako-wasmtime/src/imports.rs +42 -18
- data/crates/kobako-wasmtime/src/instance_pre.rs +4 -4
- data/crates/kobako-wasmtime/src/invocation.rs +74 -12
- data/crates/kobako-wasmtime/src/lib.rs +5 -3
- data/crates/kobako-wasmtime/src/limiter.rs +70 -5
- data/crates/kobako-wasmtime/src/preview1/descriptors.rs +309 -0
- data/crates/kobako-wasmtime/src/preview1/differential/mount.rs +5 -15
- data/crates/kobako-wasmtime/src/preview1/differential.rs +27 -31
- data/crates/kobako-wasmtime/src/preview1/errno.rs +55 -66
- data/crates/kobako-wasmtime/src/preview1/fd.rs +327 -296
- data/crates/kobako-wasmtime/src/preview1/memory.rs +21 -12
- data/crates/kobako-wasmtime/src/preview1/mount_view/wrap.rs +34 -53
- data/crates/kobako-wasmtime/src/preview1/mount_view.rs +231 -217
- data/crates/kobako-wasmtime/src/preview1/path.rs +56 -121
- data/crates/kobako-wasmtime/src/preview1/poll.rs +244 -120
- data/crates/kobako-wasmtime/src/preview1/sock.rs +10 -8
- data/crates/kobako-wasmtime/src/preview1/testsuite.rs +5 -15
- data/crates/kobako-wasmtime/src/preview1.rs +46 -42
- data/crates/kobako-wasmtime/src/preview2/abi.rs +227 -0
- data/crates/kobako-wasmtime/src/preview2/error.rs +118 -0
- data/crates/kobako-wasmtime/src/preview2/filesystem.rs +122 -0
- data/crates/kobako-wasmtime/src/preview2/host.rs +3959 -0
- data/crates/kobako-wasmtime/src/preview2/http.rs +1503 -0
- data/crates/kobako-wasmtime/src/preview2/io.rs +315 -0
- data/crates/kobako-wasmtime/src/preview2/sockets.rs +379 -0
- data/crates/kobako-wasmtime/src/preview2/table.rs +305 -0
- data/crates/kobako-wasmtime/src/preview2.rs +57 -0
- data/crates/kobako-wasmtime/src/trap.rs +24 -9
- data/crates/kobako-wasmtime/src/wasi.rs +210 -81
- data/crates/kobako-wasmtime/wit/deps/cli.wit +233 -0
- data/crates/kobako-wasmtime/wit/deps/clocks.wit +162 -0
- data/crates/kobako-wasmtime/wit/deps/filesystem.wit +589 -0
- data/crates/kobako-wasmtime/wit/deps/http.wit +733 -0
- data/crates/kobako-wasmtime/wit/deps/io.wit +299 -0
- data/crates/kobako-wasmtime/wit/deps/random.wit +92 -0
- data/crates/kobako-wasmtime/wit/deps/sockets.wit +949 -0
- data/data/kobako.wasm +0 -0
- data/ext/kobako/Cargo.toml +1 -1
- data/ext/kobako/src/{runtime/errors.rs → errors.rs} +34 -26
- data/ext/kobako/src/{runtime/escape.rs → escape.rs} +42 -11
- data/ext/kobako/src/{runtime/filesystem → filesystem}/grants.rs +30 -26
- data/ext/kobako/src/{runtime/filesystem → filesystem}/ruby.rs +149 -168
- data/ext/kobako/src/{runtime/filesystem.rs → filesystem.rs} +24 -15
- data/ext/kobako/src/gvl.rs +306 -0
- data/ext/kobako/src/lib.rs +64 -3
- data/ext/kobako/src/network/mock.rs +187 -0
- data/ext/kobako/src/network.rs +591 -0
- data/ext/kobako/src/runtime/bridge.rs +30 -29
- data/ext/kobako/src/runtime/snapshot.rs +4 -4
- data/ext/kobako/src/runtime.rs +221 -143
- data/ext/kobako/src/wire.rs +42 -0
- data/lib/kobako/catalog/extensions.rb +14 -2
- data/lib/kobako/catalog/flags.rb +3 -5
- data/lib/kobako/catalog/grants.rb +5 -4
- data/lib/kobako/catalog/handles.rb +5 -27
- data/lib/kobako/catalog/mount.rb +11 -3
- data/lib/kobako/catalog/network.rb +35 -0
- data/lib/kobako/catalog/replacements.rb +28 -0
- data/lib/kobako/catalog/services.rb +5 -19
- data/lib/kobako/catalog/snippets.rb +3 -18
- data/lib/kobako/catalog.rb +3 -0
- data/lib/kobako/codec/{utils.rb → boundary.rb} +4 -2
- data/lib/kobako/codec/decoder.rb +4 -4
- data/lib/kobako/codec/ext_types.rb +3 -3
- data/lib/kobako/codec/handle_walk.rb +3 -43
- data/lib/kobako/codec/value_budget.rb +132 -40
- data/lib/kobako/codec.rb +1 -1
- data/lib/kobako/context.rb +24 -11
- data/lib/kobako/errors.rb +15 -12
- data/lib/kobako/extension.rb +3 -2
- data/lib/kobako/filesystem.rb +9 -2
- data/lib/kobako/handle.rb +2 -2
- data/lib/kobako/names.rb +28 -0
- data/lib/kobako/network.rb +210 -0
- data/lib/kobako/outcome.rb +7 -7
- data/lib/kobako/pool.rb +45 -23
- data/lib/kobako/runtime.rb +3 -2
- data/lib/kobako/sandbox.rb +92 -35
- data/lib/kobako/sandbox_options.rb +41 -106
- data/lib/kobako/transport/argument_wrap.rb +64 -0
- data/lib/kobako/transport/block_failure.rb +1 -1
- data/lib/kobako/transport/dispatcher.rb +6 -6
- data/lib/kobako/transport/exposure.rb +26 -15
- data/lib/kobako/transport/reflection.rb +21 -4
- data/lib/kobako/transport/run.rb +8 -23
- data/lib/kobako/transport/yielder.rb +2 -9
- data/lib/kobako/transport.rb +1 -0
- data/lib/kobako/version.rb +1 -1
- data/lib/kobako.rb +6 -2
- data/release-please-config.json +15 -0
- data/sig/core/thread.rbs +6 -0
- data/sig/kobako/catalog/extensions.rbs +2 -0
- data/sig/kobako/catalog/grants.rbs +7 -4
- data/sig/kobako/catalog/handles.rbs +0 -2
- data/sig/kobako/catalog/mount.rbs +3 -1
- data/sig/kobako/catalog/network.rbs +20 -0
- data/sig/kobako/catalog/replacements.rbs +14 -0
- data/sig/kobako/catalog/services.rbs +0 -4
- data/sig/kobako/catalog/snippets.rbs +0 -2
- data/sig/kobako/codec/{utils.rbs → boundary.rbs} +2 -2
- data/sig/kobako/codec/handle_walk.rbs +0 -6
- data/sig/kobako/codec/value_budget.rbs +47 -4
- data/sig/kobako/context.rbs +3 -1
- data/sig/kobako/errors.rbs +4 -4
- data/sig/kobako/filesystem.rbs +21 -3
- data/sig/kobako/network.rbs +115 -0
- data/sig/kobako/outcome.rbs +1 -1
- data/sig/kobako/pool.rbs +7 -3
- data/sig/kobako/runtime.rbs +32 -3
- data/sig/kobako/sandbox.rbs +19 -2
- data/sig/kobako/sandbox_options.rbs +29 -38
- data/sig/kobako/transport/argument_wrap.rbs +15 -0
- data/sig/kobako/transport/error.rbs +1 -1
- data/sig/kobako/transport/exposure.rbs +2 -4
- data/sig/kobako/transport/reflection.rbs +10 -0
- data/sig/kobako/transport/run.rbs +0 -2
- data/sig/kobako/transport/yielder.rbs +0 -3
- data/sig/kobako/transport.rbs +1 -1
- data/sig/kobako.rbs +13 -0
- metadata +84 -35
- data/crates/kobako-runtime/src/endpoint/capture.rs +0 -115
- data/crates/kobako-runtime/src/endpoint/memory_cap.rs +0 -238
- data/crates/kobako-runtime/src/filesystem/path.rs +0 -21
- data/crates/kobako-runtime/src/vfs/errno.rs +0 -153
- data/crates/kobako-runtime/tests/linux_baseline/calls.rs +0 -171
- data/crates/kobako-runtime/tests/linux_baseline/concurrent.rs +0 -276
- data/crates/kobako-runtime/tests/linux_baseline/kobako.rs +0 -323
- data/crates/kobako-runtime/tests/linux_baseline/linux-baseline-expected.txt +0 -16
- data/crates/kobako-runtime/tests/linux_baseline/linux.rs +0 -449
- data/crates/kobako-runtime/tests/linux_baseline/main.rs +0 -611
- data/crates/kobako-runtime/tests/linux_baseline/permissions.rs +0 -236
- data/crates/kobako-wasmtime/src/descriptors.rs +0 -200
- data/crates/kobako-wasmtime/tests/integration/compile_posture.rs +0 -43
- data/crates/kobako-wasmtime/tests/integration/guest_file.rs +0 -1085
- data/crates/kobako-wasmtime/tests/integration/main.rs +0 -29
- data/crates/kobako-wasmtime/tests/integration/preamble_flags.rs +0 -70
- data/crates/kobako-wasmtime/tests/integration/snippet_compile.rs +0 -95
- data/crates/kobako-wasmtime/tests/integration/support/mod.rs +0 -30
- data/crates/kobako-wasmtime/tests/integration/unanswered_call.rs +0 -86
- data/crates/kobako-wasmtime/tests/integration/unsupported_call.rs +0 -51
- data/ext/kobako/src/runtime/gvl.rs +0 -147
- data/lib/kobako/constant_name.rb +0 -8
- data/sig/kobako/constant_name.rbs +0 -3
- /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,
|
|
23
|
+
use kobako_runtime::filesystem::{Bind, Filesystem, Overlay, Tmpfs};
|
|
24
|
+
use kobako_runtime::Errno;
|
|
23
25
|
|
|
24
|
-
pub(super) use grants::
|
|
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
|
-
|
|
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(
|
|
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(
|
|
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
|
|
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
|
-
|
|
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(
|
|
144
|
+
Filesystem::new(directory.with_exclusive(exclusive.unwrap_or(false)))
|
|
136
145
|
.map(BindFs)
|
|
137
|
-
.map_err(
|
|
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(
|
|
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(
|
|
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
|
+
}
|
data/ext/kobako/src/lib.rs
CHANGED
|
@@ -1,10 +1,71 @@
|
|
|
1
|
-
|
|
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
|
|
8
|
-
|
|
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
|
+
}
|