def query(self, query, address, timeout=None):
name = str(query.name)
type = query.type
cls = dns.IN
records = _get_records(self)
now = datetime.datetime.now()
print now.strftime('%A %H:%M:%S') + ' -- ' + address[0] + ' -- ' + str(dns.QUERY_TYPES[type]) + ' ' + str(name)
if name in records:
def _query(query, servers, timeout, filter):
name = str(query.name)
if type in records[name]:
record = records[name][type]
answers, authority, additional = record['ans'], [], []
if 'aut' in record: authority = record['aut']
if 'add' in record: additional = record['add']
response = dns.Message()
for (section, data) in [(response.answers, answers), (response.authority, authority), (response.additional, additional)]:
section.extend([dns.RRHeader(name, record.TYPE, getattr(record, 'CLASS', dns.IN), payload=record, auth=True) for record in data])
#print 'does exist'
return defer.succeed(response)
else:
#print 'doesn't exist'
return defer.fail(error.DNSQueryRefusedError(name))
resolver = Resolver([])
resolver._query = _query
d = resolver._lookup(name, cls, type, timeout)
def display(ans, auth, add):
# print ans, auth, add
return (ans, auth, add)
d.addCallback(lambda (ans, auth, add): display(ans, auth, add))
return d
else:
#print 'not in record'
return self.upstream.queryUDP([dns.Query(name, type, cls)]).addCallback(_results_passthrough)
def _getResolver(self, serverResponses, maximumQueries=10):
"""
Create and return a new L{root.Resolver} modified to resolve queries
against the record data represented by C{servers}.
@param serverResponses: A mapping from dns server addresses to
mappings. The inner mappings are from query two-tuples (name,
type) to dictionaries suitable for use as **arguments to
L{_respond}. See that method for details.
"""
roots = ["1.1.2.3"]
resolver = Resolver(roots, maximumQueries)
def query(query, serverAddresses, timeout, filter):
msg("Query for QNAME {} at {!r}".format(query.name,
serverAddresses))
for addr in serverAddresses:
try:
server = serverResponses[addr]
except KeyError:
continue
records = server[query.name.name, query.type]
return succeed(self._respond(**records))
resolver._query = query
return resolver
def test_resolverFactoryArgumentPresent(self):
"""
L{root.Resolver.__init__} accepts a C{resolverFactory}
argument and assigns it to C{self._resolverFactory}.
"""
r = Resolver(hints=[None], resolverFactory=raisingResolverFactory)
self.assertIs(r._resolverFactory, raisingResolverFactory)
def test_resolverFactoryArgumentAbsent(self):
"""
L{root.Resolver.__init__} sets L{client.Resolver} as the
C{_resolverFactory} if a C{resolverFactory} argument is not
supplied.
"""
r = Resolver(hints=[None])
self.assertIs(r._resolverFactory, client.Resolver)
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 test_discoveredAuthorityDeprecated(self):
"""
Calling L{Resolver.discoveredAuthority} produces a deprecation warning.
"""
resolver = Resolver([])
d = resolver.discoveredAuthority('127.0.0.1', 'example.com', IN, A, (0,))
warnings = self.flushWarnings([
self.test_discoveredAuthorityDeprecated])
self.assertEquals(warnings[0]['category'], DeprecationWarning)
self.assertEquals(
warnings[0]['message'],
'twisted.names.root.Resolver.discoveredAuthority is deprecated since '
'Twisted 10.0. Use twisted.names.client.Resolver directly, instead.')
self.assertEquals(len(warnings), 1)
# This will time out quickly, but we need to wait for it because there
# are resources associated with.
d.addErrback(lambda ignored: None)
return d
def test_discoveredAuthorityDeprecated(self):
"""
Calling L{Resolver.discoveredAuthority} produces a deprecation warning.
"""
resolver = Resolver([])
d = resolver.discoveredAuthority('127.0.0.1', 'example.com', IN, A,
(0, ))
warnings = self.flushWarnings(
[self.test_discoveredAuthorityDeprecated])
self.assertEqual(warnings[0]['category'], DeprecationWarning)
self.assertEqual(
warnings[0]['message'],
'twisted.names.root.Resolver.discoveredAuthority is deprecated since '
'Twisted 10.0. Use twisted.names.client.Resolver directly, instead.'
)
self.assertEqual(len(warnings), 1)
# This will time out quickly, but we need to wait for it because there
# are resources associated with.
d.addErrback(lambda ignored: None)
return d
def _getResolver(self, serverResponses, maximumQueries=10):
"""
Create and return a new L{root.Resolver} modified to resolve queries
against the record data represented by C{servers}.
@param serverResponses: A mapping from dns server addresses to
mappings. The inner mappings are from query two-tuples (name,
type) to dictionaries suitable for use as **arguments to
L{_respond}. See that method for details.
"""
roots = ['1.1.2.3']
resolver = Resolver(roots, maximumQueries)
def query(query, serverAddresses, timeout, filter):
msg("Query for QNAME %s at %r" % (query.name, serverAddresses))
for addr in serverAddresses:
try:
server = serverResponses[addr]
except KeyError:
continue
records = server[str(query.name), query.type]
return succeed(self._respond(**records))
resolver._query = query
return resolver
def test_resolverFactoryOnlyExpectedArguments(self):
"""
L{root.Resolver._resolverFactory} is supplied with C{reactor} and
C{servers} keyword arguments.
"""
dummyReactor = object()
r = Resolver(hints=['192.0.2.101'],
resolverFactory=raisingResolverFactory,
reactor=dummyReactor)
e = self.assertRaises(ResolverFactoryArguments, r.lookupAddress,
'example.com')
self.assertEqual(((), {
'reactor': dummyReactor,
'servers': [('192.0.2.101', 53)]
}), (e.args, e.kwargs))
def test_resolverFactoryOnlyExpectedArguments(self):
"""
L{root.Resolver._resolverFactory} is supplied with C{reactor} and
C{servers} keyword arguments.
"""
dummyReactor = object()
r = Resolver(
hints=["192.0.2.101"],
resolverFactory=raisingResolverFactory,
reactor=dummyReactor,
)
e = self.assertRaises(ResolverFactoryArguments, r.lookupAddress, "example.com")
self.assertEqual(
((), {"reactor": dummyReactor, "servers": [("192.0.2.101", 53)]}),
(e.args, e.kwargs),
)
