1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
//! Async client for the shep daemon: connect-or-spawn state machine, typed
//! wrappers for every RPC verb, and event-bus subscription streams. This is
//! the programmatic API embedders use; the CLI is a thin consumer of it.
//!
//! Re-exports [`shep_core`] so downstream users need a single dependency.
//!
//! # Quick start
//! ```
//! use shep_client::shep_core::prelude::MemSize;
//!
//! let limit: MemSize = "512M".parse().unwrap();
//! assert_eq!(limit.bytes(), 512 << 20);
//! ```
//!
//! Module-by-module design: `docs/systematic-refactor/refactor-workspace/map.md`.
// the `DogConfig` derive expands to `impl ::shep_client::dogs::DogConfig`,
// a path this crate has no other way to name for its own tests
extern crate self as shep_client;
// portable: `connection` names `shep_core::transport::ClientStream`, not
// `tokio::net::UnixStream`, so the OS choice is made one crate down.
// `spawn`'s exit-code contract reads `ExitStatus::code()`, portable already.
// public: a dog is a third-party binary, so this module is the API it's
// written against; kept as a module rather than flattened, like `spawn`
// public module, not a flattened re-export, so `spawn::DAEMON_ALREADY_RUNNING`
// reads as a qualified cross-crate contract. Plain `//`, not `///`: an outer
// doc on a `mod` item merges into the crate root and breaks this module's
// own intra-doc links.
pub use ;
pub use ;
pub use ;
/// The trait [`EventStream`] implements.
///
/// Re-exported because there is no stable `core::stream::Stream`, and this
/// trait is otherwise unnameable in a caller's own bound without a direct
/// `futures-util` dependency. Pulling one event at a time needs no import:
/// [`EventStream::next`] is an inherent method. Only the trait itself is
/// re-exported, not `StreamExt`'s combinators.
///
/// # Example
///
/// Writing the bound with no `futures-util` in the caller's own manifest:
///
/// ```
/// use shep_client::{EventStream, Stream};
///
/// fn _pending_hint<S: Stream>(stream: &S) -> Option<usize> {
/// stream.size_hint().1
/// }
///
/// // And the type that bound exists to accept. A live one comes from
/// // `Client::subscribe`, which needs a daemon; naming it does not.
/// fn _accepts(events: &EventStream) -> Option<usize> {
/// _pending_hint(events)
/// }
/// ```
pub use Stream;
pub use ;
// Portable for the same reason as `connection` above: every fake here binds
// a `shep_core::transport::Listener` rather than a `UnixListener`.
pub use shep_core;
/// The wire protocol this client speaks, re-exported from
/// [`shep_core::protocol::PROTOCOL_VERSION`].
///
/// Reachable from this crate's own root because a dog depends on this
/// crate and nothing else, and `docs/dogs.md` asks every dog to print it.
///
/// A re-export rather than a copy: a second definition here could
/// disagree with the value the handshake actually compares.
pub use PROTOCOL_VERSION;