vlsi commented on code in PR #6736: URL: https://github.com/apache/jmeter/pull/6736#discussion_r3786646039
########## src/protocol/http/src/main/java/org/apache/jmeter/protocol/http/curl/CurlCommandFormatter.java: ########## @@ -0,0 +1,268 @@ +/* + * 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.curl; + +import java.net.URL; +import java.util.ArrayList; +import java.util.List; +import java.util.Locale; +import java.util.Set; + +import org.apache.jmeter.config.Argument; +import org.apache.jmeter.protocol.http.config.MultipartUrlConfig; +import org.apache.jmeter.protocol.http.sampler.HTTPSampleResult; +import org.apache.jmeter.protocol.http.sampler.PostWriter; +import org.apache.jmeter.protocol.http.util.HTTPConstants; +import org.apache.jmeter.protocol.http.util.HTTPFileArg; +import org.apache.jmeter.testelement.property.JMeterProperty; +import org.apache.jmeter.util.JMeterUtils; +import org.apache.jorphan.util.StringUtilities; + +/** + * Renders an {@link HTTPSampleResult} as a ready-to-run {@code curl} command, + * the reverse of what {@link BasicCurlParser} does. + * + * <p>The generated command targets a POSIX-compatible shell: arguments are + * single-quoted and lines are continued with a trailing backslash. It is not + * valid {@code cmd.exe} or PowerShell syntax.</p> + * + * <p>The class has no Swing dependency so it can be reused outside the + * View Results Tree (for example by a future "Copy as cURL" sampler action).</p> + */ +public final class CurlCommandFormatter { + + /** Backslash line continuation followed by indentation, for a POSIX shell. */ + private static final String NEWLINE = " \\\n "; //$NON-NLS-1$ + + private static final String ACCEPT_ENCODING = "Accept-Encoding"; //$NON-NLS-1$ + + private static final String BOUNDARY = "boundary="; //$NON-NLS-1$ + + /** + * Headers that must not be reproduced in the curl command: curl generates + * them itself, they are connection-specific (hop-by-hop) headers that are + * forbidden in HTTP/2 and would make the request fail with a protocol + * error, or they are pseudo-headers JMeter adds only for reporting and that + * never went on the wire (X-LocalAddress). + */ + private static final Set<String> SKIPPED_HEADERS = Set.of( + "content-length", //$NON-NLS-1$ + "connection", //$NON-NLS-1$ + "keep-alive", //$NON-NLS-1$ + "proxy-connection", //$NON-NLS-1$ + "transfer-encoding", //$NON-NLS-1$ + "upgrade", //$NON-NLS-1$ + HTTPConstants.HEADER_LOCAL_ADDRESS.toLowerCase(Locale.ROOT)); + + /** + * Markers JMeter writes into the rendered request body in place of content + * it did not keep (a file sent as the body, or a non-repeatable entity). + * When present, the body is not the real wire body and cannot be reproduced. + * + * @see org.apache.jmeter.protocol.http.sampler.PostWriter + */ + private static final String[] BODY_PLACEHOLDERS = { + PostWriter.FILE_CONTENT_PLACEHOLDER, + PostWriter.NON_REPEATABLE_ENTITY_PLACEHOLDER + }; + + private CurlCommandFormatter() { + } + + /** + * Build a {@code curl} command line that reproduces the given HTTP request. + * + * @param sampleResult the sampled HTTP request + * @return the curl command as a string + */ + public static String format(HTTPSampleResult sampleResult) { + StringBuilder sb = new StringBuilder(256); + sb.append("curl"); //$NON-NLS-1$ + + String method = sampleResult.getHTTPMethod(); + boolean isHead = HTTPConstants.HEAD.equalsIgnoreCase(method); + boolean isGet = StringUtilities.isBlank(method) || HTTPConstants.GET.equalsIgnoreCase(method); + + // Split by line (not via JMeterUtils.parseHeaders) so repeated header + // names such as several Accept values are all preserved. + List<String[]> headers = new ArrayList<>(); + String contentType = null; + boolean acceptsEncoding = false; + String requestHeaders = sampleResult.getRequestHeaders(); + if (StringUtilities.isNotEmpty(requestHeaders)) { + for (String header : requestHeaders.split("\n")) { //$NON-NLS-1$ + int colon = header.indexOf(':'); + if (colon <= 0) { + continue; + } + String name = header.substring(0, colon).trim(); + String value = header.substring(colon + 1).trim(); + String lower = name.toLowerCase(Locale.ROOT); + if (SKIPPED_HEADERS.contains(lower)) { + continue; + } + if (HTTPConstants.HEADER_CONTENT_TYPE.equalsIgnoreCase(name)) { + contentType = value; + } + if (ACCEPT_ENCODING.equalsIgnoreCase(name)) { + acceptsEncoding = true; + } + headers.add(new String[] { name, value }); + } + } + + String body = isHead ? "" : sampleResult.getQueryString(); //$NON-NLS-1$ + boolean hasBody = StringUtilities.isNotEmpty(body); + boolean isMultipart = contentType != null + && contentType.toLowerCase(Locale.ROOT).startsWith(HTTPConstants.MULTIPART_FORM_DATA); + // Multipart bodies are rebuilt as -F flags; curl then sets its own + // Content-Type (with its own boundary), so the original one is dropped. + List<String[]> formParts = hasBody && isMultipart ? parseMultipartForm(contentType, body) : List.of(); + boolean emitsForm = !formParts.isEmpty(); + boolean emitsDataRaw = hasBody && !isMultipart && !containsPlaceholder(body); + + // Method: --head for HEAD (plain "-X HEAD" makes curl wait for a body it + // never gets); no -X for a plain GET; -X GET only when a GET carries a + // raw body, otherwise curl would switch it to POST; -X for everything else. + if (isHead) { + sb.append(" --head"); //$NON-NLS-1$ + } else if (!isGet) { + sb.append(" -X ").append(quote(method)); //$NON-NLS-1$ + } else if (emitsDataRaw) { + sb.append(" -X ").append(quote(HTTPConstants.GET)); //$NON-NLS-1$ + } + + URL url = sampleResult.getURL(); + if (url != null) { + sb.append(NEWLINE).append(quote(url.toString())); + } + + for (String[] header : headers) { + if (emitsForm && HTTPConstants.HEADER_CONTENT_TYPE.equalsIgnoreCase(header[0])) { + continue; + } + // --compressed (below) makes curl send its own Accept-Encoding, so the explicit one is redundant. + if (acceptsEncoding && ACCEPT_ENCODING.equalsIgnoreCase(header[0])) { + continue; + } + sb.append(NEWLINE).append("-H ").append(quote(header[0] + ": " + header[1])); //$NON-NLS-1$ //$NON-NLS-2$ + } + + // HttpClient disables automatic decompression, so Accept-Encoding is only + // present when explicitly set; --compressed makes curl decode the response. + if (acceptsEncoding) { + sb.append(NEWLINE).append("--compressed"); //$NON-NLS-1$ + } + + String cookies = sampleResult.getCookies(); + if (StringUtilities.isNotEmpty(cookies)) { + sb.append(NEWLINE).append("-b ").append(quote(cookies)); //$NON-NLS-1$ + } + + if (emitsForm) { + for (String[] part : formParts) { + sb.append(NEWLINE).append(part[0]).append(' ').append(quote(part[1])); + } + } else if (emitsDataRaw) { + sb.append(NEWLINE).append("--data-raw ").append(quote(body)); //$NON-NLS-1$ + } else if (hasBody) { + // A file sent as the body or a non-repeatable entity: the bytes were + // not kept, so emitting them would produce a silently-wrong command. + sb.append('\n').append("# ") //$NON-NLS-1$ + .append(JMeterUtils.getResString("view_results_table_request_tab_curl_body_omitted")); //$NON-NLS-1$ + } + + return sb.toString(); + } + + /** + * Rebuild the {@code -F} form parts of a multipart request from its rendered + * body. Regular fields become {@code name=value}; file parts become + * {@code name=@filename;type=...}. JMeter does not keep the uploaded bytes, + * so the file name is only a placeholder the user edits to a real path + * before running the command. + * + * @return the form parts, or an empty list if the body cannot be parsed + */ + private static List<String[]> parseMultipartForm(String contentType, String body) { + String boundary = extractBoundary(contentType); + if (StringUtilities.isBlank(boundary)) { + return List.of(); + } + MultipartUrlConfig multipart = new MultipartUrlConfig(boundary); + try { + multipart.parseArguments(body); + } catch (RuntimeException e) { // NOSONAR malformed body: fall back to the omitted-body note + return List.of(); + } Review Comment: **A quoted or mismatched boundary yields a corrupted `--form-string`, not the omitted-body note.** `extractBoundary` (line 235) returns the boundary with its quotes still attached, so `Content-Type: multipart/form-data; boundary="xyz"` gives `"xyz"`. `MultipartUrlConfig.parseArguments` then splits on `--"xyz"`, finds no delimiter, and treats the whole body as one part. That part does contain `Content-Disposition: form-data`, so a field is created, and its value runs to `part.lastIndexOf(CRLF)` (`MultipartUrlConfig#170`) — i.e. it swallows the trailing boundary marker. Rendered on this branch: ``` Content-Type: multipart/form-data; boundary="xyz" body: --xyz\r\nContent-Disposition: form-data; name="a"\r\n\r\nb\r\n--xyz--\r\n curl -X 'POST' \ 'http://example.com/upload' \ --form-string 'a=b --xyz--' ``` The same thing happens whenever the header boundary and the body disagree: `boundary=nomatch` over a body delimited by `--other` renders `--form-string 'a=b\n--other--'`. Both commands run and send garbage — the class of bug this PR set out to remove. Quoting is legal per RFC 2046, and both cases are reachable: when `getUseMultipart()` is false, `HTTPHC4Impl#1523` keeps the user's own `Content-Type` header, so a hand-built multipart body in the Body Data tab arrives here verbatim. Two small guards fix it: strip surrounding quotes in `extractBoundary`, and check that the body actually contains `--<boundary>` before parsing, falling through to the omitted-body branch when it does not. While you are in `extractBoundary` — it now duplicates `RequestViewHTTP#251`, and the new one is the better of the two (it returns `null` when `boundary=` is absent, where the old one builds a nonsense substring). Now that the logic is Swing-free, `RequestViewHTTP` could call it instead. ########## src/protocol/http/src/main/java/org/apache/jmeter/protocol/http/curl/CurlCommandFormatter.java: ########## @@ -0,0 +1,268 @@ +/* + * 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.curl; + +import java.net.URL; +import java.util.ArrayList; +import java.util.List; +import java.util.Locale; +import java.util.Set; + +import org.apache.jmeter.config.Argument; +import org.apache.jmeter.protocol.http.config.MultipartUrlConfig; +import org.apache.jmeter.protocol.http.sampler.HTTPSampleResult; +import org.apache.jmeter.protocol.http.sampler.PostWriter; +import org.apache.jmeter.protocol.http.util.HTTPConstants; +import org.apache.jmeter.protocol.http.util.HTTPFileArg; +import org.apache.jmeter.testelement.property.JMeterProperty; +import org.apache.jmeter.util.JMeterUtils; +import org.apache.jorphan.util.StringUtilities; + +/** + * Renders an {@link HTTPSampleResult} as a ready-to-run {@code curl} command, + * the reverse of what {@link BasicCurlParser} does. + * + * <p>The generated command targets a POSIX-compatible shell: arguments are + * single-quoted and lines are continued with a trailing backslash. It is not + * valid {@code cmd.exe} or PowerShell syntax.</p> + * + * <p>The class has no Swing dependency so it can be reused outside the + * View Results Tree (for example by a future "Copy as cURL" sampler action).</p> + */ +public final class CurlCommandFormatter { + + /** Backslash line continuation followed by indentation, for a POSIX shell. */ + private static final String NEWLINE = " \\\n "; //$NON-NLS-1$ + + private static final String ACCEPT_ENCODING = "Accept-Encoding"; //$NON-NLS-1$ + + private static final String BOUNDARY = "boundary="; //$NON-NLS-1$ + + /** + * Headers that must not be reproduced in the curl command: curl generates + * them itself, they are connection-specific (hop-by-hop) headers that are + * forbidden in HTTP/2 and would make the request fail with a protocol + * error, or they are pseudo-headers JMeter adds only for reporting and that + * never went on the wire (X-LocalAddress). + */ + private static final Set<String> SKIPPED_HEADERS = Set.of( + "content-length", //$NON-NLS-1$ + "connection", //$NON-NLS-1$ + "keep-alive", //$NON-NLS-1$ + "proxy-connection", //$NON-NLS-1$ + "transfer-encoding", //$NON-NLS-1$ + "upgrade", //$NON-NLS-1$ + HTTPConstants.HEADER_LOCAL_ADDRESS.toLowerCase(Locale.ROOT)); + + /** + * Markers JMeter writes into the rendered request body in place of content + * it did not keep (a file sent as the body, or a non-repeatable entity). + * When present, the body is not the real wire body and cannot be reproduced. + * + * @see org.apache.jmeter.protocol.http.sampler.PostWriter + */ + private static final String[] BODY_PLACEHOLDERS = { + PostWriter.FILE_CONTENT_PLACEHOLDER, + PostWriter.NON_REPEATABLE_ENTITY_PLACEHOLDER + }; + + private CurlCommandFormatter() { + } + + /** + * Build a {@code curl} command line that reproduces the given HTTP request. + * + * @param sampleResult the sampled HTTP request + * @return the curl command as a string + */ + public static String format(HTTPSampleResult sampleResult) { + StringBuilder sb = new StringBuilder(256); + sb.append("curl"); //$NON-NLS-1$ + + String method = sampleResult.getHTTPMethod(); + boolean isHead = HTTPConstants.HEAD.equalsIgnoreCase(method); + boolean isGet = StringUtilities.isBlank(method) || HTTPConstants.GET.equalsIgnoreCase(method); + + // Split by line (not via JMeterUtils.parseHeaders) so repeated header + // names such as several Accept values are all preserved. + List<String[]> headers = new ArrayList<>(); + String contentType = null; + boolean acceptsEncoding = false; + String requestHeaders = sampleResult.getRequestHeaders(); + if (StringUtilities.isNotEmpty(requestHeaders)) { + for (String header : requestHeaders.split("\n")) { //$NON-NLS-1$ + int colon = header.indexOf(':'); + if (colon <= 0) { + continue; + } + String name = header.substring(0, colon).trim(); + String value = header.substring(colon + 1).trim(); + String lower = name.toLowerCase(Locale.ROOT); + if (SKIPPED_HEADERS.contains(lower)) { + continue; + } + if (HTTPConstants.HEADER_CONTENT_TYPE.equalsIgnoreCase(name)) { + contentType = value; + } + if (ACCEPT_ENCODING.equalsIgnoreCase(name)) { + acceptsEncoding = true; + } + headers.add(new String[] { name, value }); + } + } + + String body = isHead ? "" : sampleResult.getQueryString(); //$NON-NLS-1$ + boolean hasBody = StringUtilities.isNotEmpty(body); + boolean isMultipart = contentType != null + && contentType.toLowerCase(Locale.ROOT).startsWith(HTTPConstants.MULTIPART_FORM_DATA); + // Multipart bodies are rebuilt as -F flags; curl then sets its own + // Content-Type (with its own boundary), so the original one is dropped. + List<String[]> formParts = hasBody && isMultipart ? parseMultipartForm(contentType, body) : List.of(); + boolean emitsForm = !formParts.isEmpty(); + boolean emitsDataRaw = hasBody && !isMultipart && !containsPlaceholder(body); + + // Method: --head for HEAD (plain "-X HEAD" makes curl wait for a body it + // never gets); no -X for a plain GET; -X GET only when a GET carries a + // raw body, otherwise curl would switch it to POST; -X for everything else. + if (isHead) { + sb.append(" --head"); //$NON-NLS-1$ + } else if (!isGet) { + sb.append(" -X ").append(quote(method)); //$NON-NLS-1$ + } else if (emitsDataRaw) { + sb.append(" -X ").append(quote(HTTPConstants.GET)); //$NON-NLS-1$ + } + + URL url = sampleResult.getURL(); + if (url != null) { + sb.append(NEWLINE).append(quote(url.toString())); + } + + for (String[] header : headers) { + if (emitsForm && HTTPConstants.HEADER_CONTENT_TYPE.equalsIgnoreCase(header[0])) { + continue; + } + // --compressed (below) makes curl send its own Accept-Encoding, so the explicit one is redundant. + if (acceptsEncoding && ACCEPT_ENCODING.equalsIgnoreCase(header[0])) { + continue; + } + sb.append(NEWLINE).append("-H ").append(quote(header[0] + ": " + header[1])); //$NON-NLS-1$ //$NON-NLS-2$ + } + + // HttpClient disables automatic decompression, so Accept-Encoding is only + // present when explicitly set; --compressed makes curl decode the response. + if (acceptsEncoding) { + sb.append(NEWLINE).append("--compressed"); //$NON-NLS-1$ + } + + String cookies = sampleResult.getCookies(); + if (StringUtilities.isNotEmpty(cookies)) { + sb.append(NEWLINE).append("-b ").append(quote(cookies)); //$NON-NLS-1$ + } + + if (emitsForm) { + for (String[] part : formParts) { + sb.append(NEWLINE).append(part[0]).append(' ').append(quote(part[1])); + } + } else if (emitsDataRaw) { + sb.append(NEWLINE).append("--data-raw ").append(quote(body)); //$NON-NLS-1$ + } else if (hasBody) { + // A file sent as the body or a non-repeatable entity: the bytes were + // not kept, so emitting them would produce a silently-wrong command. + sb.append('\n').append("# ") //$NON-NLS-1$ + .append(JMeterUtils.getResString("view_results_table_request_tab_curl_body_omitted")); //$NON-NLS-1$ + } + + return sb.toString(); + } + + /** + * Rebuild the {@code -F} form parts of a multipart request from its rendered + * body. Regular fields become {@code name=value}; file parts become + * {@code name=@filename;type=...}. JMeter does not keep the uploaded bytes, + * so the file name is only a placeholder the user edits to a real path + * before running the command. + * + * @return the form parts, or an empty list if the body cannot be parsed + */ + private static List<String[]> parseMultipartForm(String contentType, String body) { + String boundary = extractBoundary(contentType); + if (StringUtilities.isBlank(boundary)) { + return List.of(); + } + MultipartUrlConfig multipart = new MultipartUrlConfig(boundary); + try { + multipart.parseArguments(body); + } catch (RuntimeException e) { // NOSONAR malformed body: fall back to the omitted-body note + return List.of(); + } + List<String[]> parts = new ArrayList<>(); + for (JMeterProperty property : multipart.getArguments()) { + Argument argument = (Argument) property.getObjectValue(); + // --form-string takes the value verbatim; -F would treat a leading + // '@' or '<' in the value as a file reference and misinterpret the field. + parts.add(new String[] { "--form-string", argument.getName() + "=" + argument.getValue() }); //$NON-NLS-1$ //$NON-NLS-2$ + } + for (HTTPFileArg file : multipart.getHTTPFileArgs().asArray()) { + StringBuilder spec = new StringBuilder(); + spec.append(file.getParamName()).append("=@").append(file.getPath()); //$NON-NLS-1$ + if (StringUtilities.isNotEmpty(file.getMimeType())) { + spec.append(";type=").append(file.getMimeType()); //$NON-NLS-1$ + } + parts.add(new String[] { "-F", spec.toString() }); //$NON-NLS-1$ + } Review Comment: **A file name containing `;` or `,` produces a `-F` spec curl rejects.** The spec is concatenated unquoted, so a part named `a;b,c.txt` renders as `-F 'up=@a;b,c.txt;type=text/plain'`. curl parses `;` and `,` inside the argument itself, so shell quoting does not protect it — the same shape as the `@`-prefixed value that `--form-string` solved, but on the file side: ```console $ curl -F 'up=@a;b,c.txt;type=text/plain' http://… curl: (26) Failed to open/read local data from file/application $ curl -F 'up=@"a;b,c.txt";type=text/plain' http://… # exit 0, part sent as filename="a;b,c.txt" ``` Commas in file names are common enough to hit this in practice. Wrapping the path in double quotes inside the spec — `name=@"path"`, with `;type=` after the closing quote — fixes both characters. ########## src/protocol/http/src/main/java/org/apache/jmeter/protocol/http/curl/CurlCommandFormatter.java: ########## @@ -0,0 +1,268 @@ +/* + * 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.curl; + +import java.net.URL; +import java.util.ArrayList; +import java.util.List; +import java.util.Locale; +import java.util.Set; + +import org.apache.jmeter.config.Argument; +import org.apache.jmeter.protocol.http.config.MultipartUrlConfig; +import org.apache.jmeter.protocol.http.sampler.HTTPSampleResult; +import org.apache.jmeter.protocol.http.sampler.PostWriter; +import org.apache.jmeter.protocol.http.util.HTTPConstants; +import org.apache.jmeter.protocol.http.util.HTTPFileArg; +import org.apache.jmeter.testelement.property.JMeterProperty; +import org.apache.jmeter.util.JMeterUtils; +import org.apache.jorphan.util.StringUtilities; + +/** + * Renders an {@link HTTPSampleResult} as a ready-to-run {@code curl} command, + * the reverse of what {@link BasicCurlParser} does. + * + * <p>The generated command targets a POSIX-compatible shell: arguments are + * single-quoted and lines are continued with a trailing backslash. It is not + * valid {@code cmd.exe} or PowerShell syntax.</p> + * + * <p>The class has no Swing dependency so it can be reused outside the + * View Results Tree (for example by a future "Copy as cURL" sampler action).</p> + */ +public final class CurlCommandFormatter { + + /** Backslash line continuation followed by indentation, for a POSIX shell. */ + private static final String NEWLINE = " \\\n "; //$NON-NLS-1$ + + private static final String ACCEPT_ENCODING = "Accept-Encoding"; //$NON-NLS-1$ + + private static final String BOUNDARY = "boundary="; //$NON-NLS-1$ + + /** + * Headers that must not be reproduced in the curl command: curl generates + * them itself, they are connection-specific (hop-by-hop) headers that are + * forbidden in HTTP/2 and would make the request fail with a protocol + * error, or they are pseudo-headers JMeter adds only for reporting and that + * never went on the wire (X-LocalAddress). + */ + private static final Set<String> SKIPPED_HEADERS = Set.of( + "content-length", //$NON-NLS-1$ + "connection", //$NON-NLS-1$ + "keep-alive", //$NON-NLS-1$ + "proxy-connection", //$NON-NLS-1$ + "transfer-encoding", //$NON-NLS-1$ + "upgrade", //$NON-NLS-1$ + HTTPConstants.HEADER_LOCAL_ADDRESS.toLowerCase(Locale.ROOT)); + + /** + * Markers JMeter writes into the rendered request body in place of content + * it did not keep (a file sent as the body, or a non-repeatable entity). + * When present, the body is not the real wire body and cannot be reproduced. + * + * @see org.apache.jmeter.protocol.http.sampler.PostWriter + */ + private static final String[] BODY_PLACEHOLDERS = { + PostWriter.FILE_CONTENT_PLACEHOLDER, + PostWriter.NON_REPEATABLE_ENTITY_PLACEHOLDER + }; + + private CurlCommandFormatter() { + } + + /** + * Build a {@code curl} command line that reproduces the given HTTP request. + * + * @param sampleResult the sampled HTTP request + * @return the curl command as a string + */ + public static String format(HTTPSampleResult sampleResult) { + StringBuilder sb = new StringBuilder(256); + sb.append("curl"); //$NON-NLS-1$ + + String method = sampleResult.getHTTPMethod(); + boolean isHead = HTTPConstants.HEAD.equalsIgnoreCase(method); + boolean isGet = StringUtilities.isBlank(method) || HTTPConstants.GET.equalsIgnoreCase(method); + + // Split by line (not via JMeterUtils.parseHeaders) so repeated header + // names such as several Accept values are all preserved. + List<String[]> headers = new ArrayList<>(); + String contentType = null; + boolean acceptsEncoding = false; + String requestHeaders = sampleResult.getRequestHeaders(); + if (StringUtilities.isNotEmpty(requestHeaders)) { + for (String header : requestHeaders.split("\n")) { //$NON-NLS-1$ + int colon = header.indexOf(':'); + if (colon <= 0) { + continue; + } + String name = header.substring(0, colon).trim(); + String value = header.substring(colon + 1).trim(); + String lower = name.toLowerCase(Locale.ROOT); + if (SKIPPED_HEADERS.contains(lower)) { + continue; + } + if (HTTPConstants.HEADER_CONTENT_TYPE.equalsIgnoreCase(name)) { + contentType = value; + } + if (ACCEPT_ENCODING.equalsIgnoreCase(name)) { + acceptsEncoding = true; + } + headers.add(new String[] { name, value }); + } + } + + String body = isHead ? "" : sampleResult.getQueryString(); //$NON-NLS-1$ + boolean hasBody = StringUtilities.isNotEmpty(body); + boolean isMultipart = contentType != null + && contentType.toLowerCase(Locale.ROOT).startsWith(HTTPConstants.MULTIPART_FORM_DATA); + // Multipart bodies are rebuilt as -F flags; curl then sets its own + // Content-Type (with its own boundary), so the original one is dropped. + List<String[]> formParts = hasBody && isMultipart ? parseMultipartForm(contentType, body) : List.of(); + boolean emitsForm = !formParts.isEmpty(); + boolean emitsDataRaw = hasBody && !isMultipart && !containsPlaceholder(body); + + // Method: --head for HEAD (plain "-X HEAD" makes curl wait for a body it + // never gets); no -X for a plain GET; -X GET only when a GET carries a + // raw body, otherwise curl would switch it to POST; -X for everything else. + if (isHead) { + sb.append(" --head"); //$NON-NLS-1$ + } else if (!isGet) { + sb.append(" -X ").append(quote(method)); //$NON-NLS-1$ + } else if (emitsDataRaw) { + sb.append(" -X ").append(quote(HTTPConstants.GET)); //$NON-NLS-1$ + } + + URL url = sampleResult.getURL(); + if (url != null) { + sb.append(NEWLINE).append(quote(url.toString())); + } + + for (String[] header : headers) { + if (emitsForm && HTTPConstants.HEADER_CONTENT_TYPE.equalsIgnoreCase(header[0])) { + continue; + } + // --compressed (below) makes curl send its own Accept-Encoding, so the explicit one is redundant. + if (acceptsEncoding && ACCEPT_ENCODING.equalsIgnoreCase(header[0])) { + continue; + } + sb.append(NEWLINE).append("-H ").append(quote(header[0] + ": " + header[1])); //$NON-NLS-1$ //$NON-NLS-2$ + } + + // HttpClient disables automatic decompression, so Accept-Encoding is only + // present when explicitly set; --compressed makes curl decode the response. + if (acceptsEncoding) { + sb.append(NEWLINE).append("--compressed"); //$NON-NLS-1$ + } + + String cookies = sampleResult.getCookies(); + if (StringUtilities.isNotEmpty(cookies)) { + sb.append(NEWLINE).append("-b ").append(quote(cookies)); //$NON-NLS-1$ + } Review Comment: **A correction to my earlier note, and a narrow case it leaves open.** I said the `hasCookieHeader` guard was unreachable, and that was too broad. It holds for `HTTPHC4Impl` and `HTTPJavaImpl`, which strip `Cookie` in `getAllHeadersExceptCookie`, but `AjpSampler.setConnectionHeaders` copies Header Manager entries into the header string verbatim while `setConnectionCookies` fills `getCookies()` separately. With both a Header Manager `Cookie` and a Cookie Manager, the result is: ``` curl \ 'http://example.com/' \ -H 'Cookie: a=1' \ -b 'b=2' ``` curl lets the explicit header win, so `b=2` is dropped without a word. Skipping `-b` when a `Cookie` header was already emitted restores what the guard used to cover. Low stakes given it is AJP-only — mentioning it because I am the reason the guard went away. ########## src/protocol/http/src/test/java/org/apache/jmeter/protocol/http/curl/CurlCommandFormatterTest.java: ########## @@ -0,0 +1,257 @@ +/* + * 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.curl; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.net.MalformedURLException; +import java.net.URL; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; + +import org.apache.jmeter.protocol.http.sampler.HTTPSampleResult; +import org.junit.jupiter.api.Test; + +class CurlCommandFormatterTest { + + private static HTTPSampleResult result(String method, String url) throws MalformedURLException { + HTTPSampleResult res = new HTTPSampleResult(); + res.setHTTPMethod(method); + if (url != null) { + res.setURL(new URL(url)); + } + return res; + } + + @Test + void testSimpleGetOmitsMethodFlag() throws Exception { + HTTPSampleResult res = result("GET", "http://example.com/path?a=1";); + + assertEquals( + "curl \\\n 'http://example.com/path?a=1'", + CurlCommandFormatter.format(res)); + } + + @Test + void testPostWithHeaderAndBody() throws Exception { + HTTPSampleResult res = result("POST", "http://example.com/submit";); + res.setRequestHeaders("Content-Type: application/json"); + res.setQueryString("{\"name\":\"value\"}"); + + assertEquals( + "curl -X 'POST' \\\n" + + " 'http://example.com/submit' \\\n" + + " -H 'Content-Type: application/json' \\\n" + + " --data-raw '{\"name\":\"value\"}'", + CurlCommandFormatter.format(res)); + } + + @Test + void testRepeatedHeadersArePreserved() throws Exception { + HTTPSampleResult res = result("GET", "http://example.com/";); + res.setRequestHeaders("X-Trace: a\nX-Trace: b\nAccept: text/html\nAccept: application/json"); + + assertEquals( + "curl \\\n" + + " 'http://example.com/' \\\n" + + " -H 'X-Trace: a' \\\n" + + " -H 'X-Trace: b' \\\n" + + " -H 'Accept: text/html' \\\n" + + " -H 'Accept: application/json'", + CurlCommandFormatter.format(res)); + } + + @Test + void testConnectionAutoAndPseudoHeadersAreSkipped() throws Exception { + HTTPSampleResult res = result("POST", "http://example.com/";); + res.setRequestHeaders("Connection: keep-alive\n" + + "Content-Length: 5\n" + + "Transfer-Encoding: chunked\n" + + "X-LocalAddress: /10.0.0.5\n" + + "Accept: application/json"); + res.setQueryString("hello"); + + assertEquals( + "curl -X 'POST' \\\n" + + " 'http://example.com/' \\\n" + + " -H 'Accept: application/json' \\\n" + + " --data-raw 'hello'", + CurlCommandFormatter.format(res)); + } + + @Test + void testHeadUsesHeadFlag() throws Exception { + HTTPSampleResult res = result("HEAD", "http://example.com/";); + res.setRequestHeaders("Accept: */*"); + + String curl = CurlCommandFormatter.format(res); + assertTrue(curl.startsWith("curl --head "), curl); + assertFalse(curl.contains("-X "), curl); + assertFalse(curl.contains("--data"), curl); + } + + @Test + void testGetWithBodyKeepsMethodSoCurlDoesNotSwitchToPost() throws Exception { + HTTPSampleResult res = result("GET", "http://example.com/";); + res.setQueryString("q=1"); + + String curl = CurlCommandFormatter.format(res); + assertTrue(curl.contains("-X 'GET'"), curl); + assertTrue(curl.contains("--data-raw 'q=1'"), curl); + } + + @Test + void testMultipartRebuiltAsFormFlagsWithFileName() throws Exception { + HTTPSampleResult res = result("POST", "http://example.com/upload";); + res.setRequestHeaders("Content-Type: multipart/form-data; boundary=xyz"); + // Rendered multipart body as JMeter stores it in the result. + res.setQueryString("--xyz\r\n" + + "Content-Disposition: form-data; name=\"comment\"\r\n" + + "\r\n" + + "hello\r\n" + + "--xyz\r\n" + + "Content-Disposition: form-data; name=\"upload\"; filename=\"report.pdf\"\r\n" + + "Content-Type: application/pdf\r\n" + + "\r\n" + + "<actual file content, not shown here>\r\n" + + "--xyz--\r\n"); + + String curl = CurlCommandFormatter.format(res); + // The file part is rebuilt with the file name as an editable @placeholder. + assertTrue(curl.contains("-F '[email protected];type=application/pdf'"), curl); + // Regular fields use --form-string so the value is never treated as a file. + assertTrue(curl.contains("--form-string 'comment=hello'"), curl); + // No raw dump of the placeholder, and curl sets its own multipart Content-Type. + assertFalse(curl.contains("--data-raw"), curl); + assertFalse(curl.contains("actual file content"), curl); + assertFalse(curl.contains("-H 'Content-Type: multipart/form-data"), curl); + } + + @Test + void testMultipartTextFieldWithAtPrefixUsesFormString() throws Exception { + HTTPSampleResult res = result("POST", "http://example.com/upload";); + res.setRequestHeaders("Content-Type: multipart/form-data; boundary=xyz"); + // A legitimate text field whose value starts with '@' must not be read as a file. + res.setQueryString("--xyz\r\n" + + "Content-Disposition: form-data; name=\"handle\"\r\n" + + "\r\n" + + "@someuser\r\n" + + "--xyz--\r\n"); + + String curl = CurlCommandFormatter.format(res); + assertTrue(curl.contains("--form-string 'handle=@someuser'"), curl); + assertFalse(curl.contains("-F 'handle=@someuser'"), curl); + } + + @Test + void testFileAsBodyPlaceholderIsNotReproduced() throws Exception { + HTTPSampleResult res = result("POST", "http://example.com/upload";); + res.setRequestHeaders("Content-Type: application/octet-stream"); + res.setQueryString("<actual file content, not shown here>"); + + String curl = CurlCommandFormatter.format(res); + assertFalse(curl.contains("--data-raw"), curl); + } + + @Test + void testNonRepeatableBodyPlaceholderIsNotReproduced() throws Exception { + HTTPSampleResult res = result("POST", "http://example.com/";); + res.setQueryString("<Entity was not repeatable, cannot view what was sent>"); + + String curl = CurlCommandFormatter.format(res); + assertFalse(curl.contains("--data-raw"), curl); + } + + @Test + void testWhitespaceOnlyBodyIsKept() throws Exception { + HTTPSampleResult res = result("POST", "http://example.com/";); + res.setQueryString(" "); + + assertTrue(CurlCommandFormatter.format(res).contains("--data-raw ' '")); + } + + @Test + void testCookiesAddedAsFlag() throws Exception { + HTTPSampleResult res = result("GET", "http://example.com/";); + res.setCookies("session=abc; theme=dark"); + + assertTrue(CurlCommandFormatter.format(res).contains("-b 'session=abc; theme=dark'")); + } + + @Test + void testAcceptEncodingAddsCompressed() throws Exception { + HTTPSampleResult res = result("GET", "http://example.com/";); + res.setRequestHeaders("Accept-Encoding: gzip, deflate"); + + String curl = CurlCommandFormatter.format(res); + assertTrue(curl.contains("--compressed"), curl); + // --compressed makes curl send its own Accept-Encoding, so the explicit one is dropped. + assertFalse(curl.contains("-H 'Accept-Encoding"), curl); + } + + @Test + void testSingleQuoteIsEscaped() throws Exception { + HTTPSampleResult res = result("POST", "http://example.com/";); + res.setQueryString("name=O'Brien"); + + // single quote becomes '\'' so the value stays shell-safe + assertTrue(CurlCommandFormatter.format(res).contains("--data-raw 'name=O'\\''Brien'")); + } + + @Test + void testNullUrlDoesNotFail() throws Exception { + HTTPSampleResult res = result("GET", null); + + assertEquals("curl", CurlCommandFormatter.format(res)); + } + + @Test + void testRoundTripThroughParser() throws Exception { + HTTPSampleResult res = result("POST", "http://example.com/submit";); + res.setRequestHeaders("X-A: 1\nX-B: 2"); + res.setQueryString("payload"); + + String curl = CurlCommandFormatter.format(res); + BasicCurlParser.Request parsed = new BasicCurlParser().parse(curl); + + assertEquals("POST", parsed.getMethod()); + assertEquals("http://example.com/submit";, parsed.getUrl()); + assertEquals("payload", parsed.getPostData()); + List<String> headers = parsed.getHeaders().stream() + .map(e -> e.getKey() + ": " + e.getValue()) + .collect(Collectors.toList()); + assertEquals(List.of("X-A: 1", "X-B: 2"), headers); + } Review Comment: **The round-trip tests stop short of the flags this class now emits.** `BasicCurlParser` already handles `--head`, `--compressed`, `-F`, and `--form-string` (`BasicCurlParser#537,557,560,614`), so the round trip can cover the interesting paths rather than the simple one. That is the cheapest guard against the multipart and encoding notes above regressing later. Cases the suite does not reach today, each of which renders a wrong command on this branch: a quoted boundary, a boundary that disagrees with the body, a file name containing `;` or `,`, and a part carrying a non-default content type. ########## src/protocol/http/src/main/java/org/apache/jmeter/protocol/http/curl/CurlCommandFormatter.java: ########## @@ -0,0 +1,268 @@ +/* + * 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.curl; + +import java.net.URL; +import java.util.ArrayList; +import java.util.List; +import java.util.Locale; +import java.util.Set; + +import org.apache.jmeter.config.Argument; +import org.apache.jmeter.protocol.http.config.MultipartUrlConfig; +import org.apache.jmeter.protocol.http.sampler.HTTPSampleResult; +import org.apache.jmeter.protocol.http.sampler.PostWriter; +import org.apache.jmeter.protocol.http.util.HTTPConstants; +import org.apache.jmeter.protocol.http.util.HTTPFileArg; +import org.apache.jmeter.testelement.property.JMeterProperty; +import org.apache.jmeter.util.JMeterUtils; +import org.apache.jorphan.util.StringUtilities; + +/** + * Renders an {@link HTTPSampleResult} as a ready-to-run {@code curl} command, + * the reverse of what {@link BasicCurlParser} does. + * + * <p>The generated command targets a POSIX-compatible shell: arguments are + * single-quoted and lines are continued with a trailing backslash. It is not + * valid {@code cmd.exe} or PowerShell syntax.</p> + * + * <p>The class has no Swing dependency so it can be reused outside the + * View Results Tree (for example by a future "Copy as cURL" sampler action).</p> + */ +public final class CurlCommandFormatter { + + /** Backslash line continuation followed by indentation, for a POSIX shell. */ + private static final String NEWLINE = " \\\n "; //$NON-NLS-1$ + + private static final String ACCEPT_ENCODING = "Accept-Encoding"; //$NON-NLS-1$ + + private static final String BOUNDARY = "boundary="; //$NON-NLS-1$ + + /** + * Headers that must not be reproduced in the curl command: curl generates + * them itself, they are connection-specific (hop-by-hop) headers that are + * forbidden in HTTP/2 and would make the request fail with a protocol + * error, or they are pseudo-headers JMeter adds only for reporting and that + * never went on the wire (X-LocalAddress). + */ + private static final Set<String> SKIPPED_HEADERS = Set.of( + "content-length", //$NON-NLS-1$ + "connection", //$NON-NLS-1$ + "keep-alive", //$NON-NLS-1$ + "proxy-connection", //$NON-NLS-1$ + "transfer-encoding", //$NON-NLS-1$ + "upgrade", //$NON-NLS-1$ + HTTPConstants.HEADER_LOCAL_ADDRESS.toLowerCase(Locale.ROOT)); + + /** + * Markers JMeter writes into the rendered request body in place of content + * it did not keep (a file sent as the body, or a non-repeatable entity). + * When present, the body is not the real wire body and cannot be reproduced. + * + * @see org.apache.jmeter.protocol.http.sampler.PostWriter + */ + private static final String[] BODY_PLACEHOLDERS = { + PostWriter.FILE_CONTENT_PLACEHOLDER, + PostWriter.NON_REPEATABLE_ENTITY_PLACEHOLDER + }; + + private CurlCommandFormatter() { + } + + /** + * Build a {@code curl} command line that reproduces the given HTTP request. + * + * @param sampleResult the sampled HTTP request + * @return the curl command as a string + */ + public static String format(HTTPSampleResult sampleResult) { + StringBuilder sb = new StringBuilder(256); + sb.append("curl"); //$NON-NLS-1$ + + String method = sampleResult.getHTTPMethod(); + boolean isHead = HTTPConstants.HEAD.equalsIgnoreCase(method); + boolean isGet = StringUtilities.isBlank(method) || HTTPConstants.GET.equalsIgnoreCase(method); + + // Split by line (not via JMeterUtils.parseHeaders) so repeated header + // names such as several Accept values are all preserved. + List<String[]> headers = new ArrayList<>(); + String contentType = null; + boolean acceptsEncoding = false; + String requestHeaders = sampleResult.getRequestHeaders(); + if (StringUtilities.isNotEmpty(requestHeaders)) { + for (String header : requestHeaders.split("\n")) { //$NON-NLS-1$ + int colon = header.indexOf(':'); + if (colon <= 0) { + continue; + } + String name = header.substring(0, colon).trim(); + String value = header.substring(colon + 1).trim(); + String lower = name.toLowerCase(Locale.ROOT); + if (SKIPPED_HEADERS.contains(lower)) { + continue; + } + if (HTTPConstants.HEADER_CONTENT_TYPE.equalsIgnoreCase(name)) { + contentType = value; + } + if (ACCEPT_ENCODING.equalsIgnoreCase(name)) { + acceptsEncoding = true; + } + headers.add(new String[] { name, value }); + } + } + + String body = isHead ? "" : sampleResult.getQueryString(); //$NON-NLS-1$ + boolean hasBody = StringUtilities.isNotEmpty(body); + boolean isMultipart = contentType != null + && contentType.toLowerCase(Locale.ROOT).startsWith(HTTPConstants.MULTIPART_FORM_DATA); + // Multipart bodies are rebuilt as -F flags; curl then sets its own + // Content-Type (with its own boundary), so the original one is dropped. + List<String[]> formParts = hasBody && isMultipart ? parseMultipartForm(contentType, body) : List.of(); + boolean emitsForm = !formParts.isEmpty(); + boolean emitsDataRaw = hasBody && !isMultipart && !containsPlaceholder(body); + + // Method: --head for HEAD (plain "-X HEAD" makes curl wait for a body it + // never gets); no -X for a plain GET; -X GET only when a GET carries a + // raw body, otherwise curl would switch it to POST; -X for everything else. + if (isHead) { + sb.append(" --head"); //$NON-NLS-1$ + } else if (!isGet) { + sb.append(" -X ").append(quote(method)); //$NON-NLS-1$ + } else if (emitsDataRaw) { + sb.append(" -X ").append(quote(HTTPConstants.GET)); //$NON-NLS-1$ + } + + URL url = sampleResult.getURL(); + if (url != null) { + sb.append(NEWLINE).append(quote(url.toString())); + } + + for (String[] header : headers) { + if (emitsForm && HTTPConstants.HEADER_CONTENT_TYPE.equalsIgnoreCase(header[0])) { + continue; + } + // --compressed (below) makes curl send its own Accept-Encoding, so the explicit one is redundant. + if (acceptsEncoding && ACCEPT_ENCODING.equalsIgnoreCase(header[0])) { + continue; + } + sb.append(NEWLINE).append("-H ").append(quote(header[0] + ": " + header[1])); //$NON-NLS-1$ //$NON-NLS-2$ + } + + // HttpClient disables automatic decompression, so Accept-Encoding is only + // present when explicitly set; --compressed makes curl decode the response. + if (acceptsEncoding) { + sb.append(NEWLINE).append("--compressed"); //$NON-NLS-1$ + } + + String cookies = sampleResult.getCookies(); + if (StringUtilities.isNotEmpty(cookies)) { + sb.append(NEWLINE).append("-b ").append(quote(cookies)); //$NON-NLS-1$ + } + + if (emitsForm) { + for (String[] part : formParts) { + sb.append(NEWLINE).append(part[0]).append(' ').append(quote(part[1])); + } + } else if (emitsDataRaw) { + sb.append(NEWLINE).append("--data-raw ").append(quote(body)); //$NON-NLS-1$ + } else if (hasBody) { + // A file sent as the body or a non-repeatable entity: the bytes were + // not kept, so emitting them would produce a silently-wrong command. + sb.append('\n').append("# ") //$NON-NLS-1$ + .append(JMeterUtils.getResString("view_results_table_request_tab_curl_body_omitted")); //$NON-NLS-1$ + } + + return sb.toString(); + } + + /** + * Rebuild the {@code -F} form parts of a multipart request from its rendered + * body. Regular fields become {@code name=value}; file parts become + * {@code name=@filename;type=...}. JMeter does not keep the uploaded bytes, + * so the file name is only a placeholder the user edits to a real path + * before running the command. + * + * @return the form parts, or an empty list if the body cannot be parsed + */ + private static List<String[]> parseMultipartForm(String contentType, String body) { + String boundary = extractBoundary(contentType); + if (StringUtilities.isBlank(boundary)) { + return List.of(); + } + MultipartUrlConfig multipart = new MultipartUrlConfig(boundary); + try { + multipart.parseArguments(body); + } catch (RuntimeException e) { // NOSONAR malformed body: fall back to the omitted-body note + return List.of(); + } + List<String[]> parts = new ArrayList<>(); + for (JMeterProperty property : multipart.getArguments()) { + Argument argument = (Argument) property.getObjectValue(); + // --form-string takes the value verbatim; -F would treat a leading + // '@' or '<' in the value as a file reference and misinterpret the field. + parts.add(new String[] { "--form-string", argument.getName() + "=" + argument.getValue() }); //$NON-NLS-1$ //$NON-NLS-2$ + } Review Comment: **The per-part `Content-Type` is dropped.** `MultipartUrlConfig` already parses it into the argument (`MultipartUrlConfig#119,174`), and it is user-settable: the Parameters table has a content-type column (`HTTPArgumentsPanel#55,66`), and `HTTPHC4Impl` builds each part as `StringBody(value, contentType)` from it. `--form-string` emits no part header at all — verified against a server: ``` Content-Disposition: form-data; name="meta" ← no Content-Type {"a":1} ``` A field explicitly marked `application/json` therefore arrives with curl's default. `--form-string` cannot carry `;type=` by design, so the choices are to use `-F 'name=value;type=…'` when the part has a non-default type and the value does not start with `@` or `<`, or to state the limitation in `component_reference.xml`. Either is fine; silently losing it is the part worth changing. Two smaller things in the same loop: the original interleaving of fields and files is lost (all `--form-string` first, then all `-F`), and a part with no blank-line separator renders as `--form-string 'a='` with the value silently gone. ########## src/core/src/main/resources/org/apache/jmeter/resources/messages.properties: ########## @@ -1456,6 +1456,8 @@ view_results_table_request_http_protocol=Protocol view_results_table_request_params_key=Parameter name view_results_table_request_params_value=Value view_results_table_request_raw_nodata=No data to display Review Comment: This reads as a fragment glued to a finite clause — "Request body not shown (…) and cannot be reproduced". Since it renders as a shell comment the user reads next to the command, reason-then-consequence is easier to scan: ```properties view_results_table_request_tab_curl_body_omitted=Request body cannot be reproduced: JMeter does not keep the bytes of a file sent as the body or of a non-repeatable entity ``` ########## src/protocol/http/src/main/java/org/apache/jmeter/protocol/http/curl/CurlCommandFormatter.java: ########## @@ -0,0 +1,268 @@ +/* + * 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.curl; + +import java.net.URL; +import java.util.ArrayList; +import java.util.List; +import java.util.Locale; +import java.util.Set; + +import org.apache.jmeter.config.Argument; +import org.apache.jmeter.protocol.http.config.MultipartUrlConfig; +import org.apache.jmeter.protocol.http.sampler.HTTPSampleResult; +import org.apache.jmeter.protocol.http.sampler.PostWriter; +import org.apache.jmeter.protocol.http.util.HTTPConstants; +import org.apache.jmeter.protocol.http.util.HTTPFileArg; +import org.apache.jmeter.testelement.property.JMeterProperty; +import org.apache.jmeter.util.JMeterUtils; +import org.apache.jorphan.util.StringUtilities; + +/** + * Renders an {@link HTTPSampleResult} as a ready-to-run {@code curl} command, + * the reverse of what {@link BasicCurlParser} does. + * + * <p>The generated command targets a POSIX-compatible shell: arguments are + * single-quoted and lines are continued with a trailing backslash. It is not + * valid {@code cmd.exe} or PowerShell syntax.</p> + * + * <p>The class has no Swing dependency so it can be reused outside the + * View Results Tree (for example by a future "Copy as cURL" sampler action).</p> + */ +public final class CurlCommandFormatter { + + /** Backslash line continuation followed by indentation, for a POSIX shell. */ + private static final String NEWLINE = " \\\n "; //$NON-NLS-1$ + + private static final String ACCEPT_ENCODING = "Accept-Encoding"; //$NON-NLS-1$ + + private static final String BOUNDARY = "boundary="; //$NON-NLS-1$ + + /** + * Headers that must not be reproduced in the curl command: curl generates + * them itself, they are connection-specific (hop-by-hop) headers that are + * forbidden in HTTP/2 and would make the request fail with a protocol + * error, or they are pseudo-headers JMeter adds only for reporting and that + * never went on the wire (X-LocalAddress). + */ + private static final Set<String> SKIPPED_HEADERS = Set.of( + "content-length", //$NON-NLS-1$ + "connection", //$NON-NLS-1$ + "keep-alive", //$NON-NLS-1$ + "proxy-connection", //$NON-NLS-1$ + "transfer-encoding", //$NON-NLS-1$ + "upgrade", //$NON-NLS-1$ + HTTPConstants.HEADER_LOCAL_ADDRESS.toLowerCase(Locale.ROOT)); + + /** + * Markers JMeter writes into the rendered request body in place of content + * it did not keep (a file sent as the body, or a non-repeatable entity). + * When present, the body is not the real wire body and cannot be reproduced. + * + * @see org.apache.jmeter.protocol.http.sampler.PostWriter + */ + private static final String[] BODY_PLACEHOLDERS = { + PostWriter.FILE_CONTENT_PLACEHOLDER, + PostWriter.NON_REPEATABLE_ENTITY_PLACEHOLDER + }; + + private CurlCommandFormatter() { + } + + /** + * Build a {@code curl} command line that reproduces the given HTTP request. + * + * @param sampleResult the sampled HTTP request + * @return the curl command as a string + */ + public static String format(HTTPSampleResult sampleResult) { + StringBuilder sb = new StringBuilder(256); + sb.append("curl"); //$NON-NLS-1$ + + String method = sampleResult.getHTTPMethod(); + boolean isHead = HTTPConstants.HEAD.equalsIgnoreCase(method); + boolean isGet = StringUtilities.isBlank(method) || HTTPConstants.GET.equalsIgnoreCase(method); + + // Split by line (not via JMeterUtils.parseHeaders) so repeated header + // names such as several Accept values are all preserved. + List<String[]> headers = new ArrayList<>(); + String contentType = null; + boolean acceptsEncoding = false; + String requestHeaders = sampleResult.getRequestHeaders(); + if (StringUtilities.isNotEmpty(requestHeaders)) { + for (String header : requestHeaders.split("\n")) { //$NON-NLS-1$ + int colon = header.indexOf(':'); + if (colon <= 0) { + continue; + } + String name = header.substring(0, colon).trim(); + String value = header.substring(colon + 1).trim(); + String lower = name.toLowerCase(Locale.ROOT); + if (SKIPPED_HEADERS.contains(lower)) { + continue; + } + if (HTTPConstants.HEADER_CONTENT_TYPE.equalsIgnoreCase(name)) { + contentType = value; + } + if (ACCEPT_ENCODING.equalsIgnoreCase(name)) { + acceptsEncoding = true; + } + headers.add(new String[] { name, value }); + } + } + + String body = isHead ? "" : sampleResult.getQueryString(); //$NON-NLS-1$ + boolean hasBody = StringUtilities.isNotEmpty(body); + boolean isMultipart = contentType != null + && contentType.toLowerCase(Locale.ROOT).startsWith(HTTPConstants.MULTIPART_FORM_DATA); + // Multipart bodies are rebuilt as -F flags; curl then sets its own + // Content-Type (with its own boundary), so the original one is dropped. + List<String[]> formParts = hasBody && isMultipart ? parseMultipartForm(contentType, body) : List.of(); + boolean emitsForm = !formParts.isEmpty(); + boolean emitsDataRaw = hasBody && !isMultipart && !containsPlaceholder(body); + + // Method: --head for HEAD (plain "-X HEAD" makes curl wait for a body it + // never gets); no -X for a plain GET; -X GET only when a GET carries a + // raw body, otherwise curl would switch it to POST; -X for everything else. + if (isHead) { + sb.append(" --head"); //$NON-NLS-1$ + } else if (!isGet) { + sb.append(" -X ").append(quote(method)); //$NON-NLS-1$ + } else if (emitsDataRaw) { + sb.append(" -X ").append(quote(HTTPConstants.GET)); //$NON-NLS-1$ + } + + URL url = sampleResult.getURL(); + if (url != null) { + sb.append(NEWLINE).append(quote(url.toString())); + } + + for (String[] header : headers) { + if (emitsForm && HTTPConstants.HEADER_CONTENT_TYPE.equalsIgnoreCase(header[0])) { + continue; + } + // --compressed (below) makes curl send its own Accept-Encoding, so the explicit one is redundant. + if (acceptsEncoding && ACCEPT_ENCODING.equalsIgnoreCase(header[0])) { + continue; + } + sb.append(NEWLINE).append("-H ").append(quote(header[0] + ": " + header[1])); //$NON-NLS-1$ //$NON-NLS-2$ + } + + // HttpClient disables automatic decompression, so Accept-Encoding is only + // present when explicitly set; --compressed makes curl decode the response. + if (acceptsEncoding) { + sb.append(NEWLINE).append("--compressed"); //$NON-NLS-1$ + } Review Comment: **Dropping the explicit `Accept-Encoding` changes what the server is asked for.** `--compressed` is the right flag to add — JMeter does decode the response, so the command should too. But it is not a substitute for the header, because curl supplies its own list when none is given, and that list depends on how curl was built: ```console $ curl --compressed http://… Accept-Encoding: deflate, gzip # this build; brotli/zstd builds also send br, zstd $ curl --compressed -H 'Accept-Encoding: gzip' http://… Accept-Encoding: gzip # explicit header wins, response still decoded ``` So the two are not redundant: keeping both reproduces the request byte-for-byte *and* decodes, while dropping the header lets curl negotiate an encoding the test plan never asked for, and the server may answer with a different body than the sample recorded. Suggest keeping the header and adding `--compressed` alongside it. `testAcceptEncodingAddsCompressed` asserts the current behavior, so its second assertion inverts with the fix. -- This is an automated message from the Apache Git Service. To respond to the message, please log on to GitHub and use the URL above to go to the specific comment. To unsubscribe, e-mail: [email protected] For queries about this service, please contact Infrastructure at: [email protected]
