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
use anyhow::Context;
use interprocess::local_socket::{LocalSocketListener, LocalSocketStream, NameTypeSupport};
use std::{
io::{self, prelude::*, BufReader},
sync::mpsc::Sender,
};
pub fn main(notify: Sender<()>) -> anyhow::Result<()> {
// Define a function that checks for errors in incoming connections. We'll use this to filter
// through connections that fail on initialization for one reason or another.
fn handle_error(conn: io::Result<LocalSocketStream>) -> Option<LocalSocketStream> {
match conn {
Ok(c) => Some(c),
Err(e) => {
eprintln!("Incoming connection failed: {}", e);
None
}
}
}
// Pick a name. There isn't a helper function for this, mostly because it's largely unnecessary:
// in Rust, `match` is your concise, readable and expressive decision making construct.
let name = {
// This scoping trick allows us to nicely contain the import inside the `match`, so that if
// any imports of variants named `Both` happen down the line, they won't collide with the
// enum we're working with here. Maybe someone should make a macro for this.
use NameTypeSupport::*;
match NameTypeSupport::query() {
OnlyPaths => "/tmp/example.sock",
OnlyNamespaced | Both => "@example.sock",
}
};
// Bind our listener.
let listener = match LocalSocketListener::bind(name) {
Err(e) if e.kind() == io::ErrorKind::AddrInUse => {
// One important problem that is easy to handle improperly (or not at all) is the
// "corpse sockets" that are left when a program that uses a file-type socket name
// terminates its socket server without deleting the file. There's no single strategy
// for handling this kind of address-already-occupied error. Services that are supposed
// to only exist as a single instance running on a system should check if another
// instance is actually running, and if not, delete the socket file. In this example,
// we leave this up to the user, but in a real application, you usually don't want to do
// that.
eprintln!(
"\
Error: could not start server because the socket file is occupied. Please check if {} is in use by \
another process and try again.",
name,
);
return Err(e.into());
}
x => x?,
};
println!("Server running at {}", name);
// Stand-in for the syncronization used, if any, between the client and the server.
let _ = notify.send(());
// Preemptively allocate a sizeable buffer for reading at a later moment. This size should be
// enough and should be easy to find for the allocator. Since we only have one concurrent
// client, there's no need to reallocate the buffer repeatedly.
let mut buffer = String::with_capacity(128);
for conn in listener.incoming().filter_map(handle_error) {
// Wrap the connection into a buffered reader right away
// so that we could read a single line out of it.
let mut conn = BufReader::new(conn);
println!("Incoming connection!");
// Since our client example writes first, the server should read a line and only then send a
// response. Otherwise, because reading and writing on a connection cannot be simultaneous
// without threads or async, we can deadlock the two processes by having both sides wait for
// the write buffer to be emptied by the other.
conn.read_line(&mut buffer)
.context("Socket receive failed")?;
// Now that the read has come through and the client is waiting on the server's write, do
// it. (`.get_mut()` is to get the writer, `BufReader` doesn't implement a pass-through
// `Write`.)
conn.get_mut().write_all(b"Hello from server!\n")?;
// Print out the result, getting the newline for free!
print!("Client answered: {}", buffer);
// Let's add an exit condition to shut the server down gracefully.
if buffer == "stop\n" {
break;
}
// Clear the buffer so that the next iteration will display new data instead of messages
// stacking on top of one another.
buffer.clear();
}
Ok(())
}