95af2a0aca
On my machine the program would not even parse the SIZE from the server correctly without this change.
127 lines
3.9 KiB
Rust
127 lines
3.9 KiB
Rust
extern crate bufstream;
|
|
extern crate regex;
|
|
|
|
use std::io::prelude::*;
|
|
use std::io::{Error, ErrorKind};
|
|
use std::net::TcpStream;
|
|
|
|
use self::bufstream::BufStream;
|
|
use self::regex::Regex;
|
|
|
|
use color::Color;
|
|
|
|
// The default buffer size for reading the client stream.
|
|
// - Big enough so we don't have to expand
|
|
// - Small enough to not take up to much memory
|
|
const CMD_READ_BUFFER_SIZE: usize = 32;
|
|
|
|
// The response format of the screen size from a pixelflut server.
|
|
const PIX_SERVER_SIZE_REGEX: &str = r"^(?i)\s*SIZE\s+([[:digit:]]+)\s+([[:digit:]]+)\s*$";
|
|
|
|
/// A pixelflut client.
|
|
///
|
|
/// This client uses a stream to talk to a pixelflut panel.
|
|
/// It allows to write pixels to the panel, and read some status.
|
|
///
|
|
/// The client provides an interface for other logic to easily talk
|
|
/// to the pixelflut panel.
|
|
pub struct Client {
|
|
stream: BufStream<TcpStream>,
|
|
}
|
|
|
|
impl Client {
|
|
/// Create a new client instance.
|
|
pub fn new(stream: TcpStream) -> Client {
|
|
Client {
|
|
stream: BufStream::new(stream),
|
|
}
|
|
}
|
|
|
|
/// Create a new client instane from the given host, and connect to it.
|
|
pub fn connect(host: String) -> Result<Client, Error> {
|
|
// Create a new stream, and instantiate the client
|
|
Ok(Client::new(create_stream(host)?))
|
|
}
|
|
|
|
/// Write a pixel to the given stream.
|
|
pub fn write_pixel(&mut self, x: u32, y: u32, color: Color) -> Result<(), Error> {
|
|
// Write the command to set a pixel
|
|
self.write_command(&format!("PX {} {} {}", x, y, color.as_hex()))
|
|
}
|
|
|
|
/// Read the size of the screen.
|
|
pub fn read_screen_size(&mut self) -> Result<(u32, u32), Error> {
|
|
// Read the screen size
|
|
let data = self
|
|
.write_read_command("SIZE".into())
|
|
.expect("Failed to read screen size");
|
|
|
|
// Build a regex to parse the screen size
|
|
let re = Regex::new(PIX_SERVER_SIZE_REGEX).unwrap();
|
|
|
|
// Find captures in the data, return the result
|
|
match re.captures(&data) {
|
|
Some(matches) => Ok((
|
|
matches[1]
|
|
.parse::<u32>()
|
|
.expect("Failed to parse screen width, received malformed data"),
|
|
matches[2]
|
|
.parse::<u32>()
|
|
.expect("Failed to parse screen height, received malformed data"),
|
|
)),
|
|
None => Err(Error::new(
|
|
ErrorKind::Other,
|
|
"Failed to parse screen size, received malformed data",
|
|
)),
|
|
}
|
|
}
|
|
|
|
/// Write the given command to the given stream.
|
|
fn write_command(&mut self, cmd: &str) -> Result<(), Error> {
|
|
// Write the pixels and a new line
|
|
self.stream.write_all(cmd.as_bytes())?;
|
|
self.stream.write_all(b"\n")?;
|
|
|
|
// Flush, make sure to clear the send buffer
|
|
// TODO: only flush each 100 pixels?
|
|
// TODO: make flushing configurable?
|
|
// TODO: make buffer size configurable?
|
|
self.stream
|
|
.flush()?;
|
|
|
|
// Everything seems to be ok
|
|
Ok(())
|
|
}
|
|
|
|
/// Write the given command to the given stream, and read the output.
|
|
fn write_read_command(&mut self, cmd: &str) -> Result<String, Error> {
|
|
// Write the command
|
|
self.write_command(cmd)?;
|
|
|
|
// Flush the pipe, ensure the command is actually sent
|
|
self.stream.flush()?;
|
|
|
|
// Read the output
|
|
// TODO: this operation may get stuck (?) if nothing is received from the server
|
|
let mut buffer = String::with_capacity(CMD_READ_BUFFER_SIZE);
|
|
self.stream.read_line(&mut buffer)?;
|
|
|
|
// Return the read string
|
|
Ok(buffer)
|
|
}
|
|
}
|
|
|
|
impl Drop for Client {
|
|
/// Nicely drop the connection when the client is disconnected.
|
|
fn drop(&mut self) {
|
|
let _ = self.write_command("\nQUIT".into());
|
|
}
|
|
}
|
|
|
|
/// Create a stream to talk to the pixelflut server.
|
|
///
|
|
/// The stream is returned as result.
|
|
fn create_stream(host: String) -> Result<TcpStream, Error> {
|
|
TcpStream::connect(host)
|
|
}
|