testTruncated0() — netty Function Reference

Source Code

resolver-dns/src/test/java/io/netty/resolver/dns/DnsNameResolverTest.java lines 3329–3441

    private static void testTruncated0(DnsNameResolverChannelStrategy strategy,
                                       boolean tcpFallback, final boolean truncatedBecauseOfMtu) throws IOException {
        ServerSocket serverSocket = null;
        final String host = "somehost.netty.io";
        final String txt = "this is a txt record";
        final AtomicReference<DnsMessage> messageRef = new AtomicReference<DnsMessage>();

        TestDnsServer dnsServer2 = new TestDnsServer(new RecordStore() {
            @Override
            public Set<ResourceRecord> getRecords(QuestionRecord question) {
                String name = question.getDomainName();
                if (name.equals(host)) {
                    return Collections.<ResourceRecord>singleton(
                            new TestDnsServer.TestResourceRecord(name, RecordType.TXT,
                                    Collections.<String, Object>singletonMap(
                                            DnsAttribute.CHARACTER_STRING.toLowerCase(), txt)));
                }
                return null;
            }
        }) {
            @Override
            protected DnsMessage filterMessage(DnsMessage message) {
                // Store a original message so we can replay it later on.
                messageRef.set(message);

                if (!truncatedBecauseOfMtu) {
                    // Create a copy of the message but set the truncated flag.
                    DnsMessageModifier modifier = modifierFrom(message);
                    modifier.setTruncated(true);
                    return modifier.getDnsMessage();
                }
                return message;
            }
        };
        DnsNameResolver resolver = null;
        try {
            DnsNameResolverBuilder builder = newResolver(strategy);
            final DatagramChannel datagramChannel = new NioDatagramChannel();
            ChannelFactory<DatagramChannel> channelFactory = new ChannelFactory<DatagramChannel>() {
                @Override
                public DatagramChannel newChannel() {
                    return datagramChannel;
                }
            };
            builder.datagramChannelFactory(channelFactory);
            if (tcpFallback) {
                // If we are configured to use TCP as a fallback also bind a TCP socket
                serverSocket = startDnsServerAndCreateServerSocket(dnsServer2);
                // If we are configured to use TCP as a fallback also bind a TCP socket
                builder.socketChannelType(NioSocketChannel.class);
            } else {
                dnsServer2.start();
            }
            builder.queryTimeoutMillis(10000)
                    .resolvedAddressTypes(ResolvedAddressTypes.IPV4_PREFERRED)
                    .maxQueriesPerResolve(16)
                    .nameServerProvider(new SingletonDnsServerAddressStreamProvider(dnsServer2.localAddress()));
            resolver = builder.build();
            if (truncatedBecauseOfMtu) {
                datagramChannel.pipeline().addFirst(new ChannelInboundHandlerAdapter() {
                    @Override
                    public void channelRead(ChannelHandlerContext ctx, Object msg) {
                        if (msg instanceof DatagramPacket) {
                            // Truncate the packet by 1 byte.
                            DatagramPacket packet = (DatagramPacket) msg;
                            packet.content().writerIndex(packet.content().writerIndex() - 1);
                        }
                        ctx.fireChannelRead(msg);
                    }
                });
            }
            Future<AddressedEnvelope<DnsResponse, InetSocketAddress>> envelopeFuture = resolver.query(
                    new DefaultDnsQuestion(host, DnsRecordType.TXT));

            if (tcpFallback) {
                // If we are configured to use TCP as a fallback lets replay the dns message over TCP
                Socket socket = serverSocket.accept();
                responseViaSocket(socket, messageRef.get());

                // Let's wait until we received the envelope before closing the socket.
                envelopeFuture.syncUninterruptibly();