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
|
@@ -0,0 +1,285 @@
|
|
|
1
|
+
//! A name lookup the guest asked for, judged as a DNS proxy judges a query,
|
|
2
|
+
//! then resolved as a task on the reactor, its waiter woken through the
|
|
3
|
+
//! lookup's wait queue so the deadline ends the wait. Linux leaves resolution
|
|
4
|
+
//! to userspace, where a process's own query ends with it, so the Resolver is
|
|
5
|
+
//! a backend beside the Protocol Family, and dropping a lookup cancels its
|
|
6
|
+
//! query.
|
|
7
|
+
|
|
8
|
+
use std::collections::HashSet;
|
|
9
|
+
use std::future::Future;
|
|
10
|
+
use std::net::IpAddr;
|
|
11
|
+
use std::pin::Pin;
|
|
12
|
+
use std::sync::{Arc, Mutex, PoisonError};
|
|
13
|
+
use std::task::{Context, Poll};
|
|
14
|
+
|
|
15
|
+
use super::connections::{open, OpenConnections, Place};
|
|
16
|
+
use super::reactor::{Reactor, Task};
|
|
17
|
+
use super::Namespace;
|
|
18
|
+
use crate::cred::Cred;
|
|
19
|
+
use crate::filesystem::anon_inode_getfile;
|
|
20
|
+
use crate::network::{Host, Name};
|
|
21
|
+
use crate::vfs::{FMode, File, FileOperations, OpenHow, PollMask};
|
|
22
|
+
use crate::wait::{poll_wait, PollTable, WaitQueueHead};
|
|
23
|
+
|
|
24
|
+
/// A name's addresses still coming, which the reactor polls, as reqwest's
|
|
25
|
+
/// `Resolving` is.
|
|
26
|
+
pub type Resolving = Pin<Box<dyn Future<Output = Result<Vec<IpAddr>, LookupError>> + Send>>;
|
|
27
|
+
|
|
28
|
+
/// What answers a name, as userspace's `getaddrinfo` does in Linux, apart
|
|
29
|
+
/// from the Protocol Family that dials what it answered. The guest's lookups
|
|
30
|
+
/// and the L7 proxy both ask it.
|
|
31
|
+
pub trait Resolver: Send + Sync {
|
|
32
|
+
/// The addresses `name`, a fully qualified name, resolves to. It is
|
|
33
|
+
/// called on the thread that asks, never the reactor, so starting a query
|
|
34
|
+
/// may wait briefly as a system call does; the future runs on kobako's
|
|
35
|
+
/// reactor, so polling it never blocks, and dropping it cancels the
|
|
36
|
+
/// query, so no query outlives the lookup that asked. A failure names
|
|
37
|
+
/// its kind as an NSS module reports `h_errno` to `getaddrinfo`: no
|
|
38
|
+
/// address answers `NoName` or an empty list, a resolver it cannot reach
|
|
39
|
+
/// now `Again`, and one that cannot answer the name at all `Fail`.
|
|
40
|
+
fn resolve(&self, name: &str) -> Resolving;
|
|
41
|
+
}
|
|
42
|
+
|
|
43
|
+
/// Why a lookup has no address, as `getaddrinfo` names each by its `EAI_`
|
|
44
|
+
/// code; a Wasm Driver turns each into its ABI's code.
|
|
45
|
+
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
|
46
|
+
#[non_exhaustive]
|
|
47
|
+
pub enum LookupError {
|
|
48
|
+
/// No URL host spells the name, so it is no domain name or address at
|
|
49
|
+
/// all.
|
|
50
|
+
InvalidName,
|
|
51
|
+
/// `EAI_NONAME`: the name resolves to nothing, or no entry lets the guest
|
|
52
|
+
/// look it up; the two answer alike, so a refusal reads as NXDOMAIN.
|
|
53
|
+
NoName,
|
|
54
|
+
/// `EAI_FAIL`: the resolver cannot answer this name at all.
|
|
55
|
+
Fail,
|
|
56
|
+
/// `EAI_AGAIN`: no answer now, as a full cap, a timeout, or a server
|
|
57
|
+
/// failure leaves it; asking again may answer.
|
|
58
|
+
Again,
|
|
59
|
+
}
|
|
60
|
+
|
|
61
|
+
/// The answer a lookup waits for, shared with the query that sets it.
|
|
62
|
+
type Answer = Arc<Mutex<Option<Result<Vec<IpAddr>, LookupError>>>>;
|
|
63
|
+
|
|
64
|
+
/// One lookup in flight, then its answer.
|
|
65
|
+
pub struct NameLookup {
|
|
66
|
+
name: String,
|
|
67
|
+
/// Whether the name spelled an address, which answers as itself.
|
|
68
|
+
of_address: bool,
|
|
69
|
+
answer: Answer,
|
|
70
|
+
wait: Arc<WaitQueueHead>,
|
|
71
|
+
/// The query under way on the reactor, cancelled as the lookup drops.
|
|
72
|
+
query: Option<Arc<Task>>,
|
|
73
|
+
}
|
|
74
|
+
|
|
75
|
+
impl NameLookup {
|
|
76
|
+
/// A lookup of `name` through `resolver` holding one of
|
|
77
|
+
/// `open_connections`' places; a full count answers at once as a temporary
|
|
78
|
+
/// failure.
|
|
79
|
+
pub(crate) fn start(
|
|
80
|
+
resolver: Arc<dyn Resolver>,
|
|
81
|
+
name: String,
|
|
82
|
+
open_connections: &Arc<OpenConnections>,
|
|
83
|
+
) -> Result<Arc<Self>, LookupError> {
|
|
84
|
+
let place = open(open_connections).ok_or(LookupError::Again)?;
|
|
85
|
+
Self::start_holding(resolver, name, Arc::new(place))
|
|
86
|
+
}
|
|
87
|
+
|
|
88
|
+
/// A lookup of `name` through `resolver` holding `place`, which its
|
|
89
|
+
/// caller already counts. The query holds the place until it answers or
|
|
90
|
+
/// the lookup drops and cancels it, so a lookup nobody waits for gives its
|
|
91
|
+
/// place back at once. A reactor the process cannot start answers as a
|
|
92
|
+
/// resolver out of resources does.
|
|
93
|
+
pub(crate) fn start_holding(
|
|
94
|
+
resolver: Arc<dyn Resolver>,
|
|
95
|
+
name: String,
|
|
96
|
+
place: Arc<Place>,
|
|
97
|
+
) -> Result<Arc<Self>, LookupError> {
|
|
98
|
+
let reactor = Reactor::current().map_err(|_| LookupError::Again)?;
|
|
99
|
+
let answer = Answer::default();
|
|
100
|
+
let wait = Arc::<WaitQueueHead>::default();
|
|
101
|
+
let resolving = resolver.resolve(&name);
|
|
102
|
+
let (answering, waking) = (answer.clone(), wait.clone());
|
|
103
|
+
let query = reactor.spawn(async move {
|
|
104
|
+
let _place = place;
|
|
105
|
+
let found = match resolving.await {
|
|
106
|
+
Ok(addresses) if addresses.is_empty() => Err(LookupError::NoName),
|
|
107
|
+
Ok(mut addresses) => {
|
|
108
|
+
// Each real address once, so each takes one virtual one.
|
|
109
|
+
let mut seen = HashSet::new();
|
|
110
|
+
addresses.retain(|ip| seen.insert(*ip));
|
|
111
|
+
Ok(addresses)
|
|
112
|
+
}
|
|
113
|
+
failed => failed,
|
|
114
|
+
};
|
|
115
|
+
*answering.lock().unwrap_or_else(PoisonError::into_inner) = Some(found);
|
|
116
|
+
waking.wake_up();
|
|
117
|
+
});
|
|
118
|
+
Ok(Arc::new(Self {
|
|
119
|
+
name,
|
|
120
|
+
of_address: false,
|
|
121
|
+
answer,
|
|
122
|
+
wait,
|
|
123
|
+
query: Some(query),
|
|
124
|
+
}))
|
|
125
|
+
}
|
|
126
|
+
|
|
127
|
+
/// A lookup answered at once, with no query, as a refused name is.
|
|
128
|
+
pub(crate) fn with_answer(name: String, answer: Result<Vec<IpAddr>, LookupError>) -> Arc<Self> {
|
|
129
|
+
Arc::new(Self {
|
|
130
|
+
name,
|
|
131
|
+
of_address: false,
|
|
132
|
+
answer: Arc::new(Mutex::new(Some(answer))),
|
|
133
|
+
wait: Arc::default(),
|
|
134
|
+
query: None,
|
|
135
|
+
})
|
|
136
|
+
}
|
|
137
|
+
|
|
138
|
+
/// A lookup of a name spelling `ip`, answered as `ip` itself.
|
|
139
|
+
fn from_address(ip: IpAddr) -> Arc<Self> {
|
|
140
|
+
Arc::new(Self {
|
|
141
|
+
name: ip.to_string(),
|
|
142
|
+
of_address: true,
|
|
143
|
+
answer: Arc::new(Mutex::new(Some(Ok(vec![ip])))),
|
|
144
|
+
wait: Arc::default(),
|
|
145
|
+
query: None,
|
|
146
|
+
})
|
|
147
|
+
}
|
|
148
|
+
|
|
149
|
+
/// Whether the name spelled an address, answered as itself rather than
|
|
150
|
+
/// at a virtual one.
|
|
151
|
+
pub(crate) fn is_of_address(&self) -> bool {
|
|
152
|
+
self.of_address
|
|
153
|
+
}
|
|
154
|
+
|
|
155
|
+
/// The answer for a task on the reactor, which the lookup's wait queue
|
|
156
|
+
/// wakes once it arrives; the answer is read again once the task is
|
|
157
|
+
/// added, so none arrives unseen.
|
|
158
|
+
pub(crate) fn poll_answer(
|
|
159
|
+
&self,
|
|
160
|
+
cx: &mut Context<'_>,
|
|
161
|
+
) -> Poll<Result<Vec<IpAddr>, LookupError>> {
|
|
162
|
+
if let Some(answer) = self.answer() {
|
|
163
|
+
return Poll::Ready(answer);
|
|
164
|
+
}
|
|
165
|
+
self.wait.add(cx.waker());
|
|
166
|
+
match self.answer() {
|
|
167
|
+
Some(answer) => Poll::Ready(answer),
|
|
168
|
+
None => Poll::Pending,
|
|
169
|
+
}
|
|
170
|
+
}
|
|
171
|
+
|
|
172
|
+
/// The name looked up, normalized.
|
|
173
|
+
pub fn name(&self) -> &str {
|
|
174
|
+
&self.name
|
|
175
|
+
}
|
|
176
|
+
|
|
177
|
+
/// The real addresses the name resolved to, or why it has none; `None`
|
|
178
|
+
/// while the lookup is under way.
|
|
179
|
+
pub fn answer(&self) -> Option<Result<Vec<IpAddr>, LookupError>> {
|
|
180
|
+
self.answer
|
|
181
|
+
.lock()
|
|
182
|
+
.unwrap_or_else(PoisonError::into_inner)
|
|
183
|
+
.clone()
|
|
184
|
+
}
|
|
185
|
+
|
|
186
|
+
/// Allocate the lookup's file, opened as `cred`, as `anon_inode_getfile`
|
|
187
|
+
/// does: a poll finds it readable once the lookup answers.
|
|
188
|
+
pub fn alloc_file(self: &Arc<Self>, cred: &Arc<Cred>) -> File {
|
|
189
|
+
let how = OpenHow {
|
|
190
|
+
read: true,
|
|
191
|
+
nonblock: true,
|
|
192
|
+
..OpenHow::default()
|
|
193
|
+
};
|
|
194
|
+
anon_inode_getfile(Box::new(LookupFile(self.clone())), &how, cred)
|
|
195
|
+
}
|
|
196
|
+
}
|
|
197
|
+
|
|
198
|
+
impl Drop for NameLookup {
|
|
199
|
+
fn drop(&mut self) {
|
|
200
|
+
if let Some(query) = &self.query {
|
|
201
|
+
query.cancel();
|
|
202
|
+
}
|
|
203
|
+
}
|
|
204
|
+
}
|
|
205
|
+
|
|
206
|
+
/// What answers for a lookup's file.
|
|
207
|
+
struct LookupFile(Arc<NameLookup>);
|
|
208
|
+
|
|
209
|
+
impl FileOperations for LookupFile {
|
|
210
|
+
fn poll(&self, _mode: FMode, table: Option<&mut PollTable>) -> PollMask {
|
|
211
|
+
poll_wait(&self.0.wait, table);
|
|
212
|
+
match self.0.answer() {
|
|
213
|
+
Some(_) => PollMask::IN,
|
|
214
|
+
None => PollMask::default(),
|
|
215
|
+
}
|
|
216
|
+
}
|
|
217
|
+
|
|
218
|
+
fn is_stream(&self) -> bool {
|
|
219
|
+
true
|
|
220
|
+
}
|
|
221
|
+
}
|
|
222
|
+
|
|
223
|
+
/// A lookup of `name` in `net`. The name is read as a URL host: one spelling
|
|
224
|
+
/// an address answers that address, with no query, as WIT returns an address
|
|
225
|
+
/// string; an IPv4-mapped one answers its IPv4 address, as WIT never returns a
|
|
226
|
+
/// mapped one. Each entry's `resolve` policy and the endpoints judge any
|
|
227
|
+
/// other, as a DNS proxy judges a query before it forwards one; a refused or
|
|
228
|
+
/// unmatched name answers as NXDOMAIN before any query, as a real one would.
|
|
229
|
+
/// A name the Invocation already translated answers its first real addresses
|
|
230
|
+
/// again, with no query, so a resolver cannot rebind it.
|
|
231
|
+
pub fn resolve(net: &Namespace, name: &str) -> Result<Arc<NameLookup>, LookupError> {
|
|
232
|
+
let name = match Host::parse(name).ok_or(LookupError::InvalidName)? {
|
|
233
|
+
Host::Address(ip) => return Ok(NameLookup::from_address(ip.to_canonical())),
|
|
234
|
+
Host::Name(name) => name,
|
|
235
|
+
};
|
|
236
|
+
if !allows_lookup(net, &name) || !net.ruleset().admits_name(&name) {
|
|
237
|
+
return Ok(NameLookup::with_answer(name, Err(LookupError::NoName)));
|
|
238
|
+
}
|
|
239
|
+
let translated = net.real_addresses_of(&name);
|
|
240
|
+
match translated.is_empty() {
|
|
241
|
+
false => Ok(NameLookup::with_answer(name, Ok(translated))),
|
|
242
|
+
true => NameLookup::start(net.resolver().clone(), name, net.open_connections()),
|
|
243
|
+
}
|
|
244
|
+
}
|
|
245
|
+
|
|
246
|
+
/// Whether every `resolve` policy in `net` lets `name`, normalized, be
|
|
247
|
+
/// looked up.
|
|
248
|
+
pub(crate) fn allows_lookup(net: &Namespace, name: &str) -> bool {
|
|
249
|
+
let request = Name::new(name);
|
|
250
|
+
net.resolve_policies()
|
|
251
|
+
.iter()
|
|
252
|
+
.all(|policy| policy.allows(&request))
|
|
253
|
+
}
|
|
254
|
+
|
|
255
|
+
#[cfg(test)]
|
|
256
|
+
mod tests {
|
|
257
|
+
use std::sync::mpsc;
|
|
258
|
+
|
|
259
|
+
use super::super::connections::open_within;
|
|
260
|
+
use super::super::family::testing::StallsLookups;
|
|
261
|
+
use super::*;
|
|
262
|
+
|
|
263
|
+
// @behavior NW-085
|
|
264
|
+
#[test]
|
|
265
|
+
fn a_dropped_lookup_cancels_its_query_and_gives_both_places_back_at_once() {
|
|
266
|
+
let (started, _) = mpsc::channel();
|
|
267
|
+
let resolver = Arc::new(StallsLookups::new(started));
|
|
268
|
+
let invocation = OpenConnections::new(Some(1));
|
|
269
|
+
let process = OpenConnections::new(Some(1));
|
|
270
|
+
let place = open_within(&invocation, &process).expect("both counts have room");
|
|
271
|
+
let lookup =
|
|
272
|
+
NameLookup::start_holding(resolver.clone(), "slow.test".into(), Arc::new(place))
|
|
273
|
+
.expect("the lookup starts");
|
|
274
|
+
drop(lookup);
|
|
275
|
+
assert_eq!(
|
|
276
|
+
(
|
|
277
|
+
open_within(&invocation, &process).is_some(),
|
|
278
|
+
resolver.cancelled()
|
|
279
|
+
),
|
|
280
|
+
(true, 1),
|
|
281
|
+
"a lookup dropped while its resolver has not answered must cancel the resolver's \
|
|
282
|
+
query and give its place back to the invocation's count and the process's at once"
|
|
283
|
+
);
|
|
284
|
+
}
|
|
285
|
+
}
|
|
@@ -0,0 +1,251 @@
|
|
|
1
|
+
//! A Protocol Family and a Resolver for a Host App's tests: names answer
|
|
2
|
+
//! from a table, a dial reaches only a route it was given, and each question
|
|
3
|
+
//! is recorded so a test reads back what the guest asked. It stands where
|
|
4
|
+
//! `HostInet` stands, beneath every rule, so the rules judge it alike. It
|
|
5
|
+
//! lives in the runtime so the Rust SDK and the Ruby gem hand the guest one
|
|
6
|
+
//! Mock, as neither frontend depends on the other.
|
|
7
|
+
|
|
8
|
+
use std::collections::HashMap;
|
|
9
|
+
use std::future::poll_fn;
|
|
10
|
+
use std::io;
|
|
11
|
+
use std::net::{IpAddr, SocketAddr, TcpStream, UdpSocket};
|
|
12
|
+
use std::sync::{Arc, Mutex, MutexGuard, PoisonError};
|
|
13
|
+
use std::task::{Poll, Waker};
|
|
14
|
+
|
|
15
|
+
use super::family::{is_same_family, HostInet, ProtocolFamily};
|
|
16
|
+
use super::lookup::{LookupError, Resolver, Resolving};
|
|
17
|
+
use crate::errno::CarriedErrno;
|
|
18
|
+
use crate::network::Host;
|
|
19
|
+
use crate::Errno;
|
|
20
|
+
|
|
21
|
+
/// A table of names, routes, and refusals, answering the guest's network in
|
|
22
|
+
/// place of the host's.
|
|
23
|
+
pub struct Mock {
|
|
24
|
+
state: Arc<Mutex<State>>,
|
|
25
|
+
local_addresses: Option<Vec<IpAddr>>,
|
|
26
|
+
}
|
|
27
|
+
|
|
28
|
+
#[derive(Default)]
|
|
29
|
+
struct State {
|
|
30
|
+
answers: HashMap<String, Vec<IpAddr>>,
|
|
31
|
+
routes: HashMap<(IpProtocol, SocketAddr), Dial>,
|
|
32
|
+
/// How many holds each held name has.
|
|
33
|
+
held: HashMap<String, usize>,
|
|
34
|
+
/// The lookups waiting for a hold to drop.
|
|
35
|
+
waiting: Vec<Waker>,
|
|
36
|
+
lookups: Vec<String>,
|
|
37
|
+
dials: Vec<SocketAddr>,
|
|
38
|
+
}
|
|
39
|
+
|
|
40
|
+
/// What a dial to one address does.
|
|
41
|
+
#[derive(Clone)]
|
|
42
|
+
enum Dial {
|
|
43
|
+
To(SocketAddr),
|
|
44
|
+
Refused(Errno),
|
|
45
|
+
}
|
|
46
|
+
|
|
47
|
+
/// The protocol a dial runs over, as Linux's `IPPROTO_TCP` and `IPPROTO_UDP`
|
|
48
|
+
/// name it, which a route keys on. An HTTP request dials over TCP.
|
|
49
|
+
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
|
|
50
|
+
pub enum IpProtocol {
|
|
51
|
+
Tcp,
|
|
52
|
+
Udp,
|
|
53
|
+
}
|
|
54
|
+
|
|
55
|
+
impl Default for Mock {
|
|
56
|
+
/// A table answering no name and dialing nowhere, on a host with no
|
|
57
|
+
/// addresses of its own.
|
|
58
|
+
fn default() -> Self {
|
|
59
|
+
Self {
|
|
60
|
+
state: Arc::default(),
|
|
61
|
+
local_addresses: Some(Vec::new()),
|
|
62
|
+
}
|
|
63
|
+
}
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
impl Mock {
|
|
67
|
+
/// A table whose host holds `addresses` as its own, which the rules
|
|
68
|
+
/// count as local; `None` for a host that cannot say them, so the rules
|
|
69
|
+
/// refuse every connect to a name.
|
|
70
|
+
pub fn with_local_addresses(self, addresses: Option<Vec<IpAddr>>) -> Self {
|
|
71
|
+
Self {
|
|
72
|
+
local_addresses: addresses,
|
|
73
|
+
..self
|
|
74
|
+
}
|
|
75
|
+
}
|
|
76
|
+
|
|
77
|
+
/// Resolve `name` to `addresses` from now on; `InvalidName` for a host
|
|
78
|
+
/// that is no name a guest's lookup asks.
|
|
79
|
+
pub fn resolve_to_addrs(&self, name: &str, addresses: Vec<IpAddr>) -> Result<(), LookupError> {
|
|
80
|
+
let name = to_key(name)?;
|
|
81
|
+
self.state().answers.insert(name, addresses);
|
|
82
|
+
Ok(())
|
|
83
|
+
}
|
|
84
|
+
|
|
85
|
+
/// Dial `to` whenever `from` is dialed over `protocol`.
|
|
86
|
+
pub fn route(&self, protocol: IpProtocol, from: SocketAddr, to: SocketAddr) {
|
|
87
|
+
self.state().routes.insert((protocol, from), Dial::To(to));
|
|
88
|
+
}
|
|
89
|
+
|
|
90
|
+
/// Fail a dial to `addr` over `protocol` with `err`, which the socket
|
|
91
|
+
/// layer answers as a host socket failing with it, alike on every host. A
|
|
92
|
+
/// datagram socket fails as it connects.
|
|
93
|
+
pub fn refuse(&self, protocol: IpProtocol, addr: SocketAddr, err: Errno) {
|
|
94
|
+
self.state()
|
|
95
|
+
.routes
|
|
96
|
+
.insert((protocol, addr), Dial::Refused(err));
|
|
97
|
+
}
|
|
98
|
+
|
|
99
|
+
/// Keep each lookup of `name` waiting until the hold drops, as a
|
|
100
|
+
/// resolver that has not answered; `InvalidName` for a host that is no
|
|
101
|
+
/// name a guest's lookup asks.
|
|
102
|
+
pub fn hold(&self, name: &str) -> Result<Hold<'_>, LookupError> {
|
|
103
|
+
let name = to_key(name)?;
|
|
104
|
+
*self.state().held.entry(name.clone()).or_default() += 1;
|
|
105
|
+
Ok(Hold { mock: self, name })
|
|
106
|
+
}
|
|
107
|
+
|
|
108
|
+
/// Each name the guest's lookups asked, in order.
|
|
109
|
+
pub fn lookups(&self) -> Vec<String> {
|
|
110
|
+
self.state().lookups.clone()
|
|
111
|
+
}
|
|
112
|
+
|
|
113
|
+
/// Each address dialed, in order, routed or not.
|
|
114
|
+
pub fn dialed_addresses(&self) -> Vec<SocketAddr> {
|
|
115
|
+
self.state().dials.clone()
|
|
116
|
+
}
|
|
117
|
+
|
|
118
|
+
/// Where a dial to `addr` over `protocol` goes, recording it.
|
|
119
|
+
fn dial(&self, protocol: IpProtocol, addr: SocketAddr) -> io::Result<SocketAddr> {
|
|
120
|
+
self.state().dials.push(addr);
|
|
121
|
+
self.target_of(protocol, addr)
|
|
122
|
+
}
|
|
123
|
+
|
|
124
|
+
/// Where a dial to `addr` over `protocol` goes.
|
|
125
|
+
fn target_of(&self, protocol: IpProtocol, addr: SocketAddr) -> io::Result<SocketAddr> {
|
|
126
|
+
let dial = self.state().routes.get(&(protocol, addr)).cloned();
|
|
127
|
+
match dial {
|
|
128
|
+
Some(Dial::To(target)) => Ok(target),
|
|
129
|
+
Some(Dial::Refused(err)) => Err(io::Error::other(CarriedErrno(err))),
|
|
130
|
+
None => Err(io::ErrorKind::ConnectionRefused.into()),
|
|
131
|
+
}
|
|
132
|
+
}
|
|
133
|
+
|
|
134
|
+
fn state(&self) -> MutexGuard<'_, State> {
|
|
135
|
+
self.state.lock().unwrap_or_else(PoisonError::into_inner)
|
|
136
|
+
}
|
|
137
|
+
}
|
|
138
|
+
|
|
139
|
+
/// A name held unanswered; dropping it lets each waiting lookup answer.
|
|
140
|
+
pub struct Hold<'a> {
|
|
141
|
+
mock: &'a Mock,
|
|
142
|
+
name: String,
|
|
143
|
+
}
|
|
144
|
+
|
|
145
|
+
impl Drop for Hold<'_> {
|
|
146
|
+
fn drop(&mut self) {
|
|
147
|
+
let mut state = self.mock.state();
|
|
148
|
+
if let Some(count) = state.held.get_mut(&self.name) {
|
|
149
|
+
*count -= 1;
|
|
150
|
+
if *count == 0 {
|
|
151
|
+
state.held.remove(&self.name);
|
|
152
|
+
}
|
|
153
|
+
}
|
|
154
|
+
state.waiting.drain(..).for_each(Waker::wake);
|
|
155
|
+
}
|
|
156
|
+
}
|
|
157
|
+
|
|
158
|
+
impl ProtocolFamily for Mock {
|
|
159
|
+
/// The route's target, through the host's own sockets; an address with
|
|
160
|
+
/// no route is refused, so nothing unrouted reaches the host network.
|
|
161
|
+
fn connect(&self, addr: SocketAddr) -> io::Result<TcpStream> {
|
|
162
|
+
HostInet.connect(self.dial(IpProtocol::Tcp, addr)?)
|
|
163
|
+
}
|
|
164
|
+
|
|
165
|
+
/// The route's target over UDP, refused as it connects when there is
|
|
166
|
+
/// none, so every host answers alike where one would wait for a peer's
|
|
167
|
+
/// ICMP reply.
|
|
168
|
+
fn connect_datagram(&self, addr: SocketAddr) -> io::Result<UdpSocket> {
|
|
169
|
+
HostInet.connect_datagram(self.dial(IpProtocol::Udp, addr)?)
|
|
170
|
+
}
|
|
171
|
+
|
|
172
|
+
/// The route's target when it lies in the socket's family, recorded as a
|
|
173
|
+
/// dial; one in another family is left for the fresh socket to dial, and
|
|
174
|
+
/// recorded there.
|
|
175
|
+
fn route_datagram(
|
|
176
|
+
&self,
|
|
177
|
+
local: SocketAddr,
|
|
178
|
+
addr: SocketAddr,
|
|
179
|
+
) -> io::Result<Option<SocketAddr>> {
|
|
180
|
+
match self.target_of(IpProtocol::Udp, addr) {
|
|
181
|
+
Ok(target) if !is_same_family(local, target) => Ok(None),
|
|
182
|
+
_ => self.dial(IpProtocol::Udp, addr).map(Some),
|
|
183
|
+
}
|
|
184
|
+
}
|
|
185
|
+
|
|
186
|
+
fn local_addresses(&self) -> io::Result<Vec<IpAddr>> {
|
|
187
|
+
self.local_addresses
|
|
188
|
+
.clone()
|
|
189
|
+
.ok_or_else(|| io::ErrorKind::Unsupported.into())
|
|
190
|
+
}
|
|
191
|
+
}
|
|
192
|
+
|
|
193
|
+
impl Resolver for Mock {
|
|
194
|
+
/// The table's answer for `name` once no hold keeps it; a name the table
|
|
195
|
+
/// does not hold resolves to nothing.
|
|
196
|
+
fn resolve(&self, name: &str) -> Resolving {
|
|
197
|
+
self.state().lookups.push(name.to_string());
|
|
198
|
+
let Ok(key) = to_key(name) else {
|
|
199
|
+
return Box::pin(std::future::ready(Ok(Vec::new())));
|
|
200
|
+
};
|
|
201
|
+
let state = self.state.clone();
|
|
202
|
+
Box::pin(poll_fn(move |cx| {
|
|
203
|
+
let mut state = state.lock().unwrap_or_else(PoisonError::into_inner);
|
|
204
|
+
if state.held.contains_key(&key) {
|
|
205
|
+
state.waiting.push(cx.waker().clone());
|
|
206
|
+
return Poll::Pending;
|
|
207
|
+
}
|
|
208
|
+
Poll::Ready(Ok(state.answers.get(&key).cloned().unwrap_or_default()))
|
|
209
|
+
}))
|
|
210
|
+
}
|
|
211
|
+
}
|
|
212
|
+
|
|
213
|
+
/// A name as the table keys it, read as a guest's lookup reads one: in any
|
|
214
|
+
/// case, with or without its root, and an IDN as its A-label.
|
|
215
|
+
fn to_key(name: &str) -> Result<String, LookupError> {
|
|
216
|
+
match Host::parse(name) {
|
|
217
|
+
Some(Host::Name(name)) => Ok(name),
|
|
218
|
+
_ => Err(LookupError::InvalidName),
|
|
219
|
+
}
|
|
220
|
+
}
|
|
221
|
+
|
|
222
|
+
#[cfg(test)]
|
|
223
|
+
mod tests {
|
|
224
|
+
use std::task::Context;
|
|
225
|
+
|
|
226
|
+
use super::*;
|
|
227
|
+
|
|
228
|
+
#[test]
|
|
229
|
+
fn a_name_held_twice_waits_until_both_holds_drop() {
|
|
230
|
+
let mock = Mock::default();
|
|
231
|
+
mock.resolve_to_addrs("held.test", vec![IpAddr::from([93, 184, 216, 34])])
|
|
232
|
+
.unwrap();
|
|
233
|
+
let outer = mock.hold("held.test").unwrap();
|
|
234
|
+
let inner = mock.hold("held.test").unwrap();
|
|
235
|
+
let mut resolving = mock.resolve("held.test");
|
|
236
|
+
let mut cx = Context::from_waker(Waker::noop());
|
|
237
|
+
drop(inner);
|
|
238
|
+
let waited = resolving.as_mut().poll(&mut cx).is_pending();
|
|
239
|
+
drop(outer);
|
|
240
|
+
let answered = match resolving.as_mut().poll(&mut cx) {
|
|
241
|
+
Poll::Ready(found) => found.ok().map(|found| found.len()),
|
|
242
|
+
Poll::Pending => None,
|
|
243
|
+
};
|
|
244
|
+
assert_eq!(
|
|
245
|
+
(waited, answered),
|
|
246
|
+
(true, Some(1)),
|
|
247
|
+
"a lookup of a name held twice must wait while either hold lives, and answer once both \
|
|
248
|
+
have dropped"
|
|
249
|
+
);
|
|
250
|
+
}
|
|
251
|
+
}
|