DNSCacheManager=org.apache.jmeter.protocol.http.control.DNSCacheManager

DNSCachePanel=org.apache.jmeter.protocol.http.gui.DNSCachePanel

# dnsjava for DNSCacheManager

dnsjava.version             = 2.1.6

dnsjava.jar                 = dnsjava-${dnsjava.version}.jar

dnsjava.loc                 = ${maven2.repo}/dnsjava/dnsjava/${dnsjava.version}

dnsjava.md5                 = 4f95b291e738bb7c5a8773b22749afc3

    <pathelement location="${lib.dir}/${dnsjava.jar}"/>

        <process_jarfile jarname="dnsjava"/>

	<classpathentry kind="lib" path="lib/dnsjava-2.1.6.jar"/>

      <dnsjava.version>2.1.6</dnsjava.version>

	    <groupId>dnsjava</groupId>

	    <artifactId>dnsjava</artifactId>

	    <version>${dnsjava.version}</version>

      </dependency>

      <dependency>

clear_cache_each_iteration=Clear cache each iteration

dns_cache_manager_title=DNS Cache Manager

dns_hostname_or_ip=Hostname or IP address

dns_servers=DNS Servers

use_custom_dns_resolver=Use custom DNS resolver

use_system_dns_resolver=Use system DNS resolver

clear_cache_each_iteration=Vider le cache \u00E0 chaque it\u00E9ration ?

dns_cache_manager_title=Gestionnaire de cache DNS

dns_hostname_or_ip=Nom de machine ou adresse IP

dns_servers=Serveurs DNS

use_custom_dns_resolver=Utiliser un r\u00E9solveur DNS personnalis\u00E9

use_system_dns_resolver=Utiliser le r\u00E9solveur DNS syst\u00E8me (JVM)

/*

 * Licensed to the Apache Software Foundation (ASF) under one or more

 * contributor license agreements. See the NOTICE file distributed with this

 * work for additional information regarding copyright ownership. The ASF

 * licenses this file to You under the Apache License, Version 2.0 (the

 * "License"); you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 * 

 * http://www.apache.org/licenses/LICENSE-2.0

 * 

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT

 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

 * License for the specific language governing permissions and limitations under

 * the License.

 */

package org.apache.jmeter.protocol.http.control;

import java.io.Serializable;

import java.net.InetAddress;

import java.net.UnknownHostException;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.LinkedHashMap;

import java.util.Map;

import org.apache.http.conn.DnsResolver;

import org.apache.http.impl.conn.SystemDefaultDnsResolver;

import org.apache.jmeter.config.ConfigTestElement;

import org.apache.jmeter.engine.event.LoopIterationEvent;

import org.apache.jmeter.testelement.TestIterationListener;

import org.apache.jmeter.testelement.property.BooleanProperty;

import org.apache.jmeter.testelement.property.CollectionProperty;

import org.apache.jmeter.testelement.property.PropertyIterator;

import org.apache.jmeter.threads.JMeterContextService;

import org.apache.jorphan.logging.LoggingManager;

import org.apache.log.Logger;

import org.xbill.DNS.ARecord;

import org.xbill.DNS.Cache;

import org.xbill.DNS.ExtendedResolver;

import org.xbill.DNS.Lookup;

import org.xbill.DNS.Record;

import org.xbill.DNS.Resolver;

import org.xbill.DNS.SimpleResolver;

import org.xbill.DNS.TextParseException;

import org.xbill.DNS.Type;

/**

 * This config element provides ability to have flexible control over DNS

 * caching function. Depending on option from @see

 * {@link org.apache.jmeter.protocol.http.gui.DNSCachePanel}, either system or

 * custom resolver can be used. Custom resolver uses dnsjava library, and gives

 * ability to bypass both OS and JVM cache. It allows to use paradigm

 * "1 virtual user - 1 DNS cache" in performance tests.

 *

 * @since 2.12

 */

public class DNSCacheManager extends ConfigTestElement implements TestIterationListener, Serializable, DnsResolver {

    private static final long serialVersionUID = 2120L;

    private static final Logger log = LoggingManager.getLoggerForClass();

    private SystemDefaultDnsResolver systemDefaultDnsResolver = null;

    private Map<String, InetAddress[]> cache = null;

    private Resolver resolver = null;

    //++ JMX tag values

    public static final String CLEAR_CACHE_EACH_ITER = "DNSCacheManager.clearEachIteration"; // $NON-NLS-1$

    public static final String SERVERS = "DNSCacheManager.servers"; // $NON-NLS-1$

    public static final String IS_CUSTOM_RESOLVER = "DNSCacheManager.isCustomResolver"; // $NON-NLS-1$

    //-- JMX tag values

    public static final boolean DEFAULT_CLEAR_CACHE_EACH_ITER = false;

    public static final String DEFAULT_SERVERS = ""; // $NON-NLS-1$

    public static final boolean DEFAULT_IS_CUSTOM_RESOLVER = false;

    private final transient Cache lookupCache;

    // ensure that the initial DNSServers are copied to the per-thread instances

    public DNSCacheManager() {

        setProperty(new CollectionProperty(SERVERS, new ArrayList<String>()));

        //disabling cache

        lookupCache = new Cache();

        lookupCache.setMaxCache(0);

        lookupCache.setMaxEntries(0);

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public Object clone() {

        DNSCacheManager clone = (DNSCacheManager) super.clone();

        clone.systemDefaultDnsResolver = new SystemDefaultDnsResolver();

        clone.cache = new LinkedHashMap<String, InetAddress[]>();

        CollectionProperty dnsServers = getServers();

        try {

            clone.resolver = new ExtendedResolver();

            PropertyIterator dnsServIt = dnsServers.iterator();

            while (dnsServIt.hasNext()) {

                String dnsServer = dnsServIt.next().getStringValue();

                ((ExtendedResolver) clone.resolver).addResolver(new SimpleResolver(dnsServer));

            }

            // resolvers will be chosen via round-robin

            ((ExtendedResolver) clone.resolver).setLoadBalance(true);

        } catch (UnknownHostException uhe) {

            log.warn("Failed to create Extended resolver: " + uhe.getMessage());

        }

        return clone;

    }

    /**

     *

     * Resolves address using system or custom DNS resolver

     */

    @Override

    public InetAddress[] resolve(String host) throws UnknownHostException {

        if (cache.containsKey(host)) {

            if (log.isDebugEnabled()) {

                log.debug("Cache hit thr#" + JMeterContextService.getContext().getThreadNum() + ": " + host + "=>"

                        + Arrays.toString(cache.get(host)));

            }

            return cache.get(host);

        } else {

            InetAddress[] addresses = requestLookup(host);

            if (log.isDebugEnabled()) {

                log.debug("Cache miss thr#" + JMeterContextService.getContext().getThreadNum() + ": " + host + "=>"

                        + Arrays.toString(addresses));

            }

            cache.put(host, addresses);

            return addresses;

        }

    }

    /**

     * Sends DNS request via system or custom DNS resolver

     */

    private InetAddress[] requestLookup(String host) throws UnknownHostException {

        InetAddress[] addresses = null;

        if (getIsCustResolver() && ((ExtendedResolver) resolver).getResolvers().length > 1) {

            try {

                Lookup lookup = new Lookup(host, Type.A);

                lookup.setCache(lookupCache);

                lookup.setResolver(resolver);

                Record[] records = lookup.run();

                if (records.length == 0) {

                    throw new UnknownHostException("Failed to resolve host name: " + host);

                }

                addresses = new InetAddress[records.length];

                for (int i = 0; i < records.length; i++) {

                    addresses[i] = ((ARecord) records[i]).getAddress();

                }

            } catch (TextParseException tpe) {

                log.debug("Failed to create Lookup object: " + tpe);

            }

        } else {

            addresses = systemDefaultDnsResolver.resolve(host);

            if (log.isDebugEnabled()) {

                log.debug("Cache miss: " + host + " Thread #" + JMeterContextService.getContext().getThreadNum()

                        + ", resolved with system resolver into " + Arrays.toString(addresses));

            }

        }

        return addresses;

    }

    /**

     * {@inheritDoc} Clean DNS cache if appropriate check-box was selected

     */

    @Override

    public void testIterationStart(LoopIterationEvent event) {

        if (getClearEachIteration()) {

            this.cache.clear();

        }

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void clear() {

        super.clear();

        clearServers(); // ensure data is set up OK initially

    }

    /**

     * Remove all the servers.

     */

    private void clearServers() {

        log.debug("Clear all servers from store");

        setProperty(new CollectionProperty(SERVERS, new ArrayList<String>()));

    }

    public void addServer(String dnsServer) {

        getServers().addItem(dnsServer);

    }

    /**

     * Clean DNS cache each iteration

     * 

     * @return boolean

     */

    public boolean getClearEachIteration() {

        return getPropertyAsBoolean(CLEAR_CACHE_EACH_ITER);

    }

    /**

     * Clean DNS cache each iteration

     *

     */

    public void setClearEachIteration(boolean clear) {

        setProperty(new BooleanProperty(CLEAR_CACHE_EACH_ITER, clear));

    }

    public CollectionProperty getServers() {

        return (CollectionProperty) getProperty(SERVERS);

    }

    public boolean getIsCustResolver() {

        return this.getPropertyAsBoolean(IS_CUSTOM_RESOLVER, true);

    }

    public void setIsCustomResolver(boolean isCustomResolver) {

        this.setProperty(IS_CUSTOM_RESOLVER, isCustomResolver);

    }

}

/*

 * Licensed to the Apache Software Foundation (ASF) under one or more

 * contributor license agreements. See the NOTICE file distributed with this

 * work for additional information regarding copyright ownership. The ASF

 * licenses this file to You under the Apache License, Version 2.0 (the

 * "License"); you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 * 

 * http://www.apache.org/licenses/LICENSE-2.0

 * 

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT

 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

 * License for the specific language governing permissions and limitations under

 * the License.

 */

package org.apache.jmeter.protocol.http.gui;

import java.awt.BorderLayout;

import java.awt.Color;

import java.awt.Dimension;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import javax.swing.BorderFactory;

import javax.swing.ButtonGroup;

import javax.swing.JButton;

import javax.swing.JCheckBox;

import javax.swing.JPanel;

import javax.swing.JRadioButton;

import javax.swing.JScrollPane;

import javax.swing.JTable;

import javax.swing.ListSelectionModel;

import javax.swing.table.TableCellEditor;

import org.apache.jmeter.config.gui.AbstractConfigGui;

import org.apache.jmeter.gui.util.PowerTableModel;

import org.apache.jmeter.protocol.http.control.DNSCacheManager;

import org.apache.jmeter.testelement.TestElement;

import org.apache.jmeter.testelement.property.PropertyIterator;

import org.apache.jmeter.util.JMeterUtils;

import org.apache.jorphan.gui.GuiUtils;

import org.apache.jorphan.gui.layout.VerticalLayout;

/**

 * This gui part of @see

 * {@link org.apache.jmeter.protocol.http.control.DNSCacheManager}. Using

 * radiobuttons, user can switch between using system DNS resolver and custom

 * resolver. Custom resolver functionality is provided by dnsjava library.

 * "DNS servers" may contain one or more IP/Name of dns server for resolving

 * name DNS servers are chosen via round-robin. If table is empty - system

 * resolver is used.

 *

 * @since 2.12

 */

public class DNSCachePanel extends AbstractConfigGui implements ActionListener {

    private static final long serialVersionUID = 2120L;

//    public static final String CLEAR_CACHE_EACH_ITER = JMeterUtils.getResString("clear_cache_each_iteration");

    public static final String OPTIONS = JMeterUtils.getResString("option");

    private static final String ADD_COMMAND = JMeterUtils.getResString("add"); // $NON-NLS-1$

    private static final String DELETE_COMMAND = JMeterUtils.getResString("delete"); // $NON-NLS-1$

    private static final String SYS_RES_COMMAND = JMeterUtils.getResString("use_system_dns_resolver"); // $NON-NLS-1$

    private static final String CUST_RES_COMMAND = JMeterUtils.getResString("use_custom_dns_resolver"); // $NON-NLS-1$

    private JTable dnsServersTable;

    private JPanel dnsServersPanel;

    private JPanel dnsServButPanel;

    private PowerTableModel dnsServersTableModel;

    private JRadioButton sysResButton;

    private JRadioButton custResButton;

    private JButton deleteButton;

    private JButton addButton;

    private static final String[] COLUMN_RESOURCE_NAMES = {

        (JMeterUtils.getResString("dns_hostname_or_ip")), //$NON-NLS-1$

    };

    private static final Class<?>[] columnClasses = {

        String.class };

    private JCheckBox clearEachIteration;

    /**

     * Default constructor.

     */

    public DNSCachePanel() {

        init();

    }

    @Override

    public String getLabelResource() {

        return "dns_cache_manager_title";

    }

    /**

     * Modifies a given TestElement to mirror the data in the gui components.

     *

     * @see org.apache.jmeter.gui.JMeterGUIComponent#modifyTestElement(org.apache.jmeter.testelement.TestElement)

     */

    @Override

    public void modifyTestElement(TestElement dnsRes) {

        GuiUtils.stopTableEditing(dnsServersTable);

        dnsRes.clear();

        configureTestElement(dnsRes);

        if (dnsRes instanceof DNSCacheManager) {

            DNSCacheManager dnsCacheManager = (DNSCacheManager) dnsRes;

            for (int i = 0; i < dnsServersTableModel.getRowCount(); i++) {

                String server = (String) dnsServersTableModel.getRowData(i)[0];

                dnsCacheManager.addServer(server);

            }

            dnsCacheManager.setClearEachIteration(clearEachIteration.isSelected());

            dnsCacheManager.setIsCustomResolver(custResButton.isSelected());

        }

    }

    /**

     * Implements JMeterGUIComponent.clearGui

     */

    @Override

    public void clearGui() {

        super.clearGui();

        clearEachIteration.setSelected(true);

        dnsServersTableModel.clearData();

        deleteButton.setEnabled(custResButton.isSelected() && dnsServersTable.getColumnCount() > 0);

    }

    private void populateTable(DNSCacheManager resolver) {

        dnsServersTableModel.clearData();

        PropertyIterator iter = resolver.getServers().iterator();

        while (iter.hasNext()) {

            addServerToTable((String) iter.next().getObjectValue());

        }

    }

    @Override

    public TestElement createTestElement() {

        DNSCacheManager dnsCacheManager = new DNSCacheManager();

        modifyTestElement(dnsCacheManager);

        return dnsCacheManager;

    }

    @Override

    public void configure(TestElement el) {

        super.configure(el);

        populateTable((DNSCacheManager) el);

        clearEachIteration.setSelected(el.getPropertyAsBoolean(DNSCacheManager.CLEAR_CACHE_EACH_ITER, 

                DNSCacheManager.DEFAULT_CLEAR_CACHE_EACH_ITER));

        custResButton.setSelected(el.getPropertyAsBoolean(DNSCacheManager.IS_CUSTOM_RESOLVER, 

                DNSCacheManager.DEFAULT_IS_CUSTOM_RESOLVER));

    }

    private void init() {

        dnsServersTableModel = new PowerTableModel(COLUMN_RESOURCE_NAMES, columnClasses);

        clearEachIteration = new JCheckBox(JMeterUtils.getResString("clear_cache_each_iteration"), true); //$NON-NLS-1$

        setLayout(new BorderLayout());

        setBorder(makeBorder());

        JPanel northPanel = new JPanel();

        northPanel.setLayout(new VerticalLayout(5, VerticalLayout.BOTH));

        northPanel.add(makeTitlePanel());

        JPanel optionsPane = new JPanel();

        optionsPane.setBorder(BorderFactory.createTitledBorder(BorderFactory.createEtchedBorder(), OPTIONS)); // $NON-NLS-1$

        optionsPane.setLayout(new VerticalLayout(5, VerticalLayout.BOTH));

        optionsPane.add(clearEachIteration, BorderLayout.WEST);

        optionsPane.add(createChooseResPanel(), BorderLayout.SOUTH);

        northPanel.add(optionsPane);

        add(northPanel, BorderLayout.NORTH);

        dnsServersPanel = createDnsServersTablePanel();

        add(dnsServersPanel, BorderLayout.CENTER);

    }

    public JPanel createDnsServersTablePanel() {

        // create the JTable that holds header per row

        dnsServersTable = new JTable(dnsServersTableModel);

        dnsServersTable.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

        dnsServersTable.setPreferredScrollableViewportSize(new Dimension(400, 100));

        JPanel panel = new JPanel(new BorderLayout(0, 5));

        panel.setBorder(BorderFactory.createTitledBorder(BorderFactory.createEtchedBorder(),

                JMeterUtils.getResString("dns_servers"))); // $NON-NLS-1$

        JScrollPane dnsServScrollPane = new JScrollPane(dnsServersTable);

        panel.add(dnsServScrollPane, BorderLayout.CENTER);

        dnsServButPanel = createButtonPanel();

        panel.add(dnsServButPanel, BorderLayout.SOUTH);

        return panel;

    }

    private JPanel createChooseResPanel() {

        JPanel chooseResPanel = new JPanel(new BorderLayout(0, 5));

        sysResButton = new JRadioButton();

        sysResButton.setSelected(true);

        sysResButton.setText(SYS_RES_COMMAND);

        sysResButton.setToolTipText(SYS_RES_COMMAND);

        sysResButton.setEnabled(true);

        sysResButton.addActionListener(this);

        custResButton = new JRadioButton();

        custResButton.setSelected(false);

        custResButton.setText(CUST_RES_COMMAND);

        custResButton.setToolTipText(CUST_RES_COMMAND);

        custResButton.setEnabled(true);

        custResButton.addActionListener(this);

        ButtonGroup buttonGroup;

        buttonGroup = new ButtonGroup();

        buttonGroup.add(sysResButton);

        buttonGroup.add(custResButton);

        chooseResPanel.add(sysResButton, BorderLayout.WEST);

        chooseResPanel.add(custResButton, BorderLayout.CENTER);

        return chooseResPanel;

    }

    private JPanel createButtonPanel() {

        boolean tableEmpty = (dnsServersTableModel.getRowCount() == 0);

        addButton = createButton("add", 'A', ADD_COMMAND, custResButton.isSelected()); // $NON-NLS-1$

        deleteButton = createButton("delete", 'D', DELETE_COMMAND, !tableEmpty); // $NON-NLS-1$

        JPanel buttonPanel = new JPanel();

        buttonPanel.add(addButton, BorderLayout.WEST);

        buttonPanel.add(deleteButton, BorderLayout.LINE_END);

        return buttonPanel;

    }

    private JButton createButton(String resName, char mnemonic, String command, boolean enabled) {

        JButton button = new JButton(JMeterUtils.getResString(resName));

        button.setMnemonic(mnemonic);

        button.setActionCommand(command);

        button.setEnabled(enabled);

        button.addActionListener(this);

        return button;

    }

    private void addServerToTable(String dnsServer) {

        dnsServersTableModel.addRow(new Object[] {

            dnsServer });

    }

    @Override

    public void actionPerformed(ActionEvent e) {

        String action = e.getActionCommand();

        dnsServersTable.setEnabled(custResButton.isSelected());

        Color greyColor = new Color(240, 240, 240);

        Color blueColor = new Color(184, 207, 229);

        dnsServersTable.setBackground(sysResButton.isSelected() ? greyColor : Color.WHITE);

        dnsServersTable.setSelectionBackground(sysResButton.isSelected() ? greyColor : blueColor);

        addButton.setEnabled(custResButton.isSelected());

        deleteButton.setEnabled(custResButton.isSelected());

        if (custResButton.isSelected() && (dnsServersTableModel.getRowCount() > 0)) {

            deleteButton.setEnabled(true);

            addButton.setEnabled(true);

        }

        if (action.equals(DELETE_COMMAND)) {

            if (dnsServersTableModel.getRowCount() > 0) {

                // If a table cell is being edited, we must cancel the editing

                // before deleting the row.

                if (dnsServersTable.isEditing()) {

                    TableCellEditor cellEditor = dnsServersTable.getCellEditor(dnsServersTable.getEditingRow(),

                            dnsServersTable.getEditingColumn());

                    cellEditor.cancelCellEditing();

                }

                int rowSelected = dnsServersTable.getSelectedRow();

                if (rowSelected != -1) {

                    dnsServersTableModel.removeRow(rowSelected);

                    dnsServersTableModel.fireTableDataChanged();

                    if (dnsServersTableModel.getRowCount() == 0) {

                        deleteButton.setEnabled(false);

                    }

                    else {

                        int rowToSelect = rowSelected;

                        if (rowSelected >= dnsServersTableModel.getRowCount()) {

                            rowToSelect = rowSelected - 1;

                        }

                        dnsServersTable.setRowSelectionInterval(rowToSelect, rowToSelect);

                    }

                }

            }

        } else if (action.equals(ADD_COMMAND)) {

            // If a table cell is being edited, we should accept the current

            // value and stop the editing before adding a new row.

            GuiUtils.stopTableEditing(dnsServersTable);

            dnsServersTableModel.addNewRow();

            dnsServersTableModel.fireTableDataChanged();

            if (!deleteButton.isEnabled()) {

                deleteButton.setEnabled(true);

            }

            // Highlight (select) the appropriate row.

            int rowToSelect = dnsServersTableModel.getRowCount() - 1;

            dnsServersTable.setRowSelectionInterval(rowToSelect, rowToSelect);

        }

    }

}

import org.apache.http.conn.DnsResolver;

import org.apache.http.impl.conn.PoolingClientConnectionManager;

import org.apache.http.impl.conn.SchemeRegistryFactory;

import org.apache.http.impl.conn.SystemDefaultDnsResolver;

import org.apache.jmeter.protocol.http.control.DNSCacheManager;

                    "org.apache.jmeter.protocol.http.control.DNSCacheManager",

                    "org.apache.jmeter.protocol.http.gui.DNSCachePanel",

    public static final String DNS_CACHE_MANAGER = "HTTPSampler.dns_cache_manager"; // $NON-NLS-1$

        } else if (el instanceof DNSCacheManager) {

            setDNSResolver((DNSCacheManager) el);

    public DNSCacheManager getDNSResolver() {

        return (DNSCacheManager) getProperty(DNS_CACHE_MANAGER).getObjectValue();

    }

    public void setDNSResolver(DNSCacheManager cacheManager) {

        DNSCacheManager mgr = getDNSResolver();

        if (mgr != null) {

            log.warn("Existing DNSCacheManager " + mgr.getName() + " superseded by " + cacheManager.getName());

        }

        setProperty(new TestElementProperty(DNS_CACHE_MANAGER, cacheManager));

    }