twisted.names.client.Resolver

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 7

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

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

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)

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

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

Example 6

Project: SubliminalCollaborator Source File: secondary.py
Function: transfer
    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
            )

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)

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

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)

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)

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
            )

Example 12

Project: SubliminalCollaborator Source File: test_names.py
Function: test_empty
    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()

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

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

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)

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)

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

Example 18

Project: SubliminalCollaborator Source File: root.py
Function: query
    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

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

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

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)

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)

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

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)

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)

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)

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)

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)

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

Example 30

Project: SubliminalCollaborator Source File: test_names.py
Function: test_missing
    def testMissing(self):
        resolvConf = self.mktemp()
        r = client.Resolver(resolv=resolvConf)
        self.assertEqual(r.dynServers, [('127.0.0.1', 53)])
        r._parseCall.cancel()

Example 31

Project: SubliminalCollaborator Source File: test_names.py
Function: set_up
    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)])

Example 32

Project: SubliminalCollaborator Source File: test_names.py
Function: test_no_answer
    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)