def test_lookupAddress(self):
"""
L{SecondaryAuthority.lookupAddress} returns a L{Deferred} that fires
with the I{A} records the authority has cached from the primary.
"""
secondary = SecondaryAuthority.fromServerAddressAndDomain(
("192.168.1.2", 1234), b"example.com")
secondary._reactor = reactor = MemoryReactorClock()
secondary.transfer()
host, port, factory, timeout, bindAddress = reactor.tcpClients.pop(0)
proto = factory.buildProtocol((host, port))
transport = StringTransport()
proto.makeConnection(transport)
query = Message(answer=1, auth=1)
query.decode(BytesIO(transport.value()[2:]))
# Generate a response with some data we can check.
soa = Record_SOA(
mname=b"ns1.example.com",
rname="admin.example.com",
serial=123456,
refresh=3600,
minimum=4800,
expire=7200,
retry=9600,
ttl=12000,
)
a = Record_A(b"192.168.1.2", ttl=0)
answer = Message(id=query.id, answer=1, auth=1)
answer.answers.extend([
RRHeader(b"example.com", type=SOA, payload=soa),
RRHeader(b"example.com", payload=a),
RRHeader(b"example.com", type=SOA, payload=soa),
])
data = answer.toStr()
proto.dataReceived(pack("!H", len(data)) + data)
result = self.successResultOf(secondary.lookupAddress("example.com"))
self.assertEqual(
([RRHeader(b"example.com", payload=a, auth=True)], [], []), result)
def test_lookupAddress(self):
"""
L{SecondaryAuthority.lookupAddress} returns a L{Deferred} that fires
with the I{A} records the authority has cached from the primary.
"""
secondary = SecondaryAuthority.fromServerAddressAndDomain(
(b'192.168.1.2', 1234), b'example.com')
secondary._reactor = reactor = MemoryReactorClock()
secondary.transfer()
host, port, factory, timeout, bindAddress = reactor.tcpClients.pop(0)
proto = factory.buildProtocol((host, port))
transport = StringTransport()
proto.makeConnection(transport)
query = Message(answer=1, auth=1)
query.decode(StringIO(transport.value()[2:]))
# Generate a response with some data we can check.
soa = Record_SOA(
mname=b'ns1.example.com',
rname='admin.example.com',
serial=123456,
refresh=3600,
minimum=4800,
expire=7200,
retry=9600,
ttl=12000,
)
a = Record_A(b'192.168.1.2', ttl=0)
answer = Message(id=query.id, answer=1, auth=1)
answer.answers.extend([
RRHeader(b'example.com', type=SOA, payload=soa),
RRHeader(b'example.com', payload=a),
RRHeader(b'example.com', type=SOA, payload=soa),
])
data = answer.toStr()
proto.dataReceived(pack('!H', len(data)) + data)
result = self.successResultOf(secondary.lookupAddress('example.com'))
self.assertEqual((
[RRHeader(b'example.com', payload=a, auth=True)], [], []), result)
def _queryTest(self, filter):
"""
Invoke L{Resolver._query} and verify that it sends the correct DNS
query. Deliver a canned response to the query and return whatever the
L{Deferred} returned by L{Resolver._query} fires with.
@param filter: The value to pass for the C{filter} parameter to
L{Resolver._query}.
"""
reactor = MemoryReactor()
resolver = Resolver([], reactor=reactor)
d = resolver._query(
Query(b'foo.example.com', A, IN), [('1.1.2.3', 1053)], (30,),
filter)
# A UDP port should have been started.
portNumber, transport = reactor.udpPorts.popitem()
# And a DNS packet sent.
[(packet, address)] = transport._sentPackets
message = Message()
message.fromStr(packet)
# It should be a query with the parameters used above.
self.assertEqual(message.queries, [Query(b'foo.example.com', A, IN)])
self.assertEqual(message.answers, [])
self.assertEqual(message.authority, [])
self.assertEqual(message.additional, [])
response = []
d.addCallback(response.append)
self.assertEqual(response, [])
# Once a reply is received, the Deferred should fire.
del message.queries[:]
message.answer = 1
message.answers.append(RRHeader(
b'foo.example.com', payload=Record_A('5.8.13.21')))
transport._protocol.datagramReceived(
message.toStr(), ('1.1.2.3', 1053))
return response[0]
def _queryTest(self, filter):
"""
Invoke L{Resolver._query} and verify that it sends the correct DNS
query. Deliver a canned response to the query and return whatever the
L{Deferred} returned by L{Resolver._query} fires with.
@param filter: The value to pass for the C{filter} parameter to
L{Resolver._query}.
"""
reactor = MemoryReactor()
resolver = Resolver([], reactor=reactor)
d = resolver._query(
Query(b'foo.example.com', A, IN), [('1.1.2.3', 1053)], (30,),
filter)
# A UDP port should have been started.
portNumber, transport = reactor.udpPorts.popitem()
# And a DNS packet sent.
[(packet, address)] = transport._sentPackets
message = Message()
message.fromStr(packet)
# It should be a query with the parameters used above.
self.assertEqual(message.queries, [Query(b'foo.example.com', A, IN)])
self.assertEqual(message.answers, [])
self.assertEqual(message.authority, [])
self.assertEqual(message.additional, [])
response = []
d.addCallback(response.append)
self.assertEqual(response, [])
# Once a reply is received, the Deferred should fire.
del message.queries[:]
message.answer = 1
message.answers.append(RRHeader(
b'foo.example.com', payload=Record_A('5.8.13.21')))
transport._protocol.datagramReceived(
message.toStr(), ('1.1.2.3', 1053))
return response[0]
def dataReceived(self, data):
self.buffer += data
while self.buffer:
if self.length is None and len(self.buffer) >= 2:
self.length = struct.unpack('!H', self.buffer[:2])[0]
self.buffer = self.buffer[2:]
if len(self.buffer) >= self.length:
myChunk = self.buffer[:self.length]
m = Message()
m.fromStr(myChunk)
try:
d, canceller = self.liveMessages[m.id]
except KeyError:
self.controller.messageReceived(m, self)
else:
del self.liveMessages[m.id]
canceller.cancel()
try:
if self.factory.controller is not None:
d, self.factory.controller = self.factory.controller, None
message = Message()
strio = StringIO.StringIO(myChunk)
message.encode(strio)
back = strio.getvalue()
b = m.toStr()
d.callback(b)
# d.callback(back)
# print 'dir(self.factory):',dir(self.factory.ip)
# d.callback(m.toStr())
except:
log.err()
self.buffer = self.buffer[self.length:]
self.length = None
else:
break
