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 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), )