use std::{
convert::Infallible,
error::Error,
io,
net::SocketAddr,
sync::atomic::{AtomicBool, Ordering},
};
use bornera_core::{FrameDecoder, MatchKey, RetainedBytes};
use calandria::{Interest, Readiness, ResourceOwnerId, Retained, Span, WaitOutcome};
use mio::{Registry, Token, event::Source};
use crate::{
ConnectionPulseHandle, ConnectionSet, ConnectionSetConfig, InboundClassifier,
RegisteredTransport, SlotTransport, TcpSocketPolicy, TcpTransport, TransportBudget,
TransportConnector, TransportError, TransportPressure, TransportProgress,
};
#[path = "set_connect_test/config.rs"]
mod config;
use config::{connection_config, set_limits, slot_limits};
static SOCKET_ATTEMPTED: AtomicBool = AtomicBool::new(false);
pub(crate) fn reset_socket_attempt() {
SOCKET_ATTEMPTED.store(false, Ordering::Relaxed);
}
pub(crate) fn socket_attempted() -> bool {
SOCKET_ATTEMPTED.load(Ordering::Relaxed)
}
#[derive(Debug)]
pub(crate) struct RecordSocketAttempt;
impl TransportConnector for RecordSocketAttempt {
type Transport = TcpTransport;
fn connect(
self,
_address: SocketAddr,
_limits: crate::TransportLimits,
) -> io::Result<Self::Transport> {
SOCKET_ATTEMPTED.store(true, Ordering::Relaxed);
Err(io::Error::other("capacity check acquired a socket"))
}
}
#[test]
fn custom_transport_registers_its_initial_interest() -> Result<(), Box<dyn Error>> {
let mut set: ConnectionSet<Decoder, Classifier, TestRegisteredTransport> = ConnectionSet::new(
ConnectionSetConfig::new(ResourceOwnerId::new(81)),
set_limits(),
)?;
let token = set.connect_with(
connection_config(),
slot_limits()?,
Decoder,
Classifier,
TestConnector,
)?;
let transport = set
.entry(token)?
.transport
.as_ref()
.ok_or_else(|| io::Error::other("registered transport disappeared"))?;
assert!(transport.registered_readable);
assert!(!transport.registered_writable);
Ok(())
}
#[test]
fn independent_pulse_domains_cannot_strand_selector_work() -> Result<(), Box<dyn Error>> {
fn assert_send_sync<T: Send + Sync>() {}
assert_send_sync::<ConnectionPulseHandle>();
let mut set: ConnectionSet<Decoder, Classifier> = ConnectionSet::new(
ConnectionSetConfig::new(ResourceOwnerId::new(82)),
set_limits(),
)?;
let first = set.pulse_handle();
let second = first.clone();
second.pulse()?;
assert_eq!(set.poll_io(Span::ZERO)?, WaitOutcome::Notified);
first.pulse()?;
assert_eq!(set.poll_io(Span::ZERO)?, WaitOutcome::Notified);
Ok(())
}
#[derive(Debug)]
struct TestConnector;
impl TransportConnector for TestConnector {
type Transport = TestRegisteredTransport;
fn connect(
self,
_address: SocketAddr,
_limits: crate::TransportLimits,
) -> io::Result<Self::Transport> {
Ok(TestRegisteredTransport {
open: false,
registered_readable: false,
registered_writable: false,
})
}
}
#[derive(Debug)]
struct TestRegisteredTransport {
open: bool,
registered_readable: bool,
registered_writable: bool,
}
impl io::Read for TestRegisteredTransport {
fn read(&mut self, _buffer: &mut [u8]) -> io::Result<usize> {
Err(io::ErrorKind::WouldBlock.into())
}
}
impl io::Write for TestRegisteredTransport {
fn write(&mut self, _buffer: &[u8]) -> io::Result<usize> {
Err(io::ErrorKind::WouldBlock.into())
}
fn flush(&mut self) -> io::Result<()> {
Ok(())
}
}
impl SlotTransport for TestRegisteredTransport {
fn drive_establishment(
&mut self,
_policy: TcpSocketPolicy,
_budget: TransportBudget,
) -> Result<TransportProgress, TransportError> {
self.open = true;
Ok(TransportProgress::operation())
}
fn drive_transport(
&mut self,
_budget: TransportBudget,
) -> Result<TransportProgress, TransportError> {
Ok(TransportProgress::IDLE)
}
fn begin_shutdown(
&mut self,
_budget: TransportBudget,
) -> Result<TransportProgress, TransportError> {
Ok(TransportProgress::operation())
}
fn can_establish(&self) -> bool {
!self.open
}
fn has_transport_work(&self) -> bool {
false
}
fn is_shutdown_complete(&self) -> bool {
true
}
fn is_open(&self) -> bool {
self.open
}
fn can_read(&self) -> bool {
false
}
fn can_write(&self) -> bool {
false
}
fn desired_interest(&self, _has_writes: bool) -> Interest {
Interest::READABLE
}
fn pressure(&self) -> TransportPressure {
TransportPressure::ZERO
}
fn pressure_limit(&self) -> crate::TransportLimits {
crate::TransportLimits::new(calandria::RetainedBytes::ZERO)
}
fn clear_read(&mut self) {}
fn clear_write(&mut self) {}
}
impl RegisteredTransport for TestRegisteredTransport {
fn observe_readiness(&mut self, _readiness: Readiness) {}
}
impl Source for TestRegisteredTransport {
fn register(
&mut self,
_registry: &Registry,
_token: Token,
interests: mio::Interest,
) -> io::Result<()> {
self.registered_readable = interests.is_readable();
self.registered_writable = interests.is_writable();
Ok(())
}
fn reregister(
&mut self,
registry: &Registry,
token: Token,
interests: mio::Interest,
) -> io::Result<()> {
self.register(registry, token, interests)
}
fn deregister(&mut self, _registry: &Registry) -> io::Result<()> {
Ok(())
}
}
#[derive(Debug)]
struct Decoder;
impl FrameDecoder for Decoder {
type Frame = Frame;
type Error = Infallible;
fn feed(&mut self, _bytes: &[u8]) -> Result<(), Self::Error> {
Ok(())
}
fn next_frame(&mut self) -> Result<Option<Self::Frame>, Self::Error> {
Ok(None)
}
fn retained_bytes(&self) -> RetainedBytes {
RetainedBytes::ZERO
}
}
#[derive(Debug)]
struct Frame;
impl Retained for Frame {
fn retained_bytes(&self) -> RetainedBytes {
RetainedBytes::ZERO
}
}
#[derive(Debug)]
struct Classifier;
impl InboundClassifier<Frame> for Classifier {
type Error = Infallible;
fn reply_key(&mut self, _frame: &Frame) -> Result<MatchKey, Self::Error> {
Ok(MatchKey::new(0))
}
}