250 lines
9.8 KiB
Rust
250 lines
9.8 KiB
Rust
// SPDX-License-Identifier: MIT
|
|
use alkane_os::stratum_v1::MAX_POOL_LINE_BYTES;
|
|
use alkane_os::stratum_wire::{
|
|
authorize_request, configure_request, subscribe_request, HandshakeError, StratumWire, WireError,
|
|
};
|
|
use serde_json::Value;
|
|
use std::io::{BufRead, BufReader, Read, Write};
|
|
use std::net::TcpListener;
|
|
use std::thread;
|
|
use std::time::Duration;
|
|
|
|
#[test]
|
|
fn request_frames_escape_pool_credentials_and_advertise_supported_bits() {
|
|
let configure: Value = serde_json::from_str(&configure_request(1)).unwrap();
|
|
assert_eq!(configure["method"], "mining.configure");
|
|
assert_eq!(configure["params"][1]["version-rolling.mask"], "1fffe000");
|
|
assert_eq!(configure["params"][0][1], "subscribe-extranonce");
|
|
let subscribe: Value =
|
|
serde_json::from_str(&subscribe_request(2, "alkane-os/0.1").unwrap()).unwrap();
|
|
assert_eq!(subscribe["params"][0], "alkane-os/0.1");
|
|
let authorized = authorize_request(3, "worker\"name", "secret\nvalue").unwrap();
|
|
assert_eq!(authorized.as_bytes().last(), Some(&b'\n'));
|
|
let authorize: Value = serde_json::from_str(&authorized).unwrap();
|
|
assert_eq!(authorize["params"][0], "worker\"name");
|
|
assert_eq!(authorize["params"][1], "secret\nvalue");
|
|
assert!(matches!(
|
|
subscribe_request(2, ""),
|
|
Err(WireError::InvalidRequest)
|
|
));
|
|
assert!(matches!(
|
|
authorize_request(3, "", "pass"),
|
|
Err(WireError::InvalidRequest)
|
|
));
|
|
}
|
|
|
|
#[test]
|
|
fn loopback_frames_preserve_pipelined_lines_and_reject_invalid_sends() {
|
|
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
|
|
let address = listener.local_addr().unwrap();
|
|
let server = thread::spawn(move || {
|
|
let (mut stream, _) = listener.accept().unwrap();
|
|
stream.write_all(b"{\"id\":1}\n{\"id\":2}\n").unwrap();
|
|
let mut request = [0_u8; 3];
|
|
stream.read_exact(&mut request).unwrap();
|
|
assert_eq!(&request, b"{}\n");
|
|
});
|
|
let mut wire = StratumWire::connect(address, Duration::from_secs(2)).unwrap();
|
|
assert_eq!(wire.read_line().unwrap(), b"{\"id\":1}\n");
|
|
assert_eq!(wire.read_line().unwrap(), b"{\"id\":2}\n");
|
|
assert!(matches!(
|
|
wire.send_line(b"bad\nline\n"),
|
|
Err(WireError::InvalidRequest)
|
|
));
|
|
wire.send_line(b"{}\n").unwrap();
|
|
server.join().unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn oversized_pool_line_poison_closes_the_connection() {
|
|
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
|
|
let address = listener.local_addr().unwrap();
|
|
let server = thread::spawn(move || {
|
|
let (mut stream, _) = listener.accept().unwrap();
|
|
let mut line = vec![b'a'; MAX_POOL_LINE_BYTES];
|
|
line.push(b'\n');
|
|
let _ = stream.write_all(&line);
|
|
});
|
|
let mut wire = StratumWire::connect(address, Duration::from_secs(2)).unwrap();
|
|
assert!(matches!(wire.read_line(), Err(WireError::LineTooLong)));
|
|
assert!(matches!(wire.read_line(), Err(WireError::Closed)));
|
|
server.join().unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn trickled_pool_line_hits_the_absolute_deadline() {
|
|
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
|
|
let address = listener.local_addr().unwrap();
|
|
let server = thread::spawn(move || {
|
|
let (mut stream, _) = listener.accept().unwrap();
|
|
for byte in b"{123}\n" {
|
|
if stream.write_all(&[*byte]).is_err() {
|
|
break;
|
|
}
|
|
thread::sleep(Duration::from_millis(60));
|
|
}
|
|
});
|
|
let mut wire = StratumWire::connect(address, Duration::from_millis(130)).unwrap();
|
|
assert!(matches!(wire.read_line(), Err(WireError::Timeout)));
|
|
assert!(matches!(wire.send_line(b"{}\n"), Err(WireError::Closed)));
|
|
server.join().unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn buffered_complete_lines_do_not_extend_a_partial_line_deadline() {
|
|
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
|
|
let address = listener.local_addr().unwrap();
|
|
let server = thread::spawn(move || {
|
|
let (mut stream, _) = listener.accept().unwrap();
|
|
stream.write_all(b"first\nsecond\nunfinished").unwrap();
|
|
thread::sleep(Duration::from_secs(3));
|
|
});
|
|
let mut wire = StratumWire::connect(address, Duration::from_secs(2)).unwrap();
|
|
let first = loop {
|
|
if let Some(line) = wire.try_read_line().unwrap() {
|
|
break line;
|
|
}
|
|
};
|
|
assert_eq!(first, b"first\n");
|
|
thread::sleep(Duration::from_millis(1300));
|
|
assert_eq!(wire.try_read_line().unwrap(), Some(b"second\n".to_vec()));
|
|
thread::sleep(Duration::from_millis(800));
|
|
assert!(matches!(wire.try_read_line(), Err(WireError::Timeout)));
|
|
assert!(wire.is_closed());
|
|
server.join().unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn idle_timeout_keeps_connection_available_for_later_messages() {
|
|
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
|
|
let address = listener.local_addr().unwrap();
|
|
let (release, wait) = std::sync::mpsc::channel();
|
|
let server = thread::spawn(move || {
|
|
let (mut stream, _) = listener.accept().unwrap();
|
|
wait.recv().unwrap();
|
|
stream
|
|
.write_all(b"{\"id\":null,\"method\":\"mining.set_difficulty\",\"params\":[1]}\n")
|
|
.unwrap();
|
|
});
|
|
let mut wire = StratumWire::connect(address, Duration::from_millis(130)).unwrap();
|
|
assert!(matches!(wire.read_line(), Err(WireError::Timeout)));
|
|
release.send(()).unwrap();
|
|
assert_eq!(
|
|
serde_json::from_slice::<Value>(&wire.read_line().unwrap()).unwrap()["method"],
|
|
"mining.set_difficulty"
|
|
);
|
|
server.join().unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn handshake_preserves_early_notifications_and_authorizes_worker() {
|
|
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
|
|
let address = listener.local_addr().unwrap();
|
|
let server = thread::spawn(move || {
|
|
let (mut stream, _) = listener.accept().unwrap();
|
|
let mut input = BufReader::new(stream.try_clone().unwrap());
|
|
let mut line = String::new();
|
|
input.read_line(&mut line).unwrap();
|
|
assert_eq!(
|
|
serde_json::from_str::<Value>(&line).unwrap()["method"],
|
|
"mining.configure"
|
|
);
|
|
stream.write_all(b"{\"id\":1,\"result\":{\"version-rolling\":true,\"version-rolling.mask\":\"1fffe000\",\"subscribe-extranonce\":true},\"error\":null}\n").unwrap();
|
|
line.clear();
|
|
input.read_line(&mut line).unwrap();
|
|
assert_eq!(
|
|
serde_json::from_str::<Value>(&line).unwrap()["method"],
|
|
"mining.subscribe"
|
|
);
|
|
stream.write_all(b"{\"id\":null,\"method\":\"mining.set_difficulty\",\"params\":[1]}\n{\"id\":2,\"result\":[[],\"01020304\",4],\"error\":null}\n").unwrap();
|
|
line.clear();
|
|
input.read_line(&mut line).unwrap();
|
|
assert_eq!(
|
|
serde_json::from_str::<Value>(&line).unwrap()["method"],
|
|
"mining.authorize"
|
|
);
|
|
stream
|
|
.write_all(b"{\"id\":3,\"result\":true,\"error\":null}\n")
|
|
.unwrap();
|
|
});
|
|
let mut wire = StratumWire::connect(address, Duration::from_secs(2)).unwrap();
|
|
let result = wire
|
|
.handshake(
|
|
"alkane-os/0.1",
|
|
"miner.worker",
|
|
"password",
|
|
Duration::from_secs(2),
|
|
)
|
|
.unwrap();
|
|
assert_eq!(result.subscription.extranonce1, [1, 2, 3, 4]);
|
|
assert_eq!(result.subscription.extranonce2_size, 4);
|
|
assert!(result.configure.subscribe_extranonce);
|
|
assert_eq!(result.configure.version_mask.unwrap().bits(), 0x1fff_e000);
|
|
assert_eq!(result.early_notifications.len(), 1);
|
|
assert_eq!(
|
|
serde_json::from_slice::<Value>(&result.early_notifications[0]).unwrap()["method"],
|
|
"mining.set_difficulty"
|
|
);
|
|
server.join().unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn rejected_worker_closes_the_handshake_connection() {
|
|
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
|
|
let address = listener.local_addr().unwrap();
|
|
let server = thread::spawn(move || {
|
|
let (mut stream, _) = listener.accept().unwrap();
|
|
let mut input = BufReader::new(stream.try_clone().unwrap());
|
|
let mut line = String::new();
|
|
input.read_line(&mut line).unwrap();
|
|
stream.write_all(b"{\"id\":1,\"result\":{\"version-rolling\":false,\"subscribe-extranonce\":false},\"error\":null}\n").unwrap();
|
|
line.clear();
|
|
input.read_line(&mut line).unwrap();
|
|
stream
|
|
.write_all(b"{\"id\":2,\"result\":[[],\"01020304\",4],\"error\":null}\n")
|
|
.unwrap();
|
|
line.clear();
|
|
input.read_line(&mut line).unwrap();
|
|
stream
|
|
.write_all(b"{\"id\":3,\"result\":false,\"error\":[24,\"unauthorized\"]}\n")
|
|
.unwrap();
|
|
});
|
|
let mut wire = StratumWire::connect(address, Duration::from_secs(2)).unwrap();
|
|
assert!(matches!(
|
|
wire.handshake("alkane-os/0.1", "bad", "password", Duration::from_secs(2)),
|
|
Err(HandshakeError::Rejected)
|
|
));
|
|
assert!(matches!(wire.read_line(), Err(WireError::Closed)));
|
|
server.join().unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn wrong_handshake_reply_id_is_rejected_and_connection_closed() {
|
|
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
|
|
let address = listener.local_addr().unwrap();
|
|
let server = thread::spawn(move || {
|
|
let (mut stream, _) = listener.accept().unwrap();
|
|
let mut line = String::new();
|
|
BufReader::new(stream.try_clone().unwrap())
|
|
.read_line(&mut line)
|
|
.unwrap();
|
|
stream
|
|
.write_all(b"{\"id\":9,\"result\":true,\"error\":null}\n")
|
|
.unwrap();
|
|
});
|
|
let mut wire = StratumWire::connect(address, Duration::from_secs(2)).unwrap();
|
|
assert!(matches!(
|
|
wire.handshake(
|
|
"alkane-os/0.1",
|
|
"miner.worker",
|
|
"password",
|
|
Duration::from_secs(2)
|
|
),
|
|
Err(HandshakeError::Pool(
|
|
alkane_os::stratum_v1::PoolMessageError::WrongMessage
|
|
))
|
|
));
|
|
assert!(matches!(wire.read_line(), Err(WireError::Closed)));
|
|
server.join().unwrap();
|
|
}
|