Files
noah 79c6c72fd6
main-release-gate / verify-and-release (push) Failing after 1m35s
Keep buffered Stratum partial line deadline across drains
2026-10-16 04:02:03 -06:00

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();
}