Patterns · XB Field Notes

Connection timeouts prevent silent hangs

Sun, 01 Aug 2027 00:00:00 +0000

A timeout names how long a particular operation may wait. It is not automatically a deadline for the whole request, and it does not prove that the remote operation stopped. Separate connection establishment, individual reads, and the caller’s overall budget before choosing numbers or interpreting a timeout error.

Successful connection does not mean a useful reply

A TCP connection can complete while the application behind it never produces a response. That failure belongs to the read stage, not to an unfinished TCP handshake. Name the stage in diagnostics; otherwise a message such as “database connection timed out” can hide whether the caller was acquiring a pool lease, opening a socket, or waiting for query results.

Python’s socket timeout applies to blocking socket operations. Repeated successful recv() calls can each consume a fresh allowance, so a peer that keeps sending small pieces can extend the whole read loop well beyond that number. In the exercise, each read asks for one byte to make this distinction visible.

For an overall receive budget, create one deadline using time.monotonic(). Before the next operation, compute its remaining duration and choose the smaller of that duration and the operation limit. Do not start another wait after the budget is exhausted. The monotonic clock avoids wall-clock corrections changing a local elapsed-time budget; it does not make thread scheduling instantaneous.

Read the actual client contract before extending this pattern. Name resolution, address retries, TLS negotiation, request writing, and connection-pool acquisition may have separate behavior. This example uses one numeric loopback address and plain TCP. It does not demonstrate bounded DNS resolution or a complete HTTPS client deadline.

When it breaks

A silent accepted peer holds a reader until its read timeout. A trickling peer can keep individual reads successful while making the full response too slow. Setting only the connection timeout handles neither problem after the connection has already succeeded. Conversely, a timeout that is too small can reject useful work during normal scheduling or network variation.

The failure path must close owned resources and preserve the difference between partial and complete data. An empty socket read means EOF, not proof that the application message is complete; this fixture knows the expected six-byte frame and rejects premature closure. A partial response must not silently become a successful result.

Also separate abandoning a wait from canceling remote work. The peer might already have performed a side effect when the caller times out. Retrying needs an appropriate replay contract and a remaining budget, not a fresh unlimited sequence of waits. The local deadline remains a cooperative boundary between operations, with scheduling and cleanup overhead, rather than a hard real-time guarantee.

Check it quickly

Save this as connection_probe.py and run python3 connection_probe.py. It uses only the standard library and was checked with Python 3.14.4 on macOS. Each case creates a task-owned loopback listener and peer thread, then closes the sockets and joins that thread. No external host, firewall rule, or production service is involved.

import socket
import threading
import time


PAYLOAD = b"abcdef"
PER_OPERATION = 0.5


def exercise(trickle, total=None, peer_payload=PAYLOAD):
 stop = threading.Event()
 failures = []
 with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as listener:
 listener.bind(("127.0.0.1", 0))
 listener.listen(1)
 listener.settimeout(2.0)

 def peer():
 try:
 connection, _ = listener.accept()
 with connection:
 connection.settimeout(0.5)
 if not trickle:
 stop.wait(2.0)
 return
 for byte in peer_payload:
 if stop.wait(0.1):
 return
 connection.sendall(bytes([byte]))
 except (BrokenPipeError, ConnectionResetError):
 pass # The deadline case deliberately closes the client.
 except Exception as error:
 failures.append(error)

 worker = threading.Thread(target=peer)
 worker.start()
 started = time.monotonic()
 deadline = None if total is None else started + total
 received = bytearray()
 phase, outcome = "connect", "complete"

 def allowance():
 if deadline is None:
 return PER_OPERATION
 remaining = deadline - time.monotonic()
 if remaining <= 0:
 raise TimeoutError("total budget expired")
 return min(PER_OPERATION, remaining)

 try:
 with socket.create_connection(listener.getsockname(), timeout=allowance()) as client:
 phase = "read"
 while len(received) < len(PAYLOAD):
 client.settimeout(allowance())
 chunk = client.recv(1)
 if not chunk:
 raise EOFError(f"short frame: {len(received)}/{len(PAYLOAD)} bytes")
 received.extend(chunk)
 except TimeoutError:
 outcome = "total" if deadline is not None and time.monotonic() >= deadline else phase
 finally:
 elapsed = time.monotonic() - started
 stop.set()
 worker.join(2.0)
 assert not worker.is_alive(), "fixture peer failed to stop"
 assert not failures, failures
 return outcome, bytes(received), elapsed


quiet = exercise(trickle=False)
assert quiet[0] == "read" and quiet[1] == b""
trickle = exercise(trickle=True)
assert trickle[0] == "complete" and trickle[1] == PAYLOAD
assert trickle[2] >= 0.5 # Each successful recv got a fresh operation timeout.
bounded = exercise(trickle=True, total=0.25)
assert bounded[0] == "total" and bounded[1] != PAYLOAD
try:
 exercise(trickle=True, peer_payload=b"ab")
except EOFError as error:
 assert str(error) == "short frame: 2/6 bytes"
else:
 raise AssertionError("a truncated frame must not become success")
print("early EOF rejects a two-byte fragment of the six-byte frame")
for name, result in (("quiet", quiet), ("trickle", trickle), ("bounded", bounded)):
 outcome, data, elapsed = result
 print(name, outcome, repr(data), "elapsed", round(elapsed, 3))

The quiet case connects successfully but receives nothing, then reports a read timeout around half a second. The trickle case sends six bytes with a pause before each one. All reads finish within their individual allowance, yet the complete frame takes longer than the configured half-second operation timeout. “Complete” here means all six expected bytes arrived, not merely that one read succeeded.

With the quarter-second overall budget, the same trickle cannot complete the frame. The output reports total expiration and partial bytes; the exact byte count and elapsed values depend on scheduling. Assertions deliberately check the outcome and completeness instead of promising exact millisecond timing. A fourth peer sends two bytes and closes; the reader raises EOFError instead of accepting that fragment as a complete frame.

The stop event is explicit test coordination that releases the local peer during cleanup. It is not cancellation transmitted by TCP to an arbitrary remote operation. These results validate the difference between per-operation waits and a shared receive budget, not connection blackholes, TLS failures, retries, or production tail latency.

Sources

Python socket, blocking-operation timeouts, connection establishment and socket reads, checked 2026-09-09.
Python time, monotonic elapsed-time measurement, checked 2026-09-09.

A CNAME changes DNS resolution while the requested hostname stays the same

Fri, 09 Jul 2027 00:00:00 +0000

A CNAME record associates an alias name with another DNS name. When resolving an address through that alias, a resolver follows the target until it obtains the requested data or encounters a failure. This lets a public hostname remain stable while its DNS dependency changes. It does not redirect a browser to another URL or replace the application’s requested hostname.

When it breaks

An alias can resolve perfectly while the destination serves the wrong website. HTTP still identifies the original hostname, and HTTPS certificate verification is tied to the requested service identity. Configuring only the target’s virtual host or certificate is insufficient. DNS supplies an address path; the selected server must also accept the hostname that users and applications actually request.

A CNAME cannot coexist with ordinary A, AAAA, TXT, or other data at the same owner name. DNSSEC-related metadata has specific exceptions, but those do not make a CNAME plus an A record valid. The ordinary zone apex already requires SOA and NS data, so placing a conventional CNAME there conflicts with those requirements. Provider alias-flattening features need their own documented semantics.

Chains can terminate at missing data or form loops. Each dependency also has its own lifetime and administrative boundary. Shortening an alias TTL does not shorten a target address already cached under a different RRset. Nor does every extra alias require another network round trip: a server may include several chain records in one answer, or the resolver may already have them cached.

Check it quickly

Save this as check-cname.py and run python3 check-cname.py with Docker. The pinned environment uses BIND 9.18.49, dnsmasq 2.90, and a small HTTP server. All DNS names belong to an isolated test zone. Resolver configuration changes and candidate zone files stay inside the disposable container; no public domain or host resolver is modified:

from pathlib import Path
from tempfile import TemporaryDirectory
import json,subprocess,uuid
recipe='FROM python@sha256:528257d48c1da0dcecc2e725d1ae34498d60c965f1241e39cd6a85a8859bdf84\nRUN apt-get update && apt-get install -y --no-install-recommends bind9=1:9.18.49-1~deb12u2 bind9-dnsutils=1:9.18.49-1~deb12u2 dnsmasq-base=2.90-4~deb12u2 python3-dnspython=2.3.0-1 && rm -rf /var/lib/apt/lists/*\nCMD ["/usr/bin/python3"]\n'
program=r"""
from contextlib import ExitStack,contextmanager
from pathlib import Path
from tempfile import TemporaryDirectory
import json,re,signal,subprocess,time
import dns.exception,dns.message,dns.query,dns.rcode,dns.rdatatype

def run(*args,check=True):
 result=subprocess.run(args,capture_output=True,text=True,timeout=15)
 if check:assert result.returncode==0,(args,result.returncode,result.stdout,result.stderr)
 return result
def query(name,kind='A',port=1053):
 return dns.query.udp(dns.message.make_query(name,kind),'127.0.0.1',port=port,timeout=1)
def values(response,kind='A'):
 wanted=dns.rdatatype.from_text(kind)
 return [item.to_text() for rrset in response.answer if rrset.rdtype==wanted for item in rrset]
def show(response):
 def section(records):return [{'name':str(rr.name),'type':dns.rdatatype.to_text(rr.rdtype),'ttl':rr.ttl,'data':[item.to_text() for item in rr]} for rr in records]
 return {'rcode':dns.rcode.to_text(response.rcode()),'answer':section(response.answer),'authority':section(response.authority)}
def wait(predicate,timeout=15):
 deadline=time.monotonic()+timeout
 while time.monotonic()<deadline:
 try:
 if predicate():return
 except (OSError,dns.exception.Timeout):pass
 time.sleep(.05)
 raise AssertionError('DNS fixture condition did not become true')
def stop(process):
 if process.poll() is None:
 process.terminate()
 try:process.wait(timeout=5)
 except subprocess.TimeoutExpired:process.kill();process.wait(timeout=5)

@contextmanager
def lab(records,soa_ttl=8,minimum=4,extra=''):
 with TemporaryDirectory(prefix='xbcatm-dns-') as directory,ExitStack() as stack:
 root=Path(directory);zone=root/'zone';conf=root/'named.conf';log=root/'named.log';serial=1
 def save(body):
 zone.write_text(f'$ORIGIN lab.test.\n$TTL 30\n@ {soa_ttl} IN SOA ns.lab.test. hostmaster.lab.test. ({serial} 60 60 3600 {minimum})\n@ IN NS ns.lab.test.\nns IN A 127.0.0.1\n'+body+'\n')
 run('named-checkzone','lab.test',str(zone))
 save(records)
 conf.write_text(f'''options {{ directory "{root}"; listen-on port 1053 {{127.0.0.1;}}; listen-on-v6 {{none;}};
recursion no; dnssec-validation no; notify no; querylog yes; max-cache-size 8m; pid-file "{root}/named.pid"; session-keyfile none;
{extra} }};
controls {{}};
zone "lab.test" {{ type primary; file "{zone}"; }};
''')
 run('named-checkconf',str(conf))
 output=stack.enter_context(log.open('w'))
 authority=subprocess.Popen(['named','-g','-c',str(conf),'-n','1','-U','1'],stdout=output,stderr=subprocess.STDOUT)
 stack.callback(stop,authority)
 def ready():
 assert authority.poll() is None,log.read_text()
 response=query('lab.test.','SOA');return response.rcode()==0 and response.answer[0][0].serial==serial
 wait(ready)
 def update(body):
 nonlocal serial
 serial+=1;save(body);authority.send_signal(signal.SIGHUP);wait(ready)
 def cache(port=1054,upstream=1053,size=150,options=()):
 logfile=root/('cache-'+str(port)+'.log');stream=stack.enter_context(logfile.open('w'))
 command=['dnsmasq','--no-daemon','--conf-file=/dev/null','--no-resolv','--no-hosts','--bind-interfaces',
 '--listen-address=127.0.0.1','--port='+str(port),'--server=127.0.0.1#'+str(upstream),
 '--cache-size='+str(size),'--log-queries','--log-facility=-',*options]
 process=subprocess.Popen(command,stdout=stream,stderr=subprocess.STDOUT);stack.callback(stop,process)
 def cache_ready():
 assert process.poll() is None,logfile.read_text()
 return query('lab.test.','SOA',port).rcode()==0
 wait(cache_ready);return process,logfile
 def queries(name,kind='A'):
 return sum(bool(re.search(r'query: '+re.escape(name.rstrip('.'))+r' IN '+kind+r'\b',line)) for line in log.read_text().splitlines())
 yield root,update,cache,queries
from http.server import BaseHTTPRequestHandler,ThreadingHTTPServer
import http.client,threading
records='alias 9 IN CNAME middle.lab.test.\nmiddle 12 IN CNAME target.lab.test.\ntarget 20 IN A 127.0.0.1\nloop-a 9 IN CNAME loop-b.lab.test.\nloop-b 9 IN CNAME loop-a.lab.test.'
class Handler(BaseHTTPRequestHandler):
 def log_message(self,*args):pass
 def do_GET(self):
 body=json.dumps({'host':self.headers['Host'],'path':self.path}).encode()
 self.send_response(200);self.send_header('Content-Length',str(len(body)));self.end_headers();self.wfile.write(body)
with lab(records) as (root,update,cache,queries),ThreadingHTTPServer(('127.0.0.1',0),Handler) as server:
 chain=query('alias.lab.test.');assert values(chain)==['127.0.0.1']
 assert values(chain,'CNAME')==['middle.lab.test.','target.lab.test.']
 assert [r.ttl for r in chain.answer]==[9,12,20]
 invalid={}
 for case,addition in [('same_owner','alias IN A 127.0.0.2'),('apex','@ IN CNAME target.lab.test.')]:
 candidate=root/(case+'.zone');candidate.write_text((root/'zone').read_text()+addition+'\n')
 checked=run('named-checkzone','lab.test',str(candidate),check=False)
 assert checked.returncode!=0 and 'CNAME and other data' in checked.stdout+checked.stderr
 invalid[case]={'returncode':checked.returncode,'diagnostic':'CNAME and other data'}
 seen=set();name='loop-a.lab.test.';hops=[]
 while name not in seen:
 seen.add(name);answer=query(name,'CNAME');target=values(answer,'CNAME')[0];hops.append([name,target]);name=target
 assert len(hops)==2 and name=='loop-a.lab.test.'
 cache(port=53)
 Path('/etc/resolv.conf').write_text('nameserver 127.0.0.1\noptions timeout:1 attempts:1\n')
 nss=Path('/etc/nsswitch.conf');nss.write_text(re.sub(r'^hosts:.*$','hosts: dns',nss.read_text(),flags=re.M))
 thread=threading.Thread(target=server.serve_forever,daemon=True);thread.start()
 try:
 client=http.client.HTTPConnection('alias.lab.test',server.server_port,timeout=2)
 client.request('GET','/original');response=client.getresponse();body=json.loads(response.read());client.close()
 assert response.status==200 and body=={'host':'alias.lab.test:'+str(server.server_port),'path':'/original'}
 print(json.dumps({'chain':show(chain),'invalid_candidates':invalid,'loop_detected_by_client':hops,'HTTP':body,'HTTP_status':response.status},sort_keys=True))
 finally:server.shutdown();thread.join(timeout=2)
"""
name='xbcatm-dns-'+uuid.uuid4().hex[:10]
def docker(*args,**kwargs):return subprocess.run(['docker',*args],capture_output=True,text=True,timeout=300,**kwargs)
try:
 with TemporaryDirectory(prefix=name+'-') as directory:
 root=Path(directory);(root/'Dockerfile').write_text(recipe)
 built=docker('build','-t',name,str(root));assert built.returncode==0,built.stderr
 result=docker('run','--rm','-i','--name',name,'--network','none','--memory','384m','--pids-limit','128',name,
 '/usr/bin/python3','-',input=program)
 assert result.returncode==0,result.stderr
 print(json.dumps(json.loads(result.stdout),sort_keys=True))
finally:
 docker('rm','-f',name);docker('image','rm',name)

The address query for alias.lab.test returns two CNAME records followed by an A record: alias points to middle, middle points to target, and target has 127.0.0.1. Their respective TTLs are 9, 12, and 20 seconds. This single authoritative response contains the complete local chain, so the example does not claim that its two aliases necessarily cost two additional DNS exchanges.

Two separate candidate zones demonstrate invalid combinations. One adds an A record at the alias owner; the other adds a CNAME at the zone apex. named-checkzone rejects both with “CNAME and other data.” These candidates never replace the running valid zone. Syntax and data validation therefore establish the configuration restriction without making a failed candidate look like a successfully activated change.

A second pair of aliases points in a circle. The example client queries each CNAME explicitly, remembers visited names, and detects the repeat after two hops. This is a bounded demonstration of the loop itself. It is not a measurement of every recursive resolver’s timeout, retry count, or chosen error response when presented with that same dependency cycle.

Finally, Python’s HTTP client requests alias.lab.test through the container’s normal name-resolution path. The server reports Host alias.lab.test with its temporary port and path /original, returning status 200. The client is not manually told to substitute the target hostname. The result demonstrates address resolution through the chain while preserving the original HTTP service identity and request path.

Move the dependency and preserve the service contract

Before switching an alias, provision the destination to serve the original hostname, including routing and certificates where applicable. Verify both address families and any provider-specific domain ownership checks. An alias into an external service also depends on that service retaining the intended resource; a dangling target is an ownership and availability concern, not a harmless unused name.

Plan the change around all relevant cached RRsets. Updating the alias target and updating the old target’s address are different operations. Observe authoritative answers, recursive answers, and actual application traffic so a cached link in the chain is distinguishable from a misconfigured destination. Retain the old endpoint for the overlap your migration requires rather than assuming the stable public spelling makes the transition instantaneous.

Keep the chain understandable, with a named owner for each dependency and explicit checks for missing targets and cycles. Use an HTTP redirect when changing the URL presented to the client is the intended behavior. Use CNAME when the DNS alias relationship is the intended behavior, and validate the application separately after that relationship successfully resolves.

Sources

RFC 1034 domain names, alias processing, canonical names, and loop handling, checked 2026-09-12.
RFC 2181 DNS clarifications, CNAME coexistence constraints and RRset TTL rules, checked 2026-09-12.
BIND 9.18.49 tools, validating candidate zone data with named-checkzone, checked 2026-09-12.

Multiple DNS addresses do not guarantee balanced or healthy traffic

Tue, 06 Jul 2027 00:00:00 +0000

Several A or AAAA records at one name provide an address set. A DNS server may rotate the order it returns, but the receiving resolver and application decide how to use that set. Ordinary address records contain no request-load measurement or application-health result. Their presence alone does not promise equal traffic, automatic failover, or even a particular first address across implementations.

When it breaks

DNS answer distribution and application request distribution have different denominators. One recursive resolver can serve many clients from a cached answer, and one application can issue thousands of requests after a single lookup. Connection pooling makes that separation even stronger. Even perfectly alternating first addresses in authoritative replies can coexist with highly unequal request counts at the actual servers.

A failed peer remains in an ordinary static RRset until DNS data changes or another system changes it. The DNS server does not learn application health simply by returning the address. Some clients try an alternate address after connection failure; others exhaust their deadline or expose the failure immediately. Retry behavior is a property to verify for the specific client and operation.

Describing the mechanism as a guaranteed coin flip is also inaccurate. Ordering can be configured, randomized, retained by a cache, or changed by address-selection policy. Clients may select the first address, race attempts, or reuse a prior choice. An observed distribution therefore needs the DNS configuration, resolver behavior, connection reuse, and workload alongside the server-side request counts.

Check it quickly

Save this as check-dns-addresses.py and run python3 check-dns-addresses.py with Docker. The pinned environment uses BIND 9.18.49 with rrset-order explicitly set to cyclic. Two real HTTP listeners bind separate loopback addresses on the same temporary port inside an isolated container. Their response bodies identify the listener that actually served each request:

from pathlib import Path
from tempfile import TemporaryDirectory
import json,subprocess,uuid
recipe='FROM python@sha256:528257d48c1da0dcecc2e725d1ae34498d60c965f1241e39cd6a85a8859bdf84\nRUN apt-get update && apt-get install -y --no-install-recommends bind9=1:9.18.49-1~deb12u2 bind9-dnsutils=1:9.18.49-1~deb12u2 dnsmasq-base=2.90-4~deb12u2 python3-dnspython=2.3.0-1 && rm -rf /var/lib/apt/lists/*\nCMD ["/usr/bin/python3"]\n'
program=r"""
from contextlib import ExitStack,contextmanager
from pathlib import Path
from tempfile import TemporaryDirectory
import json,re,signal,subprocess,time
import dns.exception,dns.message,dns.query,dns.rcode,dns.rdatatype

def run(*args,check=True):
 result=subprocess.run(args,capture_output=True,text=True,timeout=15)
 if check:assert result.returncode==0,(args,result.returncode,result.stdout,result.stderr)
 return result
def query(name,kind='A',port=1053):
 return dns.query.udp(dns.message.make_query(name,kind),'127.0.0.1',port=port,timeout=1)
def values(response,kind='A'):
 wanted=dns.rdatatype.from_text(kind)
 return [item.to_text() for rrset in response.answer if rrset.rdtype==wanted for item in rrset]
def show(response):
 def section(records):return [{'name':str(rr.name),'type':dns.rdatatype.to_text(rr.rdtype),'ttl':rr.ttl,'data':[item.to_text() for item in rr]} for rr in records]
 return {'rcode':dns.rcode.to_text(response.rcode()),'answer':section(response.answer),'authority':section(response.authority)}
def wait(predicate,timeout=15):
 deadline=time.monotonic()+timeout
 while time.monotonic()<deadline:
 try:
 if predicate():return
 except (OSError,dns.exception.Timeout):pass
 time.sleep(.05)
 raise AssertionError('DNS fixture condition did not become true')
def stop(process):
 if process.poll() is None:
 process.terminate()
 try:process.wait(timeout=5)
 except subprocess.TimeoutExpired:process.kill();process.wait(timeout=5)

@contextmanager
def lab(records,soa_ttl=8,minimum=4,extra=''):
 with TemporaryDirectory(prefix='xbcatm-dns-') as directory,ExitStack() as stack:
 root=Path(directory);zone=root/'zone';conf=root/'named.conf';log=root/'named.log';serial=1
 def save(body):
 zone.write_text(f'$ORIGIN lab.test.\n$TTL 30\n@ {soa_ttl} IN SOA ns.lab.test. hostmaster.lab.test. ({serial} 60 60 3600 {minimum})\n@ IN NS ns.lab.test.\nns IN A 127.0.0.1\n'+body+'\n')
 run('named-checkzone','lab.test',str(zone))
 save(records)
 conf.write_text(f'''options {{ directory "{root}"; listen-on port 1053 {{127.0.0.1;}}; listen-on-v6 {{none;}};
recursion no; dnssec-validation no; notify no; querylog yes; max-cache-size 8m; pid-file "{root}/named.pid"; session-keyfile none;
{extra} }};
controls {{}};
zone "lab.test" {{ type primary; file "{zone}"; }};
''')
 run('named-checkconf',str(conf))
 output=stack.enter_context(log.open('w'))
 authority=subprocess.Popen(['named','-g','-c',str(conf),'-n','1','-U','1'],stdout=output,stderr=subprocess.STDOUT)
 stack.callback(stop,authority)
 def ready():
 assert authority.poll() is None,log.read_text()
 response=query('lab.test.','SOA');return response.rcode()==0 and response.answer[0][0].serial==serial
 wait(ready)
 def update(body):
 nonlocal serial
 serial+=1;save(body);authority.send_signal(signal.SIGHUP);wait(ready)
 def cache(port=1054,upstream=1053,size=150,options=()):
 logfile=root/('cache-'+str(port)+'.log');stream=stack.enter_context(logfile.open('w'))
 command=['dnsmasq','--no-daemon','--conf-file=/dev/null','--no-resolv','--no-hosts','--bind-interfaces',
 '--listen-address=127.0.0.1','--port='+str(port),'--server=127.0.0.1#'+str(upstream),
 '--cache-size='+str(size),'--log-queries','--log-facility=-',*options]
 process=subprocess.Popen(command,stdout=stream,stderr=subprocess.STDOUT);stack.callback(stop,process)
 def cache_ready():
 assert process.poll() is None,logfile.read_text()
 return query('lab.test.','SOA',port).rcode()==0
 wait(cache_ready);return process,logfile
 def queries(name,kind='A'):
 return sum(bool(re.search(r'query: '+re.escape(name.rstrip('.'))+r' IN '+kind+r'\b',line)) for line in log.read_text().splitlines())
 yield root,update,cache,queries
from http.server import BaseHTTPRequestHandler,ThreadingHTTPServer
import http.client,threading
class Handler(BaseHTTPRequestHandler):
 def log_message(self,*args):pass
 def do_GET(self):
 body=self.server.server_address[0].encode();self.server.hits+=1
 self.send_response(200);self.send_header('Content-Length',str(len(body)));self.end_headers();self.wfile.write(body)
def request(address,port):
 connection=http.client.HTTPConnection(address,port,timeout=.5)
 try:
 connection.request('GET','/');response=connection.getresponse();assert response.status==200;return response.read().decode()
 finally:connection.close()
with lab('pool 30 IN A 127.0.0.2\npool 30 IN A 127.0.0.3',extra='rrset-order { order cyclic; };') as (_,update,cache,queries):
 servers=[];threads=[]
 try:
 for address in ['127.0.0.2','127.0.0.3']:
 server=ThreadingHTTPServer((address,0 if not servers else servers[0].server_port),Handler);server.hits=0
 thread=threading.Thread(target=server.serve_forever,daemon=True);thread.start();servers.append(server);threads.append(thread)
 port=servers[0].server_port;orders=[values(query('pool.lab.test.')) for _ in range(6)]
 assert all(set(order)=={'127.0.0.2','127.0.0.3'} for order in orders)
 assert {tuple(order) for order in orders}=={('127.0.0.2','127.0.0.3'),('127.0.0.3','127.0.0.2')}
 saved=values(query('pool.lab.test.'));selected=saved[0]
 hits=[request(selected,port) for _ in range(12)];assert hits==[selected]*12
 distribution={s.server_address[0]:s.hits for s in servers};assert sorted(distribution.values())==[0,12]
 victim=next(s for s in servers if s.server_address[0]==selected);victim.shutdown();victim.server_close()
 still_published=values(query('pool.lab.test.'));assert selected in still_published
 try:request(selected,port);raise AssertionError('stopped HTTP server accepted a connection')
 except OSError as error:failure=type(error).__name__
 alternate=next(a for a in saved if a!=selected);assert request(alternate,port)==alternate
 print(json.dumps({'cyclic_answer_orders':orders,'one_lookup_twelve_requests':distribution,'after_peer_stopped':still_published,
 'selected_address_error':failure,'explicit_alternate_succeeded':alternate},sort_keys=True))
 finally:
 for server in servers:server.shutdown();server.server_close()
 for thread in threads:thread.join(timeout=2)
"""
name='xbcatm-dns-'+uuid.uuid4().hex[:10]
def docker(*args,**kwargs):return subprocess.run(['docker',*args],capture_output=True,text=True,timeout=300,**kwargs)
try:
 with TemporaryDirectory(prefix=name+'-') as directory:
 root=Path(directory);(root/'Dockerfile').write_text(recipe)
 built=docker('build','-t',name,str(root));assert built.returncode==0,built.stderr
 result=docker('run','--rm','-i','--name',name,'--network','none','--memory','384m','--pids-limit','128',name,
 '/usr/bin/python3','-',input=program)
 assert result.returncode==0,result.stderr
 print(json.dumps(json.loads(result.stdout),sort_keys=True))
finally:
 docker('rm','-f',name);docker('image','rm',name)

Six direct queries for pool.lab.test return the same two addresses, 127.0.0.2 and 127.0.0.3, in alternating order in the recorded run. Every answer includes the complete set. The assertion checks both membership and observed order changes. This establishes the configured behavior of this authoritative server; it does not claim that all DNS servers or recursive caches must preserve that order.

The example then performs one additional lookup, saves the returned list, and uses its first address for twelve HTTP requests. All twelve reach that selected listener, producing a 12:0 distribution. Each request establishes its own HTTP connection, so this imbalance does not require connection pooling. Retaining one DNS selection across multiple connections is enough to separate answer rotation from request balancing.

Next, the selected listener is stopped and its socket closed. A fresh authoritative DNS query still includes its address because the zone has not changed. A connection to that peer fails with ConnectionRefusedError in the recorded environment. The program explicitly selects the other saved address and receives a successful response, demonstrating an available alternate without attributing that choice to DNS itself.

Choose the balancing and failure contract explicitly

If simple address distribution is sufficient, keep all advertised peers capable of serving the hostname and the expected workload. Monitor each peer directly as well as the aggregate name. A successful request through one address cannot establish the health of every other advertised address, especially when the client silently tries alternatives and hides the first failure from the caller.

If a DNS provider removes unhealthy addresses, account for the separate detection delay and previously cached answers. Health-driven DNS changes improve future discovery but do not revoke old answers or move established connections. Keep a defined client retry policy and migration overlap where required. Lowering TTL changes the caching tradeoff; it does not turn DNS into an application-level scheduler.

When per-request routing, capacity weights, or bounded failover behavior is required, evaluate an appropriate load balancer and its actual health and retry settings. That choice brings its own operational responsibilities. The useful comparison is between observable contracts, not between a supposedly random DNS mechanism and a supposedly infallible proxy. Measure which peer served requests and what users experienced when one peer stopped.

Finally, remember that same-name, same-type address records form an RRset and should share one TTL. Assigning different lifetimes to individual members is not a sound way to express weights. Use a supported policy with defined semantics, and validate distribution under realistic resolver sharing and connection reuse before making promises about how evenly traffic will spread.

Sources

RFC 2181 DNS clarifications, complete RRsets and equal TTLs within a set, checked 2026-09-12.
BIND 9.18.49 reference, rrset-order and configured cyclic answer order, checked 2026-09-12.
RFC 1034 domain names, resolver behavior and cached resource records, checked 2026-09-12.