NetworkFailure
Classifies portable networking failures independently of errno. WouldBlock/InProgress preserve socket ownership and require readiness before retry. Cancelled/TimedOut belong to async operation policy; immediate calls do not manufacture them. Packet truncation is DatagramReceipt.IsTruncated instead.
Module std.net
import std.net;Public declaration contracts and authored examples. A page can document several related symbols. Implementation bodies are excluded.
NetworkFailure
pub enum NetworkFailureClassifies portable networking failures independently of errno. WouldBlock/InProgress preserve socket ownership and require readiness before retry. Cancelled/TimedOut belong to async operation policy; immediate calls do not manufacture them. Packet truncation is DatagramReceipt.IsTruncated instead.
NetworkFailure.InvalidInput
InvalidInput;An endpoint, capacity or operation argument violates the contract.
NetworkFailure.Closed
Closed;The socket has no live close authority, including moved-from state.
NetworkFailure.WouldBlock
WouldBlock;No immediate progress is available; retain ownership for readiness.
NetworkFailure.InProgress
InProgress;Connection establishment remains pending.
NetworkFailure.Interrupted
Interrupted;The one-shot native operation was interrupted.
NetworkFailure.AddressInUse
AddressInUse;The local endpoint is already occupied.
NetworkFailure.AccessDenied
AccessDenied;Platform policy refused the operation.
NetworkFailure.ConnectionRefused
ConnectionRefused;The peer refused connection establishment.
NetworkFailure.ConnectionReset
ConnectionReset;Peer reset or broken-pipe failure ended transfer.
NetworkFailure.NotConnected
NotConnected;A required peer attachment is absent.
NetworkFailure.MessageTooLarge
MessageTooLarge;The selected transport cannot accept this packet size.
NetworkFailure.ResourceUnavailable
ResourceUnavailable;Native descriptor or memory capacity prevented admission.
NetworkFailure.Unsupported
Unsupported;The selected capability or family is unavailable.
NetworkFailure.NativeFailure
NativeFailure;Native failure has no narrower portable identity.
NetworkFailure.Cancelled
Cancelled;Cancellation ended the async operation according to its progress contract.
NetworkFailure.TimedOut
TimedOut;The explicit monotonic deadline expired.
NetworkFailure.ClockUnavailable
ClockUnavailable;Monotonic deadline sampling is unavailable.
Example
module example.socket_deadline;
from std.net import TcpStream, TcpListener, UdpSocket, Endpoint;
from std.time import Deadline, Instant;
from std.task import Task;
async fn Main() -> Task<i32> {
let Now = switch Instant.TryNow() { case .Ok { Value = Value } => break Value; case .Err => return 1; };
let Expired: Deadline = .Finite { At = Now };
var Stream = TcpStream();
var Listener = TcpListener();
var Packet = UdpSocket();
var Output: byte[1] = [0xA1_byte];
let Input: byte[1] = [0xB2_byte];
// Match one enum layer at a time while preserving each original fallback.
switch await Stream.ReadAsync(Output, Expired) {
case .Err { Error = PatternPayload5105 } => {
switch PatternPayload5105 {
case .Failure { Reason = PatternPayload5106, Transferred = Count } => {
switch PatternPayload5106 {
case .Network { Reason = PatternPayload5107 } if (PatternPayload5107 is .TimedOut) => { if Count != 0 { return 2; } }
default => return 3;
}
}
default => return 3;
}
}
default => return 3;
}
switch await Stream.WriteAsync(Input, Expired) {
case .Err { Error = PatternPayload5108 } => {
switch PatternPayload5108 {
case .Failure { Reason = PatternPayload5109 } => {
switch PatternPayload5109 {
case .Network { Reason = PatternPayload5110 } if (PatternPayload5110 is .TimedOut) => {}
default => return 4;
}
}
default => return 4;
}
}
default => return 4;
}
switch await Stream.FlushAsync(Expired) {
case .Err { Error = PatternPayload5111 } => {
switch PatternPayload5111 {
case .Failure { Reason = PatternPayload5112 } => {
switch PatternPayload5112 {
case .Network { Reason = PatternPayload5113 } if (PatternPayload5113 is .TimedOut) => {}
default => return 5;
}
}
default => return 5;
}
}
default => return 5;
}
switch await Listener.AcceptAsync(Expired) {
case .Err { Error = PatternPayload5114 } => {
switch PatternPayload5114 {
case .Failure { Reason = PatternPayload5115 } if (PatternPayload5115 is .TimedOut) => {}
default => return 6;
}
}
default => return 6;
}
switch await TcpStream.ConnectAsync(default(Endpoint), Expired) {
case .Err { Error = PatternPayload5116 } => {
switch PatternPayload5116 {
case .Failure { Reason = PatternPayload5117 } if (PatternPayload5117 is .TimedOut) => {}
default => return 7;
}
}
default => return 7;
}
switch await Packet.SendToAsync(default(Endpoint), Input, Expired) {
case .Err { Error = PatternPayload5118 } => {
switch PatternPayload5118 {
case .Failure { Reason = PatternPayload5119 } if (PatternPayload5119 is .TimedOut) => {}
default => return 8;
}
}
default => return 8;
}
switch await Packet.ReceiveFromAsync(Output, Expired) {
case .Err { Error = PatternPayload5120 } => {
switch PatternPayload5120 {
case .Failure { Reason = PatternPayload5121 } if (PatternPayload5121 is .TimedOut) => {}
default => return 9;
}
}
default => return 9;
}
if Output[0] != 0xA1_byte || !Stream.IsClosed || !Listener.IsClosed || !Packet.IsClosed { return 10; }
let Invalid: Deadline = .Finite { At = default(Instant) };
switch await Stream.ReadAsync(Output, Invalid) {
case .Err { Error = PatternPayload5122 } => {
switch PatternPayload5122 {
case .Failure { Reason = PatternPayload5123 } => {
switch PatternPayload5123 {
case .Network { Reason = PatternPayload5124 } if (PatternPayload5124 is .IncompatibleClockDomain) => {}
default => return 11;
}
}
default => return 11;
}
}
default => return 11;
}
let Forever: Deadline = .Endless;
switch await Stream.ReadAsync(Output, Forever) {
case .Err { Error = PatternPayload5125 } => {
switch PatternPayload5125 {
case .Failure { Reason = PatternPayload5126 } => {
switch PatternPayload5126 {
case .Network { Reason = PatternPayload5127 } if (PatternPayload5127 is .Closed) => {}
default => return 12;
}
}
default => return 12;
}
}
default => return 12;
}
return 0;
}NetworkFailure.IncompatibleClockDomain
IncompatibleClockDomain;A finite deadline carries an invalid or incompatible domain.
NetworkFailure.RangeOverflow
RangeOverflow;The finite deadline exceeds native tick range.
NetworkFailure.NameNotFound
NameNotFound;Platform resolver found no address in the selected family.
NetworkFailure.TemporaryFailure
TemporaryFailure;Platform resolution requests a later attempt; no automatic retry.