Attachment #28398 for bug #52674

View | Details | Raw Unified | Return to bug 52674
Collapse All | Expand All




/*
 * 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.proxy;

import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Map;

import org.apache.commons.io.FileUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.jmeter.protocol.http.config.MultipartUrlConfig;
import org.apache.jmeter.protocol.http.control.gui.HttpTestSampleGui;
import org.apache.jmeter.protocol.http.sampler.HTTPSamplerBase;
import org.apache.jmeter.protocol.http.sampler.HTTPSamplerFactory;
import org.apache.jmeter.protocol.http.sampler.PostWriter;
import org.apache.jmeter.protocol.http.util.ConversionUtils;
import org.apache.jmeter.protocol.http.util.HTTPConstants;
import org.apache.jmeter.protocol.http.util.HTTPFileArg;
import org.apache.jmeter.testelement.TestElement;
import org.apache.jorphan.logging.LoggingManager;
import org.apache.log.Logger;

/**
 * Default implementation that handles classical HTTP textual + Multipart requests
 */
public class DefaultSamplerCreator extends AbstractSamplerCreator {
    private static final Logger log = LoggingManager.getLoggerForClass();
 
    /**
     * 
     */
    public DefaultSamplerCreator() {
    }

    /**
     * @see org.apache.jmeter.protocol.http.proxy.SamplerCreator#getManagedContentTypes()
     */
    public String[] getManagedContentTypes() {
        return new String[0];
    }

    /**
     * 
     * @see org.apache.jmeter.protocol.http.proxy.SamplerCreator#createSampler(org.apache.jmeter.protocol.http.proxy.HttpRequestHdr, java.util.Map, java.util.Map)
     */
    public HTTPSamplerBase createSampler(HttpRequestHdr request,
            Map<String, String> pageEncodings, Map<String, String> formEncodings) {
        // Instantiate the sampler
        HTTPSamplerBase sampler = HTTPSamplerFactory.newInstance(request.getHttpSamplerName());

        sampler.setProperty(TestElement.GUI_CLASS, HttpTestSampleGui.class.getName());

        // Defaults
        sampler.setFollowRedirects(false);
        sampler.setUseKeepAlive(true);

        if (log.isDebugEnabled()) {
            log.debug("getSampler: sampler path = " + sampler.getPath());
        }
        return sampler;
    }

    /**
     * @see org.apache.jmeter.protocol.http.proxy.SamplerCreator#populateSampler(org.apache.jmeter.protocol.http.sampler.HTTPSamplerBase, org.apache.jmeter.protocol.http.proxy.HttpRequestHdr, java.util.Map, java.util.Map)
     */
    public final void populateSampler(HTTPSamplerBase sampler,
            HttpRequestHdr request, Map<String, String> pageEncodings,
            Map<String, String> formEncodings) throws Exception{
        computeFromHeader(sampler, request, pageEncodings, formEncodings);

        computeFromPostBody(sampler, request);
        if (log.isDebugEnabled()) {
            log.debug("sampler path = " + sampler.getPath());
        }
    }

    /**
     * Compute sampler informations from Request Header
     * @param sampler {@link HTTPSamplerBase}
     * @param request {@link HttpRequestHdr}
     * @param pageEncodings Map<String, String>
     * @param formEncodings Map<String, String>
     * @throws Exception
     */
    protected void computeFromHeader(HTTPSamplerBase sampler,
            HttpRequestHdr request, Map<String, String> pageEncodings,
            Map<String, String> formEncodings) throws Exception {
        computeDomain(sampler, request);
        
        computeMethod(sampler, request);
        
        computePort(sampler, request);
        
        computeProtocol(sampler, request);

        computeContentEncoding(sampler, request,
                pageEncodings, formEncodings);

        computePath(sampler, request);
        
        computeSamplerName(sampler, request);
    }

    /**
     * Compute sampler informations from Request Header
     * @param sampler {@link HTTPSamplerBase}
     * @param request {@link HttpRequestHdr}
     * @throws Exception
     */
    protected void computeFromPostBody(HTTPSamplerBase sampler,
            HttpRequestHdr request) throws Exception {
        // If it was a HTTP GET request, then all parameters in the URL
        // has been handled by the sampler.setPath above, so we just need
        // to do parse the rest of the request if it is not a GET request
        if((!HTTPConstants.CONNECT.equals(request.getMethod())) && (!HTTPConstants.GET.equals(request.getMethod()))) {
            // Check if it was a multipart http post request
            final String contentType = request.getContentType();
            MultipartUrlConfig urlConfig = request.getMultipartConfig(contentType);
            String contentEncoding = sampler.getContentEncoding();
            // Get the post data using the content encoding of the request
            String postData = null;
            if (log.isDebugEnabled()) {
                if(!StringUtils.isEmpty(contentEncoding)) {
                    log.debug("Using encoding " + contentEncoding + " for request body");
                }
                else {
                    log.debug("No encoding found, using JRE default encoding for request body");
                }
            }
            
            
            if (!StringUtils.isEmpty(contentEncoding)) {
                postData = new String(request.getRawPostData(), contentEncoding);
            } else {
                // Use default encoding
                postData = new String(request.getRawPostData(), PostWriter.ENCODING);
            }
            
            if (urlConfig != null) {
                urlConfig.parseArguments(postData);
                // Tell the sampler to do a multipart post
                sampler.setDoMultipartPost(true);
                // Remove the header for content-type and content-length, since
                // those values will most likely be incorrect when the sampler
                // performs the multipart request, because the boundary string
                // will change
                request.getHeaderManager().removeHeaderNamed(HttpRequestHdr.CONTENT_TYPE);
                request.getHeaderManager().removeHeaderNamed(HttpRequestHdr.CONTENT_LENGTH);

                // Set the form data
                sampler.setArguments(urlConfig.getArguments());
                // Set the file uploads
                sampler.setHTTPFiles(urlConfig.getHTTPFileArgs().asArray());
            // used when postData is pure xml (eg. an xml-rpc call) or for PUT
            } else if (postData.trim().startsWith("<?") || "PUT".equals(sampler.getMethod())) {
                sampler.addNonEncodedArgument("", postData, "");
            } else if (contentType == null || contentType.startsWith(HTTPConstants.APPLICATION_X_WWW_FORM_URLENCODED) ){
                // It is the most common post request, with parameter name and values
                // We also assume this if no content type is present, to be most backwards compatible,
                // but maybe we should only parse arguments if the content type is as expected
                sampler.parseArguments(postData.trim(), contentEncoding); //standard name=value postData
            } else if (postData.length() > 0) {
                if (isBinaryContent(contentType)) {
                    try {
                        File tempDir = new File(getBinaryDirectory());
                        File out = File.createTempFile(request.getMethod(), getBinaryFileSuffix(), tempDir);
                        FileUtils.writeByteArrayToFile(out,request.getRawPostData());
                        HTTPFileArg [] files = {new HTTPFileArg(out.getPath(),"",contentType)};
                        sampler.setHTTPFiles(files);
                    } catch (IOException e) {
                        log.warn("Could not create binary file: "+e);
                    }
                } else {
                    // Just put the whole postbody as the value of a parameter
                    sampler.addNonEncodedArgument("", postData, ""); //used when postData is pure xml (ex. an xml-rpc call)
                }
            }
        }
    }

    /**
     * Compute sampler name
     * @param sampler {@link HTTPSamplerBase}
     * @param request {@link HttpRequestHdr}
     */
    protected void computeSamplerName(HTTPSamplerBase sampler,
            HttpRequestHdr request) {
        if (!HTTPConstants.CONNECT.equals(request.getMethod()) && isNumberRequests()) {
            incrementRequestNumber();
            sampler.setName(getRequestNumber() + " " + sampler.getPath());
        } else {
            sampler.setName(sampler.getPath());
        }
    }

    /**
     * Set path on sampler
     * @param sampler {@link HTTPSamplerBase}
     * @param request {@link HttpRequestHdr}
     */
    protected void computePath(HTTPSamplerBase sampler, HttpRequestHdr request) {
        if(sampler.getContentEncoding() != null) {
            sampler.setPath(request.getPath(), sampler.getContentEncoding());
        }
        else {
            // Although the spec says UTF-8 should be used for encoding URL parameters,
            // most browser use ISO-8859-1 for default if encoding is not known.
            // We use null for contentEncoding, then the url parameters will be added
            // with the value in the URL, and the "encode?" flag set to false
            sampler.setPath(request.getPath(), null);
        }
        if (log.isDebugEnabled()) {
            log.debug("Proxy: setting path: " + sampler.getPath());
        }
    }

    /**
     * Compute content encoding
     * @param sampler {@link HTTPSamplerBase}
     * @param request {@link HttpRequestHdr}
     * @param pageEncodings Map<String, String>
     * @param formEncodings Map<String, String>
     * @throws MalformedURLException
     */
    protected void computeContentEncoding(HTTPSamplerBase sampler,
            HttpRequestHdr request, Map<String, String> pageEncodings,
            Map<String, String> formEncodings) throws MalformedURLException {
        URL pageUrl = null;
        if(sampler.isProtocolDefaultPort()) {
            pageUrl = new URL(sampler.getProtocol(), sampler.getDomain(), request.getPath());
        }
        else {
            pageUrl = new URL(sampler.getProtocol(), sampler.getDomain(), 
                    sampler.getPort(), request.getPath());
        }
        String urlWithoutQuery = request.getUrlWithoutQuery(pageUrl);


        String contentEncoding = computeContentEncoding(request, pageEncodings,
                formEncodings, urlWithoutQuery);
        
        // Set the content encoding
        if(!StringUtils.isEmpty(contentEncoding)) {
            sampler.setContentEncoding(contentEncoding);
        } 
    }
    
    /**
     * Computes content encoding from request and if not found uses pageEncoding 
     * and formEncoding to see if URL was previously computed with a content type
     * @param sampler {@link HTTPSamplerBase}
     * @param request {@link HttpRequestHdr}
     * @param pageEncodings Map<String, String>
     * @param formEncodings Map<String, String>
     * @return String content encoding
     */
    protected String computeContentEncoding(HttpRequestHdr request,
            Map<String, String> pageEncodings,
            Map<String, String> formEncodings, String urlWithoutQuery) {
        // Check if the request itself tells us what the encoding is
        String contentEncoding = null;
        String requestContentEncoding = ConversionUtils.getEncodingFromContentType(
                request.getContentType());
        if(requestContentEncoding != null) {
            contentEncoding = requestContentEncoding;
        }
        else {
            // Check if we know the encoding of the page
            if (pageEncodings != null) {
                synchronized (pageEncodings) {
                    contentEncoding = pageEncodings.get(urlWithoutQuery);
                }
            }
            // Check if we know the encoding of the form
            if (formEncodings != null) {
                synchronized (formEncodings) {
                    String formEncoding = formEncodings.get(urlWithoutQuery);
                    // Form encoding has priority over page encoding
                    if (formEncoding != null) {
                        contentEncoding = formEncoding;
                    }
                }
            }
        }
        return contentEncoding;
    }

    /**
     * Set protocol on sampler
     * @param sampler {@link HTTPSamplerBase}
     * @param request {@link HttpRequestHdr}
     */
    protected void computeProtocol(HTTPSamplerBase sampler,
            HttpRequestHdr request) {
        sampler.setProtocol(request.getProtocol(sampler));
    }

    /**
     * Set Port on sampler
     * @param sampler {@link HTTPSamplerBase}
     * @param request {@link HttpRequestHdr}
     */
    protected void computePort(HTTPSamplerBase sampler, HttpRequestHdr request) {
        sampler.setPort(request.serverPort());
        if (log.isDebugEnabled()) {
            log.debug("Proxy: setting port: " + sampler.getPort());
        }
    }

    /**
     * Set method on sampler
     * @param sampler {@link HTTPSamplerBase}
     * @param request {@link HttpRequestHdr}
     */
    protected void computeMethod(HTTPSamplerBase sampler, HttpRequestHdr request) {
        sampler.setMethod(request.getMethod());
        log.debug("Proxy: setting method: " + sampler.getMethod());
    }

    /**
     * Set domain on sampler
     * @param sampler {@link HTTPSamplerBase}
     * @param request {@link HttpRequestHdr}
     */
    protected void computeDomain(HTTPSamplerBase sampler, HttpRequestHdr request) {
        sampler.setDomain(request.serverName());
        if (log.isDebugEnabled()) {
            log.debug("Proxy: setting server: " + sampler.getDomain());
        }
    }
}




/*
 * 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.proxy;

import java.util.Map;

import org.apache.jmeter.protocol.http.sampler.HTTPSamplerBase;

/**
 * Factory of sampler
 */
public interface SamplerCreator {
    
    /**
     * @return String[] array of Content types managed by Factory
     */
    public String[] getManagedContentTypes();

    /**
     * Create HTTPSamplerBase
     * @param request {@link HttpRequestHdr}
     * @param pageEncodings Map<String, String>
     * @param formEncodings Map<String, String>
     * @return {@link HTTPSamplerBase}
     */
    public HTTPSamplerBase createSampler(HttpRequestHdr request,
            Map<String, String> pageEncodings, Map<String, String> formEncodings);

    /**
     * Populate sampler from request
     * @param sampler {@link HTTPSamplerBase}
     * @param request {@link HttpRequestHdr}
     * @param pageEncodings Map<String, String>
     * @param formEncodings Map<String, String>
     * @throws Exception
     */
    public void populateSampler(HTTPSamplerBase sampler,
            HttpRequestHdr request, Map<String, String> pageEncodings,
            Map<String, String> formEncodings)
                    throws Exception;
}




/*
 * 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.proxy;

import java.util.HashSet;
import java.util.Set;
import java.util.StringTokenizer;

import org.apache.jmeter.util.JMeterUtils;

/**
 * Base class for SamplerCreator
 */
public abstract class AbstractSamplerCreator implements SamplerCreator {

    protected static final String HTTP = "http"; // $NON-NLS-1$
    protected static final String HTTPS = "https"; // $NON-NLS-1$

    /** Filetype to be used for the temporary binary files*/
    private static final String binaryFileSuffix =
        JMeterUtils.getPropDefault("proxy.binary.filesuffix",// $NON-NLS-1$
                                   ".binary"); // $NON-NLS-1$

    /** Which content-types will be treated as binary (exact match) */
    private static final Set<String> binaryContentTypes = new HashSet<String>();

    /** Where to store the temporary binary files */
    private static final String binaryDirectory =
        JMeterUtils.getPropDefault("proxy.binary.directory",// $NON-NLS-1$
                System.getProperty("user.dir")); // $NON-NLS-1$ proxy.binary.filetype=binary

    static {
        String binaries = JMeterUtils.getPropDefault("proxy.binary.types", // $NON-NLS-1$
                "application/x-amf,application/x-java-serialized-object"); // $NON-NLS-1$
        if (binaries.length() > 0){
            StringTokenizer s = new StringTokenizer(binaries,"|, ");// $NON-NLS-1$
            while (s.hasMoreTokens()){
               binaryContentTypes.add(s.nextToken());
            }
        }
    }
    
    /*
     * Optionally number the requests
     */
    private static final boolean numberRequests =
        JMeterUtils.getPropDefault("proxy.number.requests", false); // $NON-NLS-1$

    private static volatile int requestNumber = 0;// running number
    

    /**
     * 
     */
    /**
     * 
     */
    public AbstractSamplerCreator() {
        super();
    }

    /**
     * @return int request number
     */
    protected static int getRequestNumber() {
        return requestNumber;
    }

    /**
     * Increment request number
     */
    protected static void incrementRequestNumber() {
        requestNumber++;
    }

    /**
     * @return boolean is numbering requests is required
     */
    protected static boolean isNumberRequests() {
        return numberRequests;
    }

    /**
     * @param contentType String content type
     * @return true if contentType is part of binary declared types
     */
    protected boolean isBinaryContent(String contentType) {
        if (contentType == null) {
            return false;
        }
        return binaryContentTypes.contains(contentType);
    }
    
    /**
     * @return String binary file suffix
     */
    protected String getBinaryFileSuffix() {
        return binaryFileSuffix;
    }

    /**
     * @return String binary directory
     */
    protected String getBinaryDirectory() {
        return binaryDirectory;
    }
}




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

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.StringTokenizer;

import org.apache.commons.io.FileUtils;
import org.apache.commons.lang.CharUtils;
import org.apache.jmeter.protocol.http.config.MultipartUrlConfig;
import org.apache.jmeter.protocol.http.control.Header;
import org.apache.jmeter.protocol.http.control.HeaderManager;
import org.apache.jmeter.protocol.http.control.gui.HttpTestSampleGui;
import org.apache.jmeter.protocol.http.gui.HeaderPanel;
import org.apache.jmeter.protocol.http.sampler.HTTPSamplerBase;
import org.apache.jmeter.protocol.http.sampler.HTTPSamplerFactory;
import org.apache.jmeter.protocol.http.util.ConversionUtils;
import org.apache.jmeter.protocol.http.util.HTTPConstants;
import org.apache.jmeter.protocol.http.util.HTTPFileArg;
import org.apache.jmeter.testelement.TestElement;
import org.apache.jmeter.util.JMeterUtils;
import org.apache.jorphan.logging.LoggingManager;

    private static final String HTTP = "http"; // $NON-NLS-1$
    private static final String HTTPS = "https"; // $NON-NLS-1$
    private static final String PROXY_CONNECTION = "proxy-connection"; // $NON-NLS-1$
    public static final String CONTENT_TYPE = "content-type"; // $NON-NLS-1$
    public static final String CONTENT_LENGTH = "content-length"; // $NON-NLS-1$

    /** Filetype to be used for the temporary binary files*/
    private static final String binaryFileSuffix =
        JMeterUtils.getPropDefault("proxy.binary.filesuffix",// $NON-NLS-1$
                                   ".binary"); // $NON-NLS-1$

    /** Which content-types will be treated as binary (exact match) */
    private static final Set<String> binaryContentTypes = new HashSet<String>();

    /** Where to store the temporary binary files */
    private static final String binaryDirectory =
        JMeterUtils.getPropDefault("proxy.binary.directory",// $NON-NLS-1$
                System.getProperty("user.dir")); // $NON-NLS-1$ proxy.binary.filetype=binary

    static {
        String binaries = JMeterUtils.getPropDefault("proxy.binary.types", // $NON-NLS-1$
                "application/x-amf,application/x-java-serialized-object"); // $NON-NLS-1$
        if (binaries.length() > 0){
            StringTokenizer s = new StringTokenizer(binaries,"|, ");// $NON-NLS-1$
            while (s.hasMoreTokens()){
               binaryContentTypes.add(s.nextToken());
            }
        }
    }

    /**
     * Http Request method, uppercased, e.g. GET or POST.


    private HeaderManager headerManager;

    /*
     * Optionally number the requests
     */
    private static final boolean numberRequests =
        JMeterUtils.getPropDefault("proxy.number.requests", false); // $NON-NLS-1$

    private static volatile int requestNumber = 0;// running number

    public HttpRequestHdr() {
        this.httpSamplerName = ""; // $NON-NLS-1$
    }

        return headerManager;
    }

    public String getContentType() {
            throws MalformedURLException, IOException {
        // Instantiate the sampler
        HTTPSamplerBase sampler = HTTPSamplerFactory.newInstance(httpSamplerName);
        sampler.setProperty(TestElement.GUI_CLASS, HttpTestSampleGui.class.getName());

        // Populate the sampler
        populateSampler(sampler, pageEncodings, formEncodings);

        // Defaults
        sampler.setFollowRedirects(false);
        sampler.setUseKeepAlive(true);

        if (log.isDebugEnabled()) {
            log.debug("getSampler: sampler path = " + sampler.getPath());
        }
        return sampler;
    }

    private String getContentType() {
        Header contentTypeHeader = headers.get(CONTENT_TYPE);
        if (contentTypeHeader != null) {
            return contentTypeHeader.getValue();

        return false;
    }

    public MultipartUrlConfig getMultipartConfig(String contentType) {
        if(isMultipart(contentType)) {
            // Get the boundary string for the multiparts from the content type
            String boundaryString = contentType.substring(contentType.toLowerCase(java.util.Locale.ENGLISH).indexOf("boundary=") + "boundary=".length());

        return null;
    }

    private void populateSampler(
            HTTPSamplerBase sampler,
            Map<String, String> pageEncodings, Map<String, String> formEncodings)
            throws MalformedURLException, UnsupportedEncodingException {
        sampler.setDomain(serverName());
        if (log.isDebugEnabled()) {
            log.debug("Proxy: setting server: " + sampler.getDomain());
        }
        sampler.setMethod(method);
        log.debug("Proxy: setting method: " + sampler.getMethod());
        sampler.setPort(serverPort());
        if (log.isDebugEnabled()) {
            log.debug("Proxy: setting port: " + sampler.getPort());
        }
        if (url.indexOf("//") > -1) {
            String protocol = url.substring(0, url.indexOf(":"));
            if (log.isDebugEnabled()) {
                log.debug("Proxy: setting protocol to : " + protocol);
            }
            sampler.setProtocol(protocol);
        } else if (sampler.getPort() == HTTPConstants.DEFAULT_HTTPS_PORT) {
            sampler.setProtocol(HTTPS);
            if (log.isDebugEnabled()) {
                log.debug("Proxy: setting protocol to https");
            }
        } else {
            if (log.isDebugEnabled()) {
                log.debug("Proxy setting default protocol to: http");
            }
            sampler.setProtocol(HTTP);
        }

        URL pageUrl = null;
        if(sampler.isProtocolDefaultPort()) {
            pageUrl = new URL(sampler.getProtocol(), sampler.getDomain(), getPath());
        }
        else {
            pageUrl = new URL(sampler.getProtocol(), sampler.getDomain(), sampler.getPort(), getPath());
        }
        String urlWithoutQuery = getUrlWithoutQuery(pageUrl);


        // Check if the request itself tells us what the encoding is
        String contentEncoding = null;
        String requestContentEncoding = ConversionUtils.getEncodingFromContentType(getContentType());
        if(requestContentEncoding != null) {
            contentEncoding = requestContentEncoding;
        }
        else {
            // Check if we know the encoding of the page
            if (pageEncodings != null) {
                synchronized (pageEncodings) {
                    contentEncoding = pageEncodings.get(urlWithoutQuery);
                }
            }
            // Check if we know the encoding of the form
            if (formEncodings != null) {
                synchronized (formEncodings) {
                    String formEncoding = formEncodings.get(urlWithoutQuery);
                    // Form encoding has priority over page encoding
                    if (formEncoding != null) {
                        contentEncoding = formEncoding;
                    }
                }
            }
        }

        // Get the post data using the content encoding of the request
        String postData = null;
        if (log.isDebugEnabled()) {
            if(contentEncoding != null) {
                log.debug("Using encoding " + contentEncoding + " for request body");
            }
            else {
                log.debug("No encoding found, using JRE default encoding for request body");
            }
        }
        if (contentEncoding != null) {
            postData = new String(rawPostData, contentEncoding);
        } else {
            // Use default encoding
            postData = new String(rawPostData);
        }

        if(contentEncoding != null) {
            sampler.setPath(getPath(), contentEncoding);
        }
        else {
            // Although the spec says UTF-8 should be used for encoding URL parameters,
            // most browser use ISO-8859-1 for default if encoding is not known.
            // We use null for contentEncoding, then the url parameters will be added
            // with the value in the URL, and the "encode?" flag set to false
            sampler.setPath(getPath(), null);
        }
        if (log.isDebugEnabled()) {
            log.debug("Proxy: setting path: " + sampler.getPath());
        }
        if (!HTTPConstants.CONNECT.equals(getMethod()) && numberRequests) {
            requestNumber++;
            sampler.setName(requestNumber + " " + sampler.getPath());
        } else {
            sampler.setName(sampler.getPath());
        }

        // Set the content encoding
        if(contentEncoding != null) {
            sampler.setContentEncoding(contentEncoding);
        }

        // If it was a HTTP GET request, then all parameters in the URL
        // has been handled by the sampler.setPath above, so we just need
        // to do parse the rest of the request if it is not a GET request
        if((!HTTPConstants.CONNECT.equals(getMethod())) && (!HTTPConstants.GET.equals(method))) {
            // Check if it was a multipart http post request
            final String contentType = getContentType();
            MultipartUrlConfig urlConfig = getMultipartConfig(contentType);
            if (urlConfig != null) {
                urlConfig.parseArguments(postData);
                // Tell the sampler to do a multipart post
                sampler.setDoMultipartPost(true);
                // Remove the header for content-type and content-length, since
                // those values will most likely be incorrect when the sampler
                // performs the multipart request, because the boundary string
                // will change
                getHeaderManager().removeHeaderNamed(CONTENT_TYPE);
                getHeaderManager().removeHeaderNamed(CONTENT_LENGTH);

                // Set the form data
                sampler.setArguments(urlConfig.getArguments());
                // Set the file uploads
                sampler.setHTTPFiles(urlConfig.getHTTPFileArgs().asArray());
            // used when postData is pure xml (eg. an xml-rpc call) or for PUT
            } else if (postData.trim().startsWith("<?") || "PUT".equals(sampler.getMethod())) {
                sampler.addNonEncodedArgument("", postData, "");
            } else if (contentType == null || contentType.startsWith(HTTPConstants.APPLICATION_X_WWW_FORM_URLENCODED) ){
                // It is the most common post request, with parameter name and values
                // We also assume this if no content type is present, to be most backwards compatible,
                // but maybe we should only parse arguments if the content type is as expected
                sampler.parseArguments(postData.trim(), contentEncoding); //standard name=value postData
            } else if (postData.length() > 0) {
                if (isBinaryContent(contentType)) {
                    try {
                        File tempDir = new File(binaryDirectory);
                        File out = File.createTempFile(method, binaryFileSuffix, tempDir);
                        FileUtils.writeByteArrayToFile(out,rawPostData);
                        HTTPFileArg [] files = {new HTTPFileArg(out.getPath(),"",contentType)};
                        sampler.setHTTPFiles(files);
                    } catch (IOException e) {
                        log.warn("Could not create binary file: "+e);
                    }
                } else {
                    // Just put the whole postbody as the value of a parameter
                    sampler.addNonEncodedArgument("", postData, ""); //used when postData is pure xml (ex. an xml-rpc call)
                }
            }
        }
        if (log.isDebugEnabled()) {
            log.debug("sampler path = " + sampler.getPath());
        }
    }

    private boolean isBinaryContent(String contentType) {
        if (contentType == null) return false;
        return binaryContentTypes.contains(contentType);
    }

    //
    // Parsing Methods
    //

     *
     * @return server's internet name
     */
    public String serverName() {
        // chop to "server.name:x/thing"
        String str = url;
        int i = str.indexOf("//"); // $NON-NLS-1$

     *
     * @return server's port (or UNSPECIFIED if not found)
     */
    public int serverPort() {
        String str = url;
        // chop to "server.name:x/thing"
        int i = str.indexOf("//");

     *
     * @return the path
     */
    public String getPath() {
        String str = url;
        int i = str.indexOf("//");
        if (i > 0) {

//        return strBuff.toString();
//    }

    public String getUrlWithoutQuery(URL _url) {
        String fullUrl = _url.toString();
        String urlWithoutQuery = fullUrl;
        String query = _url.getQuery();

        }
        return urlWithoutQuery;
    }

    /**
     * @return the httpSamplerName
     */
    public String getHttpSamplerName() {
        return httpSamplerName;
    }

    /**
     * @return byte[] Raw post data
     */
    public byte[] getRawPostData() {
        return rawPostData;
    }

    /**
     * @param sampler {@link HTTPSamplerBase}
     * @return String Protocol (http or https)
     */
    public String getProtocol(HTTPSamplerBase sampler) {
        if (url.indexOf("//") > -1) {
            String protocol = url.substring(0, url.indexOf(":"));
            if (log.isDebugEnabled()) {
                log.debug("Proxy: setting protocol to : " + protocol);
            }
            return protocol;
        } else if (sampler.getPort() == HTTPConstants.DEFAULT_HTTPS_PORT) {
            if (log.isDebugEnabled()) {
                log.debug("Proxy: setting protocol to https");
            }
            return HTTPS;
        } else {
            if (log.isDebugEnabled()) {
                log.debug("Proxy setting default protocol to: http");
            }
            return HTTP;
        }
    }
}

Lines 109-114 Link Here

(-)src/protocol/http/org/apache/jmeter/protocol/http/proxy/Proxy.java (-4 / +6 lines)
109	private static final char[] KEY_PASSWORD =	109	private static final char[] KEY_PASSWORD =
110	JMeterUtils.getPropDefault("proxy.cert.keypassword","password").toCharArray(); // $NON-NLS-1$ $NON-NLS-2$	110	JMeterUtils.getPropDefault("proxy.cert.keypassword","password").toCharArray(); // $NON-NLS-1$ $NON-NLS-2$
111		111
		112	private static final SamplerCreatorFactory factory = new SamplerCreatorFactory();
		113
112	// Use with SSL connection	114	// Use with SSL connection
113	private OutputStream outStreamClient = null;	115	private OutputStream outStreamClient = null;
114		116
Lines 202-211 Link Here
202	request.parse(new BufferedInputStream(clientSocket.getInputStream()));	204	request.parse(new BufferedInputStream(clientSocket.getInputStream()));
203	}	205	}
204		206
205	// Populate the sampler. It is the same sampler as we sent into	207	SamplerCreator samplerCreator = factory.getSamplerCreator(request, pageEncodings, formEncodings);
206	// the constructor of the HttpRequestHdr instance above	208	sampler = samplerCreator.createSampler(request, pageEncodings, formEncodings);
207	sampler = request.getSampler(pageEncodings, formEncodings);	209	samplerCreator.populateSampler(sampler, request, pageEncodings, formEncodings);
208		210
209	/*	211	/*
210	* Create a Header Manager to ensure that the browsers headers are	212	* Create a Header Manager to ensure that the browsers headers are
211	* captured and sent to the server	213	* captured and sent to the server




/*
 * 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.proxy;

import java.lang.reflect.Modifier;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.jmeter.util.JMeterUtils;
import org.apache.jorphan.logging.LoggingManager;
import org.apache.jorphan.reflect.ClassFinder;
import org.apache.log.Logger;

/**
 * {@link SamplerCreator} factory
 */
public class SamplerCreatorFactory {
    private static final Logger log = LoggingManager.getLoggerForClass();

    private static final SamplerCreator DEFAULT_SAMPLER_CREATOR = new DefaultSamplerCreator();

    private Map<String, SamplerCreator> samplerCreatorMap = new HashMap<String, SamplerCreator>();

    /**
     * 
     */
    public SamplerCreatorFactory() {
        init();
    }
    
    /**
     * Initialize factory from classpath
     */
    private void init() {
        try {
            List<String> listClasses = ClassFinder.findClassesThatExtend(
                    JMeterUtils.getSearchPaths(), 
                    new Class[] {SamplerCreator.class }); 
            for (String strClassName : listClasses) {
                try {
                    log.info("Loading class:"+ strClassName);
                    Class<?> commandClass = Class.forName(strClassName);
                    if (!Modifier.isAbstract(commandClass.getModifiers())) {
                            log.info("Instantiating :"+ commandClass.getName());
                            SamplerCreator creator = (SamplerCreator) commandClass.newInstance();
                            String[] contentTypes = creator.getManagedContentTypes();
                            for (String contentType : contentTypes) {
                                if(log.isInfoEnabled()) {
                                    log.info("Registering samplerCreator "+commandClass.getName()+" for content type:"+contentType);
                                }
                                samplerCreatorMap.put(contentType, creator);
                            }                        
                    }
                } catch (Exception e) {
                    log.error("Exception registering "+SamplerCreator.class.getName() + " with implementation:"+strClassName, e);
                }
            }
        } catch (Exception e) {
            log.error("Exception finding implementations of "+SamplerCreator.class, e);
        }
    }

    /**
     * Gets {@link SamplerCreator} for content type, if none is found returns {@link DefaultSamplerCreator}
     * @param request {@link HttpRequestHdr}
     * @param pageEncodings Map<String, String> pageEncodings
     * @param formEncodings  Map<String, String> formEncodings
     * @return SamplerCreator
     */
    public SamplerCreator getSamplerCreator(HttpRequestHdr request,
            Map<String, String> pageEncodings, Map<String, String> formEncodings) {
        SamplerCreator creator = samplerCreatorMap.get(request.getContentType());
        if(creator == null) {
            return DEFAULT_SAMPLER_CREATOR;
        }
        return creator;
    }
}

Lines 569-575 Link Here

(-)test/src/org/apache/jmeter/protocol/http/proxy/TestHttpRequestHdr.java (-2 / +6 lines)
569	}	569	}
570		570
571	private HTTPSamplerBase getSamplerForRequest(String url, String request, String contentEncoding)	571	private HTTPSamplerBase getSamplerForRequest(String url, String request, String contentEncoding)
572	throws IOException {	572	throws Exception {
573	HttpRequestHdr req = new HttpRequestHdr();	573	HttpRequestHdr req = new HttpRequestHdr();
574	ByteArrayInputStream bis = null;	574	ByteArrayInputStream bis = null;
575	if(contentEncoding != null) {	575	if(contentEncoding != null) {
Lines 587-593 Link Here
587	if(url != null && contentEncoding != null) {	587	if(url != null && contentEncoding != null) {
588	pageEncodings.put(url, contentEncoding);	588	pageEncodings.put(url, contentEncoding);
589	}	589	}
590	return req.getSampler(pageEncodings, formEncodings);	590	SamplerCreatorFactory creatorFactory = new SamplerCreatorFactory();
		591	SamplerCreator creator = creatorFactory.getSamplerCreator(req, pageEncodings, formEncodings);
		592	HTTPSamplerBase sampler = creator.createSampler(req, pageEncodings, formEncodings);
		593	creator.populateSampler(sampler, req, pageEncodings, formEncodings);
		594	return sampler;
591	}	595	}
592		596
593	private void checkArgument(	597	private void checkArgument(

Return to bug 52674

Line 0 Link Here

(-)src/protocol/http/org/apache/jmeter/protocol/http/proxy/DefaultSamplerCreator.java (+349 lines)
		1	/*
		2	* Licensed to the Apache Software Foundation (ASF) under one or more
		3	* contributor license agreements. See the NOTICE file distributed with
		4	* this work for additional information regarding copyright ownership.
		5	* The ASF licenses this file to You under the Apache License, Version 2.0
		6	* (the "License"); you may not use this file except in compliance with
		7	* the License. You may obtain a copy of the License at
		8	*
		9	* http://www.apache.org/licenses/LICENSE-2.0
		10	*
		11	* Unless required by applicable law or agreed to in writing, software
		12	* distributed under the License is distributed on an "AS IS" BASIS,
		13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		14	* See the License for the specific language governing permissions and
		15	* limitations under the License.
		16	*
		17	*/
		18
		19	package org.apache.jmeter.protocol.http.proxy;
		20
		21	import java.io.File;
		22	import java.io.IOException;
		23	import java.net.MalformedURLException;
		24	import java.net.URL;
		25	import java.util.Map;
		26
		27	import org.apache.commons.io.FileUtils;
		28	import org.apache.commons.lang.StringUtils;
		29	import org.apache.jmeter.protocol.http.config.MultipartUrlConfig;
		30	import org.apache.jmeter.protocol.http.control.gui.HttpTestSampleGui;
		31	import org.apache.jmeter.protocol.http.sampler.HTTPSamplerBase;
		32	import org.apache.jmeter.protocol.http.sampler.HTTPSamplerFactory;
		33	import org.apache.jmeter.protocol.http.sampler.PostWriter;
		34	import org.apache.jmeter.protocol.http.util.ConversionUtils;
		35	import org.apache.jmeter.protocol.http.util.HTTPConstants;
		36	import org.apache.jmeter.protocol.http.util.HTTPFileArg;
		37	import org.apache.jmeter.testelement.TestElement;
		38	import org.apache.jorphan.logging.LoggingManager;
		39	import org.apache.log.Logger;
		40
		41	/**
		42	* Default implementation that handles classical HTTP textual + Multipart requests
		43	*/
		44	public class DefaultSamplerCreator extends AbstractSamplerCreator {
		45	private static final Logger log = LoggingManager.getLoggerForClass();
		46
		47	/**
		48	*
		49	*/
		50	public DefaultSamplerCreator() {
		51	}
		52
		53	/**
		54	* @see org.apache.jmeter.protocol.http.proxy.SamplerCreator#getManagedContentTypes()
		55	*/
		56	public String[] getManagedContentTypes() {
		57	return new String[0];
		58	}
		59
		60	/**
		61	*
		62	* @see org.apache.jmeter.protocol.http.proxy.SamplerCreator#createSampler(org.apache.jmeter.protocol.http.proxy.HttpRequestHdr, java.util.Map, java.util.Map)
		63	*/
		64	public HTTPSamplerBase createSampler(HttpRequestHdr request,
65	Map<String, String> pageEncodings, Map<String, String> formEncodings) {
66	// Instantiate the sampler
67	HTTPSamplerBase sampler = HTTPSamplerFactory.newInstance(request.getHttpSamplerName());
68
69	sampler.setProperty(TestElement.GUI_CLASS, HttpTestSampleGui.class.getName());
70
71	// Defaults
72	sampler.setFollowRedirects(false);
73	sampler.setUseKeepAlive(true);
74
75	if (log.isDebugEnabled()) {
76	log.debug("getSampler: sampler path = " + sampler.getPath());
77	}
78	return sampler;
79	}
80
81	/**
82	* @see org.apache.jmeter.protocol.http.proxy.SamplerCreator#populateSampler(org.apache.jmeter.protocol.http.sampler.HTTPSamplerBase, org.apache.jmeter.protocol.http.proxy.HttpRequestHdr, java.util.Map, java.util.Map)
83	*/
84	public final void populateSampler(HTTPSamplerBase sampler,
85	HttpRequestHdr request, Map<String, String> pageEncodings,
86	Map<String, String> formEncodings) throws Exception{
87	computeFromHeader(sampler, request, pageEncodings, formEncodings);
88
89	computeFromPostBody(sampler, request);
90	if (log.isDebugEnabled()) {
91	log.debug("sampler path = " + sampler.getPath());
92	}
93	}
94
95	/**
96	* Compute sampler informations from Request Header
97	* @param sampler {@link HTTPSamplerBase}
98	* @param request {@link HttpRequestHdr}
99	* @param pageEncodings Map<String, String>
100	* @param formEncodings Map<String, String>
101	* @throws Exception
102	*/
103	protected void computeFromHeader(HTTPSamplerBase sampler,
104	HttpRequestHdr request, Map<String, String> pageEncodings,
105	Map<String, String> formEncodings) throws Exception {
106	computeDomain(sampler, request);
107
108	computeMethod(sampler, request);
109
110	computePort(sampler, request);
111
112	computeProtocol(sampler, request);
113
114	computeContentEncoding(sampler, request,
115	pageEncodings, formEncodings);
116
117	computePath(sampler, request);
118
119	computeSamplerName(sampler, request);
120	}
121
122	/**
123	* Compute sampler informations from Request Header
124	* @param sampler {@link HTTPSamplerBase}
125	* @param request {@link HttpRequestHdr}
126	* @throws Exception
127	*/
128	protected void computeFromPostBody(HTTPSamplerBase sampler,
129	HttpRequestHdr request) throws Exception {
130	// If it was a HTTP GET request, then all parameters in the URL
131	// has been handled by the sampler.setPath above, so we just need
132	// to do parse the rest of the request if it is not a GET request
133	if((!HTTPConstants.CONNECT.equals(request.getMethod())) && (!HTTPConstants.GET.equals(request.getMethod()))) {
134	// Check if it was a multipart http post request
135	final String contentType = request.getContentType();
136	MultipartUrlConfig urlConfig = request.getMultipartConfig(contentType);
137	String contentEncoding = sampler.getContentEncoding();
138	// Get the post data using the content encoding of the request
139	String postData = null;
140	if (log.isDebugEnabled()) {
141	if(!StringUtils.isEmpty(contentEncoding)) {
142	log.debug("Using encoding " + contentEncoding + " for request body");
143	}
144	else {
145	log.debug("No encoding found, using JRE default encoding for request body");
146	}
147	}
148
149
150	if (!StringUtils.isEmpty(contentEncoding)) {
151	postData = new String(request.getRawPostData(), contentEncoding);
152	} else {
153	// Use default encoding
154	postData = new String(request.getRawPostData(), PostWriter.ENCODING);
155	}
156
157	if (urlConfig != null) {
158	urlConfig.parseArguments(postData);
159	// Tell the sampler to do a multipart post
160	sampler.setDoMultipartPost(true);
161	// Remove the header for content-type and content-length, since
162	// those values will most likely be incorrect when the sampler
163	// performs the multipart request, because the boundary string
164	// will change
165	request.getHeaderManager().removeHeaderNamed(HttpRequestHdr.CONTENT_TYPE);
166	request.getHeaderManager().removeHeaderNamed(HttpRequestHdr.CONTENT_LENGTH);
167
168	// Set the form data
169	sampler.setArguments(urlConfig.getArguments());
170	// Set the file uploads
171	sampler.setHTTPFiles(urlConfig.getHTTPFileArgs().asArray());
172	// used when postData is pure xml (eg. an xml-rpc call) or for PUT
173	} else if (postData.trim().startsWith("<?") \|\| "PUT".equals(sampler.getMethod())) {
174	sampler.addNonEncodedArgument("", postData, "");
175	} else if (contentType == null \|\| contentType.startsWith(HTTPConstants.APPLICATION_X_WWW_FORM_URLENCODED) ){
176	// It is the most common post request, with parameter name and values
177	// We also assume this if no content type is present, to be most backwards compatible,
178	// but maybe we should only parse arguments if the content type is as expected
179	sampler.parseArguments(postData.trim(), contentEncoding); //standard name=value postData
180	} else if (postData.length() > 0) {
181	if (isBinaryContent(contentType)) {
182	try {
183	File tempDir = new File(getBinaryDirectory());
184	File out = File.createTempFile(request.getMethod(), getBinaryFileSuffix(), tempDir);
185	FileUtils.writeByteArrayToFile(out,request.getRawPostData());
186	HTTPFileArg [] files = {new HTTPFileArg(out.getPath(),"",contentType)};
187	sampler.setHTTPFiles(files);
188	} catch (IOException e) {
189	log.warn("Could not create binary file: "+e);
190	}
191	} else {
192	// Just put the whole postbody as the value of a parameter
193	sampler.addNonEncodedArgument("", postData, ""); //used when postData is pure xml (ex. an xml-rpc call)
194	}
195	}
196	}
197	}
198
199	/**
200	* Compute sampler name
201	* @param sampler {@link HTTPSamplerBase}
202	* @param request {@link HttpRequestHdr}
203	*/
204	protected void computeSamplerName(HTTPSamplerBase sampler,
205	HttpRequestHdr request) {
206	if (!HTTPConstants.CONNECT.equals(request.getMethod()) && isNumberRequests()) {
207	incrementRequestNumber();
208	sampler.setName(getRequestNumber() + " " + sampler.getPath());
209	} else {
210	sampler.setName(sampler.getPath());
211	}
212	}
213
214	/**
215	* Set path on sampler
216	* @param sampler {@link HTTPSamplerBase}
217	* @param request {@link HttpRequestHdr}
218	*/
219	protected void computePath(HTTPSamplerBase sampler, HttpRequestHdr request) {
220	if(sampler.getContentEncoding() != null) {
221	sampler.setPath(request.getPath(), sampler.getContentEncoding());
222	}
223	else {
224	// Although the spec says UTF-8 should be used for encoding URL parameters,
225	// most browser use ISO-8859-1 for default if encoding is not known.
226	// We use null for contentEncoding, then the url parameters will be added
227	// with the value in the URL, and the "encode?" flag set to false
228	sampler.setPath(request.getPath(), null);
229	}
230	if (log.isDebugEnabled()) {
231	log.debug("Proxy: setting path: " + sampler.getPath());
232	}
233	}
234
235	/**
236	* Compute content encoding
237	* @param sampler {@link HTTPSamplerBase}
238	* @param request {@link HttpRequestHdr}
239	* @param pageEncodings Map<String, String>
240	* @param formEncodings Map<String, String>
241	* @throws MalformedURLException
242	*/
243	protected void computeContentEncoding(HTTPSamplerBase sampler,
244	HttpRequestHdr request, Map<String, String> pageEncodings,
245	Map<String, String> formEncodings) throws MalformedURLException {
246	URL pageUrl = null;
247	if(sampler.isProtocolDefaultPort()) {
248	pageUrl = new URL(sampler.getProtocol(), sampler.getDomain(), request.getPath());
249	}
250	else {
251	pageUrl = new URL(sampler.getProtocol(), sampler.getDomain(),
252	sampler.getPort(), request.getPath());
253	}
254	String urlWithoutQuery = request.getUrlWithoutQuery(pageUrl);
255
256
257	String contentEncoding = computeContentEncoding(request, pageEncodings,
258	formEncodings, urlWithoutQuery);
259
260	// Set the content encoding
261	if(!StringUtils.isEmpty(contentEncoding)) {
262	sampler.setContentEncoding(contentEncoding);
263	}
264	}
265
266	/**
267	* Computes content encoding from request and if not found uses pageEncoding
268	* and formEncoding to see if URL was previously computed with a content type
269	* @param sampler {@link HTTPSamplerBase}
270	* @param request {@link HttpRequestHdr}
271	* @param pageEncodings Map<String, String>
272	* @param formEncodings Map<String, String>
273	* @return String content encoding
274	*/
275	protected String computeContentEncoding(HttpRequestHdr request,
276	Map<String, String> pageEncodings,
277	Map<String, String> formEncodings, String urlWithoutQuery) {
278	// Check if the request itself tells us what the encoding is
279	String contentEncoding = null;
280	String requestContentEncoding = ConversionUtils.getEncodingFromContentType(
281	request.getContentType());
282	if(requestContentEncoding != null) {
283	contentEncoding = requestContentEncoding;
284	}
285	else {
286	// Check if we know the encoding of the page
287	if (pageEncodings != null) {
288	synchronized (pageEncodings) {
289	contentEncoding = pageEncodings.get(urlWithoutQuery);
290	}
291	}
292	// Check if we know the encoding of the form
293	if (formEncodings != null) {
294	synchronized (formEncodings) {
295	String formEncoding = formEncodings.get(urlWithoutQuery);
296	// Form encoding has priority over page encoding
297	if (formEncoding != null) {
298	contentEncoding = formEncoding;
299	}
300	}
301	}
302	}
303	return contentEncoding;
304	}
305
306	/**
307	* Set protocol on sampler
308	* @param sampler {@link HTTPSamplerBase}
309	* @param request {@link HttpRequestHdr}
310	*/
311	protected void computeProtocol(HTTPSamplerBase sampler,
312	HttpRequestHdr request) {
313	sampler.setProtocol(request.getProtocol(sampler));
314	}
315
316	/**
317	* Set Port on sampler
318	* @param sampler {@link HTTPSamplerBase}
319	* @param request {@link HttpRequestHdr}
320	*/
321	protected void computePort(HTTPSamplerBase sampler, HttpRequestHdr request) {
322	sampler.setPort(request.serverPort());
323	if (log.isDebugEnabled()) {
324	log.debug("Proxy: setting port: " + sampler.getPort());
325	}
326	}
327
328	/**
329	* Set method on sampler
330	* @param sampler {@link HTTPSamplerBase}
331	* @param request {@link HttpRequestHdr}
332	*/
333	protected void computeMethod(HTTPSamplerBase sampler, HttpRequestHdr request) {
334	sampler.setMethod(request.getMethod());
335	log.debug("Proxy: setting method: " + sampler.getMethod());
336	}
337
338	/**
339	* Set domain on sampler
340	* @param sampler {@link HTTPSamplerBase}
341	* @param request {@link HttpRequestHdr}
342	*/
343	protected void computeDomain(HTTPSamplerBase sampler, HttpRequestHdr request) {
344	sampler.setDomain(request.serverName());
345	if (log.isDebugEnabled()) {
346	log.debug("Proxy: setting server: " + sampler.getDomain());
347	}
348	}
349	}