Here are the examples of the python api twisted.names.client.Resolver taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.
32 Examples
3
Example 1
Project: simple-dns Source File: dns.py
def create_resolver(servers=None, resolvconf=None, hosts=None):
if platform.getType() == 'posix':
if resolvconf is None:
resolvconf = b'/etc/resolv.conf'
if hosts is None:
hosts = b'/etc/hosts'
the_resolver = client.Resolver(resolvconf, servers)
host_resolver = Resolver(hosts)
else:
if hosts is None:
hosts = r'c:\windows\hosts'
from twisted.internet import reactor
bootstrap = client._ThreadedResolverImpl(reactor)
host_resolver = Resolver(hosts)
the_resolver = root.bootstrap(bootstrap, resolverFactory=client.Resolver)
return resolve.ResolverChain([host_resolver, cache.CacheResolver(), the_resolver])
3
Example 2
Project: rosbridge_suite Source File: twisted.py
def initialize(self, io_loop=None):
self.io_loop = io_loop or IOLoop.current()
# partial copy of twisted.names.client.createResolver, which doesn't
# allow for a reactor to be passed in.
self.reactor = tornado.platform.twisted.TornadoReactor(io_loop)
host_resolver = twisted.names.hosts.Resolver('/etc/hosts')
cache_resolver = twisted.names.cache.CacheResolver(reactor=self.reactor)
real_resolver = twisted.names.client.Resolver('/etc/resolv.conf',
reactor=self.reactor)
self.resolver = twisted.names.resolve.ResolverChain(
[host_resolver, cache_resolver, real_resolver])
3
Example 3
Project: ooni-backend Source File: dns_helpers.py
def __init__(self, authorities=None,
caches=None, clients=None,
verbose=0):
try:
host, port = config.helpers.dns.split(':')
port = int(port)
# XXX remove this when we have configuration file versioning.
# https://github.com/TheTorProject/ooni-probe/issues/190
except:
host, port = '8.8.8.8', 53
resolver = client.Resolver(servers=[(host, port)])
server.DNSServerFactory.__init__(self, authorities=authorities,
caches=caches, clients=[resolver],
verbose=verbose)
3
Example 4
Project: netflix-no-ipv6-dns-proxy Source File: server.py
def main():
factory = server.DNSServerFactory(
clients=[
BlockNetflixAAAAResolver(),
client.Resolver(
servers=OPTIONS.get('upstream-dns', None),
resolv=OPTIONS.get('resolv-conf', None)
)
]
)
protocol = dns.DNSDatagramProtocol(controller=factory)
reactor.listenUDP(OPTIONS['listen-port'], protocol, interface=OPTIONS['listen-address'])
reactor.listenTCP(OPTIONS['listen-port'], factory, interface=OPTIONS['listen-address'])
reactor.run()
3
Example 5
Project: SubliminalCollaborator Source File: root.py
def discoveredAuthority(self, auth, name, cls, type, timeout):
warnings.warn(
'twisted.names.root.Resolver.discoveredAuthority is deprecated since '
'Twisted 10.0. Use twisted.names.client.Resolver directly, instead.',
category=DeprecationWarning, stacklevel=2)
from twisted.names import client
q = dns.Query(name, type, cls)
r = client.Resolver(servers=[(auth, dns.PORT)])
d = r.queryUDP([q], timeout)
d.addCallback(r.filterAnswers)
return d
3
Example 6
def transfer(self):
if self.transferring:
return
self.transfering = True
reactor = self._reactor
if reactor is None:
from twisted.internet import reactor
resolver = client.Resolver(
servers=[(self.primary, self._port)], reactor=reactor)
return resolver.lookupZone(self.domain
).addCallback(self._cbZone
).addErrback(self._ebZone
)
3
Example 7
Project: SubliminalCollaborator Source File: test_client.py
def test_resolverProtocol(self):
"""
Reading L{client.Resolver.protocol} causes a deprecation warning to be
emitted and evaluates to an instance of L{DNSDatagramProtocol}.
"""
resolver = client.Resolver(servers=[('example.com', 53)])
self.addCleanup(setWarningMethod, getWarningMethod())
warnings = []
setWarningMethod(
lambda message, category, stacklevel:
warnings.append((message, category, stacklevel)))
protocol = resolver.protocol
self.assertIsInstance(protocol, dns.DNSDatagramProtocol)
self.assertEqual(
warnings, [("Resolver.protocol is deprecated; use "
"Resolver.queryUDP instead.",
PendingDeprecationWarning, 0)])
self.assertIdentical(protocol, resolver.protocol)
3
Example 8
Project: SubliminalCollaborator Source File: test_client.py
def test_connectedProtocol(self):
"""
L{client.Resolver._connectedProtocol} returns a new
L{DNSDatagramProtocol} connected to a new address with a
cryptographically secure random port number.
"""
resolver = client.Resolver(servers=[('example.com', 53)])
firstProto = resolver._connectedProtocol()
secondProto = resolver._connectedProtocol()
self.assertNotIdentical(firstProto.transport, None)
self.assertNotIdentical(secondProto.transport, None)
self.assertNotEqual(
firstProto.transport.getHost().port,
secondProto.transport.getHost().port)
return defer.gatherResults([
defer.maybeDeferred(firstProto.transport.stopListening),
defer.maybeDeferred(secondProto.transport.stopListening)])
3
Example 9
Project: SubliminalCollaborator Source File: test_client.py
def test_disallowedPort(self):
"""
If a port number is initially selected which cannot be bound, the
L{CannotListenError} is handled and another port number is attempted.
"""
ports = []
class FakeReactor(object):
def listenUDP(self, port, *args):
ports.append(port)
if len(ports) == 1:
raise error.CannotListenError(None, port, None)
resolver = client.Resolver(servers=[('example.com', 53)])
resolver._reactor = FakeReactor()
proto = resolver._connectedProtocol()
self.assertEqual(len(set(ports)), 2)
3
Example 10
Project: SubliminalCollaborator Source File: test_client.py
def test_tcpDisconnectRemovesFromConnections(self):
"""
When a TCP DNS protocol associated with a Resolver disconnects, it is
removed from the Resolver's connection list.
"""
resolver = client.Resolver(servers=[('example.com', 53)])
protocol = resolver.factory.buildProtocol(None)
protocol.makeConnection(None)
self.assertIn(protocol, resolver.connections)
# Disconnecting should remove the protocol from the connection list:
protocol.connectionLost(None)
self.assertNotIn(protocol, resolver.connections)
3
Example 11
Project: SubliminalCollaborator Source File: test_names.py
def testRoundRobinBackoff(self):
addrs = [(x, 53) for x in self.testServers]
r = client.Resolver(resolv=None, servers=addrs)
r.protocol = proto = FakeDNSDatagramProtocol()
return r.lookupAddress("foo.example.com"
).addCallback(self._cbRoundRobinBackoff
).addErrback(self._ebRoundRobinBackoff, proto
)
3
Example 12
def testEmpty(self):
resolvConf = self.mktemp()
fObj = file(resolvConf, 'w')
fObj.close()
r = client.Resolver(resolv=resolvConf)
self.assertEqual(r.dynServers, [('127.0.0.1', 53)])
r._parseCall.cancel()
0
Example 13
Project: kanone Source File: tx.py
def monkeyPatch():
"""
Patches Kanone so that any validation returns a Deferred, thus
one can write asynchronous validators using Twisted's non-blocking API.
Schema and ForEach fields are validated concurrently.
"""
if getattr( monkeyPatch,'_isMonkeyPatched',False):
return
from ..lib import Context, PASS, MISSING
from ..validator.core import Tag, Compose, Tmp, Item, Not, And, Or, Call, If
from ..validator.check import Match
from ..validator.schema import Schema, ForEach, Field
from ..validator.web import MXLookup
@defer.inlineCallbacks
def context_validate( self ):
if self.isValidated:
if self.__error__ is not MISSING:
raise self.__error__
defer.returnValue( self.__result__ )
self.isValidating = True
if self.parent is not None:
if not self.parent.isValidated and not self.parent.isValidating:
yield defer.maybeDeferred\
( self.parent.validate
)
if not self.validator:
raise AttributeError("No validator set for context '%s'" % self.path )
result = defer.maybeDeferred\
( self.validator.validate
, self
, self.__value__
)
result.addErrback( context_gotError, self )
result = yield result
self.isValidated = True
self.isValidating = False
if self.__error__ is not MISSING:
raise self.__error__
else:
if result is not PASS:
self.__result__ = result
else:
self.__result__ = self.__value__
self.__result__ = result
defer.returnValue( result )
def context_gotError( error, self ):
e = error.value
if not isinstance( e, Invalid ):
self.__error__ = error
return
self.__error__ = e
e.context = self
message = e.validator.__messages__[e.key]
if message is not None:
extra = e.data['extra']
value = e.value
data = e.data
data['message'] = message
if hasattr(e,'realkey'):
data['key'] = e.realkey
extra['value.type'] = getattr(value, '__class__', None) is not None \
and getattr(value.__class__,'__name__', False) or 'unknown'
if isinstance(value,str) or not _python3 and isinstance(value,basestring):
extra['value'] = value
else:
extra['value'] = str(value)
cache = getattr( self, 'cache', None)
if cache is not None:
extra.update( cache )
self['error'] = self.__error__.data
self.root.errorlist.append( self.__error__.context.path )
def tag_gotResult( result, d, validator, tagName ):
if isinstance( result, Failure ):
if not isinstance(result.value, Invalid):
d.errback( result )
return
e = result.value
if e.validator is validator or getattr(e,'composer',None) is validator:
e.tagName = tagName
d.errback( e )
else:
d.callback( result )
def tag_validate( self, context, value ):
validator = context.root.taggedValidators.get(self.tagID, None)
if validator is None:
validator = self.enabled and self.validator
if not validator:
return value
d = defer.Deferred()
result = defer.maybeDeferred\
( validator.validate
, context
, value
)
result.addBoth( tag_gotResult, d, validator, self.tagName )
return d
def compose_gotResult( result, d, context, tmpTags, composer ):
context.root.taggedValidators = tmpTags
if isinstance( result, Failure ):
if not isinstance( result.value, Invalid ):
d.errback( result )
return
e = result.value
if hasattr(e,'tagName'):
e.realkey = "%s_%s" % (e.tagName, getattr(e,'realkey',e.key))
e.composer = composer
del e.tagName
d.errback( e )
else:
d.callback( result )
def compose_validate( self, context, value ):
tmpTags = context.root.taggedValidators
context.root.taggedValidators = self.currentTaggedValidators
d = defer.Deferred()
result = defer.maybeDeferred\
( self.validator.validate
, context
, value
)
result.addBoth( compose_gotResult, d, context, tmpTags, self )
return d
def tmp_gotReslt( result, d, raiseError, value ):
if isinstance( result, Failure ):
if not isinstance(result.value, Invalid):
d.errback( result )
return
if raiseError:
d.errback( result.value )
return
d.callback( value )
def tmp_validate( self, context, value ):
d = defer.Deferred()
result = defer.maybeDeferred\
( self.validator.validate
, context
, value
)
result.addBoth( tmp_gotReslt, d, self.raiseError, value )
return d
def item_gotResult( result, d, value, key, alter ):
if isinstance( result, Failure ):
if not isinstance(result.value, Invalid):
d.errback( result )
return
d.errback( result.value )
else:
if alter:
value[key] = result
d.callback( value )
def item_validate( self, context, value ):
try:
val = value[ self.key ]
except TypeError:
raise Invalid( value, self, 'type' )
except (KeyError, IndexError):
raise Invalid( value, self, 'notFound', key=self.key )
else:
if self.validator is not None:
d = defer.Deferred()
result = defer.maybeDeferred\
( self.validator.validate
, context
, val
)
result.addBoth( item_gotResult, d , value, self.key, self.alter )
return d
else:
return val
def not_gotResult( result, d, value, validator ):
if isinstance( result, Failure ):
if not isinstance( result.value, Invalid ):
d.errback( result )
return
d.callback( value )
else:
d.errback( Invalid( value, validator ) )
def not_validate(self, context, value ):
d = defer.Deferred()
result = defer.maybeDeferred\
( self.validator.validate
, context
, value
)
result.addBoth( not_gotResult, d, value, self )
return d
def and_doTryNext( result, validators, context, value, d ):
if isinstance( result, Failure ):
if not isinstance(result.value, Invalid):
d.errback( result )
else:
e = result.value
d.errback( e )
else:
if validators:
and_tryNext( validators, context, result, d )
else:
d.callback( result )
def and_tryNext( validators, context, value, d ):
result = defer.maybeDeferred\
( validators.pop(0).validate
, context
, value
)
result.addBoth( and_doTryNext, validators, context, value, d )
def and_validate( self, context, value ):
d = defer.Deferred()
and_tryNext( list( self.validators ), context, value, d )
return d
def or_doTryNext( result, validators, context, value, d ):
if isinstance( result, Failure ):
err = result
if not isinstance(err.value, Invalid):
d.errback( err )
return
e = err.value
if not validators:
d.errback( e )
else:
or_tryNext( validators, context, value, d )
else:
d.callback( result )
def or_tryNext( validators, context, value, d ):
result = defer.maybeDeferred\
( validators.pop(0).validate
, context
, value
)
result.addBoth( or_doTryNext, validators, context, value, d )
def or_validate( self, context, value ):
d = defer.Deferred()
or_tryNext( list(self.validators), context, value, d )
return d
@defer.inlineCallbacks
def call_validate( self, context, value ):
try:
result = yield defer.maybeDeferred\
( self.__func__
, context
, value
)
except Failure as e:
if not isinstance(e.value, Invalid):
raise
e = e.value
e.validator = self
raise e
else:
defer.returnValue( result )
def match_gotResult( result, self, value, d ):
if isinstance( result, Failure ):
if not isinstance(result.value, Invalid):
raise
d.errback( Invalid( value, self, matchType=self.type, criterion=result.value ) )
else:
val = value
if self.ignoreCase:
result = str(result).lower()
val = str(value).lower()
if val != result:
d.errback( Invalid( value, self, matchType=self.type, criterion=result ) )
else:
d.callback( value )
def match_on_value(self, context, value ):
if self.type is Match.REGEX:
if not self.criterion.match(value):
raise Invalid( value, self, matchType=self.type, criterion=self.criterion.pattern)
return value
elif self.type is Match.VALIDATOR:
compare = defer.maybeDeferred\
( self.criterion.validate
, context
, value
)
d = defer.Deferred()
compare.addBoth( match_gotResult, self, value, d )
return d
else:
compare = self.criterion
val = value
if self.ignoreCase:
compare = str(compare).lower()
val = str(value).lower()
if val != compare:
raise Invalid( value, self, matchType=self.type, criterion=compare )
return value
def if_gotResult( result, d, context, value ):
if isinstance( result, Failure ):
if not isinstance(result.value, Invalid):
d.errback( result )
else:
d.errback( result.value )
else:
d.callback( result )
def if_gotResultExpression( result, validator, d, context, value ):
if isinstance( result, Failure ):
if not isinstance( result.value, Invalid):
raise
value = defer.maybeDeferred\
( validator._else.validate, context, value
)
else:
value = defer.maybeDeferred\
( validator._then.validate, context, result
)
value.addBoth( if_gotResult, d, context, value )
def if_validate( self, context, value ):
d = defer.Deferred()
result = defer.maybeDeferred( self.criterion.validate, context, value )
result.addBoth( if_gotResultExpression, self, d, context, value )
return d
def schema_gotResult( result, resultset, key, isList, returnList ):
if returnList:
resultset.append( result )
else:
resultset[ key ] = result
return result
def schema_gotError( error, errorset, key ):
if isinstance( error, Failure ):
if not isinstance(error.value, Invalid):
raise error
error = error.value
errorset.append( error )
def schema__on_value_done( waste, d, schema, value, result, errors ):
if not errors:
d.callback( result )
else:
d.errback( errors.pop(0) )
def schema__createContextChildren_on_value_done( waste, d, schema, value, result, errors ):
if not errors:
d.callback( result )
else:
d.errback( Invalid( value, schema ) )
def schema__on_value( self, context, value ):
isList = isinstance(value, list) or isinstance(value,tuple) or isinstance(value,set)
if not isList and not isinstance( value, dict ):
raise Invalid( value, self, 'type')
extraFields = None
if not self.allowExtraFields:
if isList:
extraFields = max( len(value), len(self.index) )
else:
extraFields = list(value.keys())
if self.returnList:
result = []
else:
result = {}
numValues = len(value)
jobs = []
errorset = []
for pos in range(len(self.index)):
key = self.index[pos]
if isList:
if numValues>pos:
val = value[ pos ]
if not self.allowExtraFields:
extraFields-=1
else:
val = MISSING
else:
val = value.get( key, MISSING)
if not self.allowExtraFields and val is not MISSING:
try: extraFields.remove(key)
except: pass
job = defer.maybeDeferred\
( self.validators[ key ].validate
, context
, val
)
jobs.append\
( job.addCallback( schema_gotResult, result, key, isList, self.returnList )\
.addErrback( schema_gotError, errorset, key )
)
if extraFields:
raise Invalid( value, self, 'extraFields',extraFields=extraFields)
d = defer.Deferred()
jobs =defer.DeferredList( jobs )
jobs.addCallback\
( schema__on_value_done
, d
, self
, value
, result
, errorset
)
return d
def schema__createContextChildren_on_value( self, context, value ):
isList = isinstance(value, list) or isinstance(value,tuple) or isinstance(value,set)
if not isList and not isinstance( value, dict ):
raise Invalid( value, self, 'type')
extraFields = None
if not self.allowExtraFields:
if isList:
extraFields = max( len(value), len(self.index) )
else:
extraFields = list(value.keys())
errors = []
if self.returnList:
result = []
else:
result = {}
len_value = len(value)
len_index = len(self.index)
# populate
for pos in range(len_index):
key = self.index[pos]
childContext = context( key )
try:
childContext.validator = self.validators[ key ]
except KeyError:
raise SyntaxError("No validator set for %s" % childContext.path)
if isList:
if len_value<=pos:
childContext.__value__ = MISSING
else:
childContext.__value__ = value[ pos ]
else:
childContext.__value__ = value.get( key, MISSING )
if not self.allowExtraFields:
if isList:
extraFields-=1
else:
try: extraFields.remove(key)
except: pass
if extraFields:
raise Invalid( value, self, 'extraFields',extraFields=extraFields)
context.setIndexFunc( lambda index: self.index[index] )
jobs = []
# validate
for key in self.index:
jobs.append\
( context( key ).result\
.addCallback( schema_gotResult, result, key, isList, self.returnList )\
.addErrback( schema_gotError, errors, key )
)
d = defer.Deferred()
jobs = defer.DeferredList( jobs )
jobs.addCallback\
( schema__createContextChildren_on_value_done
, d
, self
, value
, result
, errors
)
return d
def forEach__on_value( self, context, value ):
if self.returnList:
result = []
else:
result = {}
isList = isinstance( value, list) or isinstance(value, tuple) or isinstance(value, set)
errorset = []
jobs = []
if isList or self.numericKeys:
for pos in range( len( value ) ):
if not isList:
val = value.get(str(pos),MISSING)
if val is MISSING:
raise Invalid( value, self, 'numericKeys', keys=list(value.keys()) )
else:
val = value[pos]
key = str(pos)
jobs.append\
( defer.maybeDeferred\
( self.validator.validate
, context, val
).addCallback\
( schema_gotResult
, result
, key
, isList
, self.returnList
)\
.addErrback\
( schema_gotError
, errorset
, key
)
)
else:
for (key, val) in value.items():
jobs.append\
( defer.maybeDeferred\
( self.validator.validate
, context, val
).addCallback\
( schema_gotResult
, result
, key
, isList
, self.returnList
)\
.addErrback\
( schema_gotError
, errorset
, key
)
)
d = defer.Deferred()
jobs = defer.DeferredList( jobs )
jobs.addCallback\
( schema__on_value_done
, d
, self
, value
, result
, errorset
)
return d
def forEach__createContextChildren_on_value( self, context, value ):
isList = isinstance( value, list) or isinstance(value, tuple) or isinstance(value, set)
if not isList:
if not isinstance(value, dict ):
raise Invalid( value, self,'type' )
if self.returnList:
result = []
else:
result = {}
errors = []
# populate
children = []
if isList or self.numericKeys:
context.setIndexFunc( lambda index: str(index) )
for pos in range( len( value ) ):
if not isList:
val = value.get(str(pos),MISSING)
if value.get(str(pos),MISSING) is MISSING:
context.setIndexFunc( None )
raise Invalid( value, self, 'numericKeys',keys=list(value.keys()))
else:
val = value[ pos ]
contextChild = context( str( pos ) )
contextChild.validator = self.validator
contextChild.__value__ = val
children.append( contextChild )
else:
context.setIndexFunc( None )
if self.returnList:
raise Invalid( value, self, 'listType' )
for (key,val) in value.items():
contextChild = context( key )
contextChild.validator = self.validator
contextChild.__value__ = val
children.append( contextChild )
jobs = []
#validate
for childContext in children:
jobs.append\
( childContext.validate()\
.addCallback\
( schema_gotResult
, result
, childContext.key
, isList
, self.returnList
)\
.addErrback\
( schema_gotError
, errors
, childContext.key
)
)
d = defer.Deferred()
jobs = defer.DeferredList( jobs )
jobs.addCallback\
( schema__createContextChildren_on_value_done
, d
, self
, value
, result
, errors
)
return d
@defer.inlineCallbacks
def field_validate(self, context, value):
fieldcontext = self.getField( context, self.path )
if not self.useResult:
result = fieldcontext.value
else:
try:
result = yield fieldcontext.result
except Invalid:
result = PASS
if self.validator is not None:
if result is not PASS:
result = yield defer.maybeDeferred\
( self.validator.validate
, fieldcontext, result
)
if self.writeToContext:
fieldcontext.__result__ = result
if self.copy:
if result is PASS:
defer.returnValue( value )
defer.returnValue( result )
defer.returnValue( value )
from twisted.names import client
from twisted.names.dns import Record_MX
from twisted.names.error import DNSNameError
from twisted.internet.defer import TimeoutError
def mxLookup_gotResult(result, d, value, validator, context ):
if isinstance( result, Failure ):
if isinstance(result.value, TimeoutError):
d.errback( Invalid( value, validator ) )
elif not isinstance(result.value, DNSNameError):
d.errback( result )
else:
d.errback( Invalid( value, validator ) )
return
(answers, auth, add) = result
if not len(answers):
d.errback( Invalid( value, validator ) )
else:
for record in answers:
if isinstance(record.payload,Record_MX):
d.callback( value )
return
d.errback( Invalid( value, validator ) )
mxLookup_resolver = client.Resolver('/etc/resolv.conf')
def mxLookup_on_value( self, context, value ):
d = defer.Deferred()
mxLookup_resolver.lookupMailExchange( value, [2,4,6,8,10] )\
.addBoth( mxLookup_gotResult, d, value, self, context )
return d
Context.validate = context_validate
Tag.validate = tag_validate
Compose.valdate = compose_validate
Tmp.validate = tmp_validate
Item.validate = item_validate
Not.validate = not_validate
And.validate = and_validate
Or.validate = or_validate
Call.validate = call_validate
Match.on_value = match_on_value
If.validate = if_validate
Schema._on_value = schema__on_value
Schema._createContextChildren_on_value = schema__createContextChildren_on_value
ForEach._on_value = forEach__on_value
ForEach._createContextChildren_on_value = forEach__createContextChildren_on_value
Field.validate = field_validate
MXLookup.on_value = mxLookup_on_value
monkeyPatch._isMonkeyPatched = True
0
Example 14
Project: feat Source File: test_agents_dns.py
@defer.inlineCallbacks
def testNSQueries(self):
@defer.inlineCallbacks
def check(exp_ns, exp_ttl, suffix='mydomain.lan', ns_ttl=300):
notify = dns_agent.NotifyConfiguration()
patron = log.LogProxy(self)
labour = production.Labour(
patron, notify, suffix, '127.0.0.1', 'ns.' + suffix, ns_ttl)
res = labour.startup(0)
self.assertTrue(res)
address = labour.get_host()
port = address.port
cresolver = client.Resolver(servers=[("127.0.0.1", port)])
res = yield cresolver.queryUDP(
[dns.Query(suffix, dns.NS)])
self.assertEqual(len(res.answers), 1)
answer = res.answers[0]
self.assertEqual(answer.ttl, exp_ttl)
payload = answer.payload
self.assertEqual(payload.TYPE, dns.NS)
self.assertEqual(payload.name.name, exp_ns)
yield labour.cleanup()
yield check("ns.mydomain.lan", 300)
yield check("ns.mydomain.lan", 42, ns_ttl=42)
yield check("ns.spam.lan", 300, suffix="spam.lan")
0
Example 15
Project: feat Source File: test_agents_dns.py
@defer.inlineCallbacks
def testCNAMEQueries(self):
@defer.inlineCallbacks
def check(name, alias, exp_ttl, aa_ttl=300):
notify = dns_agent.NotifyConfiguration()
suffix='mydomain.lan'
ns_ttl=300
patron = log.LogProxy(self)
labour = production.Labour(
patron, notify, suffix, '127.0.0.1', 'ns.' + suffix, ns_ttl)
res = labour.startup(0)
self.assertTrue(res)
name = format_name(name, suffix)
record = RecordCNAME(ip=name, ttl=aa_ttl)
labour.update_records(name, [record])
address = labour.get_host()
port = address.port
cresolver = client.Resolver(servers=[("127.0.0.1", port)])
res = yield cresolver.queryUDP([dns.Query(alias, dns.CNAME)])
for answer in res.answers:
self.assertEqual(answer.ttl, exp_ttl)
payload = answer.payload
self.assertEqual(payload.TYPE, dns.CNAME)
self.assertEqual(str(payload.name), name)
yield labour.cleanup()
yield check("spam", 'cname.example.com', 300)
yield check("spam", 'cname.example.com', 42, aa_ttl=42)
0
Example 16
Project: feat Source File: test_agents_dns.py
@defer.inlineCallbacks
def testAQueries(self):
@defer.inlineCallbacks
def check(name, exp_ips, exp_ttl, aa_ttl=300):
notify = dns_agent.NotifyConfiguration()
suffix='mydomain.lan'
ns_ttl=300
name = format_name(name, suffix)
patron = log.LogProxy(self)
labour = production.Labour(
patron, notify, suffix, '127.0.0.1', 'ns.' + suffix, ns_ttl)
res = labour.startup(0)
self.assertTrue(res)
records = [RecordA(ttl=aa_ttl, ip=ip)
for ip in exp_ips]
labour.update_records(name, records)
address = labour.get_host()
port = address.port
cresolver = client.Resolver(servers=[("127.0.0.1", port)])
res = yield cresolver.queryUDP([dns.Query(name, dns.A)])
result = []
for answer in res.answers:
self.assertEqual(answer.ttl, exp_ttl)
payload = answer.payload
self.assertEqual(payload.TYPE, dns.A)
result.append(socket.inet_ntoa(payload.address))
self.assertEqual(exp_ips, result)
yield labour.cleanup()
yield check("spam", [], 300)
yield check("spam", ["192.168.0.1"], 300)
yield check("spam", ["192.168.0.1"], 42, aa_ttl=42)
yield check("spam", ["192.168.0.1", "192.168.0.2"], 300)
0
Example 17
Project: SubliminalCollaborator Source File: common.py
def extractRecord(resolver, name, answers, level=10):
if not level:
return None
if hasattr(socket, 'inet_ntop'):
for r in answers:
if r.name == name and r.type == dns.A6:
return socket.inet_ntop(socket.AF_INET6, r.payload.address)
for r in answers:
if r.name == name and r.type == dns.AAAA:
return socket.inet_ntop(socket.AF_INET6, r.payload.address)
for r in answers:
if r.name == name and r.type == dns.A:
return socket.inet_ntop(socket.AF_INET, r.payload.address)
for r in answers:
if r.name == name and r.type == dns.CNAME:
result = extractRecord(
resolver, r.payload.name, answers, level - 1)
if not result:
return resolver.getHostByName(
str(r.payload.name), effort=level - 1)
return result
# No answers, but maybe there's a hint at who we should be asking about
# this
for r in answers:
if r.type == dns.NS:
from twisted.names import client
r = client.Resolver(servers=[(str(r.payload.name), dns.PORT)])
return r.lookupAddress(str(name)
).addCallback(
lambda (ans, auth, add):
extractRecord(r, name, ans + auth + add, level - 1))
0
Example 18
def _query(self, query, servers, timeout, filter):
"""
Issue one query and return a L{Deferred} which fires with its response.
@param query: The query to issue.
@type query: L{dns.Query}
@param servers: The servers which might have an answer for this
query.
@type servers: L{list} of L{tuple} of L{str} and L{int}
@param timeout: A timeout on how long to wait for the response.
@type timeout: L{tuple} of L{int}
@param filter: A flag indicating whether to filter the results. If
C{True}, the returned L{Deferred} will fire with a three-tuple of
lists of L{RRHeaders} (like the return value of the I{lookup*}
methods of L{IResolver}. IF C{False}, the result will be a
L{Message} instance.
@type filter: L{bool}
@return: A L{Deferred} which fires with the response or a timeout
error.
@rtype: L{Deferred}
"""
from twisted.names import client
r = client.Resolver(servers=servers, reactor=self._reactor)
d = r.queryUDP([query], timeout)
if filter:
d.addCallback(r.filterAnswers)
return d
0
Example 19
Project: SubliminalCollaborator Source File: test_client.py
def test_datagramQueryServerOrder(self):
"""
L{client.Resolver.queryUDP} should issue queries to its
L{dns.DNSDatagramProtocol} with server addresses taken from its own
C{servers} and C{dynServers} lists, proceeding through them in order
as L{DNSQueryTimeoutError}s occur.
"""
protocol = StubDNSDatagramProtocol()
servers = [object(), object()]
dynServers = [object(), object()]
resolver = client.Resolver(servers=servers)
resolver.dynServers = dynServers
resolver.protocol = protocol
expectedResult = object()
queryResult = resolver.queryUDP(None)
queryResult.addCallback(self.assertEqual, expectedResult)
self.assertEqual(len(protocol.queries), 1)
self.assertIdentical(protocol.queries[0][0], servers[0])
protocol.queries[0][-1].errback(DNSQueryTimeoutError(0))
self.assertEqual(len(protocol.queries), 2)
self.assertIdentical(protocol.queries[1][0], servers[1])
protocol.queries[1][-1].errback(DNSQueryTimeoutError(1))
self.assertEqual(len(protocol.queries), 3)
self.assertIdentical(protocol.queries[2][0], dynServers[0])
protocol.queries[2][-1].errback(DNSQueryTimeoutError(2))
self.assertEqual(len(protocol.queries), 4)
self.assertIdentical(protocol.queries[3][0], dynServers[1])
protocol.queries[3][-1].callback(expectedResult)
return queryResult
0
Example 20
Project: SubliminalCollaborator Source File: test_client.py
def test_singleConcurrentRequest(self):
"""
L{client.Resolver.query} only issues one request at a time per query.
Subsequent requests made before responses to prior ones are received
are queued and given the same response as is given to the first one.
"""
resolver = client.Resolver(servers=[('example.com', 53)])
resolver.protocol = StubDNSDatagramProtocol()
queries = resolver.protocol.queries
query = dns.Query('foo.example.com', dns.A, dns.IN)
# The first query should be passed to the underlying protocol.
firstResult = resolver.query(query)
self.assertEqual(len(queries), 1)
# The same query again should not be passed to the underlying protocol.
secondResult = resolver.query(query)
self.assertEqual(len(queries), 1)
# The response to the first query should be sent in response to both
# queries.
answer = object()
response = dns.Message()
response.answers.append(answer)
queries.pop()[-1].callback(response)
d = defer.gatherResults([firstResult, secondResult])
def cbFinished((firstResponse, secondResponse)):
self.assertEqual(firstResponse, ([answer], [], []))
self.assertEqual(secondResponse, ([answer], [], []))
0
Example 21
Project: SubliminalCollaborator Source File: test_client.py
def test_multipleConcurrentRequests(self):
"""
L{client.Resolver.query} issues a request for each different concurrent
query.
"""
resolver = client.Resolver(servers=[('example.com', 53)])
resolver.protocol = StubDNSDatagramProtocol()
queries = resolver.protocol.queries
# The first query should be passed to the underlying protocol.
firstQuery = dns.Query('foo.example.com', dns.A)
resolver.query(firstQuery)
self.assertEqual(len(queries), 1)
# A query for a different name is also passed to the underlying
# protocol.
secondQuery = dns.Query('bar.example.com', dns.A)
resolver.query(secondQuery)
self.assertEqual(len(queries), 2)
# A query for a different type is also passed to the underlying
# protocol.
thirdQuery = dns.Query('foo.example.com', dns.A6)
resolver.query(thirdQuery)
self.assertEqual(len(queries), 3)
0
Example 22
Project: SubliminalCollaborator Source File: test_client.py
def test_multipleSequentialRequests(self):
"""
After a response is received to a query issued with
L{client.Resolver.query}, another query with the same parameters
results in a new network request.
"""
resolver = client.Resolver(servers=[('example.com', 53)])
resolver.protocol = StubDNSDatagramProtocol()
queries = resolver.protocol.queries
query = dns.Query('foo.example.com', dns.A)
# The first query should be passed to the underlying protocol.
resolver.query(query)
self.assertEqual(len(queries), 1)
# Deliver the response.
queries.pop()[-1].callback(dns.Message())
# Repeating the first query should touch the protocol again.
resolver.query(query)
self.assertEqual(len(queries), 1)
0
Example 23
Project: SubliminalCollaborator Source File: test_client.py
def test_multipleConcurrentFailure(self):
"""
If the result of a request is an error response, the Deferreds for all
concurrently issued requests associated with that result fire with the
L{Failure}.
"""
resolver = client.Resolver(servers=[('example.com', 53)])
resolver.protocol = StubDNSDatagramProtocol()
queries = resolver.protocol.queries
query = dns.Query('foo.example.com', dns.A)
firstResult = resolver.query(query)
secondResult = resolver.query(query)
class ExpectedException(Exception):
pass
queries.pop()[-1].errback(failure.Failure(ExpectedException()))
return defer.gatherResults([
self.assertFailure(firstResult, ExpectedException),
self.assertFailure(secondResult, ExpectedException)])
0
Example 24
Project: SubliminalCollaborator Source File: test_client.py
def test_differentProtocol(self):
"""
L{client.Resolver._connectedProtocol} is called once each time a UDP
request needs to be issued and the resulting protocol instance is used
for that request.
"""
resolver = client.Resolver(servers=[('example.com', 53)])
protocols = []
class FakeProtocol(object):
def __init__(self):
self.transport = StubPort()
def query(self, address, query, timeout=10, id=None):
protocols.append(self)
return defer.succeed(dns.Message())
resolver._connectedProtocol = FakeProtocol
resolver.query(dns.Query('foo.example.com'))
resolver.query(dns.Query('bar.example.com'))
self.assertEqual(len(set(protocols)), 2)
0
Example 25
Project: SubliminalCollaborator Source File: test_client.py
def test_differentProtocolAfterTimeout(self):
"""
When a query issued by L{client.Resolver.query} times out, the retry
uses a new protocol instance.
"""
resolver = client.Resolver(servers=[('example.com', 53)])
protocols = []
results = [defer.fail(failure.Failure(DNSQueryTimeoutError(None))),
defer.succeed(dns.Message())]
class FakeProtocol(object):
def __init__(self):
self.transport = StubPort()
def query(self, address, query, timeout=10, id=None):
protocols.append(self)
return results.pop(0)
resolver._connectedProtocol = FakeProtocol
resolver.query(dns.Query('foo.example.com'))
self.assertEqual(len(set(protocols)), 2)
0
Example 26
Project: SubliminalCollaborator Source File: test_client.py
def test_protocolShutDown(self):
"""
After the L{Deferred} returned by L{DNSDatagramProtocol.query} is
called back, the L{DNSDatagramProtocol} is disconnected from its
transport.
"""
resolver = client.Resolver(servers=[('example.com', 53)])
protocols = []
result = defer.Deferred()
class FakeProtocol(object):
def __init__(self):
self.transport = StubPort()
def query(self, address, query, timeout=10, id=None):
protocols.append(self)
return result
resolver._connectedProtocol = FakeProtocol
resolver.query(dns.Query('foo.example.com'))
self.assertFalse(protocols[0].transport.disconnected)
result.callback(dns.Message())
self.assertTrue(protocols[0].transport.disconnected)
0
Example 27
Project: SubliminalCollaborator Source File: test_client.py
def test_protocolShutDownAfterTimeout(self):
"""
The L{DNSDatagramProtocol} created when an interim timeout occurs is
also disconnected from its transport after the Deferred returned by its
query method completes.
"""
resolver = client.Resolver(servers=[('example.com', 53)])
protocols = []
result = defer.Deferred()
results = [defer.fail(failure.Failure(DNSQueryTimeoutError(None))),
result]
class FakeProtocol(object):
def __init__(self):
self.transport = StubPort()
def query(self, address, query, timeout=10, id=None):
protocols.append(self)
return results.pop(0)
resolver._connectedProtocol = FakeProtocol
resolver.query(dns.Query('foo.example.com'))
self.assertFalse(protocols[1].transport.disconnected)
result.callback(dns.Message())
self.assertTrue(protocols[1].transport.disconnected)
0
Example 28
Project: SubliminalCollaborator Source File: test_client.py
def test_protocolShutDownAfterFailure(self):
"""
If the L{Deferred} returned by L{DNSDatagramProtocol.query} fires with
a failure, the L{DNSDatagramProtocol} is still disconnected from its
transport.
"""
class ExpectedException(Exception):
pass
resolver = client.Resolver(servers=[('example.com', 53)])
protocols = []
result = defer.Deferred()
class FakeProtocol(object):
def __init__(self):
self.transport = StubPort()
def query(self, address, query, timeout=10, id=None):
protocols.append(self)
return result
resolver._connectedProtocol = FakeProtocol
queryResult = resolver.query(dns.Query('foo.example.com'))
self.assertFalse(protocols[0].transport.disconnected)
result.errback(failure.Failure(ExpectedException()))
self.assertTrue(protocols[0].transport.disconnected)
return self.assertFailure(queryResult, ExpectedException)
0
Example 29
Project: SubliminalCollaborator Source File: test_names.py
def setUp(self):
self.factory = server.DNSServerFactory([
test_domain_com, reverse_domain, my_domain_com
], verbose=2)
p = dns.DNSDatagramProtocol(self.factory)
while 1:
listenerTCP = reactor.listenTCP(0, self.factory, interface="127.0.0.1")
# It's simpler to do the stop listening with addCleanup,
# even though we might not end up using this TCP port in
# the test (if the listenUDP below fails). Cleaning up
# this TCP port sooner than "cleanup time" would mean
# adding more code to keep track of the Deferred returned
# by stopListening.
self.addCleanup(listenerTCP.stopListening)
port = listenerTCP.getHost().port
try:
listenerUDP = reactor.listenUDP(port, p, interface="127.0.0.1")
except error.CannotListenError:
pass
else:
self.addCleanup(listenerUDP.stopListening)
break
self.listenerTCP = listenerTCP
self.listenerUDP = listenerUDP
self.resolver = client.Resolver(servers=[('127.0.0.1', port)])
0
Example 30
def testMissing(self):
resolvConf = self.mktemp()
r = client.Resolver(resolv=resolvConf)
self.assertEqual(r.dynServers, [('127.0.0.1', 53)])
r._parseCall.cancel()
0
Example 31
def setUp(self):
# Create a resolver pointed at an invalid server - we won't be hitting
# the network in any of these tests.
self.resolver = Resolver(servers=[('0.0.0.0', 0)])
0
Example 32
def test_no_answer(self):
"""
If a request returns a L{dns.NS} response, but we can't connect to the
given server, the request fails with the error returned at connection.
"""
def query(self, *args):
# Pop from the message list, so that it blows up if more queries
# are run than expected.
return succeed(messages.pop(0))
def queryProtocol(self, *args, **kwargs):
return defer.fail(socket.gaierror("Couldn't connect"))
resolver = Resolver(servers=[('0.0.0.0', 0)])
resolver._query = query
messages = []
# Let's patch dns.DNSDatagramProtocol.query, as there is no easy way to
# customize it.
self.patch(dns.DNSDatagramProtocol, "query", queryProtocol)
records = [
dns.RRHeader(name='fooba.com', type=dns.NS, cls=dns.IN, ttl=700,
auth=False,
payload=dns.Record_NS(name='ns.twistedmatrix.com',
ttl=700))]
m = dns.Message(id=999, answer=1, opCode=0, recDes=0, recAv=1, auth=1,
rCode=0, trunc=0, maxSize=0)
m.answers = records
messages.append(m)
return self.assertFailure(
resolver.getHostByName("fooby.com"), socket.gaierror)