65cc7bb286
This is a port of something I found when developing some changes in watchman. When doing something like: `some win32 command | wsl something` That pipe doesn't look like a normal win32 pipe and we'd end up treating it like a socket, but it isn't really a socket either. |
||
|---|---|---|
| .. | ||
| src | ||
| Cargo.toml | ||
| README.md | ||
The purpose of this crate is to make it a bit more ergonomic for portable
applications that need to work with the platform level RawFd and
RawHandle types.
Rather than conditionally using RawFd and RawHandle, the FileDescriptor
type can be used to manage ownership, duplicate, read and write.
FileDescriptor
This is a bit of a contrived example, but demonstrates how to avoid
the conditional code that would otherwise be required to deal with
calling as_raw_fd and as_raw_handle:
use filedescriptor::{FileDescriptor, FromRawFileDescriptor};
use std::io::Write;
fn get_stdout() -> anyhow::Result<FileDescriptor> {
let stdout = std::io::stdout();
let handle = stdout.lock();
FileDescriptor::dup(&handle)
}
fn print_something() -> anyhow::Result<()> {
get_stdout()?.write(b"hello")?;
Ok(())
}
Pipe
The Pipe type makes it more convenient to create a pipe and manage
the lifetime of both the read and write ends of that pipe.
use filedescriptor::Pipe;
use std::io::{Read, Write};
use anyhow::Error;
let mut pipe = Pipe::new()?;
pipe.write.write(b"hello")?;
drop(pipe.write);
let mut s = String::new();
pipe.read.read_to_string(&mut s)?;
assert_eq!(s, "hello");
Socketpair
The socketpair function returns a pair of connected SOCK_STREAM
sockets and functions both on posix and windows systems.
use std::io::{Read, Write};
use anyhow::Error;
let (mut a, mut b) = filedescriptor::socketpair()?;
a.write(b"hello")?;
drop(a);
let mut s = String::new();
b.read_to_string(&mut s)?;
assert_eq!(s, "hello");
Polling
The mio crate offers powerful and scalable IO multiplexing, but there
are some situations where mio doesn't fit. The filedescriptor crate
offers a poll(2) compatible interface suitable for testing the readiness
of a set of file descriptors. On unix systems this is a very thin wrapper
around poll(2), except on macOS where it is actually a wrapper around
the select(2) interface. On Windows systems the winsock WSAPoll
function is used instead.
use filedescriptor::*;
use anyhow::Error;
use std::time::Duration;
use std::io::{Read, Write};
let (mut a, mut b) = filedescriptor::socketpair()?;
let mut poll_array = [pollfd {
fd: a.as_socket_descriptor(),
events: POLLIN,
revents: 0
}];
// sleeps for 20 milliseconds because `a` is not yet ready
assert_eq!(poll(&mut poll_array, Some(Duration::from_millis(20)))?, 0);
b.write(b"hello")?;
// Now a is ready for read
assert_eq!(poll(&mut poll_array, Some(Duration::from_millis(20)))?, 1);