feat(http): add cURL tab to View Results Tree Request panel #6736
There are no files selected for viewing
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,314 @@ | ||
| /* | ||
| * 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.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.HTTPArgument; | ||
| 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$ | ||
|
|
||
| /** {@code HTTPArgument} defaults a part's content type to this; see HTTPArgumentSchema. */ | ||
| private static final String DEFAULT_FIELD_CONTENT_TYPE = "text/plain"; //$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 = { | ||
|
poliakov-alex marked this conversation as resolved.
|
||
| 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())); | ||
| } | ||
|
|
||
| boolean hasCookieHeader = false; | ||
| for (String[] header : headers) { | ||
| if (emitsForm && HTTPConstants.HEADER_CONTENT_TYPE.equalsIgnoreCase(header[0])) { | ||
| continue; | ||
| } | ||
| if (HTTPConstants.HEADER_COOKIE.equalsIgnoreCase(header[0])) { | ||
| hasCookieHeader = true; | ||
| } | ||
| 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; it is kept | ||
| // alongside the explicit header rather than replacing it, because curl otherwise | ||
| // negotiates its own build-dependent encoding list the test plan never asked for. | ||
| if (acceptsEncoding) { | ||
| sb.append(NEWLINE).append("--compressed"); //$NON-NLS-1$ | ||
| } | ||
|
|
||
| // Cookies normally arrive through getCookies(), but AjpSampler can also leave a | ||
| // Cookie header in the list; curl lets the header win and silently drops -b, so | ||
| // only add -b when no Cookie header was emitted. | ||
| String cookies = sampleResult.getCookies(); | ||
| if (!hasCookieHeader && StringUtilities.isNotEmpty(cookies)) { | ||
| sb.append(NEWLINE).append("-b ").append(quote(cookies)); //$NON-NLS-1$ | ||
| } | ||
|
Comment on lines
+180
to
+183
Collaborator
There was a problem hiding this comment. A correction to my earlier note, and a narrow case it leaves open. I said the curl lets the explicit header win, so |
||
|
|
||
| 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); | ||
| // A quoted boundary is unquoted above; but if the header boundary and the body | ||
| // disagree, MultipartUrlConfig would treat the whole body as one field and emit | ||
| // garbage, so require the delimiter to be present and fall back to the note otherwise. | ||
| if (StringUtilities.isBlank(boundary) || !body.contains("--" + boundary)) { //$NON-NLS-1$ | ||
| 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(); | ||
| } | ||
|
Comment on lines
+210
to
+223
Collaborator
There was a problem hiding this comment. A quoted or mismatched boundary yields a corrupted
Rendered on this branch: The same thing happens whenever the header boundary and the body disagree: Quoting is legal per RFC 2046, and both cases are reachable: when Two small guards fix it: strip surrounding quotes in While you are in |
||
| List<String[]> parts = new ArrayList<>(); | ||
| for (JMeterProperty property : multipart.getArguments()) { | ||
| parts.add(formField((HTTPArgument) property.getObjectValue())); | ||
| } | ||
|
Comment on lines
+225
to
+227
Collaborator
There was a problem hiding this comment. The per-part
A field explicitly marked Two smaller things in the same loop: the original interleaving of fields and files is lost (all |
||
| for (HTTPFileArg file : multipart.getHTTPFileArgs().asArray()) { | ||
| parts.add(fileField(file)); | ||
| } | ||
|
Comment on lines
+228
to
+230
Collaborator
There was a problem hiding this comment. A file name containing The spec is concatenated unquoted, so a part named $ 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 — |
||
| return parts; | ||
| } | ||
|
|
||
| /** | ||
| * A multipart text field. {@code --form-string} keeps the value verbatim (curl would | ||
| * otherwise read a leading {@code @} or {@code <} as a file reference), but it cannot | ||
| * carry a per-part content type; {@code -F} can, so it is used when the value is safe | ||
| * for it (no {@code @}/{@code <} prefix and no {@code ;} that curl would read as an | ||
| * option separator). | ||
| */ | ||
| private static String[] formField(HTTPArgument argument) { | ||
| String value = argument.getValue() == null ? "" : argument.getValue(); //$NON-NLS-1$ | ||
| String type = argument.getContentType(); | ||
| // HTTPArgument defaults content_type to text/plain, which is indistinguishable from | ||
| // a part that carried none; only a non-default type is worth reproducing. | ||
| boolean hasType = StringUtilities.isNotEmpty(type) && !DEFAULT_FIELD_CONTENT_TYPE.equalsIgnoreCase(type); | ||
| boolean safeForF = hasType | ||
| && !value.startsWith("@") && !value.startsWith("<") && value.indexOf(';') < 0; //$NON-NLS-1$ //$NON-NLS-2$ | ||
| if (safeForF) { | ||
| return new String[] { "-F", argument.getName() + "=" + value + ";type=" + type }; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ | ||
| } | ||
| return new String[] { "--form-string", argument.getName() + "=" + value }; //$NON-NLS-1$ //$NON-NLS-2$ | ||
| } | ||
|
|
||
| /** | ||
| * A multipart file part. The file name is double-quoted inside the spec so that a name | ||
| * containing {@code ;} or {@code ,} is not parsed by curl as an option separator; the | ||
| * bytes are not kept by JMeter, so the name is a placeholder to edit to a real path. | ||
| */ | ||
| private static String[] fileField(HTTPFileArg file) { | ||
| StringBuilder spec = new StringBuilder(); | ||
| spec.append(file.getParamName()).append("=@\"").append(file.getPath()).append('"'); //$NON-NLS-1$ | ||
| if (StringUtilities.isNotEmpty(file.getMimeType())) { | ||
| spec.append(";type=").append(file.getMimeType()); //$NON-NLS-1$ | ||
| } | ||
| return new String[] { "-F", spec.toString() }; //$NON-NLS-1$ | ||
| } | ||
|
|
||
| /** | ||
| * Extract the {@code boundary} value of a multipart content type, unquoted. | ||
| * | ||
| * @param contentType a {@code Content-Type} header value | ||
| * @return the boundary, or {@code null} if it is absent | ||
| */ | ||
| public static String extractBoundary(String contentType) { | ||
| int index = contentType.toLowerCase(Locale.ROOT).indexOf(BOUNDARY); | ||
| if (index < 0) { | ||
| return null; | ||
| } | ||
| String boundary = contentType.substring(index + BOUNDARY.length()); | ||
| int semicolon = boundary.indexOf(';'); | ||
| if (semicolon >= 0) { | ||
| boundary = boundary.substring(0, semicolon); | ||
| } | ||
| boundary = boundary.trim(); | ||
| // RFC 2046 allows the boundary to be quoted; MultipartUrlConfig expects it unquoted. | ||
| if (boundary.length() >= 2 && boundary.charAt(0) == '"' | ||
| && boundary.charAt(boundary.length() - 1) == '"') { | ||
| boundary = boundary.substring(1, boundary.length() - 1); | ||
| } | ||
| return boundary; | ||
| } | ||
|
|
||
| private static boolean containsPlaceholder(String body) { | ||
| for (String placeholder : BODY_PLACEHOLDERS) { | ||
| if (body.contains(placeholder)) { | ||
| return true; | ||
| } | ||
| } | ||
| return false; | ||
| } | ||
|
|
||
| /** | ||
| * Wrap a value in single quotes for safe use in a POSIX shell, escaping any | ||
| * embedded single quotes using the {@code '\''} idiom. | ||
| * | ||
| * @param value the value to quote | ||
| * @return the shell-quoted value | ||
| */ | ||
| private static String quote(String value) { | ||
| return "'" + value.replace("'", "'\\''") + "'"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ | ||
| } | ||
|
|
||
| } | ||
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
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:
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